Formas

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

• Uma polilinha é uma série de segmentos de linha conectados que pode criar qualquer forma desejada 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 na superfície do planeta.

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

Polilinhas

As polilinhas permitem desenhar linhas no mapa. Um objeto GMSPolyline representa uma sequência ordenada de locais, exibida como uma série de segmentos de linha. Defina a cor de uma polilinha com GMSStrokeStyle.

Para criar uma polilinha, é necessário especificar o caminho criando um objeto GMSMutablePath correspondente com dois ou mais pontos. Cada CLLocationCoordinate2D representa um ponto na superfície da Terra. Os segmentos da linha são desenhados entre os pontos de acordo com a ordem em que são adicionados ao caminho. Adicione pontos ao caminho com os métodos 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 os métodos addCoordinate: ou addLatitude:longitude:.
3. Instancie um novo objeto GMSPolyline usando o caminho como um argumento.
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

Para remover uma polilinha do mapa, defina a propriedade map da GMSPolyline como nil. Como alternativa, remova todas as sobreposições (inclusive polilinhas e outras formas) no mapa chamando o método clear GMSMapView.

mapView.clear()
      

[mapView clear];
      

Personalizar uma polilinha

O objeto GMSPolyline oferece 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 é alterada com a mudança do zoom do mapa.

geodesic

Quando YES, renderize essa margem de polilinha como uma geodésica. Os segmentos geodésicos seguem o menor caminho sobre a superfície do planeta e podem ser exibidos como linhas curvas em um mapa com projeção Mercator. Os segmentos não geodésicos 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 propriedade spans é uma matriz de objetos GMSStyleSpan. Definir a propriedade spans é a forma recomendada de mudar a cor de uma polilinha.

strokeColor

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

O snippet a seguir adiciona uma polilinha azul 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, não deixe de manter o objeto GMSPolyline.

polyline.strokeColor = .blue
      

polyline.strokeColor = [UIColor blueColor];
      

Como mudar a cor de uma polilinha

As polilinhas são desenhadas como uma série de segmentos no mapa. Você pode mudar a cor de segmentos individuais ou de toda a linha com a propriedade spans. Embora essa propriedade ofereça controle detalhado sobre a coloração de uma polilinha, há várias conveniências para aplicar um único estilo a toda a linha.

O snippet abaixo usa o método spanWithColor: para mudar a cor de toda a linha para vermelho.

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

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

Como alternativa, se você já tiver acesso a um objeto 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 toda a cor de um GMSPolyline. A propriedade spans tem precedência sobre strokeColor.

polyline.strokeColor = .red
      

polyline.strokeColor = [UIColor redColor];
      

Estilos

Se o app aplica a mesma cor de traço várias vezes, é útil definir um estilo reutilizável. Os estilos de polilinha são especificados usando o objeto GMSStrokeStyle. Um estilo de traço pode ser uma cor sólida ou um gradiente de uma cor para outra. Depois de criar um estilo, você pode aplicá-lo a um GMSStyleSpan com o método 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 um span continua até o fim da polilinha ou até que um novo estilo seja definido. É possível mudar a cor de toda a linha definindo a propriedade spans de uma polilinha como um único GMSStyleSpan. O exemplo demonstra como aplicar um gradiente em todo o comprimento da polilinha.

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

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

Como mudar a cor de segmentos de linha individuais

Para aplicar um estilo a cada segmento individual da polilinha, crie uma matriz de objetos GMSStyleSpan e transmita-a para a propriedade spans. Por padrão, cada item na matriz define a cor do segmento de linha correspondente. Se houver mais elementos na matriz que segmentos na linha, os elementos extras serão ignorados. Se houver menos elementos na matriz, o GMSStyleSpan final vai descrever a cor do restante da linha.

Use blocos de cor e/ou polilinhas com gradiente para indicar mudanças ao longo da polilinha, como um aumento de velocidade. O snippet abaixo define a cor dos dois primeiros segmentos de uma polilinha como vermelho, e o restante da linha é um gradiente 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]];
      

Use 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 comprimento do segmento do GMSStyleSpan final é sempre ignorado, porque 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. O estilo é aplicado ao número fracionário de segmentos, causando possivelmente uma divisão em um único segmento. Cada GMSStyleSpan começa imediatamente após o anterior. No exemplo abaixo, a cor cinza começa de ½ até o segundo segmento e continua até ½ no 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. O método GMSStyleSpans aceita duas matrizes que definem um padrão repetido. Uma matriz define os estilos a serem repetidos, e a outra define o intervalo de repetição. Usadas em conjunto, é possível criar um padrão que pode ser aplicado em qualquer polilinha, independentemente do comprimento ou do número de segmentos disponíveis.

Por exemplo, o snippet de código abaixo define uma polilinha com um padrão alternado preto e branco. Os comprimentos são tratados como metros em uma linha loxodrômica (na projeção Mercator, uma linha reta), porque 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 com estampa de sprite

As polilinhas estampadas permitem criar uma polilinha usando uma imagem de bitmap repetida de sua escolha. As formas aparecem com um traço de plano de fundo claro, mas o selo não é truncado nos cantos da linha, o que é útil em situações como pontos para ilustrar direções a pé.

É possível usar esse recurso com GMSSpriteStyle e defini-lo como o selo usando a propriedade 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 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 com estampa de textura

As polilinhas estampadas com textura permitem criar uma polilinha usando uma textura repetida de sua escolha. As formas podem ser mostradas com traço de plano de fundo claro, cor sólida ou gradiente. A textura é redimensionada conforme os níveis de zoom mudam. As imagens no início ou no fim de caminhos ou pontos de caminho são truncadas em determinados níveis de zoom.

É possível usar esse recurso com GMSTextureStyle e defini-lo como o selo usando a propriedade 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 a verificação programática de recursos específicos do mapa. Isso é útil quando você quer saber se determinados capabilities do mapa estão disponíveis antes de chamar APIs específicas. Essa consulta determina se a visualização do mapa oferece suporte a Sprite Stamped Polylines.

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 em mudanças e reaja a atualizações com o estado da visualização do mapa. Também é possível implementar didChangeMapCapabilities em GMSMapViewDelegate para receber atualizações sobre a disponibilidade do recurso.

Polígonos

Os polígonos são semelhantes às polilinhas. Ambos consistem em uma série de coordenadas em uma sequência ordenada. No entanto, em vez de abertos, os polígonos foram projetados para definir regiões sólidas em um loop fechado. Os polígonos são definidos no SDK do Maps para iOS pela classe GMSPolygon.

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

Adicionar um polígono

1. Crie um objeto GMSMutablePath.
2. Defina os pontos no caminho com os métodos addCoordinate: ou addLatitude:longitude:. Esses pontos formam o contorno do polígono.
3. Instancie um novo objeto GMSPolygon usando o caminho como um argumento.
4. Defina outras propriedades, como strokeWidth, strokeColor e fillColor, conforme desejado.
5. Atribua o polígono a um objeto GMSMapView definindo a 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 e depois de adicioná-lo ao mapa.

Como remover um polígono

Remova um polígono definindo a propriedade GMSPolygon.map como nil e desconectando 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, o SDK do Maps para iOS também inclui GMSCircle, permitindo que você desenha 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 a projeção de Mercator usada pela API Maps renderiza uma esfera em uma superfície plana, o círculo no mapa vai ser praticamente perfeito, quando localizado perto da Linha do Equador, e vai ficar cada vez menos circular à medida que se afastar da linha.

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 e depois de 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 interior do círculo. É configurado por padrão como transparente.

strokeColor

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

strokeWidth

A espessura do contorno do círculo, em pontos da 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 grosso com um interior vermelho semitransparente.

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

É possível combinar vários caminhos em um único objeto GMSPolygon para criar formas complexas, como anéis preenchidos ou roscas (em que as áreas poligonais são exibidas dentro do polígono como formas separadas). As formas complexas são a 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 no polígono.

Quando um caminho menor é totalmente incluído no caminho maior, parece que uma parte do polígono foi removida.

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;