Cartographie interactive : comment visualiser mes données spatiales de manière dynamique avec leaflet ?

Mais que ne peut-on pas faire avec R ?! Car oui, avec R, on peut même faire des cartes interactives, et les packages dédiés sont relativement nombreux. La représentation de données spatiales se veut de plus en plus interactive, et quoi de mieux qu’une carte pour illustrer son propos lorsque l’on souhaite transmettre une information géographique ?

Comme les choses sont bien faites, ces cartes s’intègreront aussi parfaitement à vos applications interactives Shiny. Késako ? la réponse dans « A la découverte de Shiny et pour la cheat sheet Shiny en français, c’est par là.

Notre article du jour se focalisera sur le package {leaflet}, majoritairement utilisé par la communauté.

Ce qu’il faut savoir avant de commencer

Je ne m’attarderai pas ici à entrer dans les détails de la théorie de la cartographie, car le sujet a déjà été abordé par Colin dans cet article “Dessine-moi une carte avec R”. Il y définit notamment ce qu’est une carte et en décrit les éléments qui la composent.

Il y a toutefois un point sur lequel il me semble bon d’insister : le système de projection. Les coordonnées d’un point sur une carte sont constituées de deux valeurs, la première selon l’axe Nord/Sud – la latitude, et la seconde selon l’axe Est/Ouest – la longitude. Selon le système de projection choisi, elles prendront des valeurs différentes, et la notion de distance en sera modifiée. Ci-dessous quelques exemples de transformation d’un jeu de données mondial dans différentes projections (issues du livre de Manuel Gimond, très complet : https://mgimond.github.io/Spatial/)

library(tmap)
library(sf)
# Projection Eckert IV
data(World) 
# Projection azimutale équivalente 
World.ae <- World %>% 
  st_transform("+proj=aeqd +lat_0=0.01 +lon_0=0.01 +x_0=0 +y_0=0 +ellps=WGS84 +datum=WGS84 +units=m +no_defs")
# Projection de Robinson
World.robin <- World %>% 
  st_transform("+proj=robin +lon_0=0 +x_0=0 +y_0=0 +ellps=WGS84 +datum=WGS84 +units=m +no_defs")
# Projection sinusoidale
World.sin <- World %>% 
  st_transform("+proj=sinu +lon_0=0 +x_0=0 +y_0=0 +ellps=WGS84 +datum=WGS84 +units=m +no_defs")
# Projection Mercator
World.mercator <- World %>% 
  st_transform("+proj=merc +lon_0=0 +k=1 +x_0=0 +y_0=0 +ellps=WGS84 +datum=WGS84 +units=m +no_defs")
# plot : 
tm_shape(World) + 
  tm_fill() + 
  tm_layout("Eckert IV", inner.margins=c(0,0,.1,0), title.size=.8)
tm_shape(World.ae) + 
  tm_fill() + 
  tm_layout("Azimutale éq.", inner.margins=c(0,0,.1,0), title.size=.8)
tm_shape(World.robin) + 
  tm_fill() + 
  tm_layout("Robinson", inner.margins=c(0,0,.1,0), title.size=.8)
tm_shape(World.sin) + 
  tm_fill() + 
  tm_layout("Sinus", inner.margins=c(0,0,.1,0), title.size=.8)
tm_shape(World.mercator) + 
  tm_fill() + 
  tm_layout("Mercator", inner.margins=c(0,0,.1,0), title.size=.8)

Ceci étant dit, passons maintenant à ce qui nous intéresse et plongeons nous dans ces packages de cartographie.

{leaflet}, le package star des cartes interactives

Je dirais que {leaflet} est LA star des packages de cartes interactifs. On le voit partout, et même si on lui reproche parfois sa lenteur d’affichage, il est ultra complet, et la doc est vraiment bien faite : https://rstudio.github.io/leaflet/. Ce package utilise la librairie Javascript open source du même nom qui est largement utilisée (cf. la partie “Trusted by the best” sur https://leafletjs.com/ ).

Maintenant, la base. Pour créer notre carte, on appelle la fonction leaflet(), avec ou sans données :

library(leaflet)
library(plyr)
map_leaflet <- leaflet()
map_leaflet

Ceci est une carte interactive, vous pouvez la tester (elle est vide et c’est normal.

Voilà, notre map est créé, mais pour le moment il ne contient rien. On va pouvoir lui ajouter autant de layers que l’on souhaite, et dans l’ordre qui nous chante. Mais un layer c’est quoi ? C’est une couche qu’on ajoute à notre carte, et il y en a de différents types :

• les fonds de carte
• les points, ou markers
• les lignes
• les polygones/surfaces

Il est également possible d’ajouter des éléments d’évènements, j’y reviendrai plus tard.

Ajouter un fond de carte

Le fond de carte de base de {leaflet} est par défaut celui d’OpenStreetMap. Pour ajouter un fond de carte à notre Leaflet, on appelle la fonction addTiles() :

map_leaflet <- leaflet() %>%
  addTiles()
map_leaflet

Ceci est une carte interactive, vous pouvez la tester

Bon on est d’accord, c’est pas le fond de carte le plus sexy qu’on puisse trouver. Heureusement, grâce à la fonction addProviderTiles(), on peut choisir l’un des nombreux fond de carte proposés par Leaflet et que vous trouverez sur http://leaflet-extras.github.io/leaflet-providers/preview/ .

Choisissons "Esri.OceanBasemap" par exemple :

leaflet() %>%
    addProviderTiles("Esri.OceanBasemap")

Ceci est une carte interactive, vous pouvez la tester

Vous trouverez aussi la liste des couches a priori disponibles en tapant providers dans la console. Il est également possible de superposer ces couches. Je souhaite par exemple avoir le fond de carte “CartoDB.DarkMatter”, avec les lignes de train qui sont dans le layer “OpenRailwayMap”.
Par ailleurs, ce qui m’intéresse, c’est la France. La fonction setView() permet de centrer la carte sur le lieu de notre choix (coordonnées géographiques), avec un certain niveau de zoom :

map_leaflet <- leaflet() %>%
  addProviderTiles("CartoDB.DarkMatter") %>%
  addProviderTiles("OpenRailwayMap") %>%
  setView(lng = 2.80, lat = 46.80, zoom = 5)
map_leaflet

Ceci est une carte interactive, vous pouvez la tester

Ça commence à être pas mal non ?

Afficher un fichier de points avec des markers

Nous téléchargeons le jeu de données “Que faire à Paris ?” sur le site Opendata de Paris au format GeoJSON. Un format de données cartographiques, en coordonnées géographiques, lisible avec {sf}.
Nous allons filtrer les expositions dans le premier arrondissement de Paris et conserver uniquement certaines colonnes d’intérêt pour la suite. La colonne description n’est pas affichée dan le résumé ci-dessous mais on la garde aussi pour plus tard.

library(sf)
library(stringr)
data_expo_wgs84 <- read_sf("data/que-faire-a-paris-.geojson") %>% 
  filter(
    address_zipcode == 75001,
    str_detect(category, pattern = "Expositions")
  ) %>% 
  select(title, cover_url, description, address_name)
data_expo_wgs84 %>% 
  select(-description)

## Simple feature collection with 14 features and 3 fields
## geometry type:  POINT
## dimension:      XY
## bbox:           xmin: 2.325941 ymin: 48.8576 xmax: 2.346853 ymax: 48.86405
## geographic CRS: WGS 84
## # A tibble: 14 x 4
##    title              cover_url                  address_name                      geometry
##    <chr>              <chr>                      <chr>                          <POINT [°]>
##  1 "Giorgio de Chiri… https://quefaire-api.pari… Musée de l'Orange…     (2.325941 48.86219)
##  2 "Vinyle, quand la… https://quefaire-api.pari… Médiathèque music…     (2.345769 48.86271)
##  3 "Exposition : \"V… https://quefaire-api.pari… Médiathèque de la…      (2.346853 48.8624)
##  4 "Vinyle, quand la… https://quefaire-api.pari… Médiathèque de la…      (2.346853 48.8624)
##  5 "Araignées, lucio… https://cdn.paris.fr/qfap… Musée en herbe         (2.342144 48.86012)
##  6 "Figure d'artiste" https://quefaire-api.pari… Musée du Louvre        (2.340255 48.85912)
##  7 "Rêves d'une nuit… https://cdn.paris.fr/qfap… 59 Rivoli              (2.345768 48.85924)
##  8 "Le Corps et l’Âm… https://cdn.paris.fr/qfap… Le Louvre              (2.338457 48.86042)
##  9 "De Calcutta à la… https://quefaire-api.pari… Médiathèque music…     (2.345769 48.86271)
## 10 "Vinyle, quand la… https://quefaire-api.pari… Médiathèque music…     (2.345769 48.86271)
## 11 "Exposition \" Sc… https://cdn.paris.fr/qfap… Médiathèque de la…      (2.346853 48.8624)
## 12 "Construire l’opé… https://cdn.paris.fr/qfap… Théâtre du Châtel…      (2.346764 48.8576)
## 13 "Vinyle, quand la… https://quefaire-api.pari… Bibliothèque du c…     (2.331053 48.86405)
## 14 "Harper’s Bazaar,… https://quefaire-api.pari… Musée des arts Dé…     (2.333307 48.86309)

Les cartes avec {leaflet} n’acceptent que les jeux de données en coordonnées géographiques. Si vous avez besoin de transformer vos données spatiales dans ce système de coordonnées, pensez à la fonction st_transform() de {sf} comme on l’a fait au début de cet article.
Pour afficher les points sur la carte, on appelle la fonction addMarkers() qui reconnaîtra directement les coordonnées des points à afficher dans l’objet {sf}.

Pour intégrer ces données à la carte, deux façons possibles :

• soit un appel global avec la fonction leaflet(), ce qui permet de réutiliser ce jeu de données pour d’autres affichages :

map_leaflet <- leaflet(data_expo_wgs84) %>%
  addProviderTiles('Stamen.Watercolor') %>%
  addMarkers()
map_leaflet

• soit en local lors de l’appel de la fonction addMarkers()

map_leaflet <- leaflet() %>%
  addProviderTiles('Stamen.Watercolor') %>%
  addMarkers(data = data_expo_wgs84)
map_leaflet

Ceci est une carte interactive, vous pouvez la tester

Pas mal… Ajoutons maintenant un peu d’infos à ce graphe. Je vous parlais plus haut d’éléments “évènement”. J’entends par là ce que l’on va pouvoir afficher lorque l’on passe la souris sur un élément, ou que l’on clique dessus. Pour les personnes familières avec le JavaScript, on parle de hover ou onClick. Les paramètres label et popup nous permettent de renseigner ce que l’on souhaite afficher.

• On affiche le nom du lieu de l’exposition avec label quand on passe la souris sur le marker.
• Pour le popup, c’est-à-dire quand on clique sur le marker, compliquons un peu les choses : je veux afficher le nom de l’exposition en gras, sa description, et la photo correspondante. Le paramètre popup accepte du texte au format HTML que l’on va créé comme une variable de notre jeu de données avant le Leaflet.
• Et pour une carte un peu plus personnalisée, je choisis un marker spécifique grâce à la fonction makeIcon(): .

# Contenu du popup en HTML
data_expo_infos_wgs84 <- data_expo_wgs84 %>% 
  mutate(
    popup = paste0(
      "<b>", title,
      "</b><br/><img src=", cover_url, " width='100px'><br/>",
      description)
  )
# Nouvelle icone
icone_musee <- makeIcon(iconUrl = "img/leaflet-icons8-museum-26.png")
# Leaflet
map_leaflet <- leaflet(data_expo_infos_wgs84) %>%
  addProviderTiles('Stamen.Watercolor') %>%
  addMarkers(
    # En passant la souris
    label = ~address_name, 
    # En cliquant sur l'icone
    popup = ~popup,
    # Quelques options de la popup
    popupOptions = 
      list(maxHeight = 150, maxWidth = 200),
    # icone affichée
    icon = icone_musee)
map_leaflet

Ceci est une carte interactive, vous pouvez la tester

Afficher des lignes et des polygones avec leaflet

Prenons comme exemple les régions de France (Format shapefile, WGS84), auxquelles on ajoute les données de population.

Ici aussi, pour lire le fichier de données géographiques au format shapefile, on utilise la fonction read_sf() du package {sf}. Notez que l’encodage est en UTF-8, si vous n’avez pas réglé votre machine sur cet encodage par défaut, il faudra modifier la colonne comme ci-dessous :

regions_wgs84 <- read_sf(
  dsn = "data/contours-geographiques-des-nouvelles-regions-metropole", 
  layer = "contours-geographiques-des-nouvelles-regions-metropole") %>% 
  mutate(region = str_conv(region, "utf-8"))
regions_wgs84

## Simple feature collection with 13 features and 2 fields
## geometry type:  MULTIPOLYGON
## dimension:      XY
## bbox:           xmin: -4.794442 ymin: 41.36456 xmax: 9.559699 ymax: 51.08914
## geographic CRS: WGS 84
## # A tibble: 13 x 3
##    region             new_code                                                     geometry
##  * <chr>              <chr>                                              <MULTIPOLYGON [°]>
##  1 Hauts-de-France    32       (((4.141926 49.97883, 4.142696 49.9777, 4.145595 49.97602, …
##  2 Grand-Est          44       (((7.578222 48.12144, 7.577952 48.12067, 7.577341 48.11881,…
##  3 Occitanie          76       (((4.101622 43.55436, 4.101012 43.55451, 4.100892 43.5546, …
##  4 Normandie          28       (((1.714687 49.40929, 1.714757 49.40915, 1.714847 49.40875,…
##  5 Pays de la Loire   52       (((0.2307793 47.60846, 0.2316886 47.60744, 0.2321986 47.607…
##  6 Ile-de-France      11       (((1.609616 49.0777, 1.610746 49.07799, 1.611316 49.07818, …
##  7 Bourgogne-Franche… 27       (((6.94079 47.43332, 6.94066 47.43102, 6.94099 47.42944, 6.…
##  8 Auvergne-Rhône-Al… 84       (((6.261095 45.12686, 6.260896 45.12664, 6.259585 45.1243, …
##  9 Bretagne           53       (((-1.947151 48.53889, -1.947301 48.53911, -1.947911 48.539…
## 10 Provence-Alpes-Cô… 93       (((4.231137 43.47935, 4.231196 43.47973, 4.232336 43.48149,…
## 11 Corse              94       (((9.395212 41.86071, 9.395042 41.86055, 9.395103 41.86041,…
## 12 Nouvelle Aquitaine 75       (((1.448978 45.01935, 1.448347 45.0189, 1.446077 45.01803, …
## 13 Centre-Val de Loi… 24       (((2.168888 46.42398, 2.167757 46.42396, 2.165697 46.42387,…

Le fichier de données de population est un fichier csv avec un encodage Windows. Vous pouvez le spécifier à la lecture. Ensuite, on peut réaliser la jointure entre notre fichier de polygones et le fichier de population sur la base de la colonne region.

# Lecture pop
pop <- read_csv2("data/region_population.csv", locale = locale(encoding = "latin1"))
# Jointure à gauche
regions_pop_wgs84 <- regions_wgs84 %>% 
  left_join(pop, by = "region")
regions_pop_wgs84

## Simple feature collection with 13 features and 3 fields
## geometry type:  MULTIPOLYGON
## dimension:      XY
## bbox:           xmin: -4.794442 ymin: 41.36456 xmax: 9.559699 ymax: 51.08914
## geographic CRS: WGS 84
## # A tibble: 13 x 4
##    region          new_code                                             geometry population
##    <chr>           <chr>                                      <MULTIPOLYGON [°]>      <dbl>
##  1 Hauts-de-France 32       (((4.141926 49.97883, 4.142696 49.9777, 4.145595 49…    5962662
##  2 Grand-Est       44       (((7.578222 48.12144, 7.577952 48.12067, 7.577341 4…    5511747
##  3 Occitanie       76       (((4.101622 43.55436, 4.101012 43.55451, 4.100892 4…    5924858
##  4 Normandie       28       (((1.714687 49.40929, 1.714757 49.40915, 1.714847 4…    3303500
##  5 Pays de la Loi… 52       (((0.2307793 47.60846, 0.2316886 47.60744, 0.232198…    3801797
##  6 Ile-de-France   11       (((1.609616 49.0777, 1.610746 49.07799, 1.611316 49…   12278210
##  7 Bourgogne-Fran… 27       (((6.94079 47.43332, 6.94066 47.43102, 6.94099 47.4…    2783039
##  8 Auvergne-Rhône… 84       (((6.261095 45.12686, 6.260896 45.12664, 6.259585 4…    8032377
##  9 Bretagne        53       (((-1.947151 48.53889, -1.947301 48.53911, -1.94791…    3340379
## 10 Provence-Alpes… 93       (((4.231137 43.47935, 4.231196 43.47973, 4.232336 4…    5055651
## 11 Corse           94       (((9.395212 41.86071, 9.395042 41.86055, 9.395103 4…     344679
## 12 Nouvelle Aquit… 75       (((1.448978 45.01935, 1.448347 45.0189, 1.446077 45…    5999982
## 13 Centre-Val de … 24       (((2.168888 46.42398, 2.167757 46.42396, 2.165697 4…    2559073

Bon, maintenant que ces petits détails techniques sont réglés, faisons ce pour quoi on est là : une carte !

• La fonction addPolygons() nous permet d’ajouter les polygones à la carte.
  • Comme avec la fonction addMarkers(), les paramètres label et popup permettent d’afficher des informations relatives à nos polygones.
  • Les paramètres fill, fillColor, et fillOpacity nous donnent la possibilité quant à eux d’indiquer la couleur de remplissage de notre objet, color pour la couleur des contours
  • Ici on colore la région en fonction de la densité de sa population calculée à partir de la taille de la population totale divisée par la surface du polygone.
  • Le paramètre highlightOptions concerne le comportement de la forme lorsque l’on passe le curseur dessus.
• La création d’une palette de couleur pour des données numériques se fait en deux temps, avec colorBin() (ou autres color*()).
  • On crée une fonction qui permet de lier une valeur à une couleur sur la base de notre vecteur de données: pal()
  • On utiliser effectivement cette fonction dans Leaflet sur nos données
• Il est également possible d’ajouter cercles et rectangles manuellement à notre carte, grâce aux fonctions addCircles() et addRectangles() respectivement.

Notez que nous représentons avec un dégradé de couleurs la densité et non pas le nombre absolu d’habitants. C’est une des règles de représentation en cartographie. Si vous affichez un polygone coloré, la valeur représentée par la couleur doit être vraie en tout pixel de la carte. Une couleur pour différencier une forêt d’une plage, ça marche. Un nombre moyen d’habitant au km², ça marche. Le nombre total d’habitants de la région, ça ne marche pas.

# Calcul de la densité de population
regions_dens_wgs84 <- regions_pop_wgs84 %>% 
  # Simplifier la géométrie pour une carte plus légère
  rmapshaper::ms_simplify(keep = 0.01) %>% 
  # Calcul surface et densite
  mutate(
    area_km2 = set_units(st_area(geometry), "km2"),
    density = drop_units(population / area_km2)
  )
# Creation de la fonction de palette numérique sur nos densités
pal <- colorBin(
  palette = "viridis",
  domain = regions_dens_wgs84$density,
  reverse = TRUE,
  # Echelle avec des quantiles sinon Paris prend toute la place...
  bins = quantile(
    regions_dens_wgs84$density,
    probs = seq(0, 1, by = 0.2))
)
map_regions <- leaflet() %>%
  addTiles() %>%
  # polygone des regions
  addPolygons(
    data = regions_dens_wgs84, 
    label = ~region,
    popup = ~paste0("Densité : ", round(density), " hab/km2"), 
    fill = TRUE, 
    # Application de la fonction palette
    fillColor = ~pal(density),
    fillOpacity = 0.8,
    highlightOptions = highlightOptions(color = "white", weight = 2)) %>%
  # Ajout d'un cercle à la main sur Paris
  addCircles(
    lng = 2.34, lat = 48.85,
    radius = 20000,
    popup = "Paris", color = "red") %>%
  # Ajout d'un rectangle à la main sur la Corse
  addRectangles(
    lng1 = 8.11, lat1 = 43.10,
    lng2 = 9.92, lat2 = 41.25,
    color = "green", 
    fill = FALSE) %>% 
  addLegend(
    title = "Density nb/km2",
    pal = pal, values = regions_dens_wgs84$density)
# map_regions

Ceci est une carte interactive, vous pouvez la tester

Integration de {leaflet} dans Shiny

Côté UI, la fonction dédiée s’appelle leafletOutput(), et côté server, sans surprise, la fonction renderLeaflet().
Exemple d’utilisation :

library(shiny)
library(leaflet)
ui <- fluidPage(
  h3("Points sur une carte"),
  actionButton("go_alea", "Générer points aléatoires"),
  leafletOutput("map_points")
)
server <- function(input, output) {
  output$map_points <- renderLeaflet({
    input$go_alea
    isolate({
      points <- data.frame(
        lon = runif(10, -0.6, 5.5),
        lat = runif(10, 44.10, 48.9)
      )
      leaflet() %>%
        addTiles() %>%
        addMarkers(lng = ~lon, lat = ~lat, data = points)
    })
  })
}
shinyApp(ui, server)

Ceci est une capture d’écran…

L’utilisation conjointe de Shiny et de Leaflet est également intéressante lorsque l’on souhaite récupérer des valeurs d’input via la carte. On utilisera un input de la forme : input$<ma_carte_output>_<forme_action_javascript>. Cela s’utilise comme un input qui va renvoyer une liste contenant lgn la longitude, lat la latitude, et id si la variable correspondante est renseignée via le paramètre layerId.
En prenant l’exemple précédent : je souhaite afficher les coordonnées d’un point cliqué sur la carte.

library(shiny)
library(leaflet)
ui <- fluidPage(
  h3("Points aléatoires sur la carte et coordonnées"),
  fluidRow(
    column(width = 6,
           actionButton("go_alea", "Points aléatoires")),
    column(width = 6, 
           h4("Coordonnées"),
           textOutput("coord"))
  ),
  leafletOutput("map_points")
)
server <- function(input, output) {
  output$map_points <- renderLeaflet({
    input$go_alea
    isolate({
      points <- data.frame(
        lon = runif(10, -0.6, 5.5),
        lat = runif(10, 44.10, 48.9))
      points$id <- paste0(points$lon, " - ", points$lat)
      map_alea <- leaflet() %>%
        addTiles() %>%
        addMarkers(lng = ~lon, lat = ~lat,
                   data = points, layerId = ~id)
      map_alea
    })
  })
  output$coord <- renderText({
    clic <- input$map_points_click
    txt <- paste0("Coordonnées : ", clic$lat, " - ", clic$lng)
    txt
  })
}
shinyApp(ui, server)

Ceci est une capture d’écran…

Les objets concernés sont, entre autres :

• la carte : input$<ma_carte_output>_<action>
• les markers : input$<ma_carte_output>_marker_<action>
• les polygones, lignes, cercles : input$<ma_carte_output>_shape_<action>

Les actions possibles sont :

• le clic : input$<ma_carte_output>_<forme>_click
• le survol de curseur : input$<ma_carte_output>_<forme>_mouseover
• moins utilisé, quand le curseur “quitte” l’élément : input$<ma_carte_output>_<forme>_mouseout

Pour en savoir plus sur l’intégration de Leaflet dans Shiny, c’est par là : https://rstudio.github.io/leaflet/shiny.html

Enfin, si vous souhaitez aller plus loin dans la personnalisation de vos cartes, je vous suggère d’aller jeter un oeil à la grande quantité de plugins existants pour Leaflet : https://leafletjs.com/plugins.html.

Bonus : Intégrer un fond de carte Mapbox GL dans Leaflet

Mapbox, pour ceux qui ne connaissent pas, c’est une api de cartes pour les développeurs. Et vu qu’ils ont des fonds de carte plutôt pas mal, on s’est dit que c’était une bonne idée de vous montrer comment on peut les utiliser dans {leaflet} directement. Il vous faudra tout d’abord créer un compte sur le site de Mapbox (gratuit). On va ensuite choisir le fond de carte qui nous intéresse avec le lien suivant : https://studio.mapbox.com/.

url <- "https://api.mapbox.com/styles/v1/..."
leaflet(quakes) %>%
  addTiles(urlTemplate = url,
           attribution = "Maps by mapbox") %>%
  addCircleMarkers(weight = 1, fillOpacity = 0, radius = 3) 

Ceci est une carte interactive, vous pouvez la tester

Joe Cheng nous a fait un petit package, pas encore disponible sur le CRAN mais téléchargeable depuis Github, {leaflet.mapboxgl}, qui nous fournit une extension via la librarie JavaScript Mapbox GL JS. Il est nécessaire dans certains cas de se créer un compte sur Mapbox afin de disposer d’un token. Un petit exemple d’utilisation :

# Installation et chargement du package : 
# devtools::install_github("rstudio/leaflet.mapboxgl")
library(leaflet.mapboxgl)
# Declaration du token
options(mapbox.accessToken = "...")
# Carte
leaflet(quakes) %>%
  addMapboxGL(style = "mapbox://styles/mapbox/streets-v9") %>%
  addCircleMarkers(weight = 1, fillOpacity = 0, radius = 3)

Ceci est une carte interactive, vous pouvez la tester

Et voilà !

Affaire à suivre…

Comme il n’y a pas que Leaflet dans la vie, on vous proposera prochainement un nouvel article pour un petit tour d’horizon des autres packages R qui existent et avec lesquels il est également possible de faire des cartes interactives plutôt sympas.

Et pour une initiation à la cartographie avec {sf}, les cartes interatives et autres packages, c’est par ici.

Article rédigé par Elena Salette, avec la participation de Sébastien Rochette.