Projet graphe géographique

On utilise un fichier de données pour créer un graphe de proximité géographique.

Nous allons dans ce projet utiliser deux bibliothèques d'analyse des données très utilisées :

• pandas pour la gestion des données sous forme de matrices nommées dataframe
• geopandas qui ajoute à pandas la gestion de données géographiques

Nous n'allons pas expliquer tous les tenants et aboutissants de ces bibliothèques mais j'espère que le fait de les utiliser vous donnera envie d'en savoir plus.

Les données

Nous utilisons le fichier villes_france_30000.csv qui contient une liste des 30000 plus grandes villes françaises au format csv.

Installation des bibliothèques

Nous allons utiliser python pour lire et traiter ces données. Commençons donc par installer les bibliothèques qui nous serons nécessaires. Dans un terminal de vscode, tapez :

python -m pip install pandas geopandas

Dans les fichiers python utilisant pandas et geopandas, on commencera toujours par les importer avec les lignes suivantes :

import pandas as pd
import geopandas as gpd

Lecture des données

Lecture du fichier dans un data frame

df = pd.read_csv("./villes_france_30000.csv", skipinitialspace=True)

Aperçu du contenu

print(df)

Types des colonnes

Un dataframe est une sorte de tableau excel où chaque ligne a un type. Il est crucial de toujours vérifier que les types des colonnes sont bien ce qu'ils devraient être. Un type incorrect est souvent le signe d'un mauvais chargement ds données :

print(df.columns)
print(df.dtypes)

Vous devez obtenir le fait que :

• les colonnes idx, INSEE et population doivent être des entiers,
• les colonnes latitude et longitude doivent être des réels,
• la colonne nom doit être une chaîne de caractère (nommé object en pandas)

idx              int64
 INSEE           int64
 nom            object
 latitude      float64
 longitude     float64
 population      int64
dtype: object

print(df[df["nom"] == "Marseille"])

Données géographiques

Nos données contiennent à la fois des données :

• normales comme le nom u la population pour chaque ville
• géographes avec la latitude et la longitude

Pour pouvoir utiliser les données géographiques de façon efficace, on a l'habitude de les regrouper en classes particulières. Toutes les classes et possibles et leurs utilisations sont décrites dans la bibliothèque Shapely. Citons en 3 parmi le plus utilisées :

• des points pour nos coordonnées GPS
• des Polygones pour des surfaces connexes comme des arrondissements (pour les pays non connexes comme la France on utilisera des collections de polygone)
• lignes pour des chemins.

De plus, on utilise la bibliothèque GeoPandas (que vous avez déjà du installer) pour une utilisation aise de celle-ci.

Points à partir des coordonnées

On va créer un GeoDataFrame qui contient nos données.

La différence avec un DataFrame pandas est l'ajout d'une colonne geometry (obligatoire en geopandas) qui contient... La géométrie de nos données. Dans notre cas :

• géométrie est un point (longitude, latitude)
• le système de coordonnée est le système gps : https://epsg.io/4326

Faisons ça :

# ...

villes = gpd.GeoDataFrame(df, geometry=gpd.points_from_xy(df.longitude, df.latitude))
villes.set_crs("EPSG:4326")

Représentation graphique

On utilise le tutoriel matplotlib pour représenter graphiquement nos villes :

# ...

import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(10, 5))

villes.plot(ax=ax)

plt.show()

import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(10, 5))

villes[villes["population"] > 50000].plot(ax=ax)

plt.show()

print(len(villes[villes["population"] > 50000]))

Supprimons l'île de France

On le voit sur la représentation graphique, l'île de France regroupe trop de granges villes par rapport au reste de la France métropolitaine : on va supprimer toutes les villes de l'île de France sauf Paris.

Pour cela, commençons par trouver l'île de France.

Il faut transcrire ce rectangle en coordonnées géographique. Ceci est facile avec la bibliothèque shapely. On peut utiliser shapely.geometry.box dont les paramètres correspondant à la deuxième ligne du site déterminant les bounding box. Avec mes coordonnées ça fait :

import shapely.geometry

île_de_France = shapely.geometry.box(2.02, 48.7, 2.72, 48.98)

On peut maintenant utiliser la puissance de GeoPandas et de ses outils de gestion géographique. Ces outils sont principalement des méthodes de la classe GeoSeries qui correspond à la colonne geometry.

print(len(villes[villes["geometry"].within(île_de_France)]))

v2 = villes[villes["geometry"].within(île_de_France)]
print(v2[v2["population"] > 50000])
print(len(v2[v2["population"] > 50000]))

print(villes[villes["geometry"].within(île_de_France) & (villes["population"] > 50000)])
print(len(villes[villes["geometry"].within(île_de_France) & (villes["population"] > 50000)]))

On finalise le tout en gardant Paris :

v2 = villes[(~villes.geometry.within(île_de_France)) | (villes["nom"] == "Paris")]
grandes_villes = v2[v2["population"] > 50000]

En les représentant graphique, j'obtiens :

Distance entre villes

Commençons par extraire une ville du tableau. Par exemple Marseille.

La ligne suivante :

marseille_df = villes[villes["nom"] == "Marseille"]

Rend non pas une ville (une ligne du tableau), mais un dataFrame contenant toutes les lignes dont la colonne "nom" vaut "Marseille" (il n'y en a qu'une). Si on l'affiche avec print(marseille_df) :

   idx  INSEE        nom  latitude  longitude  population                  geometry
1    2  13200  Marseille      43.3        5.4      800550  POINT (5.40000 43.30000)

Récupérer une ligne se fait avec les 2 méthodes :

• .iloc[x] : pour récupérer la $i$ème ligne du dataFrame
• .loc[x] : pour récupérer la ligne d'index x du dataFrame

Utilisons ceci pour trouver Marseille dans les données

marseille = marseille_df.iloc[0]

marseille = marseille_df.loc[1]

Déterminer la distance entre deux géométries se fait avec la méthode distance. Par exemple pour connaître la distance entre la première ville du dataFrame grandes_villes et marseille :

print(grandes_villes.iloc[0]["geometry"].distance(marseille["geometry"]))

Ce qui est pratique avec pandas, c'est qu'on peut aussi appliquer cette méthode à une colonne :

print(grandes_villes["geometry"].distance(marseille["geometry"]))

La dataFrame que l'on affiche est une dataFrame à autant de lignes que le nombre de grandes villes (avec le même index) et une seule colonne, la distance avec Marseille.

Si l'on veut connaître la distance entre deux villes deux à deux, on peut utiliser la méthode apply des colonnes :

d = grandes_villes["geometry"].apply(lambda x: grandes_villes["geometry"].distance(x))
print(d)

L'objet d est une dataFrame où :

• les index de lignes correspondent aux index des lignes de grande_villes
• les noms de colonnes correspondent aux index des lignes de grande_villes
• chaque cellule est une distance.

Si on veut connaître la distance entre la ville d'index $i$ et celle d'index $j$ :

i, j = 2, 91
print(d.loc[i, j])

Pour connaître l'index d'une ville, on peut procéder comme ça :

1. la dataFrame : grandes_villes
2. la dataFrame avec une ligne : grandes_villes[grandes_villes["nom"] == "Marseille"]
3. les index de cette dataFrame : grandes_villes[grandes_villes["nom"] == "Marseille"].index, qui est une colonne
4. l'index de l'unique élément : grandes_villes[grandes_villes["nom"] == "Marseille"].index[0]

i = grandes_villes[grandes_villes["nom"] == "Marseille"].index[0]
j = grandes_villes[grandes_villes["nom"] == "Rennes"].index[0]

print(d.loc[i, j])

Graphe des grandes villes

On va créer un graphe :

• dont les sommets sont les villes de Métropole (hors île de France) de plus de 50000 habitants
• il y a une arête entre la ville $x$ et la ville $y$ si la distance entre les deux est inférieure à MAX_DIST

En utilisant ce qui précède :

MAX_DIST = 2
G = {}
f = {}
for i in grandes_villes.index:
    nom_i = grandes_villes.loc[i]["nom"]
    G[nom_i] = set()
    for j in grandes_villes.index:
        if d.loc[i, j] <= MAX_DIST:
            nom_j = grandes_villes.loc[j]["nom"]
            G[nom_i].add(nom_j)
            f[(nom_i, nom_j)] = d.loc[i, j]

On peut ensuite représenter graphiquement ce graphe :

# ...
import matplotlib.lines as mlines

fig, ax = plt.subplots(figsize=(10, 5))

grandes_villes.plot(ax=ax)

for u in G:
    i = grandes_villes[grandes_villes["nom"] == u].index[0]
    point_i = grandes_villes.loc[i]["geometry"]
    for v in G[u]:
        j = grandes_villes[grandes_villes["nom"] == v].index[0]
        point_j = grandes_villes.loc[j]["geometry"]
        ax.add_line(mlines.Line2D((point_i.x, point_j.x), (point_i.y, point_j.y)))        
plt.show()

J'obtiens ce graphe là (essayez d'obtenir le même) :

{'Aix-en-Provence', 'Charleville-Mezieres', 'Rennes', 'Quimper', 'LaRochelle', 'Villeurbanne', 'Arles', 'Sarcelles', 'Orleans', 'Chambery', 'Montauban', 'Troyes', 'Laval', 'Brest', 'Calais', 'Nantes', 'Nice', 'Lorient', 'Saint-Etienne', 'Besancon', 'Strasbourg', 'Angers', 'Bordeaux', 'Caen', 'Rouen', 'Niort', 'Amiens', 'Mulhouse', 'Merignac', 'Tours', 'Pau', 'LeHavre', 'Grenoble', 'Limoges', 'Toulon', 'Beziers', 'LaSeyne-sur-Mer', 'Saint-Quentin', 'Antibes', 'Poitiers', 'Montpellier', 'Marseille', 'Venissieux', 'Metz', 'Nancy', 'Reims', 'Valence', 'Belfort', 'Toulouse', 'Nimes', 'Chateauroux', 'Bourges', 'Clermont-Ferrand', 'Saint-Nazaire', 'LeMans', 'Lyon', 'Lille', 'Paris', 'Dunkerque', 'Pessac', 'Avignon', 'Tourcoing', 'Chalon-sur-Saone', 'Cholet', "Villeneuve-d'Ascq", 'Cannes', 'Beauvais', 'Perpignan', 'Roubaix', 'Dijon', 'Colmar'}

{'Ajaccio'}

i = grandes_villes[grandes_villes["nom"] == "Ajaccio"].index[0]

print(d[i].sort_values())

print(grandes_villes.loc[4])

i = grandes_villes[grandes_villes["nom"] == "Ajaccio"].index[0]
proche = d[i].sort_values().index[1]

G['Ajaccio'].update({'Nice'})
G['Nice'].update({'Ajaccio'})

f[('Ajaccio', 'Nice')] = d.loc[i, proche]
f[('Nice', 'Ajaccio')] = d.loc[i, proche]

J'obtiens au final le graphe suivant :

Graphe géographique

TBD utilisation de networkx