Shapes

Seleziona la piattaforma: Android iOS JavaScript

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

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

Per tutte queste forme, puoi personalizzarne l'aspetto modificando un numero di proprietà.

Esempi di codice

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

Inoltre, il repository ApiDemos su GitHub include esempi che dimostrano l'uso delle forme e delle loro caratteristiche:

• CircleDemoActivity (Java / Kotlin): un cerchio
• MetricDemoActivity (Java / Kotlin): poligono
• PolylineDemoActivity (Java / Kotlin): Polyline

Polilinee

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

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

Per creare una Polyline, crea prima un oggetto PolylineOptions e aggiungi punti. I punti rappresentano un punto sulla superficie terrestre e sono espressi come oggetti LatLng. I segmenti della linea vengono disegnati 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 utilizza un numero variabile di parametri in modo da poter aggiungere più punti contemporaneamente (puoi anche chiamare PolylineOptions.addAll(Iterable<LatLng>) se i punti sono già in un elenco).

A questo punto puoi aggiungere la polilinea su una mappa chiamando GoogleMap.addPolyline(PolylineOptions). Il metodo restituisce un oggetto Polyline con cui puoi modificare la polilinea in un secondo momento.

Il seguente snippet di codice illustra come aggiungere un rettangolo a una mappa:

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

      

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)

      

Il rettangolo viene visualizzato sulla mappa, come mostrato di seguito:

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 sia prima che dopo averla aggiunta alla mappa e dopo averla aggiunta. Consulta la sezione sulla personalizzazione degli aspetti di seguito per ulteriori dettagli.

Personalizzazione di Polyline

Esistono diversi modi per personalizzare l'aspetto delle polilinee:

• Le polilinee multicolori impostano i segmenti polilineali in colori diversi.
• Le polilinee del gradiente colorano una polilinea utilizzando una sfumatura di due colori.
• Le polilinee con timestamp delineano una polilinea utilizzando bitmap ripetute.

Per utilizzare le personalizzazioni di Polyline, devi utilizzare la versione 18.1.0 o successiva dell'SDK Maps per Android e usare il più recente renderer di Maps SDK for Android.

Creazione di una polilinea multicolore

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

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

      

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

      

Creazione di una polilinea gradiente

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

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

      

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

      

Creazione di una polilinea stampata

Puoi impostare l'aspetto di una polilinea su una texture di bitmap ricorrente. Per farlo, crea un StampStyle di TextureStyle, quindi imposta questa proprietà sull'oggetto delle opzioni della forma chiamando PolylineOptions.addSpan() come mostrato qui:

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

      

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

      

Eventi Polilinea

Per impostazione predefinita, le polilinee non sono cliccabili. Puoi abilitare e disabilitare la cliccabilità chiamando Polyline.setClickable(boolean).

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

Nota: se più overlay o forme (indicatori, polilinee, poligoni, cerchi e/o overlay del suolo) sono sovrapposti uno sopra l'altro, l'evento di clic viene mostrato prima all'interno del cluster di indicatori, poi viene attivato per altri overlay o forme selezionabili in base ai relativi valori z-index. Viene attivato al massimo un evento per clic. In altre parole, il clic non viene passato agli overlay o alle forme con valori z-index più bassi. Scopri di più sugli eventi z-index e indicatori di clic.

Poligoni

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

Puoi aggiungere una Polygon alla mappa nello stesso modo in cui aggiungi un Polyline. Innanzitutto, crea un oggetto PolygonOptions e aggiungi alcuni punti. Questi punti forniranno il contorno del poligono. Poi aggiungi il poligono alla mappa chiamando GoogleMap.addPolygon(PolygonOptions) per restituire un oggetto Polygon.

Il seguente snippet di codice aggiunge un rettangolo a una mappa.

Nota: poiché non hai definito un colore di riempimento e il colore di riempimento predefinito è trasparente, questo rettangolo viene visualizzato esattamente come il rettangolo di polilinea dello snippet nella sezione precedente.

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

      

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)

      

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

Puoi personalizzare l'aspetto del poligono prima di aggiungerlo alla mappa e dopo che è stato aggiunto alla mappa. Consulta la sezione sulla personalizzazione degli aspetti di seguito per ulteriori dettagli.

Completamento automatico poligono

Il poligono nell'esempio riportato sopra è composto da cinque coordinate, ma tieni presente che la prima e l'ultima coordinate sono nella stessa posizione, cosa che definisce il loop. In pratica, tuttavia, poiché i poligoni definiscono le aree chiuse, non è necessario definire quest'ultima coordinata. Se l'ultima coordinata è diversa dalla prima, l'API "chiude" automaticamente il poligono aggiungendo la prima coordinata alla fine della sequenza di coordinate.

I due poligoni seguenti sono equivalenti e la chiamata a polygon.getPoints() per ciascuno di essi restituirà tutti e 4 i punti.

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

      

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

      

Crea un poligono vuoto

È possibile combinare più percorsi in un singolo oggetto Polygon per creare forme complesse, come anelli pieni o "ciambelle" (dove 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 più grande delle due regioni definisce l'area di riempimento ed è un semplice poligono senza opzioni aggiuntive. Passa quindi un secondo percorso al metodo addHole(). Quando il secondo percorso più piccolo è racchiuso dal percorso più grande, sembrerà che una parte del poligono sia stata rimossa. Se il foro si interseca con il contorno del poligono, quest'ultimo verrà visualizzato senza alcun riempimento.

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

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

      

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

      

Il poligono cavo appare sulla mappa come mostrato di seguito:

Eventi poligonali

Per impostazione predefinita, non è possibile fare clic sui poligoni. Puoi abilitare e disabilitare la cliccabilità chiamando Polygon.setClickable(boolean).

Utilizza una OnPolygonClickListener per ascoltare gli eventi relativi a 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).

Nota: se più overlay o forme (indicatori, polilinee, poligoni, cerchi e/o overlay del suolo) sono sovrapposti uno sopra l'altro, l'evento di clic viene mostrato prima all'interno del cluster di indicatori, poi viene attivato per altri overlay o forme selezionabili in base ai relativi valori z-index. Viene attivato al massimo un evento per clic. In altre parole, il clic non viene passato agli overlay o alle forme con valori z-index più bassi. Scopri di più sugli eventi z-index e indicatori di clic.

Cerchi

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

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

• center come LatLng.
• radius metri.

Un cerchio viene quindi definito come l'insieme di tutti i punti della superficie terrestre che distano radius metri dalla center specificata. A causa del modo in cui la proiezione di Mercatore utilizzata dall'API di Google Maps esegue il rendering di una sfera su una superficie piana, verrà visualizzata come un cerchio quasi perfetto sulla mappa quando si trova vicino all'equatore e apparirà sempre più non circolare (sullo schermo) quando 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 di aggiungerlo alla mappa e dopo che è stato aggiunto alla mappa. Consulta la sezione sulla personalizzazione degli aspetti di seguito per ulteriori dettagli.

Il seguente snippet di codice aggiunge un cerchio alla mappa mediante la creazione di un oggetto CircleOptions e la chiamata GoogleMap.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);

      

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)

      

Eventi nel cerchio

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 una 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 un cerchio, riceverai un callback onCircleClick(Circle), come mostrato nell'esempio di codice seguente:

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

      

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
}

      

Nota: se più overlay o forme (indicatori, polilinee, poligoni, cerchi e/o overlay del suolo) sono sovrapposti uno sopra l'altro, l'evento di clic viene mostrato prima all'interno del cluster di indicatori, poi viene attivato per altri overlay o forme selezionabili in base ai relativi valori z-index. Viene attivato al massimo un evento per clic. In altre parole, il clic non viene passato agli overlay o alle forme con valori z-index più bassi. Scopri di più sugli eventi z-index e indicatori di clic.

Personalizzare gli aspetti

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

Lo snippet seguente aggiunge una polilinea spessa blu con segmenti geodetici da Mezzanotte a Perth. Nelle sezioni che seguono vengono descritte in modo più dettagliato queste proprietà.

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

      

Kotlin

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

      

La mappa viene visualizzata come mostrato di seguito:

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

Colore tratto

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

Dopo che la forma è stata aggiunta alla mappa, il colore del tratto è accessibile chiamando getStrokeColor() (o getColor() per una polilinea) e può essere modificato chiamando setStrokeColor() (setColor() for a polyline).

Colore riempimento

Il colore di riempimento si applica solo a poligoni e cerchi. Non si applica alle polilinee, in quanto non hanno interni definiti. Per un poligono, le regioni all'interno dei suoi fori non fanno parte dell'interno del poligono e non vengono colorate se viene impostato un colore di riempimento.

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

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

Ampiezza tratto

La larghezza del tratto di linea, sotto forma di numero in pixel (px). La larghezza non viene ridotta quando la mappa viene ingrandita (ovvero, una forma avrà la stessa larghezza del tratto a tutti i livelli di zoom). Imposta questa proprietà sull'oggetto opzione della forma chiamando *Options.strokeWidth() (o PolylineOptions.width() per una polilinea). Se il valore non è specificato, il tratto predefinito è 10 pixel.

Dopo aver aggiunto la forma alla mappa, è possibile accedere alla larghezza del tratto chiamando getStrokeWidth() (o getWidth() per una polilinea) e modificare la chiamata chiamando setStrokeWidth() (setWidth() for a polyline).

Fantasia

Lo schema tratto predefinito è una linea continua per le polilinee e per il contorno di poligoni e cerchi. Puoi specificare un pattern di tratto personalizzato degli oggetti PatternItem, in cui ogni elemento è un trattino, un punto o un intervallo.

Il seguente esempio imposta lo schema per una polilinea su una sequenza ripetuta di un punto, seguita da uno spazio di 20 pixel, un trattino di 30 pixel e un altro spazio di 20 pixel.

Java

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

      

Kotlin

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

      

Il pattern si ripete lungo la linea, iniziando con il primo elemento del pattern al primo vertice specificato per la forma.

Tipi di giunti

Per le polilinee e i contorni dei poligoni, puoi specificare uno smusso o una cornice tonda JointType per sostituire il tipo di giunzione fissa predefinita.

Il seguente campione applica un tipo di giunto rotondo a una polilinea:

Java

polyline.setJointType(JointType.ROUND);

      

Kotlin

polyline.jointType = JointType.ROUND

      

Il tipo di giunto incide sulle curve interne della linea. Se la linea ha un motivo di tratto che include trattini, il tipo di giunzione si applica anche quando un trattino si trova a cavallo di un giunto. I tipi di giunto non hanno effetto sui punti, poiché 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 o utilizza i metodi getter e setter appropriati.

Il seguente snippet specifica un limite di forma tondo all'inizio di una polilinea.

Java

polyline.setStartCap(new RoundCap());

      

Kotlin

polyline.startCap = RoundCap()

      

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

Java

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

      

Kotlin

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

      

Quando utilizzi una bitmap personalizzata, devi specificare la larghezza del tratto di riferimento in pixel. L'API scala la bitmap di conseguenza. La larghezza del tratto di riferimento è la larghezza del tratto che hai utilizzato durante la progettazione dell'immagine bitmap per il limite, in base alla dimensione originale dell'immagine. La larghezza di riferimento predefinita è di 10 pixel. Suggerimento: per determinare la larghezza del tratto di riferimento, apri l'immagine bitmap con uno zoom del 100% in un editor di immagini e traccia la larghezza desiderata del tratto di linea rispetto 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 tracciati i segmenti della linea tra i vertici consecutivi della polilinea/poligono. I segmenti geodetici sono quelli che seguono il percorso più breve lungo la superficie della Terra (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 geodetica e false indica che i segmenti devono essere tracciati come linee rette. Se non specificati, il valore predefinito è i segmenti non geografici (false).

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

Z-index

Lo z-index specifica l'ordine di stack di questa forma, rispetto agli altri overlay (altre forme, overlay del suolo e overlay del riquadro) sulla mappa. Un overlay con un indice z elevato viene disegnato sopra gli overlay con z-index inferiori. Due overlay con lo stesso z-index vengono disegnati in ordine arbitrario.

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

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

Visibilità

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

Imposta questa proprietà sull'oggetto opzioni della forma chiamando *Options.visible(). Se non è specificato, la visibilità predefinita è true. Dopo aver aggiunto la forma alla mappa, la visibilità è accessibile chiamando isVisible() e può essere modificata 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 recuperare l'oggetto dati.

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

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

      

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"

      

Ecco alcuni esempi di scenari quando è utile archiviare e recuperare dati con forme:

• L'app può adattarsi a diversi tipi di forme e tu vuoi trattarle in modo diverso quando l'utente fa clic sulle forme.
• Potresti visualizzare l'interfaccia con un sistema dotato di identificatori univoci, in cui le forme rappresentano record specifici del sistema.
• I dati della forma possono indicare una priorità per determinare lo z-index per la forma.