Chargement et manipulation de données géographiques

  • gpd.read_file()

    La fonction gpd.read_file() permet de lire un fichier géospatial (par exemple, un Shapefile, GeoJSON, etc.) et de le charger sous forme de GeoDataFrame. Elle est utilisée pour importer des données géographiques à partir de fichiers externes dans un format compatible avec GeoPandas.

    Importation :
    import geopandas as gpd
    Attributs :
    Paramètre Type Description Valeur par défaut
    filename str Le chemin du fichier à lire (ex : « data.shp », « data.geojson »). None
    crs str Le système de référence de coordonnées (CRS) souhaité. Si non précisé, GeoPandas essaie de détecter le CRS du fichier. None
    bbox tuple Une boîte délimitée (bbox) pour restreindre la lecture aux géométries à l’intérieur de cette boîte (optionnel). None
    Exemple de code :
    import geopandas as gpd

# Chargement d'un fichier Shapefile dans un GeoDataFrame
gdf = gpd.read_file("data.shp")

# Affichage des 5 premières lignes du GeoDataFrame
print(gdf.head())
    Explication du code :

    1. La fonction gpd.read_file() est utilisée pour charger un fichier Shapefile (data.shp) dans un GeoDataFrame.

    2. Une fois le fichier chargé, la méthode head() est appelée pour afficher les 5 premières lignes du GeoDataFrame.

    3. Le fichier peut être d’un autre format pris en charge, comme GeoJSON, KML, etc. GeoPandas gère automatiquement les différents types de fichiers géospatiaux.

    Remarque importante :

    • gpd.read_file() est une méthode très pratique pour charger des données géospatiales en provenance de fichiers. Elle gère la conversion automatique du système de coordonnées (CRS) si le fichier en contient un.

    • Si le fichier a un CRS différent de celui attendu ou si vous souhaitez spécifier un CRS différent lors du chargement, vous pouvez utiliser le paramètre crs.

    • Vous pouvez également utiliser le paramètre bbox pour ne charger qu’une partie des données géographiques à l’intérieur d’une zone géographique spécifique.

  • GeoDataFrame.to_file()

    La méthode GeoDataFrame.to_file() permet de sauvegarder un GeoDataFrame dans un fichier au format spécifié (par exemple, shapefile, GeoJSON, etc.). Elle prend en charge divers formats géospatiaux populaires pour l’exportation des données géométriques.

    Importation :
    import geopandas as gpd
    Attributs :
    Paramètre Type Description Valeur par défaut
    filename str Le chemin du fichier de sortie (ex: « output.shp », « output.geojson »). None
    driver str Le format du fichier de sortie (par exemple, « ESRI Shapefile », « GeoJSON »). None
    schema dict Schéma pour le fichier de sortie (optionnel, dépend du format). None
    Exemple de code :
    import geopandas as gpd
from shapely.geometry import Point

# Création d’un GeoDataFrame avec quelques données
gdf = gpd.GeoDataFrame({
    'id': [1, 2, 3],
    'geometry': [Point(0, 0), Point(1, 1), Point(2, 2)],
    'name': ['A', 'B', 'C']
}, crs="EPSG:4326")  # WGS84 (Latitude/Longitude)

# Sauvegarde du GeoDataFrame en format Shapefile
gdf.to_file("output.shp")
    Explication du code :

    1. Un GeoDataFrame est créé avec des géométries simples (des points) et quelques autres colonnes.

    2. La méthode to_file() est utilisée pour exporter le GeoDataFrame au format Shapefile (ici « output.shp »).

    3. Le fichier de sortie sera créé dans le même répertoire que celui où le script est exécuté, à moins qu’un chemin complet ne soit fourni.

    Remarque importante :

    • Vous pouvez spécifier le format du fichier de sortie avec le paramètre driver si nécessaire. Par exemple, pour un fichier GeoJSON, vous pourriez utiliser driver="GeoJSON".

    • La méthode to_file() est flexible et prend en charge plusieurs formats, dont Shapefile, GeoJSON, et d’autres formats pris en charge par la bibliothèque fiona utilisée par GeoPandas.

    • Le paramètre schema peut être utilisé pour définir explicitement la structure des données à sauvegarder, notamment les types des colonnes, mais il est optionnel dans de nombreux cas.

  • GeoDataFrame.head()

    La méthode GeoDataFrame.head() permet de visualiser les premières lignes d’un GeoDataFrame. Par défaut, elle retourne les 5 premières lignes, ce qui est utile pour examiner rapidement un échantillon de données et vérifier leur structure.

    Importation :
    import geopandas as gpd
    Attributs :
    Paramètre Type Description Valeur par défaut
    n int Le nombre de lignes à afficher (par défaut 5). 5
    Exemple de code :
    import geopandas as gpd
from shapely.geometry import Point

# Création d’un GeoDataFrame avec quelques données
gdf = gpd.GeoDataFrame({
    'id': [1, 2, 3],
    'geometry': [Point(0, 0), Point(1, 1), Point(2, 2)],
    'name': ['A', 'B', 'C']
}, crs="EPSG:4326")  # WGS84 (Latitude/Longitude)

# Affichage des premières lignes du GeoDataFrame
print(gdf.head())
    Explication du code :

    1. Un GeoDataFrame est créé avec des données simples contenant des identifiants, des géométries (points) et des noms.

    2. La méthode head() est utilisée pour afficher les 5 premières lignes de ce GeoDataFrame.

    3. Le résultat est un aperçu rapide du contenu du GeoDataFrame, incluant les colonnes id, geometry et name pour les premières lignes.

    Remarque importante :

    • La méthode head() est particulièrement utile pour explorer un GeoDataFrame avant de l’analyser ou de le manipuler davantage. Vous pouvez aussi spécifier un autre nombre de lignes à afficher en passant un argument n (par exemple, gdf.head(10) pour afficher les 10 premières lignes).

    • Cette méthode est identique à celle de pandas.DataFrame.head(), mais elle affiche les géométries dans le format approprié pour un GeoDataFrame.

  • GeoDataFrame.to_crs()

    La méthode GeoDataFrame.to_crs() permet de transformer les coordonnées géographiques d’un GeoDataFrame dans un autre système de référence de coordonnées (CRS - Coordinate Reference System). Cela est utile pour effectuer des calculs géospatiaux ou pour standardiser les données selon un CRS spécifique.

    Importation :
    import geopandas as gpd
    Attributs :
    Paramètre Type Description Valeur par défaut
    crs str, dict ou pyproj.CRS Système de référence de coordonnées (CRS) cible dans lequel les géométries doivent être transformées. None
    epsg int Code EPSG du CRS cible. Utilisé si crs est défini comme None. None
    always_xy bool Si True, force l’utilisation des coordonnées cartésiennes (X, Y), même pour les systèmes géographiques. False
    Exemple de code :
    import geopandas as gpd
from shapely.geometry import Point

# Création d’un GeoDataFrame avec un système de coordonnées géographiques (WGS84)
gdf = gpd.GeoDataFrame({
    'id': [1, 2, 3],
    'geometry': [Point(0, 0), Point(1, 1), Point(2, 2)],
    'name': ['A', 'B', 'C']
}, crs="EPSG:4326")  # WGS84 (Latitude/Longitude)

# Transformation des coordonnées en un CRS projeté (par exemple, UTM)
gdf_transformed = gdf.to_crs(epsg=32633)  # UTM zone 33N

# Affichage du GeoDataFrame après transformation du CRS
print(gdf_transformed)
    Explication du code :

    1. Un GeoDataFrame est créé avec un système de référence de coordonnées (CRS) basé sur le système WGS84 (EPSG:4326), qui est un système de coordonnées géographiques couramment utilisé pour la latitude et la longitude.

    2. La méthode to_crs(epsg=32633) est utilisée pour transformer les coordonnées du GeoDataFrame en un autre CRS, ici le système de projection UTM zone 33N (EPSG:32633), qui est un système de coordonnées projetées utilisé pour des calculs plus précis sur de petites zones géographiques.

    3. Le GeoDataFrame résultant possède des coordonnées projetées selon le CRS spécifié, et il peut être utilisé pour des calculs géospatiaux précis ou pour l’affichage sur des cartes dans ce CRS.

    Remarque importante :

    • Avant de transformer les coordonnées d’un GeoDataFrame, il est essentiel que celui-ci ait déjà un CRS défini. Si vous avez un GeoDataFrame sans CRS ou dans un CRS inconnu, vous devrez d’abord lui attribuer un CRS avec set_crs().

    • L’utilisation de codes EPSG est courante pour spécifier des CRS, mais vous pouvez aussi utiliser une chaîne de caractères ou un dictionnaire décrivant le CRS cible.

  • GeoDataFrame.set_index()

    La méthode GeoDataFrame.set_index() permet de définir une ou plusieurs colonnes comme index d'un GeoDataFrame. Cela permet de réorganiser les données et de faciliter les opérations de recherche et d'indexation.

    Importation :
    import geopandas as gpd
    Attributs :
    Paramètre Type Description Valeur par défaut
    keys str ou list Nom(s) de la ou des colonnes à utiliser comme index. None
    drop bool Si True, supprime la colonne utilisée comme index du DataFrame. True
    inplace bool Si True, modifie le GeoDataFrame en place, sinon retourne un nouveau GeoDataFrame. False
    verify_integrity bool Vérifie l’intégrité des index, s’assurant qu’ils sont uniques. False
    Exemple de code :
    import geopandas as gpd
from shapely.geometry import Point

# Création d’un GeoDataFrame avec des géométries
gdf = gpd.GeoDataFrame({
    'id': [1, 2, 3],
    'geometry': [Point(0, 0), Point(1, 1), Point(2, 2)],
    'name': ['A', 'B', 'C']
})

# Définir 'id' comme index
gdf_set_index = gdf.set_index('id')

# Affichage du GeoDataFrame après modification de l'index
print(gdf_set_index)
    Explication du code :

    1. Un GeoDataFrame est créé avec trois colonnes : id, geometry et name.

    2. Nous utilisons set_index('id') pour définir la colonne id comme index du GeoDataFrame.

    3. Après l’exécution de cette ligne, le GeoDataFrame est réorganisé, et la colonne id devient l’index. Ce qui signifie que la colonne id ne fera plus partie des données du DataFrame, sauf si drop=False est spécifié.

    4. Le GeoDataFrame modifié est ensuite affiché, et on remarque que la colonne id a été déplacée en tant qu’index, ce qui facilite les recherches et les manipulations basées sur cet index.

    Remarque importante :

    • Si vous ne souhaitez pas supprimer la colonne utilisée comme index, vous pouvez définir drop=False. Cela conservera la colonne dans le GeoDataFrame, tout en la rendant l’index.

    • Le paramètre verify_integrity permet de vérifier si les valeurs de l’index sont uniques. Si vous souhaitez garantir qu’il n’y a pas de doublons dans l’index, il peut être utile de définir ce paramètre sur True.

  • GeoDataFrame.drop()

    La méthode GeoDataFrame.drop() permet de supprimer des colonnes ou des lignes d’un GeoDataFrame. Cette fonction est identique à celle de pandas.DataFrame.drop(), mais elle conserve la géométrie du GeoDataFrame et peut supprimer des colonnes de données géospatiales.

    Importation :
    import geopandas as gpd
    Attributs :
    Paramètre Type Description Valeur par défaut
    labels str ou list Nom(s) de la ou des colonnes ou index à supprimer. None
    axis int, str Si 0, supprime les lignes ; si 1, supprime les colonnes. 0
    inplace bool Si True, modifie le GeoDataFrame en place, sinon retourne un nouveau GeoDataFrame. False
    errors str Si 'raise', lève une erreur si la colonne ou ligne n’existe pas. Si 'ignore', ne fait rien si la colonne ou ligne n’existe pas. 'raise'
    Exemple de code :
    import geopandas as gpd
from shapely.geometry import Point

# Création d’un GeoDataFrame avec des géométries
gdf = gpd.GeoDataFrame({
    'id': [1, 2, 3],
    'geometry': [Point(0, 0), Point(1, 1), Point(2, 2)],
    'name': ['A', 'B', 'C']
})

# Suppression de la colonne 'name'
gdf_dropped = gdf.drop('name', axis=1)

# Affichage du GeoDataFrame après suppression
print(gdf_dropped)
    Explication du code :

    Nous créons un GeoDataFrame avec des colonnes id, geometry et name. Ensuite, on supprime la colonne name du GeoDataFrame, en conservant les géométries.

    Avantages :

    • Utile pour nettoyer un GeoDataFrame en supprimant des colonnes non nécessaires ou des lignes indésirables.

    • Conserve la géométrie lors de la suppression.

    • Option inplace=True permet de modifier directement le GeoDataFrame sans avoir à créer une nouvelle variable.

  • GeoDataFrame.merge()

    La méthode GeoDataFrame.merge() permet de fusionner un GeoDataFrame avec un autre DataFrame (ou GeoDataFrame) en se basant sur une ou plusieurs colonnes communes. Elle fonctionne comme pandas.merge(), tout en conservant les géométries.

    Importation :
    import geopandas as gpd
import pandas as pd
    Attributs :
    Paramètre Type Description Valeur par défaut
    right DataFrame ou GeoDataFrame Le DataFrame à fusionner avec le GeoDataFrame de gauche. None
    how str Type de jointure : 'left', 'right', 'outer', 'inner'. 'inner'
    on str ou list Nom(s) de colonne(s) à utiliser pour la jointure. None
    left_on str Colonne du GeoDataFrame de gauche à utiliser pour la jointure. None
    right_on str Colonne du DataFrame de droite à utiliser pour la jointure. None
    suffixes tuple(str, str) Suffixes à utiliser pour les colonnes dupliquées. ('x', 'y')
    Exemple de code :
    import geopandas as gpd
import pandas as pd
from shapely.geometry import Point

# GeoDataFrame avec des géométries
gdf = gpd.GeoDataFrame({
    'id': [1, 2, 3],
    'geometry': [Point(0, 0), Point(1, 1), Point(2, 2)]
})

# DataFrame à fusionner
df = pd.DataFrame({
    'id': [1, 2, 3],
    'nom': ['A', 'B', 'C']
})

# Fusion basée sur la colonne 'id'
merged = gdf.merge(df, on='id')

# Affichage du résultat
print(merged)
    Explication du code :

    On fusionne un GeoDataFrame contenant des points avec un DataFrame contenant des noms.
    La jointure est faite sur la colonne commune id.

    Avantages :

    • Permet d’enrichir un GeoDataFrame avec des données tabulaires.

    • Compatible avec toutes les options de fusion de pandas.merge.

    • Les géométries sont automatiquement conservées après la fusion.

  • GeoDataFrame.buffer()

    La méthode GeoDataFrame.buffer() permet de créer une zone tampon (buffer) autour de chaque géométrie du GeoDataFrame, à une distance spécifiée. C’est particulièrement utile pour modéliser des zones d’influence, des périmètres de sécurité, ou encore pour les analyses de proximité.

    Importation :
    import geopandas as gpd
    Attributs :
    Paramètre Type Description Valeur par défaut
    distance float ou array-like Distance du buffer (dans les unités de projection, ex : mètres). None
    resolution int Nombre de segments utilisés pour approximer un quart de cercle. 16
    cap_style int Style de terminaison des buffers linéaires : 1 = rond, 2 = plat, 3 = carré. 1
    join_style int Style de jonction entre segments : 1 = rond, 2 = plat, 3 = biseauté. 1
    Exemple de code :
    import geopandas as gpd
from shapely.geometry import Point
import matplotlib.pyplot as plt

# Création d’un GeoDataFrame avec un point
gdf = gpd.GeoDataFrame(geometry=[Point(0, 0)])

# Création d’un buffer de 1 unité autour du point
buffered = gdf.buffer(1)

# Affichage
base = gdf.plot(color='red')
buffered.plot(ax=base, color='lightblue', alpha=0.5, edgecolor='blue')
plt.title("Buffer autour d’un point")
plt.show()
    Explication du code :

    On crée un point au centre (0,0), puis on applique un buffer de rayon 1.
    La zone bleue représente l’aire tampon générée autour du point rouge.

    Avantages :

    • Essentiel pour les analyses spatiales de proximité.

    • Permet de créer des zones d’influence ou de sécurité.

    • Fonctionne aussi bien sur des points, lignes ou polygones.

  • GeoDataFrame.intersection()

    La méthode GeoDataFrame.intersection() permet de calculer l’intersection géométrique entre chaque géométrie d’un GeoDataFrame et une géométrie ou un autre GeoSeries. Elle retourne les zones communes entre les objets — c’est une opération essentielle en géotraitement (ex : croisement entre limites administratives et zones naturelles).

    Importation :
    import geopandas as gpd
from shapely.geometry import Polygon
    Attributs :
    Paramètre Type Description Valeur par défaut
    other GeoSeries ou GeoDataFrame Objet géospatial avec lequel calculer l’intersection. None
    align bool Si True, aligne les index entre self et other avant intersection. True
    Exemple de code :
    import geopandas as gpd
from shapely.geometry import Polygon
import matplotlib.pyplot as plt

# Création d'un GeoDataFrame avec un polygone
poly1 = Polygon([(0, 0), (2, 0), (2, 2), (0, 2)])
poly2 = Polygon([(1, 1), (3, 1), (3, 3), (1, 3)])

gdf1 = gpd.GeoDataFrame(geometry=[poly1])
gdf2 = gpd.GeoDataFrame(geometry=[poly2])

# Calcul de l'intersection
intersection = gdf1.intersection(gdf2.geometry[0])

# Affichage
base = gdf1.plot(color='lightblue', edgecolor='black')
gdf2.plot(ax=base, color='salmon', edgecolor='black')
gpd.GeoSeries(intersection).plot(ax=base, color='green')
plt.title("Intersection entre deux polygones")
plt.show()
    Explication du code :

    On crée deux polygones avec une zone de recouvrement.
    La méthode .intersection() permet d’extraire cette zone.
    On affiche les deux formes initiales et la zone verte représentant l’intersection.

    Avantages :

    • Permet d’extraire les zones communes entre entités spatiales.

    • Très utile pour des opérations comme :
      – l’analyse d’impact environnemental,
      – la planification urbaine,
      – le croisement entre jeux de données géographiques.

  • GeoDataFrame.dissolve()

    La méthode GeoDataFrame.dissolve() permet de fusionner les géométries d’un GeoDataFrame en regroupant les lignes selon une valeur d’un champ commun (par exemple une région ou un pays). Elle réalise une opération géospatiale d’union des géométries et peut également agréger d’autres colonnes avec une fonction d’agrégation (somme, moyenne, etc.).

    Importation :
    import geopandas as gpd
    Attributs :
    Paramètre Type Description Valeur par défaut
    by str ou array Nom de la colonne sur laquelle regrouper les géométries (clé de regroupement). None
    aggfunc str ou fonction Fonction d’agrégation appliquée aux autres colonnes (ex : 'sum', 'mean'). 'first'
    as_index bool Définit si la colonne de regroupement devient l’index du résultat. True
    Exemple de code :
    import geopandas as gpd
import matplotlib.pyplot as plt

# Chargement d’un GeoDataFrame avec les pays
gdf = gpd.read_file(gpd.datasets.get_path('naturalearth_lowres'))

# Fusion des géométries par continent
dissolved = gdf.dissolve(by='continent')

# Affichage du résultat
dissolved.plot(edgecolor='black', cmap='Set3')
plt.title('Fusion des pays par continent')
plt.show()
    Explication du code :

    On regroupe les géométries des pays selon leur continent avec dissolve(by='continent').
    Le résultat est une carte où chaque continent est représenté par une seule géométrie.

    Avantages :

    • Simplifie et regroupe les données spatiales.

    • Très utile pour regrouper des entités administratives (ex : départements → régions).

    • Permet aussi d’agréger des données statistiques associées.

  • GeoDataFrame.simplify()

    La méthode GeoDataFrame.simplify() permet de simplifier la géométrie des objets contenus dans une GeoDataFrame en réduisant le nombre de points, tout en préservant leur forme générale. Elle est utile pour alléger les fichiers géographiques, améliorer les performances d’affichage ou préparer des cartes interactives.

    Importation :
    import geopandas as gpd
    Attributs :
    Paramètre Type Description Valeur par défaut
    tolerance float Distance maximale autorisée entre l’ancienne géométrie et la simplifiée (plus elle est grande, plus la simplification est forte). None
    preserve_topology bool Indique si la topologie (liens entre formes) doit être conservée. True
    Exemple de code :
    import geopandas as gpd
import matplotlib.pyplot as plt

# Chargement d'un GeoDataFrame
gdf = gpd.read_file(gpd.datasets.get_path('naturalearth_lowres'))

# Création d'une version simplifiée
gdf_simplified = gdf.simplify(tolerance=0.1, preserve_topology=True)

# Affichage de la version originale et simplifiée
fig, ax = plt.subplots(1, 2, figsize=(14, 7))

gdf.plot(ax=ax[0], color='lightblue', edgecolor='black')
ax[0].set_title("Original")

gdf_simplified.plot(ax=ax[1], color='lightgreen', edgecolor='black')
ax[1].set_title("Simplifié")

plt.show()
    Explication du code :

    On charge une carte du monde puis on crée une version simplifiée des géométries à l’aide d’un paramètre tolerance.
    Les deux cartes (originale et simplifiée) sont affichées côte à côte pour comparaison.

    Avantages :

    • Permet de réduire considérablement la taille des fichiers géographiques.

    • Améliore les performances de rendu, notamment en webmapping.

    • Facile à utiliser et à paramétrer.