ב-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;