Forme

Maps SDK for iOS offre vari modi per aggiungere forme alle mappe. Sono supportate le seguenti forme:

• Una polilinea è una serie di segmenti di linea collegati che possono formare qualsiasi forma e che possono essere utilizzati per contrassegnare percorsi e percorsi sulla mappa.
• Un poligono è una forma chiusa che può essere utilizzata per contrassegnare aree sulla mappa.
• Un cerchio è la proiezione geograficamente accurata di un cerchio sulla superficie terrestre.

Puoi modificare l'aspetto di ogni forma in diversi modi.

Polilinee

Le polilinee consentono di tracciare linee sulla mappa. Un oggetto GMSPolyline rappresenta una sequenza ordinata di posizioni, visualizzate come una serie di segmenti di linea. Puoi impostare il colore di una polilinea con GMSStrokeStyle.

Per creare una polilinea, devi specificarne il percorso creando un oggetto GMSMutablePath corrispondente con due o più punti. Ogni CLLocationCoordinate2D rappresenta un punto sulla superficie terrestre. I segmenti di linea vengono tracciati tra i punti in base all'ordine in cui li aggiungi al percorso. Puoi aggiungere punti al percorso con i metodi addCoordinate: o addLatitude:longitude:.

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)
      

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

Aggiunta di una polilinea

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

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
      

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;
      

Rimozione di una polilinea

Puoi rimuovere una polilinea dalla mappa impostando la proprietà map di GMSPolyline su nil. In alternativa, puoi rimuovere tutti gli overlay (comprese polilinee e altre forme) dalla mappa chiamando il metodo GMSMapView clear.

mapView.clear()
      

[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 schermo. Il valore predefinito è 1. La larghezza non viene ridimensionata quando la mappa viene ingrandita.

geodesic

Quando YES, esegui il rendering di questo bordo della polilinea come una geodetica. I segmenti geodetici seguono il percorso più breve lungo la superficie terrestre e possono apparire come linee curve su una mappa con una proiezione di Mercatore. I segmenti non geodetici sono tracciati sulla mappa come linee rette. Il valore predefinito è NO.

spans

utilizzato per specificare il colore di uno o più segmenti di una polilinea. La proprietà spans è un array di oggetti GMSStyleSpan. L'impostazione della proprietà spans è il modo preferito per modificare il colore di una polilinea.

strokeColor

Un oggetto UIColor che specifica il colore della polilinea. Il valore predefinito è blueColor. La proprietà strokeColor viene ignorata se viene impostato spans.

Lo snippet riportato di seguito aggiunge una spessa polilinea da Melbourne a Perth, con interpolazione geodetica.

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
      

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, assicurati di mantenere l'oggetto GMSPolyline.

polyline.strokeColor = .blue
      

polyline.strokeColor = [UIColor blueColor];
      

Modifica del colore di una polilinea

Le polilinee sono tracciate sulla mappa come serie di segmenti. Puoi modificare il colore di singoli segmenti o dell'intera linea con la proprietà spans. Sebbene questa proprietà offra un controllo dettagliato sulla colorazione di una polilinea, sono disponibili diverse comodità che consentono di applicare un singolo stile all'intera linea.

Lo snippet riportato di seguito utilizza il metodo spanWithColor: per modificare in rosso il colore dell'intera linea.

polyline.spans = [GMSStyleSpan(color: .red)]
      

polyline.spans = @[[GMSStyleSpan spanWithColor:[UIColor redColor]]];
      

In alternativa, se hai già accesso a un oggetto GMSStrokeStyle, puoi utilizzare il metodo spanWithStyle:.

let solidRed = GMSStrokeStyle.solidColor(.red)
polyline.spans = [GMSStyleSpan(style: solidRed)]
      

GMSStrokeStyle *solidRed = [GMSStrokeStyle solidColor:[UIColor redColor]];
polyline.spans = @[[GMSStyleSpan spanWithStyle:solidRed]];
      

Prima della versione 1.7 dell'SDK Maps per iOS, era disponibile la singola proprietà strokeColor per impostare l'intero colore di GMSPolyline. La proprietà spans ha la precedenza sulla proprietà strokeColor.

polyline.strokeColor = .red
      

polyline.strokeColor = [UIColor redColor];
      

Stili

Se la tua app applica più volte lo stesso colore del tratto, potrebbe essere utile definire uno stile riutilizzabile. Gli stili della polilinea vengono specificati utilizzando l'oggetto GMSStrokeStyle. Uno stile del tratto può essere un colore a tinta unita o un gradiente da un colore all'altro. Dopo aver creato uno stile, puoi applicarlo a una GMSStyleSpan con il metodo spanWithStyle:.

// 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)
      

// 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 span continuerà fino alla fine della polilinea o fino a quando non verrà impostato un nuovo stile. Puoi modificare il colore dell'intera linea impostando la proprietà spans di una polilinea su un singolo GMSStyleSpan. L'esempio mostra come applicare un gradiente sull'intera lunghezza della polilinea.

polyline.spans = [GMSStyleSpan(style: redYellow)]
      

polyline.spans = @[[GMSStyleSpan spanWithStyle:redYellow]];
      

Modifica del colore di singoli segmenti di linea

Se vuoi applicare uno stile individuale a ogni segmento della polilinea, puoi creare un array di oggetti GMSStyleSpan e trasmetterlo alla proprietà spans. Per impostazione predefinita, ogni elemento nell'array imposta il colore del segmento pubblicitario corrispondente. Se l'array contiene più elementi rispetto ai segmenti nella riga, gli elementi aggiuntivi vengono ignorati. Se l'array contiene meno elementi, l'intestazione GMSStyleSpan finale descrive il colore per il resto della riga.

Puoi utilizzare blocchi di polilinee di colore e/o gradiente per indicare i cambiamenti lungo la polilinea, ad esempio l'altitudine o la velocità. Lo snippet riportato di seguito imposta il colore dei primi due segmenti di una polilinea su rosso, mentre il resto della linea è un gradiente dal rosso al giallo.

polyline.spans = [
  GMSStyleSpan(style: solidRed),
  GMSStyleSpan(style: solidRed),
  GMSStyleSpan(style: redYellow)
]
      

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 codice seguente è equivalente a quello riportato sopra. La lunghezza del segmento dell'elemento GMSStyleSpan finale viene sempre ignorata poiché lo stile viene utilizzato per descrivere il resto della linea.

polyline.spans = [
  GMSStyleSpan(style: solidRed, segments:2),
  GMSStyleSpan(style: redYellow, segments:10)
]
      

polyline.spans = @[[GMSStyleSpan spanWithStyle:solidRed segments:2],
                   [GMSStyleSpan spanWithStyle:redYellow segments:10]];
      

Segmenti frazionari

I segmenti possono essere specificati anche come valore frazionario. Questo applicherà lo stile al numero frazionario di segmenti, causando potenzialmente una suddivisione in un singolo segmento. Ciascun GMSStyleSpan inizia immediatamente dopo quello precedente: nell'esempio seguente, il colore grigio inizia da metà fino al secondo segmento e continua fino a metà per il terzo segmento.

polyline.spans = [
  GMSStyleSpan(style: solidRed, segments: 2.5),
  GMSStyleSpan(color: .gray),
  GMSStyleSpan(color: .purple, segments: 0.75),
  GMSStyleSpan(style: redYellow)
]
      

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 colore ripetuto a una polilinea

Se vuoi aggiungere un pattern a una polilinea, puoi utilizzare il metodo dell'utilità GMSStyleSpans in GMSGeometryUtils. Il metodo GMSStyleSpans accetta due array che definiscono un pattern di ripetizione. Un array imposta gli stili da ripetere, l'altro definisce l'intervallo di ripetizione. Se utilizzati insieme, puoi creare un pattern che può essere applicato 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 pattern alternato in bianco e nero. Le sue lunghezze vengono trattate come metri lungo una linea del pollice (in Mercator, questa è una linea retta) poiché il tipo è specificato come kGMSLengthRhumb.

let styles = [
  GMSStrokeStyle.solidColor(.white),
  GMSStrokeStyle.solidColor(.black)
]
let lengths: [NSNumber] = [100000, 50000]
polyline.spans = GMSStyleSpans(
  polyline.path!,
  styles,
  lengths,
  GMSLengthKind.rhumb
)
      

NSArray *styles = @[[GMSStrokeStyle solidColor:[UIColor whiteColor]],
                    [GMSStrokeStyle solidColor:[UIColor blackColor]]];
NSArray *lengths = @[@100000, @50000];
polyline.spans = GMSStyleSpans(polyline.path, styles, lengths, kGMSLengthRhumb);
      

Polilinee con stampa sprite

Le polilinee stampate sprite consentono di creare una polilinea utilizzando un'immagine bitmap ricorrente di tua scelta. Le forme vengono visualizzate con un tratto di sfondo chiaro, ma il timbro non viene troncato intorno agli angoli delle linee, il che le rende utili in situazioni come i puntini per illustrare le indicazioni a piedi.

Puoi utilizzare questa funzionalità utilizzando GMSSpriteStyle e impostandola come bollino utilizzando la proprietà stampStyle di GMSStrokeStyle.

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
      

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

Le polilinee con stampa delle texture consentono di creare una polilinea utilizzando una trama ripetuta a tua scelta. Le forme possono essere visualizzate con tratto di sfondo chiaro, a tinta unita o a gradiente. La texture si ridimensiona al variare dei livelli di zoom. Le immagini alla fine o all'inizio di percorsi o punti del percorso vengono troncate a determinati livelli di zoom.

Puoi utilizzare questa funzionalità utilizzando GMSTextureStyle e impostandola come bollino utilizzando la proprietà stampStyle di GMSStrokeStyle.

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
      

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 il controllo programmatico per funzionalità specifiche della mappa. Questo è utile per sapere se determinate mappe capabilities sono disponibili prima di chiamare API specifiche. Questa query determina se la visualizzazione mappa supporta le polilinee con stampa sprite.

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
      

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 reagire agli aggiornamenti con lo stato della visualizzazione mappa. Puoi anche implementare didChangeMapCapabilities su GMSMapViewDelegate per ricevere aggiornamenti sulla disponibilità delle funzionalità.

Poligoni

I poligoni sono simili alle polilinee in quanto sono costituiti da una serie di coordinate in una sequenza ordinata. Tuttavia, invece di essere aperti, i poligoni sono progettati per definire regioni solide all'interno di un ciclo chiuso. Nell'SDK Maps per iOS i poligoni vengono definiti dalla classe GMSPolygon.

Puoi aggiungere un elemento GMSPolygon alla mappa nello stesso modo in cui aggiungi un GMSPolyline. Per prima cosa, specifica il percorso creando un oggetto GMSMutablePath corrispondente e aggiungendo punti all'oggetto. Questi punti formano il contorno del poligono. Ogni CLLocationCoordinate2D rappresenta un punto sulla superficie terrestre. I segmenti di linea vengono 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 il contorno del poligono.
3. Crea l'istanza di un nuovo oggetto GMSPolygon utilizzando il percorso come argomento.
4. Imposta altre proprietà, come strokeWidth, strokeColor e fillColor, come preferisci.
5. Assegna il poligono a un oggetto GMSMapView impostando la proprietà GMSPolygon.map.
6. Il poligono viene visualizzato sulla mappa.

Lo snippet di codice riportato di seguito consente di aggiungere un rettangolo a una mappa.

// 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
      

// 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 di aggiungerlo alla mappa sia dopo.

Rimozione di un poligono

Rimuovi un poligono impostando la relativa proprietà GMSPolygon.map su nil e scollegando layer dal relativo elemento principale.

 polygon.map = nil
 polygon.layer.removeFromSuperLayer()

 polygon.map = nil;
 [polygon.layer removeFromSuperlayer];
 

Cerchi

Oltre alla classe generica GMSPolygon, Maps SDK per iOS include anche GMSCircle, che consente di disegnare cerchi sulla superficie terrestre.

Per costruire 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 si trovano a radius metri di distanza dal center specificato. Per via del modo in cui la proiezione di merchandising utilizzata dall'API di Google Maps esegue il rendering di una sfera su una superficie piana, appare come un cerchio quasi perfetto sulla mappa quando si trova vicino all'equatore e appare sempre più non circolare (sullo schermo) quando il cerchio si allontana dall'equatore.

Aggiunta di una cerchia

Il seguente snippet di codice aggiunge un cerchio alla mappa:

let circleCenter = CLLocationCoordinate2D(latitude: 37.35, longitude: -122.0)
let circle = GMSCircle(position: circleCenter, radius: 1000)
circle.map = mapView
      

CLLocationCoordinate2D circleCenter = CLLocationCoordinate2DMake(37.35, -122.0);
GMSCircle *circle = [GMSCircle circleWithPosition:circleCenter
                                         radius:1000];
circle.map = mapView;
      

Puoi personalizzare l'aspetto del cerchio sia prima di aggiungerlo alla mappa sia dopo averlo aggiunto alla mappa.

Personalizzazione di una cerchia

Puoi specificare colori e spessori del tratto personalizzati modificando le proprietà di GMSCircle. Supporta le seguenti opzioni:

fillColor

Un oggetto UIColor che specifica il colore interno del cerchio. Il valore predefinito è trasparente.

strokeColor

Un oggetto UIColor che specifica il colore del contorno del cerchio. 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 la mappa viene ingrandita.

Lo snippet seguente aggiunge un cerchio rosso spesso con un interno rosso semitrasparente.

circle.fillColor = UIColor(red: 0.35, green: 0, blue: 0, alpha: 0.05)
circle.strokeColor = .red
circle.strokeWidth = 5
      

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, come anelli pieni o ciambelle, in cui le aree poligonali compaiono all'interno del poligono come forme separate. Le forme complesse sono la composizione di più percorsi.

Crea un poligono con un percorso che specifichi l'area più estesa coperta dal poligono. Quindi specifica la proprietà holes del poligono come un array di uno o più oggetti GMSPath, che definiscono i punti vuoti all'interno del poligono.

Se un percorso più piccolo è completamente racchiuso dal percorso più grande, potrebbe sembrare che una parte del poligono sia stata rimossa.

Il seguente esempio di codice crea un poligono con due fori:

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
      

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;