Forme

Seleziona la piattaforma: Android iOS JavaScript

Mappa con una polilinea rossa in tinta unita

L'API di Google Maps per Android offre alcuni semplici modi per aggiungere forme alle tue mappe al fine di personalizzarle per la tua applicazione.

  • Una Polyline è una serie di segmenti di linee collegati che possono formare qualsiasi forma desiderata e possono essere utilizzati per contrassegnare percorsi e percorsi sulla mappa.
  • Una Polygon è una forma chiusa che può essere utilizzata per contrassegnare aree sulla mappa.
  • Una Circle è una proiezione geograficamente precisa di un cerchio sulla superficie terrestre disegnata sulla mappa.

Puoi personalizzare l'aspetto di tutte queste forme modificando una serie di proprietà.

Esempi di codice

Il tutorial sull'aggiunta di poligoni e polilinee per rappresentare aree e percorsi include tutto il codice di una semplice app per Android.

Inoltre, il repository ApiDemos su GitHub include esempi che mostrano l'uso delle forme e le loro funzionalità:

Polilinee

La classe Polyline definisce un insieme di segmenti di linea connessi sulla mappa. Un oggetto Polyline è costituito da un insieme di località LatLng e crea una serie di segmenti pubblicitari che collegano queste località in una sequenza ordinata.

Questo video offre idee su come aiutare gli utenti a raggiungere la loro destinazione utilizzando le polilinee per tracciare un percorso sulla mappa.

Per creare una polilinea, devi prima creare un oggetto PolylineOptions a cui aggiungere punti. I punti rappresentano un punto sulla superficie terrestre e sono espressi come un oggetto LatLng. I segmenti di linea vengono tracciati tra i punti in base all'ordine in cui li aggiungi all'oggetto PolylineOptions.

Per aggiungere punti a un oggetto PolylineOptions, chiama PolylineOptions.add(). Tieni presente che questo metodo richiede un numero variabile di parametri, quindi puoi aggiungere più punti alla volta (puoi anche chiamare PolylineOptions.addAll(Iterable<LatLng>) se i punti sono già in un elenco).

Puoi quindi aggiungere la polilinea a una mappa chiamando GoogleMap.addPolyline(PolylineOptions). Il metodo restituisce un oggetto Polyline con il quale puoi modificare la polilinea in un secondo momento.

Lo snippet di codice riportato di seguito illustra come aggiungere un rettangolo a una mappa:

Kotlin



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

      

Java


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

      

Il rettangolo viene visualizzato sulla mappa come mostrato di seguito:

Mappa con una polilinea rettangolare

Per modificare la forma della polilinea dopo averla aggiunta, puoi chiamare Polyline.setPoints() e fornire un nuovo elenco di punti per la polilinea.

Puoi personalizzare l'aspetto della polilinea prima e dopo averla aggiunta. Per ulteriori dettagli, consulta la sezione Personalizzazione dell'aspetto di seguito.

Personalizzazione di poliline

Esistono diversi modi per personalizzare l'aspetto delle polilinee:

  • Le polilinee multicolore impostano i segmenti di polilinea su colori diversi.
  • Le polilinee di sfumatura colorano una polilinea utilizzando una sfumatura di due colori.
  • Polilinee stampate applica uno stile a una polilinea utilizzando le bitmap ripetute.

Per utilizzare le personalizzazioni di Polyline, devi utilizzare la versione 18.1.0 o successiva dell'SDK Maps for Android e l'ultima versione del renderer di Maps SDK for Android.

Creazione di una polilinea multicolore

Mappa con una polilinea multicolore

Puoi utilizzare le sezioni per colorare singolarmente i segmenti di una polilinea creando oggetti StyleSpan e aggiungendoli a PolylineOptions con i metodi addSpan() o addSpans(). Per impostazione predefinita, ogni elemento dell'array imposta il colore del segmento pubblicitario corrispondente. Nell'esempio seguente viene illustrato l'impostazione dei colori del segmento per creare una polilinea con segmenti rossi e verdi:

Kotlin



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

      

Java


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

      

Creazione di una polilinea del gradiente

Mappa con una polilinea a gradiente

Puoi definire un gradiente specificando due interi a 32 bit alpha-rosso-verde-blu (ARGB) per specificare i colori di inizio e fine del tratto. Imposta questa proprietà nell'oggetto opzioni della forma chiamando PolylineOptions.addSpan(). L'esempio seguente mostra la creazione di una polilinea con gradiente rosso-giallo dal Woodland Park Zoo a Kirkland, WA.

Kotlin



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

      

Java


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

      

Creazione di una polilinea stampata

Mappa con una polilinea timbrata

Puoi impostare l'aspetto di una polilinea su una texture bitmap ricorrente. A questo scopo, crea un valore StampStyle di TextureStyle, quindi imposta questa proprietà nell'oggetto opzioni della forma chiamando PolylineOptions.addSpan(), come mostrato di seguito:

Kotlin



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

      

Java


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

      

Eventi polilinea

Per impostazione predefinita, non è possibile fare clic sulle polilinee. Puoi abilitare e disabilitare la cliccabilità chiamando Polyline.setClickable(boolean).

Utilizza OnPolylineClickListener per ascoltare gli eventi di clic su una polilinea cliccabile. Per impostare questo listener sulla mappa, chiama GoogleMap.setOnPolylineClickListener(OnPolylineClickListener). Quando un utente fa clic su una polilinea, riceverai un callback onPolylineClick(Polyline).

Poligoni

Gli oggetti Polygon sono simili agli oggetti Polyline in quanto sono costituiti da una serie di coordinate in una sequenza ordinata. Tuttavia, anziché essere aperti, i poligoni sono progettati per definire le regioni all'interno di un ciclo chiuso con l'interno riempito.

Puoi aggiungere un elemento Polygon alla mappa nello stesso modo in cui aggiungi una Polyline. Per prima cosa, crea un oggetto PolygonOptions e aggiungi alcuni punti. Questi punti formano il contorno del poligono. Puoi quindi aggiungere il poligono alla mappa chiamando GoogleMap.addPolygon(PolygonOptions), che restituirà un oggetto Polygon.

Lo snippet di codice riportato di seguito consente di aggiungere un rettangolo a una mappa.

Kotlin



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

      

Java


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

      

Per modificare la forma del poligono dopo averlo aggiunto, puoi richiamare Polygon.setPoints() e fornire un nuovo elenco di punti per il contorno del poligono.

Puoi personalizzare l'aspetto del poligono prima e dopo averlo aggiunto alla mappa. Per ulteriori dettagli, consulta la sezione Personalizzazione dell'aspetto di seguito.

Completamento automatico poligono

Il poligono nell'esempio precedente è costituito da cinque coordinate, ma tieni presente che la prima e l'ultima coordinate corrispondono alla stessa posizione, che definisce la curva. In pratica, tuttavia, poiché i poligoni definiscono aree chiuse, non è necessario definire quest'ultima coordinata. Se l'ultima coordinata differisce dalla prima, l'API "chiuderà" automaticamente il poligono aggiungendo la prima coordinata alla fine della sequenza di coordinate.

I due poligoni seguenti sono equivalenti e chiamando polygon.getPoints() per ciascuno di essi verranno restituiti tutti e quattro i punti.

Kotlin



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

      

Java


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

      

Creare un poligono vuoto

È possibile combinare più percorsi in un singolo oggetto Polygon per creare forme complesse, ad esempio cerchi pieni o "ciambelle" (in cui le aree poligonali vengono visualizzate all'interno del poligono come "isole"). Le forme complesse sono sempre la composizione di più percorsi più semplici.

È necessario definire due percorsi nella stessa area. La dimensione più grande delle due regioni definisce l'area di riempimento ed è un poligono semplice senza opzioni aggiuntive. Quindi, inserisci un secondo percorso al metodo addHole(). Quando il secondo percorso più piccolo è interamente racchiuso dal percorso più grande, risulterà come se fosse stata rimossa una parte del poligono. Se il foro si interseca con il contorno del poligono, il poligono verrà visualizzato senza riempimento.

Lo snippet riportato di seguito creerà un singolo rettangolo con un foro rettangolare più piccolo.

Kotlin



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

      

Java


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

      

Il poligono vuoto viene visualizzato sulla mappa come mostrato di seguito:

Mappa con una polilinea rettangolo vuoto

Eventi poligono

Per impostazione predefinita, i poligoni non sono cliccabili. Puoi abilitare e disabilitare la cliccabilità chiamando Polygon.setClickable(boolean).

Utilizza OnPolygonClickListener per ascoltare gli eventi di clic su un poligono cliccabile. Per impostare questo listener sulla mappa, chiama GoogleMap.setOnPolygonClickListener(OnPolygonClickListener). Quando un utente fa clic su un poligono, riceverai un callback onPolygonClick(Polygon).

Cerchi

Mappa con un cerchio

Oltre a una classe Polygon generica, l'API di Google Maps include anche classi specifiche per gli oggetti Circle, per semplificarne la costruzione.

Per creare un cerchio, devi specificare le due proprietà seguenti:

  • center come LatLng.
  • radius in metri.

Viene quindi definito un cerchio l'insieme di tutti i punti sulla superficie terrestre che distano radius metri dall'elemento center specificato. Poiché la proiezione di Mercatore utilizzata dall'API di Google Maps esegue il rendering di una sfera su una superficie piana, questa verrà visualizzata sulla mappa come un cerchio quasi perfetto quando si trova vicino all'equatore e apparirà sempre più non circolare (sullo schermo) man mano che il cerchio si allontana dall'equatore.

Per modificare la forma del cerchio dopo averlo aggiunto, puoi chiamare Circle.setRadius() o Circle.setCenter() e fornire nuovi valori.

Puoi personalizzare l'aspetto del cerchio prima e dopo averlo aggiunto alla mappa. Per ulteriori dettagli, consulta la sezione Personalizzazione dell'aspetto di seguito.

Il seguente snippet di codice aggiunge un cerchio alla mappa costruendo un oggetto CircleOptions e chiamando GoogleMap.addCircle(CircleOptions):

Kotlin



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

      

Java


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

      

Eventi cerchia

Per impostazione predefinita, non è possibile fare clic sulle cerchie. Puoi abilitare e disabilitare la cliccabilità chiamando GoogleMap.addCircle() con CircleOptions.clickable(boolean) o chiamando Circle.setClickable(boolean).

Utilizza OnCircleClickListener per ascoltare gli eventi di clic su un cerchio cliccabile. Per impostare questo listener sulla mappa, chiama GoogleMap.setOnCircleClickListener(OnCircleClickListener).

Quando un utente fa clic su una cerchia, riceverai un callback onCircleClick(Circle), come illustrato nel seguente esempio di codice:

Kotlin



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
}

      

Java


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

      

Personalizzazione dell'aspetto

Puoi modificare l'aspetto di una forma prima che venga aggiunta alla mappa (specificando la proprietà desiderata nell'oggetto opzioni) o dopo che è stata aggiunta alla mappa. I getter sono inoltre esposti per tutte le proprietà, in modo da poter accedere facilmente allo stato attuale della forma.

Lo snippet seguente aggiunge una polilinea blu spessa con segmenti geodetici da Melbourne a Perth. Le sezioni seguenti spiegano queste proprietà in modo più dettagliato.

Kotlin



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

      

Java


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

      

La mappa viene visualizzata come mostrato di seguito:

Mappa con una polilinea da Melbourne a Perth

Nota: anche se la maggior parte di queste può essere applicata a qualsiasi forma descritta, alcune proprietà potrebbero non avere senso per determinate forme (ad es. una polilinea non può avere un colore di riempimento perché non ha un interno).

Colore tratto

Il colore del tratto è un numero intero a 32 bit alfa-rosso-verde-blu (ARGB) che specifica l'opacità e il colore del tratto della forma. Imposta questa proprietà nell'oggetto options della forma chiamando *Options.strokeColor() (o PolylineOptions.color() nel caso di una polilinea). Se non specificato, il colore predefinito del tratto è nero (Color.BLACK).

Dopo aver aggiunto la forma alla mappa, puoi accedere al colore del tratto chiamando getStrokeColor() (o getColor() per una polilinea) e modificandolo chiamando setStrokeColor() (setColor() for a polyline).

Colore riempimento

Il colore di riempimento si applica solo a poligoni e cerchi. Non si applica alle polilinee perché non hanno interni definiti. In un poligono, le aree all'interno dei fori non fanno parte dell'interno del poligono e non verranno colorate se viene impostato un colore di riempimento.

Il colore di riempimento è un numero intero a 32 bit alfa-rosso-verde-blu (ARGB) che specifica l'opacità e il colore dell'interno della forma. Imposta questa proprietà nell'oggetto opzioni della forma chiamando *Options.fillColor(). Se non specificato, il colore predefinito del tratto è trasparente (Color.TRANSPARENT).

Dopo aver aggiunto la forma alla mappa, puoi accedere al colore di riempimento chiamando getFillColor() e modificarlo chiamando setFillColor().

Ampiezza tratto

Lo spessore del tratto della linea, come valore in virgola mobile in pixel (px). La larghezza non viene ridimensionata quando la mappa viene ingrandita (ad esempio, una forma avrà lo stesso tratto di larghezza a tutti i livelli di zoom). Imposta questa proprietà sull'oggetto option della forma chiamando *Options.strokeWidth() (o PolylineOptions.width() per una polilinea). Se non specificato, il tratto predefinito è di 10 pixel.

Dopo aver aggiunto la forma alla mappa, puoi accedere allo spessore del tratto chiamando getStrokeWidth() (o getWidth() per una polilinea) e modificandolo chiamando setStrokeWidth() (setWidth() for a polyline).

Sequenza tratto

Il modello di tratto predefinito è una linea continua per le polilinee e per i contorni di poligoni e cerchi. Puoi specificare uno schema di tratto personalizzato per gli oggetti PatternItem, dove ogni elemento è un trattino, un punto o un intervallo.

Il seguente esempio imposta il pattern di una polilinea su una sequenza ripetuta di un punto, seguita da uno spazio di 20 pixel di lunghezza, un trattino di 30 pixel e un altro intervallo di 20 pixel.

Kotlin



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

      

Java


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

      

Il motivo si ripete lungo la linea, a partire dal primo vertice specificato per la forma.

Tipi di giunti

Per le polilinee e i contorni dei poligoni, puoi specificare uno smusso o un rotondo JointType per sostituire il tipo di giunzione obliquo fisso predefinito.

L'esempio seguente applica un giunto di tipo rotondo a una polilinea:

Kotlin



polyline.jointType = JointType.ROUND

      

Java


polyline.setJointType(JointType.ROUND);

      

Il tipo di giunto influisce sulle curve interne della linea. Se la linea ha un pattern del tratto che include trattini, il tipo di giunto vale anche quando un trattino cavalca un giunto. I tipi di giunti non influiscono sui punti, in quanto sono sempre circolari.

Limiti di riga

Puoi specificare uno stile Cap per ciascuna estremità di una polilinea. Le opzioni sono butt (predefinito), quadrato, rotondo o una bitmap personalizzata. Imposta lo stile in PolylineOptions.startCap e PolylineOptions.endCap oppure usa i metodi getter e setter appropriati.

Lo snippet seguente specifica un cappello rotondo all'inizio di una polilinea.

Kotlin



polyline.startCap = RoundCap()

      

Java


polyline.setStartCap(new RoundCap());

      

Lo snippet seguente specifica una bitmap personalizzata per l'immagine statica finale:

Kotlin



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

      

Java


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

      

Quando utilizzi una bitmap personalizzata, devi specificare uno spessore del tratto di riferimento in pixel. L'API scala la bitmap di conseguenza. Lo spessore del tratto di riferimento è lo spessore del tratto utilizzato durante la progettazione dell'immagine bitmap per il cappello, alle dimensioni originali dell'immagine. Lo spessore del tratto di riferimento predefinito è 10 pixel. Suggerimento: per determinare lo spessore del tratto di riferimento, apri l'immagine bitmap con lo zoom del 100% in un editor di immagini e traccia lo spessore desiderato del tratto della linea in relazione all'immagine.

Se utilizzi BitmapDescriptorFactory.fromResource() per creare la bitmap, assicurati di utilizzare una risorsa indipendente dalla densità (nodpi).

Segmenti geodetici

L'impostazione geodetica si applica solo alle polilinee e ai poligoni. Non si applica alle cerchie perché non sono definite come una raccolta di segmenti.

L'impostazione geodetica determina il modo in cui vengono disegnati i segmenti di linea tra vertici consecutivi della polilinea/poligonale. I segmenti geodetici sono quelli che seguono il percorso più breve lungo la superficie terrestre (una sfera) e spesso appaiono come linee curve su una mappa con una proiezione di Mercatore. I segmenti non geodetici sono tracciati come linee rette sulla mappa.

Imposta questa proprietà sull'oggetto opzione della forma chiamando *Options.geodesic(), dove true indica che i segmenti devono essere tracciati come geodetici e false indica che i segmenti devono essere tracciati come linee rette. Se non specificati, il valore predefinito sono segmenti non geodetici (false).

Dopo aver aggiunto la forma alla mappa, puoi accedere all'impostazione geodetica chiamando isGeodesic() e modificarla chiamando setGeodesic().

Z-index

Lo z-index specifica l'ordine di impilamento di questa forma, rispetto ad altri overlay (altre forme, overlay al suolo e overlay di riquadri) sulla mappa. Sopra le sovrapposizioni con z-index più bassi viene disegnata una sovrapposizione con uno z-index elevato. Due overlay con lo stesso z-index vengono tracciate in ordine arbitrario.

Tieni presente che gli indicatori sono sempre tracciati sopra gli altri overlay, indipendentemente dallo z-index degli altri overlay.

Imposta questa proprietà nell'oggetto opzioni della forma chiamando *Options.zIndex(). Se non specificato, il valore z-index predefinito è 0. Dopo che la forma è stata aggiunta alla mappa, è possibile accedere a z-index chiamando getZIndex() e modificandolo chiamando setZIndex().

Visibilità

La visibilità specifica se la forma deve essere tracciata sulla mappa, dove true indica che deve essere disegnata e false indica che non deve essere disegnata. Ti permette di non visualizzare temporaneamente una forma sulla mappa. Per rimuovere definitivamente la forma dalla mappa, chiama remove() su quella forma.

Imposta questa proprietà nell'oggetto opzioni della forma chiamando *Options.visible(). Se non specificati, la visibilità predefinita è true. Dopo che la forma è stata aggiunta alla mappa, puoi accedere alla visibilità chiamando isVisible() e modificandola chiamando setVisible().

Associare i dati a una forma

Puoi archiviare un oggetto dati arbitrario con una polilinea, un poligono o un cerchio utilizzando il metodo setTag() della forma e recuperare l'oggetto utilizzando getTag(). Ad esempio, chiama Polyline.setTag() per archiviare un oggetto dati con una polilinea e chiama Polyline.getTag() per recuperarlo.

Il codice seguente definisce un tag arbitrario (A) per la polilinea specificata:

Kotlin



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"

      

Java


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

      

Di seguito sono riportati alcuni esempi di scenari in cui è utile archiviare e recuperare i dati con le forme:

  • La tua app può soddisfare tipi diversi di forme e vuoi trattarle in modo diverso quando l'utente fa clic su di esse.
  • Potresti interfacciarti con un sistema dotato di identificatori di record univoci, in cui le forme rappresentano record specifici all'interno del sistema.
  • I dati di forma possono indicare una priorità per determinare lo z-index della forma.