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

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

צורות

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

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

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

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

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

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

כדי ליצור קו פוליגוני, צריך לציין את הנתיב שלו על ידי יצירת אובייקט GMSMutablePath תואם עם שתי נקודות או יותר. כל CLLocationCoordinate2D מייצג נקודה על פני השטח של כדור הארץ. מקטעים של קו משורטטים בין נקודות לפי הסדר שבו הוספתם אותם לנתיב. אפשר להוסיף נקודות לנתיב באמצעות השיטות 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.
אפשר להגדיר את הנקודות בנתיב באמצעות השיטות 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, צריך לעבד את קצה הפוליגון הזה כגיאודזי. קטעים גיאודזיים עוקבים אחר המסלול הקצר ביותר על פני השטח של כדור הארץ, ועשויים להופיע כקווים מעוגלים במפה עם היטל של מרקטור. קטעים לא גיאודזיים משורטטים כקווים ישרים במפה. ברירת המחדל היא NO.
spans: משמש לציון הצבע של מקטע אחד או יותר של קו פוליגוני. המאפיין spans הוא מערך של אובייקטים של GMSStyleSpan. הגדרת המאפיין spans היא הדרך המועדפת לשינוי הצבע של קו פוליגוני.
strokeColor: אובייקט UIColor שמציין את הצבע של הקו הפוליגוני. ברירת המחדל היא blueColor. המערכת מתעלמת מהמאפיין strokeColor אם מוגדר הערך spans.

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

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

אפשר להשתמש בשיטה 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]];

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

אם רוצים להוסיף דפוס לקו פוליגוני, אפשר להשתמש בשיטת העזר GMSStyleSpans ב-GMSGeometryUtils. השיטה 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);

Sprite פוליגוני חתום

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

קו פוליגוני חתום ב-Sprite

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