Kształty

Wybierz platformę: Android iOS JavaScript

Pakiet Maps SDK na iOS pozwala na różne sposoby dodawania kształtów map. Obsługiwane są te kształty:

  • Linia łamana to seria połączonych fragmentów linii, które mogą tworzyć dowolny kształt których chcesz używać do zaznaczania na mapie ścieżek i tras.
  • Wielokąt to zamknięty kształt, którego można używać do zaznaczania obszarów na mapie.
  • Okrąg to precyzyjne geograficznie odwzorowanie okręgu na powierzchni Ziemi na różnych powierzchniach.

Wygląd każdego kształtu możesz zmienić na wiele sposobów.

Linie łamane

Linie łamane umożliwiają rysowanie linii na mapie. Obiekt GMSPolyline reprezentuje uporządkowaną sekwencję lokalizacji wyświetlaną jako seria odcinków linii. Kolor linii łamanej można ustawić za pomocą GMSStrokeStyle

Aby utworzyć linię łamaną, musisz określić jej ścieżkę przez utworzenie odpowiadający obiektowi GMSMutablePath z co najmniej 2 punktami. Każdy element CLLocationCoordinate2D reprezentuje punkt na powierzchni Ziemi. Liniowy segmenty są rysowane między punktami w kolejności, w jakiej zostały dodane do ścieżki. Możesz dodawać punkty do ścieżki za pomocą przycisków addCoordinate: lub addLatitude:longitude: metody.

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

Dodawanie linii łamanej

  1. Utwórz obiekt GMSMutablePath.
  2. Ustaw punkty na ścieżce za pomocą znaczników addCoordinate: lub addLatitude:longitude: metody.
  3. Utwórz nowy obiekt GMSPolyline, używając ścieżki jako argumentu.
  4. W razie potrzeby skonfiguruj inne właściwości, np. strokeWidth i strokeColor.
  5. Ustaw właściwość map elementu GMSPolyline.
  6. Na mapie pojawi się linia łamana.

Ten fragment kodu dodaje prostokąt do mapy:

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;

Prostokątna linia łamana

Usuwanie linii łamanej

Możesz usunąć ścieżkę wielokąta z mapy, ustawiając właściwość GMSPolyline w elementach map na wartość nil. Możesz również usunąć wszystkie nakładki (w tym linie łamane i inne kształty) na mapie, wywołując metodę GMSMapView clear.

Swift

mapView.clear()

Objective-C

[mapView clear];

Dostosowywanie linii łamanej

Obiekt GMSPolyline zawiera kilka właściwości, którymi można sterować. wygląd linii. Obsługuje te opcje:

strokeWidth
Szerokość całej linii w punktach ekranu. Domyślna wartość to 1. Szerokość nie skaluje się, gdy mapa jest powiększona.
geodesic
W przypadku wartości YES wyrenderuj tę krawędź linii łamanej jako geodezyjną. Fragmenty geodezyjne podążaj najkrótszą ścieżką wzdłuż powierzchni Ziemi i może są wyświetlane na mapie jako krzywe linie z odwzorowaniem Merkatora. Niegeodezyjna segmenty są rysowane na mapie jako linie proste. Domyślna wartość to NO.
spans
Służy do określania koloru co najmniej 1 sekcji łamany. Właściwość spans jest tablicą wartości GMSStyleSpan obiektów. Ustawienie właściwości spans to preferowany sposób zmień kolor linii łamanej.
strokeColor
Obiekt UIColor określający kolor polilinii. Domyślna wartość to blueColor. Właściwość strokeColor jest ignorowana, jeśli ustawiono element spans.

Poniższy fragment kodu dodaje pogrubioną linię łamaną z Melbourne do Perth, przy czym interpolację geodezyjną.

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;

Aby zmodyfikować linię łamaną po dodaniu jej do mapy, pamiętaj, aby przytrzymać obiekt GMSPolyline.

Swift

polyline.strokeColor = .blue

Objective-C

polyline.strokeColor = [UIColor blueColor];

Zmienianie koloru linii łamanej

Linie łamane są rysowane na mapie jako serie segmentów. Za pomocą właściwości spans możesz zmienić kolor poszczególnych segmentów lub całej linii. Choć umożliwia szczegółową kontrolę nad kolorem linii łamanej, Istnieje kilka udogodnień, które umożliwiają zastosowanie jednego stylu do całej .

Fragment kodu poniżej używa metody spanWithColor:, aby zmienić kolor całego wiersza na czerwony.

Swift

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

Objective-C

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

Jeśli masz już dostęp do GMSStrokeStyle obiektu, możesz użyć metody 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]];

Przed wersją 1.7 pakietu SDK Map na iOS dostępna była tylko jedna właściwość strokeColor, która służyła do ustawiania całego koloru GMSPolyline. Właściwość spans ma pierwszeństwo przed strokeColor

Swift

polyline.strokeColor = .red

Objective-C

polyline.strokeColor = [UIColor redColor];

Style

Jeśli aplikacja kilka razy zastosuje ten sam kolor kreski, może się okazać aby zdefiniować styl wielokrotnego użytku. Style linii łamanej są określane za pomocą atrybutu GMSStrokeStyle. Styl kreski może być lub gradientu. Po utworzeniu możesz zastosować do GMSStyleSpan z 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];

Styl obiektu span będzie obowiązywał do końca linii łamanej lub do momentu utworzenia nowego styl jest ustawiony. Możesz zmienić kolor całej linii, ustawiając spans właściwość linii łamanej do pojedynczego GMSStyleSpan Przykład pokazuje, jak zastosować gradient na całej długości linii łamanej.

Swift

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

Objective-C

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

Zmienianie koloru poszczególnych fragmentów linii

Jeśli chcesz oddzielnie nadać styl każdemu segmentowi linii łamanej, możesz to zrobić przez utworzenie tablicy obiektów GMSStyleSpan i przekazanie jej do właściwości spans. Domyślnie każdy element w tablicy ustawia kolor odpowiedniego fragmentu linii. Jeśli tablica zawiera więcej elementów niż segmentów, dodatkowe elementy zostaną zignorowane. Jeśli jest ich mniej elementów tablicy, końcowy GMSStyleSpan opisuje kolorem pozostałej części linii.

Aby wskazać zmiany wzdłuż, możesz użyć bloków koloru lub linii łamanych gradientu linii łamanej, takich jak wysokość lub prędkość. Poniższy fragment kodu ustawia kolor pierwsze dwa odcinki linii łamanej są czerwone, a pozostałe to od czerwonego do żółtego.

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

Metoda spanWithStyle:segments: pozwala ustawić styl dla kilku i segmenty odbiorców. Na przykład ten kod jest równoważny z powyższym. Długość segmentu końcowego GMSStyleSpan jest zawsze ignorowana. ponieważ styl służy do opisywania pozostałej części linii.

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

Segmenty ułamkowe

Segmenty mogą być też określone jako wartości ułamkowe. Spowoduje to zastosowanie stylu do ułamkowej liczby segmentów, potencjalnie powodując podział segmentację. Każda GMSStyleSpan rozpoczyna się bezpośrednio po elemencie poprzednia: w przykładzie poniżej kolor szary zaczyna się od 1⁄2 do połowy drugi segment i przejść do 1⁄2 do trzeciego segmentu.

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

Dodawanie powtarzającego się wzoru koloru do linii łamanej

Jeśli chcesz dodać wzór do polilinii, możesz użyć metody pomocniczej GMSStyleSpans w funkcji GMSGeometryUtils. Metoda GMSStyleSpans akceptuje 2 tablice, które definiują powtarzający się wzorzec. Jeden tablica określa style, które powinny się powtarzać, a druga określa między powtórzeniami. Połączenie tych dwóch narzędzi pozwala utworzyć wzór, który można zastosować do dowolnej ścieżki wielokąta, niezależnie od jej długości i liczby dostępnych segmentów.

Na przykład poniższy fragment kodu definiuje linię łamaną z czarno-białym obrazem naprzemienny wzorzec. Jego długości są traktowane jako metry wzdłuż linii romb (w jest to linia prosta), ponieważ typ jest określony jako 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);

Linie łamane z duszkami

Linie łamane z duszkami umożliwiają tworzenie linii łamanych przy użyciu powtarzającej się mapy bitowej wybranego zdjęcia. Kształty są wyświetlane z przezroczystym obrysem tła, ale stempel nie jest przycinany w narożnikach linii. Dzięki temu stempel jest przydatny w takich sytuacjach jak punkty na mapie pokazujące kierunki dojścia pieszo.

Linia łamana z wytłoczonym spritem

Możesz korzystać z tej funkcji za pomocą GMSSpriteStyle i skonfigurować ją jako znaczek, używając elementu stampStyle GMSStrokeStyle usłudze.

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;

Linie łamane z tłoczeniami tekstur

Linie łamane z nadrukowanymi teksturami umożliwiają tworzenie linii łamanych przy użyciu wybranej tekstury. Kształty mogą być wyświetlane z przezroczystym, jednolitym kolorem lub gradientem tła. Zmienia się rozmiar tekstury wraz ze zmianą poziomu powiększenia. Obrazy na końcu końca lub początku ścieżek bądź punktów ścieżki są obcięte przy pewnym powiększeniu poziomów.

Teksturowana linia łamana

Możesz użyć tej funkcji, korzystając z elementu GMSTextureStyle i ustawiając go jako pieczęć za pomocą właściwości stampStyle elementu 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;

Uprawnienia map

Usługa mapCapabilities w systemie GMSMapView dodaje automatyzację podczas sprawdzania funkcji poszczególnych map. Jest to przydatne, gdy chcesz się dowiedzieć, czy określone mapy capabilities są dostępne przed wywołaniem określonych interfejsów API. Ten Zapytanie określa, czy widok mapy obsługuje linie łamane ze stemplowanymi sprite’ami.

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;

Ten wzór umożliwia subskrybowanie zmian i reagowanie na aktualizacje za pomocą mapy stan widoku. Usługę didChangeMapCapabilities możesz też zaimplementować w: GMSMapViewDelegate, aby otrzymywać aktualne informacje o tej funkcji dostępność.

Wielokąty

Wielokąty są podobne do linii łamanych tym, że składają się z serii w uporządkowanej kolejności. Jednak zamiast pytania otwartego, wielokąty są przeznaczone do definiowania obszarów stałych w zamkniętej pętli. zdefiniowane w pakiecie SDK Maps na iOS przez GMSPolygon zajęcia.

Możesz dodać obiekt GMSPolygon do mapy w taki sam sposób, w jaki dodajesz GMSPolyline Najpierw określ jej ścieżkę, tworząc odpowiedni obiekt GMSMutablePath i dodając do niego punkty. Punkty te tworzą kontur wielokąta. Co CLLocationCoordinate2D reprezentuje punkt na powierzchni Ziemi. Odcinki linii są rysowane pomiędzy zgodnie z kolejnością, w jakiej dodajesz je do ścieżki.

Dodaj wielokąt

  1. Utwórz obiekt GMSMutablePath.
  2. Ustaw punkty na ścieżce za pomocą znaczników addCoordinate: lub addLatitude:longitude: metody. Punkty te tworzą zarys wielokąt.
  3. Utwórz instancję nowego obiektu GMSPolygon, używając ścieżki jako .
  4. W razie potrzeby ustaw inne właściwości, takie jak strokeWidth, strokeColor i fillColor.
  5. Przypisz wielokąt do obiektu GMSMapView, ustawiając właściwość GMSPolygon.map.
  6. Wielokąt pojawi się na mapie.

Następujący fragment kodu dodaje prostokąt do mapy.

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;

Przed dodaniem wielokąta do mapy możesz dostosować jego wygląd. po dodaniu go do mapy.

Usuwanie wielokąta

Aby usunąć wielokąt, ustaw jego właściwość GMSPolygon.map na nil i odłącz go layer z elementu nadrzędnego.

Swift

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

Objective-C

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

Kręgi

Oprócz klasy ogólnej GMSPolygon funkcja Maps SDK na iOS obejmuje też pakiet GMSCircle, dzięki któremu możesz: aby narysować okręgi na powierzchni Ziemi.

Aby utworzyć okrąg, musisz określić dwie następujące właściwości:

  • position jako CLLocationCoordinate2D.
  • radius w metrach.

Okrąg jest wtedy zdefiniowany jako zbiór wszystkich punktów na powierzchni Ziemi, które znajdują się w odległości radius metrów od danego center. Z powodu tego, Odwzorowanie Merkatora używane przez interfejs API Map Google renderuje kulę na płaskiej powierzchni. Gdy znajdziesz się w pobliżu równik i wygląda coraz na nieokrągłe (na ekranie) jako okrąg, oddala się od równika.

Dodawanie kręgu

Następujący fragment kodu dodaje okrąg do mapy:

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;

Wygląd kręgu możesz dostosować zarówno przed dodaniem go do mapy, jak i po dodaniu.

Dostosowywanie kręgu

Możesz określić niestandardowe kolory i szerokości kreski, modyfikując właściwości GMSCircle Obsługuje te opcje:

fillColor
Obiekt UIColor określający kolor wnętrza kręgu znajomych. Domyślnie jest przezroczysty.
strokeColor
Obiekt UIColor określający kolor okręgu konspektu. Domyślna wartość to blackColor.
strokeWidth
Grubość konturu okręgu w punktach na ekranie. Domyślna wartość to 1. Po powiększeniu mapy grubość nie będzie się skalować.

Ten fragment kodu dodaje grube czerwone koło z półprzezroczystym czerwonym elementem wewnętrzne.

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;

Tworzenie pustego wielokąta

Możesz połączyć wiele ścieżek w jednym obiekcie GMSPolygon, aby tworzą złożone kształty, takie jak wypełnione pierścienie lub pierścienie (w przypadku elementów wielokątnych są wyświetlane wewnątrz wielokąta jako osobne kształty). Złożone kształty to elementy z kilku ścieżek.

Utwórz wielokąt z ścieżką, która określa największy obszar objęty wielokątem. Następnie określ właściwość holes wielokąta jako tablicę z jedną lub więcej obiektów GMSPath, które definiują otwory w wielokątie.

Jeśli mniejsza ścieżka jest w pełni otoczona większą ścieżką, wydaje się, że kawałek wielokąta został usunięty.

Następujący przykładowy kod tworzy wielokąt z 2 otworami:

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;