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

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

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 שמציין את צבע המעגל Outline. ברירת המחדל היא 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;