מצלמה ותצוגה

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

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

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

התצוגה של המפה

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

מיקום המצלמה

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

יעד (מיקום)

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

כיוון

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

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

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

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

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

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

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

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

Zoom

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

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

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

• ‫1: World
• ‫5: מסת יבשה/יבשת
• ‫10: עיר
• ‫15: רחובות
• ‫20: בניינים

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

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

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

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

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

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

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.

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

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

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

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

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

במקום זאת, משתמשים בשיטה GMSMapView moveCamera: כדי להעביר את המצלמה למיקום החדש.

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

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

// 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, אפשר לציין בנפרד את הריווח הפנימי לכל צד של התיבה התוחמת.

שימוש ב-GMSMapView כדי לשנות מאפיין יחיד

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

לדוגמה, משתמשים בשיטה toViewingAngle: כדי להנפיש שינוי בהטיית המצלמה.

mapView.animate(toViewingAngle: 45)
      

[mapView animateToViewingAngle:45];
      

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

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

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

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

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

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

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

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

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

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

// 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.

mapView.animate(toBearing: 0)
      

[mapView animateToBearing:0];
      

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

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

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

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

mapView.animate(toViewingAngle: 45)
      

[mapView animateToViewingAngle:45];
      

הגדרת הזום

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

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

mapView.animate(toZoom: 12)
      

[mapView animateToZoom:12];
      

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

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

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

הגדרת גבולות

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

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

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

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

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
      

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;
      

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

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

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

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

mapView.cameraTargetBounds = bounds
      

mapView.cameraTargetBounds = bounds;
      

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

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

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

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

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

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

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)
      

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

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

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

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

// 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)
      

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