Formas

O SDK do Maps para iOS oferece várias maneiras de adicionar formas ao seu mapas. As seguintes formas são permitidas:

• Uma polilinha é uma série de segmentos de linha conectados que podem formar qualquer forma que você quer e pode ser usada para marcar caminhos e rotas no mapa.
• Um polígono é uma forma fechada que pode ser usada para marcar áreas o mapa.
• Um círculo é uma projeção geograficamente precisa de um círculo no superfície

É possível modificar a aparência de cada forma de diversas maneiras.

Polilinhas

As polilinhas permitem desenhar linhas no mapa. Uma GMSPolyline objeto representa uma sequência ordenada de localizações, exibida como uma série de segmentos de reta. Você pode definir a cor de uma polilinha com GMSStrokeStyle

Para criar uma polilinha, é necessário especificar seu caminho criando um objeto GMSMutablePath correspondente com dois ou mais pontos. Cada CLLocationCoordinate2D representa um ponto na superfície da Terra. Linhas os segmentos são desenhados entre pontos, de acordo com a ordem em que são adicionados ao caminho. É possível adicionar pontos ao caminho com o método addCoordinate: ou 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];
      

Como adicionar uma polilinha

1. Crie um objeto GMSMutablePath.
2. Defina os pontos no caminho com o método addCoordinate: ou addLatitude:longitude:.
3. Instancie um novo objeto GMSPolyline usando o caminho como um .
4. Defina outras propriedades, como strokeWidth e strokeColor, conforme necessário.
5. Defina a propriedade map do GMSPolyline.
6. A polilinha é exibida no mapa.

O fragmento de código a seguir adiciona um retângulo a um mapa:

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;
      

Como remover uma polilinha

Você pode remover uma polilinha do mapa definindo o map do GMSPolyline como nil. Como alternativa, você pode remover todas as sobreposições (incluindo polilinhas e outras formas) no mapa chamando o método GMSMapView clear.

mapView.clear()
      

[mapView clear];
      

Como personalizar uma polilinha

O objeto GMSPolyline fornece várias propriedades para controlar a aparência da linha. Ele oferece as seguintes opções:

strokeWidth

A largura de toda a linha, em pontos de tela. O padrão é 1. A largura não é dimensionada quando o mapa é ampliado.

geodesic

Quando YES, renderiza essa borda da polilinha como uma geodésica. Segmentos geodésicos seguir o caminho mais curto ao longo da superfície terrestre e pode aparecem como linhas curvas em um mapa com a projeção de Mercator. Não geodésica e segmentos são desenhados como linhas retas no mapa. O valor padrão é NO.

spans

: usado para especificar a cor de um ou mais segmentos de uma polilinha. A spans é uma matriz de GMSStyleSpan objetos. Recomendamos definir a propriedade spans para altera a cor de uma polilinha.

strokeColor

– Um objeto UIColor que especifica a cor da polilinha. O valor padrão é blueColor. A propriedade strokeColor será ignorado se spans for definido.

O snippet a seguir adiciona uma polilinha grossa de Melbourne a Perth, com interpolação geodésica.

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;
      

Para modificar uma polilinha depois de adicioná-la ao mapa, mantenha o objeto GMSPolyline.

polyline.strokeColor = .blue
      

polyline.strokeColor = [UIColor blueColor];
      

Alterar a cor de uma polilinha

As polilinhas são desenhadas como uma série de segmentos no mapa. Você pode alterar a cor de segmentos individuais ou a linha inteira com a propriedade spans. esta propriedade oferece controle detalhado sobre a cor de uma polilinha, há várias conveniências que permitem aplicar um único estilo ao linha

O snippet abaixo usa o método spanWithColor: para mudar a cor do a linha inteira em vermelho.

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

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

Ou então, se você já tiver acesso a um GMSStrokeStyle use o método spanWithStyle:.

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

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

Antes da versão 1.7 do SDK do Maps para iOS, a propriedade única strokeColor estava disponível para definir a cor inteira de um GMSPolyline. A propriedade spans tem precedência strokeColor.

polyline.strokeColor = .red
      

polyline.strokeColor = [UIColor redColor];
      

Estilos

Se o app aplicar a mesma cor do traço várias vezes, isso pode ser útil para definir um estilo reutilizável. Os estilos de polilinha são especificados usando o Objeto GMSStrokeStyle. Um estilo de traço pode ser uma linha cor ou gradiente de uma cor para outra. Depois de criar poderá aplicá-lo a uma GMSStyleSpan com o 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];
      

O estilo de span continuará até o fim da polilinha ou até que uma nova está definido. Você pode mudar a cor da linha inteira definindo a spans propriedade de uma polilinha em um único GMSStyleSpan. O exemplo demonstra como aplicar um gradiente em toda a extensão da polilinha.

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

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

Alterar a cor de segmentos de linha individuais

Se você quiser estilizar cada segmento da polilinha individualmente, faça isso criando uma matriz de objetos GMSStyleSpan e transmitindo essa à propriedade spans. Por padrão, cada item na matriz define a cor do o segmento de reta correspondente. Se há mais elementos na matriz do que na linha, os elementos extras serão ignorados. Se houver menos na matriz, o GMSStyleSpan final descreve os cor para o restante da linha.

Você pode usar blocos de cor e/ou polilinhas em gradiente para indicar mudanças ao longo sua polilinha, como elevação ou velocidade. O snippet abaixo define a cor do os dois primeiros segmentos de uma polilinha em vermelho, e o restante da linha é uma de vermelho para amarelo.

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

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

Você pode usar o método spanWithStyle:segments: para definir o estilo de vários segmentos de uma só vez. Por exemplo, o código a seguir é equivalente ao código acima. O tamanho do trecho do GMSStyleSpan final é sempre ignorado. já que o estilo é usado para descrever o restante da linha.

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

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

Segmentos fracionários

Os segmentos também podem ser especificados como um valor fracionário. Isso aplicará o estilo ao número fracionário de segmentos, o que pode causar uma divisão em um único um segmento de público-alvo. Cada GMSStyleSpan começa imediatamente após a anterior: no exemplo abaixo, a cor cinza começa de 1⁄2 a no segundo segmento e continua na metade do terceiro 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]];
      

Como adicionar um padrão de cores repetido a uma polilinha

Para adicionar um padrão a uma polilinha, use o Método utilitário GMSStyleSpans em GMSGeometryUtils. A O método GMSStyleSpans aceita duas matrizes que definem um padrão de repetição. Um define os estilos que devem ser repetidos, e a outra define os estilos intervalo de repetição. Usados juntos, você pode criar um padrão que pode ser aplicados a qualquer polilinha, independentemente do tamanho ou do número de segmentos disponíveis.

Por exemplo, o snippet de código abaixo define uma polilinha com uma cor preta e branca padrão alternado. Seus comprimentos são tratados como metros ao longo de uma linha de rhumb (em Mercator, esta é uma linha reta), já que o tipo é especificado como 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);
      

Polilinhas estampadas com sprite

As polilinhas estampadas com sprite permitem que você crie uma polilinha usando um bitmap repetido imagem de sua escolha. As formas aparecem com um traço de fundo claro, mas o selo não ficam truncados nos cantos das linhas, o que os torna úteis em situações como pontos para ilustrar as rotas a pé.

Você pode usar esse recurso com GMSSpriteStyle e defini-lo como o carimbo usando stampStyle da 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;
      

Polilinhas estampadas com textura

As polilinhas estampadas com textura permitem que você crie uma polilinha usando um textura de sua escolha. As formas podem ser mostradas com cores claras e sólidas ou gradientes traço do plano de fundo. A textura é redimensionada conforme os níveis de zoom mudam. Imagens no final de fim ou início de caminhos ou pontos de caminho ficam truncados com determinado zoom níveis

Você pode usar esse recurso com GMSTextureStyle e definindo como o carimbo usando stampStyle do 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;
      

Recursos do mapa

A propriedade mapCapabilities em GMSMapView adiciona conteúdo programático verificação de elementos específicos do mapa. Isso é útil quando queremos saber se alguns capabilities do mapa estão disponíveis antes de chamar APIs específicas. Isso determina se a visualização de mapa suporta polilinhas estampadas com 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;
      

Esse padrão permite que você se inscreva para receber mudanças e reagir a elas com seu mapa o estado de visualização dele. Também é possível implementar didChangeMapCapabilities GMSMapViewDelegate para receber atualizações sobre recursos disponibilidade.

Polígonos

Os polígonos são parecidos com as polilinhas, pois consistem em uma série de coordenadas em uma sequência ordenada. No entanto, em vez de serem abertas, polígonos são projetados para definir regiões sólidas dentro de um circuito fechado. Os polígonos são definido no SDK do Maps para iOS pelo GMSPolygon .

Você pode adicionar uma GMSPolygon ao mapa da mesma forma que adiciona uma GMSPolyline. Primeiro, especifique o caminho criando uma objeto GMSMutablePath correspondente e adicionar pontos a ele. Esses pontos formam o contorno do polígono. Cada CLLocationCoordinate2D representa um ponto na superfície da Terra. Segmentos de reta são desenhados entre de acordo com a ordem em que foram adicionados ao caminho.

Adicionar um polígono

1. Crie um objeto GMSMutablePath.
2. Defina os pontos no caminho com o método addCoordinate: ou addLatitude:longitude:. Esses pontos formam o esboço do polígono.
3. Instancie um novo objeto GMSPolygon usando o caminho como um .
4. Defina outras propriedades, como strokeWidth, strokeColor e fillColor. como quiser.
5. Atribua o polígono a um objeto GMSMapView definindo a propriedade propriedade GMSPolygon.map.
6. O polígono aparece no mapa.

O snippet de código a seguir adiciona um retângulo a um mapa.

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

Você pode personalizar a aparência do polígono antes de adicioná-lo ao mapa e após adicioná-lo ao mapa.

Como remover um polígono

Remova um polígono definindo a propriedade GMSPolygon.map como nil e removendo o layer do pai.

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

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

Círculos

Além da classe genérica GMSPolygon, a O SDK do Maps para iOS também inclui o GMSCircle, permitindo que você para desenhar círculos na superfície da Terra.

Para construir um círculo, é preciso especificar estas duas propriedades:

• position como CLLocationCoordinate2D
• radius em metros

Um círculo é, então, definido como sendo o conjunto de todos os pontos da superfície terrestre que ficam a radius metros de distância do center especificado. Devido à forma como o A projeção de Mercator usada pela API do Google Maps renderiza uma esfera em uma superfície plana, isso aparece como um círculo quase perfeito no mapa quando localizado perto do linha do Equador e aparece cada vez menos circular (na tela) como o círculo se afasta da linha do Equador.

Como adicionar um círculo

O fragmento de código a seguir adiciona um círculo ao mapa:

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;
      

Você pode personalizar a aparência do círculo antes de adicioná-lo ao mapa e após adicioná-lo ao mapa.

Personalizar um círculo

Você pode especificar cores e larguras de traço personalizadas modificando as propriedades de GMSCircle Ele oferece as seguintes opções:

fillColor

– Um objeto UIColor que especifica a cor interna do círculo É configurado por padrão como transparente.

strokeColor

– Um objeto UIColor que especifica a cor do círculo contorno. O valor padrão é blackColor.

strokeWidth

É a espessura do contorno do círculo, em pontos de tela. O padrão é 1. A espessura não é adequada à escala quando o zoom do mapa é aumentado.

O snippet a seguir adiciona um círculo vermelho espesso com um vermelho semitransparente interior.

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;
      

Como criar um polígono oco

Você pode combinar vários caminhos em um único objeto GMSPolygon para criam formas complexas, como anéis preenchidos, ou rosquinhas, onde as áreas poligonais aparecem dentro do polígono como formas separadas). Formas complexas são composição de vários caminhos.

Crie um polígono com um caminho que especifique a maior área coberta pelo polígono. Em seguida, especifique a propriedade holes do polígono como uma matriz de um ou mais objetos GMSPath, que definem os buracos dentro do polígono.

Se um caminho menor estiver totalmente delimitado pelo maior, parecerá que um pedaço do polígono foi removido.

O exemplo de código a seguir cria um polígono com dois buracos:

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;