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