מצלמה ותצוגה

בחירת פלטפורמה: Android iOS JavaScript

באמצעות SDK של מפות ל-iOS, ניתן לשנות את נקודת המבט של המשתמש על המפה על ידי שינוי המצלמה של המפה.

ב-SDK של מפות Google ל-iOS, המשתמשים יכולים להטות ולסובב את המפות כדי להתאים אותן לכיוון המיקום המתאים לפי ההקשר. בכל רמת זום, המשתמשים יכולים להזיז את המפה או לשנות את הפרספקטיבה שלה בזמן אחזור קצר מאוד.

השינויים במצלמה לא ישנו סמנים, קווים פוליגוניים או פריטי גרפיקה אחרים שהוספתם, למרות שכדאי לשנות את התוספות האלה כך שיתאימו טוב יותר לתצוגה החדשה.

תצוגת המפה

ה-SDK של מפות Google ל-iOS משתמש בהיטל של Mercator כדי לייצג את פני השטח של העולם (ספרה) במסך המכשיר (מישור שטוח).

הערה: היטל של Mercator הוא גובה מוגבל לאורך (צפון/דרום), אבל עם קו רוחב אינסופי (מזרח/מערב). המשמעות של מאפיין זה היא שתצוגת המפה חוזרת על עצמה מזרח ומערב ללא הגבלה. בכיוון הצפון והדרום, התמונה של מפת הבסיס נחתכת באמצעות היטל ה- Mercator בערך של +/- 85 מעלות כדי ליצור ריבוע של צורת המפה שמתקבלת, מה שמאפשר לוגיקה קלה יותר לבחירת משבצות.

מיקום המצלמה

המודל של תצוגת המפה הוא מצלמה שמביטה למטה במישור שטוח. מיקום המצלמה (וכתוצאה מכך עיבוד המפה) נקבע לפי המאפיינים הבאים: יעד (מיקום של קו רוחב/קו אורך), נושא, הטיה ומרחק התצוגה.

טירגוט (מיקום)

יעד המצלמה הוא המיקום של מרכז המפה, שנקבע כקואורדינטות של קו אורך וקו רוחב.

קו הרוחב יכול להיות בין -85 לבין 85 מעלות, כולל. ערכים מעל או מתחת לטווח הזה יוצמדו לערך הקרוב ביותר בטווח הזה. לדוגמה, ציון קו רוחב של 100 תגדיר את הערך כ-85. קו האורך נע בין -180 ל-180 מעלות, כולל. ערכים מעל או מתחת לטווח הזה יגלשו כך שהם יהיו בטווח (-180, 180). לדוגמה, הערכים 480, 840 ו-1,200 יעטפו ב-120 מעלות.

כיוון (כיוון)

כיוון המצלמה מציין את כיוון המצפן, שנמדד במעלות מהצפון האמיתי, בהתאם לקצה העליון של המפה. אם משרטטים קו אנכי ממרכז המפה אל הקצה העליון של המפה, הכיוון תואם לכותרת של המצלמה (במדידה במעלות) ביחס לצפון האמיתי.

אם הערך של 0 הוא 0, החלק העליון של המפה מפנה לכיוון הצפון האמיתי. ערך כיוון 90 מציין את החלק העליון של נקודות המפה עקב מזרח (90 מעלות במצפן). הערך 180 מציין את החלק העליון של הנקודות במפה עם דרום.

ה-API של מפות Google מאפשר לכם לשנות את כיוון הניווט של המפה. לדוגמה, אדם שנוהג במכונית בדרך כלל מסובב את מפת הדרכים כדי ליישר אותה עם כיוון הנסיעה, ואילו מטיילים שמשתמשים במפה ובמצפן מכוונים בדרך כלל את המפה כך שקו אנכי פונה צפונה.

הטיה (זווית צפייה)

ההטיה מגדירה את מיקום המצלמה על קשת ישירות מעל המיקום המרכזי של המפה, שנמדד במעלות מהנאדיר (הכיוון שפונה ישירות מתחת למצלמה). הערך 0 תואם למצלמה שמופנית ישירות למטה. ערכים שגדולים מ-0 מתאימים למצלמה שפונה לכיוון האופק לפי מספר המעלות שצוין. כשמשנים את זווית הצפייה, המפה מופיעה פרספקטיבה, כאשר חלקים רחוקים נראים קטנים יותר, ותכונות קרובות מופיעות גדולות יותר. האיורים הבאים ממחישים זאת.

בתמונות שלמטה, זווית הצפייה היא 0 מעלות. התמונה הראשונה מציגה סכימה; מיקום 1 הוא מיקום המצלמה, ומיקום 2 הוא המיקום הנוכחי במפה. המפה שמתקבלת מוצגת מתחתיה.

המפה שמוצגת עם זווית הצפייה שמוגדרת כברירת המחדל של המצלמה.

זווית הצפייה שמוגדרת כברירת המחדל של המצלמה.

בתמונות שלמטה, זווית הצפייה היא 45 מעלות. שימו לב שהמצלמה נעה לחצי לאורך קשת בין מלמעלה ישרה (0 מעלות) לבין הקרקע (90 מעלות), למיקום 3. המצלמה עדיין מופנית לנקודת המרכז של המפה, אבל עכשיו אפשר לראות את האזור שמיוצג על ידי הקו במיקום 4.

המפה מוצגת בזווית צפייה של 45 מעלות.

זווית צפייה של 45 מעלות של המצלמה.

המפה בצילום המסך הזה עדיין ממורכזת באותה נקודה כמו במפה המקורית, אבל מופיעות תכונות נוספות בחלק העליון של המפה. ככל שמגדילים את הזווית מעבר ל-45 מעלות, הרכיבים בין המצלמה למיקום המפה גדולים יותר באופן יחסי, בעוד שהרכיבים שנמצאים מעבר למיקום המפה קטנים יותר באופן יחסי, וכתוצאה מכך נוצר אפקט תלת-ממדי.

זום

רמת הזום של המצלמה קובעת את קנה המידה של המפה. עם זום גדול יותר אפשר לראות יותר פרטים על המסך, וברמות זום קטנות יותר ניתן לראות יותר מהעולם כולו על המסך. ברמת זום 0, גודל המפה כך שהרוחב של כל העולם הוא כ-256 נקודות.

הגדלת רמת הזום ב-1 מכפילה את רוחב העולם במסך. לכן, ברמת הזום N, רוחב העולם הוא בערך 256 * 2^N נקודות. לדוגמה, ברמת זום 2, העולם כולו הוא ברוחב של כ-1,024 נקודות.

רמת הזום לא חייבת להיות מספר שלם. טווח רמות הזום המותר במפה תלוי במספר גורמים, כולל היעד, סוג המפה וגודל המסך. כל מספר שנמצא מחוץ לטווח יומר לערך התקף הבא הקרוב ביותר, שיכול להיות רמת הזום המינימלית או רמת הזום המקסימלית. הרשימה הבאה מציגה את רמת הפירוט המשוערת שאפשר לצפות לראות בכל רמת זום:

• 1: עולם
• 5: פני השטח/יבשת
• 10: עיר
• 15: רחובות
• 20: מבנים

הערה: בגלל גודל המסך והצפיפות, יכול להיות שחלק מהמכשירים לא תומכים ברמות הזום הנמוכות ביותר. השתמשו במאפיין minZoom של GMSMapView כדי לקבל את רמת הזום המינימלית האפשרית במפה.

בתמונות הבאות מוצג מראה חזותי של רמות זום שונות:

מפה ברמת זום 5.

מפה ברמת זום 15.

מפה ברמת זום 20.

הגדרת המיקום הראשוני של המצלמה

אפשר להגדיר את המיקום הראשוני של המצלמה באמצעות האובייקט GMSCameraPosition, שמאפשר להגדיר את קווי האורך והרוחב של היעד, יחד עם נשיאה, הטיה ושינוי מרחק התצוגה.

כדי להגדיר את המיקום הראשוני של המצלמה, יוצרים אובייקט GMSMapViewOptions ומגדירים את המאפיין camera ל-GMSCameraPosition. לאחר מכן מעבירים את האפשרויות ל-constructor של הנוחות GMSMapView.

Swift

let options = GMSMapViewOptions()
options.camera = GMSCameraPosition.camera(withLatitude: -33.8683, longitude: 151.2086, zoom: 16)
let mapView = GMSMapView(options:options)

Objective-C

GMSMapViewOptions *options = [[GMSMapViewOptions alloc] init];
options.camera = [GMSCameraPosition cameraWithLatitude:-33.8683
                                                        longitude:151.2086
                                                             zoom:16];
GMSMapView *mapView = [[GMSMapView alloc] initWithOptions:options];

אפשר גם ליצור את האובייקט GMSMapView באמצעות שיטת האתחול UIView שמוגדרת כברירת מחדל. במקרה הזה, המיקום של המצלמה מתחיל במיקום ברירת המחדל ואתם משנים אותו אחרי שיוצרים את המיקום.

Swift

let options = GMSMapViewOptions()
options.frame = self.view.bounds
let mapView = GMSMapView(options:options)

Objective-C

GMSMapViewOptions *options = [[GMSMapViewOptions alloc] init];
options.frame = self.view.bounds;
GMSMapView *mapView = [[GMSMapView alloc] initWithOptions:options];

איך משנים את מיקום המצלמה

אפשר לשנות באופן פרוגרמטי את מיקום המצלמה כדי להגדיר את המיקום, הנושא, ההטיה והזום. ב-GMSMapView יש כמה שיטות לשינוי מיקום המצלמה, אבל בדרך כלל משתמשים ב-GMSCameraPosition או ב-GMSCameraUpdate:

• GMSCameraPosition מכיל את המאפיינים והשיטות שבהם משתמשים כדי לשנות כל פרמטר של מיקום מצלמה: טירגוט, כיוון, הטיה וזום.

• GMSCameraUpdate מאפשר לשנות את היעד, הכיוון, ההטיה והמרחק מהתצוגה, וכולל גם שיטות נוחות נוספות לתמיכה בגלילה, בשינוי מרחק התצוגה, במרכז המצלמה בגבולות שהוגדרו מראש ועוד.

כשמזיזים את המצלמה, אפשר לבחור "להעביר" את המצלמה למיקום החדש, כלומר אין אנימציה, או להנפיש את התנועה. לדוגמה, אם מוסיפים אנימציה לשינוי במיקום היעד של המצלמה, האנימציה תעבור מהמיקום הקודם למיקום החדש.

האנימציה מבצעת אינטרפולציה בין מאפייני המצלמה הנוכחיים לבין מאפייני המצלמה החדשים. אפשר לקבוע את משך האנימציה באמצעות אנימציה ליבה.

שימוש בחשבון GMSCameraPosition

כדי להחליף את המצלמה באמצעות GMSCameraPosition, יוצרים אובייקט חדש או מעתיקים אובייקט קיים ומגדירים אותו על האובייקט GMSMapView. משתמשים באובייקט GMSCameraPosition כדי להצמיד את המצלמה למיקום החדש, עם או בלי אנימציה.

אפשר להשתמש באובייקט GMSCameraPosition כדי להגדיר את כל מאפייני המצלמה, כמו קו רוחב, קו אורך, זום, זווית וזווית צפייה. לאחר מכן משתמשים באובייקט הזה כדי להגדיר את המאפיין camera של GMSMapView.

Swift

let fancy = GMSCameraPosition(
  latitude: -33,
  longitude: 151,
  zoom: 6,
  bearing: 270,
  viewingAngle: 45
)
mapView.camera = fancy
      

Objective-C

GMSCameraPosition *fancy = [GMSCameraPosition cameraWithLatitude:-33.8683
                                                       longitude:151.2086
                                                            zoom:6
                                                         bearing:30
                                                    viewingAngle:45];
[mapView setCamera:fancy];
      

צריך להשמיט כל מאפיין GMSCameraPosition שרוצים להגדיר לערך ברירת המחדל שלו.

כדי להוסיף אנימציה להעברה, צריך להשתמש ב-method animateToCameraPosition: במקום להגדיר את המאפיין camera.

שימוש בחשבון GMSCameraUpdate

GMSCameraUpdate מאפשרת לעדכן את מיקום המצלמה ולבחור אם לצלם או להוסיף אנימציה למיקום החדש. היתרון של GMSCameraUpdate הוא הנוחות. אפשר להשתמש ב-GMSCameraPosition כדי לבצע את אותן המשימות כמו ב-GMSCameraUpdate, אבל ב-GMSCameraUpdate יש עוד שיטות שעוזרות לתמרן את המצלמה בקלות.

לדוגמה, כדי להגדיל את רמת הזום הנוכחית באמצעות GMSCameraPosition, קודם צריך לקבוע את רמת הזום הנוכחית ואז ליצור אובייקט GMSCameraPosition שבו מגדירים את מרחק התצוגה לערך שגדול יותר מהמרחק הנוכחי.

לחלופין, אפשר ליצור אובייקט GMSCameraUpdate באמצעות השיטה zoomIn:. לאחר מכן מעדכנים את המצלמה על ידי העברת האובייקט GMSCameraUpdate ל-method animateWithCameraUpdate: GMSMapView.

Swift

// Zoom in one zoom level
let zoomCamera = GMSCameraUpdate.zoomIn()
mapView.animate(with: zoomCamera)
      

Objective-C

// Zoom in one zoom level
GMSCameraUpdate *zoomCamera = [GMSCameraUpdate zoomIn];
[mapView animateWithCameraUpdate:zoomCamera];
      

אפשר להשתמש ב-method GMSMapView moveCamera: כדי להצמיד את המצלמה למיקום החדש.

בדוגמה הבאה משתמשים ב-GMSCameraUpdate כדי ליצור אנימציה של הזזת המצלמה כדי למרכז אותה בוונקובר.

Swift

// Center the camera on Vancouver, Canada
let vancouver = CLLocationCoordinate2D(latitude: 49.26, longitude: -123.11)
let vancouverCam = GMSCameraUpdate.setTarget(vancouver)
mapView.animate(with: vancouverCam)
      

Objective-C

// Center the camera on Vancouver, Canada
CLLocationCoordinate2D vancouver = CLLocationCoordinate2DMake(49.26, -123.11);
GMSCameraUpdate *vancouverCam = [GMSCameraUpdate setTarget:vancouver];
[mapView animateWithCameraUpdate:vancouverCam];
      

בניית אובייקט GMSCameraUpdate

בונים אובייקט GMSCameraUpdate באמצעות אחת מהשיטות שלו.

zoomIn: וגם zoomOut:

שינוי רמת הזום הנוכחית ב-1.0, תוך שמירה על כל שאר המאפיינים ללא שינוי.

zoomTo:

שינוי רמת הזום לערך הנתון, בלי לשנות את כל שאר המאפיינים.

zoomBy:

הגדלה (או הקטנה, אם הערך שלילי) של רמת הזום בערך הנתון.

zoomBy:atPoint:

מגדילה (או מקטינה, אם הערך שלילי) ברמת הזום בערך הנתון, תוך שמירה על מיקום הנקודה שצוינה במסך.

setTarget:

משנה את קווי האורך והרוחב של המצלמה, תוך שימור כל שאר המאפיינים.

setTarget:zoom:

משנה את קו הרוחב, קו האורך והמרחק של המצלמה, תוך שימור כל שאר המאפיינים.

setCamera:

מגדיר GMSCameraPosition חדש.

scrollByX:Y:

שינוי קו הרוחב וקו האורך של המצלמה כדי להזיז את המפה לפי מספר הנקודות שצוין. ערך x חיובי גורם למצלמה זזה ימינה, כך שנראה שהמפה זזה שמאלה. ערך y חיובי גורם למצלמה לנוע למטה, כך שנראה שהמפה זזה למעלה. הגלילה מתבצעת ביחס לנשיאה הנוכחית של המצלמה. לדוגמה, אם המצלמה יש כיוון של 90 מעלות, הערך המזרחי הוא 'למעלה'.

fitBounds:

ממירה את המצלמה למרכז את הגבולות שצוינו במסך ברמת הזום הגבוהה ביותר האפשרית. המערכת מחילה מרווח פנימי שמוגדר כברירת מחדל לגבולות של 64 נקודות.

fitBounds:withPadding:

ממירה את המצלמה למרכז את הגבולות שצוינו במסך ברמת הזום הגבוהה ביותר האפשרית. משתמשים בשיטה הזו כדי לציין את אותו המרווח הפנימי, בנקודות, לכל הצדדים של התיבה התוחמת.

fitBounds:withEdgeInsets:

ממירה את המצלמה למרכז את הגבולות שצוינו במסך ברמת הזום הגבוהה ביותר האפשרית. באמצעות UIEdgeInsets, מציינים מרווח פנימי לכל צד של התיבה התוחמת בנפרד.

הערה: השיטות fitBounds: מביאות בחשבון גם את המרווח הפנימי שהגדרתם במפה וגם את המרווח הפנימי שצוין כשאתם מתאימים לגבולות. לדוגמה, אם מציינים 100 נקודות מרווח פנימי מסביב ל-GMSMapView ואז קוראים ל-method fitBounds:, הטרנספורמציות של המצלמה מביאות בחשבון את 64 הנקודות של המרווח הפנימי שמוגדר כברירת מחדל, בנוסף ל-100 הנקודות של המרווח הפנימי המותאם אישית.

יש להשתמש ב-GMSMapView כדי לשנות נכס יחיד

GMSMapView מספק כמה שיטות שמאפשרות להזיז את המצלמה ללא שימוש באובייקט GMSCameraPosition או באובייקט GMSCameraUpdate. באמצעות השיטות האלה, כמו animateToLocation: או animateToZoom:, אפשר להנפיש שינוי במאפיין מצלמה אחד.

הערה: ב-GMSMapView יש שיטות לשינוי נכס אחד, אבל בדרך כלל משתמשים ב-GMSCameraPosition או ב-GMSCameraUpdate כדי להזיז את המצלמה, גם כשרוצים לשנות כמה מאפיינים של מצלמה.

לדוגמה, תוכלו להשתמש ב-method toViewingAngle: כדי להוסיף אנימציה לשינוי בהטיה של המצלמה.

Swift

mapView.animate(toViewingAngle: 45)
      

Objective-C

[mapView animateToViewingAngle:45];
      

הגדרת יעד (מיקום)

המיקום קובע את מרכז המפה. המיקומים מצוינים באמצעות קו רוחב וקו אורך, והם מיוצגים באופן פרוגרמטי על ידי CLLocationCoordinate2D שנוצר באמצעות CLLocationCoordinate2DMake.

אפשר להשתמש בGMSCameraPosition כדי לשנות את המיקום. בדוגמה הזו, המפה נצמדת למיקום החדש.

Swift

let target = CLLocationCoordinate2D(latitude: -33.868, longitude: 151.208)
mapView.camera = GMSCameraPosition(target: target, zoom: 6)
      

Objective-C

CLLocationCoordinate2D target =
    CLLocationCoordinate2DMake(-33.868, 151.208);
mapView.camera = [GMSCameraPosition cameraWithTarget:target zoom:6];
      

כדי להוסיף אנימציה לשינוי ולהזיז את המפה למיקום החדש, אפשר להשתמש ב-method animateToCameraPosition: במקום להגדיר את המאפיין camera. לחלופין, אפשר להשתמש ב-method animateToLocation: ב-GMSMapView.

Swift

mapView.animate(toLocation: CLLocationCoordinate2D(latitude: -33.868, longitude: 151.208))
      

Objective-C

[mapView animateToLocation:CLLocationCoordinate2DMake(-33.868, 151.208)];
      

אפשר גם ליצור אובייקט GMSCameraUpdate כדי להזיז את המצלמה. משתמשים בשיטה המובנית scrollByX:Y: כדי לציין את מספר הנקודות לגלילה במצלמה במסלול X ו-Y. בדוגמה הזו, גוללים במצלמה 200 נקודות ימינה ו-100 נקודות למטה:

Swift

// Move the camera 200 points to the right, and 100 points downwards
let downwards = GMSCameraUpdate.scrollBy(x: 200, y: 100)
mapView.animate(with: downwards)
      

Objective-C

// Move the camera 200 points to the right, and 100 points downwards
GMSCameraUpdate *downwards = [GMSCameraUpdate scrollByX:200.0 Y:100.0];
[mapView animateWithCameraUpdate:downwards];
      

הגדרת כיוון (כיוון)

הכיוון הוא כיוון המצפן, שנמדד במעלות מהצפון האמיתי, בקצה העליון של המפה. לדוגמה, כיוון של 90 מעלות, התוצאה תהיה מפה שבה הקצה העליון מצביע על מזרח.

מגדירים את הכיוון באופן פרוגרמטי באמצעות GMSCameraPosition או GMSCameraUpdate, או באמצעות ה-method animateToBearing: של GMSMapView.

Swift

mapView.animate(toBearing: 0)
      

Objective-C

[mapView animateToBearing:0];
      

הגדרת הטיה (זווית צפייה)

זווית הצפייה היא המיקום של המצלמה על קשת בין המיקום המרכזי של המפה לבין פני השטח של כדור הארץ, שנמדדת במעלות מהנאדיר (הכיוון שפונה ישירות מתחת למצלמה). כשמשנים את זווית הצפייה, המפה מופיעה מבחינת הפרספקטיבה, כאשר התכונות בין המצלמה למיקום המפה מופיעות גדולות יותר באופן פרופורציונלי, והתכונות שמעבר למיקום המפה קטנות באופן פרופורציונלי, כך שמדובר באפקט תלת-ממדי.

זווית הצפייה יכולה לנוע בין 0 (לכיוון ישר למטה במפה) ועד למקסימום תלוי ברמת הזום. לזום ברמה 16 ומעלה, הזווית המקסימלית היא 65 מעלות. ברמת זום מ-10 ומטה, הזווית המקסימלית היא 30 מעלות.

מגדירים את זווית הצפייה באופן פרוגרמטי באמצעות GMSCameraPosition או GMSCameraUpdate, או באמצעות ה-method animateToViewingAngle: של GMSMapView.

Swift

mapView.animate(toViewingAngle: 45)
      

Objective-C

[mapView animateToViewingAngle:45];
      

הגדרת מרחק התצוגה

רמת הזום של המצלמה קובעת את קנה המידה של המפה. ברמות זום גדולות יותר אפשר לראות יותר פרטים על המסך, וברמות זום קטנות יותר אפשר לראות יותר מהעולם.

מגדירים את מרחק התצוגה באופן פרוגרמטי באמצעות GMSCameraPosition או GMSCameraUpdate, או באמצעות ה-method animateToZoom: של GMSMapView.

Swift

mapView.animate(toZoom: 12)
      

Objective-C

[mapView animateToZoom:12];
      

הדוגמה הבאה משתמשת ב-method zoomIn: כדי ליצור אובייקט GMSCameraUpdate כדי להנפיש זום ברמה אחת מהרמה הנוכחית.

Swift

// Zoom in one zoom level
let zoomCamera = GMSCameraUpdate.zoomIn()
mapView.animate(with: zoomCamera)
      

Objective-C

// Zoom in one zoom level
GMSCameraUpdate *zoomCamera = [GMSCameraUpdate zoomIn];
[mapView animateWithCameraUpdate:zoomCamera];
      

מציבים גבולות

כדי להזיז את המצלמה כך שאזור עניין שלם יהיה גלוי ברמת הזום הגבוהה ביותר האפשרית, קבעו גבולות לתצוגת המצלמה. לדוגמה, אם רוצים להציג את כל תחנות הדלק בטווח של 5 ק"מ מהמיקום הנוכחי של המשתמש, מזיזים את המצלמה כך שכולן יהיו גלויות במסך:

1. מחשבים את ה-GMSCoordinateBounds שרוצים שיופיע במסך.
2. משתמשים בשיטה cameraForBounds:insets: של GMSMapView כדי להחזיר GMSCameraPosition חדש.

הגדרת הגבולות האלה מבטיחה שהשדה GMSCoordinateBounds הנתון יתאים בדיוק לגודל המפה הנוכחית. שימו לב שהשיטה הזו מגדירה את ההטיה והנשיאה של המפה ל-0.

הדוגמה הבאה ממחישה איך לשנות את המצלמה כך שהערים ונקובר וקלגרי יופיעו באותה תצוגה.

Swift

let vancouver = CLLocationCoordinate2D(latitude: 49.26, longitude: -123.11)
let calgary = CLLocationCoordinate2D(latitude: 51.05,longitude: -114.05)
let bounds = GMSCoordinateBounds(coordinate: vancouver, coordinate: calgary)
let camera = mapView.camera(for: bounds, insets: UIEdgeInsets())!
mapView.camera = camera
      

Objective-C

CLLocationCoordinate2D vancouver = CLLocationCoordinate2DMake(49.26, -123.11);
CLLocationCoordinate2D calgary = CLLocationCoordinate2DMake(51.05, -114.05);
GMSCoordinateBounds *bounds =
    [[GMSCoordinateBounds alloc] initWithCoordinate:vancouver coordinate:calgary];
GMSCameraPosition *camera = [mapView cameraForBounds:bounds insets:UIEdgeInsetsZero];
mapView.camera = camera;
      

הערה: ה-method cameraForBounds:insets: מתייחסת למרווח הפנימי שמוגדר ב-GMSMapView בנוסף לערכי הפנימיים המפורטים כאן.

הגבלת התנועה האופקית של המשתמש לאזור נתון

התרחישים האלה מגדירים את גבולות המפה, אבל המשתמש יכול לגלול או להזיז את המפה אל מחוץ לגבולות האלה. במקום זאת, כדאי להגביל את גבולות המרכז של הקואורדינטות של נקודת המוקד במפה (יעד המצלמה), כך שהמשתמשים יוכלו לגלול ולהזיז רק בתוך הגבולות האלה.

לדוגמה, ייתכן שאפליקציית קמעונאות למרכז קניות או שדה תעופה רוצה להגביל את המפה לגבולות מסוימים, וכך לאפשר למשתמשים לגלול ולנוע בתוך הגבולות האלה.

כדי להגביל את התנועה האופקית לגבולות ספציפיים, צריך להגדיר את המאפיין cameraTargetBounds של GMSMapView לאובייקט GMSCoordinateBounds שמגדיר את הגבולות הנדרשים. כדי להסיר את ההגבלה מאוחר יותר, צריך להגדיר את הערך של cameraTargetBounds לערך nil.

Swift

mapView.cameraTargetBounds = bounds
      

Objective-C

mapView.cameraTargetBounds = bounds;
      

בתרשים הבא מתואר תרחיש שבו יעד המצלמה מוגבל לאזור שהוא מעט גדול יותר מאזור התצוגה. המשתמש יכול לגלול ולהזיז, בתנאי שיעד המצלמה נשאר בתוך האזור התחום. הצלב מייצג את יעד המצלמה:

המפה תמיד ממלאת את אזור התצוגה, גם אם התוצאה היא אזור התצוגה שמציג אזורים שמחוץ לגבולות המוגדרים. לדוגמה, אם ממקמים את יעד המצלמה בפינה של האזור תחום, האזור שמעבר לפינה גלוי באזור התצוגה, אבל המשתמשים לא יכולים לגלול עוד לתוך האזור. התרשים הבא ממחיש את התרחיש הזה. הצלב מייצג את יעד המצלמה:

בתרשים הבא, ליעד המצלמה יש גבולות מוגבלים מאוד, כך שיש למשתמש מעט מאוד הזדמנויות לגלול או להזיז את המפה. הצלב מייצג את יעד המצלמה:

הגדרת זום מינימלי או מקסימלי

הקבועים הגלובליים kGMSMinZoomLevel ו-kGMSMaxZoomLevel מגדירים את ערכי הזום המינימליים והמקסימליים. כברירת מחדל, המאפיינים minZoom ו-maxZoom של GMSMapView מוגדרים לקבועים האלה.

הערה: הטווח המותר של רמות הזום עשוי להיות תלוי גם בסוג המפה, בגודל המסך ובגורמים נוספים. כל מספר שנמצא מחוץ לטווח המותר מומר לערך התקף הבא הבא.

כדי להגביל את טווח רמות הזום הזמינות במפה, מגדירים רמת זום מינימלית ומקסימלית. הקוד הבא מגביל את רמת הזום ל-10 עד 15.

Swift

let camera = GMSCameraPosition(
  latitude: 41.887,
  longitude: -87.622,
  zoom: 12
)
let mapView = GMSMapView(frame: .zero, camera: camera)
mapView.setMinZoom(10, maxZoom: 15)
      

Objective-C

GMSCameraPosition *camera = [GMSCameraPosition cameraWithLatitude:41.887
                                                       longitude:-87.622
                                                             zoom:12];
GMSMapView *mapView = [GMSMapView mapWithFrame:CGRectZero
                                        camera:camera];
[mapView setMinZoom:10 maxZoom:15];
      

צריך להגדיר את טווח מרחק התצוגה באמצעות method setMinZoom:maxZoom:. עם זאת, אפשר לקרוא את הערכים הנוכחיים באמצעות המאפיינים minZoom ו-maxZoom. הגישה הזו מועילה כשמגבילים רק אחד מהערכים. הקוד הבא משנה רק את רמת הזום המינימלית.

Swift

mapView.setMinZoom(12, maxZoom: mapView.maxZoom)
      

Objective-C

[mapView setMinZoom:12 maxZoom:mapView.maxZoom];
      

אם אחרי שמעדכנים את הזום המינימלי והמקסימלי, רמת הזום של המצלמה מוגדרת לערך שמחוץ לטווח החדש, הזום הנוכחי מתעדכן באופן אוטומטי ומציג את הערך החוקי הקרוב ביותר. לדוגמה, בקוד הבא, מרחק התצוגה המקורי מוגדר כ-4. כשטווח הזום יוגדר ל-10-15 בהמשך, הזום הנוכחי מתעדכן ל-10.

Swift

// Sets the zoom level to 4.
let camera2 = GMSCameraPosition(
  latitude: 41.887,
  longitude: -87.622,
  zoom: 4
)
let mapView2 = GMSMapView(frame: .zero, camera: camera)

// The current zoom, 4, is outside of the range. The zoom will change to 10.
mapView.setMinZoom(10, maxZoom: 15)
      

Objective-C

// Sets the zoom level to 4.
GMSCameraPosition *camera2 = [GMSCameraPosition cameraWithLatitude:41.887
                                                         longitude:-87.622
                                                              zoom:4];
GMSMapView *mapView2 = [GMSMapView mapWithFrame:CGRectZero
                                         camera:camera];
// The current zoom, 4, is outside of the range. The zoom will change to 10.
[mapView setMinZoom:10 maxZoom:15];