0Pricing
R Academy · Leçon

Cartes interactives avec leaflet

Affichez des cartes web interactives avec des marqueurs, des fenêtres contextuelles et des couches de tuiles.

Cartes interactives avec leaflet est une leçon R Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage R Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours R Academy comprend 4 leçons au total.

Introduction à leaflet

Le package leaflet encapsule la bibliothèque Leaflet.js pour créer des cartes Web interactives et zoomables directement depuis R. Les cartes sont des widgets HTML qui s’affichent dans la visionneuse de RStudio, R Markdown et les applications Shiny, sans nécessiter de connaissances en JavaScript.

library(leaflet)

# Minimal leaflet map: tiles + one marker
leaflet() |>
  addTiles() |>         # OpenStreetMap base layer
  setView(
    lng  = -74.006,
    lat  =  40.713,
    zoom = 12
  ) |>
  addMarkers(
    lng   = -74.006,
    lat   =  40.713,
    popup = '<b>New York City</b>'
  )

addTiles : couches de fond de carte

addTiles() ajoute la couche de tuiles OpenStreetMap par défaut. Utilisez addProviderTiles(providers$) pour passer à des images satellite ou à un autre fournisseur de tuiles, comme CartoDB, Esri ou Stamen. Les noms des couches figurent dans la liste intégrée providers.

library(leaflet)

# Default OpenStreetMap
map1 <- leaflet() |> addTiles()

# CartoDB light theme (great for data overlay)
map2 <- leaflet() |>
  addProviderTiles(providers$CartoDB.Positron)

# Satellite imagery
map3 <- leaflet() |>
  addProviderTiles(providers$Esri.WorldImagery)

# Custom tile URL
custom <- leaflet() |>
  addTiles(
    urlTemplate = 'https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png',
    attribution  = '(c) OpenStreetMap contributors'
  )

map2

addMarkers avec fenêtres contextuelles

addMarkers(lng, lat, popup) ajoute des marqueurs en forme d’épingle à la carte. L’argument popup accepte des chaînes HTML, ce qui vous permet d’inclure du texte en gras, des liens ou des images. L’argument label affiche du texte au survol, sans clic.

library(leaflet)

cities <- data.frame(
  name = c('New York', 'Los Angeles', 'Chicago'),
  lon  = c(-74.006, -118.244, -87.629),
  lat  = c( 40.713,   34.052,  41.878),
  pop  = c(8336817,  3979576, 2693976)
)

leaflet(cities) |>
  addTiles() |>
  addMarkers(
    lng   = ~lon,
    lat   = ~lat,
    popup = ~paste0(
      '<b>', name, '</b><br>',
      'Population: ', format(pop, big.mark = ',')
    ),
    label = ~name
  )

addCircleMarkers

addCircleMarkers() affiche des cercles dont la taille est fixe en pixels à l’écran (contrairement à addCircles(), dont la taille varie avec le niveau de zoom). Ils sont idéaux pour représenter des symboles proportionnels : associez le radius à une variable de données.

library(leaflet)

cities <- data.frame(
  name = c('New York', 'Los Angeles', 'Chicago', 'Houston', 'Phoenix'),
  lon  = c(-74.006, -118.244, -87.629, -95.369, -112.074),
  lat  = c( 40.713,   34.052,  41.878,  29.760,   33.449),
  pop  = c(8336817,  3979576, 2693976, 2304580, 1608139)
)

leaflet(cities) |>
  addProviderTiles(providers$CartoDB.Positron) |>
  addCircleMarkers(
    lng    = ~lon,
    lat    = ~lat,
    radius = ~sqrt(pop / 50000),
    color  = 'steelblue',
    fill   = TRUE,
    fillOpacity = 0.6,
    popup  = ~paste0(name, ': ', format(pop, big.mark = ','))
  )

addPolygons : cartes choroplèthes

addPolygons() affiche directement les géométries polygonales d’un objet sf. La couleur de remplissage peut être associée à une colonne de données à l’aide des fonctions de palette colorNumeric() ou colorBin(). Une option highlight ajoute des effets au survol.

library(leaflet)
library(sf)

nc <- st_transform(
  read_sf(system.file('shape/nc.shp', package = 'sf')), 4326
)

# Colour palette based on birth count
pal <- colorNumeric('YlOrRd', domain = nc$BIR74)

leaflet(nc) |>
  addProviderTiles(providers$CartoDB.Positron) |>
  addPolygons(
    fillColor   = ~pal(BIR74),
    fillOpacity = 0.7,
    color       = 'white',
    weight      = 1,
    popup       = ~paste0('<b>', NAME, '</b><br>Births 1974: ', BIR74),
    highlight   = highlightOptions(
      weight    = 3,
      color     = '#333',
      bringToFront = TRUE
    )
  ) |>
  addLegend('bottomright', pal = pal, values = ~BIR74, title = 'Births 1974')

setView et fitBounds

setView(lng, lat, zoom) centre la carte sur un emplacement et un niveau de zoom fixes. fitBounds(lng1, lat1, lng2, lat2) ajuste automatiquement le zoom afin d’inclure une boîte englobante géographique, ce qui est utile lorsque l’étendue des données n’est pas connue à l’avance.

library(leaflet)
library(sf)

nc <- st_transform(
  read_sf(system.file('shape/nc.shp', package = 'sf')), 4326
)
bbox <- st_bbox(nc)

# fitBounds: auto-zoom to data extent
leaflet() |>
  addTiles() |>
  fitBounds(
    lng1 = bbox['xmin'], lat1 = bbox['ymin'],
    lng2 = bbox['xmax'], lat2 = bbox['ymax']
  ) |>
  addPolygons(
    data        = nc,
    fillColor   = 'lightblue',
    fillOpacity = 0.4,
    color       = 'steelblue',
    weight      = 1
  )

addLayersControl : afficher ou masquer les couches

addLayersControl() ajoute un contrôle composé de boutons radio et de cases à cocher pour afficher ou masquer les fonds de carte et les couches superposées. Utilisez baseGroups pour les couches de tuiles mutuellement exclusives et overlayGroups pour les couches de données pouvant être activées ou désactivées indépendamment.

library(leaflet)
library(sf)

nc <- st_transform(
  read_sf(system.file('shape/nc.shp', package = 'sf')), 4326
)

high_birth  <- nc[nc$BIR74 > 3000, ]
low_birth   <- nc[nc$BIR74 <= 3000, ]

leaflet() |>
  addProviderTiles(providers$CartoDB.Positron, group = 'Light') |>
  addProviderTiles(providers$Esri.WorldImagery, group = 'Satellite') |>
  addPolygons(data = high_birth, color = 'red',   group = 'High Births (>3000)') |>
  addPolygons(data = low_birth,  color = 'blue',  group = 'Low Births (<=3000)') |>
  addLayersControl(
    baseGroups    = c('Light', 'Satellite'),
    overlayGroups = c('High Births (>3000)', 'Low Births (<=3000)'),
    options       = layersControlOptions(collapsed = FALSE)
  )

addPopups et addLegend

addPopups() ajoute des fenêtres contextuelles persistantes (toujours visibles). addLegend() crée une légende de carte associée à une palette de couleurs. Les deux prennent en charge le contenu HTML et peuvent être entièrement personnalisés avec des classes CSS.

library(leaflet)

leaflet() |>
  addTiles() |>
  setView(-79.0, 35.5, zoom = 7) |>
  addPopups(
    lng     = -78.639,
    lat     =  35.779,
    popup   = '<b>Raleigh</b><br>State Capital of NC'
  ) |>
  addLegend(
    position = 'bottomleft',
    colors   = c('red', 'blue', 'green'),
    labels   = c('High', 'Medium', 'Low'),
    title    = 'Risk Level',
    opacity  = 0.8
  )

Palettes de couleurs : colorNumeric et colorBin

Les fonctions colorNumeric(), colorBin(), colorQuantile() et colorFactor() créent des fonctions de palette qui associent les valeurs des données à des couleurs hexadécimales. Transmettez le résultat à fillColor et utilisez la même palette avec addLegend().

library(leaflet)
library(sf)

nc <- st_transform(
  read_sf(system.file('shape/nc.shp', package = 'sf')), 4326
)

# Continuous palette
pal_num <- colorNumeric('Blues', domain = nc$BIR74)

# Binned palette (5 equal bins)
pal_bin <- colorBin('RdYlGn', domain = nc$BIR74, bins = 5)

# Quantile palette (equal number of features per class)
pal_qtl <- colorQuantile('YlOrRd', domain = nc$BIR74, n = 4)

# Use binned palette
leaflet(nc) |>
  addTiles() |>
  addPolygons(
    fillColor   = ~pal_bin(BIR74),
    fillOpacity = 0.7, weight = 1, color = 'white'
  ) |>
  addLegend('bottomright', pal = pal_bin, values = ~BIR74,
            title = 'Births 1974 (5 bins)')

leafletProxy : mettre à jour les cartes dans Shiny

leafletProxy('mapId') met à jour une carte leaflet existante dans une application Shiny sans restituer toute la carte depuis le début. Utilisez-le avec clearMarkers(), clearShapes() ou addMarkers() pour réagir efficacement aux données saisies par l’utilisateur.

library(shiny)
library(leaflet)

# Minimal Shiny app with leafletProxy
ui <- fluidPage(
  selectInput('colour', 'Marker colour:', choices = c('red', 'blue', 'green')),
  leafletOutput('map')
)

server <- function(input, output, session) {
  output$map <- renderLeaflet({
    leaflet() |> addTiles() |>
      setView(-79.0, 35.5, zoom = 7)
  })

  observeEvent(input$colour, {
    leafletProxy('map') |>
      clearMarkers() |>
      addCircleMarkers(
        lng   = -78.639, lat = 35.779,
        color = input$colour,
        label = paste('Raleigh -', input$colour)
      )
  })
}

# shinyApp(ui, server)  # uncomment to run

Carte choroplèthe interactive complète

Voici une carte choroplèthe de qualité production qui combine toutes les fonctionnalités essentielles : tuiles provenant d’un fournisseur, remplissage des polygones, surbrillances au survol, fenêtres contextuelles dynamiques, légende de couleurs et contrôles des couches, le tout en moins de 25 lignes.

library(leaflet)
library(sf)

nc <- st_transform(
  read_sf(system.file('shape/nc.shp', package = 'sf')), 4326
)
pal <- colorQuantile('YlOrRd', domain = nc$SID74, n = 5)

leaflet(nc) |>
  addProviderTiles(providers$CartoDB.Positron) |>
  addPolygons(
    fillColor   = ~pal(SID74),
    fillOpacity = 0.75,
    color       = 'white',
    weight      = 0.5,
    popup       = ~paste0('<b>', NAME, '</b><br>SIDS 1974: ', SID74),
    highlight   = highlightOptions(
      weight = 2, color = '#555', bringToFront = TRUE
    )
  ) |>
  addLegend(
    position = 'bottomright',
    pal = pal, values = ~SID74,
    title = 'SIDS Deaths 1974<br>(Quintiles)'
  ) |>
  addControl('<b>NC SIDS Data 1974</b>', position = 'topright')

Vérification rapide

Dans une application Shiny, vous souhaitez mettre à jour la position des marqueurs sur une carte leaflet existante lorsque l’utilisateur modifie une liste déroulante, sans restituer toute la carte. Quelle fonction devez-vous utiliser ?

Récapitulatif : package leaflet

Points essentiels :

  • leaflet() |> addTiles() crée une carte interactive avec des tuiles OpenStreetMap
  • addProviderTiles(providers$) permet de basculer vers d’autres fournisseurs de tuiles
  • addMarkers() / addCircleMarkers() servent à représenter des données ponctuelles ; utilisez popup et label
  • addPolygons(fillColor = ~pal(col)) sert à créer des cartes choroplèthes
  • colorNumeric(), colorBin() et colorQuantile() créent des fonctions de palette
  • addLegend() s’utilise avec les fonctions de palette ; addLayersControl() permet d’afficher ou de masquer les couches
  • leafletProxy() permet de mettre efficacement à jour les cartes Shiny
  • fitBounds() ajuste automatiquement le zoom à l’étendue des données
library(leaflet)

# Three-line interactive map
leaflet() |>
  addProviderTiles(providers$CartoDB.Positron) |>
  addCircleMarkers(lng = c(-74, -118, -88), lat = c(41, 34, 42),
                   label = c('NYC', 'LA', 'Chicago'), color = 'steelblue')

Questions Fréquemment Posées

La leçon « Cartes interactives avec leaflet » est-elle gratuite ?

Oui — le texte complet de « Cartes interactives avec leaflet » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours R Academy, passe à CoddyKit PRO. Le cours R Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Cartes interactives avec leaflet » ?

Affichez des cartes web interactives avec des marqueurs, des fenêtres contextuelles et des couches de tuiles. Tu pratiques R Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer R Academy ?

Aucune expérience préalable n'est requise. R Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Cartes interactives avec leaflet » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon R Academy ?

Oui. Chaque leçon R Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Objets spatiaux simples avec le paquet sf
  2. Systèmes de coordonnées et projections
  3. Jointures et opérations spatiales
  4. Cartes interactives avec leaflet
← Retour à R Academy