L’écosystème spatial de R

Rencontres R - Avignon

Timothée Giraud

RIATE - CNRS

23 juin 2023

Quelques repères historiques

Rappel (?) sur les données spatiales

Raster

C’est une image localisée dans l’espace.

L’information géographique est alors stockée dans des pixels.

Chaque pixel, défini par une résolution, possède des valeurs qui peuvent être traitées et cartographiées.

Rappel (?) sur les données spatiales

Vecteur

Il s’agit d’objets géométriques de type points, lignes ou polygones.

Ces objets vectoriels ne pixellisent pas.

Chaque objet est défini par un identifiant unique.

Vecteur et raster

Lambert et Zanin (2016)

Le socle de l’écosystème

Des bibliothèques géographiques largement utilisées :

Pebesma et Bivand (2023, chap. 1.7)

Il s’agit de dépendances externes

  • Installation
  • Reproductibilité

Envisager la conteneurisation (Nüst et Pebesma, 2021).

rgdal, rgeos, maptools

Upcoming changes to popular R packages for spatial data: what you need to do

rgdal, rgeos, maptools

Pour accompagner le processus d’archivage des packages :

  • Une série de posts de blog (avril 2022, décembre 2022, avril 2023, mai 2023)
  • Plusieurs talks dans des conférences
  • Communications directes aux auteurs de packages dépendants (emails, issues)
  • Message au démarrage des packages :

library(rgeos)
Loading required package: sp
The legacy packages maptools, rgdal, and rgeos, underpinning the sp package,
which was just loaded, will retire in October 2023.
Please refer to R-spatial evolution reports for details, especially
https://r-spatial.org/r/2023/05/15/evolution4.html.
It may be desirable to make the sf package available;
package maintainers should consider adding sf to Suggests:.
The sp package is now running under evolution status 2
     (status 2 uses the sf package in place of rgdal)
Warning in load_stuff(): rgeos: versions of GEOS runtime 3.11.1-CAPI-1.17.1
and GEOS at installation 3.9.0-CAPI-1.16.2differ
rgeos version: 0.6-3, (SVN revision 696)
 GEOS runtime version: 3.11.1-CAPI-1.17.1 
 Please note that rgeos will be retired during October 2023,
plan transition to sf or terra functions using GEOS at your earliest convenience.
See https://r-spatial.org/r/2023/05/15/evolution4.html for details.
 GEOS using OverlayNG
 Linking to sp version: 1.6-0 
 Polygon checking: TRUE

Reverse Dependencies
Type sf stars terra raster rgdal rgeos
Depends 35 3 14 64 9 8
Imports 414 27 120 280 109 69
Suggests 177 30 60 97 85 50
Source : CRAN, 22 juin 2023

Le package sf

Publié fin 2016 par Edzer Pebesma.

© Allison Horst, 2018

Principales fonctionnalités

  • import / export
  • affichage
  • géotraitements
  • support des données non projetées (sur le globe)
  • utilisation du standard simple feature
  • compatibilité avec le pipe
    (|> ou %>%)
  • compatibilité avec les opérateurs du tidyverse.

Format

Simple Features for R Vignette

Les objets sf sont des data.frame dont l’une des colonnes contient des géométries.
Format très pratique, les données et les géométries sont intrinsèquement liées dans un même objet.

Import

library(sf)
Linking to GEOS 3.11.1, GDAL 3.6.2, PROJ 9.1.1; sf_use_s2() is TRUE
mtq <- st_read(dsn = "data/mtq.gpkg", layer = "mtq")
Reading layer `mtq' from data source 
  `/home/tim/Documents/prz/RencontresR_2023/data/mtq.gpkg' using driver `GPKG'
Simple feature collection with 34 features and 7 fields
Geometry type: MULTIPOLYGON
Dimension:     XY
Bounding box:  xmin: 690574 ymin: 1592536 xmax: 735940.2 ymax: 1645660
Projected CRS: WGS 84 / UTM zone 20N


Les principaux formats de fichier sont pris en charge

Affichage

plot(mtq)

plot(st_geometry(mtq))

Centroides

mtq_c <- st_centroid(mtq)
plot(st_geometry(mtq))
plot(st_geometry(mtq_c), cex = 1.2, 
     col = "red", pch = 20, 
     add = TRUE)

Matrice de distance

mat <- st_distance(x = mtq_c, y = mtq_c)
mat[1:5, 1:5]
Units: [m]
          [,1]     [,2]      [,3]      [,4]      [,5]
[1,]     0.000 35316.29  3019.561 12247.132 17181.321
[2,] 35316.293     0.00 38303.361 25478.399 18597.357
[3,]  3019.561 38303.36     0.000 15099.121 20200.611
[4,] 12247.132 25478.40 15099.121     0.000  7149.189
[5,] 17181.321 18597.36 20200.611  7149.189     0.000

Agrégation

mtq_u <- st_union(mtq)
plot(st_geometry(mtq), col = "lightblue")
plot(st_geometry(mtq_u), lwd = 2, border = "red", add = TRUE)

Zone tampon

mtq_b <- st_buffer(x = mtq_u, dist = 5000)
plot(st_geometry(mtq_b), col = "grey", lwd = 2, border = "red")
plot(st_geometry(mtq), col = "lightblue", add = TRUE)
plot(st_geometry(mtq_u), lwd = 2, add = TRUE)

Intersection

mtq_z <- st_intersection(x = mtq, y = p)
plot(st_geometry(mtq))
plot(st_geometry(mtq_z), col = "red", 
     lwd = 2, add = TRUE)
plot(st_geometry(mtq_z), lwd = 2)

Polygones de Voronoi

mtq_c |> 
  st_union() |> 
  st_voronoi() |> 
  st_collection_extract("POLYGON") |> 
  st_intersection(mtq_u) |> 
  st_sf() |> 
  st_join(mtq_c, st_intersects) |>
  st_cast("MULTIPOLYGON") |>
  st_geometry() |>
  plot(col = "ivory4")

Le package terra

Le package terra permet de gérer des données vectorielles et surtout raster.

Il succède au package raster (Hijmans, 2023a) du même auteur.

rspatial.org

Principales fonctionnalités

  • Affichage
  • Modifications de la zone d’étude (projection, crop, mask, agrégation, fusion…)
  • Algèbre spatial (opérations locales, focales, globales, zonales)
  • Transformation et conversion (rasterisation, vectorisation)

Import des données

library(terra)
terra 1.7.37
alt_raw <- rast("data/altitude.tif") 
com <- vect("data/com46.gpkg", layer="com")
plot(alt_raw)
plot(com)

Reprojection

alt <- project(x = alt_raw, y = "EPSG:2154", method = "bilinear")
plot(alt)
plot(com, add = TRUE)

Crop

cahors <- subset(com, com$INSEE_COM == "46042") 
alt_crop <- crop(alt, cahors)
plot(alt_crop)
plot(cahors, add=TRUE)

Mask

alt_mask <- mask(alt_crop, cahors)
plot(alt_mask)
plot(cahors, add=TRUE)

Extract

stat_by_com <- extract(alt, com, fun = "min")
head(stat_by_com)
  ID altitude
1  1 131.2742
2  2 360.2112
3  3 268.4991
4  4 374.2841
5  5 100.5289
6  6 140.1108

Cartographie thématique


tmap (Tennekes, 2018)


ggplot2 + ggspatial (Dunnington, 2023)


mapsf (Giraud, 2022a)

D’autres packages : mapmisc, choropletr, oceanis…

Le package mapsf

mapsf offre la plupart des types de carte utilisés habituellement.

Successeur de cartography (Giraud et Lambert, 2017).

mf_map() est la fonction principale.

mf_map(x = objet_sf,
       var = "variable",
       type = "map type",
       ...)

Fonctionnalités principales

  • 9 types de cartes
  • Habillage (échelle, flèche nord…)
  • Export (png et svg)
  • Thèmes
  • Insets
  • Labels

Utilisation simple

library(mapsf)
# Import the sample dataset
mtq <- mf_get_mtq()
# Plot the base map
mf_map(x = mtq)

Utilisation simple

library(mapsf)
# Import the sample dataset
mtq <- mf_get_mtq()
# Plot the base map
mf_map(x = mtq)
# Plot proportional symbols
mf_map(
  x = mtq,
  var = "POP",
  type = "prop", 
  leg_title = "Population"
)

Utilisation simple

library(mapsf)
# Import the sample dataset
mtq <- mf_get_mtq()
# Plot the base map
mf_map(x = mtq)
# Plot proportional symbols
mf_map(
  x = mtq,
  var = "POP",
  type = "prop", 
  leg_title = "Population"
)
# Plot a map layout
mf_layout(
  title = "Population in Martinique", 
  credits = 
    paste0("T. Giraud;",  
           "Sources: INSEE & IGN, 2018"
    )
)

Utilisation avancée

# Export a map with a theme and extra margins
mf_theme("agolalight", bg = "ivory1")
mf_export(
  x = mtq, filename = "img/mtq.png",
  width = 600, res = 120,
  expandBB = c(0, 0, 0, .3)
)
# Plot a shadow
mf_shadow(mtq, col = "grey90", add = TRUE)
# Plot a choropleth map
mf_map(
  x = mtq, var = "MED", type = "choro",
  pal = "Dark Mint",
  breaks = "quantile",
  nbreaks = 6,
  leg_title = "Median Income\n(euros)",
  leg_val_rnd = -2,
  add = TRUE
)
# Start an inset map
mf_inset_on(x = "worldmap", pos = "right")
# Plot mtq position on a worldmap
mf_worldmap(mtq, col = "#0E3F5C")
# Close the inset
mf_inset_off()
# Plot a title
mf_title("Wealth in Martinique, 2015")
# Plot credits
mf_credits("T. Giraud\nSources: INSEE & IGN, 2018")
# Plot a scale bar
mf_scale(size = 5)
# Plot a north arrow
mf_arrow("topleft")
dev.off()

Cartographie interactive


leaflet (Cheng et al., 2023), repose sur la bibliothèque JS leaflet


mapview (Appelhans et al., 2022), repose sur le package leaflet


mapdeck (Cooley, 2020), repose sur les bibliothèques JS Mapbox GL et Deck.gl

tmap dispose d’un mode interactif (qui s’appuie sur le package leaflet aussi).

Cartographie interactive

library(mapview)
mapview(mtq)

Cartographie interactive avec shiny

rcarto.shinyapps.io/cityguess

Fond de carte

Le package maptiles (Giraud, 2023b) permet de télécharger des fonds de carte (raster).

library(maptiles)
library(terra)
library(mapsf)
bbox <- terra::ext(c(xmin = 4.795, xmax = 4.825,
                     ymin = 43.94, ymax = 43.955))
tiles <- get_tiles(x = bbox, 
                   project = FALSE, 
                   crop = TRUE, 
                   zoom = 15, 
                   cachedir = "cache")
mf_raster(tiles)
mf_credits(get_credit("OpenStreetMap"), bg = "white")

Alternatives

  • ceramic
  • ggmap (pour ggplot2)
  • ggspatial (pour ggplot2, utilise rosm)
  • mapboxapi (mapbox)
  • mapsapi (google, utilise RgoogleMaps)
  • OpenStreetMap (nécessite Java)
  • RgoogleMaps (google)
  • rosm
  • …

Palettes de couleurs

De nombreuses palettes sont directement disponibles dans R-base et près de 70 (!) packages proposent des palettes.

hcl.colors()

cols4all::c4a_gui()

Analyse spatiale / statistique spatiale

  • spatstat : Analyse statistique de semis de points
  • gstat : Variogram et Krigeage
  • rgeoda : Geoda avec R
  • GWmodel, spgwr : Geographically Weighted Models

CRAN Task View: Analysis of Spatial Data

  • Spatial sampling
  • Point pattern analysis
  • Geostatistics
  • Disease mapping and areal data analysis
  • Spatial regression
  • Ecological analysis

Session Geospatial à 11h!

La session Workflow a l’air cool aussi !

Télécharger des données spatiales

Maillages administratifs :
rnaturalearth pour les pays du monde
giscoR pour les régions européennes
tigris, mapSpain, geobr…

Données climatiques :
geodata (+ plein d’autres choses)

Altitudes :
elevatr

Occurences d’especes :
spocc

Données eco / socio / démographique :
wbstats (World Bank)
eurostat
rdhs (santé)
…

Données satellitaires :
sen2r (Sentinel-2)
MODIStsp (MODIS)
rgee (Google Earth Engine)
nasapower (météo, climato)

Accessibilité des restaurants et des hotels dans le centre d’Avignon

Acquisition des données

Le package osmdata (Padgham et al., 2017) utilise l’API du service Overpass turbo pour extraire des données de la BD OpenStreetMap.
Nous utilisons le système de clef/valeur d’OSM pour construire la requête.

library(mapsf)
library(osmdata)
Data (c) OpenStreetMap contributors, ODbL 1.0. https://www.openstreetmap.org/copyright
(bbox_avignon <- getbb("Avignon, Quartier Centre"))
        min       max
x  4.798405  4.818405
y 43.938975 43.958975
resto <-  bbox_avignon |> 
  opq(osm_types = "node")|>
  add_osm_feature(key = 'amenity', value = "restaurant") |>
  osmdata_sf() |>
  _$osm_points |>
  mf_map()

OpenStreetMap

Une base de données cartographique libre et contributive.

Conditions d’utilisation

OpenStreetMap est en données libres : vous êtes libre de l’utiliser dans n’importe quel but tant que vous créditez OpenStreetMap et ses contributeurs. Si vous modifiez ou vous appuyez sur les données d’une façon quelconque, vous pouvez distribuer le résultat seulement sous la même licence. (…)

Contributions

(…) Nos contributeurs incluent des cartographes enthousiastes, des professionnels du SIG, des ingénieurs qui font fonctionner les serveurs d’OSM, des humanitaires cartographiant les zones dévastées par une catastrophe et beaucoup d’autres. (…)

Couverture/complétude

  • Données France : 4,1 GB
  • Données Chine : 0,99 GB
  • Données Afrique : 5,8 GB

Densité des restaurants

Pour modéliser les variations de densités de restaurants dans le centre ville d’Avignon nous pouvons utiliser la méthode de lissage par noyaux (KDE) grâce au package spatstat (Baddeley et al., 2015).

library(sf)
library(spatstat)
resto <- st_transform(resto, "EPSG:3857")
p <- as.ppp(X = st_coordinates(resto), 
            W = as.owin(st_bbox(resto)))
ds <- density.ppp(x = p, sigma = 50, eps = 10, positive = TRUE)
plot(ds)

Densité des restaurants

On peut améliorer la représentation des résultats en les superposant à un fond de carte raster.

Transformation de l’image des densités en SpatRaster 
library(terra)
# densité en restaurants / hectares
r <- rast(ds) * 100 * 100
crs(r) <- st_crs(resto)$wkt
Téléchargement des tuiles et superposition 
library(maptiles)
library(mapsf)
tiles_osm <- get_tiles(r, 
                       provider = "CartoDB.Positron",
                       zoom = 15, 
                       crop = TRUE, 
                       cachedir = "cache")
mf_theme(mar = c(0,0,0,0), inner = TRUE)
mf_export(tiles_osm, filename = "img/avignon_dens1.png", 
          width = ncol(tiles_osm), height = nrow(tiles_osm))
mf_raster(tiles_osm, add = TRUE)
mf_raster(r, alpha = 0.6, add = TRUE)
mf_map(resto, add = TRUE)
dev.off()

Densité des restaurants

Nous pouvons aussi transformer le raster des densités en polygones de plages de densités grâce au package mapiso (Giraud, 2023a).

Transformation du raster en polygones 
library(mapiso)
# Limites des classes
maxval <- max(values(r))
bks <-  c(seq(0, floor(maxval), 1), maxval)
# Transformation du raster en polygones
iso_dens <- mapiso(r, breaks = bks)
# Suppression de la première classe ([0, 1[)
iso_dens <- iso_dens[-1, ]
# Affichage
mf_export(r, "img/iso_dens.png", width = ncol(r)*2)
mf_raster(r, add = TRUE)
mf_map(iso_dens, col = NA, add = TRUE)
dev.off()

Densité des restaurants

La dernière étape consiste à superposer ces polygones au fond de carte.

Cartographie 
mf_export(tiles_osm, filename = "img/avignon_dens2.png", 
          width = 600, 
          expandBB = c(0,0,0,.5))
mf_raster(tiles_osm, add = TRUE)
mf_map(iso_dens, var = "isomin", type = "choro",
       breaks = bks[-1], border = "white",
       pal = "Teal", alpha = .9,
       leg_pos = "right",
       leg_val_rnd = 1,
       leg_title = paste0("Densité de restaurants dans\n",
                          "un voisinage gaussien (σ = 50m),\n",
                          "en restaurants par hectare"),
       add = TRUE)
mf_map(resto, cex = .5, add = TRUE)
mf_credits("T. Giraud, 2023\nOpenStreetMap contributors, 2023", 
           pos = "bottomright", bg = "white")
mf_scale(pos = "bottomleft", size = 250, unit = "m")
mf_arrow(pos = "topright")
mf_title("Densité des restaurants dans le centre-ville d'Avignon")
dev.off()

Acquisition de données pour un fond de carte vectoriel

Nous pouvons aussi utiliser un fond de carte vectoriel.
Ici nous allons préparer un fond de carte constitué :

  • des espaces verts
  • des surfaces en eaux
  • des routes et rails
  • des bâtiments
  • des hotels et des restaurants
Acquisition des données OSM 
library(sf)
library(osmdata)
center <- data.frame(x=3903683, y=2329735) |>
  st_as_sf(coords = c("x","y"), crs = "EPSG:3035") |>
  st_buffer(dist = 1000)

bb <- st_transform(center,"EPSG:4326") |>
  st_bbox()

water <- opq(bbox = bb)|>
  add_osm_feature(key = 'natural', value = "water") |>
  osmdata_sf() |>
  unique_osmdata()

river <- c(st_geometry(water$osm_polygons),
           st_geometry(water$osm_multipolygons)) |>
  st_cast('MULTIPOLYGON') |>
  st_make_valid() |>
  st_transform(st_crs(center))|>
  st_intersection(center) |>
  st_union()

green <- opq(bbox = bb)|>
  add_osm_features(features = list(
    "leisure" = c("park", "garden"),
    "landuse" = c("cemetery", "grass", "forest"))
  ) |>
  osmdata_sf() |>
  unique_osmdata()

esp_vert <- st_geometry(green$osm_polygons) |>
  st_cast('MULTIPOLYGON') |>
  st_make_valid() |>
  st_transform(st_crs(center))|>
  st_intersection(center) |>
  st_union()

highway <- opq(bbox = bb)|>
  add_osm_feature(key = 'highway') |>
  osmdata_sf() |>
  unique_osmdata()

routes <- st_geometry(highway$osm_lines) |>
  st_cast('LINESTRING') |>
  st_make_valid() |>
  st_transform(st_crs(center))|>
  st_intersection(center) |>
  st_union() |>
  st_buffer(5) |>
  st_buffer(-3)

railway <- opq(bbox = bb)|>
  add_osm_feature(key = 'railway') |>
  osmdata_sf() |>
  unique_osmdata()

rail <- st_geometry(railway$osm_lines) |>
  st_cast('LINESTRING') |>
  st_make_valid() |>
  st_transform(st_crs(center))|>
  st_intersection(center) |>
  st_union()

building <- opq(bbox = bb)|>
  add_osm_feature(key = 'building') |>
  osmdata_sf() |>
  unique_osmdata()

batiments <- c(st_geometry(building$osm_polygons),
               st_geometry(building$osm_multipolygons)) |>
  st_cast('MULTIPOLYGON') |>
  st_make_valid() |>
  st_transform(st_crs(center))|>
  st_intersection(center) |>
  st_union()


restaurants <- opq(bbox = bb)|>
  add_osm_feature(key = 'amenity', value = "restaurant") |>
  osmdata_sf() |>
  unique_osmdata()
restaurants_points <- st_geometry(restaurants$osm_points) |>
  st_transform(st_crs(center))|>
  st_intersection(center)
restaurants_poly <- st_geometry(restaurants$osm_polygons) |>
  st_centroid() |>
  st_transform(st_crs(center))|>
  st_intersection(center)
resto <- c(restaurants_points, restaurants_poly)


tourism <- opq(bbox = bb)|>
  add_osm_feature(key = 'tourism', value = "hotel") |>
  osmdata_sf() |>
  unique_osmdata()

hotel_points <- tourism$osm_points[, "name"] |>
  st_set_agr("constant") |>
  st_transform(st_crs(center))|>
  st_intersection(center)
hotel_poly <- rbind(tourism$osm_polygons[, "name"],
                    tourism$osm_multipolygons[, "name"]) |>
  st_set_agr("constant") |>
  st_centroid() |>
  st_transform(st_crs(center))|>
  st_intersection(center)
hotel <- rbind(hotel_points, hotel_poly)


st_write(obj = hotel, dsn = "data/avignon.gpkg", layer = "hotel")
st_write(obj = resto, dsn = "data/avignon.gpkg", layer = "resto")
st_write(obj = batiments, dsn = "data/avignon.gpkg", layer = "batiments")
st_write(obj = rail, dsn = "data/avignon.gpkg", layer = "rail")
st_write(obj = routes, dsn = "data/avignon.gpkg", layer = "routes")
st_write(obj = esp_vert, dsn = "data/avignon.gpkg", layer = "esp_vert")
st_write(obj = river, dsn = "data/avignon.gpkg", layer = "river")
st_write(obj = center, dsn = "data/avignon.gpkg", layer = "center")

Il suffit maintenant de combiner toutes ces couches pour constituer un fond de carte.

Cartographie 
library(mapsf)
mf_theme("candy", bg ="#f7f7f7")
mf_export(center, "img/avignon.png", width = 768, res = 110)
mf_map(center, col = "#f2efe9", border = NA, add = TRUE)
mf_map(river, col = "#aad3df", border = "#aad3df", lwd = .5, add = TRUE)
mf_map(esp_vert, col = "#c8facc", border = "#c8facc", lwd = .5, add = TRUE)
mf_map(rail, col = "grey50", lty = 2, lwd = .2, add = TRUE)
mf_map(routes, col = "white", border = "white", add = TRUE)
mf_map(batiments, col = "#d9d0c9", border = "#c6bab1", lwd = 1, add = TRUE)
mf_map(hotel, col = "white", bg = "#000094", 
       pch = 21, lwd = 1, cex = 1, add = TRUE)
mf_map(resto, col = "white", bg = "#940010", 
       pch = 23, lwd = 1, cex = 1, add = TRUE)
mf_map(center, col = NA, border = "grey25", lwd = 4, add = TRUE)
mf_title("Avignon")
mf_credits("T. Giraud, 2023\nOpenStreetMap contributors, 2023")
mf_scale(100, unit = "m")
mf_arrow(pos = "topright")
mf_legend(type = "symb", pos = "bottomright2", 
          val = c("Hotels", "Restaurants"),
          pal = c("#000094", "#940010"), 
          pt_cex = c(1, 1), pt_pch = c(21, 23),
          border = "white", title = "", val_cex = 1)
dev.off()

De l’hotel à la conf…

Nous voulons connaître tous les chemins empruntés par les conférenciers pour se rendre au Rencontres R 2023!

Le package tidygeocoder (Cambon et al., 2021) permet d’utiliser un grand nombre de services de géocodage en ligne.

library(tidygeocoder)
(conf <- geo("74 rue Louis Pasteur, 84000 Avignon, FRANCE"))
Passing 1 address to the Nominatim single address geocoder
Query completed in: 1 seconds
# A tibble: 1 × 3
  address                                       lat  long
  <chr>                                       <dbl> <dbl>
1 74 rue Louis Pasteur, 84000 Avignon, FRANCE  43.9  4.82
Positionnons la conf sur la carte 
library(sf)
geoconf <- st_as_sf(conf, coords = c("long", "lat"), crs = "EPSG:4326") |>
  st_transform(st_crs(center))
mf_export(center, "img/avignon_conf.png", width = 768, res = 110)
mf_map(center, col = "#f2efe9", border = NA, add = TRUE)
mf_map(river, col = "#aad3df", border = "#aad3df", lwd = .5, add = TRUE)
mf_map(esp_vert, col = "#c8facc", border = "#c8facc", lwd = .5, add = TRUE)
mf_map(rail, col = "grey50", lty = 2, lwd = .2, add = TRUE)
mf_map(routes, col = "white", border = "white", add = TRUE)
mf_map(batiments, col = "#d9d0c9", border = "#c6bab1", lwd = 1, add = TRUE)
mf_map(geoconf, col = "white", bg = "#646400", pch = 22, lwd = 1, cex = 4, add = TRUE)
mf_map(hotel, col = "white", bg = "#000094", pch = 21, lwd = 1, cex = 1, add = TRUE)
mf_map(center, col = NA, border = "grey25", lwd = 4, add = TRUE)
mf_title("Rencontres R 2023")
mf_credits("T. Giraud, 2023\nOpenStreetMap contributors, 2023")
mf_scale(250, unit = "m")
mf_arrow(pos = "topright")
dev.off()

De l’hotel à la conf…

Le package osrm (Giraud, 2022b) permet de calculer des trajets par le plus court chemin en s’appuyant sur les données d’OSM.

Calcul des routes 
library(osrm)
n <- nrow(hotel)
routes_hotel <- vector("list", n)
for (i in 1:n) {
  routes_hotel[[i]] <- osrmRoute(src = hotel[i, ],
                                 dst = geoconf,
                                 overview = "full",
                                 osrm.profile = 'foot')
  Sys.sleep(1)
}
routes_hotel <- do.call(rbind, routes_hotel)
Cartographie des routes 
mf_export(center, "img/avignon_routes.png", width = 768, res = 110)
mf_map(center, col = "#f2efe9", border = NA, add = TRUE)
mf_map(river, col = "#aad3df", border = "#aad3df", lwd = .5, add = TRUE)
mf_map(esp_vert, col = "#c8facc", border = "#c8facc", lwd = .5, add = TRUE)
mf_map(rail, col = "grey50", lty = 2, lwd = .2, add = TRUE)
mf_map(routes, col = "white", border = "white", add = TRUE)
mf_map(batiments, col = "#d9d0c9", border = "#c6bab1", lwd = 1, add = TRUE)
mf_map(routes_hotel, col = "#940000", lwd = 2, add = TRUE)
mf_map(hotel, col = "white", bg = "#000094", pch = 21, lwd = 1, cex = 1, add = TRUE)
mf_map(geoconf, col = "white", bg = "#646400", pch = 22, lwd = 1, cex = 3, add = TRUE)
mf_map(center, col = NA, border = "grey25", lwd = 4, add = TRUE)
mf_title("Toutes les routes mènent aux Rencontres R")
mf_credits("T. Giraud, 2023\nOpenStreetMap contributors, 2023")
mf_scale(100, unit = "m")
mf_arrow(pos = "topright")
dev.off()

De l’hotel à la conf…

Il est possible d’agréger les tronçons empruntés par plusieurs routes grâce au package stplanr (Lovelace et Ellison, 2018).

library(stplanr)
routes_hotel$w <- 1
routes_hotel_ag <- overline2(routes_hotel, "w")

Nous pouvons ensuite cartographier ces tronçons agrégés par classes de taille.

Cartographie 
mf_export(center, "img/avignon_routes_ag.png", width = 768, res = 110)
mf_map(center, col = "#f2efe9", border = NA, add = TRUE)
mf_map(river, col = "#aad3df", border = "#aad3df", lwd = .5, add = TRUE)
mf_map(esp_vert, col = "#c8facc", border = "#c8facc", lwd = .5, add = TRUE)
mf_map(rail, col = "grey50", lty = 2, lwd = .2, add = TRUE)
mf_map(routes, col = "white", border = "white", add = TRUE)
mf_map(batiments, col = "#d9d0c9", border = "#c6bab1", lwd = 1, add = TRUE)
mf_map(routes_hotel_ag, var = "w", type = "grad",
       breaks = c(1,5,10,20,30,33),
       lwd = c(2,5,9,13,19), 
       leg_pos = "topleft", col= "#940000",
       leg_title = 'Nombre de trajets\nempruntant la voie', 
       add = TRUE)
mf_map(hotel, col = "white", bg = "#000094", pch = 21, lwd = 1, cex = 1, add = TRUE)
mf_map(geoconf, col = "white", bg = "#646400", pch = 22, lwd = 1, cex = 3, add = TRUE)
mf_map(center, col = NA, border = "grey25", lwd = 4, add = TRUE)
mf_title("Toutes les routes mènent aux Rencontres R")
mf_credits("T. Giraud, 2023\nOpenStreetMap contributors, 2023")
mf_scale(100, unit = "m")
mf_arrow(pos = "topright")
dev.off()

Ressources

Geocomputation with R

Lovelace et al. (2019)

r.geocompx.org

Première partie en français

Spatial Data Science with applications in R

Pebesma et Bivand (2023)

r-spatial.org/book

Spatial Data Science with R and “terra”

Robert J. Hijmans (2023)

rspatial.org

Cartographie et Géomatique avec R

Giraud et Pecout (2023a)

rcarto.github.io/cartographie_avec_r

Giraud et Pecout (2023b)

rcarto.github.io/geomatique_avec_r

Rzine

Rzine vise à Encourager la production et favoriser la diffusion de documentation sur la pratique de R en SHS.

  • Référencement de documents et supports divers.
  • La collection Rzine : publications open source, open peer review.

ElementR

ElementR est un groupe d’autoformation qui fédère trois unités de recherche en géographie : l’UMR Géographie-Cités, l’UMR PRODIG et l’UAR RIATE.
Ses activités sont accessibles à l’ensemble des membres du Campus Condorcet.

Ressources

Merci de votre attention

rcarto.github.io/RencontresR_2023

@rcarto@fosstodon.org

rcarto.github.io

@rcarto


Bibliographie

Appelhans, T., Detsch, F., Reudenbach, C. et Woellauer, S. (2022). mapview: Interactive Viewing of Spatial Data in R. https://CRAN.R-project.org/package=mapview
Baddeley, A., Rubak, E. et Turner, R. (2015). Spatial Point Patterns: Methodology and Applications with R. Chapman; Hall/CRC Press. https://www.routledge.com/Spatial-Point-Patterns-Methodology-and-Applications-with-R/Baddeley-Rubak-Turner/p/book/9781482210200/
Bivand, R. (2021). Progress in the R ecosystem for representing and handling spatial data. Journal of Geographical Systems, 23(4), 515‑546. https://doi.org/10.1007/s10109-020-00336-0
Bivand, R., Keitt, T. et Rowlingson, B. (2023). rgdal: Bindings for the ’Geospatial’ Data Abstraction Library. https://CRAN.R-project.org/package=rgdal
Bivand, R. et Rundel, C. (2023). rgeos: Interface to Geometry Engine - Open Source (’GEOS’). https://CRAN.R-project.org/package=rgeos
Cambon, J., Hernangómez, D., Belanger, C. et Possenriede, D. (2021). tidygeocoder: An R package for geocoding. Journal of Open Source Software, 6(65), 3544. https://doi.org/10.21105/joss.03544
Cheng, J., Karambelkar, B. et Xie, Y. (2023). leaflet: Create Interactive Web Maps with the JavaScript ’Leaflet’ Library. https://CRAN.R-project.org/package=leaflet
Cooley, D. (2020). mapdeck: Interactive Maps Using ’Mapbox GL JS’ and ’Deck.gl’. https://CRAN.R-project.org/package=mapdeck
Dunnington, D. (2023). ggspatial: Spatial Data Framework for ggplot2. https://CRAN.R-project.org/package=ggspatial
GDAL/OGR contributors. (2022). GDAL/OGR Geospatial Data Abstraction software Library. Open Source Geospatial Foundation. https://doi.org/10.5281/zenodo.5884351
GEOS contributors. (2021). GEOS coordinate transformation software library. Open Source Geospatial Foundation. https://libgeos.org/
Giraud, T. (2022a). mapsf: Thematic Cartography. https://CRAN.R-project.org/package=mapsf
Giraud, T. (2022b). osrm: Interface Between R and the OpenStreetMap-Based Routing Service OSRM. Journal of Open Source Software, 7(78), 4574. https://doi.org/10.21105/joss.04574
Giraud, T. (2023a). mapiso: Create Contour Polygons from Regular Grids. https://CRAN.R-project.org/package=mapiso
Giraud, T. (2023b). maptiles: Download and Display Map Tiles. https://CRAN.R-project.org/package=maptiles
Giraud, T. et Lambert, N. (2017). Reproducible Cartography. M. Peterson (dir.), Cham, Switzerland (p. 173‑183). https://doi.org/10.1007/978-3-319-57336-6_13
Giraud, T. et Pecout, H. (2023a). Cartographie avec R. https://doi.org/10.5281/zenodo.7528161
Giraud, T. et Pecout, H. (2023b). Géomatique avec R. https://doi.org/10.5281/zenodo.7528145
Hijmans, R. J. (2023a). raster: Geographic Data Analysis and Modeling. https://CRAN.R-project.org/package=raster
Hijmans, R. J. (2023b). terra: Spatial Data Analysis. https://CRAN.R-project.org/package=terra
Hvitfeldt, E. (2021). paletteer: Comprehensive Collection of Color Palettes. https://github.com/EmilHvitfeldt/paletteer
Lambert, N. et Zanin, C. (2016). Manuel de cartographie: principes, méthodes, applications. Armand Colin.
Lovelace, R. et Ellison, R. (2018). stplanr: A Package for Transport Planning. The R Journal, 10(2). https://doi.org/10.32614/RJ-2018-053
Lovelace, R., Nowosad, J. et Muenchow, J. (2019). Geocomputation with R. CRC Press. https://r.geocompx.org/
Nüst, D. et Pebesma, E. (2021). Practical Reproducibility in Geography and Geosciences. Annals of the American Association of Geographers, 111(5), 1300‑1310. https://doi.org/10.1080/24694452.2020.1806028
Padgham, M., Rudis, B., Lovelace, R. et Salmon, M. (2017). osmdata. Journal of Open Source Software, 2(14), 305. https://doi.org/10.21105/joss.00305
Pebesma, E. (2018). Simple Features for R: Standardized Support for Spatial Vector Data. The R Journal, 10(1), 439‑446. https://doi.org/10.32614/RJ-2018-009
Pebesma, E. et Bivand, R. (2023). Spatial Data Science: With applications in R (p. 352). Chapman and Hall/CRC. https://r-spatial.org/book/
PROJ contributors. (2021). PROJ coordinate transformation software library. Open Source Geospatial Foundation. https://proj.org/
Tennekes, M. (2018). tmap: Thematic Maps in R. Journal of Statistical Software, 84(6), 1‑39. https://doi.org/10.18637/jss.v084.i06
Tennekes, M. (2023). cols4all: Colors for all. https://CRAN.R-project.org/package=cols4all