מצלמה ותצוגה

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

זום

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

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

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

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

כדי ליצור אנימציה של ההעברה, משתמשים בשיטה 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];
      

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

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

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

הגדרת גבולות

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

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 כ-n.

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