Maps SDK for iOS offre diversi modi per aggiungere forme al tuo mappe. Sono supportate le seguenti forme:
- Una polilinea è una serie di segmenti di linee collegate che possono formare qualsiasi forma che desideri e può essere utilizzata per contrassegnare i percorsi e i percorsi sulla mappa.
- Un poligono è una forma chiusa che può essere utilizzata per contrassegnare aree sulla mappa.
- Un cerchio è una proiezione geograficamente accurata di un cerchio sulla superficie terrestre superficie.
Esistono diversi modi per modificare l'aspetto di ogni forma.
Polilinee
Le polilinee ti consentono di tracciare linee sulla mappa. Un GMSPolyline
rappresenta una sequenza ordinata di posizioni, visualizzate come una serie di
segmenti di linee. Puoi impostare il colore di una polilinea con
GMSStrokeStyle
Per creare una polilinea, devi specificarne il percorso creando una
l'oggetto GMSMutablePath
corrispondente con due o più punti.
Ciascun CLLocationCoordinate2D
rappresenta un punto sulla superficie terrestre. A linee
i segmenti vengono tracciati tra i punti secondo l'ordine in cui li aggiungi
al percorso. Puoi aggiungere punti al percorso con l'addCoordinate:
o
addLatitude:longitude:
metodi.
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];
Aggiungere una polilinea
- Crea un oggetto
GMSMutablePath
. - Imposta i punti del percorso con
addCoordinate:
oaddLatitude:longitude:
metodi. - Crea un'istanza per un nuovo oggetto
GMSPolyline
utilizzando il percorso come . - Imposta le altre proprietà, come
strokeWidth
estrokeColor
, in base alle esigenze. - Imposta la proprietà
map
diGMSPolyline
. - La polilinea viene visualizzata sulla mappa.
Il seguente snippet di codice consente di aggiungere un rettangolo a una mappa:
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;
Rimuovere una polilinea
Puoi rimuovere una polilinea dalla mappa impostando il map
di GMSPolyline
a nil
. In alternativa, puoi rimuovere tutti gli overlay (inclusi
polilinee e altre forme) sulla mappa chiamando il GMSMapView
clear
.
Swift
mapView.clear()
Objective-C
[mapView clear];
Personalizzazione di una polilinea
L'oggetto GMSPolyline
fornisce varie proprietà che puoi controllare
l'aspetto della linea. Supporta le seguenti opzioni:
strokeWidth
- La larghezza dell'intera linea, in punti sullo schermo. Il valore predefinito è 1. La larghezza non viene ridimensionato quando la mappa viene ingrandita.
geodesic
-
Quando
YES
, esegui il rendering del bordo della polilinea come geodetica. Segmenti geodetici seguire il percorso più breve lungo la superficie terrestre e potrebbe Appaiono come linee curve su una mappa con una proiezione di Mercatore. Non geodetica i segmenti vengono disegnati come linee rette sulla mappa. Il valore predefinito èNO
. spans
- Utilizzato per specificare il colore di uno o più segmenti di una polilinea. La
La proprietà spans è un array di
GMSStyleSpan
di oggetti strutturati. È preferibile impostare la proprietàspans
per cambia il colore di una polilinea. strokeColor
- Un oggetto
UIColor
che specifica il colore della polilinea. Il valore predefinito èblueColor
. La proprietàstrokeColor
viene ignorato se è impostatospans
.
Lo snippet seguente aggiunge una polilinea spessa da Melbourne a Perth, con l'interpolazione geodetica.
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;
Per modificare una polilinea dopo averla aggiunta alla mappa, tieni premuto
l'oggetto GMSPolyline
.
Swift
polyline.strokeColor = .blue
Objective-C
polyline.strokeColor = [UIColor blueColor];
Modificare il colore di una polilinea
Le polilinee sono disegnate come una serie di segmenti sulla mappa. Puoi modificare il colore
di singoli segmenti o dell'intera linea con la proprietà spans
. Mentre
questa proprietà ti offre un controllo dettagliato
sulla colorazione di una polilinea,
esistono numerose funzionalità per applicare un singolo stile all'intero
dalla riga di comando.
Lo snippet riportato di seguito utilizza il metodo spanWithColor:
per modificare il colore dello
l'intera riga in rosso.
Swift
polyline.spans = [GMSStyleSpan(color: .red)]
Objective-C
polyline.spans = @[[GMSStyleSpan spanWithColor:[UIColor redColor]]];
In alternativa, se hai già accesso a un GMSStrokeStyle
, puoi utilizzare il metodo 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]];
Prima della versione 1.7 di Maps SDK for iOS, la singola proprietà
strokeColor
era disponibile per impostare l'intero colore di un
GMSPolyline
La proprietà spans
ha la precedenza sulla
strokeColor
.
Swift
polyline.strokeColor = .red
Objective-C
polyline.strokeColor = [UIColor redColor];
Stili
Se la tua app applica lo stesso colore del tratto più volte, potrebbe essere utile
per definire uno stile riutilizzabile. Gli stili di polilinea vengono specificati utilizzando
GMSStrokeStyle
. Uno stile del tratto può essere un solido
colore o una sfumatura da un colore a un altro. Una volta creata una
puoi applicarlo a una GMSStyleSpan
con
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];
Lo stile di un span
continuerà fino alla fine della polilinea o fino a quando
è impostato lo stile desiderato. Puoi modificare il colore dell'intera linea impostando il spans
di una polilinea a un singolo elemento GMSStyleSpan
L'esempio
mostra come applicare un gradiente su tutta la lunghezza della polilinea.
Swift
polyline.spans = [GMSStyleSpan(style: redYellow)]
Objective-C
polyline.spans = @[[GMSStyleSpan spanWithStyle:redYellow]];
Modifica del colore di singoli segmenti di linea
Se desideri definire uno stile individuale per ogni segmento della polilinea, puoi farlo
creando un array di oggetti GMSStyleSpan
e passando questo
alla proprietà spans
. Per impostazione predefinita, ogni elemento dell'array imposta il colore
il segmento di linea corrispondente. Se l'array contiene più elementi rispetto a
segmenti nella linea, gli elementi in più verranno ignorati. Se ce ne sono meno
nell'array, la colonna GMSStyleSpan
finale descrive
per il resto della linea.
Puoi utilizzare blocchi di colore e/o polilinee a gradiente per indicare le modifiche della polilinea, come l'elevazione o la velocità. Lo snippet riportato di seguito imposta il colore i primi due segmenti di una polilinea in rosso e il resto della linea sfumatura dal rosso al giallo.
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]];
Puoi utilizzare il metodo spanWithStyle:segments:
per impostare lo stile per più
segmenti contemporaneamente. Ad esempio, il seguente codice equivale al precedente.
La lunghezza del segmento dell'elemento GMSStyleSpan
finale viene sempre ignorata
perché lo stile viene utilizzato per descrivere il resto della riga.
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]];
Segmenti frazionari
I segmenti possono anche essere specificati come valore frazionario. Lo stile verrà applicato
al numero frazionario di segmenti, causando potenzialmente una suddivisione in un
in base al segmento. Ogni GMSStyleSpan
inizia immediatamente dopo
precedente: nell'esempio in basso, il colore grigio inizia da 1⁄2 a
il secondo segmento e continuare con la metà del terzo segmento.
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]];
Aggiunta di un motivo a colori ripetuto a una polilinea
Se vuoi aggiungere un motivo a una polilinea, puoi utilizzare lo
GMSStyleSpans
in GMSGeometryUtils
. La
Il metodo GMSStyleSpans
accetta due array che definiscono un pattern ricorrente. Uno.
imposta gli stili da ripetere, mentre l'altro definisce
intervallo di ripetizione. Utilizzate insieme, potete creare uno schema che
applicata su qualsiasi polilinea, indipendentemente dalla lunghezza o dal numero di segmenti
disponibili.
Ad esempio, lo snippet di codice riportato di seguito definisce una polilinea con un'intestazione in bianco e nero
schema alternato. Le sue lunghezze sono trattate come metri lungo una linea a rombo (in
Mercator, questa è una linea retta) perché il tipo è specificato come
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);
Polilinee stampate sprite
Le polilinee tracciate sprite ti consentono di creare una polilinea utilizzando una bitmap ripetuta. un'immagine a tua scelta. Le forme vengono mostrate con un tratto di sfondo chiaro, ma il timbro non viene troncato intorno agli angoli delle linee, il che li rende utili in situazioni quali punti per l'illustrazione delle indicazioni a piedi.
Puoi usare questa funzionalità usando GMSSpriteStyle
e impostandola
come timbro usando il stampStyle
di GMSStrokeStyle
proprietà.
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;
Polilinee stampate a trama
Le polilinee stampate con texture ti consentono di creare una polilinea utilizzando una texture a tua scelta. Le forme possono essere mostrate in colori chiari e a tinta unita o in una sfumatura tratto di sfondo. La texture si ridimensiona al variare dei livelli di zoom. Immagini alla fine della fine o dell'inizio dei percorsi o i punti dei percorsi vengono troncati a un determinato zoom diversi.
Puoi utilizzare questa funzionalità usando GMSTextureStyle
e le impostazioni
come timbro usando il stampStyle
di GMSStrokeStyle
proprietà.
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;
Funzionalità mappa
La proprietà mapCapabilities
su GMSMapView
aggiunge pubblicità programmatica
alla ricerca di elementi specifici della mappa. Questo è utile quando vuoi sapere se
alcune mappe capabilities
sono disponibili prima di chiamare API specifiche. Questo
determina se la visualizzazione mappa supporta le polilinee stampate 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;
Questo pattern ti consente di iscriverti alle modifiche e di reagire agli aggiornamenti con la tua mappa
stato di visualizzazione. Puoi anche implementare didChangeMapCapabilities
GMSMapViewDelegate
per ricevere aggiornamenti sulle funzionalità
la disponibilità del servizio.
Poligoni
I poligoni sono simili alle polilinee in quanto sono costituiti da una serie di
coordinate in una sequenza ordinata. Tuttavia, invece di essere open-ended,
i poligoni sono progettati per definire regioni solide all'interno di un anello chiuso. I poligoni sono
definita in Maps SDK per iOS da GMSPolygon
.
Puoi aggiungere un GMSPolygon
alla mappa nello stesso modo in cui aggiungi un
GMSPolyline
Per prima cosa, specifica il percorso creando un'immagine
l'oggetto GMSMutablePath
corrispondente e l'aggiunta di punti.
Questi punti formano il contorno del poligono. Ogni CLLocationCoordinate2D
rappresenta un punto sulla superficie terrestre. I segmenti sono tracciati tra
i punti in base all'ordine in cui li aggiungi al percorso.
Aggiungere un poligono
- Crea un oggetto
GMSMutablePath
. - Imposta i punti del percorso con
addCoordinate:
oaddLatitude:longitude:
metodi. Questi punti formano lo schema poligono. - Crea un'istanza per un nuovo oggetto
GMSPolygon
utilizzando il percorso come . - Imposta altre proprietà, come
strokeWidth
,strokeColor
efillColor
, in base alle tue esigenze. - Per assegnare il poligono a un oggetto
GMSMapView
, imposta il valoreGMSPolygon.map
proprietà. - Il poligono viene visualizzato sulla mappa.
Il seguente snippet di codice consente di aggiungere un rettangolo a una mappa.
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;
Puoi personalizzare l'aspetto del poligono prima di aggiungerlo alla mappa. dopo averlo aggiunto alla mappa.
Rimuovere un poligono
Per rimuovere un poligono, imposta la relativa proprietà GMSPolygon.map
su nil
e scollegando
layer
da quello principale.
Swift
polygon.map = nil polygon.layer.removeFromSuperLayer()
Objective-C
polygon.map = nil; [polygon.layer removeFromSuperlayer];
Cerchi
Oltre alla classe generica GMSPolygon
, la classe
Maps SDK per iOS include anche GMSCircle
, che consente
per disegnare cerchi sulla superficie terrestre.
Per creare un cerchio, devi specificare queste due proprietà:
position
comeCLLocationCoordinate2D
.radius
in metri.
Un cerchio è quindi definito come l'insieme di tutti i punti sulla superficie terrestre
che dista radius
metri dal center
specificato. Per via del modo in cui
La proiezione di Mercatore utilizzata dall'API di Google Maps mostra una sfera su una superficie piana,
appare come un cerchio quasi perfetto sulla mappa se si trova vicino al
equatore e appare sempre più non circolare (sullo schermo) mentre il cerchio
si allontana dall'equatore.
Aggiunta di una cerchia
Il seguente snippet di codice consente di aggiungere un cerchio alla mappa:
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;
Puoi personalizzare l'aspetto del cerchio prima di aggiungerlo alla mappa dopo averlo aggiunto alla mappa.
Personalizzazione di una cerchia
Puoi specificare colori e spessori del tratto personalizzati modificando le proprietà
GMSCircle
Supporta le seguenti opzioni:
fillColor
- Un oggetto
UIColor
che specifica il colore interno dell'elemento cerchio. Il valore predefinito è trasparente. strokeColor
- Un oggetto
UIColor
che specifica il colore del cerchio struttura. Il valore predefinito èblackColor
. strokeWidth
- Lo spessore del contorno del cerchio, in punti sullo schermo. Il valore predefinito è 1. Lo spessore non viene ridimensionato quando viene ingrandita la mappa.
Il seguente snippet aggiunge un cerchio rosso spesso con un rosso semitrasparente interno.
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;
Creazione di un poligono vuoto
Puoi combinare più percorsi in un singolo oggetto GMSPolygon
per
creare forme complesse, ad esempio anelli pieni o ciambelle (in cui le aree poligonali
vengono visualizzate all'interno del poligono come forme separate. Le forme complesse sono
di più percorsi.
Crea un poligono con un percorso che specifichi l'area più ampia coperta dal
poligono. A questo punto, specifica la proprietà holes
del poligono come un array di uno o
altri GMSPath
oggetti, che definiscono i fori all'interno del poligono.
Se un percorso più piccolo è completamente racchiuso in quello più grande, avrà l'aspetto di una porzione del poligono è stata rimossa.
Il seguente esempio di codice crea un poligono con due fori:
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;