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