R Language
Introduction aux cartes géographiques

Introduction

Création de carte de base avec map () à partir des cartes de package

La fonction map() des maps package fournit un point de départ simple pour créer des cartes avec R.

Une carte du monde de base peut être dessinée comme suit:

require(maps)
map()

La couleur du contour peut être modifiée en définissant le paramètre de couleur, col , sur le nom du caractère ou la valeur hexadécimale d’une couleur:

require(maps)
map(col = "cornflowerblue")

Pour remplir les masses de terrain avec la couleur en col nous pouvons définir le fill = TRUE :

require(maps)
map(fill = TRUE, col = c("cornflowerblue"))

Un vecteur de longueur quelconque peut être fourni à col lorsque fill = TRUE est également défini:

require(maps)
map(fill = TRUE, col = c("cornflowerblue", "limegreen", "hotpink"))

Dans l'exemple ci-dessus, les couleurs de col sont affectées arbitrairement aux polygones de la carte représentant les régions et les couleurs sont recyclées s'il y a moins de couleurs que les polygones.

Nous pouvons également utiliser le codage couleur pour représenter une variable statistique, qui peut éventuellement être décrite dans une légende. Une carte créée en tant que telle est appelée "choropleth".

L'exemple choropleth suivant définit le premier argument de map() , qui est la database de database "county" et "state" pour colorer le chômage en utilisant les données des ensembles de données unemp et county.fips en superposant les lignes d'état en blanc:

require(maps)
if(require(mapproj)) {    # mapproj is used for  projection="polyconic"
  # color US county map by 2009 unemployment rate
  # match counties to map using FIPS county codes
  # Based on J's solution to the "Choropleth Challenge"
  # Code improvements by Hack-R (hack-r.github.io)
  
  # load data
  # unemp includes data for some counties not on the "lower 48 states" county
  # map, such as those in Alaska, Hawaii, Puerto Rico, and some tiny Virginia
  #  cities
  data(unemp)
  data(county.fips)
  
  # define color buckets
  colors = c("paleturquoise", "skyblue", "cornflowerblue", "blueviolet", "hotpink", "darkgrey")
  unemp$colorBuckets <- as.numeric(cut(unemp$unemp, c(0, 2, 4, 6, 8, 10, 100)))
  leg.txt <- c("<2%", "2-4%", "4-6%", "6-8%", "8-10%", ">10%")
  
  # align data with map definitions by (partial) matching state,county
  # names, which include multiple polygons for some counties
  cnty.fips <- county.fips$fips[match(map("county", plot=FALSE)$names,
                                      county.fips$polyname)]
  colorsmatched <- unemp$colorBuckets[match(cnty.fips, unemp$fips)]
  
  # draw map
  par(mar=c(1, 1, 2, 1) + 0.1)
  map("county", col = colors[colorsmatched], fill = TRUE, resolution = 0,
      lty = 0, projection = "polyconic")
  map("state", col = "white", fill = FALSE, add = TRUE, lty = 1, lwd = 0.1,
      projection="polyconic")
  title("unemployment by county, 2009")
  legend("topright", leg.txt, horiz = TRUE, fill = colors, cex=0.6)
}

50 cartes d'état et choroplèthes avancés avec Google Viz

Une question commune est de savoir comment juxtaposer (combiner) séparer physiquement des régions géographiques sur une même carte, comme dans le cas d'un choropleth décrivant les 50 États américains (le continent avec l'Alaska et Hawaii juxtaposés).

La création d'une carte attractive à 50 états est simple lors de l'utilisation de Google Maps. Les interfaces avec l'API de Google incluent les packages googleVis , ggmap et RgoogleMaps .

require(googleVis)

G4 <- gvisGeoChart(CityPopularity, locationvar='City', colorvar='Popularity',
                   options=list(region='US', height=350, 
                                displayMode='markers',
                                colorAxis="{values:[200,400,600,800],
                                 colors:[\'red', \'pink\', \'orange',\'green']}")
) 
plot(G4)

La fonction gvisGeoChart() nécessite beaucoup moins de codage pour créer un choropleth par rapport aux anciennes méthodes de mappage, telles que map() partir des maps package. Le paramètre colorvar permet de colorer facilement une variable statistique, à un niveau spécifié par le paramètre locationvar . Les différentes options transmises aux options sous forme de liste permettent de personnaliser les détails de la carte, tels que la taille ( height ), la forme ( markers ) et le code couleur ( colorAxis et colors ).

Cartes interactives

Le package plotly permet plusieurs types de tracés interactifs, y compris des cartes. Il existe plusieurs façons de créer une carte dans plotly . Soit vous fournissez vous-même les données de la carte (via plot_ly() ou ggplotly() ), utilisez les capacités de cartographie "native" de plot_geo() via plot_geo() ou plot_mapbox() ), ou même une combinaison des deux. Un exemple de fourniture de la carte vous-même serait:

library(plotly)
map_data("county") %>%
    group_by(group) %>%
    plot_ly(x = ~long, y = ~lat) %>%
    add_polygons() %>%
    layout(
        xaxis = list(title = "", showgrid = FALSE, showticklabels = FALSE),
        yaxis = list(title = "", showgrid = FALSE, showticklabels = FALSE)
    )

Pour une combinaison des deux approches, plot_ly() pour plot_geo() ou plot_mapbox() dans l'exemple ci-dessus. Voir le livre de l' intrigue pour plus d'exemples.

L'exemple suivant est une approche «strictement native» qui utilise l' attribut layout.geo pour définir l'esthétique et le niveau de zoom de la carte. Il utilise également la base de données world.cities des maps pour filtrer les villes brésiliennes et les tracer au-dessus de la carte "native".

Les principales variables: poph est un texte avec la ville et sa population (qui apparaît lors du survol de la souris); q est un facteur ordonné à partir du quantile de la population. ge a des informations pour la mise en page des cartes. Voir la documentation du package pour plus d'informations.

library(maps)
dfb <- world.cities[world.cities$country.etc=="Brazil",]
library(plotly)
dfb$poph <- paste(dfb$name, "Pop", round(dfb$pop/1e6,2), " millions")
dfb$q <- with(dfb, cut(pop, quantile(pop), include.lowest = T))
levels(dfb$q) <- paste(c("1st", "2nd", "3rd", "4th"), "Quantile")
dfb$q <- as.ordered(dfb$q)

ge <- list(
  scope = 'south america',
  showland = TRUE,
  landcolor = toRGB("gray85"),
  subunitwidth = 1,
  countrywidth = 1,
  subunitcolor = toRGB("white"),
  countrycolor = toRGB("white")
)

plot_geo(dfb, lon = ~long, lat = ~lat, text = ~poph,
    marker = ~list(size = sqrt(pop/10000) + 1, line = list(width = 0)),
    color = ~q, locationmode = 'country names') %>%
layout(geo = ge, title = 'Populations<br>(Click legend to toggle)')

Création de cartes HTML dynamiques avec Leaflet

Leaflet est une bibliothèque JavaScript open-source permettant de créer des cartes dynamiques pour le Web. RStudio a écrit des fixations R pour Leaflet, disponibles via son package de leaflet , construit avec htmlwidgets . Les cartes de dépliants s'intègrent bien avec les écosystèmes RMarkdown et Shiny .

L'interface est redirigée , en utilisant une fonction leaflet() pour initialiser une carte et les fonctions suivantes en ajoutant (ou supprimant) des couches de carte. De nombreux types de calques sont disponibles, des marqueurs avec des popups aux polygones pour créer des cartes choroplèthes. Les variables du fichier data.frame transmis à leaflet leaflet() sont accessibles via la fonction ~ quotation.

Pour mapper les jeux de données state.name et state.center :

library(leaflet)

data.frame(state.name, state.center) %>% 
    leaflet() %>% 
    addProviderTiles('Stamen.Watercolor') %>% 
    addMarkers(lng = ~x, lat = ~y, 
               popup = ~state.name, 
               clusterOptions = markerClusterOptions())

(Capture d'écran, cliquez pour la version dynamique.)

Cartes dynamiques dans des applications brillantes

Le package de brochure est conçu pour s’intégrer à Shiny

Dans l'interface utilisateur que vous appelez leafletOutput() et dans le serveur que vous appelez renderLeaflet()

library(shiny)
library(leaflet)

ui <- fluidPage(
    leafletOutput("my_leaf")
)

server <- function(input, output, session){
    
    output$my_leaf <- renderLeaflet({
        
        leaflet() %>%
            addProviderTiles('Hydda.Full') %>%
            setView(lat = -37.8, lng = 144.8, zoom = 10)
        
    })
    
}

shinyApp(ui, server)

Cependant, les entrées réactives qui affectent l'expression renderLeaflet entraînent la redessinisation de la totalité de la carte chaque fois que l'élément réactif est mis à jour.

Par conséquent, pour modifier une carte déjà en cours d’exécution, vous devez utiliser la fonction leafletProxy() .

Normalement, vous utilisez le leaflet pour créer les aspects statiques de la carte, et leafletProxy pour gérer les éléments dynamiques, par exemple:

library(shiny)
library(leaflet)

ui <- fluidPage(
    sliderInput(inputId = "slider", 
                label = "values",
                min = 0,
                max = 100,
                value = 0,
                step = 1),
    leafletOutput("my_leaf")
)

server <- function(input, output, session){
    set.seed(123456)
    df <- data.frame(latitude = sample(seq(-38.5, -37.5, by = 0.01), 100),
                     longitude = sample(seq(144.0, 145.0, by = 0.01), 100),
                     value = seq(1,100))
        
    ## create static element
    output$my_leaf <- renderLeaflet({
        
        leaflet() %>%
            addProviderTiles('Hydda.Full') %>%
            setView(lat = -37.8, lng = 144.8, zoom = 8)
        
    })
    
    ## filter data
    df_filtered <- reactive({
        df[df$value >= input$slider, ]
    })
    
    ## respond to the filtered data
    observe({

        leafletProxy(mapId = "my_leaf", data = df_filtered()) %>%
            clearMarkers() %>%   ## clear previous markers
            addMarkers()
    })
    
}

shinyApp(ui, server)