GeoLibre Python: Mappe Interattive Geospaziali con Streamlit

GeoLibre è una libreria Python che permette di creare rapidamente applicazioni web interattive per la visualizzazione e l’analisi di dati geospaziali, combinando la potenza di Streamlit con librerie GIS consolidate come Geopandas e Rasterio.

Funzionalità Chiave di GeoLibre

Funzionalità	Descrizione	Vantaggi Operativi
Visualizzazione Vettoriale	Carica e mostra punti, linee, poligoni da Geopandas DataFrames.	Mappatura rapida di confini, percorsi, punti di interesse.
Visualizzazione Raster	Supporto per immagini georeferenziate (es. satellitari, DEM) con Rasterio.	Analisi del territorio, monitoraggio ambientale, modelli di elevazione.
Mappe Interattive	Basate su Folium/Leaflet, con zoom, pan, tooltip e popup configurabili.	Esplorazione intuitiva dei dati, identificazione rapida di dettagli.
Dashboard Streamlit	Trasforma script Python in web app interattive con widget.	Condivisione facile con non-tecnici, prototipazione rapida di soluzioni GIS.
Layer Control	Gestione dei layer visibili (on/off) direttamente dalla UI.	Confronto immediato tra diversi set di dati sulla stessa mappa.

GeoLibre nasce dall’esigenza di democratizzare l’accesso e la visualizzazione dei dati geospaziali, spesso confinati in software desktop complessi e costosi. In un’organizzazione con 2.000 endpoint e centinaia di VM, la capacità di analizzare rapidamente la distribuzione geografica di asset, incidenti o risorse può ridurre significativamente i tempi di risposta e migliorare la pianificazione. Immagina di dover visualizzare la densità di alert di sicurezza su una mappa per identificare hot-spot geografici, o la distribuzione di sensori IoT. GeoLibre offre una soluzione agile, sfruttando l’ecosistema Python già familiare a molti data scientist e ingegneri, per trasformare dati grezzi in insight visivi azionabili in pochi minuti. Questo articolo ti guiderà attraverso l’installazione e l’uso pratico di GeoLibre, così potrai iniziare a creare le tue mappe interattive oggi stesso.

Testato su: Ubuntu 24.04 LTS · Python 3.10 · GeoLibre 0.1.0 · Luglio 2026

Prerequisiti / Ambiente di test

Per seguire questa guida, avrai bisogno di un ambiente Python 3.8+ con pip installato. È consigliabile creare un ambiente virtuale per isolare le dipendenze del progetto. I comandi sono stati testati su un sistema Ubuntu 24.04 LTS, ma sono compatibili con qualsiasi distribuzione Linux, macOS o Windows con Python correttamente configurato.

Per iniziare, installa GeoLibre e le sue dipendenze principali:

python3 -m venv geolibre_env
source geolibre_env/bin/activate
pip install geolibre

Questa installazione include Streamlit, Geopandas e Folium, le librerie fondamentali su cui GeoLibre si basa per la gestione e la visualizzazione dei dati geospaziali.

1. Caricare e visualizzare dati vettoriali (Punti)

Il caso d’uso più comune è la visualizzazione di punti da un dataset tabellare, come un file CSV o un Geopandas DataFrame. Supponiamo di avere un file dati_celle_5g.csv con colonne latitudine, longitudine e id_cella.

Crea un file chiamato app_punti.py:

import streamlit as st
import geolibre as gl
import pandas as pd

st.set_page_config(layout="wide")
st.title("Mappa Interattiva Celle 5G")

# Carica i dati (sostituisci con il tuo percorso o carica da file)
data = {
    'id_cella': ['Cella_A', 'Cella_B', 'Cella_C', 'Cella_D', 'Cella_E'],
    'latitudine': [41.9028, 41.8919, 41.9050, 41.8800, 41.9100],
    'longitudine': [12.4964, 12.5113, 12.4800, 12.5000, 12.5200]
}
df = pd.DataFrame(data)

st.write("### Dati delle Celle 5G")
st.dataframe(df)

# Inizializza la mappa
mappa = gl.Map(center=[df['latitudine'].mean(), df['longitudine'].mean()], zoom=12)

# Aggiungi punti dal DataFrame
mappa.add_points_from_dataframe(
    df,
    lat='latitudine',
    lon='longitudine',
    tooltip='id_cella',
    color='red',
    radius=8
)

# Mostra la mappa in Streamlit
st.write("### Visualizzazione su Mappa")
mappa.st_map(height=600)

Per eseguire l’applicazione e visualizzare la mappa nel tuo browser:

streamlit run app_punti.py

Verrà aperta una pagina web che mostra una tabella con i dati e una mappa interattiva con i punti delle celle. Puoi fare zoom, pan e cliccare sui punti per vedere il tooltip.

2. Lavorare con layer vettoriali complessi (Poligoni)

GeoLibre supporta anche layer vettoriali più complessi come i poligoni, ideali per rappresentare aree geografiche, confini amministrativi o zone di copertura. Utilizzeremo un file GeoJSON, un formato standard per dati geospaziali.

Crea un file app_poligoni.py e un file confini_roma.geojson (puoi trovare esempi online o generare il tuo).

import streamlit as st
import geolibre as gl
import geopandas as gpd

st.set_page_config(layout="wide")
st.title("Mappa Interattiva Confini Amministrativi")

# Carica un GeoJSON (esempio fittizio, sostituisci con un GeoJSON reale)
# Esempio di GeoJSON per un singolo poligono (es. un quartiere di Roma)
geoj_data = {
    "type": "FeatureCollection",
    "features": [
        {
            "type": "Feature",
            "properties": {"nome": "Quartiere_A", "popolazione": 15000},
            "geometry": {
                "type": "Polygon",
                "coordinates": [[
                    [12.49, 41.90], [12.50, 41.90], [12.50, 41.89], [12.49, 41.89], [12.49, 41.90]
                ]]
            }
        },
        {
            "type": "Feature",
            "properties": {"nome": "Quartiere_B", "popolazione": 22000},
            "geometry": {
                "type": "Polygon",
                "coordinates": [[
                    [12.50, 41.91], [12.51, 41.91], [12.51, 41.90], [12.50, 41.90], [12.50, 41.91]
                ]]
            }
        }
    ]
}

# Converti in GeoDataFrame
gdf = gpd.GeoDataFrame.from_features(geoj_data['features'], crs="EPSG:4326")

st.write("### Dati Geografici dei Quartieri")
st.dataframe(gdf)

# Inizializza la mappa
mappa = gl.Map(center=[41.90, 12.50], zoom=12)

# Aggiungi i poligoni dal GeoDataFrame
mappa.add_gdf(
    gdf,
    name='Quartieri',
    style_function=lambda x: {'fillColor': 'blue', 'color': 'black', 'weight': 1, 'fillOpacity': 0.5},
    tooltip_columns=['nome', 'popolazione']
)

# Aggiungi il controllo dei layer
mappa.add_layer_control()

st.write("### Visualizzazione Poligoni su Mappa")
mappa.st_map(height=600)

Esegui con:

streamlit run app_poligoni.py

Vedrai i poligoni rappresentati sulla mappa. Il LayerControl ti permetterà di attivare/disattivare la visibilità dei layer. Questa funzionalità è cruciale quando si lavora con molteplici set di dati sovrapposti. Leggi anche: Prometheus Alerting: Configurare AlertManager con Notifiche Telegram, Email e PagerDuty (2026)

3. Visualizzazione di dati Raster

Per i dati raster, come immagini satellitari o modelli digitali di elevazione (DEM), GeoLibre si integra con Rasterio. Supponiamo tu abbia un file dem.tif (un tipico formato raster georeferenziato).

import streamlit as st
import geolibre as gl
import rasterio
import numpy as np

st.set_page_config(layout="wide")
st.title("Mappa Interattiva Dati Raster")

# Creazione di un raster fittizio per dimostrazione
# In un caso reale, useresti rasterio.open('percorso/al/tuo/file.tif')
height = 100
width = 100
rows, cols = np.indices((height, width))
data = np.sin(rows / 10) + np.cos(cols / 10)
transform = rasterio.transform.from_bounds(12.48, 41.88, 12.52, 41.92, width, height)

# Inizializza la mappa
mappa = gl.Map(center=[41.90, 12.50], zoom=12)

# Aggiungi il layer raster
mappa.add_raster(data, transform, caption='DEM Fittizio', cmap='viridis')

# Mostra la mappa in Streamlit
st.write("### Visualizzazione Dati Raster su Mappa")
mappa.st_map(height=600)

Esegui con streamlit run app_raster.py. Questo ti permetterà di visualizzare dati raster direttamente sulla mappa, combinando la ricchezza delle informazioni spaziali con l’interattività di GeoLibre. Leggi anche: LVM Snapshot: Rollback Sicuro per Aggiornamenti Critici

Errori comuni e troubleshooting

Missing geopandas or rasterio dependencies: Anche se pip install geolibre dovrebbe installare le dipendenze principali, a volte in ambienti complessi possono mancare alcune librerie di sistema necessarie per geopandas o rasterio. Assicurati di avere installato libspatialindex-dev (su Debian/Ubuntu) o gdal-devel (su Fedora/CentOS) prima di installare GeoLibre.

    sudo apt-get update && sudo apt-get install libspatialindex-dev

st.set_page_config() error: Questo comando deve essere la prima cosa che Streamlit esegue. Assicurati che non ci sia altro codice Streamlit (es. st.title() o st.write()) prima di st.set_page_config() nel tuo script.

Dati non visualizzati correttamente: Controlla sempre che le colonne lat e lon nel tuo DataFrame siano numeriche e che i valori rientrino in un intervallo geografico valido (-90 a 90 per la latitudine, -180 a 180 per la longitudine). Un errore comune è scambiare latitudine e longitudine, o usare formati di coordinate non standard.

FAQ — Domande Frequenti

GeoLibre è adatto per applicazioni in produzione con grandi dataset?

GeoLibre, essendo basato su Streamlit, è eccellente per prototipazione rapida, analisi interattive e dashboard interne. Per dataset estremamente grandi o applicazioni con requisiti di performance molto elevati, potrebbe essere necessario ottimizzare le query o considerare soluzioni backend più robuste, pur mantenendo Streamlit/GeoLibre per il frontend di visualizzazione.

Posso personalizzare l’aspetto delle mappe?

Assolutamente sì. GeoLibre espone molte delle funzionalità di Folium e Leaflet. Puoi personalizzare colori, icone, tooltip, popup e aggiungere stili specifici tramite le funzioni add_points_from_dataframe, add_gdf e add_raster, spesso passando funzioni di stile personalizzate o parametri direttamente alle chiamate.

È possibile integrare GeoLibre con un database geospaziale come PostGIS?

Sì, puoi connettere GeoLibre a PostGIS o altri database geospaziali. Il flusso tipico sarebbe usare sqlalchemy e geopandas.read_postgis per caricare i dati direttamente dal database in un GeoDataFrame, e poi passare questo GeoDataFrame a GeoLibre per la visualizzazione. Questo ti permette di sfruttare la potenza di PostGIS per le query spaziali e GeoLibre per il frontend.

GeoLibre supporta proiezioni diverse da EPSG:4326 (WGS84)?

Internamente, le mappe web basate su Leaflet/Folium operano principalmente con EPSG:4326. Se i tuoi dati sono in una proiezione diversa, geopandas offre funzioni per riproiettare i GeoDataFrame (es. gdf.to_crs("EPSG:4326")) prima di passarli a GeoLibre. Questo è un passaggio standard quando si lavora con dati geospaziali di diversa origine.

Conclusioni con takeaway operativi

GeoLibre rappresenta un ponte significativo tra la complessità dei dati geospaziali e la facilità d’uso delle applicazioni web interattive in Python. La sua integrazione con Streamlit permette a sysadmin, data scientist e analisti di creare dashboard funzionali e condivisibili con uno sforzo minimo. La possibilità di trasformare un semplice foglio di calcolo con coordinate in una mappa interattiva è un game-changer per l’analisi rapida e la visualizzazione di scenari critici, dalla distribuzione di risorse IT alla mappatura di eventi di sicurezza. Adottare GeoLibre può ridurre il tempo speso per la visualizzazione dei dati e aumentare la loro fruibilità all’interno del tuo team. Leggi anche: Elasticsearch OOM: Cluster RED per Shard Sbagliato

Fonti

Aggiornato: Luglio 2026