Una parte considerevole dei dati generati ogni giorno è intrinsecamente spaziale. Dai dati di Osservazione della Terra e GPS ai dati inclusi in ogni tipo di mappa, i dati spaziali – noti anche come dati geospaziali o informazioni geografiche – sono dati per i quali a ogni record è associata una posizione specifica.
Ogni punto di un dato spaziale può essere localizzato su una mappa. Questo si fa usando un determinato sistema di riferimento delle coordinate, per esempio le coordinate geografiche, basate sulle consuete coppie latitudine-longitudine che usiamo per indicare dove si trova qualcosa sul globo. Questo ci permette di osservare le relazioni spaziali tra i dati.
Tuttavia, il vero punto di forza dei dati geospaziali è la combinazione tra i dati in sé e la loro posizione, sbloccando numerose opportunità per analisi sofisticate. La cosiddetta data science geospaziale è una sottodisciplina della data science che si concentra sull’estrazione di informazioni dai dati geospaziali sfruttando la potenza di algoritmi e tecniche analitiche spaziali, come il machine learning e il deep learning. In altre parole, la data science geospaziale ci aiuta a capire dove avvengono le cose e perché avvengono lì.
Esistono molti strumenti adatti alla data science geospaziale. Questo tutorial si concentrerà su GeoPandas, un pacchetto open source per lavorare con dati geospaziali in Python.
GeoPandas estende i tipi di dato usati da pandas – lo strumento standard per manipolare i dataframe in Python – per consentire operazioni spaziali su tipi geometrici. Poiché GeoPandas è costruito su pandas – e su altri popolari pacchetti Python per la data science, come matplotlib –, per i professionisti dei dati che usano Python è molto semplice prendere confidenza con la sintassi di GeoPandas.
Installare GeoPandas in Python
Per usare GeoPandas in Python, per prima cosa devi installarlo, proprio come qualsiasi altra libreria Python.
È importante notare che GeoPandas si appoggia a uno stack di librerie geospaziali open source per offrire tutto il suo potenziale spaziale, tra cui shapely, fiona, pyproj e rtree. Devi assicurarti di installare tutte queste dipendenze, altrimenti GeoPandas potrebbe non funzionare come previsto.
Per evitare complessità, GeoPandas consiglia di installare la libreria usando il gestore pacchetti conda. Questo significa che dovrai prima installare Anaconda. Per una guida su come installare e usare Anaconda, consulta il nostro tutorial.
Il vantaggio di usare conda è che fornisce binari precompilati per tutte le dipendenze richieste e opzionali di GeoPandas per tutti i sistemi operativi (Windows, Mac, Linux). Per installare GeoPandas da riga di comando:
>>conda install geopandasIn alternativa, puoi installare Anaconda usando pip, l’installer standard di pacchetti in Python. Come già detto, dovrai installare anche le dipendenze richieste. Se non conosci pip, ti consigliamo vivamente di leggere il nostro tutorial su Pip per la gestione dei pacchetti in Python. Il comando da eseguire per installare GeoPandas con pip è:
>>pip install geopandas In ogni caso, se riscontri problemi durante l’installazione di GeoPandas, consulta la documentazione per ulteriori informazioni.
Una volta installato il pacchetto, sei pronto per iniziare a usare GeoPandas. Importalo semplicemente nel tuo ambiente Python. Nota che è molto comune importare GeoPandas con l’alias gpd.
import geopandas as gpdOperazioni di base con GeoPandas
In questa sezione tratteremo le operazioni più basilari che puoi fare con GeoPandas. Nel farlo, introdurremo alcuni concetti chiave dell’analisi geospaziale, tra cui tipi di dati spaziali, formati dei dati spaziali e sistemi di riferimento delle coordinate (CRS).
Leggere e scrivere dati spaziali
Proprio come pandas richiede dati in input da convertire in un pandas dataframe, GeoPandas legge dati (spaziali) in input e li converte nel cosiddetto GeoDataFrame.
Prima di entrare nei molteplici tipi di file spaziali che GeoPandas può leggere, è importante distinguere i diversi tipi di dati spaziali. Il tipo di dato con cui abbiamo a che fare indica quali strumenti dovremmo usare per analizzare e poi visualizzare i dati.
In sostanza, esistono due principali tipi di dati spaziali:
- Dati vettoriali. Descrivono le caratteristiche di posizioni geografiche sulla Terra tramite l’uso di geometrie discrete, ovvero:
- Punto. Posizioni individuali, come un edificio o un’auto, con coordinate X e Y.
- Linea. Una serie di punti connessi che descrivono elementi come strade o corsi d’acqua.
- Poligono. Formato da una linea chiusa che racchiude un’area, come i confini di un paese. Inoltre, quando una geometria è composta da più elementi, la chiamiamo MultiPolygon.
- Dati raster. Rappresentano il mondo come una superficie continua in forma di griglia, come i pixel di un’immagine. Ogni parte della griglia può essere un valore continuo (per esempio un valore di elevazione) o una classificazione categoriale (per esempio classificazioni della copertura del suolo). Esempi classici includono dati di altitudine o immagini satellitari.
Fonte: Humboldt State University
Sia i dati vettoriali sia i raster di solito sono accompagnati da dati non spaziali, noti anche come attributi. I dati spaziali possono avere un numero qualsiasi di attributi aggiuntivi insieme alle informazioni sulla posizione. Per esempio, alla posizione di una scuola possono essere associati il nome dell’istituto, il numero di studenti o l’indirizzo.
GeoPandas è progettato per lavorare con dati vettoriali, anche se può facilmente collaborare con altri pacchetti Python per gestire dati raster, come rasterio. Per leggere dati spaziali, GeoPandas mette a disposizione la funzione geopandas.read_file(). Questa potente funzione può leggere automaticamente la maggior parte dei dati spaziali basati su vettori.
Alcuni dei formati di dati vettoriali più comuni sono:
- Shapefile. Essendo lo standard del settore, gli shapefile sono il formato di dati vettoriali più comune. Comprendono tre file solitamente forniti in un archivio zip:
- Il file .shp contiene la geometria delle forme.
- Il file .dbf contiene gli attributi per ogni geometria,
- Il file .shx, o indice delle forme, aiuta a collegare gli attributi alle geometrie.
- GeoJSON. È un formato più recente per i dati geospaziali rilasciato nel 2016. A differenza degli shapefile, GeoJSON è un singolo file, il che lo rende più facile da gestire.
Nei seguenti esempi useremo la funzione geopandas.read_file() per leggere un file GeoJSON ospitato su GitHub contenente dati geospaziali sui diversi distretti della città di Barcellona.
url = 'https://raw.githubusercontent.com/jcanalesluna/bcn-geodata/master/districtes/districtes.geojson'
districts = gpd.read_file(url)
districts
Torneremo a questo dataset tra un attimo, ma prima devi sapere come salvare un GeoDataFrame su file. È piuttosto semplice. Devi solo usare GeoDataFrame.to_file() per creare un file contenente i dati spaziali. Per impostazione predefinita, il formato del nuovo documento sarà uno shapefile, ma puoi cambiarlo con il parametro “driver”.
Per esempio, puoi salvare il GeoDataFrame dei distretti in un file geoJSON:
districts.to_file("districts.geojson", driver="GeoJSON")Esplorare i GeoDataFrame
Avrai notato che il GeoDataFrame nella sezione precedente somiglia a un tradizionale dataframe di pandas. La somiglianza ha senso, perché GeoDataFrame è una sottoclasse di pandas.DataFrame. Questo significa che eredita molti dei metodi e degli attributi dei dataframe di pandas. La novità del GeoDataFrame è che può memorizzare colonne di geometrie (note anche come GeoSeries) ed eseguire operazioni spaziali.
La colonna geometry può contenere qualsiasi tipo di dato vettoriale, come punti, linee e poligoni. Inoltre, è importante notare che, sebbene un GeoDataFrame possa avere più GeoSeries, solo una colonna è considerata la geometria attiva, il che significa che tutte le operazioni spaziali si baseranno su quella colonna.
Fonte: GeoPandas
Un’altra caratteristica importante dei GeoDataFrame è che ogni GeoSeries è accompagnata da informazioni CRS associate. Queste informazioni CRS dicono a GeoPandas dove si trovano le coordinate sulla Terra. Queste informazioni sono fondamentali per l’analisi spaziale. Per esempio, se devi combinare due dataset spaziali, devi assicurarti che siano espressi nello stesso CRS. Altrimenti, non otterrai il risultato previsto.
Esistono due principali categorie di CRS:
- Coordinate geografiche. Definiscono una posizione globale in gradi di latitudine e longitudine rispetto all’equatore e al meridiano di Greenwich. Con questo sistema possiamo indicare facilmente qualsiasi posizione sulla Terra. È ampiamente usato, per esempio, nel GPS. Il CRS più popolare è EPSG:4326, chiamato anche WGS84.
- Coordinate proiettate. Sebbene la Terra sia rotonda, di solito la rappresentiamo su una mappa bidimensionale. Le coordinate proiettate esprimono le posizioni nelle dimensioni X e Y, consentendoci così di lavorare con un’unità di lunghezza, come i metri, invece dei gradi, il che rende l’analisi più comoda ed efficace. Tuttavia, passare dalla Terra tridimensionale a una mappa bidimensionale comporta inevitabilmente delle distorsioni. Ecco perché esistono diversi approcci per creare coordinate proiettate. Per esempio, molti paesi hanno adottato un CRS proiettato standard per la loro particolare geografia.
C’è molto altro da dire sui CRS, ma esula dallo scopo di questo tutorial. Un’ottima risorsa per ulteriori informazioni ed esempi pratici è il nostro corso Working with Geospatial Data in Python.
In GeoPandas, le informazioni CRS sono memorizzate nell’attributo crs:
districts.crs
Il GeoDataFrame dei distretti è associato a coordinate geografiche (EPSG: 4326), ma vogliamo trasformarlo in coordinate proiettate, così da poter effettuare alcuni calcoli in metri. Trasformiamolo in EPSG:2062, il CRS proiettato standard per la Spagna. Possiamo farlo con il metodo Geopandas.to_crs().
districts.to_crs(epsg=2062, inplace=True)
districts.crs
Ora che abbiamo impostato il CRS proiettato giusto, siamo pronti a esplorare gli attributi dei GeoDataFrame.
Esplorare gli attributi di un dataset spaziale
GeoPandas eredita diversi metodi e attributi utili dal pacchetto shapely. Ne vedremo quattro.
Area
L’attributo area restituisce l’area calcolata di una geometria. Possiamo salvare l’area risultante (convertita in km2) in una nuova colonna:
districts['area'] = districts.area / 1000000
districts
Centroid
L’attributo centroid restituisce il punto centrale di una geometria. Possiamo aggiungerlo al nostro dataset, creando così una nuova colonna di geometrie.
districts['centroid']=districts.centroid
districts
Boundary
L’attributo boundary restituisce il contorno di un poligono.
districts['boundary']=districts.boundaryDistanza
Il metodo distance restituisce la distanza minima tra una geometria e una posizione. Supponiamo di voler calcolare la distanza dalla famosa chiesa della Sagrada Familia, situata nel distretto dell’Eixample, ai centroidi di ogni distretto di Barcellona, e poi aggiungere le distanze (in chilometri) in una nuova colonna.
La Sagrada Familia. Fonte: Wikipedia
Per prima cosa, dobbiamo creare un punto usando la funzione Point() di shapely con le coordinate desiderate (puoi trovarle facilmente su Google Maps), convertirlo in una GeoSeries con il CRS corretto e poi usare il metodo GeoPandas.distance():
from shapely.geometry import Point
sagrada_fam = Point(2.1743680500855005, 41.403656946781304)
sagrada_fam = gpd.GeoSeries(sagrada_fam, crs=4326)
sagrada_fam= sagrada_fam.to_crs(epsg=2062)
districts['sagrada_fam_dist'] = [float(sagrada_fam.distance(centroid)) / 1000 for centroid in districts.centroid]Il dataset risultante, dopo le operazioni spaziali precedenti, appare così:
Creare grafici con GeoPandas
Le operazioni spaziali che abbiamo eseguito forniscono informazioni utili per il nostro studio. Tuttavia, visualizzare le geometrie nello spazio è un ottimo modo per migliorare l’analisi. Fortunatamente, creare un grafico con GeoPandas è semplicissimo. Devi solo chiamare la funzione GeoDataFrame.plot(), costruita sul pacchetto matplotlib di Python.
Iniziamo con una visualizzazione di base dei distretti di Barcellona.
ax= districts.plot(figsize=(10,6))
Possiamo rendere il nostro grafico GeoPandas più informativo colorando ciascun distretto. Impostare la legenda su 'True' crea una legenda per aiutare a interpretare i colori.
ax= districts.plot(column=district_name', figsize=(10,6), edgecolor='black', legend=True)
Infine, possiamo aggiungere i centroidi dei distretti e la Sagrada Familia alla nostra mappa, oltre a un titolo. Inoltre, per rendere il grafico più coinvolgente, possiamo usare il pratico pacchetto contextily per aggiungere una mappa a tasselli della città di Barcellona.
import contextily
ax= districts.plot(column='district_name', figsize=(12,6), alpha=0.5, legend=True)
districts["centroid"].plot(ax=ax, color="green")
sagrada_fam.plot(ax=ax,color='black', marker='+')
contextily.add_basemap(ax, crs=districts.crs.to_string())
plt.title('A Beautiful Map of Barcelona')
plt.axis('off')
plt.show()
Bello, vero? C’è molto altro che puoi fare per creare splendide visualizzazioni spaziali. Il nostro corso Visualizing Spatial Data With Python è un’ottima risorsa per portare le tue capacità di visualizzazione al livello successivo.
Relazioni spaziali con GeoPandas
Uno degli aspetti fondamentali dei dati geospaziali è come si relazionano tra loro nello spazio. GeoPandas sfrutta la potenza dei pacchetti pandas e shapely per eseguire ogni tipo di relazione spaziale tra dataset spaziali. In questa sezione tratteremo alcune delle operazioni più comuni.
Join per attributi
In pandas ci sono due modi per combinare i dataset: join per attributi e join spaziali.
I join per attributi permettono di unire due GeoDataFrame in base a variabili non geometriche, proprio come un normale join in pandas. Infatti, il modo per eseguire join per attributi è tramite il metodo standard pandas.merge(). Se ti interessa saperne di più sui join in pandas, dai un’occhiata al nostro tutorial “Joining DataFrames in pandas”.
Per esempio, sarebbe interessante arricchire il nostro GeoDataFrame con i dati di popolazione di Barcellona nel 2022.
pop =pd.read_csv('poblacion_barna_2022.csv', usecols=['Nom_Districte','Nombre'])
pop = pd.DataFrame(pop.groupby('Nom_Districte')['Nombre'].sum()).reset_index()
pop.columns=['district_name','population_22']
districts = districts.merge(pop)
districtsv
Join spaziali
Al contrario, i join spaziali consentono di unire due GeoDataFrame in base alle loro relazioni spaziali.
Per esempio, identifichiamo i distretti in cui si trovano le piste ciclabili di Barcellona.
url = 'https://opendata-ajuntament.barcelona.cat/resources/bcn/CarrilsBici/CARRIL_BICI.geojson'
bike_lane = gpd.read_file(url)
bike_lane = bike_lane.loc[:,['ID','geometry']]
bike_lane.to_crs(epsg=2062, inplace=True)
In GeoPandas, l’operazione di join spaziale è disponibile come funzione sjoin(). Il primo argomento da specificare è il GeoDataFrame a cui vogliamo aggiungere informazioni, e il secondo è il GeoDataFrame che contiene le informazioni da aggiungere. Poi dobbiamo specificare il tipo di join. Infine, il parametro “predicate” indica a GeoPandas quale relazione spaziale usare per mettere in corrispondenza i due dataset. Alcune delle relazioni più comuni sono “intersects”, “contains” e “within”.
Nel nostro esempio useremo il predicato “intersects”. Due oggetti geometrici si intersecano se hanno in comune qualsiasi punto del bordo o dell’interno.
lanes_districts = gpd.sjoin(districts, bike_lane, how='inner', predicate='intersects')
lanes_districts
Nota che il GeoDataFrame risultante ha più righe del GeoDataFrame bike_lane. Questo perché una pista ciclabile può trovarsi in più di un distretto.
Infine, possiamo raggruppare il nostro dataset per ottenere il numero di piste ciclabili per distretto:
lanes_districts.groupby('district_name').size()
Operazioni di overlay in GeoPandas
Infine, gli overlay spaziali permettono di confrontare due GeoDataFrame contenenti geometrie poligonali o multipoligonali e creare un nuovo GeoDataFrame con le nuove geometrie che rappresentano la combinazione spaziale e le proprietà unite. L’immagine qui sotto mostra le diverse possibilità:
Fonte: GeoPandas
Immagina che il Comune di Barcellona voglia costruire nuovi parchi locali per affrontare l’inquinamento e promuovere il benessere della comunità. Un’idea preliminare è creare grandi parchi circolari entro 500 metri dal centro di ogni distretto. Possiamo simularlo creando un buffer basato sul centroide di ogni distretto.
parks = gpd.GeoDataFrame(districts.centroid.buffer(500), geometry=0)
parks.plot()
Ora siamo pronti a eseguire alcune operazioni di overlay. Per esempio, se vogliamo vedere solo le aree dei distretti in cui si troverebbero i parchi, possiamo usare il metodo GeoPandas.overlay():
parks_intersection = districts.overlay(parks, how='intersection')
ax = parks_intersection.plot(alpha=0.5, edgecolor='black', column='district_name')
Oppure, se vogliamo vedere i distretti senza l’area occupata dai parchi previsti, possiamo cambiare il parametro “how” per eseguire un’altra operazione di overlay.
parks_difference = districts.overlay(parks, how='difference')
ax = parks_difference.plot(alpha=0.5, edgecolor='black', column='district_name')
Conclusione
Speriamo che questo tutorial su GeoPandas ti sia piaciuto. L’analisi spaziale è uno dei domini più interessanti della data science e offre infinite opportunità per arricchire le tue analisi con informazioni basate sulla posizione. Esistono molti strumenti per l’analisi spaziale, ma se conosci già Python, GeoPandas è un ottimo punto di partenza.
Vuoi continuare a formarti in ambito geospaziale? Ci pensiamo noi! Dai un’occhiata ai seguenti materiali e diventa un maestro del geospaziale:
