מצלמה ותצוגה

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

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

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

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

תצוגת המפה

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

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

מיקום המצלמה

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

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

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

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

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

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

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

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

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

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

כדי להוסיף אנימציה לשינוי ולהזיז את המפה למיקום החדש, אפשר להשתמש ה-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 או באמצעות ה-method animateToBearing: של GMSMapView.

Swift

mapView.animate(toBearing: 0)
      

Objective-C

[mapView animateToBearing:0];
      

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

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

זווית הצפייה יכולה לנוע בין 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 בנוסף לערכות ה-inset שמפורטות כאן.

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

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

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

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

Swift

mapView.cameraTargetBounds = bounds
      

Objective-C

mapView.cameraTargetBounds = bounds;
      

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

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

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

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

הקבועים הגלובליים 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];