Kształty

Interfejs API Map Google dla Androida oferuje kilka prostych sposobów na dodawanie kształtów do map w celu dostosowania ich do własnej aplikacji.

• Polyline to seria połączonych fragmentów linii, które mogą przybierać dowolny kształt i pozwalają oznaczać na mapie ścieżki i trasy.
• Polygon to zamknięty kształt, który może służyć do zaznaczania obszarów na mapie.
• Circle to wierne geograficznie odwzorowanie okręgu na powierzchni Ziemi narysowanego na mapie.

Wygląd wszystkich tych kształtów można dostosować, zmieniając kilka właściwości.

Przykładowe fragmenty kodu

Samouczek dodawania wielokątów i linii łamanych reprezentujących obszary i trasy zawiera cały kod prostej aplikacji na Androida.

Dodatkowo repozytorium ApiDemos na GitHubie zawiera przykłady przedstawiające wykorzystanie kształtów i ich funkcji:

• CircleDemoActivity (Java / Kotlin): Krąg
• PolygonDemoActivity (Java / Kotlin): wielokąt
• PolylineDemoActivity (Java / Kotlin): Linia łamana

Linie łamane

Klasa Polyline definiuje zestaw połączonych segmentów linii na mapie. Obiekt Polyline składa się ze zbioru lokalizacji LatLng i tworzy serię segmentów łączących te lokalizacje w ustalonej kolejności.

Ten film zawiera pomysły, jak pomóc użytkownikom dotrzeć do celu, korzystając z linii łamanych do narysowania ścieżki na mapie.

Aby utworzyć linię łamaną, najpierw utwórz obiekt PolylineOptions i dodaj do niego punkty. Punkty reprezentują punkt na powierzchni Ziemi i są wyrażone jako obiekt LatLng. Segmenty linii są rysowane między punktami zgodnie z kolejnością ich dodania do obiektu PolylineOptions.

Aby dodać punkty do obiektu PolylineOptions, wywołaj PolylineOptions.add(). Zwróć uwagę, że ta metoda przyjmuje zmienną liczbę parametrów, dzięki czemu możesz dodawać wiele punktów naraz (możesz też wywoływać metodę PolylineOptions.addAll(Iterable<LatLng>), jeśli punkty znajdują się już na liście).

Następnie możesz dodać do mapy linię łamaną, wywołując metodę GoogleMap.addPolyline(PolylineOptions). Metoda zwraca obiekt Polyline, za pomocą którego możesz później zmienić linię łamaną.

Poniższy fragment kodu pokazuje, jak dodać do mapy prostokąt:

// Instantiates a new Polyline object and adds points to define a rectangle
val polylineOptions = PolylineOptions()
    .add(LatLng(37.35, -122.0))
    .add(LatLng(37.45, -122.0)) // North of the previous point, but at the same longitude
    .add(LatLng(37.45, -122.2)) // Same latitude, and 30km to the west
    .add(LatLng(37.35, -122.2)) // Same longitude, and 16km to the south
    .add(LatLng(37.35, -122.0)) // Closes the polyline.

// Get back the mutable Polyline
val polyline = map.addPolyline(polylineOptions)

      

// Instantiates a new Polyline object and adds points to define a rectangle
PolylineOptions polylineOptions = new PolylineOptions()
    .add(new LatLng(37.35, -122.0))
    .add(new LatLng(37.45, -122.0))  // North of the previous point, but at the same longitude
    .add(new LatLng(37.45, -122.2))  // Same latitude, and 30km to the west
    .add(new LatLng(37.35, -122.2))  // Same longitude, and 16km to the south
    .add(new LatLng(37.35, -122.0)); // Closes the polyline.

// Get back the mutable Polyline
Polyline polyline = map.addPolyline(polylineOptions);

      

Prostokąt będzie wyglądał na mapie tak:

Aby zmienić kształt linii łamanej po jej dodaniu, możesz wywołać funkcję Polyline.setPoints() i podać nową listę punktów linii łamanej.

Możesz dostosować wygląd linii łamanej zarówno przed dodaniem jej do mapy, jak i po jej dodaniu. Więcej informacji znajdziesz poniżej w sekcji o dostosowywaniu wyglądu.

Dostosowywanie linii łamanej

Wygląd linii łamanych można dostosować na kilka sposobów:

• Wielokolorowe linie łamane nadają segmentom linii łamanej różne kolory.
• Gradientowe linie łamane umożliwiają kolorowanie linii łamanej przy użyciu gradientu złożonego z dwóch kolorów.
• Statyczne linie łamane umożliwiają stylizowanie linii łamanej za pomocą powtarzających się map bitowych.

Aby korzystać z funkcji dostosowywania Polyline, musisz korzystać z pakietu Maps SDK na Androida w wersji 18.1.0 lub nowszej oraz najnowszego mechanizmu renderowania Maps SDK na Androida.

Tworzenie wielokolorowej linii łamanej

Za pomocą spanów możesz kolorować poszczególne segmenty linii łamanej. W tym celu utwórz obiekty StyleSpan i dodaj je do obiektu PolylineOptions za pomocą metody addSpan() lub addSpans(). Domyślnie każdy element w tablicy ustawi kolor odpowiedniego segmentu linii. Poniższy przykład przedstawia ustawianie kolorów segmentów w celu utworzenia linii łamanej z czerwonymi i zielonymi segmentami:

val line = map.addPolyline(
    PolylineOptions()
        .add(LatLng(47.6677146, -122.3470447), LatLng(47.6442757, -122.2814693))
        .addSpan(StyleSpan(Color.RED))
        .addSpan(StyleSpan(Color.GREEN))
)

      

Polyline line = map.addPolyline(new PolylineOptions()
        .add(new LatLng(47.6677146,-122.3470447), new LatLng(47.6442757,-122.2814693))
        .addSpan(new StyleSpan(Color.RED))
        .addSpan(new StyleSpan(Color.GREEN)));

      

Tworzenie linii łamanej gradientu

Gradient można zdefiniować, określając 2 32-bitowe liczby całkowite: alfa-czerwony-zielony-niebieski (ARGB), aby określić kolor początkowy i końcowy kreski. Ustaw tę właściwość w obiekcie opcji kształtu, wywołując PolylineOptions.addSpan(). Poniższy przykład pokazuje, jak utworzyć linię łamaną gradientową od czerwonego do żółtego z Woodland Park Zoo do Kirkland w stanie Waszyngton.

val line = map.addPolyline(
    PolylineOptions()
        .add(LatLng(47.6677146, -122.3470447), LatLng(47.6442757, -122.2814693))
        .addSpan(
            StyleSpan(
                StrokeStyle.gradientBuilder(
                    Color.RED,
                    Color.YELLOW
                ).build()
            )
        )
)

      

Polyline line = map.addPolyline(new PolylineOptions()
        .add(new LatLng(47.6677146,-122.3470447), new LatLng(47.6442757,-122.2814693))
        .addSpan(new StyleSpan(StrokeStyle.gradientBuilder(Color.RED, Color.YELLOW).build())));

      

Tworzenie oznaczonej linii łamanej

Linię łamaną można ustawić na powtarzającą się teksturę bitmapy. Aby to zrobić, utwórz StampStyle o wartości TextureStyle, a następnie ustaw tę właściwość w obiekcie opcji kształtu, wywołując PolylineOptions.addSpan() w ten sposób:

val stampStyle =
    TextureStyle.newBuilder(BitmapDescriptorFactory.fromResource(R.drawable.walking_dot)).build()
val span = StyleSpan(StrokeStyle.colorBuilder(Color.RED).stamp(stampStyle).build())
map.addPolyline(
    PolylineOptions()
        .add(LatLng(47.6677146, -122.3470447), LatLng(47.6442757, -122.2814693))
        .addSpan(span)
)

      

StampStyle stampStyle =
        TextureStyle.newBuilder(BitmapDescriptorFactory.fromResource(R.drawable.walking_dot)).build();
StyleSpan span = new StyleSpan(StrokeStyle.colorBuilder(Color.RED).stamp(stampStyle).build());
map.addPolyline(new PolylineOptions()
        .add(new LatLng(47.6677146,-122.3470447), new LatLng(47.6442757,-122.2814693))
        .addSpan(span));

      

Zdarzenia dotyczące linii łamanej

Domyślnie linii łamanych nie można kliknąć. Możesz włączyć lub wyłączyć klikalność, wywołując Polyline.setClickable(boolean).

Aby wykrywać zdarzenia kliknięcia na klikalnej linii łamanej, skorzystaj z elementu OnPolylineClickListener. Aby ustawić ten detektor na mapie, wywołaj polecenie GoogleMap.setOnPolylineClickListener(OnPolylineClickListener). Gdy użytkownik kliknie linię łamaną, otrzymasz wywołanie zwrotne onPolylineClick(Polyline).

Wielokąty

Obiekty Polygon są podobne do obiektów Polyline, ponieważ składają się z serii współrzędnych w uporządkowanej kolejności. Wielokąty nie są jednak otwarte i zostały zaprojektowane tak, aby definiować regiony w zamkniętej pętli z wypełnionym wnętrzem.

Znacznik Polygon możesz dodać do mapy tak samo jak element Polyline. Najpierw utwórz obiekt PolygonOptions i dodaj do niego kilka punktów. Te punkty utworzą kontur wielokąta. Następnie dodaj do mapy wielokąt, wywołując metodę GoogleMap.addPolygon(PolygonOptions), która zwróci obiekt Polygon.

Poniższy fragment kodu dodaje prostokąt do mapy.

// Instantiates a new Polygon object and adds points to define a rectangle
val rectOptions = PolygonOptions()
    .add(
        LatLng(37.35, -122.0),
        LatLng(37.45, -122.0),
        LatLng(37.45, -122.2),
        LatLng(37.35, -122.2),
        LatLng(37.35, -122.0)
    )

// Get back the mutable Polygon
val polygon = map.addPolygon(rectOptions)

      

// Instantiates a new Polygon object and adds points to define a rectangle
PolygonOptions polygonOptions = new PolygonOptions()
    .add(new LatLng(37.35, -122.0),
        new LatLng(37.45, -122.0),
        new LatLng(37.45, -122.2),
        new LatLng(37.35, -122.2),
        new LatLng(37.35, -122.0));

// Get back the mutable Polygon
Polygon polygon = map.addPolygon(polygonOptions);

      

Aby zmienić kształt wielokąta po jego dodaniu, wywołaj Polygon.setPoints() i podaj nową listę punktów jego konturu.

Wygląd wielokąta możesz dostosować zarówno przed dodaniem go do mapy, jak i po jego dodaniu. Więcej informacji znajdziesz poniżej w sekcji o dostosowywaniu wyglądu.

Autouzupełnianie wielokątów

Wielokąt w przykładzie powyżej składa się z pięciu współrzędnych. Zwróć uwagę, że pierwsza i ostatnia współrzędne to to samo miejsce, co definiuje pętlę. W praktyce jednak, ponieważ wielokąty definiują zamknięte obszary, nie trzeba definiować tej ostatniej współrzędnych. Jeśli ostatnia współrzędna różni się od pierwszej, interfejs API automatycznie „zamknie” wielokąt, dodając pierwszą współrzędną na końcu sekwencji współrzędnych.

Te 2 wielokąty są równoważne, a wywołanie obiektu polygon.getPoints() w przypadku każdego z nich zwróci wszystkie 4 punkty.

val polygon1 = map.addPolygon(
    PolygonOptions()
        .add(
            LatLng(0.0, 0.0),
            LatLng(0.0, 5.0),
            LatLng(3.0, 5.0),
            LatLng(0.0, 0.0)
        )
        .strokeColor(Color.RED)
        .fillColor(Color.BLUE)
)
val polygon2 = map.addPolygon(
    PolygonOptions()
        .add(
            LatLng(0.0, 0.0),
            LatLng(0.0, 5.0),
            LatLng(3.0, 5.0)
        )
        .strokeColor(Color.RED)
        .fillColor(Color.BLUE)
)

      

Polygon polygon1 = map.addPolygon(new PolygonOptions()
    .add(new LatLng(0, 0),
        new LatLng(0, 5),
        new LatLng(3, 5),
        new LatLng(0, 0))
    .strokeColor(Color.RED)
    .fillColor(Color.BLUE));

Polygon polygon2 = map.addPolygon(new PolygonOptions()
    .add(new LatLng(0, 0),
        new LatLng(0, 5),
        new LatLng(3, 5))
    .strokeColor(Color.RED)
    .fillColor(Color.BLUE));

      

Tworzenie pustego wielokąta

W pojedynczym obiekcie Polygon można połączyć wiele ścieżek, aby tworzyć złożone kształty, takie jak wypełnione pierścienie lub „pierścienie” (gdzie wielokątne obszary są widoczne wewnątrz wielokąta jako „wyspy”). Złożone kształty to zawsze kompozycja wielu, prostych ścieżek.

W tym samym obszarze muszą być zdefiniowane dwie ścieżki. Większy z tych dwóch regionów określa obszar wypełnienia. Jest to prosty wielokąt bez dodatkowych opcji. Następnie przekaż drugą ścieżkę do metody addHole(). Jeśli druga, mniejsza ścieżka jest w pełni zawarta w większej ścieżce, wydaje się, że usunięto fragment wielokąta. Jeśli otwór przecina kontury wielokąta, wielokąt jest renderowany bez żadnego wypełnienia.

Poniższy fragment kodu utworzy jeden prostokąt z mniejszym prostokątnym otworem.

val hole = listOf(
    LatLng(1.0, 1.0),
    LatLng(1.0, 2.0),
    LatLng(2.0, 2.0),
    LatLng(2.0, 1.0),
    LatLng(1.0, 1.0)
)
val hollowPolygon = map.addPolygon(
    PolygonOptions()
        .add(
            LatLng(0.0, 0.0),
            LatLng(0.0, 5.0),
            LatLng(3.0, 5.0),
            LatLng(3.0, 0.0),
            LatLng(0.0, 0.0)
        )
        .addHole(hole)
        .fillColor(Color.BLUE)
)

      

List<LatLng> hole = Arrays.asList(new LatLng(1, 1),
    new LatLng(1, 2),
    new LatLng(2, 2),
    new LatLng(2, 1),
    new LatLng(1, 1));
Polygon hollowPolygon = map.addPolygon(new PolygonOptions()
    .add(new LatLng(0, 0),
        new LatLng(0, 5),
        new LatLng(3, 5),
        new LatLng(3, 0),
        new LatLng(0, 0))
    .addHole(hole)
    .fillColor(Color.BLUE));

      

Pusty wielokąt zostanie pokazany na mapie tak jak poniżej:

Zdarzenia w polu Polygon

Domyślnie wielokątów nie można klikać. Możesz włączyć lub wyłączyć klikalność, wywołując Polygon.setClickable(boolean).

Aby wykrywać zdarzenia kliknięcia klikalnego wielokąta, użyj OnPolygonClickListener. Aby ustawić ten detektor na mapie, wywołaj polecenie GoogleMap.setOnPolygonClickListener(OnPolygonClickListener). Gdy użytkownik kliknie wielokąt, otrzymasz wywołanie zwrotne onPolygonClick(Polygon).

Kółka

Oprócz ogólnej klasy Polygon interfejs API Map Google zawiera też określone klasy obiektów Circle, aby ułatwić ich konstrukcję.

Aby utworzyć okrąg, musisz podać te dwie właściwości:

• center jako LatLng.
• radius w metrach.

Okrąg jest następnie definiowany jako zbiór wszystkich punktów na powierzchni Ziemi, które znajdują się w odległości radius metrów od określonej wartości center. Ze względu na sposób, w jaki odwzorowanie Merkatora używane przez interfejs API Map Google renderuje kulę na płaskiej powierzchni, na mapie widoczny jest prawie idealny okrąg, gdy znajduje się w pobliżu równika, a na ekranie pojawia się coraz bardziej nieokrągły, gdy koło oddala się od równika.

Aby zmienić kształt okręgu po jego dodaniu, możesz wywołać funkcję Circle.setRadius() lub Circle.setCenter() i podać nowe wartości.

Wygląd okręgu możesz dostosować zarówno przed dodaniem go do mapy, jak i po jego dodaniu. Więcej informacji znajdziesz poniżej w sekcji o dostosowywaniu wyglądu.

Ten fragment kodu dodaje okrąg do mapy, tworząc obiekt CircleOptions i wywołując GoogleMap.addCircle(CircleOptions):

// Instantiates a new CircleOptions object and defines the center and radius
val circleOptions = CircleOptions()
    .center(LatLng(37.4, -122.1))
    .radius(1000.0) // In meters

// Get back the mutable Circle
val circle = map.addCircle(circleOptions)

      

// Instantiates a new CircleOptions object and defines the center and radius
CircleOptions circleOptions = new CircleOptions()
    .center(new LatLng(37.4, -122.1))
    .radius(1000); // In meters

// Get back the mutable Circle
Circle circle = map.addCircle(circleOptions);

      

Wydarzenia związane z kręgami

Kręgi nie można domyślnie kliknąć. Aby włączyć lub wyłączyć klikalność, możesz wywołać GoogleMap.addCircle() za pomocą CircleOptions.clickable(boolean) lub Circle.setClickable(boolean).

Użyj OnCircleClickListener, aby nasłuchiwać zdarzeń kliknięć w klikalnym okręgu. Aby ustawić ten detektor na mapie, wywołaj polecenie GoogleMap.setOnCircleClickListener(OnCircleClickListener).

Gdy użytkownik kliknie krąg, otrzymasz wywołanie zwrotne onCircleClick(Circle), jak widać w tym przykładowym kodzie:

val circle = map.addCircle(
    CircleOptions()
        .center(LatLng(37.4, -122.1))
        .radius(1000.0)
        .strokeWidth(10f)
        .strokeColor(Color.GREEN)
        .fillColor(Color.argb(128, 255, 0, 0))
        .clickable(true)
)
map.setOnCircleClickListener {
    // Flip the r, g and b components of the circle's stroke color.
    val strokeColor = it.strokeColor xor 0x00ffffff
    it.strokeColor = strokeColor
}

      

Circle circle = map.addCircle(new CircleOptions()
    .center(new LatLng(37.4, -122.1))
    .radius(1000)
    .strokeWidth(10)
    .strokeColor(Color.GREEN)
    .fillColor(Color.argb(128, 255, 0, 0))
    .clickable(true));

map.setOnCircleClickListener(new GoogleMap.OnCircleClickListener() {
    @Override
    public void onCircleClick(Circle circle) {
        // Flip the r, g and b components of the circle's stroke color.
        int strokeColor = circle.getStrokeColor() ^ 0x00ffffff;
        circle.setStrokeColor(strokeColor);
    }
});

      

Dostosowywanie wyglądu

Wygląd kształtu możesz zmieniać zarówno przed dodaniem go do mapy (przez określenie odpowiedniej właściwości w obiekcie opcji), jak i po dodaniu go do mapy. Metody pobierania są też widoczne dla wszystkich właściwości, dzięki czemu można łatwo uzyskać dostęp do bieżącego stanu kształtu.

Poniższy fragment kodu dodaje grubą niebieską linię łamaną z segmentami geodezyjnymi od Melbourne do Perth. W sekcjach poniżej bardziej szczegółowo opisujemy te właściwości.

val polyline = map.addPolyline(
    PolylineOptions()
        .add(LatLng(-37.81319, 144.96298), LatLng(-31.95285, 115.85734))
        .width(25f)
        .color(Color.BLUE)
        .geodesic(true)
)

      

Polyline polyline = map.addPolyline(new PolylineOptions()
    .add(new LatLng(-37.81319, 144.96298), new LatLng(-31.95285, 115.85734))
    .width(25)
    .color(Color.BLUE)
    .geodesic(true));

      

Mapa będzie wyglądać tak:

Uwaga: większość z nich można stosować do dowolnych z opisanych kształtów, ale niektóre z nich mogą nie mieć sensu w przypadku niektórych kształtów (np. linia łamana nie może mieć koloru wypełnienia, ponieważ nie ma wnętrza).

Kolor kreski

Kolor kreski to 32-bitowa liczba całkowita alfa-czerwony-zielony-niebieski (ARGB), która określa przezroczystość i kolor kreski kształtu. Ustaw tę właściwość w obiekcie opcji kształtu, wywołując metodę *Options.strokeColor() (lub PolylineOptions.color() w przypadku linii łamanej). Jeśli nie określono inaczej, domyślnym kolorem kreski będzie czarny (Color.BLACK).

Po dodaniu kształtu do mapy kolor kreski jest możliwy przez wywołanie getStrokeColor() (lub getColor() w przypadku linii łamanej). Można go zmienić, wywołując setStrokeColor() (setColor() for a polyline).

Kolor wypełnienia

Kolor wypełnienia dotyczy tylko wielokątów i okręgów. Nie dotyczy to linii łamanych, ponieważ nie mają one zdefiniowanych wnętrz. W przypadku wielokąta obszary wewnątrz otworów nie są częścią jego wnętrza i nie zostaną kolorowane, jeśli ustawiony jest kolor wypełnienia.

Kolor wypełnienia to 32-bitowa liczba całkowita alfa-czerwony-zielony-niebieski (ARGB), która określa przezroczystość i kolor wnętrza kształtu. Ustaw tę właściwość w obiekcie opcji kształtu, wywołując *Options.fillColor(). Jeśli nie określono inaczej, domyślny kolor kreski jest przezroczysty (Color.TRANSPARENT).

Po dodaniu kształtu do mapy kolor wypełnienia jest dostępny przez wywołanie getFillColor(). Można go zmienić, wywołując metodę setFillColor().

Grubość kreski

Szerokość kreski linii w postaci liczby zmiennoprzecinkowej w pikselach (pikselach). Szerokość nie skaluje się, gdy mapa jest powiększona (tzn. kształt będzie miał tę samą szerokość kreślenia na wszystkich poziomach powiększenia). Ustaw tę właściwość w obiekcie opcji kształtu, wywołując *Options.strokeWidth() (lub PolylineOptions.width() w przypadku linii łamanej). Jeśli nie określono inaczej, domyślnym kreską jest 10 pikseli.

Po dodaniu kształtu do mapy szerokość kreski jest dostępna za pomocą wywołania getStrokeWidth() (lub getWidth() w przypadku linii łamanej). Można ją zmienić, wywołując setStrokeWidth() (setWidth() for a polyline).

Styl konturu

Domyślny wzór kreski to linia ciągła dla linii łamanych oraz kontur wielokątów i okręgów. Możesz określić niestandardowy wzór kreski w obiektach PatternItem, gdzie każdy element jest myślnikiem, kropką lub luką.

W poniższym przykładzie dla linii łamanej jest powtarzana sekwencja kropki, po której następuje przerwa o długości 20 pikseli, łącznik o długości 30 pikseli i kolejna 20-pikselowa luka.

val pattern = listOf(
    Dot(), Gap(20F), Dash(30F), Gap(20F)
)
polyline.pattern = pattern

      

List<PatternItem> pattern = Arrays.asList(
    new Dot(), new Gap(20), new Dash(30), new Gap(20));
polyline.setPattern(pattern);

      

Wzór powtarza się wzdłuż linii, rozpoczynając od pierwszego elementu wzorca na pierwszym wierzchołku określonym dla kształtu.

Rodzaje stawów

W przypadku linii łamanych i obrysów wielokątów możesz określić ścięcie lub zaokrąglenie JointType, aby zastąpić domyślny stały typ połączenia ukośnego.

Poniższy przykład pokazuje zastosowanie połączenia okrągłego do linii łamanej:

polyline.jointType = JointType.ROUND

      

polyline.setJointType(JointType.ROUND);

      

Typ połączenia wpływa na wewnętrzne zagięcia linii. Jeśli linia ma wzór kreski z myślnikami, typ połączenia ma zastosowanie również wtedy, gdy myślnik otyka się. Rodzaje złączeń nie mają wpływu na kropki, ponieważ są one zawsze okrągłe.

Ograniczenia wierszy

Możesz określić styl Cap dla każdego końca linii łamanej. Dostępne opcje to: tylny przycisk (domyślny), kwadrat, zaokrąglony lub niestandardowa bitmapa. Ustaw styl w PolylineOptions.startCap i PolylineOptions.endCap lub użyj odpowiednich metod pobierania i ustawiania.

Poniższy fragment kodu określa okrągłe zakończenie na początku linii łamanej.

polyline.startCap = RoundCap()

      

polyline.setStartCap(new RoundCap());

      

Ten fragment kodu określa niestandardową mapę bitową na potrzeby zakończenia filmu:

polyline.endCap = CustomCap(BitmapDescriptorFactory.fromResource(R.drawable.arrow), 16F)

      

polyline.setEndCap(
    new CustomCap(BitmapDescriptorFactory.fromResource(R.drawable.arrow), 16));

      

Jeśli używasz niestandardowej mapy bitowej, musisz określić odniesienie do szerokości kreski w pikselach. Interfejs API odpowiednio skaluje bitmapę. Referencyjna szerokość kreski to szerokość kreski użytej podczas projektowania mapy bitowej obrazu okładki przy pierwotnych wymiarach obrazu. Domyślna szerokość kreski w odniesienia to 10 pikseli. Wskazówka: aby określić referencyjną szerokość kreski, otwórz w edytorze obrazów obraz bitmapy przy powiększeniu 100% i narysuj odpowiednią szerokość konturu linii względem obrazu.

Jeśli do utworzenia mapy bitowej używasz narzędzia BitmapDescriptorFactory.fromResource(), pamiętaj, aby użyć zasobu niezależnego od gęstości (nodpi).

Segmenty geodezyjne

Ustawienie geodezyjne dotyczy tylko linii łamanych i wielokątów. Nie odnosi się do okręgów, ponieważ nie są one zdefiniowane jako zbiór segmentów.

Ustawienie geodetyczne określa sposób rysowania segmentów linii pomiędzy kolejnymi wierzchołkami linii łamanej/wielokąta. Segmenty geodezyjne to takie, które przebiegają najkrótszą ścieżką wzdłuż powierzchni Ziemi (kulą) i często mają postać zakrzywionych linii na mapie z odwzorowaniem Merkatora. Segmenty niegeodezyjne są rysowane na mapie jako linie proste.

Ustaw tę właściwość dla obiektu opcji kształtu, wywołując metodę *Options.geodesic(), gdzie true oznacza, że segmenty powinny być rysowane jako obiekty geodezyjne, a false wskazuje, że segmenty powinny być rysowane jako linie proste. Jeśli ich nie określisz, wartością domyślną są segmenty niegeodezyjne (false).

Po dodaniu kształtu do mapy możesz uzyskać dostęp do ustawienia geodezyjnego, wywołując isGeodesic(). Można je zmienić, wywołując setGeodesic().

Kolejność nakładania elementów

Kolejność nakładania elementów określa kolejność nakładania tego kształtu w odniesieniu do innych nakładek (innych kształtów, nakładek na ziemi i nakładek z kafelkami) na mapie. Nakładka o wysokiej kolejności nakładania elementów jest rysowana nad nakładkami o niższych wartościach kolejności nakładania elementów. Dwie nakładki o takiej samej kolejności nakładania są rysowane w dowolnej kolejności.

Pamiętaj, że znaczniki są zawsze rysowane nad innymi warstwami, niezależnie od wartości kolejności nakładania elementów na innych nakładkach.

Ustaw tę właściwość w obiekcie opcji kształtu, wywołując *Options.zIndex(). Jeśli nie określono inaczej, domyślną wartością kolejności nakładania elementów jest 0. Po dodaniu kształtu do mapy możesz uzyskać dostęp do kolejności nakładania elementów, wywołując getZIndex(). Można ją zmienić, wywołując metodę setZIndex().

Widoczność

Widoczność określa, czy kształt ma być rysowany na mapie. true oznacza, że kształt powinien być rysowany, a false wskazuje, że nie. Umożliwia tymczasowe wstrzymanie wyświetlania kształtu na mapie. Aby trwale usunąć kształt z mapy, wywołaj dla niego funkcję remove().

Aby ustawić tę właściwość w obiekcie opcji kształtu, wywołaj *Options.visible(). Jeśli nie określono inaczej, widoczność domyślna to true. Po dodaniu kształtu do mapy dostęp do widoczności można uzyskać, wywołując isVisible(). Można ją zmienić, wywołując setVisible().

Powiąż dane z kształtem

Za pomocą metody setTag() kształtu możesz zapisać dowolny obiekt danych za pomocą linii łamanej, wielokąta lub okręgu. Obiekt można pobrać za pomocą funkcji getTag(). Wywołaj np. Polyline.setTag(), aby zapisać obiekt danych z linią łamaną, oraz metodę Polyline.getTag(), aby pobrać obiekt danych.

Poniższy kod definiuje dowolny tag (A) dla podanej linii łamanej:

val polyline = map.addPolyline(
    PolylineOptions()
        .clickable(true)
        .add(
            LatLng(-35.016, 143.321),
            LatLng(-34.747, 145.592),
            LatLng(-34.364, 147.891),
            LatLng(-33.501, 150.217),
            LatLng(-32.306, 149.248),
            LatLng(-32.491, 147.309)
        )
)
polyline.tag = "A"

      

Polyline polyline = map.addPolyline((new PolylineOptions())
    .clickable(true)
    .add(new LatLng(-35.016, 143.321),
        new LatLng(-34.747, 145.592),
        new LatLng(-34.364, 147.891),
        new LatLng(-33.501, 150.217),
        new LatLng(-32.306, 149.248),
        new LatLng(-32.491, 147.309)));

polyline.setTag("A");

      

Oto kilka przykładów sytuacji, w których przechowywanie i pobieranie danych o kształtach jest przydatne:

• Twoja aplikacja może przyjmować różne rodzaje kształtów i chcesz, aby były traktowane inaczej, gdy użytkownik je kliknie.
• Być może korzystasz z systemu, który ma unikalne identyfikatory rekordów, przy czym kształty reprezentują konkretne rekordy w tym systemie.
• Dane dotyczące kształtu mogą wskazywać priorytet określania priorytetu z-index dla kształtu.