Select platform: [Android](https://developers.google.com/maps/documentation/android-sdk/shapes.md.txt "View this page for the Android platform docs.") [iOS](https://developers.google.com/maps/documentation/ios-sdk/shapes.md.txt "View this page for the iOS platform docs.") [JavaScript](https://developers.google.com/maps/documentation/javascript/shapes.md.txt "View this page for the JavaScript platform docs.")
The Maps SDK for iOS offers various ways for you to add shapes to your
maps. The following shapes are supported:
- A polyline is a series of connected line segments that can form any shape you want and can be used to mark paths and routes on the map.
- A polygon is an enclosed shape that can be used to mark areas on the map.
- A circle is a geographically accurate projection of a circle on the Earth's surface.
You are able to modify the appearance of each shape in a number of ways.
## Polylines
Polylines allow you to draw lines on the map. A [`GMSPolyline`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSPolyline.md.txt)
object represents an ordered sequence of locations, displayed as a series of
line segments. You can set the color of a polyline with
[`GMSStrokeStyle`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSStrokeStyle.md.txt).
To create a polyline, you'll need to specify its path by creating a
corresponding [`GMSMutablePath`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSMutablePath.md.txt) object with two or more points.
Each `CLLocationCoordinate2D` represents a point on the Earth's surface. Line
segments are drawn between points according to the order in which you add them
to the path. You can add points to the path with the `addCoordinate:` or
`addLatitude:longitude:` methods.
### Swift
```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
```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];
```
### Adding a polyline
1. Create a [`GMSMutablePath`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSMutablePath.md.txt) object.
2. Set the points in the path with the `addCoordinate:` or `addLatitude:longitude:` methods.
3. Instantiate a new [`GMSPolyline`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSPolyline.md.txt) object using the path as an argument.
4. Set other properties, such as `strokeWidth` and `strokeColor`, as needed.
5. Set the `map` property of the `GMSPolyline`.
6. The polyline appears on the map.
The following code snippet adds a rectangle to a map:
### Swift
```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
```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;
```
### Removing a polyline
You can remove a polyline from the map by setting your `GMSPolyline`'s `map`
property to `nil`. Alternately, you can remove all of the overlays (including
polylines and other shapes) on the map by calling the [`GMSMapView`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSMapView.md.txt)
`clear` method.
### Swift
```swift
mapView.clear()
```
### Objective-C
```objective-c
[mapView clear];
```
### Customizing a polyline
The [`GMSPolyline`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSPolyline.md.txt) object provides several properties to control
the appearance of the line. It supports the following options:
`strokeWidth`
:
The width of the entire line, in screen points. Defaults to 1. The width
does not scale when the map is zoomed.
`geodesic`
:
When `YES`, render this polyline edge as a geodesic. Geodesic segments
follow the shortest path along the Earth's surface and may
appear as curved lines on a map with a Mercator projection. Non-geodesic
segments are drawn as straight lines on the map. Defaults to `NO`.
`spans`
: Used to specify the color of one or more segments of a polyline. The
spans property is an array of `GMSStyleSpan`
objects. Setting the `spans` property is the preferred way to
change the color of a polyline.
`strokeColor`
: A `UIColor` object specifying the color of the polyline.
Defaults to `blueColor`. The `strokeColor` property
is ignored if `spans` is set.
The following snippet adds a thick polyline from Melbourne to Perth, with
geodesic interpolation.
### Swift
```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
```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;
```
To modify a polyline after it has been added to the map, be sure to keep hold of
the [`GMSPolyline`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSPolyline.md.txt) object.
### Swift
```swift
polyline.strokeColor = .blue
```
### Objective-C
```objective-c
polyline.strokeColor = [UIColor blueColor];
```
### Changing the color of a polyline
Polylines are drawn as a series of segments on the map. You can change the color
of individual segments, or the entire line, with the `spans` property. While
this property gives you detailed control over the coloring of a polyline,
several conveniences exist that allow you to apply a single style to the entire
line.
The below snippet uses the `spanWithColor:` method to change the color of the
entire line to red.
### Swift
```swift
polyline.spans = [GMSStyleSpan(color: .red)]
```
### Objective-C
```objective-c
polyline.spans = @[[GMSStyleSpan spanWithColor:[UIColor redColor]]];
```
Alternately, if you already have access to a [`GMSStrokeStyle`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSStrokeStyle.md.txt)
object, you can use the `spanWithStyle:` method.
### Swift
```swift
let solidRed = GMSStrokeStyle.solidColor(.red)
polyline.spans = [GMSStyleSpan(style: solidRed)]
```
### Objective-C
```objective-c
GMSStrokeStyle *solidRed = [GMSStrokeStyle solidColor:[UIColor redColor]];
polyline.spans = @[[GMSStyleSpan spanWithStyle:solidRed]];
```
Prior to version 1.7 of the Maps SDK for iOS, the single property
`strokeColor` was available to set the entire color of a
[`GMSPolyline`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSPolyline.md.txt). The `spans` property takes precedence over
`strokeColor`.
### Swift
```swift
polyline.strokeColor = .red
```
### Objective-C
```objective-c
polyline.strokeColor = [UIColor redColor];
```
#### Styles
If your app applies the same stroke color several times, you may find it useful
to define a reusable style. Polyline styles are specified using the
[`GMSStrokeStyle`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSStrokeStyle.md.txt) object. A stroke style can be either a solid
color or a gradient from one color to another color. Once you've created a
style, you can apply it to a [`GMSStyleSpan`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSStyleSpan.md.txt) with the
`spanWithStyle:` method.
### Swift
```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
```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];
```
A `span`'s style will continue until the end of the polyline, or until a new
style is set. You can change the color of the entire line by setting the `spans`
property of a polyline to a single [`GMSStyleSpan`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSStyleSpan.md.txt) The example
demonstrates how to apply a gradient across the entire length of the polyline.
### Swift
```swift
polyline.spans = [GMSStyleSpan(style: redYellow)]
```
### Objective-C
```objective-c
polyline.spans = @[[GMSStyleSpan spanWithStyle:redYellow]];
```
### Changing the color of individual line segments
If you'd like to style each segment of your polyline individually, you can do so
by creating an array of [`GMSStyleSpan`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSStyleSpan.md.txt) objects, and passing this
to the `spans` property. By default, each item in the array sets the color of
the corresponding line segment. If there are more elements in the array than
segments in the line, the extra elements will be ignored. If there are fewer
elements in the array, the final [`GMSStyleSpan`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSStyleSpan.md.txt) describes the
color for the remainder of the line.
You can use blocks of color and/or gradient polylines to indicate changes along
your polyline such as elevation or speed. The below snippet sets the color of
the first two segments of a polyline to red, and the remainder of the line is a
gradient from red to yellow.
### Swift
```swift
polyline.spans = [
GMSStyleSpan(style: solidRed),
GMSStyleSpan(style: solidRed),
GMSStyleSpan(style: redYellow)
]
```
### Objective-C
```objective-c
polyline.spans = @[[GMSStyleSpan spanWithStyle:solidRed],
[GMSStyleSpan spanWithStyle:solidRed],
[GMSStyleSpan spanWithStyle:redYellow]];
```
You can use the `spanWithStyle:segments:` method to set the style for several
segments at once. For example, the following code is equivalent to the above.
The segment length of the final [`GMSStyleSpan`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSStyleSpan.md.txt) is always ignored
as the style is used to describe the remainder of the line.
### Swift
```swift
polyline.spans = [
GMSStyleSpan(style: solidRed, segments:2),
GMSStyleSpan(style: redYellow, segments:10)
]
```
### Objective-C
```objective-c
polyline.spans = @[[GMSStyleSpan spanWithStyle:solidRed segments:2],
[GMSStyleSpan spanWithStyle:redYellow segments:10]];
```
#### Fractional segments
Segments may also be specified as a fractional value. This will apply the style
to the fractional number of segments, potentially causing a split in a single
segment. Each [`GMSStyleSpan`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSStyleSpan.md.txt) begins immediately after the
previous one: in the example below, the gray color begins from ½ through
the second segment and continue to ½ through the third segment.
### Swift
```swift
polyline.spans = [
GMSStyleSpan(style: solidRed, segments: 2.5),
GMSStyleSpan(color: .gray),
GMSStyleSpan(color: .purple, segments: 0.75),
GMSStyleSpan(style: redYellow)
]
```
### Objective-C
```objective-c
polyline.spans = @[[GMSStyleSpan spanWithStyle:solidRed segments:2.5],
[GMSStyleSpan spanWithColor:[UIColor grayColor]],
[GMSStyleSpan spanWithColor:[UIColor purpleColor] segments:0.75],
[GMSStyleSpan spanWithStyle:redYellow]];
```
### Adding a repeating color pattern to a polyline
If you'd like to add a pattern to a polyline, you can use the
[`GMSStyleSpans`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSStyleSpan.md.txt) utility method in `GMSGeometryUtils`. The
`GMSStyleSpans` method accepts two arrays that define a repeating pattern. One
array sets the styles that should be repeated, and the other defines the
interval of repetition. Used together you can create a pattern that can be
applied across any polyline, no matter its length or the number of segments
available.
For example, the below code snippet defines a polyline with a black and white
alternating pattern. Its lengths are treated as meters along a rhumb line (in
Mercator, this is a straight line) as the type is specified as
`kGMSLengthRhumb`.
### Swift
```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
```objective-c
NSArray *styles = @[[GMSStrokeStyle solidColor:[UIColor whiteColor]],
[GMSStrokeStyle solidColor:[UIColor blackColor]]];
NSArray *lengths = @[@100000, @50000];
polyline.spans = GMSStyleSpans(polyline.path, styles, lengths, kGMSLengthRhumb);
```
### Sprite Stamped Polylines
Sprite Stamped polylines allow you to create a polyline using a repeating bitmap
image of your choice. Shapes show with a clear background stroke, but the stamp
is not truncated around line corners - making them useful for situations such as
dots for illustrating walking directions.
You can use this feature using [`GMSSpriteStyle`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSSpriteStyle.md.txt) and setting it
as the stamp using the [`GMSStrokeStyle`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSStrokeStyle.md.txt)'s `stampStyle`
property.
### Swift
```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
```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;
UIImage *image = [UIImage imageNamed:@"imageFromBundleOrAsset"];
GMSStrokeStyle *transparentStampStroke = [GMSStrokeStyle transparentStrokeWithStampStyle:[GMSSpriteStyle spriteStyleWithImage:image]];
GMSStyleSpan *span = [GMSStyleSpan spanWithStyle:transparentStampStroke];
polyline.spans = @[span];
polyline.map = mapView;
```
> [!IMPORTANT]
> **Important:** You can programmatically check the `mapCapabilities` on [`GMSMapView`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSMapView.md.txt) to verify if your map view can show a sprite stamp.
### Texture Stamped Polylines
Texture stamped polylines allow you to create a polyline using a repeated
texture of your choice. Shapes can be shown with clear, solid color or gradient
background stroke. The texture resizes as zoom levels change. Images at the end
of end or beginning of paths or path points are truncated at certain zoom
levels.
You can use this feature using [`GMSTextureStyle`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSTextureStyle.md.txt) and setting
it as the stamp using the [`GMSStrokeStyle`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSStrokeStyle.md.txt)'s `stampStyle`
property.
### Swift
```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
```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;
```
### Map Capabilities
The `mapCapabilities` property on [`GMSMapView`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSMapView.md.txt) adds programmatic
checking for map-specific features. This is useful when wanting to know if
certain map `capabilities` are available before calling specific APIs. This
query determines if the map view supports Sprite Stamped Polylines.
### Swift
```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
```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 * 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;
```
This pattern lets you to subscribe to changes and react to updates with your map
view state. You can also implement `didChangeMapCapabilities` on
[`GMSMapViewDelegate`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Protocols/GMSMapViewDelegate.md.txt) to get updates on feature
availability.
## Polygons
Polygons are similar to polylines in that they consist of a series of
coordinates in an ordered sequence. However, instead of being open-ended,
polygons are designed to define solid regions within a closed loop. Polygons are
defined in the Maps SDK for iOS by the [`GMSPolygon`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSPolygon.md.txt)
class.
You can add a `GMSPolygon` to the map in the same way as you add a
[`GMSPolyline`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSPolyline.md.txt). First, specify its path by creating a
corresponding [`GMSMutablePath`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSMutablePath.md.txt) object and adding points to it.
These points form the outline of the polygon. Each `CLLocationCoordinate2D`
represents a point on the Earth's surface. Line segments are drawn between
points according to the order in which you add them to the path.
### Add a polygon
1. Create a [`GMSMutablePath`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSMutablePath.md.txt) object.
2. Set the points in the path with the `addCoordinate:` or `addLatitude:longitude:` methods. These points form the outline of the polygon.
3. Instantiate a new [`GMSPolygon`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSPolygon.md.txt) object using the path as an argument.
4. Set other properties, such as `strokeWidth`, `strokeColor` and `fillColor`, as desired.
5. Assign the polygon to a [`GMSMapView`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSMapView.md.txt) object by setting the `GMSPolygon.map` property.
6. The polygon appears on the map.
The following code snippet adds a rectangle to a map.
### Swift
```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
```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;
```
You can customize the appearance of the polygon both before adding it to the map
and after it has been added to the map.
### Removing a polygon
Remove a Polygon by setting its `GMSPolygon.map` property to `nil` and detaching
the `layer` from its parent.
### Swift
```
polygon.map = nil
polygon.layer.removeFromSuperLayer()
```
### Objective-C
```
polygon.map = nil;
[polygon.layer removeFromSuperlayer];
```
## Circles
In addition to the generic [`GMSPolygon`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSPolygon.md.txt) class, the
Maps SDK for iOS also includes [`GMSCircle`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSCircle.md.txt), allowing you
to draw circles on the earth's surface.
To construct a circle, you must specify the following two properties:
- `position` as a `CLLocationCoordinate2D`.
- `radius` in meters.
A circle is then defined to be the set of all points on the Earth's surface
which are `radius` meters away from the given `center`. Because of how the
Mercator projection used by the Maps API renders a sphere on a flat surface,
this appears as an almost perfect circle on the map when located near the
equator, and appears increasingly non-circular (on the screen) as the circle
moves away from the equator.
### Adding a circle
The following code snippet adds a circle to the map:
### Swift
```swift
let circleCenter = CLLocationCoordinate2D(latitude: 37.35, longitude: -122.0)
let circle = GMSCircle(position: circleCenter, radius: 1000)
circle.map = mapView
```
### Objective-C
```objective-c
CLLocationCoordinate2D circleCenter = CLLocationCoordinate2DMake(37.35, -122.0);
GMSCircle *circle = [GMSCircle circleWithPosition:circleCenter
radius:1000];
circle.map = mapView;
```
You can customize the appearance of the circle both before adding it to the map
and after it has been added to the map.
### Customizing a circle
You can specify custom colors and stroke widths by modifying properties of
[`GMSCircle`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSCircle.md.txt). It supports the following options:
`fillColor`
: A `UIColor` object specifying the interior color of the
circle. Defaults to transparent.
`strokeColor`
: A `UIColor` object specifying the color of the circle's
outline. Defaults to `blackColor`.
`strokeWidth`
:
The thickness of the circle's outline, in screen points. Defaults to 1.
The thickness does not scale when the map is zoomed.
The following snippet adds a thick red circle with a semi-transparent red
interior.
### Swift
```swift
circle.fillColor = UIColor(red: 0.35, green: 0, blue: 0, alpha: 0.05)
circle.strokeColor = .red
circle.strokeWidth = 5
```
### Objective-C
```objective-c
circle.fillColor = [UIColor colorWithRed:0.25 green:0 blue:0 alpha:0.05];
circle.strokeColor = [UIColor redColor];
circle.strokeWidth = 5;
```
## Creating a hollow polygon
You can combine multiple paths in a single [`GMSPolygon`](https://developers.google.com/maps/documentation/ios-sdk/reference/objc/Classes/GMSPolygon.md.txt) object to
create complex shapes, such as filled rings, or donuts (where polygonal areas
appear inside the polygon as separate shapes). Complex shapes are the
composition of multiple paths.
Create a polygon with a path that specifies the largest area covered by the
polygon. Then specify the `holes` property of the polygon as an array of one or
more `GMSPath` objects, which define the holes within the polygon.
If a smaller path is fully enclosed by the larger path, it appears as if a piece
of the polygon has been removed.
The following code sample creates a polygon with two holes:
### Swift
```swift
let hydeParkLocation = CLLocationCoordinate2D(latitude: -33.87344, longitude: 151.21135)
let camera = GMSCameraPosition.camera(withTarget: hydeParkLocation, zoom: 16)
let options = GMSMapViewOptions()
options.camera = camera
let mapView = GMSMapView(options: options)
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
```objective-c
CLLocationCoordinate2D hydeParkLocation = CLLocationCoordinate2DMake(-33.87344, 151.21135);
GMSCameraPosition *camera = [GMSCameraPosition cameraWithTarget:hydeParkLocation
zoom:16];
GMSMapViewOptions *options = [[GMSMapViewOptions alloc] init];
options.camera = camera;
mapView = [[GMSMapView alloc] initWithOptions:options];
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;
```