Es kann losgehen!

Bevor Sie mit der Entwicklung beginnen, lesen Sie bitte unsere Entwicklerdokumentation.

Die Google Maps Android API aktivieren

Zum Einstieg führen wir Sie durch die Google Developers Console, wo Sie vorab Folgendes tun müssen:

  1. Ein Projekt erstellen oder auswählen
  2. Die Google Maps Android API aktivieren
  3. Zugehörige Schlüssel erstellen
Weiter

Google Maps Android Heatmap-Hilfsprogramm.

Heatmaps ermöglichen es, die Verteilung und Dichte von Datenpunkten auf einer Karte darzustellen.

Einführung

Die Hilfsprogrammbibliothek von Google Maps Android API umfasst ein Heatmap-Hilfsprogramm, mit dem Sie eine oder mehrere Heatmaps zu einer Google-Karte in Ihrer Anwendung hinzufügen können.

In diesem Video wird die Verwendung von Heatmaps anstelle von Markern erörtert, wenn für Ihre Daten eine große Anzahl Datenpunkte auf der Karte erforderlich ist.

Mit Heatmaps wird es Benutzern erleichtert, die Verteilung und relative Intensität von Datenpunkten auf einer Karte zu erkennen. Statt einen Marker an jedem Standort zu platzieren, verwenden Heatmaps Farben, um die Verteilung von Daten darzustellen.

Im nachfolgenden Beispiel sind Bereiche mit einer hohen Konzentration von Polizeidienststellen in Victoria, Australien in Rot dargestellt.

Eine Karten mit einer Heatmap, auf der die Standorte von Polizeidienststellen angezeigt werden.
Eine Heatmap auf einer Karte

Wenn Sie diese Hilfsprogrammbibliothek von Google Maps Android API noch nicht eingerichtet haben, folgen Sie den Anweisungen im Einrichtungsleitfaden, bevor Sie mit der Lektüre dieser Seite fortfahren.

Einfache Heatmap hinzufügen

Um eine Heatmap zu Ihrer Karte hinzuzufügen, benötigen Sie einen Datensatz mit Koordinaten für jeden einzelnen interessanten Standort. Erstellen Sie zunächst HeatmapTileProvider, und übergeben Sie eine Sammlung von Objekten des Typs LatLng. Erstellen Sie anschließend eine neue Kachelüberlagerung (TileOverlay), übergeben Sie den Heatmap-Kachel-Provider, und fügen Sie die Kachelüberlagerung zur Karte hinzu.

Vom Hilfsprogramm wird die Klasse HeatmapTileProvider unterstützt, mit der die Schnittstelle TileProvider implementiert wird, um die Kachelbilder für die Heatmap bereitzustellen. In HeatmapTileProvider werden Sammlungen von Objekten des Typs LatLng (oder des Typs WeightedLatLng, wie weiter unten beschrieben) unterstützt. Die Kachelbilder werden für verschiedene Vergrößerungsstufen basierend auf den definierten Optionen für Radius, Farbverlauf und Deckkraft erstellt. Für diese Optionen können Sie die Standardwerte ändern.

Hier sind die einzelnen Schritte im Detail beschrieben:

  1. Verwenden Sie HeatmapTileProvider.Builder(), und übergeben Sie eine Sammlung von Objekten des Typs LatLng, um einen neuen HeatmapTileProvider hinzuzufügen.
  2. Erstellen Sie ein neues Objekt TileOverlayOptions mit den relevanten Optionen einschließlich HeatmapTileProvider.
  3. Rufen Sie GoogleMap.addTileOverlay() auf, um die Überlagerung zur Karte hinzuzufügen.
private void addHeatMap() {
    List<LatLng> list = null;

    // Get the data: latitude/longitude positions of police stations.
    try {
        list = readItems(R.raw.police_stations);
    } catch (JSONException e) {
        Toast.makeText(this, "Problem reading list of locations.", Toast.LENGTH_LONG).show();
    }

    // Create a heat map tile provider, passing it the latlngs of the police stations.
    mProvider = new HeatmapTileProvider.Builder()
        .data(list)
        .build();
    // Add a tile overlay to the map, using the heat map tile provider.
    mOverlay = mMap.addTileOverlay(new TileOverlayOptions().tileProvider(mProvider));
}

private ArrayList<LatLng> readItems(int resource) throws JSONException {
    ArrayList<LatLng> list = new ArrayList<LatLng>();
    InputStream inputStream = getResources().openRawResource(resource);
    String json = new Scanner(inputStream).useDelimiter("\\A").next();
    JSONArray array = new JSONArray(json);
    for (int i = 0; i < array.length(); i++) {
        JSONObject object = array.getJSONObject(i);
        double lat = object.getDouble("lat");
        double lng = object.getDouble("lng");
        list.add(new LatLng(lat, lng));
    }
    return list;
}

In diesem Beispiel sind die Daten in einer JSON-Datei, police_stations.json, hinterlegt. Hier sehen Sie einen Auszug aus der Datei:

[
{"lat" : -37.1886, "lng" : 145.708 } ,
{"lat" : -37.8361, "lng" : 144.845 } ,
{"lat" : -38.4034, "lng" : 144.192 } ,
{"lat" : -38.7597, "lng" : 143.67 } ,
{"lat" : -36.9672, "lng" : 141.083 }
]

Gewichtete Breiten-/Längenangaben verwenden

Sie können beim Erstellen von HeatmapTileProvider eine Sammlung gewichteter Breiten-/Längenkoordinaten mit übergeben. Dies ist sinnvoll, wenn Sie die Bedeutung einer bestimmten Standortgruppe hervorheben möchten.

So weisen Sie einzelnen Standorten eine Gewichtung zu:

  1. Erstellen Sie eine neue Gewichtung (WeightedLatLng) für jeden Standort, für den dies erforderlich ist. Übergeben Sie den Wert LatLng und einen Wert double, der die erforderliche Intensität bestimmt. Mit der Intensität wird die relative Bedeutung oder der Wert dieses Standorts angegeben. Ein höherer Wert führt im Farbverlauf der Heatmap zu einer farblich intensiveren Darstellung. Standardmäßig ist Rot die Farbe mit der höchsten Intensität.
  2. Rufen Sie HeatmapTileProvider.Builder().weightedData() anstelle von HeatmapTileProvider.Builder().data() auf, um die Heatmap zu erstellen.

Heatmap anpassen

Sie können verschiedene Eigenschaften der Heatmap anpassen. Sie können diese Optionen während der Erstellung mithilfe der Builder-Funktionen einstellen. Sie können eine Option aber auch jederzeit ändern, indem Sie den entsprechenden Setter in HeatmapTileProvider aufrufen und anschließend den Cachespeicher der Überlagerungskachel löschen, sodass alle Kacheln mit den neuen Optionen neu abgerufen werden.

Folgende Optionen sind verfügbar:

  1. Radius: Die Größe des auf die Heatmap angewandten Gaußschen Weichzeichners, ausgedrückt in Pixeln. Der Standardwert ist 20. Der Wert muss zwischen 10 und 50 liegen. Verwenden Sie die Builder-Methode radius(), um den Wert beim Erstellen der Heatmap zu definieren, oder ändern Sie den Wert später mit setRadius().
  2. Gradient: Der Farbverlauf von der niedrigsten zur höchsten Intensität, der in der Heatmap zum Erstellen der Farbkarte verwendet wird. Ein Farbverlauf wird mithilfe von zwei Arrays erstellt: ein Ganzzahl-Array, das die Farben enthält, und ein Gleitkommazahl-Array, das den Anfangspunkt für jede Farbe in Form eines Prozentsatzes der maximalen Intensität angibt, ausgedrückt als Teilwert zwischen 0 und 1. Für einen einfarbigen Farbverlauf müssen Sie nur eine Farbe angeben; für mehrfarbige Farbverläufe sind mindestens zwei Farben zu definieren. Die Farbkarte wird durch Interpolieren dieser Farben generiert. Der Standardfarbverlauf verfügt über zwei Farben. Verwenden Sie die Builder-Methode gradient(), um den Wert beim Erstellen der Heatmap zu definieren, oder ändern Sie den Wert später mit setGradient().
  3. Opacity: Bezeichnet die Deckkraft der gesamten Heatmap-Ebene. Der Bereich liegt zwischen 0 und 1. Der Standardwert ist 0,7. Verwenden Sie die Builder-Methode opacity(), um den Wert beim Erstellen der Heatmap zu definieren, oder ändern Sie den Wert später mit setOpacity().

Erstellen Sie z. B. einen Farbverlauf (Gradient), um den Farbverlauf vor dem Hinzufügen der Karte zu definieren:

// Create the gradient.
int[] colors = {
    Color.rgb(102, 225, 0), // green
    Color.rgb(255, 0, 0)    // red
};

float[] startPoints = {
    0.2f, 1f
};

Gradient gradient = new Gradient(colors, startPoints);

// Create the tile provider.
mProvider = new HeatmapTileProvider.Builder()
     .data(mList)
     .gradient(gradient)
     .build();

// Add the tile overlay to the map.
mOverlay = mMap.addTileOverlay(new TileOverlayOptions().tileProvider(mProvider));

So ändern Sie die Deckkraft einer vorhandenen Heatmap:

  mProvider.setOpacity(0.7);
  mOverlay.clearTileCache();

Datensatz ändern

Um den Datensatz zu ändern, auf dessen Grundlage eine Heatmap erstellt wird, verwenden Sie HeatmapTileProvider.setData() bzw. HeatmapTileProvider.setWeightedData() für Punkte vom Typ WeightedLatLng. Hinweis: Um Punkte zur Heatmap hinzuzufügen bzw. daraus zu entfernen, aktualisieren Sie Ihre Datensammlung, und verwenden Sie anschließend setData() bzw. setWeightedData().

  ArrayList<WeightedLatLng> data = new ArrayList<WeightedLatLng>();
  mProvider.setData(data);
  mOverlay.clearTileCache();

Heatmap entfernen

Angenommen, Sie haben diese Heatmap hinzugefügt:
mProvider = new HeatmapTileProvider.Builder.data(data).build();
mOverlay = mMap.addTileOverlay(new
    TileOverlayOptions().tileProvider(mProvider));

Um die Heatmap zu entfernen, müssen Sie die Kachelüberlagerung entfernen.

mOverlay.remove();

Demo-App anzeigen

Ein weiteres Beispiel für die Implementierung einer Heatmap finden Sie in der Demo-App, die mit der Hilfsprogrammbibliothek ausgeliefert wird, unter HeatmapsDemoActivity. Im Einrichtungsleitfaden erhalten Sie Informationen zum Ausführen der Demo-App.

Feedback geben zu...

Google Maps Android API
Google Maps Android API