TD 3.2 - Créer une carte choroplèthe de la ville de Gresham en Oregon.

Vincent GODARD - V3.1 - 03/05/2021

Cours de traitement des données et cartographie

Département de géographie - L2 - Université de Paris 8

Inspiré de :

• https://learn.arcgis.com/fr/projects/evaluate-locations-for-mixed-use-development/

de

• https://fxjollois.github.io/cours-2016-2017/analyse-donnees-massives-tp9.html

de

• https://towardsdatascience.com/mapping-geograph-data-in-python-610a963d2d7f

et de

• https://python-visualization.github.io/folium/quickstart.html

Téléchargement des documents nécessaires :

Dossier compressé à télécharger => ici.

1. Chargement des bibliothèques (packages)

Dans le JupyterLab la bibliothèque pandas est déjà installée mais pas la bibliothèque folium. Il faut l'installer.

Il faut ensuite les charger (fonction import).

# Pour installer folium, effacez le # (avant le "!").
#!pip install folium

import pandas as pd
import folium
import json

2. Chargement du fond de carte

Gresham = folium.Map(location = [45.5, -122.43], zoom_start = 13, tiles='OpenStreetMap')
# Affichage de la carte.
Gresham

3. Chargement et affichage des données

3.1 Chargement des fichiers vecteurs

Les données à récupérer sont celles au format GeoJSON. Exportées d'ArcGIS pro en GeoJSON ou converties avec "mapshaper.org" de shp en GeoJSON.

Vous devez les sauvegarder, idéalement dans le même répertoire que votre notebook.

Ici, le fichier est dans le répertoire "data".

Chargez (UpLoad) les fichiers "Enriched_Block_Groups_GJS.geojson" dans un répertoire nommé "data" dans le répertoire "/demo/" du JupyterLab.

Vérifiez que le nom du fichier est entre "".

geo = json.load(open("data/Enriched_Block_Groups_GJS.geojson")) # lire les données 

Le format GeoJSON est un JSON (JavaScrip Object Notation) de type géographique. Il permet de décrire des implantations (points, lignes, polygones, chaînes de caractères), leur type et sous-type, leurs attributs et peut être utilisé directement comme nous le verrons plus loin (https://fr.wikipedia.org/wiki/GeoJSON).

L'import avec Python de la couche "geo" a transformé celle-ci en dictionnaire qui contient deux éléments : le type et les informations (nommées features).

geo.keys()

geo["type"]

Nous contrôlons la présence des 50 blocks dans l'objet features, qui est une "list".

len(geo["features"]) # liste des valeurs de l'enregistrement n°0 (1ère ligne !) pour chaque champ.

Dans chaque objet de cette liste, nous disposons aussi de différents objets de type Feature.

geo["features"][0].keys()

geo["features"][0]['type']

Dans le champs "properties", il y a  les coordonnées en longitude et latitude du centre du polygone.

geo["features"][0]['properties']

Et dans la partie "geometry", nous voyons que c'est un "Polygon" qui est représenté, avec toutes les coordonnées des sommets de ce polygone.

geo["features"][0]['geometry']

3.2 Conversion de la table attributaire en tableau de données (df)

Conversion dans un tableau (dataframe = df) de la bibliothèque Pandas.

Dans les cartes choroplètes, les polygones sont coloriés selon une variable statistique.

Pour cela, nous devons devons utiliser la fonction Choropleth() de la carte créée.

Nous passons dans le paramètre geo_data les données contenues dans le fichier GeoJSON importés plus haut.

Gresham = folium.Map(location = [45.5, -122.43], zoom_start = 13, tiles='OpenStreetMap')
folium.Choropleth(geo_data = geo).add_to(Gresham)
Gresham

Cartographie d'une information statistique

Nous avons besoin d'un DataFrame contenant deux variables :

- un identifiant commun avec les informations contenues dans le GeoJSON ;
- la variable statistique d'intérêt (pour cet exemple, ce sera la densité : population par mille carré "POP10_SQMI").

Pour le construire, nous allons récupérer le numéro de bloc (FIPS dans properties) et la densité (POP10_SQMI dans properties).

[block["properties"]["FIPS"] for block in geo["features"]]

[block["properties"]["POP10_SQMI"] for block in geo["features"]]

Création du DataFrame (df)

#import pandas

df = pandas.DataFrame({
    "Num_Block" : [block["properties"]["FIPS"] for block in geo["features"]], 
    "Densité" : [block["properties"]["POP10_SQMI"] for block in geo["features"]]
})
df

Pour relier ces informations (df) à la carte, toujours dans la fonction Choropleth(), nous devons définir les éléments suivants :

• geo_data : les contours au format GeoJSON ;

• key_on : l'item dans le GeoJSON avec lequel nous ferons la jointure ;

• data : le DataFrame dans lequel nous avons les informations statistiques ;

• columns : les deux colonnes à prendre

1. clé de jointure
2. mesure statistique

• fill_color : la palette de couleurs à utiliser (provenant de Color Brewer)

Quelques paramètres pour réaliser une carte choroplèthe https://python-visualization.github.io/folium/quickstart.html

Des infos sur différents fonds de cartes (cf. tiles=' Stamen Terrain') =>

• https://duspviz.org/tutorials/modules/15/

• https://python-visualization.github.io/folium/modules.html?highlight=tiles

4. Cartographie

4.1 Méthode des quantiles

## Méthode des quartiles (quatre quarts)

bins = list(df["Densité"].quantile([0, 0.25, 0.5, 0.75, 1])) # à adapter

Gresham = folium.Map(location = [45.5, -122.43], zoom_start = 13, tiles='OpenStreetMap')
folium.Choropleth(geo_data = geo,
                  data = df,
                  columns = ["Num_Block", "Densité"],
                  key_on = "feature.properties.FIPS",
                  fill_color='YlGn', #BuGn YlGn BuPu
                  fill_opacity=0.7,
                  line_opacity=0.8,
                  legend_name='Population en 2010 par mille carré',
                 bins= bins,
                 reset=True,).add_to(Gresham)

Gresham

4.2 Méthode des intervalles égaux¶

## Méthode des intervalles égaux

bins = 5 # à adapter

Gresham = folium.Map(location = [45.5, -122.43], zoom_start = 13, tiles='OpenStreetMap')
folium.Choropleth(geo_data = geo,
                  data = df,
                  columns = ["Num_Block", "Densité"],
                  key_on = "feature.properties.FIPS",
                  fill_color='YlGn', #BuGn YlGn BuPu
                  fill_opacity=0.7,
                  line_opacity=0.8,
                  legend_name='Population en 2010 par mille carré',
                 bins= bins,
                 reset=True,).add_to(Gresham)

Gresham

4.3 Méthode de Jenks

!pip install jenkspy

from jenkspy import jenks_breaks
jenks_breaks = jenks_breaks(df["Densité"], nb_class=4) # à adapter

Gresham = folium.Map(location = [45.5, -122.43], zoom_start = 13, tiles='OpenStreetMap')
folium.Choropleth(geo_data = geo,
                  data = df,
                  columns = ["Num_Block", "Densité"],
                  key_on = "feature.properties.FIPS",
                  fill_color='YlGn', #BuGn YlGn BuPu
                  fill_opacity=0.7,
                  line_opacity=0.8,
                  legend_name='Population en 2010 par mille carré',
                 bins= jenks_breaks,
                 reset=True,).add_to(Gresham)

Gresham