Eso es todo.

Para comenzar a desarrollar, consulta nuestra documentación para desarrolladores.

Activar la Google Maps Android API

Para que puedas comenzar, te proporcionaremos orientación en la Google Developers Console a fin de que hagas primero algunas acciones:

  1. Crear o seleccionar un proyecto
  2. Activar la Google Maps Android API
  3. Crear claves correspondientes
Continuar

Utilidad de mapa de calor para Google Maps en Android

Los mapas de calor son útiles para representar la distribución y densidad de puntos de datos de un mapa.

Introducción

En la biblioteca de utilidades de la Google Maps Android API se incluye una utilidad de mapa de calor que puedes usar para agregar uno o más mapas de calor a un mapa de Google en tu aplicación.

En este video se discute el uso de mapas de calor como alternativa a los marcadores cuando para tus datos se necesitan muchos puntos de datos en el mapa.

Los mapas de calor permiten a los observadores comprender la distribución y la intensidad relativa de puntos de datos de un mapa de manera sencilla. En los mapas de calor, en lugar de disponerse un marcador en cada ubicación se usan colores para representar la distribución de los datos.

En el siguiente ejemplo, el rojo representa áreas de alta concentración de comisarías en Victoria, Australia.

Mapa con un mapa de calor en el que se muestra la ubicación de comisarías
Mapa de calor en un mapa

Si aún no configuraste la biblioteca de utilidades de la Google Maps Android API, sigue la guía de configuración antes de leer el resto de esta página.

Agregar un mapa de calor simple

Para agregar un mapa de calor a tu mapa, necesitarás un conjunto de datos que conste de coordenadas de cada ubicación de interés. Primero crea una clase HeatmapTileProvider y pásale la recopilación de objetos LatLng. Luego crea una clase TileOverlay, pásale el proveedor de mosaicos de mapas de calor y agrega la superposición de mosaicos al mapa.

La utilidad suministra la clase HeatmapTileProvider, que implementa la interfaz de TileProvider para proporcionar las imágenes de mosaicos del mapa de calor. HeatmapTileProvider acepta una recopilación de objetos LatLng (u objetos WeightedLatLng, según lo descrito a continuación). Esta clase crea las imágenes de mosaicos para diferentes niveles de zoom según las opciones de radio, gradiente y opacidad suministradas. Puedes modificar los valores predeterminados para estas opciones.

Una vista detallada de los pasos:

  1. Usar HeatmapTileProvider.Builder() y pasarle una recopilación de objetos LatLng para agregar una nueva clase HeatmapTileProvider.
  2. Crea un nuevo objeto TileOverlayOptions con las opciones correspondientes, incluida la clase HeatmapTileProvider.
  3. Llama a GoogleMap.addTileOverlay() para agregar la superposición al mapa.
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;
}

Para este ejemplo, los datos se almacenan en un archivo JSON, police_stations.json. Aquí se proporciona un extracto del archivo:

[
{"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 }
]

Usar puntos promediados de latitud y longitud

Al crear una clase HeatmapTileProvider, puedes pasarle una recopilación de coordenadas promediadas de latitud y longitud. Esto resulta útil si deseas ilustrar la importancia de un conjunto determinado de ubicaciones.

Para aplicar la obtención de promedios a ubicaciones específicas:

  1. Crea un nuevo objeto WeightedLatLng por cada ubicación para la que se deban obtener promedios. Pasa el objeto LatLng y un valor double que represente la intensidad requerida. La intensidad indica la importancia o el valor relativos de esta ubicación. Un valor superior generará un color más intenso en el gradiente del mapa de calor. De manera predeterminada, el color de mayor intensidad es el rojo.
  2. Para crear el mapa de calor, llama a HeatmapTileProvider.Builder().weightedData() en lugar de HeatmapTileProvider.Builder().data().

Personalizar el mapa de calor

Varias propiedades del mapa de calor son personalizables. Puedes configurar las opciones en el momento de la creación a través de las funciones Builder. También puedes modificar una opción en cualquier momento llamando al establecedor correspondiente en la clase HeatmapTileProvider y luego eliminar el caché de moscaicos de la superposición para que vuelva a dibujar todos los mosaicos con las opciones nuevas.

Están disponibles las siguientes opciones:

  1. Radius: tamaño de desenfoque gausiano aplicado al mapa de calor, expresado en píxeles. El valor predeterminado es 20 y debe estar entre 10 y 50. Usa el elemento radius() de las funciones Builder para configurar el valor al crear el mapa de calor, o cambia el valor posteriormente con setRadius().
  2. Gradient: una variedad de colores que se usan en el mapa de calor para generar el mapa de color, con una intensidad de menor a mayor. Un gradiente se genera usando dos matrices: una con valores enteros que contiene los colores, y una de flotación en la que se indica el punto de partida para cada color, como porcentaje de la intensidad máxima, y expresado como fracción de 0 a 1. Debes especificar solo un color para un gradiente de un único color o dos colores como mínimo para un gradiente multicolor. El mapa de color se genera aplicando una interpolación entre dichos colores. El gradiente predeterminado tiene dos colores. Usa el elemento gradient() de las funciones Builder para configurar el valor al crear el mapa de calor, o cambia el valor posteriormente con setGradient().
  3. Opacity: Es la opacidad de toda la capa de mapas de calor, y varía de 0 a 1. El valor predeterminado es 0.7. Cuando crees el mapa de calor, usa el elemento opacity() de Builder para establecer el valor o cambia el valor más adelante con setOpacity().

Por ejemplo, crea un elemento Gradient para configurar el gradiente antes de agregar el mapa de calor:

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

Para cambiar la opacidad de un mapa de calor existente:

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

Cambiar el conjunto de datos

Si deseas cambiar el conjunto de datos a partir del cual se crea un mapa de calor, usa HeatmapTileProvider.setData() o HeatmapTileProvider.setWeightedData() para los puntos del objeto WeightedLatLng. Nota: Si deseas agregar puntos al mapa de calor o eliminarlos de este, actualiza tu recopilación de datos y luego usa setData() o setWeightedData().

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

Eliminar un mapa de calor

Supongamos que agregaste el siguiente mapa de calor:
mProvider = new HeatmapTileProvider.Builder.data(data).build();
mOverlay = mMap.addTileOverlay(new
    TileOverlayOptions().tileProvider(mProvider));

Para eliminarlo, debes eliminar la superposición de mosaicos:

mOverlay.remove();

Ver la aplicación de demostración

Para hallar otro ejemplo de la implementación de un mapa de calor, observa HeatmapsDemoActivity en la aplicación de demostración que se incluye con la biblioteca de utilidades. En la guía de configuración podrás ver la manera de ejecutar la aplicación de demostración.

Enviar comentarios sobre...

Google Maps Android API
Google Maps Android API
Si necesitas ayuda, visita nuestra página de asistencia.