Chapitre 10 Créer des cartes statiques avec {ggplot2}

10.1 Librairies

Dans ce chapitre, nous allons utiliser les librairies suivantes :

# CRAN
library(cowplot)
library(ggspatial)
library(sf)
library(tidyverse) #comprend ggplot2

# Github
library(COGiter)    # remotes::install_github("MaelTheuliere/COGiter")
library(gouvdown)   # remotes::install_github("spyrales/gouvdown")

# Gitlab-forge
library(mapfactory) # remotes::install_gitlab("dreal-pdl/csd/mapfactory", host = "gitlab-forge.din.developpement-durable.gouv.fr")

10.2 Introduction : les cartes statiques en R

Il existe de nombreuses manières de visualiser des données géographiques dans R. Des instructions très concises suffisent pour disposer d’un premier aperçu. Prenons l’exemple de notre couche régionale issue de COGiter.

library(COGiter)
library(sf)

En utilisant la fonction plot() basique de R sur un objet sf, R nous propose un rapide aperçu de la couche et de ses attributs :

plot(COGiter::regions_geo)

Le package {mapview} permet également d’afficher un aperçu de couche très rapidement, posé sur un fond de carte Open street map.

library(mapview) 
mapview(x = COGiter::regions_geo)

Le résultat est un widget html, explorable, zoomable, cliquable. Bien que conçu principalement pour faciliter l’exploration de données spatiales, {mapview} permet de personnaliser la mise en plage, d’empiler les couches… Ce ne sera pas vu lors de la formation, mais tout est très bien expliqué dans l’aide ?mapview() et sur le site de présentation du package, notamment sur la vignette de démarrage.

Pour mettre en page des cartes, 3 packages se distinguent :

{ggplot2},
{tmap},
et {mapsf} (successeur de {cartography}).

{ggplot2} est un package du tidyverse, qui propose une syntaxe cohérente entre dataviz et cartoviz. Il dispose de templates à la Marque Etat, raison pour laquelle son utilisation est à privilégier au sein du pôle ministériel.

{tmap} a longtemps été plus complet et plus simple que ggplot2. Il constituait un incontournable. Ce n’est plus le cas désormais. Son utilisation est détaillée en annexe pour mémoire.

Le package {mapsf} a été développé par Timothé Giraud du CNRS. Ses fonctionnalités sont assez complètes et la prise en main est plutôt simple, pour des rendus graphiques très aboutis. De plus, le package est relativement léger. Un support de cours et une feuille de triche facilitent son appropriation. Comme l’utilisation de {ggplot2} est à privilégier au sein du pôle ministériel, ce package ne sera pas présenté lors de la formation.

10.3 Quelques rappels sur `{ggplot2}`

{ggplot2} est un package de visualisation de données qui dispose de templates (thèmes, palettes) à la Marque Etat grâce au package {gouvdown}, créé par la communauté d’agents de l’Etat Spyrales.

ggplot 2 a été créé par Hadley Wickham et Winston Chang pour implémenter dans R la vision développée par Leland Wilkinson dans The Grammar of Graphics (Statistics and Computing) de la conception de graphiques.
Le but est de fournir une approche unique pour produire quasiment toute valorisation graphique de données que l’on peut trouver dans des revues scientifiques, les journaux, dans l’analyse statistique ou la data visualisation.
Ce package aujourd’hui s’inscrit dans R dans le framework Tidyverse qui propose une approche cohérente sur l’ensemble de la chaîne de vie de la donnée : importation, préparation des données, analyse et valorisation.

le tidyverse

Se référer à la feuille de triche {ggplot2} permet de se lancer rapidement.

10.3.1 `{ggplot2}` : les concepts clefs

Pour construire un graphique avec {ggplot2} il faut lui déclarer plusieurs éléments :

la donnée à représenter : ggplot2 permet de travailler sur des vecteurs, des dataframes, des tibbles, ou des données spatiales ;
le mapping : on définit dans l’aesthetic (ou aes) le mapping, c’est à dire ce que l’on veut représenter qui dépend des variables (quelle variable sur l’axe x, sur l’axe y, quelle variable pour définir une graduation de couleurs…), par exemple :
- x, y : pour les variables qui seront représentées selon les axes x et y ;
- colour : pour la variable qui sera représentée par la couleur (contour),
- fill : pour la variable qui sera représentée par la couleur de remplissage ;
- shape : pour la variable qui sera représentée par la forme du point,
- size : pour la variable qui sera représentée par la taille du point ou de la ligne,
- alpha : pour la variable qui sera représentée par la transparence du remplissage.
les autres paramètres : on définit en dehors de l’aesthetic les autres paramètres graphiques constants (par exemple : je veux que toutes mes lignes soient rouges ou de taille 2 pixels) ;
le layer (forme ou calque géométrique) : on définit sous quelle représentation graphique on représente les paramètres précédents (nuages de points, diagramme barres,…). Sous ggplot, ces fonctions sont de la forme geom_XX() ;
le système de coordonnées : on définit quel type de système de coordonnées (polaire, cartésien…) on souhaite utiliser pour visualiser nos données. Par défaut ggplot utilise les coordonnées x, y cartésiennes. Si besoin de changer, on spécifie le système de coordonnées à l’aide d’une fonction de type coord_XX.

L’écriture type d’un graphique ggplot sera donc :

ggplot(data = <DATA>) + 
  <CALQUE_GEO>(mapping = aes(<MAPPINGS>), ...=<PARAMS>)

Voici un exemple appliqué au jeu de données d’exemple de R iris :

Rows: 150
Columns: 5
$ Sepal.Length <dbl> 5.1, 4.9, 4.7, 4.6, 5.0, 5.4, 4.6, 5.0, 4.4, 4.9, 5.4, 4.…
$ Sepal.Width  <dbl> 3.5, 3.0, 3.2, 3.1, 3.6, 3.9, 3.4, 3.4, 2.9, 3.1, 3.7, 3.…
$ Petal.Length <dbl> 1.4, 1.4, 1.3, 1.5, 1.4, 1.7, 1.4, 1.5, 1.4, 1.5, 1.5, 1.…
$ Petal.Width  <dbl> 0.2, 0.2, 0.2, 0.2, 0.2, 0.4, 0.3, 0.2, 0.2, 0.1, 0.2, 0.…
$ Species      <fct> setosa, setosa, setosa, setosa, setosa, setosa, setosa, s…

ggplot(data = iris) + 
  geom_point(mapping = aes(x = Sepal.Length, y = Petal.Length, color = Species))

Les fonctions de création de calques geom_XX incluent une transformation statistique par défaut (identité, décompte, quantile, classification…) grâce à leur paramètre “stat”, qu’il est possible de modifier au besoin.
Par exemple la fonction geom_bar() est associé par défaut à la transformation stat_count() qui décompte les observations.

ggplot(data = iris) + 
  geom_bar(mapping = aes(x = Species, fill = Species))

On peut modifier ici le paramètre stat de geom_bar() pour afficher la moyenne des longueurs de sépales par espèces :

ggplot(data = iris) + 
  geom_bar(mapping = aes(x = Species, y = Sepal.Length, fill = Species), stat = "summary")

Les fonctions ggplot de création de calques géométriques de type geom_XX(stat = "YY") sont équivalentes aux fonctions stat_YY(geom = "XX").

ggplot(data = iris) + 
  stat_summary(mapping = aes(x = Species, y = Sepal.Length, fill = Species), geom = "bar")

En résumé et en image :

On va ensuite pouvoir partir de cette base pour l’enrichir avec des fonctions supplémentaires, comme le calibrage des palettes, le titre… Chaque fonction ggplot s’enchaîne avec des + comme les %>%.

Les paramètres graphiques se calibrent grâce aux fonctions scale_XX(), où XX est la propriété graphique à étalonner.

Par exemple : distribution des communes selon leur population à partir du jeu de données d’exemple de COGiter pop2015.

glimpse(pop2015)

Rows: 35,441
Columns: 4
$ DEPCOM         <fct> 01001, 01002, 01004, 01005, 01006, 01007, 01008, 01009,…
$ pop2015        <dbl> 767, 241, 14127, 1619, 109, 2615, 747, 342, 1133, 390, …
$ pop2015_a_part <dbl> 18, 1, 504, 33, 6, 107, 18, 9, 19, 11, 4, 3, 94, 5, 12,…
$ pop2015_totale <dbl> 785, 242, 14631, 1652, 115, 2722, 765, 351, 1152, 401, …

ggplot(pop2015, aes(x = pop2015_totale)) +
  geom_histogram(fill = "lightblue") + 
  scale_x_log10(labels = ~format(.x, big.mark = " ", scientific = FALSE), name = "nombre d'hab.")

Pour en savoir plus sur ggplot2 :

cheatsheet {ggplot2},
module 5 du parcours R sur la datavisualisation.

10.3.2 {ggplot2} pour les cartes

Pour visualiser des données spatiales, ggplot propose maintenant une série de fonctions geom_sf, stat_sf et coord_sf adaptées aux dataframes de type sf.

Pour les visualisations les plus simples, seule geom_sf() suffit, ggplot utilise silencieusement les fonctions de transformation stat et de coordonnées appropriées.

ggreg <- ggplot(COGiter::regions_geo) + 
  geom_sf(color = "white", fill = "lightblue")

ggreg

Quatre types de calques géographiques sont utilisables :

geom_sf() : pour visualiser nos objets géographiques tels quels,
geom_sf_label() : pour étiqueter nos objets géographiques,
geom_sf_text() : pour annoter nos objets géographiques,
stat_sf_coordinates() : pour transformer des géométries complexes (lignes, polygones) en points avant de tracer le calque.

geom_sf()et ses petites sœurs n’acceptent qu’une seule variable de coordonnées dans le mapping esthétique : celle de la géographie de nos données spatiales. Il n’est pas besoin de le préciser, quelque soit le nom du champ contenant les coordonnées géo s’il n’y a qu’un champ géo. Dans le cas contraire, on indique le nom de la colonne de coordonnées à utiliser dans l’aesthetic aes(geometry = mon_champ_geo).

Les autres paramètres esthétiques acceptés par les fonctions de traçage de calques sf sont par exemple :

colour : pour une variable qui sera représentée par la couleur (contour),
fill : pour une variable qui sera représentée par la couleur de remplissage,
shape : pour une variable qui sera représentée par la forme du point,
size : pour une variable qui sera représentée par la taille du point ou de la ligne,
alpha : pour une variable qui sera représentée par la transparence du remplissage.

geom_sf_label() (étiquette) et geom_sf_text() (texte simple) acceptent en plus le paramètre label pour ajouter des étiquettes ou des annotations à notre fond de carte.

Les fonctions geom_sf_text() et geom_sf_label() sont associées à la fonction de transformation stat_sf_coordinates() qui par défaut renvoie un point au centre de nos objets géographiques pour placer l’annotation textuelle (grâce à la fonction sf::st_point_on_surface()).

Pour le système de coordonnées, la fonction coord_sf() va silencieusement chercher celui de nos données spatiales pour l’appliquer au graphique. Elle peut servir à définir celui qu’on l’on souhaite utiliser pour la visualisation, en spécifiant le datum (les axes représentés).
coord_sf() permet également de zoomer sur la carte en spécifiant les bornes x et y de la carte, ou également de définir le titre des axes.

10.4 Faire des cartes avec {ggplot2}

10.4.1 Préparation des données

Comme avec d’autres packages, la première étape consiste à préparer le jeu de données à visualiser, c’est à dire d’associer les variables à analyser à leur géographie.

Ici, nous partons des données de population 2015 et les fonds de carte disponibles dans le package {COGiter}, que nous allons préparer avec {COGiter} également.

pop2015_preparee <- pop2015 %>% 
  # mise à jour du COG et agrégation aux différentes échelles adm
  cogifier(code_commune = DEPCOM, communes = TRUE, epci = TRUE, departements = TRUE, regions = TRUE, metro = FALSE) %>% 
  # on filtre le jeu de données pour ne garder que les territoires de Normandie et toutes les régions
  filtrer_cog(reg = "28", garder_supra = ">=") 

# Aperçu du jeu de données
glimpse(pop2015_preparee)

Rows: 2,744
Columns: 6
$ TypeZone       <fct> Communes, Communes, Communes, Communes, Communes, Commu…
$ Zone           <fct> "Ablon", "Agy", "Valambray", "Amayé-sur-Orne", "Amayé-s…
$ CodeZone       <fct> 14001, 14003, 14005, 14006, 14007, 14009, 14011, 14012,…
$ pop2015        <dbl> 1216, 281, 1767, 985, 218, 1414, 1935, 139, 1137, 712, …
$ pop2015_a_part <dbl> 34, 6, 24, 18, 4, 18, 43, 2, 33, 20, 8, 5, 50, 12, 8, 2…
$ pop2015_totale <dbl> 1250, 287, 1791, 1003, 222, 1432, 1978, 141, 1170, 732,…

# Préparation des fonds carto
fonds_carto_normands <- filtrer_cog_geo(reg = "28")

#jointure du fond carto EPCI aux données EPCI de Normandie
pop2015_epci_normands_geo <- fonds_carto_normands$epci %>% 
  left_join(pop2015_preparee, by = c("EPCI" = "CodeZone")) %>% 
  # calcul des indicateurs a représenter
  mutate(poids_pop_a_part = pop2015_a_part / pop2015_totale * 100,
         densite_pop = as.numeric(pop2015 / AREA * 1000000))

10.4.2 Les cartes choroplèthe

Le premier exemple que nous allons pouvoir voir, c’est une carte choroplèthe, càd en aplat de couleur, adaptée à la représentation d’indicateurs intensifs (%, densité…), par exemple la densité de population des EPCI normands.

ggplot(data = pop2015_epci_normands_geo) +
  geom_sf(mapping = aes(fill = densite_pop), color = "white")

10.4.3 Les cartes à ronds proportionnels

La fonction stat_sf_coordinates() permet d’extraire les coordonnées d’un objet ‘sf’ avant de produire le calque. Ainsi un rond proportionnel peut être attribué à un polygone.
On ajoute le calque des ronds proportionnels au dessus de celui des polygones en enchainant les fonctions de traçage des calques avec le +.

carte_ronds_prop <- ggplot(data = pop2015_epci_normands_geo) +
  geom_sf() +
  stat_sf_coordinates(mapping = aes(size = pop2015_totale, color = poids_pop_a_part))

carte_ronds_prop

10.4.4 L’habillage simple

10.4.4.1 Titre et libellé des axes

Chaque nouvel élément graphique est à ajouter sous forme de calques (layers). Pour les titres, nous utilisons la fonction labs() qui permet de donner un titre à tous les éléments possibles de l’aesthetic, ainsi que le titre (title), le sous-titre (subtitle) et le bas de page (caption).

carte_ronds_prop +
  labs(
    title = "Population par EPCI en Normandie",
    subtitle = "En 2015", x = "", y = "",
    size = "Nombre d'habitants",
    color = "Poids population\ncomptée à part (%)",
    caption = "Source : INSEE - RP"
  )

A noter qu’il existe plusieurs autres façons de spécifier ces éléments par des fonctions spécifiques: ggtitle(), xlab(), ylab(), …

10.4.4.2 Légende

Les fonctions guide_xx() et guides() permettent de modifier finement la légende. Les guides peuvent être spécifiées dans chaque scale_ ou dans une instruction guides.

carte_ronds_prop2 <- carte_ronds_prop +
  labs(
    title = "Population par EPCI en Normandie",
    subtitle = "En 2015", x = "", y = "",
    size = "Nombre d'habitants",
    color = "Poids population\ncomptée à part (%)",
    caption = "Source : INSEE - RP"
  ) +
  guides(color = guide_legend(
    direction = "horizontal",
    order = 1,
    title.position = "top",
    title.hjust = 0.5,
    nrow = 1,
    label.position = "bottom"
  )) +
  theme(legend.position = "left")

carte_ronds_prop2

10.4.4.3 Annotation

Il est aussi possible de rajouter des annotations de type texte, par exemple, “texte la volée”.

carte_ronds_prop2 +
  coord_sf(datum = 2154) +
  annotate("text", x = 400000, y = 6800000, label = "texte à la volée", color = "blue")

10.4.5 Les thèmes

Pour modifier simplement la position de la légende, c’est la fonction theme() qu’il faut utiliser.

theme() permet de créer des templates, c’est à dire de définir tout ce qui n’est pas lié directement aux données sur un graphique, notamment:

la position, taille, couleur et police des éléments textuels
la couleur des grilles primaires et secondaires du graphique

Pour unifier un document, il est vivement conseillé de recourir à un thème.

Il existe des thèmes prédéfinis dans ggplot que l’on peut déjà utiliser. Par exemple: theme_classic(), theme_bw(), theme_dark(), …

Pour les cartes, les thèmes theme_minimal() ou theme_void() sont particulièrement indiqués.

Le theme_gouv_map() de {gouvdown} est tout indiqué pour les services de l’État. Il ne gère pas les couleurs par défaut, mais tout le reste l’est. La taille des éléments de texte reste paramétrable par l’utilisateur.
Voir l’aide theme_gouv_map().

carte_ronds_prop2 +
  theme_gouv_map(plot_title_size = 20, subtitle_size = 12)

La fonction theme_set() vous permet de définir un thème par défaut pour l’ensemble de vos graphiques.

theme_set(theme_gouv_map(plot_title_size = 20, subtitle_size = 12))

10.4.6 Les scales

Les fonctions scales() permettent globalement de paramétrer ou étalonner les éléments rentrés dans l’aesthetic :

Si je veux un gradient de couleurs fonction d’une variable continue : quelle palette de couleurs je choisis, comment je cale mon dégradé en fonction de cette variable continue ?
Si je met une variable continue en paramètre de transparence, comment je définis le minimum et maximum de cette transparence ou les valeurs que j’affiche sur l’échelle…

L’ensemble des scales possibles peuvent se décrire sous la forme suivante:

scale_xx_yy()

ou xx peut être un des paramètres de l’aesthétic :

xx	description
alpha	transparence
color	couleur des lignes ou des points
fill	couleurs des aires
linetype	type de ligne (continue,pointillée,…)
shape	forme des points
size	aire des points

Et yy un type de paramétrage :

yy	description
date	gérer une variable au format date
reverse	inverser l’axe
log	convertir l’échelle d’une variable continue en échelle logarithmique
log10	convertir l’échelle d’une variable continue en échelle logarithmique décimale
continuous	gérer les variables continue
discrete	gérer les variables discrètes
continuous_gouv	utiliser les palettes de `{gouvdown}` (Marque Etat) pour une variable continue
discrete_gouv	utiliser les palettes de `{gouvdown}` (Marque Etat) pour une variable catégorielle
gradient	utiliser un gradient de 2 couleurs
gradient2	utiliser un gradient divergent de 3 couleurs
viridis	utiliser une palette de couleur viridis
brewer	utiliser une palette de couleur brewer (variable discrète)
distiller	utiliser une palette de couleur brewer (variable continue)

{gouvdown} propose des fonctions scales_xx_yy() mobilisant les palettes de couleurs à la marque Etat :

La vignette graph_gouv du site de présentation de {gouvdown} propose des exemples d’utilisation des palettes pour {ggplot2}.

carte_ronds_prop2 +
  scale_color_gouv_continuous(palette = "pal_gouv_i", reverse = FALSE)

{gouvdown} propose également de récupérer le code hex des couleurs de la marque Etat grâce à la fonction gouv_colors().

gouv_colors("a1")

       a1 
"#958B62"

On peut utiliser cette fonction pour créer une palette à partir d’un gradient de couleurs :

carte_ronds_prop2 +
  scale_colour_gradient(low = gouv_colors("b1")[[1]], high = gouv_colors("p1")[[1]])

10.4.6.1 Formatage spécifique

Le formatage des valeurs des axes ou de la légende se fait à l’aide d’une fonction de formatage des nombres passée à l’argument ‘labels’ des fonctions scale_xx_yy()

Transformation en pourcentage ;

scale_color_continuous(labels = scales::percent)

Ajout du symbole € ;

scale_y_continuous(labels = function(x) paste(x, " €"))

Ajout du séparateur des milliers ;

carte_ronds_prop2 +
  scale_color_gouv_continuous(palette = "pal_gouv_i", reverse = FALSE) +
  scale_size_continuous(labels = function(x) format(x, big.mark = " ", scientific = FALSE))

10.4.7 Exercice 3 - Carte des données dvf par quartie de Nantes

Avec les résultats de l’exercice 2, produire les cartes du nombre de ventes et du prix au m2 des maisons en 2019 par quartier de Nantes.

Résultats attendus :

10.4.8 Les facettes

Lorsque l’on veut pouvoir réaliser une carte pour plusieurs sous-ensembles, les facettes sont alors très utiles.

Il faut au préalable préparer notre jeu de données en le passant au format long avec pivot_longer() de {tidyr}.

indic_epci_normands_geo_long <- pop2015_epci_normands_geo %>% 
  pivot_longer(cols = c(starts_with("pop2015"), densite_pop, poids_pop_a_part), names_to = "indicateurs", values_to = "valeurs") %>% 
  filter(!str_detect(indicateurs, "pop2015"))
  
ggplot(data = indic_epci_normands_geo_long) +
  geom_sf(aes(fill = valeurs), color = "white") + 
  facet_wrap(~indicateurs) +
  scale_fill_gouv_continuous("pal_gouv_b")

Un deuxième exemple de facette sur la maille géo.

fonds_carto_empiles <- bind_rows(
  COGiter::communes_geo %>% mutate(TypeZone = "Communes") %>% rename(CodeZone = DEPCOM),
  COGiter::epci_geo %>% mutate(TypeZone = "Epci") %>% rename(CodeZone = EPCI),
  COGiter::departements_geo %>% mutate(TypeZone = "Départements") %>% rename(CodeZone = DEP)
  ) %>% 
  inner_join(pop2015_preparee) %>% 
  mutate(densite = round(pop2015 / as.numeric(AREA) * 1000000, 0),
         TypeZone = fct_inorder(TypeZone))


ggplot(fonds_carto_empiles) + 
  geom_sf(aes(fill = log(densite)), color = "white", size = 0.01) + 
  facet_wrap(~TypeZone) +
  scale_fill_gradient(low = gouv_colors("b1")[[1]], high = gouv_colors("p1")[[1]]) + 
  theme_gouv_map()

10.4.9 Ajouter une barre d’échelle et la flèche du nord

Le package ggspatial permet d’enrichir simplement nos cartes ggplot2 avec une barre d’échelle et la flèche du nord.

Les deux fonctions qui permettent cela sont annotation_scale() et annotation_north_arrow().

L’utilisation de ces fonctions nécessitent un système de coordonnées géographiques.

carte_ronds_prop2 +
  scale_color_gouv_continuous(palette = "pal_gouv_i", reverse = FALSE) +
  scale_size_continuous(labels = function(x) format(x, big.mark = " ", scientific = FALSE)) +
  annotation_scale(location = "br", line_width = .5) +
  annotation_north_arrow(location = "bl", height = unit(0.7, "cm"), width = unit(0.7, "cm"))

10.4.10 Mettre plusieurs cartes côte à côte

On peut a partir d’une même carte vouloir réaliser un zoom sur une sous partie de celle-ci. coord_sf() va nous permettre de zoomer sur une carte, et cow_plot() va nous permettre d’afficher nos deux cartes côte à côte.

Pour zoomer sur une carte, coord_sf() va avoir besoin des coordonnées x et y du cadre sur lequel on veut zoomer. Le plus simple pour cela est de filtrer préalablement notre spatial dataframe et de récupérer la bbox de celle-ci.

Filtrons par exemple sur le Département de l’Orne.

bbox_dep <- fonds_carto_normands$departements %>% 
  filter(DEP == "14") %>%
  st_bbox()

On peut ensuite réaliser une carte zoomée sur l’Orne

normandie <- carte_ronds_prop +
  geom_sf(data = fonds_carto_normands$departements, size = 1, color = "gray10", fill = NA) +
  guides(color = "none", size = 'none')

calvados <- normandie + 
  coord_sf(xlim = c(bbox_dep[1], bbox_dep[3]), ylim = c(bbox_dep[2], bbox_dep[4])) +
  theme(panel.background = element_rect(fill = "light blue")) +
  scale_color_gouv_continuous(palette = "pal_gouv_i", reverse = FALSE) +
  scale_size_continuous(labels = function(x) format(x, big.mark = " ", scientific = FALSE)) +
  labs(title = "Population par EPCI en Normandie",
       subtitle = "En 2015", x = "", y = "",
       size = "Nombre d'habitants",
       color = "Poids population\ncomptée à part (%)",
       caption = "Source : INSEE - RP")

calvados

On peut utiliser ensuite le package {cowplot} et sa fonction plot_grid() pour afficher nos cartes côte à côte.

La fonction plot_grid() qui permet de disposer n graphes sur i colonnes et j lignes.

Il faut jouer sur les largeurs relatives pour que les deux cartes s’agencent bien.

plot_grid(calvados, normandie, rel_widths = c(1, 2))

10.4.11 Exporter sa carte

ggplot contient une fonction ggsave() qui permet d’exporter nos graphiques ou cartes dans les formats suivants : eps, ps, tex (pictex), pdf, jpeg, tiff, png, bmp, svg or wmf.

p <- carte_ronds_prop2 +
  scale_color_gouv_continuous(palette = "pal_gouv_i", reverse = FALSE) +
  scale_size_continuous(labels = function(x) format(x, big.mark = " ", scientific = FALSE))

ggsave("pic/pop_epci_2015_normandie.svg", p, width = 12, height = 5)

10.4.12 Exercice 4 : Assemblage de cartes sur dvf

A partir des données dvf 2014 et 2017 de la région Pays de la Loire contenues dans le package {variousdata} et les fonds de carte de {COGiter}, produire :

une carte régionale à l’EPCI comprenant :
- un dégrade de couleur sur l’évolution des prix au m2 des maisons entre 2014 et 2017,
- un rond sur le volume des prix au m2 des maisons,
un zoom sur les communes des principaux EPCI, c’est à dire une carte à la commune par EPCI de type Métropole (ME) ou Communauté urbaine (CU).

Puis, assembler ces différentes cartes sur un même graphique.

Il faut comme toujours procéder par étape.

Etape 1 : Calcul de l’évolution des prix et du nombre de ventes

A l’EPCI
A la commune
Intégration des données calculées aux fonds de carte

Etape 2 : Datavisualisation

Carte à l’EPCI de la région

Zooms à la commune

Assemblage

10.5 Faire des cartes avec {mapfactory}

{mapfactory} facilite la création de cartes statistiques sur les territoires administratifs français, sur la base des packages {COGiter}, {gouvdown} et {ggplot2}.

Il s’installe depuis la forge gitlab du pôle ministériel :

remotes::install_gitlab(repo = "dreal-pdl/csd/mapfactory", 
                        host = "gitlab-forge.din.developpement-durable.gouv.fr")

Il crée des cartes régionales de visualisation d’indicateurs statistiques préparés par {COGiter}, aux maille départements, EPCI ou communes.

pop2015_prepa_nat <- pop2015 %>% 
  cogifier() %>% 
  mutate(poids_pop_a_part = pop2015_a_part / pop2015_totale * 100)

creer_carte_communes_prop(data = pop2015_prepa_nat, code_region = "02", indicateur = pop2015,
                          carto = fond_carto("Martinique", ombre = 0), espace = "\u202f",
                          palette = "pal_gouv_o", titre = "Population par commune", sous_titre = "En 2015", 
                          bas_de_page = "INSEE - RP", decimales = 0, suffixe = " hab", nclass = 4, method = "quantile")

Les fonctions principales sont :

creer_carte_categorie_epci(), creer_carte_categorie_communes() : pour créer une carte régionale de visualisation d’un indicateur catégoriel ;
creer_carte_epci(), creer_carte_communes() pour créer une carte régionale choroplèthe ;
creer_carte_epci_prop(), creer_carte_communes_prop() pour créer une carte régionale de visualisation d’un indicateur en rond proportionnel.

Toutes ces fonctions sont des cas particulier de la fonction creer_carte() :

creer_carte(data = pop2015_prepa_nat, code_region = "28", indicateur = poids_pop_a_part, maillage = "Département",
            carto = fond_carto("Normandie"), titre = "Proportion de la population comptée à part", sous_titre = "En 2015",
            bas_de_page = "INSEE - RP", decimales = 1, pourcent = TRUE, palette = "pal_gouv_b", espace = "\u202f" )

Il est nécessaire de partir d’un jeu de données national pour utiliser ce package, car les valeurs des territoires voisins sont requises pour la mise en page.