Kształty

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

• Polyline to seria połączonych ze sobą segmentów liniowych, które mogą tworzyć dowolne kształty i mogą służyć do oznaczania ścieżek i tras na mapie.
• Polygon to zamknięty kształt, którego można używać do oznaczania obszarów na mapie.
• Circle to geograficzne odwzorowanie okręgu na powierzchni Ziemi narysowane na mapie.

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

Przykładowe fragmenty kodu

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

Dodatkowo w repozytorium ApiDemos na GitHubie znajdziesz przykłady, które obrazują użycie kształtów i ich funkcji:

• CircleDemoActivity (Java / Kotlin): krąg
• PolygonDemoActivity (Java / Kotlin): wielokąt
• PolylineDemoActivity (Java / Kotlin): Polyline

Linie łamane

Klasa Polyline definiuje zestaw połączonych segmentów linii na mapie. Obiekt Polyline składa się z zestawu lokalizacji LatLng. Tworzy serię segmentów liniowych, które łączą te lokalizacje w ustalonej kolejności.

Ten film zawiera pomysły, jak pomóc użytkownikom w dotarciu do miejsca docelowego. W tym celu użyj linii łamanych na mapie.

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

Aby dodać punkty do obiektu PolylineOptions, wywołaj funkcję PolylineOptions.add(). Pamiętaj, że ta metoda wykorzystuje zmienną liczbę parametrów, więc możesz dodawać wiele punktów naraz (możesz też wywołać metodę PolylineOptions.addAll(Iterable<LatLng>), jeśli punkty są już na liście).

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

Ten fragment kodu pokazuje, jak dodać prostokąt do mapy:

// 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);

      

// 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)

      

Prostokąt pojawi się na mapie:

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

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

Dostosowywanie linii łamanej

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

• Wielokolorowe linie łamane ustawiają linie łamane na różne kolory.
• Linie gradientowe zmieniają kolor linii łamanej przy użyciu gradientu dwóch kolorów.
• Templowane linie łamane nadają styl linii powtarzalnej za pomocą powtarzających się map bitowych.

Aby korzystać z dostosowań Polyline, musisz używać 18.1.0 lub nowszego pakietu SDK Maps na Androida i najnowszego mechanizmu renderowania pakietu Maps SDK na Androida.

Tworzenie wielokolorowej linii łamanej

Możesz użyć rozpiętości, aby pokolorować poszczególne segmenty linii łamanej. W tym celu utwórz obiekty StyleSpan i dodaj je do PolylineOptions za pomocą metod addSpan() lub addSpans(). Domyślnie każdy element w tablicy ustawia kolor odpowiedniego segmentu linii. Poniższy przykład pokazuje ustawianie kolorów segmentów, aby utworzyć linię łamaną z czerwonymi i zielonymi segmentami:

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

      

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

      

Tworzenie linii łamanej w postaci gradientu

Gradient możesz zdefiniować, określając 22-bitowe 32-bitowe znaki alfanumeryczne, czerwone-niebieskie (ARGB), aby określić początek i koniec koloru kreski. Ustaw tę właściwość w obiekcie opcji kształtu, wywołując PolylineOptions.addSpan(). Poniższy przykład pokazuje utworzenie linii łamanej w kolorze czerwonym i żółtym między zoo Park Park a Kirkland, Waszyngton.

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())));

      

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()
            )
        )
)

      

Tworzenie sfotografowanej linii łamanej

Wygląd linii łamanej możesz ustawić na powtarzającą się teksturę bitmapy. Aby to zrobić, utwórz obiekt StampStyle o wartości TextureStyle, a następnie ustaw tę właściwość na obiekcie opcji kształtu, wywołując metodę PolylineOptions.addSpan() w następujący sposób:

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

      

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)
)

      

Zdarzenia linii Polyline

Domyślnie linie łamane nie są klikalne. Możesz włączyć lub wyłączyć klikalność, wywołując Polyline.setClickable(boolean).

Użyj OnPolylineClickListener, aby nasłuchiwać zdarzeń kliknięcia na linii łamanej, którą można kliknąć. Aby ustawić ten detektor na mapie, wywołaj 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 szeregu współrzędnych w ustalonej kolejności. Jednak wielokąty nie są otwarte, ale służą do definiowania regionów w zamkniętej pętli, z wypełnionym wnętrzem.

Sposób dodawania obiektu Polygon do mapy możesz dodać w taki sam sposób jak Polyline. Najpierw utwórz obiekt PolygonOptions i dodaj do niego punkty. Punkty te stanowią kontur wielokąta. Następnie dodajesz do mapy wielokąt, wywołując GoogleMap.addPolygon(PolygonOptions). Zwraca to obiekt Polygon.

Ten fragment kodu dodaje do mapy prostokąt.

// 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);

      

// 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)

      

Aby zmienić kształt wielokąta dodanego do niego, możesz wywołać metodę Polygon.setPoints() i podać nową listę punktów.

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

Autouzupełnianie wielokątów

Wielokąt w powyższym przykładzie składa się z pięciu współrzędnych, ale pamiętaj, że pierwsza i ostatnia współrzędne to ta sama lokalizacja, która definiuje pętlę. W rzeczywistości jednak wielokąty definiują zamknięte obszary, więc nie musisz określać ostatniej. Jeśli ostatnia współrzędna jest inna niż pierwsza, interfejs API automatycznie „zamknie” wielokąt, dołączając do niego pierwszą współrzędną na końcu sekwencji współrzędnych.

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

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

      

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)
)

      

Utwórz pusty wielokąt

W jednym obiekcie Polygon można łączyć wiele ścieżek, aby tworzyć złożone kształty, takie jak wypełnione pierścienie czy „pączki”, czyli w miejscach, w których wielokąty pojawiają się na wyspach. Złożone kształty zawsze składają się z wielu, prostszych ścieżek.

W tym samym obszarze muszą być zdefiniowane dwie ścieżki. Większe regiony wypełniają obszar wypełnienia. Jest to prosty wielokąt bez żadnych dodatkowych opcji. Następnie przekaż drugą ścieżkę do metody addHole(). Gdy druga mniejsza ścieżka jest pełna, otoczona większą ścieżką, wygląda tak, jakby został usunięty fragment wielokąta. Jeśli otwór przecina się przez kontur wielokąta, wielokąt jest renderowany bez wypełnienia.

Podany niżej fragment tworzy jeden prostokąt z mniejszym prostokątnym otworem.

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

      

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)
)

      

Pusty wielokąt jest wyświetlany na mapie w następujący sposób:

Zdarzenia związane z wielokątami

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

Użyj OnPolygonClickListener, aby nasłuchiwać zdarzeń kliknięcia w wielokątach, które można kliknąć. Aby ustawić ten detektor na mapie, wywołaj 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 uprościć ich konstrukcję.

Aby utworzyć okrąg, musisz określić te 2 właściwości:

• center jako LatLng.
• radius metrów.

Okrąg jest następnie określany jako zbiór wszystkich punktów na powierzchni Ziemi znajdujący się w odległości radius m od podanego miejsca (center). Ze względu na sposób, w jaki odwzorowanie Merkatora używane przez interfejs API Map Google renderuje sferę na płaskiej powierzchni, gdy znajduje się w pobliżu równika, pojawi się na mapie jako niemal idealny okrąg, a gdy okrąg odsunie się od równika, będzie coraz bardziej okrągły (na ekranie).

Aby zmienić kształt okręgu po jego dodaniu, możesz wywołać 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 do mapy. Więcej informacji znajdziesz poniżej w sekcji Dostosowywanie wyglądu.

Ten fragment kodu dodaje do mapy okrąg, tworząc obiekt CircleOptions i wywołując GoogleMap.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);

      

// 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)

      

Wydarzenia związane z kręgami

Domyślnie nie można klikać kręgów. Możesz włączyć lub wyłączyć klikalność, wywołując GoogleMap.addCircle() za pomocą właściwości CircleOptions.clickable(boolean) lub wywołując metodę Circle.setClickable(boolean).

Użyj OnCircleClickListener, aby nasłuchiwać zdarzeń kliknięcia w okręgu, który można kliknąć. Aby ustawić ten detektor na mapie, wywołaj GoogleMap.setOnCircleClickListener(OnCircleClickListener).

Gdy użytkownik kliknie kółko, otrzymasz wywołanie zwrotne onCircleClick(Circle), jak w tym przykładowym kodzie:

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);
    }
});

      

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
}

      

Dostosowywanie wyglądu

Wygląd kształtu możesz zmienić zarówno przed dodaniem go do mapy (określając odpowiednią właściwość w obiekcie opcji), jak i po jego dodaniu do mapy. Getry są również udostępniane dla wszystkich właściwości, dzięki czemu można łatwo uzyskać dostęp do bieżącego stanu kształtu.

Fragment kodu poniżej zawiera grubą niebieską łamaną z segmentami geodezyjnymi z Melbourne do Perth. Poniżej znajdziesz ich bardziej szczegółowe omówienie.

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

      

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

      

Mapa wygląda tak:

Uwaga: chociaż większość z nich można zastosować do dowolnego z opisanych kształtów, w przypadku niektórych kształtów może wydawać się to niezrozumiałe (np. kolor linii łamanej nie może mieć koloru wypełnienia, bo nie ma wnętrza).

Kolor kreski

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

Po dodaniu kształtu do mapy kolor koloru kreski można uzyskać, wywołując obiekt 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 mają zastosowania do linii łamanych, ponieważ nie mają zdefiniowanych wnętrz. W przypadku wielokąta regiony w jego otworach nie są częścią wnętrza wielokąta i nie zostaną pokolorowane, gdy zostanie ustawiony kolor wypełnienia.

Kolor wypełnienia to 32-bitowa alfa-czerwono-niebieska liczba całkowita (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 wartość nie jest określona, domyślny kolor kreski jest przezroczysty (Color.TRANSPARENT).

Po dodaniu kształtu do mapy kolor koloru wypełnienia można uzyskać, wywołując metodę getFillColor(). Można go zmienić, wywołując obiekt setFillColor().

Grubość kreski

Szerokość kreski linii w postaci liczby zmiennoprzecinkowej w pikselach (piks.). Szerokość nie jest skalowana po powiększeniu mapy (tzn. kształt ma taką samą szerokość kreski 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 wartość nie jest określona, domyślny kreski to 10 pikseli.

Po dodaniu kształtu do mapy możesz uzyskać dostęp do szerokości kreski, wywołując getStrokeWidth() (lub getWidth() w przypadku linii łamanej) i zmieniając ją, wywołując setStrokeWidth() (setWidth() for a polyline).

Styl kreski

Domyślnym wzorcem jest linia łamana dla linii łamanych i konturów wielokątów i okręgów. Możesz określić niestandardowy wzór kreski obiektów PatternItem, w którym każdy element to łącznik, kropka lub luka.

W przykładzie poniżej ustawiamy wzór linii łamanej na powtarzającą się sekwencję kropki, po której następuje 20-pikselowa przerwa, 30 pikseli i 20-pikselowa luka.

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

      

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

      

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

Rodzaje stawów

W przypadku linii łamanych i konturów wielokątów możesz określić skośność lub okrągłość JointType, aby zastąpić domyślny typ połączenia przecinającego.

W tym przykładzie zastosowano na osi łamanej typ złącza zaokrąglonego:

polyline.setJointType(JointType.ROUND);

      

polyline.jointType = JointType.ROUND

      

Typ złącza ma wpływ na zakręty wewnętrzne w linii. Jeśli linia zawiera wzór kreski, który obejmuje kreski, ten rodzaj połączenia ma zastosowanie również do sytuacji, gdy łącznik znajduje się na stawie. Rodzaje złączy nie mają wpływu na kropki, bo zawsze są okrągłe.

Limity dotyczące linii

Dla każdego końca linii łamanej możesz określić styl Cap. Dostępne opcje to butt (domyślna), kwadrat, okrągły lub niestandardowy bitmapa. Ustaw styl w PolylineOptions.startCap i PolylineOptions.endCap lub użyj odpowiednich metod get i setter.

Ten fragment kodu określa okrągły limit na początku linii łamanej.

polyline.setStartCap(new RoundCap());

      

polyline.startCap = RoundCap()

      

Ten fragment określa niestandardowy bitmapę końcową:

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

      

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

      

Podczas korzystania z niestandardowej mapy bitowej podaj w pikselach szerokość kreski odniesienia. Interfejs API odpowiednio skaluje bitmapę. Szerokość kreski referencyjnej to szerokość kreski użyta podczas projektowania obrazu bitmapy w pierwotnym wymiarze obrazu. Domyślna szerokość kreski referencyjnej to 10 pikseli. Wskazówka: aby określić szerokość kreski odniesienia, otwórz obraz mapy bitowej przy 100% powiększenia w edytorze obrazów i narysuj pożądaną szerokość kreski linii względem obrazu.

Jeśli tworzysz mapę bitową za pomocą BitmapDescriptorFactory.fromResource(), pamiętaj, aby użyć zasobu niezależnego od gęstości (nodpi).

Segmenty geodezyjne

Ustawienie danych geodezycznych dotyczy tylko linii łamanych i wielokątów. Nie dotyczy to kręgów, ponieważ nie są one zdefiniowane jako zbiór segmentów.

Ustawienie geodezyjnego decyduje o tym, jak rysowane są linie między wierzchołkami linii łamanej/wielokąta. Segmenty geodezyjne to fragmenty, które podążają najkrótszą ścieżką wzdłuż powierzchni Ziemi (kuli) i często pojawiają się na mapie jako zakrzywione linie z odwzorowaniem Merkatora. Segmenty niegeograficzne są rysowane na mapie jako proste linie.

Ustaw tę właściwość w obiekcie opcji kształtu, wywołując *Options.geodesic(), gdzie true wskazuje, że segmenty powinny być rysowane jako geometria, a false wskazuje, że segmenty powinny być rysowane jako linie proste. Jeśli wartość nie jest określona, domyślnie są to segmenty niegeograficzne (false).

Po dodaniu kształtu do mapy dostęp do ustawień geodezyjnych można uzyskać, wywołując isGeodesic() i można go zmienić, wywołując setGeodesic().

Kolejność nakładania elementów

Kolejność nakładania elementów określa kolejność nakładania tego kształtu względem innych nakładek (innych kształtów, nakładek na ziemię i nakładek płytek) na mapie. Nakładki z wysokim z-indeksem są wyświetlane nad nakładkami o niższym z-indeksie. Dwie nakładki z tym samym kolejności nakładania elementów są rysowane w dowolnej kolejności.

Pamiętaj, że znaczniki są zawsze rysowane nad innymi nakładkami, niezależnie od kolejności nakładania się elementów.

Ustaw tę właściwość w obiekcie opcji kształtu, wywołując *Options.zIndex(). Jeśli wartość nie zostanie określona, domyślna kolejność nakładania elementów wynosi 0. Po dodaniu kształtu do mapy możesz uzyskać dostęp do kolejności nakładania elementów za pomocą wywołania getZIndex() i zmienić go przez wywoływanie setZIndex().

Widoczność

Widoczność określa, czy kształt ma być rysowany na mapie – pole true wskazuje, że należy go narysować, a false, że nie należy go rysować. Umożliwia tymczasowe wyłączenie kształtu na mapie. Aby trwale usunąć kształt z mapy, wywołaj na nim remove().

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

Powiązanie danych z kształtem

Możesz zapisać dowolny obiekt danych za pomocą linii łamanej, wielokąta lub okręgu, korzystając z metody setTag() kształtu, i pobrać obiekt za pomocą getTag(). Na przykład wywołaj Polyline.setTag(), aby zapisać obiekt danych z łamaną łamaną, a funkcję Polyline.getTag(), aby go pobrać.

Kod poniżej określa dowolny tag (A) dla określonej linii łamanej:

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");

      

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"

      

Oto kilka przykładowych scenariuszy, w których można przechowywać i pobierać dane o kształtach:

• Twoja aplikacja może dostosować się do różnych typów kształtów i musisz traktować je inaczej, gdy użytkownik je kliknie.
• Być może wchodzisz w interakcję z systemem, który ma unikalne identyfikatory rekordów, w których kształty odpowiadają konkretnym rekordom w tym systemie.
• Dane kształtu mogą wskazywać priorytet określania kolejności kolejności nakładania się elementów.