מצלמה ותצוגה

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

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

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

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

תצוגת המפה

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

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

מיקום המצלמה

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

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

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

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

כיוון (אוריינטציה)

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

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

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

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

ההטיה מגדירה את מיקום המצלמה בקשת ישירות מעל מיקום מרכז המפה, ונמדדת במעלות מהנאדיר (הכיוון שמצביע ישירות מתחת למצלמה). הערך 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. לאחר מכן מעבירים את האפשרויות ל-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 init. במקרה כזה, מיקום המצלמה מתחיל במיקום ברירת המחדל ואפשר לשנות אותו אחרי היצירה.

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

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

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

שימוש ב-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 שבו מגדירים את הזום לערך שגדול ב-1 מהזום הנוכחי.

אפשר גם ליצור אובייקט GMSCameraUpdate באמצעות ה-method‏ 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:

משנה את המצלמה כדי למרכז את הגבולות שצוינו במסך ברמת הזום הגבוהה ביותר האפשרית. הפונקציה מחילה ריפוד (padding) כברירת מחדל על גבולות של 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, או באמצעות השיטה 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];
      

בדוגמה הבאה נעשה שימוש ב-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];
      

קבעו גבולות

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

1. מחשבים את GMSCoordinateBounds שרוצים שיוצג במסך.
2. משתמשים ב-method‏ 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 ל-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 options = GMSMapViewOptions()
options.camera = camera
let mapView = GMSMapView(options: options)
mapView.setMinZoom(10, maxZoom: 15)
      

Objective-C

GMSCameraPosition *camera = [GMSCameraPosition cameraWithLatitude:41.887
                                                       longitude:-87.622
                                                             zoom:12];
GMSMapViewOptions *options = [[GMSMapViewOptions alloc] init];
options.camera = camera;
GMSMapView *mapView = [[GMSMapView alloc] initWithOptions:options];
[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 options2 = GMSMapViewOptions()
options2.camera = camera2
let mapView2 = GMSMapView(options: options2)

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

Objective-C

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