Forme

Seleziona la piattaforma: Android iOS JavaScript

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

  1. Crea un oggetto GMSMutablePath.
  2. Imposta i punti nel percorso con i metodi addCoordinate: o addLatitude:longitude:.
  3. Crea un'istanza per un nuovo oggetto GMSPolyline utilizzando il percorso come .
  4. Imposta le altre proprietà, come strokeWidth e strokeColor, in base alle esigenze.
  5. Imposta la proprietà map di GMSPolyline.
  6. 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;

Una polilinea rettangolare

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 diverse proprietà per 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 ridimensionata quando si esegue lo zoom sulla mappa.
geodesic
Se YES, esegui il rendering di questo bordo del polilinea come geodetico. I segmenti geodetici seguono il percorso più breve lungo la superficie terrestre e possono essere visualizzati 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 è impostato spans.

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 un polilinea dopo averlo aggiunto alla mappa, assicurati di mantenere l'oggetto GMSPolyline.

Swift

polyline.strokeColor = .blue

Objective-C

polyline.strokeColor = [UIColor blueColor];

Modificare il colore di una polilinea

Le polilinee vengono 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 seguente utilizza il metodo spanWithColor: per impostare il colore dell'intera linea su 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 per 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 di tratto più volte, potresti trovare utile 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 vuoi applicare uno stile a ciascun segmento del polilinea singolarmente, puoi farlo creando un array di oggetti GMSStyleSpan e passandolo 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 polilinee colorate e/o con gradiente per indicare variazioni lungo la polilinea, ad esempio altitudine o 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'ultimo GMSStyleSpan viene sempre ignorata poiché 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 frazionati

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 pattern di 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 un polilinea con un motivo alternato bianco e nero. 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.

Una polilinea stampata con lo sprite

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 con texture stampata

Le polilinee stampate con texture ti consentono di creare una polilinea utilizzando una texture a tua scelta. Le forme possono essere mostrate con un tratto di sfondo chiaro, a tinta unita o con gradiente. La trama viene ridimensionata in base ai 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.

Una polilinea con texture

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à della 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 all'oggetto GMSMutablePath corrispondente e all'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

  1. Crea un oggetto GMSMutablePath.
  2. Imposta i punti nel percorso con i metodi addCoordinate: o addLatitude:longitude:. Questi punti formano lo schema poligono.
  3. Crea un'istanza per un nuovo oggetto GMSPolygon utilizzando il percorso come .
  4. Imposta altre proprietà, come strokeWidth, strokeColor e fillColor, in base alle tue esigenze.
  5. Assegna il poligono a un oggetto GMSMapView impostando la proprietà GMSPolygon.map.
  6. 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 sia prima che 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 le due proprietà seguenti:

  • position come CLLocationCoordinate2D.
  • 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, questo 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.

Personalizzare 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ù grande 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;