מצלמה ותצוגה

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

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

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

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

תצוגת המפה

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

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

מיקום המצלמה

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Zoom

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

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

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

• 1: עולם
• 5: ארץ/יבשת
• 10: עיר
• 15: רחובות
• 20: בניינים

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

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

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

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

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

קביעת המיקום הראשוני של המצלמה

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

כדי לקבוע את מיקום המצלמה הראשוני, צריך ליצור אובייקט GMSMapViewOptions ולהגדיר במאפיין camera את הערך GMSCameraPosition. לאחר מכן מעבירים את האפשרויות לבניית הנוחות של 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 באמצעות ה-method 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 GMSMapView animateWithCameraUpdate:.

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];
      

אפשר להשתמש בשיטה 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 ואז מפעילים את השיטה fitBounds:, הטרנספורמציות של המצלמה מביאות בחשבון את 64 הנקודות של המרווח הפנימי שמוגדר כברירת מחדל, בנוסף ל-100 הנקודות של המרווח הפנימי בהתאמה אישית.

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

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

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

לדוגמה, אפשר להשתמש בשיטה 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. לחלופין, אפשר להשתמש בשיטה 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, או באמצעות השיטה animateToBearing: של GMSMapView.

Swift

mapView.animate(toBearing: 0)
      

Objective-C

[mapView animateToBearing:0];
      

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

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

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

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

Swift

mapView.animate(toViewingAngle: 45)
      

Objective-C

[mapView animateToViewingAngle:45];
      

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

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

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

Swift

mapView.animate(toZoom: 12)
      

Objective-C

[mapView animateToZoom:12];
      

בדוגמה הבאה משתמשים בשיטה 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;
      

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

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

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

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

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

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];
      

צריך להגדיר את טווח הזום בשיטה 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];