De nouveaux styles de cartes seront bientôt disponibles dans Google Maps Platform. Cette modification des styles de cartes inclut une nouvelle palette de couleurs par défaut, et améliore l'expérience utilisateur et l'usabilité des cartes. Tous les styles de cartes seront automatiquement mis à jour en mars 2025. Pour en savoir plus sur la disponibilité et la façon de s'inscrire plus tôt, consultez Nouveau style de carte pour Google Maps Platform.

Cette page a été traduite par l'API Cloud Translation.

Formes

Sélectionnez une plate-forme : Android iOS JavaScript

Le SDK Maps pour iOS vous permet d'ajouter des formes à vos Google Maps. Les formes suivantes sont prises en charge :

Une polyligne est une série de segments de ligne connectés qui peuvent former n’importe quelle forme et vous pouvez l'utiliser pour marquer des trajets et des itinéraires sur la carte.
Un polygone est une forme fermée qui peut être utilisée pour marquer des zones sur la carte.
Un cercle est une projection géographique précise d'un cercle sur le globe terrestre sur la surface de l'écran.

Vous pouvez modifier l'apparence de chaque forme de nombreuses façons.

Polylignes

Les polylignes vous permettent de dessiner des lignes sur la carte. Un GMSPolyline représente une séquence ordonnée de lieux, affichés sous la forme d'une série segments de ligne. Vous pouvez définir la couleur d'une polyligne avec GMSStrokeStyle

Pour créer une polyligne, vous devez spécifier son tracé en créant une l'objet GMSMutablePath correspondant avec deux points ou plus. Chaque CLLocationCoordinate2D représente un point à la surface de la Terre. Courbe Des segments sont dessinés entre les points dans l'ordre dans lequel vous les avez ajoutés. dans le chemin d'accès. Vous pouvez ajouter des points au tracé à l'aide de la commande 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];

Ajouter une polyligne

Créez un objet GMSMutablePath.
Définissez les points du tracé à l'aide de la commande addCoordinate: ou addLatitude:longitude:.
Instanciez un nouvel objet GMSPolyline en utilisant le chemin d'accès comme .
Définissez d'autres propriétés, telles que strokeWidth et strokeColor, si nécessaire.
Définissez la propriété map de GMSPolyline.
La polyligne apparaît sur la carte.

L'extrait de code suivant ajoute un rectangle à une carte :

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;

Polyligne rectangulaire

Supprimer une polyligne

Vous pouvez supprimer une polyligne de la carte en définissant les map de votre GMSPolyline sur nil. Vous pouvez également supprimer toutes les superpositions (y compris polylignes et autres formes) sur la carte en appelant la méthode GMSMapView clear.

Swift

mapView.clear()

Objective-C

[mapView clear];

Personnaliser une polyligne

L'objet GMSPolyline fournit plusieurs propriétés à contrôler l'apparence de la ligne. Il prend en charge les options suivantes :

strokeWidth: Largeur de la ligne entière, en points d'écran. La valeur par défaut est 1. La largeur n'est pas mise à l'échelle lorsque l'utilisateur fait un zoom sur la carte.
geodesic: Lorsque la valeur est YES, le bord de la polyligne est affiché en tant que géodésique. Segments géodésiques suivre le tracé le plus court à la surface de la Terre apparaissent sous forme de lignes courbes sur une carte présentant une projection de Mercator. Non géodésique des segments sont tracés sous forme de lignes droites sur la carte. La valeur par défaut est NO.
spans: Permet de spécifier la couleur d'un ou de plusieurs segments d'une polyligne. La La propriété spans est un tableau de GMSStyleSpan d'objets. Il est préférable de définir la propriété spans changer la couleur d'une polyligne.
strokeColor: : objet UIColor spécifiant la couleur de la polyligne. La valeur par défaut est blueColor. Propriété strokeColor est ignoré si spans est défini.

L'extrait de code suivant ajoute une polyligne épaisse de Melbourne à Perth, avec l'interpolation géodésique.

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;

Pour modifier une polyligne après l'avoir ajoutée à la carte, veillez à conserver l'objet GMSPolyline.

Swift

polyline.strokeColor = .blue

Objective-C

polyline.strokeColor = [UIColor blueColor];

Modifier la couleur d'une polyligne

Les polylignes sont dessinées sous la forme d'une série de segments sur la carte. Vous pouvez modifier la couleur des segments individuels, ou la ligne entière, avec la propriété spans. Alors que cette propriété vous permet de contrôler précisément la couleur d'une polyligne, vous pouvez appliquer un style unique à l'ensemble ligne.

L'extrait ci-dessous utilise la méthode spanWithColor: pour modifier la couleur du la ligne entière en rouge.

Swift

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

Objective-C

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

Si vous avez déjà accès à un GMSStrokeStyle vous pouvez utiliser la méthode 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]];

Avant la version 1.7 du SDK Maps pour iOS, la propriété unique strokeColor était disponible pour définir toute la couleur d'un GMSPolyline La propriété spans est prioritaire sur strokeColor

Swift

polyline.strokeColor = .red

Objective-C

polyline.strokeColor = [UIColor redColor];

Styles

Si votre application applique la même couleur de trait plusieurs fois, cela peut s'avérer utile pour définir un style réutilisable. Les styles de polyligne sont spécifiés à l'aide de la propriété objet GMSStrokeStyle. Un style de trait peut être un trait plein couleur ou un dégradé d'une couleur à une autre. Une fois que vous avez créé un vous pouvez l'appliquer à un GMSStyleSpan avec la 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];

Le style d'un span se poursuivra jusqu'à la fin de la polyligne ou jusqu'à ce qu'un nouveau est défini. Vous pouvez modifier la couleur de la ligne entière en définissant spans d'une polyligne à un seul élément GMSStyleSpan. Exemple : montre comment appliquer un dégradé sur toute la longueur de la polyligne.

Swift

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

Objective-C

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

Modification de la couleur de segments de ligne individuels

Vous pouvez appliquer un style à chaque segment de la polyligne individuellement. en créant un tableau d'objets GMSStyleSpan et en transmettant cette à la propriété spans. Par défaut, chaque élément du tableau définit la couleur le segment de ligne correspondant. S'il y a plus d'éléments dans le tableau que segments sur la ligne, les éléments superflus sont ignorés. S'il y en a moins du tableau, l'élément GMSStyleSpan final décrit le pour le reste de la ligne.

Vous pouvez utiliser des blocs de polylignes de couleur et/ou en dégradé pour indiquer les changements tout au long à votre polyligne, comme l'altitude ou la vitesse. L'extrait de code ci-dessous définit la couleur les deux premiers segments d'une polyligne en rouge, et le reste de la ligne du rouge au jaune.

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

Vous pouvez utiliser la méthode spanWithStyle:segments: pour définir le style de plusieurs à la fois. Par exemple, le code suivant équivaut au code ci-dessus. La longueur du segment du dernier GMSStyleSpan est toujours ignorée. car le style est utilisé pour décrire le reste de la ligne.

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

Segments fractionnaires

Les segments peuvent aussi être spécifiés par une valeur fractionnaire. Le style est alors appliqué au nombre fractionnaire de segments, ce qui peut entraîner une division segment. Chaque GMSStyleSpan commence immédiatement après la la couleur précédente: dans l'exemple ci-dessous, la couleur grise commence de 1⁄2 à sur le deuxième segment et continuer jusqu'à la moitié jusqu'au troisième.

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

Ajouter un motif de couleurs répétitif à une polyligne

Si vous souhaitez ajouter un motif à une polyligne, vous pouvez utiliser les GMSStyleSpans dans GMSGeometryUtils. La La méthode GMSStyleSpans accepte deux tableaux qui définissent un motif répétitif. Un tableau définit les styles qui doivent être répétés, et l'autre définit le l'intervalle de répétition. En les combinant, vous pouvez créer un modèle appliqué à n'importe quelle polyligne, indépendamment de sa longueur ou du nombre de segments disponibles.

Par exemple, l'extrait de code ci-dessous définit une polyligne avec un bloc noir et blanc modèle en alternance. Ses longueurs sont traitées comme des mètres le long d'une ligne graduée (dans Mercator, il s'agit d'une ligne droite), car le type est spécifié comme 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);

Polylignes estampillées en sprites

Les polylignes avec estampes en sprites vous permettent de créer une polyligne à l'aide d'un bitmap qui se répète de votre choix. Les formes s'affichent avec un trait clair en arrière-plan, mais le tampon ne sont pas tronqués autour des angles des lignes. Ils sont donc utiles dans les situations suivantes : points pour illustrer l'itinéraire à pied.

Polyligne avec motif de sprite

Vous pouvez utiliser cette fonctionnalité avec GMSSpriteStyle et la configurer comme tampon à l'aide de la propriété stampStyle du 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;

Polylignes texturées à motif

Les polylignes à motif texturé vous permettent de créer une polyligne à l’aide d’une propriété ou la texture de votre choix. Les formes peuvent être affichées avec une couleur claire, unie ou un dégradé un trait d'arrière-plan. La texture est redimensionnée en fonction des niveaux de zoom. Images à la fin de fin ou de début de trajets ou de points de tracé sont tronqués à un niveau de zoom donné et des niveaux de service.

Polyligne texturée

Vous pouvez utiliser cette fonctionnalité avec GMSTextureStyle et les paramètres comme tampon en utilisant la propriété stampStyle du 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;

Fonctionnalités de la carte

La propriété mapCapabilities sur GMSMapView ajoute le programmatique en vérifiant les éléments propres à la carte. Ceci est utile pour savoir si certains éléments capabilities de carte sont disponibles avant d'appeler des API spécifiques. Ce détermine si la vue de la carte est compatible avec les polylignes estampées en sprites.

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;

Ce modèle vous permet de vous abonner aux modifications et de réagir aux mises à jour avec votre carte l'état de la vue. Vous pouvez également implémenter didChangeMapCapabilities sur GMSMapViewDelegate pour recevoir des informations sur la fonctionnalité la disponibilité.

Polygones

Les polygones sont similaires aux polylignes dans la mesure où ils sont constitués d’une série de les coordonnées géographiques dans une séquence ordonnée. Cependant, au lieu d'être ouvert, les polygones sont conçus pour définir des régions pleines au sein d'une boucle fermée. Les polygones sont défini dans le SDK Maps pour iOS par la GMSPolygon .

Vous pouvez ajouter un GMSPolygon à la carte de la même manière que vous ajoutez un GMSPolyline Spécifiez d'abord son chemin d'accès en créant un l'objet GMSMutablePath correspondant et y ajouter des points. Ces points forment le contour du polygone. Chaque CLLocationCoordinate2D qui représente un point à la surface de la Terre. Des segments de ligne sont tracés entre en fonction de l'ordre dans lequel vous les ajoutez au tracé.

Ajouter un polygone

Créez un objet GMSMutablePath.
Définissez les points du tracé à l'aide de la commande addCoordinate: ou addLatitude:longitude:. Ces points forment le contour du d'un polygone.
Instanciez un nouvel objet GMSPolygon en utilisant le chemin d'accès comme .
Définissez d'autres propriétés, telles que strokeWidth, strokeColor et fillColor. comme vous le souhaitez.
Attribuez le polygone à un objet GMSMapView en définissant la GMSPolygon.map.
Le polygone s'affiche sur la carte.

L'extrait de code suivant ajoute un rectangle à une carte :

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;

Vous pouvez personnaliser l'apparence du polygone avant de l'ajouter à la carte et une fois qu'il a été ajouté à la carte.

Supprimer un polygone

Supprimer un polygone en définissant sa propriété GMSPolygon.map sur nil et en détachant le layer de son parent.

Swift

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

Objective-C

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

Cercles

En plus de la classe générique GMSPolygon, Le SDK Maps pour iOS inclut aussi GMSCircle, ce qui vous permet pour dessiner des cercles à la surface de la Terre.

Pour construire un cercle, vous devez spécifier les deux propriétés suivantes :

position en tant que CLLocationCoordinate2D
radius en mètres

Un cercle est ensuite défini comme étant l'ensemble de tous les points de la surface de la Terre, à radius mètres du center donné. En raison de la façon dont le La projection de Mercator utilisée par l'API Google Maps génère une sphère sur une surface plane, celle-ci apparaît sous la forme d'un cercle presque parfait sur la carte lorsqu'elle est située à proximité l'équateur, et apparaît de moins en moins circulaire (à l'écran) comme le cercle s'éloigne de l'équateur.

Ajouter un cercle

L'extrait de code suivant ajoute un cercle à la carte :

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;

Vous pouvez personnaliser l'aspect du cercle avant de l'ajouter à la carte. et une fois qu'il a été ajouté à la carte.

Personnaliser un cercle

Vous pouvez spécifier des couleurs et des épaisseurs de trait personnalisées en modifiant les propriétés GMSCircle Il prend en charge les options suivantes :

fillColor: : objet UIColor spécifiant la couleur intérieure du cercle. La valeur par défaut est transparente.
strokeColor: : objet UIColor spécifiant la couleur du cercle. de la conception. La valeur par défaut est blackColor.
strokeWidth: Épaisseur du contour du cercle, en points d'écran. La valeur par défaut est 1. L'épaisseur n'est pas mise à l'échelle lorsque l'utilisateur effectue un zoom sur la carte.

L'extrait de code suivant ajoute un cercle rouge épais avec un rouge semi-transparent à l'intérieur.

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;

Créer un polygone creux

Vous pouvez combiner plusieurs chemins d'accès dans un seul objet GMSPolygon pour : créer des formes complexes, telles que des anneaux pleins ou des beignets (où des zones polygonales apparaissent à l'intérieur du polygone sous forme de formes distinctes). Les formes complexes sont la composition de plusieurs chemins.

Créez un polygone comportant un tracé spécifiant la plus grande zone couverte par le d'un polygone. Spécifiez ensuite la propriété holes du polygone en tant que tableau de un ou d'autres objets GMSPath, qui définissent les trous à l'intérieur du polygone.

Si un tracé plus petit est entièrement englobé par un tracé plus grand, on a l'impression qu'un morceau du polygone a été supprimé.

L'échantillon de code suivant crée un polygone avec deux trous :

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;