Pronto!

Para começar a desenvolver, acesse nossa documentação do desenvolvedor.

Ative a Google Maps Android API

Para começar, orientaremos você pelo Google Developers Console para realizar algumas atividades:

  1. Criar ou selecionar um projeto
  2. Ative a Google Maps Android API
  3. Criar chaves apropriadas
Continuar

Utilitário de mapa de calor do Google Maps Android

Os mapas de calor são úteis para representar a distribuição e a densidade de pontos de dados em um mapa.

Introdução

A biblioteca de utilitários da Google Maps Android API inclui um utilitário de mapa de calor que pode ser usado para adicionar um ou mais mapas de calor a um mapa Google no aplicativo.

Este vídeo discute o uso de mapas de calor como uma alternativa aos marcadores quando os dados exigem um grande número de pontos de dados no mapa.

Os mapas de calor permitem que os visualizadores compreendam com mais facilidade a distribuição e a intensidade relativa de pontos de dados em um mapa. Em vez de colocar um marcador em cada localização, os mapas de calor usam cores para representar a distribuição dos dados.

No exemplo abaixo, o vermelho representa as áreas de alta concentração de delegacias de polícia em Victoria, Austrália.

Um mapa com um mapa de calor mostrando a localização de delegacias de polícia
Um mapa de calor em um mapa

Se você ainda não configurou a biblioteca de utilitários da Google Maps Android API, siga o guia de configuração antes de ler o restante desta página.

Adicionar um mapa de calor simples

Para adicionar um mapa de calor ao seu mapa, é necessário um conjunto de dados com as coordenadas de cada localização de interesse. Primeiro, crie um HeatmapTileProvider passando uma coleção de objetos LatLng. Em seguida, crie um novo TileOverlay passando o provedor de blocos do mapa de calor e adicione a sobreposição de blocos ao mapa.

O utilitário fornece a classe HeatmapTileProvider, que implementa a interface TileProvider para fornecer as imagens de blocos do mapa de calor. A classe HeatmapTileProvider aceita uma coleção de objetos LatLng (ou objetos WeightedLatLng, como descrito abaixo). Ela cria as imagens de bloco para os diversos níveis de zoom de acordo com as opções de raio, gradiente e opacidade especificadas. É possível alterar os valores padrão dessas opções.

Examinando as etapas de forma mais detalhada:

  1. Use HeatmapTileProvider.Builder() passando uma coleção de objetos LatLng para adicionar um novo HeatmapTileProvider.
  2. Crie um novo objeto TileOverlayOptions com as opções relevantes, incluindo o HeatmapTileProvider.
  3. Chame GoogleMap.addTileOverlay() para adicionar a sobreposição ao 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;
}

Neste exemplo, os dados estão armazenados em um arquivo JSON, police_stations.json. Este é um trecho do arquivo:

[
{"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 pontos de latitude/longitude ponderados

Na criação do HeatmapTileProvider, é possível passar uma coleção de coordenadas de latitude/longitude ponderadas. Esse recurso é útil quando você quer mostrar a importância de um determinado conjunto de localizações.

Para aplicar ponderação a localizações específicas:

  1. Crie um novo WeightedLatLng para cada localização a ser ponderada. Passe LatLng e um double representando a intensidade necessária. A intensidade indica a importância relativa, ou valor, dessa localização. Um valor maior resulta em uma cor de maior intensidade no gradiente do mapa de calor. Por padrão, a cor de maior intensidade é o vermelho.
  2. Para criar o mapa de calor, chame HeatmapTileProvider.Builder().weightedData() em vez de HeatmapTileProvider.Builder().data().

Personalizar o mapa de calor

Várias propriedades do mapa de calor são personalizáveis. Você pode definir as opções no momento da criação usando as funções Builder. Como alternativa, altere uma opção a qualquer momento chamando o configurador relevante em HeatmapTileProvider e limpe o cache de blocos da sobreposição para forçar a reexibição de todos os blocos com as novas opções.

As seguintes opções estão disponíveis:

  1. Radius: o tamanho do desfoque gaussiano aplicado ao mapa de calor, expresso em pixels. O padrão é 20. O valor deve estar entre 10 e 50. Use radius() do Builder para definir o valor durante a criação do mapa de calor ou altere o valor posteriormente com setRadius().
  2. Gradient: Uma faixa de cores usada pelo mapa de calor para gerar o mapa de cores, da menor para a maior intensidade. Um gradiente é criado usando duas matrizes: uma matriz de inteiros, contendo as cores, e uma matriz de números flutuantes, indicando o ponto inicial de cada cor, considerado como uma porcentagem da intensidade máxima e especificado como uma fração entre 0 e 1. Você precisa especificar somente uma cor para um gradiente de uma cor ou um mínimo de duas cores para um gradiente de várias cores. O mapa de cores é gerado usando interpolação entre essas cores. O gradiente padrão tem duas cores. Use gradient() do Builder para definir o valor durante a criação do mapa de calor ou altere o valor posteriormente com setGradient().
  3. Opacity: Esta é a opacidade de toda a camada do mapa de calor, variando de 0 a 1. O padrão é 0.7. Use opacity() do Builder para definir o valor durante a criação do mapa de calor ou altere o valor posteriormente com setOpacity().

Por exemplo, crie um Gradient para definir o gradiente antes de adicioná-lo ao 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 alterar a opacidade de um mapa de calor existente:

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

Alterar o conjunto de dados

Para alterar o conjunto de dados usado para criar o mapa de calor, use HeatmapTileProvider.setData() ou HeatmapTileProvider.setWeightedData() para pontos WeightedLatLng. Observação: se quiser adicionar pontos ao mapa de calor ou removê-los, atualize a coleção de dados e use setData() ou setWeightedData().

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

Remover um mapa de calor

Vamos supor que você adicionou este mapa de calor:
mProvider = new HeatmapTileProvider.Builder.data(data).build();
mOverlay = mMap.addTileOverlay(new
    TileOverlayOptions().tileProvider(mProvider));

Para remover o mapa de calor, é necessário remover a sobreposição de blocos:

mOverlay.remove();

Ver o aplicativo de demonstração

Para obter outro exemplo de implementação de um mapa de calor, consulte HeatmapsDemoActivity no aplicativo de demonstração fornecido com a biblioteca de utilitários. O guia de configuração mostra como executar o aplicativo de demonstração.

Enviar comentários sobre…

Google Maps Android API
Google Maps Android API
Precisa de ajuda? Acesse nossa página de suporte.