Une part considérable des données générées chaque jour est intrinsèquement spatiale. Des données d’observation de la Terre et du GPS aux informations présentes dans tous types de cartes, les données spatiales – aussi appelées données géospatiales ou informations géographiques – associent une localisation précise à chaque enregistrement.
Chaque point spatial peut être situé sur une carte. On le fait à l’aide d’un système de référence de coordonnées, par exemple les coordonnées géographiques, basées sur les paires latitude-longitude que nous utilisons couramment pour indiquer un emplacement sur le globe. Cela nous permet d’examiner les relations spatiales entre les données.
La véritable puissance des données géospatiales réside toutefois dans la combinaison des valeurs et de leur localisation, ce qui ouvre la voie à des analyses avancées. La science des données géospatiales est une sous-discipline de la data science qui vise à extraire de l’information à partir de données géospatiales en s’appuyant sur des algorithmes spatiaux et des techniques analytiques, comme le machine learning et le deep learning. En d’autres termes, la data science géospatiale nous aide à comprendre où les phénomènes se produisent et pourquoi ils se produisent là.
De nombreux outils sont adaptés à la data science géospatiale. Ce tutoriel se concentre sur GeoPandas, un package open source pour travailler avec des données géospatiales en Python.
GeoPandas étend les types de données de pandas – l’outil de référence pour manipuler des dataframes en Python – afin d’autoriser des opérations spatiales sur des objets géométriques. Comme GeoPandas s’appuie sur pandas – ainsi que sur d’autres packages Python populaires pour la data science, comme matplotlib –, les professionnels des données qui utilisent Python adoptent facilement la syntaxe GeoPandas.
Installer GeoPandas pour Python
Pour utiliser GeoPandas en Python, vous devez d’abord l’installer, comme toute autre bibliothèque Python.
Important : GeoPandas repose sur une pile de bibliothèques géospatiales open source pour offrir tout son potentiel spatial, notamment shapely, fiona, pyproj et rtree. Assurez-vous d’installer ces dépendances, sinon GeoPandas risque de ne pas fonctionner comme prévu.
Pour éviter les complications, GeoPandas recommande d’installer la bibliothèque avec le gestionnaire de paquets conda. Vous devrez donc installer Anaconda au préalable. Pour un guide sur l’installation et l’utilisation d’Anaconda, consultez notre tutoriel.
L’avantage de conda est qu’il fournit des binaires précompilés pour toutes les dépendances requises et optionnelles de GeoPandas, sur tous les systèmes (Windows, Mac, Linux). Pour installer GeoPandas en ligne de commande :
>>conda install geopandasVous pouvez aussi installer GeoPandas avec pip, l’installateur standard de paquets en Python. Comme indiqué, vous devrez également installer les dépendances nécessaires. Si vous ne connaissez pas pip, nous vous recommandons vivement de lire notre tutoriel pip pour la gestion des paquets. La commande à exécuter pour installer GeoPandas avec pip est :
>>pip install geopandas En cas de difficultés lors de l’installation de GeoPandas, consultez la documentation pour plus d’informations.
Une fois le package installé, vous pouvez commencer à utiliser GeoPandas. Importez-le simplement dans votre environnement Python. Il est courant d’importer GeoPandas avec l’alias gpd.
import geopandas as gpdOpérations de base avec GeoPandas
Dans cette section, nous allons couvrir les opérations les plus basiques avec GeoPandas. Ce sera l’occasion d’introduire des notions clés de l’analyse géospatiale, notamment les types de données spatiales, les formats de données spatiales et les systèmes de référence de coordonnées (CRS).
Lecture et écriture de données spatiales
Tout comme pandas lit des données d’entrée pour produire un dataframe pandas, GeoPandas lit des données (spatiales) d’entrée et les convertit en ce que l’on appelle un GeoDataFrame.
Avant d’aborder les multiples formats de fichiers spatiaux que GeoPandas peut lire, il est essentiel de distinguer les différents types de données spatiales. Le type de données détermine les outils à utiliser pour analyser puis visualiser ces données.
On distingue essentiellement deux grands types de données spatiales :
- Données vectorielles. Elles décrivent des entités géographiques sur Terre à l’aide de géométries discrètes :
- Point. Localisations individuelles, comme un bâtiment ou une voiture, avec des coordonnées X et Y.
- Ligne. Une série de points connectés décrivant par exemple des routes ou des cours d’eau.
- Polygone. Formé par une ligne fermée qui délimite une zone, comme les frontières d’un pays. Lorsque qu’une entité regroupe plusieurs géométries, on parle de MultiPolygon.
- Données raster. Elles encodent le monde comme une surface continue représentée par une grille, à l’image des pixels d’une photo. Chaque cellule de la grille peut contenir une valeur continue (comme l’altitude) ou une classe catégorielle (comme une classe d’occupation des sols). Exemples classiques : données d’altitude ou images satellites.
Source : Humboldt State University
Les données vectorielles comme raster sont généralement accompagnées de données non spatiales, appelées attributs. Les données spatiales peuvent comporter un nombre quelconque d’attributs supplémentaires en plus des informations de localisation. Par exemple, la localisation d’une école peut être associée à son nom, son effectif ou son adresse.
GeoPandas est conçu pour travailler avec des données vectorielles, mais peut s’associer facilement à d’autres packages Python pour traiter des rasters, comme rasterio. Pour lire des données spatiales, GeoPandas propose la fonction geopandas.read_file(). Cette fonction puissante sait lire automatiquement la plupart des formats vectoriels courants.
Parmi les formats vectoriels les plus répandus :
- Shapefile. Considéré comme un standard de l’industrie, c’est le format vectoriel le plus courant. Il se compose de trois fichiers généralement fournis dans une archive zip :
- Le fichier .shp contient les géométries.
- Le fichier .dbf contient les attributs associés à chaque géométrie,
- Le fichier .shx, index des formes, permet de lier attributs et géométries.
- GeoJSON. Format plus récent, publié en 2016. À la différence des shapefiles, un GeoJSON tient dans un seul fichier, ce qui simplifie la manipulation.
Dans les exemples suivants, nous utiliserons la fonction geopandas.read_file() pour lire un fichier GeoJSON hébergé sur GitHub contenant des données géospatiales sur les différents districts de la ville de Barcelone.
url = 'https://raw.githubusercontent.com/jcanalesluna/bcn-geodata/master/districtes/districtes.geojson'
districts = gpd.read_file(url)
districts
Nous reviendrons sur ce jeu de données dans un instant, mais vous devez d’abord savoir comment écrire un GeoDataFrame dans un fichier. C’est très simple. Utilisez GeoDataFrame.to_file() pour créer un fichier contenant les données spatiales. Par défaut, le format sera un shapefile, mais vous pouvez le modifier avec le paramètre "driver".
Par exemple, vous pouvez enregistrer le GeoDataFrame des districts au format GeoJSON :
districts.to_file("districts.geojson", driver="GeoJSON")Explorer les GeoDataFrames
Vous avez peut-être remarqué que le GeoDataFrame de la section précédente ressemble à un dataframe pandas classique. C’est logique : GeoDataFrame est une sous-classe de pandas.DataFrame. Il hérite donc de nombreuses méthodes et attributs des dataframes pandas. La nouveauté, c’est qu’un GeoDataFrame peut stocker des colonnes de géométrie (appelées GeoSeries) et effectuer des opérations spatiales.
La colonne de géométrie peut contenir tout type de données vectorielles : points, lignes, polygones. Il est également important de noter que même si un GeoDataFrame peut comporter plusieurs GeoSeries, une seule colonne est considérée comme géométrie active : toutes les opérations spatiales se basent sur cette colonne.
Source : GeoPandas
Autre caractéristique importante : chaque GeoSeries est associée à des informations de CRS. Ce CRS indique à GeoPandas où se situent les coordonnées sur Terre. Ces informations sont essentielles pour l’analyse spatiale. Par exemple, si vous devez combiner deux jeux de données spatiales, ils doivent être exprimés dans le même CRS. Sinon, vous n’obtiendrez pas le résultat escompté.
On distingue deux grandes catégories de CRS :
- Coordonnées géographiques. Elles définissent une position globale en degrés de latitude et de longitude par rapport à l’équateur et au méridien d’origine. Avec ce système, on peut spécifier n’importe quel lieu sur Terre. Il est largement utilisé, par exemple dans le GPS. Le CRS le plus populaire est EPSG:4326, aussi appelé WGS84.
- Coordonnées projetées. La Terre est ronde, mais nous la représentons généralement sur une carte en deux dimensions. Les coordonnées projetées expriment les positions en X et Y, ce qui permet de travailler avec une unité de longueur (par exemple le mètre) plutôt qu’en degrés, rendant l’analyse plus pratique et efficace. Cependant, le passage d’un globe 3D à une carte 2D engendre inévitablement des distorsions. C’est pourquoi il existe différentes méthodes de projection. Par exemple, de nombreux pays ont adopté un CRS projeté standard adapté à leur géographie.
Il y aurait encore beaucoup à dire sur les CRS, mais cela dépasse le cadre de ce tutoriel. Une excellente ressource pour approfondir et voir des exemples concrets : notre cours Working with Geospatial Data in Python.
Dans GeoPandas, les informations de CRS sont stockées dans l’attribut crs :
districts.crs
Le GeoDataFrame des districts est associé à des coordonnées géographiques (EPSG:4326), mais nous souhaitons le transformer en coordonnées projetées afin d’effectuer des calculs en mètres. Convertissons-le en EPSG:2062, un CRS projeté utilisé en Espagne. Pour cela, utilisons la méthode Geopandas.to_crs().
districts.to_crs(epsg=2062, inplace=True)
districts.crs
Maintenant que nous avons défini un CRS projeté adéquat, nous pouvons explorer les attributs des GeoDataFrames.
Explorer les attributs d’un jeu de données spatial
GeoPandas hérite d’un certain nombre de méthodes et attributs utiles du package shapely. Nous allons en couvrir quatre.
Area
L’attribut area renvoie la surface calculée d’une géométrie. Nous pouvons enregistrer la surface (convertie en km2) dans une nouvelle colonne :
districts['area'] = districts.area / 1000000
districts
Centroid
L’attribut centroid renvoie le point central d’une géométrie. Nous pouvons l’ajouter à notre jeu de données, ce qui crée une nouvelle colonne de géométrie.
districts['centroid']=districts.centroid
districts
Boundary
L’attribut boundary renvoie la limite d’un polygone.
districts['boundary']=districts.boundaryDistance
La méthode distance donne la distance minimale entre une géométrie et un emplacement. Supposons que nous souhaitions calculer la distance entre la célèbre Sagrada Família, située dans le district de l’Eixample, et les centroïdes de chaque district de Barcelone, puis ajouter ces distances (en kilomètres) dans une nouvelle colonne.
La Sagrada Família. Source : Wikipédia
Nous devons d’abord créer un point avec la fonction Point() de shapely aux coordonnées souhaitées (faciles à récupérer sur Google Maps), le convertir en GeoSeries avec le bon CRS, puis utiliser la méthode 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]Le jeu de données obtenu après ces opérations spatiales ressemble à ceci :
Visualisation avec GeoPandas
Les opérations spatiales réalisées apportent des enseignements précieux. Mais visualiser vos géométries sur une carte est un excellent moyen d’enrichir l’analyse. Bonne nouvelle : créer un graphique avec GeoPandas est très simple. Il suffit d’appeler la fonction GeoDataFrame.plot(), qui s’appuie sur matplotlib.
Commençons par une visualisation basique des districts de Barcelone.
ax= districts.plot(figsize=(10,6))
Nous pouvons rendre ce graphique plus informatif en colorant chaque district. En définissant la légende à True, une légende facilite l’interprétation des couleurs.
ax= districts.plot(column=district_name', figsize=(10,6), edgecolor='black', legend=True)
Enfin, ajoutons les centroïdes des districts et la Sagrada Família à notre carte, ainsi qu’un titre. Pour donner plus de relief au rendu, utilisons le très pratique package contextily afin d’ajouter un fond de carte tuile de la ville de Barcelone.
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()
Sympa, non ? Vous pouvez aller bien plus loin pour créer de superbes visualisations spatiales. Notre cours Visualizing Spatial Data With Python est une excellente ressource pour passer au niveau supérieur.
Relations spatiales avec GeoPandas
L’un des points clés des données géospatiales est la façon dont elles se relient entre elles dans l’espace. GeoPandas s’appuie sur la puissance de pandas et shapely pour effectuer toutes sortes d’opérations de relation spatiale entre jeux de données. Dans cette section, nous couvrirons quelques opérations courantes.
Jointures attributaires
Il existe deux façons de combiner des jeux de données dans pandas : les jointures attributaires et les jointures spatiales.
Les jointures attributaires permettent d’assembler deux GeoDataFrames sur des variables non géométriques, comme une jointure classique dans pandas. On les réalise via la méthode standard pandas.merge(). Pour en savoir plus sur les jointures pandas, consultez notre tutoriel Joining DataFrames in pandas.
Par exemple, il serait intéressant d’enrichir notre GeoDataFrame avec les données de population de Barcelone en 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
Jointures spatiales
À l’inverse, les jointures spatiales permettent de fusionner deux GeoDataFrames en s’appuyant sur leurs relations spatiales.
Par exemple, identifions les districts dans lesquels se trouvent les pistes cyclables de Barcelone.
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)
Dans GeoPandas, la jointure spatiale est disponible via la fonction sjoin(). Le premier argument est le GeoDataFrame à enrichir, le second celui qui contient l’information à ajouter. Ensuite, on précise le type de jointure. Enfin, le paramètre "predicate" indique à GeoPandas quelle relation spatiale utiliser pour faire correspondre les deux jeux de données. Parmi les relations les plus courantes : "intersects", "contains" et "within".
Dans notre exemple, nous utilisons le prédicat "intersects". Deux objets géométriques s’intersectent s’ils partagent au moins un point de frontière ou d’intérieur.
lanes_districts = gpd.sjoin(districts, bike_lane, how='inner', predicate='intersects')
lanes_districts
Notez que le GeoDataFrame résultant comporte plus de lignes que le GeoDataFrame bike_lane. C’est parce qu’une piste cyclable peut se trouver dans plusieurs districts.
Enfin, nous pouvons agréger notre jeu de données pour obtenir le nombre de segments de piste cyclable par district :
lanes_districts.groupby('district_name').size()
Opérations d’overlay avec GeoPandas
Les overlays spatiaux permettent de comparer deux GeoDataFrames contenant des géométries de type polygone ou multipolygone et de créer un nouveau GeoDataFrame avec des géométries résultant de la combinaison spatiale, ainsi que des attributs fusionnés. L’illustration ci-dessous présente différentes possibilités :
Source : GeoPandas
Imaginons que la mairie de Barcelone souhaite créer de nouveaux parcs de quartier pour lutter contre la pollution et favoriser le bien-être. Une idée préliminaire consiste à créer de grands parcs circulaires dans un rayon de 500 m autour du centre de chaque district. Nous pouvons simuler cela en créant un buffer à partir du centroïde de chaque district.
parks = gpd.GeoDataFrame(districts.centroid.buffer(500), geometry=0)
parks.plot()
Nous sommes maintenant prêts à effectuer des opérations d’overlay. Par exemple, si nous voulons ne voir que les zones des districts où se situeraient les parcs, nous pouvons utiliser la méthode GeoPandas.overlay() :
parks_intersection = districts.overlay(parks, how='intersection')
ax = parks_intersection.plot(alpha=0.5, edgecolor='black', column='district_name')
Ou, si nous voulons visualiser les districts sans la surface occupée par les parcs projetés, il suffit de changer le paramètre "how" pour effectuer une autre opération d’overlay.
parks_difference = districts.overlay(parks, how='difference')
ax = parks_difference.plot(alpha=0.5, edgecolor='black', column='district_name')
Conclusion
Nous espérons que ce tutoriel GeoPandas vous a plu. L’analyse spatiale est l’un des domaines les plus stimulants de la data science, offrant d’infinies possibilités pour enrichir vos analyses par la localisation. Les outils ne manquent pas, mais si vous maîtrisez déjà Python, GeoPandas est un excellent point de départ.
Envie de poursuivre votre montée en compétences en géospatial ? On s’occupe de tout ! Découvrez les ressources ci-dessous et devenez un expert du sujet :