צורות

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

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

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

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

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

קווים פוליגוניים מאפשרים לשרטט קווים במפה. 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];
      

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

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

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

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

הוספת מצולע

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

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

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;