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 trajetos 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 addCoordinate:
ou
addLatitude:longitude:
.
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];
Como adicionar uma polilinha
- Crie um objeto
GMSMutablePath
. - Defina os pontos no caminho com o método
addCoordinate:
ouaddLatitude:longitude:
. - Instancie um novo objeto
GMSPolyline
usando o caminho como um . - Defina outras propriedades, como
strokeWidth
estrokeColor
, conforme necessário. - Defina a propriedade
map
doGMSPolyline
. - A polilinha é exibida no mapa.
O fragmento de código a seguir adiciona um retângulo a um mapa:
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;
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
.
Swift
mapView.clear()
Objective-C
[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 propriedadespans
para altera a cor de uma polilinha. strokeColor
- – Um objeto
UIColor
que especifica a cor da polilinha. O valor padrão éblueColor
. A propriedadestrokeColor
será ignorado sespans
for definido.
O snippet a seguir adiciona uma polilinha grossa de Melbourne a Perth, com interpolação geodésica.
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;
Para modificar uma polilinha depois de adicioná-la ao mapa, mantenha
o objeto GMSPolyline
.
Swift
polyline.strokeColor = .blue
Objective-C
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.
Swift
polyline.spans = [GMSStyleSpan(color: .red)]
Objective-C
polyline.spans = @[[GMSStyleSpan spanWithColor:[UIColor redColor]]];
Ou então, se você já tiver acesso a um GMSStrokeStyle
use o método 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]];
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
.
Swift
polyline.strokeColor = .red
Objective-C
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:
.
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];
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.
Swift
polyline.spans = [GMSStyleSpan(style: redYellow)]
Objective-C
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.
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]];
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.
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]];
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.
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]];
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. Uma
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
:
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);
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
.
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;
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
.
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;
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 ficam disponíveis antes da chamada de APIs específicas. Isso
determina se a visualização de mapa suporta polilinhas estampadas com 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;
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
- Crie um objeto
GMSMutablePath
. - Defina os pontos no caminho com o método
addCoordinate:
ouaddLatitude:longitude:
. Esses pontos formam o esboço do polígono. - Instancie um novo objeto
GMSPolygon
usando o caminho como um . - Defina outras propriedades, como
strokeWidth
,strokeColor
efillColor
. como quiser. - Atribua o polígono a um objeto
GMSMapView
definindo a propriedade propriedadeGMSPolygon.map
. - O polígono aparece no mapa.
O snippet de código a seguir adiciona um retângulo a um mapa.
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;
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.
Swift
polygon.map = nil polygon.layer.removeFromSuperLayer()
Objective-C
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
comoCLLocationCoordinate2D
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:
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;
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.
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;
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 é removido.
O exemplo de código a seguir cria um polígono com dois buracos:
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;