Os mapas de calor (heatmaps) são uma das formas mais intuitivas de visualizar densidade de ocorrências geográficas, seja para representar crimes, atendimentos de saúde, pontos de coleta de resíduos ou eventos climáticos.
No GeoServer, podemos gerar mapas de calor usando o WMS Heatmap Rendering Transform, mas configurar isso manualmente para dezenas de camadas pode ser trabalhoso.
Neste post, vamos mostrar como automatizar esse processo com Python + IA, criando um pipeline que:
- Analisa automaticamente seus dados espaciais;
- Gera os parâmetros ideais do heatmap (raio, cores, intensidade);
- Publica o estilo e a camada automaticamente no GeoServer;
- Pode ser aplicado a qualquer dataset de pontos no PostGIS.
1. O conceito de heatmap no GeoServer
O GeoServer suporta a geração de heatmaps a partir de camadas de pontos usando o processo de renderização “vec:Heatmap” dentro de um estilo SLD.
Exemplo básico de configuração manual:
<RasterSymbolizer>
<Geometry>
<ogc:PropertyName>geom</ogc:PropertyName>
</Geometry>
<Opacity>0.6</Opacity>
<ColorMap type="ramp" extended="true">
<ColorMapEntry color="#0000FF" quantity="0" opacity="0"/>
<ColorMapEntry color="#00FF00" quantity="0.5" opacity="0.7"/>
<ColorMapEntry color="#FF0000" quantity="1" opacity="1"/>
</ColorMap>
</RasterSymbolizer>
O problema é que definir manualmente raio, opacidade e escala de cores exige tentativas e erros. É aí que você pode utilizar a IA para automatizar essa etapa.
2. Onde entra a IA
A IA pode atuar para:
-
Analisar a densidade e distribuição dos pontos
(via amostra SQL do PostGIS); -
Sugerir automaticamente:
- Raio ideal para suavização do heatmap;
- Paleta de cores coerente com o contexto (ex.: segurança, saúde, meio ambiente);
- Limites de intensidade (quantidade mínima/máxima de ocorrências);
- Gerar o SLD completo com os parâmetros otimizados.
3. PostGIS + Python + IA + GeoServer
A seguir, um exemplo completo de automação, do banco ao GeoServer que:
- Conecta-se ao banco PostGIS e coleta estatísticas da camada (contagem e extensão).
- Envia essas informações à IA, que gera um SLD completo com o transform “vec:Heatmap”.
- Publica automaticamente o estilo no GeoServer via REST API.
- O resultado pode ser aplicado imediatamente na camada eventos_ocorrencias.
import psycopg2
import openai
import requests
# Configurações
DB_NAME = "gisdb"
DB_USER = "gis"
DB_PASS = "123"
DB_HOST = "localhost"
GEOSERVER_URL = "http://localhost:8080/geoserver/rest/styles"
GEOSERVER_USER = "admin"
GEOSERVER_PASS = "geoserver"
LAYER_NAME = "eventos_ocorrencias"
STYLE_NAME = "heatmap_eventos"
# 1. Amostrar dados para análise
conn = psycopg2.connect(f"dbname={DB_NAME} user={DB_USER} password={DB_PASS} host={DB_HOST}")
cur = conn.cursor()
cur.execute(f"SELECT COUNT(*), ST_Extent(geom) FROM {LAYER_NAME};")
total, bbox = cur.fetchone()
# 2. Gerar estilo Heatmap com IA
prompt = f"""
Crie um estilo SLD para gerar um heatmap no GeoServer.
Use o transform 'vec:Heatmap' com parâmetros otimizados.
Contexto:
- Camada: {LAYER_NAME}
- Total de pontos: {total}
- Extensão espacial: {bbox}
- O mapa representa ocorrências de eventos.
A paleta de cores deve ir de azul (baixa densidade) a vermelho (alta densidade).
"""
resposta = openai.ChatCompletion.create(
model="gpt-4o-mini",
messages=[{"role": "user", "content": prompt}]
)
sld_xml = resposta.choices[0].message.content
# 3. Publicar estilo no GeoServer
headers = {"Content-type": "application/vnd.ogc.sld+xml"}
r = requests.post(
f"{GEOSERVER_URL}?name={STYLE_NAME}",
data=sld_xml.encode("utf-8"),
headers=headers,
auth=(GEOSERVER_USER, GEOSERVER_PASS)
)
if r.status_code in [200, 201]:
print(f"Estilo '{STYLE_NAME}' publicado com sucesso!")
else:
print("Erro ao publicar estilo:", r.status_code, r.text)
A saída gerada pelo script será:
<StyledLayerDescriptor version="1.0.0">
<NamedLayer>
<Name>eventos_ocorrencias</Name>
<UserStyle>
<Title>Heatmap de Ocorrências</Title>
<FeatureTypeStyle>
<Transformation>
<ogc:Function name="vec:Heatmap">
<ogc:Function name="parameter">
<ogc:Literal>weightAttr</ogc:Literal>
<ogc:Literal></ogc:Literal>
</ogc:Function>
<ogc:Function name="parameter">
<ogc:Literal>radiusPixels</ogc:Literal>
<ogc:Literal>20</ogc:Literal>
</ogc:Function>
</ogc:Function>
</Transformation>
<Rule>
<RasterSymbolizer>
<Opacity>0.7</Opacity>
<ColorMap type="ramp">
<ColorMapEntry color="#0000FF" quantity="0" opacity="0"/>
<ColorMapEntry color="#00FF00" quantity="0.5" opacity="0.7"/>
<ColorMapEntry color="#FF0000" quantity="1" opacity="1"/>
</ColorMap>
</RasterSymbolizer>
</Rule>
</FeatureTypeStyle>
</UserStyle>
</NamedLayer>
</StyledLayerDescriptor>
A IA gera não só as cores, mas também parâmetros adaptados ao tamanho da amostra (por exemplo, ajustando o raio se a camada tiver muitos ou poucos pontos).
Você pode evoluir esse fluxo para:
- Rodar diariamente e gerar heatmaps atualizados com novos dados;
- Integrar ao GeoNode, atualizando automaticamente o estilo da camada;
- Usar IA para escolher paletas temáticas (ex.: “vermelho–amarelo” para calor humano, “verde–azul” para vegetação).
💡 Dica: para heatmaps temporais, combine com filtros SQL por data e gere um estilo dinâmico para cada período (ex.: “ocorrências_2025_01.sld”).
4. Conclusão
A combinação de PostGIS + IA + GeoServer permite criar pipelines geoespaciais realmente inteligentes capazes de analisar, gerar e publicar visualizações complexas de forma automática.
Esse tipo de automação é especialmente útil em projetos de monitoramento ambiental, urbano e operacional, onde o volume de dados cresce rapidamente. Veja alguns benefícios:
- Heatmaps automáticos e personalizados sem ajustes manuais.
- IA adaptando parâmetros de renderização conforme o dataset.
- Integração total com GeoServer via REST API.
- Atualização contínua, ideal para dashboards geoespaciais em tempo real.
Gostou desse post? Achou ele útil? Então que tal deixar um comentário ?
