8  Raster : Indices Topographiques

Author

Dr. Elisabetta Pietrostefani

Published

March 24, 2026

8.1 Introduction

Dans le chapitre Données Raster, nous avons vu ce qu’est un raster, les grands types de données (MNT, images multispectrales, nightlights), le compromis résolution spatiale/temporelle, et les principales sources d’imagerie. Ce chapitre part de là pour se concentrer entièrement sur les Modèles Numériques de Terrain : comment les obtenir, les charger, et en extraire des indices topographiques utiles.

Les cinq opérations couvertes sur un MNT du Liban :

Opération Fonction
Charger et explorer rast()
Recadrer et masquer crop() + mask()
Calculer la pente terrain()
Reclassifier classify()
Extraire vers des données vecteur terra::extract()

À la fin, vous reproduirez ces étapes sur la Corse en exercice indépendant.

8.2 Obtenir des données d’altitude

Trois grandes familles de sources couvrent les besoins selon l’étendue géographique et la résolution souhaitée : les données globales de la NASA (SRTM, ASTER GDEM, NASADEM), les données françaises de haute précision de l’IGN (RGE ALTI®), et les tuiles accessibles directement depuis R via le package elevatr.

8.2.1 Comparaison des principales sources

Source Résolution Couverture Accès Usage typique
SRTM (NASA) ~30 m (1 arc-sec) Mondial (60°N–56°S) Libre Analyse topographique générale
ASTER GDEM v3 ~30 m Mondial (83°N–83°S) Libre Zones hors couverture SRTM
NASADEM ~30 m Mondial (60°N–56°S) Libre SRTM retraité, moins de vides
RGE ALTI® IGN 1 m France entière Libre Analyses fines, zones inondables
NextGIS / SRTM France ~30 m France Libre Téléchargement rapide, prêt à l’emploi
AWS Terrain Tiles Variable (zoom 1–14) Mondial Via elevatr Import direct dans R sans compte

8.2.2 Option 1 — NASA Earthdata : SRTM, ASTER GDEM, NASADEM

La NASA distribue plusieurs MNT mondiaux librement accessibles après création d’un compte gratuit sur Earthdata.

Les trois produits NASA à connaître

SRTM (Shuttle Radar Topography Mission, 2000) — collecté en 11 jours par la navette spatiale Endeavour, il couvre 80 % de la surface terrestre à ~30 m de résolution. C’est la référence mondiale pour la plupart des analyses topographiques.

ASTER GDEM v3 — produit à partir de plus d’un million d’images stéréoscopiques du satellite Terra (NASA/METI), il couvre 99 % de la surface terrestre jusqu’à 83° de latitude. Résolution nominale de 30 m, mais précision réelle légèrement inférieure au SRTM dans les zones nuageuses.

NASADEM — retraitement amélioré du SRTM intégrant des données ASTER GDEM, ICESat et ALOS pour combler les vides et améliorer la précision verticale. À privilégier par rapport au SRTM brut pour les nouvelles analyses.

Les données sont distribuées en tuiles de 1° × 1° au format GeoTIFF. Une fois téléchargées, on les charge et assemble directement avec terra :

Code 
library(terra)
library(tidyterra)
library(ggplot2)

# Après téléchargement manuel depuis https://earthdata.nasa.gov
# Les fichiers SRTM ont la convention de nommage : N48E002.SRTMGL1.hgt.zip
# Les fichiers NASADEM : NASADEM_HGT_n48e002.zip

# Charger une tuile SRTM décompressée
srtm_tuile <- rast("data/DEM/N48E002.hgt")

cat("Résolution :", res(srtm_tuile), "degrés (~30 m)\n")
cat("Étendue    :", as.character(ext(srtm_tuile)), "\n")

# Assembler plusieurs tuiles avec mosaic()
# (nécessaire si la zone d'intérêt couvre plusieurs tuiles)
t1 <- rast("data/DEM/N48E001.hgt")
t2 <- rast("data/DEM/N48E002.hgt")
t3 <- rast("data/DEM/N49E001.hgt")
t4 <- rast("data/DEM/N49E002.hgt")

dem_mosaic <- mosaic(t1, t2, t3, t4, fun = "mean")

ggplot() +
  geom_spatraster(data = dem_mosaic) +
  scale_fill_gradientn(colors   = hcl.colors(50, "Terrain"),
                        name     = "Altitude (m)",
                        na.value = "transparent") +
  labs(title   = "MNT SRTM assemblé",
       caption = "Source : NASA SRTM | Earthdata") +
  theme_void(base_size = 12) +
  theme(plot.title = element_text(face = "bold", hjust = 0.5))

8.2.3 Option 2 — RGE ALTI® : le MNT 1 m de l’IGN pour la France

Pour les analyses sur la France, le RGE ALTI® de l’IGN est la source de référence. Il décrit l’altitude de la surface du sol à 1 mètre de résolution sur l’ensemble du territoire métropolitain et des DOM-TOM, avec une précision verticale de 20 cm dans les zones inondables et littorales.

Comment télécharger le RGE ALTI®
  1. Rendez-vous sur geoservices.ign.fr/rgealti
  2. Créez un compte gratuit sur le Géoportail de l’IGN
  3. Sélectionnez le département ou la région souhaités
  4. Choisissez le format GeoTIFF et la résolution 1 m ou 5 m
  5. Les fichiers sont distribués par dalles (tuiles) — utilisez mosaic() pour les assembler

Le RGE ALTI® à 1 m est aussi accessible via l’API flux WCS de l’IGN pour une extraction directe par emprise.

Code 
# Après téléchargement depuis geoservices.ign.fr/rgealti
# Structure typique des fichiers IGN :
#   RGEALTI_2-0_1M_ASC_LAMB93-IGN69_D075_2021-01-01/
#     RGEALTI_FXX_0630_6860_MNT_LAMB93_IGN69.asc   ← tuiles ASCII Grid
#   ou format GeoTIFF selon la version téléchargée

# Charger une tuile GeoTIFF
ign_tuile <- rast("data/IGN/RGEALTI_FXX_0630_6860_MNT_LAMB93_IGN69.tif")

cat("SCR        :", crs(ign_tuile, describe = TRUE)$name, "\n")  # Lambert-93
cat("Résolution :", res(ign_tuile), "mètres\n")                   # 1 m × 1 m
cat("Min / Max  :", global(ign_tuile, "range", na.rm = TRUE)[[1]], "m\n")

# Le RGE ALTI® est déjà en Lambert-93 (EPSG:2154) — aucune reprojection nécessaire
# pour les analyses sur la France

# Si les fichiers sont au format ASCII Grid (.asc), terra les lit de la même façon
ign_asc <- rast("data/IGN/RGEALTI_FXX_0630_6860_MNT_LAMB93_IGN69.asc")

# Assembler plusieurs dalles
dalles <- list.files("data/IGN/", pattern = "\\.tif$", full.names = TRUE)
dem_ign <- do.call(mosaic, c(lapply(dalles, rast), list(fun = "mean")))

ggplot() +
  geom_spatraster(data = dem_ign) +
  scale_fill_gradientn(colors   = hcl.colors(50, "Terrain"),
                        name     = "Altitude (m)",
                        na.value = "transparent") +
  labs(title   = "RGE ALTI® IGN — résolution 1 m",
       caption = "Source : IGN — RGE ALTI® | geoservices.ign.fr") +
  theme_void(base_size = 12) +
  theme(plot.title = element_text(face = "bold", hjust = 0.5))

8.2.4 Option 3 — NextGIS : SRTM France prêt à l’emploi

NextGIS propose des MNT SRTM préconfigurés par pays, directement téléchargeables au format GeoTIFF sans création de compte. C’est l’option la plus rapide pour obtenir un MNT de la France entière à ~30 m de résolution.

Code 
# Après téléchargement depuis https://data.nextgis.com/en/region/FR/dem/
# Le fichier est un GeoTIFF unique couvrant toute la France

dem_france <- rast("data/nextgis/dem.tif")

cat("SCR        :", crs(dem_france, describe = TRUE)$name, "\n")
cat("Résolution :", res(dem_france), "\n")
cat("Min / Max  :", global(dem_france, "min", na.rm = TRUE)[[1]], "/",
                    global(dem_france, "max", na.rm = TRUE)[[1]], "m\n")

# Reprojeter en Lambert-93 pour les analyses sur la France
dem_france_l93 <- project(dem_france, "EPSG:2154")

ggplot() +
  geom_spatraster(data = dem_france_l93) +
  scale_fill_gradientn(colors   = hcl.colors(50, "Terrain"),
                        name     = "Altitude (m)",
                        na.value = "transparent") +
  labs(title   = "MNT France — SRTM via NextGIS",
       caption = "Source : NextGIS / SRTM | data.nextgis.com") +
  theme_void(base_size = 12) +
  theme(plot.title = element_text(face = "bold", hjust = 0.5))

8.2.5 Option 4 — elevatr : import direct depuis R sans téléchargement manuel

Le package elevatr permet de récupérer des données d’altitude directement depuis R, sans passer par un navigateur. Il interroge les tuiles AWS Terrain (synthèse SRTM/3DEP/GMTED2010) ou l’API OpenTopography, et renvoie un objet terra prêt à l’emploi.

Code 
install.packages("elevatr")
Code 
library(elevatr)
library(sf)
library(terra)
library(tidyterra)
library(ggplot2)
library(rnaturalearth)

# elevatr accepte un objet sf comme emprise — on utilise la France métropolitaine
france <- ne_countries(country = "France", returnclass = "sf") |>
  st_transform(4326)

# get_elev_raster() télécharge les tuiles couvrant l'emprise de l'objet sf
# z = niveau de zoom (1 à 14) — z = 5 ≈ ~5 km, z = 8 ≈ ~600 m, z = 10 ≈ ~150 m
# src = "aws"  → tuiles AWS (SRTM + 3DEP + GMTED2010, pas de compte requis)
# src = "gl1"  → SRTM 1 arc-sec (~30 m) via OpenTopography (clé API requise)
# src = "alos" → ALOS World 3D (~30 m) via OpenTopography (clé API requise)

dem_fr <- get_elev_raster(locations = france, z = 6, src = "aws",
                           clip = "locations")   # découper sur le contour exact

# Convertir en SpatRaster terra et reprojeter
dem_fr_terra <- rast(dem_fr)
dem_fr_l93   <- project(dem_fr_terra, "EPSG:2154")

cat("Résolution après reprojection :", res(dem_fr_l93), "mètres\n")

ggplot() +
  geom_spatraster(data = dem_fr_l93) +
  scale_fill_gradientn(colors   = hcl.colors(50, "Terrain"),
                        name     = "Altitude (m)",
                        na.value = "transparent") +
  labs(title   = "MNT France — elevatr (AWS Terrain Tiles, z = 6)",
       caption = "Source : AWS Terrain Tiles via elevatr | Cours R-Carto") +
  theme_void(base_size = 12) +
  theme(plot.title = element_text(face = "bold", hjust = 0.5))
Choisir le bon niveau de zoom (z)
z Résolution approx. Usage
4–5 5–10 km Vue continentale, aperçu rapide
6–7 1–5 km Pays entier, analyses régionales
8–9 300–600 m Région, département
10–11 75–150 m Zone d’étude locale
12–14 10–40 m Analyse fine (fichiers volumineux)

Plus le zoom est élevé, plus les fichiers sont lourds et le téléchargement lent. Pour une première exploration, commencez par z = 6 ou z = 7.

Code 
# Avec OpenTopography (clé API gratuite requise)
# Créer un compte sur https://portal.opentopography.org/newUser
# puis récupérer votre clé dans myOpenTopo → API Key

# Enregistrer la clé une fois pour toutes dans votre .Renviron :
# usethis::edit_r_environ()
# → ajouter la ligne : OPENTOPO_KEY=votre_cle_ici

# Télécharger le SRTM 1 arc-sec (~30 m) pour une zone précise
corsica <- ne_states(country = "France", returnclass = "sf") |>
  dplyr::filter(name == "Corse-du-Sud" | name == "Haute-Corse") |>
  st_transform(4326)

dem_corse_gl1 <- get_elev_raster(locations = corsica,
                                  src  = "gl1",       # SRTM 1 arc-sec
                                  clip = "locations") # découper sur la Corse

dem_corse_terra <- rast(dem_corse_gl1) |>
  project("EPSG:2154")

ggplot() +
  geom_spatraster(data = dem_corse_terra) +
  scale_fill_gradientn(colors   = hcl.colors(50, "Terrain"),
                        name     = "Altitude (m)",
                        na.value = "transparent") +
  labs(title   = "MNT Corse — SRTM 1 arc-sec via OpenTopography",
       caption = "Source : OpenTopography / SRTM GL1 | Cours R-Carto") +
  theme_void(base_size = 12) +
  theme(plot.title = element_text(face = "bold", hjust = 0.5))
Sources disponibles via OpenTopography dans elevatr
src Produit Résolution
"gl3" SRTM 3 arc-sec ~90 m
"gl1" SRTM 1 arc-sec ~30 m
"alos" ALOS World 3D ~30 m
"srtm15plus" SRTM 15 arc-sec + bathymétrie ~450 m

L’option "alos" (satellite japonais ALOS) peut être plus précise que le SRTM dans les zones montagneuses tropicales ou très boisées.

Code 
library(terra)        # manipulation des rasters
library(tidyterra)    # geom_spatraster() pour ggplot2
library(sf)           # données vectorielles
library(ggplot2)      # visualisation
library(dplyr)        # manipulation de données
library(scales)       # rescale()
Code 
install.packages(c("terra", "tidyterra"))

terra remplace l’ancien package raster (déprécié depuis 2023). tidyterra permet d’utiliser les objets terra directement dans ggplot2 via geom_spatraster().

8.3 Étape 1 — Charger et explorer le MNT

Code 
dem <- rast("data/Liban/LBN_elevation_w_bathymetry.tif")

cat("SCR        :", crs(dem, describe = TRUE)$name, "\n")
SCR        : WGS 84
Code 
cat("Résolution :", res(dem), "degrés\n")
Résolution : 0.0025 0.0025 degrés
Code 
cat("Min / Max  :", global(dem, "min", na.rm = TRUE)[[1]], "/",
                    global(dem, "max", na.rm = TRUE)[[1]], "m\n")
Min / Max  : -2173 / 3065 m
Code 
ggplot() +
  geom_spatraster(data = dem) +
  scale_fill_gradientn(
    colors   = hcl.colors(50, "Terrain"),
    name     = "Altitude (m)",
    na.value = "transparent"
  ) +
  labs(title   = "MNT du Liban",
       caption = "Source : SRTM | Cours R-Carto") +
  theme_void(base_size = 12) +
  theme(plot.title = element_text(face = "bold", hjust = 0.5))
Figure 8.1: MNT du Liban — emprise originale

8.4 Étape 2 — Recadrer et masquer

Le MNT couvre une zone plus large que le pays. On utilise deux opérations :

  • crop() — découpe selon l’emprise rectangulaire du vecteur
  • mask() — applique le contour exact du polygone (valeurs extérieures → NA)
Code 
Lebanon <- read_sf("data/Liban/LBN_adm1.shp")

dem_proj  <- terra::project(dem, crs(Lebanon))
dem_crop  <- crop(dem_proj, Lebanon)
dem_liban <- mask(dem_crop, Lebanon)
Code 
ggplot() +
  geom_spatraster(data = dem_liban) +
  scale_fill_gradientn(
    colors   = hcl.colors(50, "Terrain"),
    name     = "Altitude (m)",
    na.value = "transparent"
  ) +
  geom_sf(data = Lebanon, fill = NA, color = "white", linewidth = 0.6) +
  labs(title   = "MNT du Liban — recadré et masqué",
       caption = "Source : SRTM / GADM | Cours R-Carto") +
  theme_void(base_size = 12) +
  theme(plot.title = element_text(face = "bold", hjust = 0.5))
Figure 8.2: MNT recadré sur le Liban avec les gouvernorats

8.5 Étape 3 — Calculer la pente

La pente mesure l’inclinaison du terrain en degrés. On utilise terrain() avec un MNT projeté en mètres pour obtenir des valeurs correctes.

Code 
dem_m <- rast("data/Liban/DEM_Leb_projected.tif")
slope <- terrain(dem_m, v = "slope", unit = "degrees")

cat("Pente moyenne :", round(global(slope, "mean", na.rm = TRUE)[[1]], 1), "°\n")
Pente moyenne : 8.1 °
Code 
cat("Pente max     :", round(global(slope, "max",  na.rm = TRUE)[[1]], 1), "°\n")
Pente max     : 62.5 °
Code 
ggplot() +
  geom_spatraster(data = slope) +
  scale_fill_viridis_c(
    option   = "magma",
    name     = "Pente (°)",
    na.value = "transparent"
  ) +
  geom_sf(data = Lebanon, fill = NA, color = "white", linewidth = 0.5) +
  labs(title   = "Pente du terrain — Liban",
       caption = "Source : SRTM | Cours R-Carto") +
  theme_void(base_size = 12) +
  theme(plot.title = element_text(face = "bold", hjust = 0.5))
Figure 8.3: Pente du terrain — Liban (degrés)

8.6 Étape 4 — Reclassifier

La reclassification transforme un raster continu en catégories selon des seuils. Ici, on identifie les zones à risque d’inondation (altitude < 10 m).

Code 
rcl <- matrix(c(
  -Inf,  10, 1,
    10, Inf, 0
), ncol = 3, byrow = TRUE)

flood_risk <- classify(dem_m, rcl)

freq_tbl <- freq(flood_risk)
pct_risk  <- round(freq_tbl$count[freq_tbl$value == 1] /
                   sum(freq_tbl$count) * 100, 1)
cat("Proportion de zones à risque (< 10 m) :", pct_risk, "%\n")
Proportion de zones à risque (< 10 m) : 1.1 %
Code 
ggplot() +
  geom_spatraster(data = as.factor(flood_risk)) +
  scale_fill_manual(
    values   = c("0" = "#d9d9d9", "1" = "#2166ac"),
    labels   = c("0" = "Hors risque (≥ 10 m)", "1" = "Zone à risque (< 10 m)"),
    name     = "",
    na.value = "transparent"
  ) +
  geom_sf(data = Lebanon, fill = NA, color = "grey40", linewidth = 0.5) +
  labs(title    = "Zones à risque d'inondation — Liban",
       subtitle = "Altitude inférieure à 10 m",
       caption  = "Source : SRTM | Cours R-Carto") +
  theme_void(base_size = 12) +
  theme(plot.title      = element_text(face = "bold", hjust = 0.5),
        plot.subtitle   = element_text(color = "grey40", hjust = 0.5),
        legend.position = "bottom")
Figure 8.4: Zones à risque d’inondation côtière — altitude < 10 m

8.7 Étape 5 — Extraction vers des données vectorielles

Les étapes précédentes produisent des rasters. Mais en pratique, on veut souvent extraire des valeurs raster à des emplacements précis — des points d’enquête, des communes, des bassins versants — pour les analyser statistiquement ou les cartographier dans un cadre vectoriel sf.

terra::extract() fait exactement cela : pour chaque géométrie vecteur (point ou polygone), il identifie les cellules raster correspondantes et renvoie leurs valeurs.

8.7.1 Extraction à des points

Code 
# Charger des données d'enquête géolocalisées
# (points représentant des ménages au Liban)
households <- read_sf("data/Lebanon/random_survey_LBN.shp")

# terra::extract() trouve pour chaque point la cellule raster
# qui le contient et renvoie sa valeur.
# Le MNT dem (chargé à l'étape 1) est utilisé directement.
households_elevation <- terra::extract(dem, vect(households))
# vect() convertit l'objet sf en SpatVector, requis par terra

head(households_elevation)
Harmoniser les SCR avant l’extraction

Si vos données vecteur et votre raster ne sont pas dans le même SCR, terra::extract() tentera une transformation automatique mais affichera un avertissement :

Warning: [extract] transforming vector data to the CRS of the raster

Ne laissez pas cette transformation se faire silencieusement — reprojetez explicitement avec st_transform() (pour sf) ou project() (pour terra) avant l’extraction. Si vous obtenez des NA à la place de valeurs, c’est presque toujours un problème de SCR.

Code 
# Vérifier les SCR
st_crs(households)$srid
crs(dem, describe = TRUE)$code

# Reprojeter les points dans le SCR du raster
households <- st_transform(households, crs(dem))

# Ou reprojeter le raster dans le SCR des points (plus coûteux)
dem_reproj <- terra::project(dem, "EPSG:4326")
Code 
# Attacher les altitudes extraites au data frame d'origine
# cbind() ajoute la colonne en conservant la géométrie sf
households <- cbind(households, households_elevation)

# Vérifier le résultat
head(households)

Le résultat ressemble à ceci — une colonne d’altitude ajoutée pour chaque point :

Simple feature collection with 6 features and 3 fields
Geometry type: POINT
Dimension:     XY
Bounding box:  xmin: 35.69817 ymin: 33.72841 xmax: 36.17128 ymax: 34.33229
Geodetic CRS:  WGS 84
  id ID LBN_elevation_w_bathymetry                  geometry
1  0  1                   878.1839 POINT (35.90386 33.72841)
2  1  2                  1558.2007 POINT (36.17128 34.20268)
3  2  3                  1096.7252 POINT (35.81425 34.19914)
4  3  4                  1251.2185 POINT (36.03916 34.06442)
5  4  5                    986.273  POINT (35.69817 34.04050)
6  5  6                  1323.2316 POINT (35.98001 34.33229)

8.7.2 Extraction à des polygones (statistiques zonales)

Pour des polygones (gouvernorats, communes, bassins versants), terra::extract() renvoie toutes les valeurs des cellules dont le centroïde tombe dans le polygone. On les agrège ensuite avec fun = mean (ou toute autre fonction).

Code 
# Charger les gouvernorats du Liban (déjà utilisés à l'étape 2)
Lebanon <- read_sf("data/Liban/LBN_adm1.shp")

# Harmoniser le SCR
Lebanon <- st_transform(Lebanon, crs(dem))

# Extraire l'altitude moyenne par gouvernorat
# fun = mean agrège directement → une ligne par polygone
# bind = TRUE conserve les attributs originaux du vecteur
gov_elevation <- terra::extract(dem, vect(Lebanon),
                                  fun   = mean,
                                  na.rm = TRUE,
                                  bind  = TRUE) |>
  st_as_sf()

head(gov_elevation |> st_drop_geometry() |>
       select(NAME_1, LBN_elevation_w_bathymetry))
terra::extract() vs exactextractr::exact_extract()

Pour un MNT à 1 m ou 5 m avec de nombreux polygones, exactextractr::exact_extract() est nettement plus rapide et gère les cellules partiellement couvertes en les pondérant par leur fraction de surface :

Code 
# install.packages("exactextractr")
library(exactextractr)

gov_elevation_exact <- exact_extract(dem, Lebanon, "mean",
                                      progress = FALSE)
Lebanon$alt_moy <- gov_elevation_exact

Voir le script rgealti_extraction.R pour une comparaison complète des deux méthodes.

8.7.3 Visualiser les points extraits

Code 
ggplot() +
  geom_spatraster(data = dem_liban) +
  scale_fill_gradientn(colors   = hcl.colors(50, "Terrain"),
                        name     = "Altitude (m)",
                        na.value = "transparent") +
  geom_sf(data = households,
          aes(color = LBN_elevation_w_bathymetry),
          size = 3, shape = 21, fill = "white", stroke = 1.2) +
  scale_color_viridis_c(option = "plasma", name = "Altitude\nextraite (m)") +
  geom_sf(data = Lebanon, fill = NA, color = "white", linewidth = 0.5) +
  labs(title   = "Extraction du MNT aux points d'enquête",
       caption = "Source : SRTM / données enquête | Cours R-Carto") +
  theme_void(base_size = 12) +
  theme(plot.title = element_text(face = "bold", hjust = 0.5))

8.8 Récapitulatif

Les 5 opérations raster essentielles 
# 1. Charger
dem <- rast("fichier.tif")

# 2. Recadrer + masquer
dem_zone <- crop(dem, vecteur) |> mask(vecteur)

# 3. Calculer la pente (MNT projeté en mètres obligatoire)
slope <- terrain(dem_proj, v = "slope", unit = "degrees")

# 4. Reclassifier
rcl   <- matrix(c(0, 10, 1, 10, Inf, 0), ncol = 3, byrow = TRUE)
zones <- classify(dem, rcl)

# 5. Extraire vers des données vectorielles
pts_sf    <- st_transform(pts_sf, crs(dem))           # harmoniser les SCR
alt_pts   <- terra::extract(dem, vect(pts_sf))         # extraction ponctuelle
poly_mean <- terra::extract(dem, vect(poly_sf),        # extraction polygonale
                             fun = mean, na.rm = TRUE,
                             bind = TRUE) |> st_as_sf()

Pour assembler des tuiles : mosaic(t1, t2, t3, t4, fun = "mean")

8.9 À vous de jouer — Exercice Corse

Reproduire l’analyse sur la Corse

La Corse présente une topographie contrastée similaire au Liban : côte méditerranéenne et massif montagneux dépassant 2 700 m. Reproduisez les quatre étapes ci-dessus avec les données corses.

Fichiers disponibles dans data/France/Corse/ :

Fichier Description
Corse_tout_lambert.tif MNT complet en Lambert-93
DEM_corse_1_Lambert93.tif Tuile projetée en mètres (pour la pente)
DEM_corse_1.tif → DEM_corse_4.tif 4 tuiles WGS84 à assembler avec mosaic()

Étapes :

  1. Chargez Corse_tout_lambert.tif — ou assemblez les 4 tuiles avec mosaic()
  2. Visualisez le MNT
  3. Calculez la pente à partir de DEM_corse_1_Lambert93.tif
  4. Reclassifiez en 4 zones : 0–200 m · 200–800 m · 800–1500 m · > 1500 m

→ Corrigé : Corse

8.10 Pour aller plus loin : classification supervisée

Une fois les bases raster maîtrisées, l’étape suivante est de transformer des pixels en catégories — cartographier l’occupation du sol, distinguer l’urbain du rural, identifier les cultures. C’est le domaine de la classification supervisée.

Le principe : chaque pixel d’une image multispectrale possède une signature spectrale — une empreinte de la façon dont il réfléchit la lumière dans chaque bande. La classification supervisée consiste à entraîner un algorithme à reconnaître ces empreintes à partir d’exemples labelisés (points d’entraînement), puis à appliquer le modèle à l’ensemble de l’image.

La chaîne de classification en six étapes
  1. Définir les classes — urbain, péri-urbain, agriculture, forêt, eau…
  2. Collecter des points d’entraînement — idéalement 50 à 200+ exemples par classe
  3. Extraire les valeurs spectrales aux emplacements d’entraînement
  4. Entraîner un classifieur — Forêt Aléatoire, SVM, Maximum de Vraisemblance…
  5. Appliquer à l’image complète — chaque pixel reçoit un label
  6. Valider — réserver un jeu de test, calculer la matrice de confusion et les métriques de précision

Le pipeline est simple. Les choix méthodologiques à l’intérieur ne le sont pas.

Les bandes infrarouge (PIR, SWIR) sont particulièrement utiles pour la distinction urbain/rural : la végétation saine réfléchit fortement le PIR tandis que les surfaces imperméables ne le font pas. Les frontières péri-urbaines restent cependant notoriellement difficiles à classifier avec précision.