Mit dem Maps SDK for iOS können Sie Formen einfach in Ihre Karten einfügen. Folgende Formen werden unterstützt:
- Eine Polylinie ist eine Reihe verbundener Liniensegmente, die Sie zu einer beliebigen Form zusammenfügen können, um Pfade und Routen auf einer Karte darzustellen.
- Ein Polygon ist eine geschlossene Form zur Markierung von Bereichen auf der Karte.
- Ein Kreis ist eine geografisch genaue Projektion eines Kreises auf der Erdoberfläche.
Sie können das Erscheinungsbild jeder dieser Formen auf verschiedene Weise verändern.
Polylinien
Mit Polylinien können Sie Linien auf einer Karte zeichnen. Ein GMSPolyline
-Objekt stellt eine geordnete Folge von Standorten dar, die als Folge von Liniensegmenten angezeigt wird. Sie können die Farbe einer Polylinie mit GMSStrokeStyle
festlegen.
Um eine Polylinie zu erstellen, müssen Sie den Pfad angeben. Dazu erstellen Sie ein entsprechendes GMSMutablePath
-Objekt mit zwei oder mehr Punkten. Jedes CLLocationCoordinate2D
-Objekt steht für einen Punkt auf der Erdoberfläche. Die Punkte werden in der Reihenfolge durch Liniensegmente verbunden, in der Sie die Punkte dem Pfad hinzufügen. Mit der Methode addCoordinate:
oder addLatitude:longitude:
können Sie dem Pfad Punkte hinzufügen.
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];
Polylinien hinzufügen
- Erstellen Sie ein
GMSMutablePath
-Objekt. - Legen Sie die Punkte im Pfad mit den Methoden
addCoordinate:
oderaddLatitude:longitude:
fest. - Instanziieren Sie ein neues
GMSPolyline
-Objekt mit dem Pfad als Argument. - Legen Sie bei Bedarf weitere Attribute wie
strokeWidth
undstrokeColor
fest. - Legen Sie die Eigenschaft
map
vonGMSPolyline
fest. - Die Polylinie wird auf der Karte angezeigt.
Im folgenden Codebeispiel wird ein Rechteck zu einer Karte hinzugefügt:
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;
Polylinien entfernen
Wenn Sie eine Polylinie aus der Karte entfernen möchten, legen Sie für die Eigenschaft map
der GMSPolyline
den Wert nil
fest. Alternativ können Sie alle Overlays, einschließlich Polylinien und anderer Formen, auf der Karte entfernen, indem Sie die Methode GMSMapView
clear
aufrufen.
Swift
mapView.clear()
Objective-C
[mapView clear];
Polylinien anpassen
Das GMSPolyline
-Objekt bietet mehrere Eigenschaften zur Steuerung der Darstellung der Linie. Folgende Optionen werden unterstützt:
strokeWidth
- Die Breite der gesamten Linie in Bildschirmpunkten. Der Standardfaktor ist 1. Die Breite wird beim Zoomen der Karte nicht skaliert.
geodesic
-
Wenn
YES
festgelegt, wird die Polylinienkante als Geodäte gerendert. Geodätische Segmente folgen dem kürzesten Pfad entlang der Erdoberfläche und können auf einer Karte mit Mercator-Projektion als gebogene Linien angezeigt werden. Nicht geodätische Segmente werden auf der Karte als gerade Linien gezeichnet. Die Standardeinstellung istNO
. spans
- : Hiermit wird die Farbe eines oder mehrerer Segmente einer Polylinie angegeben. Die Property spans ist ein Array von
GMSStyleSpan
-Objekten. Das Attributspans
wird bevorzugt zum Ändern der Farbe einer Polylinie verwendet. strokeColor
- : Ein
UIColor
-Objekt, das die Farbe der Polylinie angibt. Die Standardeinstellung istblueColor
. Das AttributstrokeColor
wird ignoriert, wennspans
festgelegt ist.
Mit dem folgenden Snippet wird eine dicke Polylinie von Melbourne nach Perth mit geodätischer Interpolation hinzugefügt.
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;
Wenn Sie eine Polylinie nach dem Hinzufügen zur Karte ändern möchten, müssen Sie das GMSPolyline
-Objekt beibehalten.
Swift
polyline.strokeColor = .blue
Objective-C
polyline.strokeColor = [UIColor blueColor];
Farbe von Polylinien ändern
Polylinien werden als Reihen von Segmenten auf der Karte gezeichnet. Mit der Eigenschaft spans
können Sie die Farbe einzelner Segmente oder die gesamte Linie ändern. Diese Eigenschaft ermöglicht Ihnen eine genaue Kontrolle über die Farbgebung einer Polylinie. Es gibt jedoch mehrere praktische Funktionen, mit denen sich ein einzelner Stil auf die gesamte Linie anwenden lässt.
Im nachfolgenden Snippet wird die Methode spanWithColor:
verwendet, um die Farbe der gesamten Linie in Rot zu ändern.
Swift
polyline.spans = [GMSStyleSpan(color: .red)]
Objective-C
polyline.spans = @[[GMSStyleSpan spanWithColor:[UIColor redColor]]];
Wenn Sie bereits Zugriff auf ein GMSStrokeStyle
-Objekt haben, können Sie alternativ die Methode spanWithStyle:
verwenden.
Swift
let solidRed = GMSStrokeStyle.solidColor(.red) polyline.spans = [GMSStyleSpan(style: solidRed)]
Objective-C
GMSStrokeStyle *solidRed = [GMSStrokeStyle solidColor:[UIColor redColor]]; polyline.spans = @[[GMSStyleSpan spanWithStyle:solidRed]];
Vor Version 1.7 des Maps SDK for iOS war die einzelne Property strokeColor
verfügbar, um die gesamte Farbe einer GMSPolyline
festzulegen.
Das Attribut spans
hat Vorrang vor strokeColor
.
Swift
polyline.strokeColor = .red
Objective-C
polyline.strokeColor = [UIColor redColor];
Stile
Wenn Ihre App mehrmals dieselbe Strichfarbe verwendet, kann es hilfreich sein, einen wiederverwendbaren Stil zu definieren. Polylinienstile werden mit dem Objekt GMSStrokeStyle
angegeben. Es kann entweder eine Volltonfarbe oder ein Farbverlauf von einer Farbe in eine andere sein. Sobald Sie einen Stil erstellt haben, können Sie ihn mit der Methode spanWithStyle:
auf ein GMSStyleSpan
anwenden.
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];
Der Stil von span
wird bis zum Ende der Polylinie oder bis ein neuer Stil festgelegt wird, beibehalten. Sie können die Farbe der gesamten Linie ändern. Legen Sie dazu das Attribut spans
einer Polylinie auf einen einzelnen GMSStyleSpan
fest. Im nachfolgenden Snippet sehen Sie, wie ein Farbverlauf über die gesamte Länge der Polylinie angewendet wird.
Swift
polyline.spans = [GMSStyleSpan(style: redYellow)]
Objective-C
polyline.spans = @[[GMSStyleSpan spanWithStyle:redYellow]];
Farbe einzelner Liniensegmente ändern
Wenn Sie die einzelnen Segmente Ihrer Polylinie einzeln gestalten möchten, können Sie ein Array mit GMSStyleSpan
-Objekten erstellen und an die Eigenschaft spans
übergeben. Standardmäßig wird durch jedes Element im Array die Farbe des entsprechenden Liniensegments festgelegt. Wenn das Array mehr Elemente enthält als Segmente, werden die zusätzlichen Elemente ignoriert. Wenn das Array weniger Elemente enthält, beschreibt das endgültige GMSStyleSpan
die Farbe für den Rest der Linie.
Sie können Blöcke von Farb- und/oder Farbverlaufspolygonen verwenden, um Veränderungen entlang der Polylinie anzugeben, z. B. Höhe oder Geschwindigkeit. Mit dem nachfolgenden Snippet wird die Farbe der ersten beiden Segmente einer Polylinie auf Rot gesetzt. Der Rest der Linie ist ein Farbverlauf von Rot zu Gelb.
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]];
Mit der Methode spanWithStyle:segments:
können Sie den Stil für mehrere Segmente gleichzeitig festlegen. So entspricht das folgende Codebeispiel dem obigen.
Die Segmentlänge der endgültigen GMSStyleSpan
wird immer ignoriert, da der Stil zur Beschreibung des Rests der Zeile verwendet wird.
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]];
Bruchsegmente
Segmente können auch als Bruchzahlen angegeben werden. Der Stil wird so auf die anteilige Anzahl von Segmenten angewendet, was zu einer Aufteilung in einem einzelnen Segment führen kann. Jeder GMSStyleSpan
beginnt direkt nach dem vorherigen: Im Beispiel unten beginnt die graue Farbe von 1⁄2 bis zum zweiten Segment und geht bis zu 1⁄2 bis zum dritten Segment.
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]];
Sich wiederholende Farbmuster zu einer Polylinie hinzufügen
Wenn Sie einer Polylinie ein Muster hinzufügen möchten, können Sie die Dienstprogrammmethode GMSStyleSpans
in GMSGeometryUtils
verwenden. Die Methode GMSStyleSpans
akzeptiert zwei Arrays, die ein wiederkehrendes Muster definieren. Mit einem Array werden die Stile festgelegt, die wiederholt werden sollen, und mit dem anderen das Wiederholungsintervall. Gemeinsam können Sie ein Muster erstellen, das auf jede Polylinie angewendet werden kann, unabhängig von seiner Länge oder der Anzahl der verfügbaren Segmente.
Im folgenden Code-Snippet wird beispielsweise eine Polylinie mit einem schwarz-weißen abwechselnden Muster definiert. Die Länge wird als Meter entlang einer Rautelinie (in Mercator ist dies eine gerade Linie) behandelt, da der Typ als kGMSLengthRhumb
angegeben wird.
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);
Prägestempel mit Sprite
Mit Sprite abgestempelte Polylinien ermöglichen es Ihnen, eine Polylinie mithilfe eines sich wiederholenden Bitmapbilds Ihrer Wahl zu erstellen. Formen werden mit einem klaren Hintergrundstrich angezeigt, aber der Stempel ist nicht um die Ecken der Linie herum abgeschnitten und eignet sich daher für Situationen wie Punkte zur Darstellung von Fußgängerrouten.
Sie können diese Funktion über GMSSpriteStyle
verwenden und sie über die Property stampStyle
von GMSStrokeStyle
als Stempel festlegen.
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;
Strukturierte gestanzte Polylinien
Mit Struktur gestanzte Polylinien können Sie mit einer wiederholten Textur Ihrer Wahl erstellen. Formen können mit einem klaren, einfarbigen oder einem Farbverlauf im Hintergrund angezeigt werden. Die Größe der Textur ändert sich, wenn die Zoomstufen geändert werden. Bilder am Ende oder Anfang von Pfaden oder Pfadpunkten werden bei bestimmten Zoomstufen abgeschnitten.
Sie können diese Funktion über GMSTextureStyle
verwenden und sie über die Property stampStyle
von GMSStrokeStyle
als Stempel festlegen.
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;
Kartenfunktionen
Mit der Eigenschaft mapCapabilities
für GMSMapView
wird eine programmatische Prüfung auf kartenspezifische Funktionen hinzugefügt. Dies ist hilfreich, wenn Sie wissen möchten, ob bestimmte Karten (capabilities
) verfügbar sind, bevor Sie bestimmte APIs aufrufen. Mit dieser Abfrage wird festgelegt, ob die Kartenansicht von gespritzten Polylinien unterstützt wird.
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;
Mit diesem Muster können Sie Änderungen abonnieren und auf Updates mit Ihrem Status der Kartenansicht reagieren. Sie können didChangeMapCapabilities
auch in GMSMapViewDelegate
implementieren, um Updates zur Verfügbarkeit der Funktion zu erhalten.
Polygone
Polygone sind Polylinien ähnlich, da sie aus einer Reihe von Koordinaten in einer geordneten Reihenfolge bestehen. Allerdings sind Polygone nicht offen, sondern umschließen bestimmte Regionen. Polygone werden im Maps SDK for iOS durch die Klasse GMSPolygon
definiert.
Ein GMSPolygon
-Objekt lässt sich der Karte auf dieselbe Weise hinzufügen wie ein GMSPolyline
. Geben Sie als Erstes den Pfad an, indem Sie ein entsprechendes GMSMutablePath
-Objekt erstellen und diesem Punkte hinzufügen. Diese Punkte bilden den Umriss des Polygons. Jedes CLLocationCoordinate2D
-Objekt steht für einen Punkt auf der Erdoberfläche. Die Punkte werden in der Reihenfolge durch Liniensegmente verbunden, in der Sie die Punkte dem Pfad hinzufügen.
Polygone hinzufügen
- Erstellen Sie ein
GMSMutablePath
-Objekt. - Legen Sie die Punkte im Pfad mit den Methoden
addCoordinate:
oderaddLatitude:longitude:
fest. Diese Punkte bilden den Umriss des Polygons. - Instanziieren Sie ein neues
GMSPolygon
-Objekt mit dem Pfad als Argument. - Legen Sie bei Bedarf weitere Attribute wie
strokeWidth
,strokeColor
undfillColor
fest. - Weisen Sie das Polygon einem
GMSMapView
-Objekt zu, indem Sie die EigenschaftGMSPolygon.map
festlegen. - Das Polygon wird auf der Karte angezeigt.
Mit dem folgenden Code-Snippet wird der Karte ein Rechteck hinzugefügt.
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;
Die Darstellung des Polygons kann sowohl vor als auch nach dem Hinzufügen zur Karte angepasst werden.
Polygone entfernen
Wenn Sie ein Polygon entfernen möchten, legen Sie die Eigenschaft GMSPolygon.map
auf nil
fest und trennen das layer
von seinem übergeordneten Element.
Swift
polygon.map = nil polygon.layer.removeFromSuperLayer()
Objective-C
polygon.map = nil; [polygon.layer removeFromSuperlayer];
Kreise
Zusätzlich zur generischen GMSPolygon
-Klasse enthält das Maps SDK for iOS auch GMSCircle
. Damit können Sie ganz einfach Kreise auf der Erdoberfläche zeichnen.
Um einen Kreis zu konstruieren, müssen die folgenden beiden Eigenschaften definiert werden:
position
alsCLLocationCoordinate2D
.radius
in Metern.
Ein Kreis ist definiert als die Menge aller Punkte auf der Erdoberfläche, die radius
Meter vom angegebenen Kreismittelpunkt (center
) entfernt sind. Aufgrund der Art, wie die von der Google Maps API verwendete Mercator-Projektion eine Kugel auf einer ebenen Oberfläche rendert, erscheint diese Form nahe am Äquator wie ein fast perfekter Kreis. Mit zunehmender Entfernung vom Äquator verliert sie (auf dem Bildschirm) aber immer mehr diese kreisrunde Form.
Kreise hinzufügen
Im folgenden Codebeispiel wird ein Kreis zu einer Karte hinzugefügt:
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;
Die Darstellung des Kreises lässt sich anpassen, unabhängig davon, ob er der Karte schon hinzugefügt wurde oder nicht.
Kreise anpassen
Sie können benutzerdefinierte Farben und Strichbreiten angeben, indem Sie die Eigenschaften von GMSCircle
ändern. Folgende Optionen werden unterstützt:
fillColor
- : Ein
UIColor
-Objekt, das die Innenfarbe des Kreises angibt. Die Standardeinstellung ist "transparent". strokeColor
- Ein
UIColor
-Objekt, mit dem die Farbe des Umrisses des Kreises festgelegt wird. Die Standardeinstellung istblackColor
. strokeWidth
- Die Umrissstärke des Kreises in Bildschirmpunkten. Der Standardfaktor ist 1. Die Linienstärke bleibt beim Zoomen der Karte unverändert.
Mit dem folgenden Snippet wird ein dicker roter Kreis mit einem halbtransparenten roten Innenraum hinzugefügt.
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;
Hohles Polygon erstellen
Sie können mehrere Pfade in einem einzelnen GMSPolygon
-Objekt kombinieren, um komplexe Formen wie gefüllte Ringe oder Ringe zu erstellen, bei denen innerhalb des Polygons polygonale Bereiche als separate Formen angezeigt werden. Komplexe Formen setzen sich aus mehreren Pfaden zusammen.
Erstellen Sie ein Polygon mit einem Pfad, der den größten vom Polygon abgedeckten Bereich angibt. Anschließend geben Sie die Eigenschaft holes
des Polygons als Array aus einem oder mehreren GMSPath
-Objekten an, die die Löcher innerhalb des Polygons definieren.
Wenn ein kleinerer Pfad vollständig vom größeren Pfad umschlossen ist, wirkt es so, als ob ein Teil des Polygons entfernt wurde.
Im folgenden Codebeispiel wird ein Polygon mit zwei Löchern erstellt:
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;