Introduction à Google Earth Engine

Esteban Hamel et Arthur de Grandpré

Janvier 2021

Résumé

Cet atelier Numérilab a pour objectif d’introduire la plateforme Google Earth Engine (GEE) et certaines de ses fonctionnalités.

Earth Engine est un logiciel en ligne de la compagnie Google qui met à la disposition de ses utilisateurs une grande variété de données géographiques (images satellitaires, données climatiques, topographiques, etc.), ainsi que des outils pour les analyser. L’avantage de GEE est qu’une grande majorité des calculs sont faits directement par les serveurs de Google sur le cloud, donc beaucoup plus rapidement que sur un ordinateur personnel. Le but de cet atelier n’est pas d’apprendre un nouveau langage de programmation, mais plutôt de présenter certains outils et codes reproductibles et adaptables à vos besoins.

Objectifs

Étape 1 : Introduction à l’interface EE

Pour accéder aux différentes fonctionnalités de GEE, vous devez premièrement avoir un compte Google. À l’aide de votre identifiant Gmail, vous pourrez vous inscrire au lien suivant. https://signup.earthengine.google.com/#!/ Une fois votre inscription complétée, il vous faudra aller sur l’interface pour faire vos scripts. https://code.earthengine.google.com/

Voici quelques informations pour vous retrouver dans l’interface.

Panneau de gauche

Panneau du centre

Panneau de droite

Barre de recherche

Carte

Étape 2 : Sélectionner un lieu d’intérêt à l’aide des outils de géométrie

Naviguer sur la carte jusqu’au Parc National de la Mauricie. Il est aussi possible de faire une recherche à l’aide de la barre de recherche, p. ex. “Shawinigan”.

  1. À l’aide de l’outil de géométrie, « ajouter un repère » en cliquant sur le pictogramme de repère et déposez-le au milieu du Parc national.
  2. Cliquer sur « exit » une fois que le repère est placé.
  3. Renommer le nouveau repère « pnm » dans le haut de votre script.

Alternative, utiliser la ligne de code suivante. Pour importer le repère, il vous faudrait cliquer sur le bouton importer qui serait proposer après avoir taper ce code.

var pnm = /* color: #d63000 */ee.Geometry.Point([-72.97, 46.74])

N’oubliez pas d’enregistrer votre code à l’aide du bouton enregistrer.

Étape 3 : Charger et afficher une carte de l’élévation

Pour importer une couche, vous devrez la charger à partir de la banque de données de Earth Engine. Pour cela, il suffit de rechercher au sein du catalogue GEE à l’aide de la barre de recherche et de l’importer. À noter que lorsqu’une couche est importée elle ne s’affichera pas directement. Comme aucunes limites n’ont été spécifiées pour cette couche, elle contient l’information reliée à une énorme superficie et le mieux est de la filtrer pour avoir un affichage autour d’un lieu d’intérêt. Voici un exemple avec des données d’élévation.

// Imprimer la couche d'élévation dans la console
print(srtm);

// Ajouter la couche d'élévation
Map.addLayer(srtm);


// Ajouter la couche d'élévation avec une échelle appropriée
Map.addLayer(srtm, {min: 0, max: 400},"Élévation");

// Ajouter la couche d'élévation avec des paramètres de visualisation adéquat
Map.addLayer(srtm, {min: 0, max: 400, palette: ['blue', 'yellow', 'red']},"Élévation colorée");


// Calculer une couche de modèle relief ombré
var ombre = ee.Terrain.hillshade(srtm);

// Visualier la couche de modèle relief ombré
Map.addLayer(ombre, {min: 150, max:255}, 'Ombre');

// Créer une carte des pentes
var pente = ee.Terrain.slope(srtm);

//Afficher la carte des pentes
Map.addLayer(pente, {min: 0, max: 30}, 'Pente');

Étape 4 : Travailler avec des images satellitaires pour une région déterminée

Le catalogue de données de Google Earth Engine permet d’accéder à de nombreuses sources d’images satellitaires. Pour travailler sur d’un lieu d’intérêt, il faudra filtrer les données disponibles pour ce lieu pour une période donnée. Commencez par importer les images du satellite Sentinel 2 (aussi possible pour Landsat).

// Définir la variable d'image satellite
var pnm_s2=sent2
    .filterBounds(pnm) // Filtre géographique
    .filterDate("2020-07-01", "2020-08-30") // Filtre temporel
    .filterMetadata('CLOUDY_PIXEL_PERCENTAGE','less_than',10);// Filtre clarté d'image

// Requête du nombre d'image
print(pnm_s2.size(),"n. images");


//Imprimer les propriétés de l'image dans la console
print(pnm_s2, "propriétés pnm_s2")

// Définir l'inage à importer
var pnm_i = sent2
    .filterBounds(pnm) // Filtre géographique
    .filterDate("2020-07-01", "2020-09-30") // Filtre Temporel
    .sort("CLOUD_COVERAGE_ASSESSMENT") // Filre pour la clartée de l'image
    .first(); // Sélection de l'image avec le moins de nuage possible

print(pnm_i,"meilleur image");


//extra : 2nd best?
var pnm_i2 = sent2
    .filterDate("2020-07-01", "2020-09-30")
    .filterBounds(pnm)
    .sort("CLOUD_COVERAGE_ASSESSMENT")
    .select(1);  //le premier index est 0, donc la 2e image est 1
print(pnm_i2, "2e meilleur image");


var couleur_rgb = {
        bands: ["B4", "B3", "B2"],
        min: 0,
        max: 1850
        };

Map.addLayer(pnm_i,couleur_rgb,"Image Sentinel-2");

Étape 5 : Afficher une image satellite selon les contours d’un shapefile

Dans les étapes précédentes, le lieu d’intérêt était le Parc National de la Maurice. Un repère a été placé à un endroit aléatoire dans le Parc. Il est cependant possible de travailler dans Earth Engine avec des superficies prédéterminées, par exemple dans le cas d’un fichier shapefile. Pour ce faire, il vous faudra importer les fichiers shapefiles de votre ordinateur vers Google Earth Engine.

 // Ajouter une variable correspondant à un shapefile
var pnm_poly = ee.FeatureCollection('users/XXX/PNM_poly');

Une fois le fichier shapefile importé, il est possible d’afficher la photo satellite seulement pour cette superficie avec l’outil «.clip » et le code suivant:

// Afficher l'image satellite autour d'une région sélectionnée
Map.addLayer(pnm_i.clip(shape_pnm),couleur_rgb,"Image Satellite coupée");

Étape 6 : Calculer un indice spectral (ex: NDVI)

Un autre exercice qui requiert peu de code avec Google Earth Engine est de créer une nouvelle couche de donnée qui contient une bande calculée comme l’indice spectral NDVI (Normalized difference vegetation index).

Dans le cas du NDVI, il s’agit d’un ratio entre les réflectances des bandes rouge et proche infra-rouge qui permet de cibler les interactions entre les propriétés optiques de la végétation et le spectre électromagnétique. La formule permettant de calculer l’indice NDVI est la suivante.

\(NDVI = \frac{NIR-RED}{NIR+RED}\) Différentes méthodes permettent de créer une telle couche :

  1. Utiliser une fonction.
// Définir la fonction
var ndvi = function (x) {
  var result=x.normalizedDifference(["B8", "B4"]).rename("NDVI");
  return x.addBands(result);
};

// Appliquer la fonction à une image
var ndvi1 = ndvi(pnm_i);

// Afficher le résultat
Map.addLayer(ndvi1, {bands:['NDVI'],min:0,max:1,palette:['red','yellow','green']},"NDVI Méthode1");
print(ndvi1,"ndvi1");
  1. Faire un calcul de la différence des bandes dans une expression.
// Créer l'expression à calculer
var ndvi2 = pnm_i.expression(
     "(NIR - RED) / (NIR + RED)",
    {
      RED: pnm_i.select("B4"),
      NIR: pnm_i.select("B8"),
 }).rename('NDVI'); // Donner un attribut à la bande créée

// Afficher le résultat
Map.addLayer(ndvi2, {min: 0, max: 1,palette:['cyan','green','orange'] }, "NDVI Méthode 2");

Étape 7 : Faire une classification d’image à l’aide de Google Earth Engine

Le prochain exercice vise à introduire à la classification d’image à l’aide de Google Earth Engine. Le code ci-dessous permettra de faire une classification supervisée des différents types de paysages à partir d’image satellite. À l’aide d’un jeu de données préliminaires où les différents types de paysages sont connus, l’outil cart permet d’extrapoler la classification à une plus grande échelle.

// Regrouper les différents polygones de paysage dans une même couche
var classNames = foret.merge(agricole).merge(eau).merge(ville);

print(classNames);


var bands = ['B2', 'B3', 'B4', 'B8']; // pour définir les bandes a utiliser

// Faire le jeu de donnée d'entrainement
var training = pnm_i.select(bands).sampleRegions({
  collection: classNames,
  properties: ['landcover'],
  scale: 30
});

print(training, 'data training');

//L’algorithme de classification (ici l'outil .cart mais il y en a d'autres)
var classifier = ee.Classifier.cart().train({
  features: training,
  classProperty: 'landcover',
  inputProperties: bands
});

// Appliquer la classification à l'image satellite "pnm_i" et ajouter la carte
var classification = pnm_i.select(bands).classify(classifier);
Map.addLayer(classification, {min: 0, max: 3, palette: ['green', 'yellow','blue','red']}, 'classification');

Le résultat précédent n’est pas parfait. Il serait probablement utile d’ajouter la couche NDVI générée plus tôt dans l’objet ndvi1 qui contient l’image satellite et le NDVI.

// Ajouter d'autres bandes
var bands2 = ['B2', 'B3', 'B4', 'B8', 'NDVI']; // pour définir les bandes a utiliser

// Le jeu de donnée d'entrainement avec les nouvelles bandes de l'objet ndvi1
var training2 = ndvi1.select(bands2).sampleRegions({
  collection: classNames,
  properties: ['landcover'],
  scale: 30
});

// L'algorithme de classification
var classifier2 = ee.Classifier.cart().train({
  features: training2,
  classProperty: 'landcover',
  inputProperties: bands2
});


// Appliquer la classification à l'objet ndvi1
var classification2 = ndvi1.select(bands2).classify(classifier2);

Map.addLayer(classification2, {min: 0, max: 3, palette: ['green', 'yellow','blue','red']}, 'classification +ndvi');

• Le résultat final pourrait donc ressembler à ça (bien qu’imparfait encore).

Étape 8 : Exportation vers un fichier raster via Google Drive

Il est possible d’exporter les couches créées dans Google Earth Engine pour continuer de les modifier dans des logiciels SIG. Par exemple, on pourrait vouloir exporter une partie de la classification précédente dans un fichier raster. Comme l’image satellite est relativement volumineuse, vous exporterez seulement une partie de la couche.

// créer une zone d'exportation
var exportation=exporter.buffer(1500);
Map.addLayer(exportation,couleur_rgb,"Export");


//Exporter le raster
Export.image.toDrive({
  image: classification,
  description: 'image_classifier',
  scale: 10,
  region: exportation
});

Étape 9 : Faire des graphiques à l’aide de GEE

L’interface de Earth Engine permet de faire rapidement des graphiques par exemple pour voir la distribution des données d’une couche. Dans les manipulations suivantes, vous reprendrez la couche d’élévation ajusté au contour du parc national de la Mauricie. Ensuite il vous sera possible de construire un histogramme pour voir la distribution de l’élévation dans cette couche.

// Création d'une couche d'élévation pour la région de la mauricie
var elevation1= srtm.clip(shape_pnm);
print(elevation1,"Élevation 1");

// Validation de la couche d'élévation créée
Map.addLayer(elevation1, {min: 0, max: 400, palette: ['blue', 'yellow', 'red']},"Élévation colorée pnm");

// Création du graphique
var Chart1 = ui.Chart.image.histogram(
    elevation1,shape_pnm,30);
print(Chart1);

// Définir quelques options pour personnaliser le graphique
var options = {
  title: "Histogramme de l'élévation pour le Parc National",
  fontSize: 15,
  hAxis: {title: "Élévation (m)"},
  vAxis: {title: 'Fréquence'},
  series: {
    0: {color: 'magenta'}
  }};

// Créer le graphique personnalisé
var Chart2 = ui.Chart.image.histogram(
    elevation1,shape_pnm,30)
    .setSeriesNames(['Hauteur'])
    .setOptions(options);
print(Chart2);

Une fois le graphique afficher dans la console, il vous est possible de l’agrandir et d’exporter les données sous forme de table en différents formats.

Fin du numerilab