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

דף זה תורגם על ידי Cloud Translation API.

צורות

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

ב-SDK של מפות Google ל-iOS יש דרכים שונות להוסיף צורות למפות. הצורות הבאות נתמכות:

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

ניתן לשנות את המראה של כל צורה בכמה דרכים.

קווים פוליגוניים

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

כדי ליצור קו פוליגוני, צריך לציין את הנתיב שלו על ידי יצירת אובייקט GMSMutablePath תואם עם שתי נקודות או יותר. כל CLLocationCoordinate2D מייצג נקודה על פני כדור הארץ. קטעי קו משורטטים בין נקודות בהתאם לסדר שבו הוספתם אותם לנתיב. אפשר להוסיף נקודות לנתיב באמצעות method addCoordinate: או addLatitude:longitude:.

Swift

let path = GMSMutablePath()
path.add(CLLocationCoordinate2D(latitude: -33.85, longitude: 151.20))
path.add(CLLocationCoordinate2D(latitude: -33.70, longitude: 151.40))
path.add(CLLocationCoordinate2D(latitude: -33.73, longitude: 151.41))
let polyline = GMSPolyline(path: path)

Objective-C

GMSMutablePath *path = [GMSMutablePath path];
[path addCoordinate:CLLocationCoordinate2DMake(-33.85, 151.20)];
[path addCoordinate:CLLocationCoordinate2DMake(-33.70, 151.40)];
[path addCoordinate:CLLocationCoordinate2DMake(-33.73, 151.41)];
GMSPolyline *polyline = [GMSPolyline polylineWithPath:path];

הוספת קו פוליגוני

יוצרים אובייקט GMSMutablePath.
אפשר להגדיר את הנקודות בנתיב באמצעות ה-methods addCoordinate: או addLatitude:longitude:.
יוצרים אובייקט GMSPolyline חדש באמצעות הנתיב כארגומנט.
מגדירים מאפיינים אחרים, כמו strokeWidth ו-strokeColor, לפי הצורך.
מגדירים את המאפיין map של GMSPolyline.
הקו הפוליגוני יופיע במפה.

קטע הקוד הבא מוסיף מלבן למפה:

Swift

let rectanglePath = GMSMutablePath()
rectanglePath.add(CLLocationCoordinate2D(latitude: 37.36, longitude: -122.0))
rectanglePath.add(CLLocationCoordinate2D(latitude: 37.45, longitude: -122.0))
rectanglePath.add(CLLocationCoordinate2D(latitude: 37.45, longitude: -122.2))
rectanglePath.add(CLLocationCoordinate2D(latitude: 37.36, longitude: -122.2))
rectanglePath.add(CLLocationCoordinate2D(latitude: 37.36, longitude: -122.0))

let rectangle = GMSPolyline(path: path)
rectangle.map = mapView

Objective-C

GMSMutablePath *rectanglePath = [GMSMutablePath path];
[rectanglePath addCoordinate:CLLocationCoordinate2DMake(37.36, -122.0)];
[rectanglePath addCoordinate:CLLocationCoordinate2DMake(37.45, -122.0)];
[rectanglePath addCoordinate:CLLocationCoordinate2DMake(37.45, -122.2)];
[rectanglePath addCoordinate:CLLocationCoordinate2DMake(37.36, -122.2)];
[rectanglePath addCoordinate:CLLocationCoordinate2DMake(37.36, -122.0)];

GMSPolyline *rectangle = [GMSPolyline polylineWithPath:path];
rectangle.map = mapView;

קו פוליגוני מלבני

הסרת קו פוליגוני

אפשר להסיר קו פוליגוני מהמפה על ידי הגדרת המאפיין map של GMSPolyline ל-nil. לחלופין, אפשר להסיר את כל שכבות-העל (כולל קווים פוליגוניים וצורות אחרות) מהמפה על ידי קריאה לשיטה GMSMapView clear.

Swift

mapView.clear()

Objective-C

[mapView clear];

התאמה אישית של קו פוליגוני

האובייקט GMSPolyline מספק מספר מאפיינים כדי לקבוע את מראה הקו. הוא תומך באפשרויות הבאות:

strokeWidth: הרוחב של כל הקו, בנקודות מסך. ברירת המחדל היא 1. הרוחב לא ישתנה כשמגדילים את המפה.
geodesic: כשהערך הוא YES, צריך לעבד את הקצה של הקו הפוליגוני הזה כגיאודזי. פלחים גיאודזיים עוקבים אחר המסלול הקצר ביותר לאורך פני כדור הארץ ועשויים להופיע כקווים מעוקלים במפה עם היטל Mercator. קטעים לא גיאוזיים משורטטים כקווים ישרים במפה. ברירת המחדל היא NO.
spans: משמש לציון הצבע של קטע אחד או יותר של קו פוליגוני. המאפיין spans הוא מערך של GMSStyleSpan אובייקטים. הגדרת המאפיין spans היא הדרך המועדפת לשינוי הצבע של קו פוליגוני.
strokeColor: אובייקט UIColor שמציין את הצבע של הקו הפוליגוני. ברירת המחדל היא blueColor. אם המאפיין spans מוגדר, המערכת תתעלם מהמאפיין strokeColor.

הקטע הבא מוסיף קו פוליגוני עבה ממלבורן לפרת', עם אינטרפולציה גיאודסית.

Swift

let path = GMSMutablePath()
path.addLatitude(-37.81319, longitude: 144.96298)
path.addLatitude(-31.95285, longitude: 115.85734)
let polyline = GMSPolyline(path: path)
polyline.strokeWidth = 10.0
polyline.geodesic = true
polyline.map = mapView

Objective-C

GMSMutablePath *path = [GMSMutablePath path];
[path addLatitude:-37.81319 longitude:144.96298];
[path addLatitude:-31.95285 longitude:115.85734];
GMSPolyline *polyline = [GMSPolyline polylineWithPath:path];
polyline.strokeWidth = 10.f;
polyline.geodesic = YES;
polyline.map = mapView;

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

Swift

polyline.strokeColor = .blue

Objective-C

polyline.strokeColor = [UIColor blueColor];

שינוי הצבע של קו פוליגוני

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

בקטע הקוד הבא נעשה שימוש בשיטה spanWithColor: כדי לשנות את הצבע של כל הקו לאדום.

Swift

polyline.spans = [GMSStyleSpan(color: .red)]

Objective-C

polyline.spans = @[[GMSStyleSpan spanWithColor:[UIColor redColor]]];

לחלופין, אם כבר יש לכם גישה לאובייקט GMSStrokeStyle, אתם יכולים להשתמש ב-method spanWithStyle:.

Swift

let solidRed = GMSStrokeStyle.solidColor(.red)
polyline.spans = [GMSStyleSpan(style: solidRed)]

Objective-C

GMSStrokeStyle *solidRed = [GMSStrokeStyle solidColor:[UIColor redColor]];
polyline.spans = @[[GMSStyleSpan spanWithStyle:solidRed]];

לפני גרסה 1.7 של ה-SDK של מפות Google ל-iOS, הנכס היחיד strokeColor היה זמין להגדרת הצבע המלא של GMSPolyline. המאפיין spans מקבל עדיפות על פני המאפיין strokeColor.

Swift

polyline.strokeColor = .red

Objective-C

polyline.strokeColor = [UIColor redColor];

סגנונות

אם באפליקציה משתמשים באותו צבע קו מספר פעמים, כדאי להגדיר סגנון לשימוש חוזר. סגנונות של קו פוליגוני מוגדרים באמצעות האובייקט GMSStrokeStyle. סגנון קו יכול להיות צבע אחיד או הדרגתי מצבע אחד לצבע אחר. אחרי שיוצרים סגנון, אפשר להחיל אותו על GMSStyleSpan באמצעות ה-method spanWithStyle:.

Swift

// Create two styles: one that is solid blue, and one that is a gradient from red to yellow
let solidBlue = GMSStrokeStyle.solidColor(.blue)
let solidBlueSpan = GMSStyleSpan(style: solidBlue)
let redYellow = GMSStrokeStyle.gradient(from: .red, to: .yellow)
let redYellowSpan = GMSStyleSpan(style: redYellow)

Objective-C

// Create two styles: one that is solid blue, and one that is a gradient from red to yellow
GMSStrokeStyle *solidBlue = [GMSStrokeStyle solidColor:[UIColor blueColor]];
GMSStyleSpan *solidBlueSpan = [GMSStyleSpan spanWithStyle:solidBlue];
GMSStrokeStyle *redYellow =
    [GMSStrokeStyle gradientFromColor:[UIColor redColor] toColor:[UIColor yellowColor]];
GMSStyleSpan *redYellowSpan = [GMSStyleSpan spanWithStyle:redYellow];

הסגנון של span ימשיך עד סוף הקו הפוליגוני או עד שיוגדר סגנון חדש. אפשר לשנות את הצבע של הקו כולו על-ידי הגדרת המאפיין spans של קו פוליגוני כ-GMSStyleSpan יחיד. הדוגמה ממחישה איך להחיל שיפוע לאורך כל האורך של הקו הפוליגוני.

Swift

polyline.spans = [GMSStyleSpan(style: redYellow)]

Objective-C

polyline.spans = @[[GMSStyleSpan spanWithStyle:redYellow]];

שינוי הצבע של מקטעי קו בודדים

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

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

Swift

polyline.spans = [
  GMSStyleSpan(style: solidRed),
  GMSStyleSpan(style: solidRed),
  GMSStyleSpan(style: redYellow)
]

Objective-C

polyline.spans = @[[GMSStyleSpan spanWithStyle:solidRed],
                   [GMSStyleSpan spanWithStyle:solidRed],
                   [GMSStyleSpan spanWithStyle:redYellow]];

אפשר להשתמש ב-method spanWithStyle:segments: כדי להגדיר את הסגנון למספר פלחים בבת אחת. לדוגמה, הקוד הבא מקביל לקוד הקודם. המערכת תמיד מתעלמת מאורך הקטע של GMSStyleSpan הסופי, כי הסגנון משמש לתיאור שאר הקו.

Swift

polyline.spans = [
  GMSStyleSpan(style: solidRed, segments:2),
  GMSStyleSpan(style: redYellow, segments:10)
]

Objective-C

polyline.spans = @[[GMSStyleSpan spanWithStyle:solidRed segments:2],
                   [GMSStyleSpan spanWithStyle:redYellow segments:10]];

פלחים חלקיים

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

Swift

polyline.spans = [
  GMSStyleSpan(style: solidRed, segments: 2.5),
  GMSStyleSpan(color: .gray),
  GMSStyleSpan(color: .purple, segments: 0.75),
  GMSStyleSpan(style: redYellow)
]

Objective-C

polyline.spans = @[[GMSStyleSpan spanWithStyle:solidRed segments:2.5],
                   [GMSStyleSpan spanWithColor:[UIColor grayColor]],
                   [GMSStyleSpan spanWithColor:[UIColor purpleColor] segments:0.75],
                   [GMSStyleSpan spanWithStyle:redYellow]];

הוספת תבנית צבעים שחוזרת על עצמה לקו פוליגוני

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

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

Swift

let styles = [
  GMSStrokeStyle.solidColor(.white),
  GMSStrokeStyle.solidColor(.black)
]
let lengths: [NSNumber] = [100000, 50000]
polyline.spans = GMSStyleSpans(
  polyline.path!,
  styles,
  lengths,
  GMSLengthKind.rhumb
)

Objective-C

NSArray *styles = @[[GMSStrokeStyle solidColor:[UIColor whiteColor]],
                    [GMSStrokeStyle solidColor:[UIColor blackColor]]];
NSArray *lengths = @[@100000, @50000];
polyline.spans = GMSStyleSpans(polyline.path, styles, lengths, kGMSLengthRhumb);

קווים פוליגוניים עם חותמת

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

קו פוליגוני עם חותמת

אפשר להשתמש בתכונה הזו באמצעות GMSSpriteStyle ולהגדיר אותה כחותמת באמצעות המאפיין stampStyle של GMSStrokeStyle.

Swift

let path = GMSMutablePath()
path.addLatitude(-37.81319, longitude: 144.96298)
path.addLatitude(-31.95285, longitude: 115.85734)
let polyline = GMSPolyline(path: path)
polyline.strokeWidth = 20
let image = UIImage(named: "imageFromBundleOrAsset")! // Image could be from anywhere
let stampStyle = GMSSpriteStyle(image: image)
let transparentStampStroke = GMSStrokeStyle.transparentStroke(withStamp: stampStyle)
let span = GMSStyleSpan(style: transparentStampStroke)
polyline.spans = [span]
polyline.map = mapView

Objective-C

GMSMutablePath *path = [GMSMutablePath path];
[path addLatitude:-37.81319 longitude:144.96298];
[path addLatitude:-31.95285 longitude:115.85734];
polyline.strokeWidth = 20;
GMSPolyline *polyline = [GMSPolyline polylineWithPath:path];

UIImage *image = [UIImage imageNamed:@"imageFromBundleOrAsset"];
GMSStrokeStyle *transparentStampStroke = [GMSStrokeStyle transparentStrokeWithStampStyle:[GMSSpriteStyle spriteStyleWithImage:image]];

GMSStyleSpan *span = [GMSStyleSpan spanWithStyle:transparentStampStroke];
polyline.spans = @[span];
polyline.map = _mapView;

קווים פוליגוניים עם חותמת

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

קו פוליגוני עם טקסטורה

אפשר להשתמש בתכונה הזו באמצעות GMSTextureStyle ולהגדיר אותה כחותמת באמצעות המאפיין stampStyle של GMSStrokeStyle.

Swift

let path = GMSMutablePath()
path.addLatitude(-37.81319, longitude: 144.96298)
path.addLatitude(-31.95285, longitude: 115.85734)
let polyline = GMSPolyline(path: path)
polyline.strokeWidth = 20
let redWithStamp = GMSStrokeStyle.solidColor(.red)
let image = UIImage(named: "imageFromBundleOrAsset")! // Image could be from anywhere
redWithStamp.stampStyle = GMSTextureStyle(image: image)
let span = GMSStyleSpan(style: redWithStamp)
polyline.spans = [span]
polyline.map = mapView

Objective-C

GMSMutablePath *path = [GMSMutablePath path];
[path addLatitude:-37.81319 longitude:144.96298];
[path addLatitude:-31.95285 longitude:115.85734];
GMSPolyline *polyline = [GMSPolyline polylineWithPath:path];
polyline.strokeWidth = 20;
GMSStrokeStyle *redWithStamp = [GMSStrokeStyle solidColor:[UIColor redColor]];

UIImage *image = [UIImage imageNamed:@"imageFromBundleOrAsset"]; // Image could be from anywhere
redWithStamp.stampStyle = [GMSTextureStyle textureStyleWithImage:image];

GMSStyleSpan *span = [GMSStyleSpan spanWithStyle:redWithStamp];
polyline.spans = @[span];
polyline.map = _mapView;

יכולות מפה

המאפיין mapCapabilities ב-GMSMapView כולל בדיקה פרוגרמטית של תכונות ספציפיות למפה. האפשרות הזו שימושית כשרוצים לדעת אם חלק מהמפה capabilities זמינה לפני קריאה לממשקי API ספציפיים. השאילתה הזו קובעת אם תצוגת המפה תומכת בקווים פוליגוניים עם חותמת של Sprite.

Swift

let path = GMSMutablePath()
path.addLatitude(-37.81319, longitude: 144.96298)
path.addLatitude(-31.95285, longitude: 115.85734)
let polyline = GMSPolyline(path: path)
polyline.strokeWidth = 20
let image = UIImage(named: "imageFromBundleOrAsset")! // Image could be from anywhere
let spans: [GMSStyleSpan]
if (mapView.mapCapabilities.contains(.spritePolylines)) {
  let spriteStyle = GMSSpriteStyle(image: image)
  let stroke = GMSStrokeStyle.transparentStroke(withStamp: spriteStyle)
  spans = [ GMSStyleSpan(style: stroke) ]
} else {
  let stroke = GMSStrokeStyle.solidColor(.clear)
  stroke.stampStyle = GMSTextureStyle(image: image)
  spans = [ GMSStyleSpan(style: stroke) ]
}
polyline.spans = spans
polyline.map = mapView

Objective-C

GMSMutablePath *path = [GMSMutablePath path];
[path addLatitude:-37.81319 longitude:144.96298];
[path addLatitude:-31.95285 longitude:115.85734];

UIImage *_Nonnull image = [UIImage imageNamed:@"imageFromBundleOrAsset"]; // Image could be from anywhere

NSArray<GMSStyleSpan *> * spans;
if (_mapView.mapCapabilities & GMSMapCapabilityFlagsSpritePolylines) {
  GMSSpriteStyle *spriteStyle = [GMSSpriteStyle spriteStyleWithImage:image];
  GMSStrokeStyle *stroke = [GMSStrokeStyle transparentStrokeWithStampStyle:spriteStyle];
  spans = @[ [GMSStyleSpan spanWithStyle:stroke] ];
} else {
  GMSStrokeStyle *stroke = [GMSStrokeStyle solidColor:UIColor.clearColor];
  stroke.stampStyle = [GMSTextureStyle textureStyleWithImage:image];
  spans = @[ [GMSStyleSpan spanWithStyle:stroke] ];
}

GMSPolyline *polyline = [GMSPolyline polylineWithPath:path];
polyline.strokeWidth = 20;
polyline.spans = spans;
polyline.map = _mapView;

הדפוס הזה מאפשר להירשם לשינויים ולהגיב לעדכונים באמצעות מצב תצוגת המפה. תוכלו גם להטמיע את didChangeMapCapabilities ב-GMSMapViewDelegate כדי לקבל עדכונים לגבי זמינות התכונות.

פוליגונים

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

אפשר להוסיף GMSPolygon למפה באותו אופן שבו מוסיפים GMSPolyline. קודם כול, מציינים את הנתיב שלו על ידי יצירת אובייקט GMSMutablePath תואם והוספת נקודות אליו. הנקודות האלה יוצרות את קווי המתאר של המצולע. כל CLLocationCoordinate2D מייצג נקודה על פני כדור הארץ. קטעי הקו משורטטים בין נקודות לפי הסדר שבו הוספתם אותן לנתיב.

הוספת מצולע

יוצרים אובייקט GMSMutablePath.
אפשר להגדיר את הנקודות בנתיב באמצעות ה-methods addCoordinate: או addLatitude:longitude:. הנקודות האלו יוצרות את קווי המתאר של הפוליגון.
יוצרים אובייקט GMSPolygon חדש באמצעות הנתיב כארגומנט.
מגדירים מאפיינים אחרים כמו strokeWidth, strokeColor ו-fillColor, לפי הצורך.
כדי להקצות את הפוליגון לאובייקט GMSMapView, מגדירים את המאפיין GMSPolygon.map.
הפוליגון יופיע במפה.

קטע הקוד הבא מוסיף מלבן למפה.

Swift

// Create a rectangular path
let rect = GMSMutablePath()
rect.add(CLLocationCoordinate2D(latitude: 37.36, longitude: -122.0))
rect.add(CLLocationCoordinate2D(latitude: 37.45, longitude: -122.0))
rect.add(CLLocationCoordinate2D(latitude: 37.45, longitude: -122.2))
rect.add(CLLocationCoordinate2D(latitude: 37.36, longitude: -122.2))

// Create the polygon, and assign it to the map.
let polygon = GMSPolygon(path: rect)
polygon.fillColor = UIColor(red: 0.25, green: 0, blue: 0, alpha: 0.05);
polygon.strokeColor = .black
polygon.strokeWidth = 2
polygon.map = mapView

Objective-C

// Create a rectangular path
GMSMutablePath *rect = [GMSMutablePath path];
[rect addCoordinate:CLLocationCoordinate2DMake(37.36, -122.0)];
[rect addCoordinate:CLLocationCoordinate2DMake(37.45, -122.0)];
[rect addCoordinate:CLLocationCoordinate2DMake(37.45, -122.2)];
[rect addCoordinate:CLLocationCoordinate2DMake(37.36, -122.2)];

// Create the polygon, and assign it to the map.
GMSPolygon *polygon = [GMSPolygon polygonWithPath:rect];
polygon.fillColor = [UIColor colorWithRed:0.25 green:0 blue:0 alpha:0.05];
polygon.strokeColor = [UIColor blackColor];
polygon.strokeWidth = 2;
polygon.map = mapView;

אפשר להתאים אישית את המראה של הפוליגון גם לפני שמוסיפים אותו למפה וגם אחרי שהוא נוסף למפה.

הסרת פוליגון

מסירים פוליגון על ידי הגדרת מאפיין GMSPolygon.map שלו ל-nil וניתוק של layer מהורה.

Swift

 polygon.map = nil
 polygon.layer.removeFromSuperLayer()

Objective-C

 polygon.map = nil;
 [polygon.layer removeFromSuperlayer];

עיגולים

בנוסף למחלקה הגנרית GMSPolygon, ה-SDK של מפות Google ל-iOS כולל גם את GMSCircle, שמאפשר לצייר מעגלים על פני כדור הארץ.

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

position בתור CLLocationCoordinate2D.
radius במטרים.

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

הוספת מעגל

קטע הקוד הבא מוסיף עיגול למפה:

Swift

let circleCenter = CLLocationCoordinate2D(latitude: 37.35, longitude: -122.0)
let circle = GMSCircle(position: circleCenter, radius: 1000)
circle.map = mapView

Objective-C

CLLocationCoordinate2D circleCenter = CLLocationCoordinate2DMake(37.35, -122.0);
GMSCircle *circle = [GMSCircle circleWithPosition:circleCenter
                                         radius:1000];
circle.map = mapView;

אפשר להתאים אישית את המראה של העיגול לפני שמוסיפים אותו למפה וגם אחרי שהוא נוסף למפה.

התאמה אישית של מעגל

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

fillColor: אובייקט UIColor שמציין את הצבע הפנימי של העיגול. ברירת המחדל היא שקוף.
strokeColor: אובייקט UIColor שמציין את צבע המתאר של העיגול. ברירת המחדל היא blackColor.
strokeWidth: העובי של מתאר העיגול, בנקודות על המסך. ברירת המחדל היא 1. העובי לא יוגדל כשמגדילים את המפה.

קטע הקוד הבא מוסיף עיגול אדום עבה עם חלל פנימי אדום למחצה.

Swift

circle.fillColor = UIColor(red: 0.35, green: 0, blue: 0, alpha: 0.05)
circle.strokeColor = .red
circle.strokeWidth = 5

Objective-C

circle.fillColor = [UIColor colorWithRed:0.25 green:0 blue:0 alpha:0.05];
circle.strokeColor = [UIColor redColor];
circle.strokeWidth = 5;

יצירת פוליגון חלול

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

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

אם נתיב קטן יותר מוקף במלואו בנתיב הגדול, נראה כאילו קטע מהפוליגון הוסר.

דוגמת הקוד הבאה יוצרת פוליגון עם שני חורים:

Swift

let hydeParkLocation = CLLocationCoordinate2D(latitude: -33.87344, longitude: 151.21135)
let camera = GMSCameraPosition.camera(withTarget: hydeParkLocation, zoom: 16)
let mapView = GMSMapView.map(withFrame: .zero, camera: camera)
mapView.animate(to: camera)

let hydePark = "tpwmEkd|y[QVe@Pk@BsHe@mGc@iNaAKMaBIYIq@qAMo@Eo@@[Fe@DoALu@HUb@c@XUZS^ELGxOhAd@@ZB`@J^BhFRlBN\\BZ@`AFrATAJAR?rAE\\C~BIpD"
let archibaldFountain = "tlvmEqq|y[NNCXSJQOB[TI"
let reflectionPool = "bewmEwk|y[Dm@zAPEj@{AO"

let hollowPolygon = GMSPolygon()
hollowPolygon.path = GMSPath(fromEncodedPath: hydePark)
hollowPolygon.holes = [GMSPath(fromEncodedPath: archibaldFountain)!, GMSPath(fromEncodedPath: reflectionPool)!]
hollowPolygon.fillColor = UIColor(red: 1.0, green: 0.0, blue: 0.0, alpha: 0.2)
hollowPolygon.strokeColor = UIColor(red: 1.0, green: 0.0, blue: 0.0, alpha: 1.0)
hollowPolygon.strokeWidth = 2
hollowPolygon.map = mapView

Objective-C

CLLocationCoordinate2D hydeParkLocation = CLLocationCoordinate2DMake(-33.87344, 151.21135);
GMSCameraPosition *camera = [GMSCameraPosition cameraWithTarget:hydeParkLocation
                                                           zoom:16];
mapView = [GMSMapView mapWithFrame:CGRectZero camera:camera];

NSString *hydePark = @"tpwmEkd|y[QVe@Pk@BsHe@mGc@iNaAKMaBIYIq@qAMo@Eo@@[Fe@DoALu@HUb@c@XUZS^ELGxOhAd@@ZB`@J^BhFRlBN\\BZ@`AFrATAJAR?rAE\\C~BIpD";
NSString *archibaldFountain = @"tlvmEqq|y[NNCXSJQOB[TI";
NSString *reflectionPool = @"bewmEwk|y[Dm@zAPEj@{AO";

GMSPolygon *hollowPolygon = [[GMSPolygon alloc] init];
hollowPolygon.path = [GMSPath pathFromEncodedPath:hydePark];
hollowPolygon.holes = @[[GMSPath pathFromEncodedPath:archibaldFountain],
                  [GMSPath pathFromEncodedPath:reflectionPool]];
hollowPolygon.fillColor = [UIColor colorWithRed:1.0 green:0.0 blue:0.0 alpha:0.2];
hollowPolygon.strokeColor = [UIColor colorWithRed:1.0 green:0.0 blue:0.0 alpha:1.0];
hollowPolygon.strokeWidth = 2;
hollowPolygon.map = mapView;