INTRODUCTION AU GOOGLE EARTH ENGINE ET AUX

COMPOSITES CLOUD FREE

Google Earth Engine (GEE) est une plate-forme basée sur le cloud pour l'analyse à grande échelle de
données géospatiales. GEE permet aux utilisateurs d'accéder à une archive à l'échelle d'un pétaoctet
d'images télédétectées, de données auxiliaires et d'outils informatiques accessibles au public pour
accomplir une multitude de tâches de télédétection et géospatiales à des vitesses et à des échelles sans
précédent. GEE est gratuit pour un usage non commercial à condition que les utilisateurs s'inscrivent
pour un compte GEE. Depuis sa sortie en 2010, il s'est progressivement développé pour devenir un
outil confirmé pour l'analyse géospatiale à grande échelle. Dans ce module, vous vous concentrerez
sur l'acquisition et la préparation des données pour les analyser géospatialement. Vous apprendrez à
utiliser GEE pour acquérir et préparer des données des images Landsat, Sentinel et MODIS à utiliser
dans le flux de travail (workflows) de cartographie de la couverture terrestre et du changement.
EXERCICE 1: EXPLORER LES ARCHIVES DE DONNEES

Introduction
Earth Engine est disponible via les Interfaces de Programme d’Application (API) Python et JavaScript.
L'API JavaScript est accessible via un Environnement de Développement Intégré (IDE) basé sur le
Web appelé l'Editeur de Code. Cette plate-forme est l'endroit où les utilisateurs peuvent écrire et
exécuter des scripts pour partager et répéter l'analyse géospatiale et le traitement des flux de travail
(workflows). L'Editeur de Code offre un accès à la pleine puissance de l’Earth Engine. Dans cet
exercice, vous découvrirez la plate-forme de l'Editeur de Code et explorez des concepts de base de la
programmation, en JavaScript. Certaines connaissances de base de codage et JavaScript sont
nécessaires pour utiliser l'Editeur de Code de l’Earth Engine.

Qu'est-ce qu'un script?

Un script est une série d'instructions qu'un ordinateur suit pour exécuter un processus. C'est
comme une recette - un ensemble d'instructions qu'un cuisinier suit une à une pour préparer un
plat. Dans la plateforme de l'éditeur de code, les instructions sont écrites sous forme
d'instructions JavaScript. L'ordinateur utilise ces déclarations pour indiquer à Earth Engine les
informations et les traitements que vous demandez.

Matériaux nécessaires
- Un compte Google Earth Engine approuvé
- suggéré: Google Chrome installé sur votre ordinateur

PARTIE 1 : INTRODUCTION A L'EDITEUR DE CODE

Dans cet exercice, vous travaillerez dans l'Editeur de Code du Google Earth Engine. Cette plate-forme
offre beaucoup plus de flexibilité que la plate-forme Explorer
(https://explorer.earthengine.google.com/) basée sur l'interface graphique. Vous avez la possibilité de
créer des workflows d'analyse complexes et personnalisés. Dans l'Editeur de Code, vous écrirez du
code JavaScript pour accéder aux images et les analyser
A. EXPLOREZ L'EDITEUR DE CODE JAVASCRIPT
1. Dans votre navigateur Web Google Chrome, accédez à l'URL suivante:
https://code.earthengine.google.com/ (après avoir créé un compte Google-Gmail)

i. Lorsque / si vous y êtes invité, laissez l'éditeur de code EE accéder à votre compte Google.
ii. Cela devrait vous amener à l'interface de l'Editeur de Code indiqué ci-dessous.

2. Utilisez le graphique ci-dessus pour vous guider et cliquer sur les onglets dans le panneau de la
main supérieure gauche, les Scripts et le panneau de Documentation (Docs).
i. Sous l'onglet Scripts, notez la grande variété de scripts d'exemple préchargés qui
démontrent des capacités et de l'offre de code que vous pouvez utiliser pour vos analyses.
Vous pouvez jeter un coup d'œil à ceux-ci pour commencer à apprendre à quels types de
choses que Earth Engine peut faire. Après avoir créé et enregistré un script plus tard dans la
journée, il sera disponible ici dans votre référentiel privé.
ii. Dans le cadre de l'onglet Docs, il existe une liste interrogeable de documentation pour les
types d'objets et méthodes prédéfinis GEE. Notez ceux-ci sont regroupés et organisés par type.
Explorez brièvement quels types de méthodes (fonctions) sont disponibles dans GEE pour
différents types d'objets.
(a) Sélectionnez l'un qui vous intéresse et cliquez dessus pour voir la fenêtre
d'informations avec une description des méthodes et des arguments associés
(obligatoire et facultatif). Tous les arguments facultatifs sont en italique. (Les
exemples de scripts incluent des exemples de nombreuses méthodes, essayez d'obtenir
d'abord la recherche d'eux à l'aide de la barre de recherche des scripts.)
3. Utilisation du graphique au-dessus de l'écran dans les onglets dans le panneau de la main supérieure
droite où les onglets Inspecteur, Console et Tasks (Tâches) sont situés.
i. Nous utiliserons l'Inspecteur (similaire à l'outil Identifier dans ArcMap) afin d'obtenir
facilement des informations sur les couches sur la carte à des points spécifiés (spécifiés en
cliquant sur le panneau de la carte).
ii. La Console est utilisée pour renvoyer des messages en fonction des scripts exécutant et
d'imprimer (afficher) des informations sur les données, les produits intermédiaires et les
résultats. Il enregistre également tous les messages de diagnostic, tels que des informations sur
les erreurs d'exécution.
iii. L'onglet Tasks est utilisé pour gérer l'exportation de données et de résultats.
4. Cliquez sur le bouton (?) /aide (Guide user) dans la partie supérieure droite et sélectionnez une
visite de fonctionnalité pour en savoir plus sur chaque composant de l'API.
i. Cliquez sur les options de la visite de fonctionnalités pour se familiariser avec chaque
composant de l'Editeur de Code.

B. Dessiner une géométrie représentant la zone d'étude

La géométrie est un autre type d'objet géospatial dans Earth Engine. Pour charger des shapefiles ou
d'autres fichiers vectoriels, on doit utiliser Fusion Tables.
Pour dessiner des lignes ou des polygones à la main ou déposer des points pour créer une géométrie,
on utilise la fenêtre de la carte située dans le coin supérieur gauche. Il y a plusieurs boutons que vous
pouvez utiliser pour dessiner des géométries. Il s'agit notamment d'une petite main (pour faire un
panoramique sur une image), d'une forme de goutte d'eau renversée, d'une ligne et d'un polygone.
Dans notre cas on utiliser le polygone ; Cliquez sur le polygone.

2. Cela vous permettra de dessiner une géométrie qui représente le domaine d'étude qui vous intéresse.
Cliquez dans la fenêtre d'affichage de la carte pour créer un polygone autour d'une zone qui vous
intéresse (par exemple, la partie sud de la ville de Kénitra-Forêt de la Maamora). Rappelez-vous que
vous pouvez utiliser une couche de base (dans le coin supérieur à droite) sous forme de plan ou une
image satellite de type Google Earth. Double-cliquez pour fermer le polygone.
3. Après avoir fermé votre polygone, il y aura un enregistrement d'importation en haut du panneau de
l'éditeur de code. Reportez-vous à la flèche et la case rouges dans l'image ci-dessous.

4. Cliquez sur la flèche à côté de la ligne var studyArea pour voir les détails de la géométrie que vous
avez créée (voir l'image précédente illustrant un exemple).

i. Vous pouvez afficher le code généré en cliquant sur la case bleue à côté de la ligne Imports. Ce
code peut être copié et collé dans la fenêtre de l’Editeur du Code pour l’utiliser dans n’importe
quel script.
ii. Cliquez sur le mot géométry. Changez le nom de la géométrie en studyArea.

var studyarea =
/* color: #d63000 */
/* displayProperties: [
{
"type": "rectangle"
}
] */
ee.Geometry.Polygon(
[[[-6.6017445769855385, 34.25052633418923],
[-6.6017445769855385, 34.2232785364399],
[-6.5564259734699135, 34.2232785364399],
[-6.5564259734699135, 34.25052633418923]]], null, false);
 5. Si vous pointez sur la ligne Geomtry, une icône de corbeille apparaît à gauche. Cela peut être utilisé
pour supprimer cette géométrie dans la fenêtre d’importation.

Notes sur la syntaxe JavaScript:

C. Importer une géométrie représentant la zone d'étude
La déclaration JavaScript est composée de :
1) var : C’est
Pour un mot -clé
télécharger à l'aide
votre zoneduquel
d’étudeles
parvariables
exemplesont
sousdéclarées en JavaScript.
format Shapefile ou CSV,Lesvous
variables peuvent
pouvez utiliserêtre des
chiffres, des chaînes, des objets, des collections d'objets,
l’onglet Assets manager (Gestionnaire de ressources). etc. Les variables sont utilisées pour stocker des
informations à utiliser plus tard dans le script. Dans le cas de l'instruction ci-dessus, la variable a été nommée
Pour télécharger un fichier Shapefile, suivez les étapes suivantes:
studyarea.

2) /* color: #d63000 */ /* displayProperties: [{ "type": "rectangle"}] */ : des commentaires générés

automatiquement et décrive les caractéristiques géométrique de l’entité géométrique dessinée. En général,
permettent de se souvenir de ce que fait une application. Selon le nombre de lignes du commentaire, on peut les
symboles suivants sont utilisés:
Cliquez sur le bouton , puis sélectionnez Shapefiles dans la section Table Upload.
Une boîte de dialogue de téléchargement similaire à celle de la figure ci-dessous sera présentée.

Cliquez sur le bouton SELECT et accédez à votre fichier Shapefile ou à une archive Zip contenant le
fichier Shapefile sur votre système ou support de fichiers local.
Lorsque vous sélectionnez un fichier .shp, veillez à sélectionner les fichiers .dbf, .shx et .prj
correspondants. Earth Engine utilisera par défaut les coordonnées WGS84 (longitude, latitude) si un
fichier .prj n'est pas fourni. Votre fichier doit être projeté en coordonnées WGS84.
Si vous téléchargez une archive Zip, assurez-vous qu'elle ne contient qu'un seul fichier Shapefile
(ensemble de .shp, .dbf, .shx, .prj, etc.) et aucun nom de fichier en double. Assurez-vous que les noms
de fichiers ne comportent pas de points ou de points supplémentaires. (Les noms de fichiers
comprendront un seul point avant l'extension).
Donnez à la table un ID d'actif approprié (qui n'existe pas déjà) dans votre dossier utilisateur. Cliquez
sur UPLOAD pour lancer le téléchargement
 Après avoir lancé le téléchargement d'une table, une tâche d' " Asset ingestion " est ajoutée au
gestionnaire de tâches, qui se trouve sous l'onglet Tâches (Tasks) à droite de l'éditeur de code. Vérifiez
l'état du téléchargement en cliquant sur le bouton ? qui apparaît lorsque l'on passe la souris sur la
tâche. Pour annuler un téléchargement, cliquez sur l'icône en forme de spirale à côté de la tâche. Une
fois l'ingestion terminée, la cellule de la tâche devient bleue et la ressource apparaît dans votre dossier
utilisateur sous l'onglet Ressources (Assets ).

Exemple : télécharger les limites du canton A de la forêt de la Mamora sous format Shapefile
PARTIE 1 : TRAVAILLER AVEC DES IMAGES
A. Ouvrez un nouveau script
1. Ouvrez la page Web de l'éditeur de code dans Google Chrome, s'il n'est pas déjà ouvert:
https://code.earthengine.google.com/
2. Cliquez sur la flèche déroulante adjacente au bouton de Reset (réinitialisation) et sélectionnez Clear
15 (Effacer le script).

B. Créer une variable représentant une seule image LandSat 8

1. Utilisez le code dans la case ci-dessous pour créer une variable représentant un objet ee.Image pour
une image LandSat 8 de 2021.
i. Copiez et collez le code ci-dessous dans l'éditeur de code.

// Get the image.

var lc8_image = ee.Image('LANDSAT/LC08/C01/T1_RT/LC08_201036_20210418');
 Notes sur la syntaxe JavaScript:

Il y a beaucoup de choses en deux lignes. Regardez de plus près les pièces de cette déclaration que vous êtes en
train de charger dans.

1) Double Forwer Slashes, //, sont des caractères de commentaire en JavaScript. Rappelez-vous que ceux-ci
empêchent le texte sur cette ligne d'être exécuté et sont utiles pour créer des notes ou des commentaires dans
votre code.

2) var qu est le mot-clé pour déclarer des variables en JavaScript. Rappelez-vous que les variables peuvent être des
chiffres, des chaînes, des objets, des collections d'objets, etc. et que les variables sont utilisées pour stocker des
informations à utiliser plus tard dans le script. Dans le cas de l'instruction ci-dessus, vous nommez la variable
lc8_image et l'utilisez pour faire référence à l'ensemble de données raster que vous souhaitez analyser.

3) ee.Image () est une fonction GEE qui indique à GEE que vous souhaitez charger une image en tant qu'objet (et
dans ce cas, enregistrez-la sous la forme d'une variable appelée "Lc8_Image"). En JavaScript, les fonctions
commencent par une lettre et ont une paire de parenthèses à la fin. Les fonctions incluent souvent des entrées
(inputs) ou des paramètres, qui indiquent à la fonction quoi faire, et sont spécifiés à l'intérieur des parenthèses.
Dans ce cas, le paramètre que vous spécifiez à l'intérieur des parenthèses est l'ID de l'image.

Une version généralisée de la déclaration ci-dessus est la suivante: ee.Image ('image_id'). "Image_ID" est l'image
que vous souhaitez charger ('LANDSAT/LC08/C01/T1_RT/LC08_201036_20210418') et référencer avec la variable
(lc8_image).

4) La syntaxe pour spécifier l'ID d'image dans cette fonction (ee.Image) est d'entourer la chaîne de caractères (l'ID
de l'image, 'LANDSAT/LC08/C01/T1_RT/LC08_201036_20210418') entre guillemets. L'identifiant de l'image ID est
entre guillemets car la collection et le nom de l'image sont des chaînes de caractères (string). Les chaînes sont des
ensembles de caractères qui, dans cet exemple, nomment l'ensemble de données spécifique.

a. Les ID d'image Landsat pour les scènes de Landsat individuelles sont disponibles chez glovis.usgs.gov.
Vous travaillerez avec cela plus dans l'exercice 3.

5) Les déclarations javascript se terminent par un point-virgule.

2. Exécutez le code et observe le résultat.

i. Cliquez sur le bouton RUN (Exécuter) et notez que rien ne se passe sur la carte ou la
console. Ce code crée simplement la variable, rien n'est imprimé ou affiché.

Notes sur la formulation de l’ID d’une image Landsat 8:

- Accéder au site: https://earthexplorer.usgs.gov/ , choisissez l’image qui vous convient et ouvrez sa

métadonnée.
- Copier le contenu du "Landasat product identifer" de l'image. Ce contenue est composé comme suit :

LC08_L1TP_201036_20200501_20200509_01_T1

- Supprimez la partie tachée en rouge et composer l’ID de l’image comme suit :

'LANDSAT/LC08/C01/T1_RT/LC08_201036_20210418'
C. Ajouter l'image à la carte de la rédaction de code
1. Copiez et collez ou tapez le code ci-dessous dans votre script. Ces lignes supplémentaires ajouteront
l'image LandSat sur le panneau de la carte. Ajoutez ces lignes sous le code de l'étape précédente. GEE
exécutera le code (lignes) séquentiellement lorsque vous appuyez sur Run.

// Add the image to the map.

Map.addLayer(lc8_image);

2. Exécutez le code et examinez le résultat.

i. Cliquez sur le bouton RUN (Exécuter). Cette fois, une image se chargera dans la fenêtre de
sortie de la carte (Map Output). Si votre zoome n’inclut pas le Maroc, vous ne verrez rien.

ii. Utilisez votre curseur pour naviguer (clic gauche et glisser) dans la vue Carte pour trouver
l'image que vous avez appelée. Ce serait bien si le script l'a fait cela pour nous, c’est ce que va
faire l’instruction suivante qui permet de faire le zoom sur la carte si elle est ajoutée au script.

D. Centrez et zoomez la fenêtre de la carte

Map.centerObject() est la fonction qui indique au GEE où positionner la fenêtre de sortie de la carte.
Copiez et collez les deux lignes de code (ci-dessous) sous les quatre lignes que vous avez déjà dans la
fenêtre de l’Editeur de Code GEE. Cliquez sur Exécuter.

// Center the map display on the image.

Map.centerObject(lc8_image, 8);

2. Pour effectuer un zoom arrière, réduisez la deuxième entrée à un nombre inférieur à 8. Pour
effectuer un zoom avant plus important, augmentez le deuxième paramètre d'entrée (essayez 10).
Modifiez votre déclaration pour qu'elle ressemble aux deux lignes ci-dessous et cliquez sur Exécuter.
Que s'est-il passé ?
3. Dans le panneau en haut à gauche, passez de l'onglet Scripts à l'onglet Docs. Tapez
Map.centerObject() dans la barre de recherche de Docs. Quelle est la portée du paramètre de zoom ?

// Center map display on the image.

Map.centerObject(lc8_image, 10);

E. Explorer les outils de la fenêtre de la carte

1. Explorez cette image, lc8_image ('LANDSAT/LC08/C01/T1_RT/LC08_201036_20210418'), avec
les outils de visualisation (Viewer Tools) de la carte.
i. Vous pouvez zoomer et faire un panoramique à l'aide des outils à gauche du panneau de
sortie de la carte (illustré dans la figure suivante)
 ii. Utilisez l'outil calques (Layers) (à droite du panneau de sortie de la carte) pour activer ou
désactiver l'image (Layer 1) (affichée dans la figure suivante).

Note: Même si vous avez sauvegardé l'image LANDSAT/LC08/C01/T1_RT/LC08_201036_20210418 en tant

que variable nommée Lc8_Image, le nom de l'image est étiqueté sous forme de Layer_1 par défaut dans la
légende des calques (Layers) dans la fenêtre de la carte de sortie. Comme vous le verrez plus tard, il est
possible de modifier le nom qui apparaît dans l'outil Calques (Layers) à quelque chose de plus descriptif des
données affichées.

iii. Faites glisser le levier de transparence (la barre coulissante à droite du nom de la couche
dans l'image précédente). Cela rendra la "Layer 1" transparente, révélant la carte de base
(basemap) en dessous.

F. Explorez la fenêtre par l'inspecteur

1. Cliquez sur l'onglet Inspector dans le coin supérieur droit de l'interface de l'éditeur de Earth Engine.
Votre curseur passera maintenant à une croix lorsque vous le placez dans la fenêtre de la carte.
2. Cliquez maintenant, n'importe où, sur la carte en utilisant l'Inspecteur (Croix) pour identifier les
valeurs de pixels pour chaque bande de l'image à l'emplacement sélectionné (voir l'exemple de résultat
dans la figure suivante).

G. Modifier les paramètres de visualisation pour améliorer l'affichage

Maintenant, vous pouvez voir l'image, mais les paramètres de couleur ne sont pas très bien adaptés à
cette image. Vous modifierez les paramètres de visualisation suivant.
1. Ouvrez la fonction addLayer qui est archivé dans le groupe de cartes (Map) en cliquant sur l'onglet
Docs dans le panneau situé à gauche de l'éditeur de code.
i. Développez le groupe de Map et sélectionnez Map.addLayer dans la liste (comme illustré ci-
dessous); ou alors
ii. Recherchez Map.addLayer à travers la barre de recherche.

2. Examiner la documentation qui apparaît (indiquée ci-dessus). Ceci fournit des informations sur
l'utilisation et les arguments de cette fonction.
i. Notez que certaines options de saisie (telle que vis) sont en italique dans la documentation.
Cela signifie que ce sont des paramètres facultatifs (optionel) pouvant être spécifiés ou
 délaissés. Si vous souhaitez sauter un paramètre facultatif, utilisez «undefined» comme
support de lieu. Voir la déclaration ci-dessous pour un exemple.

// Ajoutez l'image à la carte et nommez le calque dans la fenêtre de la carte.

Map.addLayer(lc8_image, undefined, 'Landsat8scene');

Il existe un certain nombre d'options disponibles pour ajuster la manière dont les images sont affichées. Les
entrées les plus couramment utilisées pour modifier les paramètres d'affichage sont les suivantes:
Bands: Permet à l'utilisateur de spécifier les bandes à rendre en rouge, de vert et de bleu.
Min and max: définit la plage d'étirement des couleurs. La plage dépend du type de données. Par exemple,
l'imagerie 16 bits non signée a une plage totale de 0 à 65 536. Cette option vous permet de définir l'affichage sur
un sous-ensemble de cette plage.
Palette: Spécifie la palette de couleurs utilisée pour afficher des informations. Vous verrez comment utiliser cette
option plus tard dans le didacticiel.
Naming convention (in the Layers Legend): (Convention de dénomination (dans la légende des couches
(calque))): Vous pouvez également spécifier le nom qui apparaît dans la légende des couches. Dans le code ci -
dessus, vous avez nommé la couche "Landsat 8scene".
Syntax: la plupart de ces paramètres optionnels sont entrés dans l'objet dictionnaire en tant que paires de valeurs
clés.
La syntaxe est:
{vis_param1: number, number, number
vis_param2: 'string, string, string',

// or an array of strings like this (ou un tableau de chaînes comme celui-ci):

vis_param2: ['string', 'string', 'string']}

1. Modifiez la fonction Map.addLayer() dans notre script pour afficher l'image sous forme de faux
composite de couleurs et appliquez un étirement pour améliorer l'affichage. Modifiez l'instruction
Map.addLayer() à partir des étapes précédentes pour ressembler au code ci-dessous. La déclaration ci-
dessous inclut les paramètres facultatifs suivants : afficher les bandes B6, B5et B4 (bands: ['B6', 'B5',
'B4']), spécifier un étirement pour améliorer la visualisation (min: 5136, max: 31261, gamma: 1.6) et
donner enfin à l'image un nom d'affichage.
2. Cliquez sur Exécuter et utiliser les outils de la carte pour explorer le résultat. Notez que le nom sous
les couches (légende) est maintenant Landsat8scene.

// Ajoutez l'image à la carte sous la forme d'un faux composite de couleurs.

Map.addLayer(lc8_image,
{bands: ['B6', 'B5', 'B4'], "min":5136,"max":31261, gamma: 1.6},
'Landsat8scene');
 Note: Dans la déclaration ci-dessus, les noms des bandes ont déjà été insérés pour vous. Si vous
vouliez les regarder vous-même, vous pouvez utiliser la fonction d'impression (ou l'Inspector) pour
identifier les bandes nommées (par exemple, B6, B5, B4).

3. Copiez et collez l'instruction suivante dans votre éditeur de code. Puis cliquez sur Run.

// Imprimer les informations de l’image.

print(lc8_image) ;

4. Maintenant, dans l'onglet Console, cliquez sur la flèche à côté de l’Image LANDSAT/... pour
afficher les propriétés de l'image. Cliquez ensuite sur la flèche à côté de bandes: pour afficher les
propriétés de la bande. Cela révélera que la première bande (indexée à 0) est appelée “B1”, la seconde
(indexée à 1) est appelée “B2”, etc. La figure suivante illustre un exemple.

Note: Pour en savoir plus sur les combinaisons de bandes pour la visualisation les images Landsat 8
et Landsat 5 ou 7, consultez la comparaison des bandes Landsat dans le site:
www.usgs.gov/landsat.
6. Cliquez sur le bouton Enregistrer (Save) dans la partie supérieure droite du panneau Editeur de
Code pour enregistrer votre script pour une référence future.
i. Nommez ce script : Visualisez une image LandSat 8.

Note: il existe de nombreuses autres options de visualisation des données dans la fenêtre de la
carte, telles que la définition d'un masque ou la mosaïque de deux ensembles de données.

PARTIE 3 : EXECUTER UN EXEMPLE DE SCRIPT ET EXAMINER LES

RESULTATS
1. Cliquez sur l'onglet Scripts dans le panneau de gauche et développez le groupe Exemples.

2. Cliquez sur le triangle pour développer le sous-groupe Image.

3. Sélectionnez le script Normalized Difference (différence normalisé) dans la liste des scripts (stockés
dans le sous-groupe Image). Ceci copiera le script dans votre panneau de Code Editor.
4. La figure ci-dessous montre le script qui devrait apparaître dans le panneau Code Editor (panneau
central supérieur).
5. Lisez le script de Normalized Difference, ligne par ligne (ou déclaration par déclaration) pour voir
ce qu'il fait:
i. Les lignes 1 à 6 sont des notes, ou des commentaires, que le développeur a inclus pour
décrire le script. Les commentaires de ligne sont désignés par le //, les doubles barres obliques
au début de la ligne. Les commentaires sont ignorés par l'éditeur de code lorsque le script
s'exécute.
ii. La ligne 8 accomplit deux choses. Il déclare une variable, appelée img. Il attribue ensuite
une valeur à cette variable. La valeur est une image MODIS
ee.Image('MOD09GA/MOD09GA_005_2012_03_09').
iii. La ligne 9 fait plusieurs choses. Il déclare et attribue une valeur à une variable, appelée
ndvi. Il appelle également la méthode NormalizedDifference d’Earth Engine et l'applique à la
variable "img" définie au niveau de la ligne précédente. Les bandes "sur_refl_b02" et
"sur_refl_b01" sont spécifiées comme entrées de ce calcul (arguments de la méthode). Ces
deux bandes sont les bandes NIR (Proche-infrarouges) et RED (rouges), de sorte que le
résultat du calcul est une image de l'Indice de Végétation par Différence Normalisée (NDVI).
Cette image ndvi calculée est celle qui est assignée à la variable ndvi. Plus précisément, c'est
une image qui représente le calcul
(sur_refl_b02 - sur_refl_b01) / (sur_refl_b02 + sur_refl_b01)

iv. Les lignes 10-12 déclarent une variable ‘palette’, et l'affectation d'une matrice qui spécifie
une palette de codes de couleur hexadécimale pour afficher l'image ndvi résultante. Les
couleurs hexadécimales sont : blanc (FFFFFFF), brun (CE7E45), jaune (FCD163), verts
(529400) et sombre (011301).

Note: vous pouvez en savoir plus sur les codes de couleur hexadécimale ici
http://www.colorhexa.com/.
 v. La ligne 14 centre la carte sur la zone d’intérêt. Les arguments, les valeurs entre crochets,
sont les valeurs de longitude et de latitude pour Kansas City, États-Unis; la troisième valeur
définit le niveau de zoom.
vi. Les lignes 15 à 17 ajoutent des données à la fenêtre en sortie de la carte (panneau
inférieur). Deux images sont affichées : la variable img, qui pointe vers l’image MODIS
d’origine, et la variable ndvi, qui pointe vers l’image de Différence Normalisée créée à la
ligne 9.
6. Cliquez sur le bouton Run en haut à droite de l'éditeur de code pour exécuter le script de
Normalized Difference.

i. Vous devriez voir une image MODIS et l'image NDVI résultante apparaissent dans la
fenêtre de sortie de carte en bas de votre écran.
ii. Dans la ligne 14, changer les valeurs de longitude et de latitude comme suit :
Map.setCenter(-5, 35, 8) pour zoomer sur la Maroc; réexécuter le script pour voir le
résultat.
7. Examinez visuellement les résultats dans la fenêtre de sortie de la carte à l'aide des outils de la
visionneuse de la carte.
i. Cliquez ou passez la souris sur le bouton Layers dans le coin supérieur droit du panneau de
sortie de carte en bas de votre écran (illustré dans la figure suivante).
ii. Activez et désactivez la couche NDVI en décochant et en cochant la case à coté de la
couche NDVI.
iii. Cliquez et faites glisser le curseur en avant et en arrière pour ajuster la transparence de
la couche NDVI et visualiser l'image MODIS sous l'image NDVI (voir la figure,
montrant la boîte de paramètres de visualisation)

8. Utilisez le panneau de l’Inspector pour explorer les valeurs de l'image NDVI résultante.
i. Cliquez sur l'onglet Inspecteur dans le panneau à droite.
(a) Survolez votre curseur sur la carte. Notez que votre curseur est devenu une croix.
 ii. Cliquez sur n'importe où sur la carte et observez les valeurs qui apparaissent dans la fenêtre
sous l'onglet Inspecteur.
(a) Ce sont les valeurs du pixel à cet endroit pour:
(i) Les valeurs des bandes de l'image MODIS.
(ii) la valeurs NDVI calculée.

PARTIE 4 : EXPLORER LES DONNEES DISPONIBLES DANS EARTH

ENGINE
1. Dans un navigateur Web, tel que Google Chrome, ouvrez la page d'accueil du Google Earth
Engine :https://earthengine.google.com/.
2. Cliquez sur Datasets dans le coin supérieur droit. Cela vous donnera un aperçu rapide de certaines
des données disponibles dans Earth Engine. Prenez un moment pour lire les informations sur
l'imagerie, les données géophysiques, le climat et la météo, et les données démographiques.
EXERCISE 2: EARTH ENGINE IMAGE OBJECTS AND
METHODS

Introduction
Le Code Editor offre l'accès à toute la puissance du Earth Engine; cependant, une compréhension de
base des principes fondamentaux du codage et du JavaScript est requise. Dans cet exercice, vous
apprendrez la syntaxe JavaScript et plusieurs concepts clés de données spatiales Earth Engine. Cet
exercice se concentre sur les propriétés et méthodes, ou fonctions, associées à des images raster
uniques dans Earth Engine. Cependant, vous obtiendrez également une brève introduction à d'autres
types d'objets spatiaux Earth Engine. Cet exercice vous permettra d'écrire un script JavaScript simple.
Vous en apprendrez également sur les tables Fusion (Fusion Tables).

PARTIE 1 : CONFIGUREZ VOTRE ESPACE DE TRAVAIL

A. Ouvrez un nouveau script
1. Ouvrez la page Web de l'éditeur de code dans Google Chrome, s'il n'est pas déjà ouvert:
https://code.earthengine.google.com/
Cliquez sur la flèche déroulante adjacente au bouton de réinitialisation et sélectionnez Effacer le
script.

B. Créer une variable représentant une seule image LandSat 8

1. Utilisez le code dans le cadre ci-dessous pour créer une variable représentant un objet ee.Image pour
une image Landsat 8.
i. Copiez et collez le code ci-dessous dans Code Editor.

// Stockez une image dans une variable, LC8_Image.

var lc8_image = ee.Image('LANDSAT/LC08/C01/T1_RT/LC08_201036_20210418');
// Afficher l'image dans la fenêtre de la carte.
Map.addLayer(lc8_image, {min:5170,max:30995, bands: ['B6', 'B5', 'B4']}, "Landsat 8 Scene");
// Centre la fenêtre de la carte.
Map.centerObject(lc8_image, 8);

PARTIE 2 : EXPLOREZ LES FONCTIONS DE TRAITEMENT D'IMAGES

EXISTANTES
Une collection complète d'outils sont facilement disponibles dans Code Editor pour analyser et traiter
les objets d'image que vous avez appris. Ceux-ci sont disponibles en tant que méthodes et fonctions
d’Earth Engine.

A. Calculez NDVI sur votre image LandSat

1. Vous pouvez calculer l'indice de végétation de différence normalisé (NDVI) sur votre image à l'aide
de la méthode normalizedDifference(). Copiez les lignes ci-dessous et collez-les au bas de votre
script. Cliquez sur Run. Cela calculera la valeur NDVI dans chaque pixel de votre image.

// Créez une image NDVI à l'aide de bandes les bandes NIR et Red (5 et 4).
var NDVI = lc8_image.normalizedDifference(['B5', 'B4']);
// Affiche l'image NDVI avec un stretch en niveaux de gris.
Map.addLayer(NDVI, {min: -0.2, max: 0.5, palette: ['FFFFFF', '339900']}, "NDVI");
B. masquer les nuages
1. Effacez votre script de la partie 2 A, sauf pour les lignes ci-dessous.

// Stockez une image dans une variable, LC8_Image.

var lc8_image = ee.Image('LANDSAT/LC08/C01/T1_TOA/LC08_201036_20210520');
// Afficher l'image dans la fenêtre de la carte.
Map.addLayer(lc8_image, { min: 0.05, max: 0.8, bands: ['B6', 'B5', 'B4']}, "Landsat 8 Scene");
// Centre la fenêtre de la carte.
Map.centerObject(lc8_image, 8);

2. Exécutez le script. Remarquez les nuages qui sont présents sur la moitié nord de l'image ?
Ultérieurement, vous allez construire un processus pour les retirer de l'imagerie.
3. Premièrement, vous allez créer une variable, cloud_thresh. Cela permettra de stocker la valeur du
seuil de probabilité du nuage. Après avoir rédigé le script, vous pouvez facilement modifier la valeur
de cette variable. Changez la valeur et réexécutez le script pour déterminer la valeur de seuil de nuage
appropriée pour la région d'étude.

// Spécifique le seuil de probabilité du nuage.

var cloud_thresh = 40;

Ensuite, vous utiliserez un algorithme de Earth Engine qui calculera un score simple de probabilité
de nuages en combinant la luminosité, la température et l'indice de neige normalisé (NDSI). Cette
probabilité est représentée par une bande ajouté à l’image ‘cloud’ sur une échelle de 0 à 100, les
valeurs les plus élevées indiquant une plus grande probabilité qu'un pixel soit obscurci. Vous
pouvez en savoir plus à ce sujet dans l'onglet Docs (ou consulter l'image ci-dessous)..
4. Copiez les lignes ci-dessous et collez-les en bas de votre script. Cela générera et une couche raster
dont les valeurs des pixels varient de 0 à 100, les pixels d'une valeur plus élevée sont plus susceptibles
d'être des nuages.

// Ajoutez la bande ‘cloud’ de probabilité de nuages à l'image.

var cloudscore = ee.Algorithms.Landsat.simpleCloudScore(lc8_image);

5. (Facultatif) Ajoutez la couche de nuages à la carte en copiant les lignes ci-dessous et en les ajoutant
au bas de votre script. Cliquez sur Exécuter.
i. Quelles valeurs sont attribuées aux zones nuageuses ? (Indice : utiliser l'inspecteur pour
rechercher des valeurs à différents endroits de la carte)
ii. Remarquez-vous la différence entre les résultats des deux instructions Map.addLayer() ?
(Indice : utilisez l'onglet inspecteur et activez et désactivez les couches pour comparer)
iii. Après avoir inspecté le raster cloudscore, supprimez (ou commentez -en ajoutant double
slaches) les lignes suivantes de votre script.

// Ajoutez l'image cloud à la carte.

// Cela affichera les trois premières bandes comme R, G, B par défaut.
Map.addLayer(cloudscore, {}, 'Cloud Likelihood, all bands');

// Etant intéressé seulement par la seule couche de nuage, spécifique juste cette bande à afficher
dans les Paramètres de la déclaration de Map.addLayer.
Map.addLayer(cloudscore, {bands: 'cloud'}, 'Cloud Likelihood');

6. Le raster que vous avez généré à partir de la méthode : ee.Algorithms.Landsat.simpleCloudScore()

renvoie une image avec 13 bandes : les 12 de l'image Landsat, et la 13ème bande est la nouvelle - le
score/la valeur de probabilité du nuage. La bande de score des nuages est utile pour masquer les
nuages dans l'image Landsat. Copiez les lignes ci-dessous et collez-les au bas de votre script. La bande

// isolez la bande de probabilité du nuage.

var cloudLikelihood = cloudscore.select('cloud');

"
Cloud " est alors placée dans une variable appelée "cloudLikelihood"..
1. Copiez les lignes ci-dessous et collez-les au bas de votre script. Ce code utilise la méthode lt() pour
créer un raster binaire qui attribue une valeur à chaque pixel :
i. Un (1) si la probabilité du nuage, variable de qualité, est inférieure à la valeur seuil du
nuage;
 ii. Zéro (0) si la probabilité du nuage, variable de qualité, est supérieure à la valeur seuil du
nuage.

// Calculer un masque dans lequel les pixels en dessous du seuil sont 1.

var cloudPixels = cloudLikelihood.lt(cloud_thresh);

// Ajoutez l'image à la carte.

Map.addLayer(cloudPixels, {}, 'Cloud Mask');

2. Exécutez le code et inspectez les valeurs à différents endroits (indice: utilisez l'Inspector).
3. Copiez les lignes ci-dessous et collez-les au bas de votre script.
i. Vous utilisez la méthode updateMask() pour supprimer de l'image Landsat les valeurs dont
la probabilité de nuages est élevée. La méthode updateMask() supprime les pixels de l'image
Landsat là où l'image d'entrée, CloudPixels, a une valeur de zéro.
ii. Exécutez le code et inspectez la sortie.

// Créez un masque indiquant quels pixels sont susceptibles d'être des nuages.
var lc8_imagenoclouds = lc8_image.updateMask (cloudPixels);

// revoir le résultat.
Map.addLayer(lc8_imagenoclouds, {bands: ['B6', 'B5', 'B4'], min: 0.1, max: 0.5},
'Landsat8scene_cloudmasked');

C. Éditez le script pour masquer la brume en plus des nuages

1. Avec l'image Landsat 8 originale désactivée, faites un zoom avant sur le bord d'un nuage dans
l'image. Observez-vous la présence de brume dans certaines zones de l'image masquée?
2. Vous pouvez essayer de réduire la brume en diminuant le seuil de probabilité des nuages. Localisez
la variable cloud_thresh et modifiez cette valeur de 40 à 20. Cliquez sur Exécuter et examinez le
résultat.
i. En abaissant le seuil de probabilité des nuages de 40 à 20, on réduit considérablement la
présence de pixels nuageux et brumeux dans l'image - les pixels restants apparaissent clairs et
lumineux
ii. Pensez-vous qu'il s'agisse d'un seuil approprié de probabilité de nuages?

3. Utilisez les outils de visualisation pour explorer les images et essayez d'autres seuils si vous le
souhaitez.

Note: les ombres ne sont pas éliminées de l'image.

PARTIE 3: (FACULTATIF) ACCES AUX METADONNEES
Comprendre comment accéder aux métadonnées de votre imagerie est important lorsque vous créez
vos scripts.

Note: ces exemples proviennent de la documentation du Earth Engine, disponible ici:

https://developers.google.com/earth-Engine/Image_info

1. Effacez le script précédent à partir de votre panneau d'éditeur de code.

2. Examinez les déclarations ci-dessous. Ensuite, copiez et collez ce qui suit dans votre éditeur de
code. Exécutez le script et examinez ce qui est renvoyé dans chaque instruction d'impression.

// Get an image.
var lc8_image = ee.Image('LANDSAT/LC08/C01/T1_RT/LC08_201036_20210504');
//Add the image to the map as a false color composite.
Map.addLayer(lc8_image, {bands: ['B6', 'B5', 'B4'], "min":5307,"max":25723,"gamma":1.6},
'Landsat8scene');
// Center the map on the image.
Map.centerObject(lc8_image, 9);
// Retrieve information about the bands as an Earth Engine list.
var bandNames = lc8_image.bandNames();
print('Band names: ', bandNames);
// Get projection information from band 1.
var b1proj = lc8_image.select('B1').projection(); print('Band 1 projection: ', b1proj);
// Get scale (in meters) information from band 1.
var b1scale = lc8_image.select('B1').projection().nominalScale(); print('Band 1 scale: ', b1scale);
// Note that different bands can have different projections and scale.
var b8scale = lc8_image.select('B8').projection().nominalScale();
print('Band 8 scale: ', b8scale);
// Get a list of all metadata properties.
var properties = lc8_image.propertyNames();
print('Metadata properties: ', properties);
// Get a specific metadata property.
var cloudiness = lc8_image.get('CLOUD_COVER'); print('CLOUD_COVER: ', cloudiness);
// Get the timestamp and convert it to a date.
var date = ee.Date(lc8_image.get('system:time_start'));
print('Timestamp: ', date);

PARTIE 4: (LECTURE FACULTATIVE) DE FOND SUR DES OBJETS

A. Objets
Qu'est-ce qu'un objet JavaScript?
" JavaScript est conçu sur un paradigme simple basé sur les objets. Un objet est une collection de
propriétés, et une propriété est une association entre un nom (ou une clé) et une valeur. La valeur d'une
propriété peut être une fonction, dans ce cas la propriété est appelée méthode. En plus des objets
prédéfinis dans le navigateur, vous pouvez définir vos propres objets" (extrait du Mozilla Developer
Network JavaScript Guide, lien)

En savoir plus sur les objets JavaScript ici:

https://developer.mozilla.org/en-us/docs/web/javascript/guide/working_with_Objects

ou ici:
http://eloquentjavascript.net/06_Object.html.

Il y a aussi des objets d’Earth Engine. Ce sont des objets qui ont une signification dans Earth Engine,
mais pas des applications JavaScript générales. Des exemples d'objets d’Earth Engine incluent des
images (par exemple, et une scène Landsat) et des collections d'images (une collection de scènes
Landsat). Ici, l'accent est mis sur les objets d’Earth Engine et leurs méthodes de géotraitement
associées. Cependant, il est important de distinguer les objets d’Earth Engine et des objets javascript
afin de ne pas appliquer à tort de méthodes d'un type d'objet à l'autre.

B. Propriétés d'objet et leurs méthodes associées

Properties : les objets ont des propriétés. Chaque propriété a un nom et une valeur (qui peut être
nulle). Les paires « nom et valeur » vous renseignent sur l'instance individuelle de l'objet. Par
exemple, un objet image possède des propriétés spécifiques à cet objet. Une scène Landsat est un objet
image, avec 12 bandes, et de multiples propriétés qui représentent des choses comme l'heure à laquelle
la scène a été acquise (system:time_start) et les métadonnées de la scène définies par le fournisseur
(USGS)

Methods: Les fonctions qui sont spécifiques aux types d'objets sont appelées méthodes. Ils peuvent
récupérer des données, trier des données, mettre à jour les valeurs des propriétés d'un objet, etc. Par
exemple, la méthode NormalizedDifference, est une méthode d'objet d'image.

C. Objets d'Image d’Earth Engine

Dans l'éditeur de code GEE, les données raster peuvent être représentées par deux types d'objets: un
objet image ou un ImageCollection.

Image: les données raster sont représentées sous forme d'objets images dans Earth Engine. Un objet
image représente une image raster unique, telle qu'une seule scène Landsat collectée un jour donné, un
composite médian Landsat ou un jeu de données topographiques (DEM). Les images sont composées
de zéro ou plusieurs bandes, où chaque bande a un nom, un type de données, une résolution de pixel et
une projection. Chaque image a également des métadonnées stockées sous forme de dictionnaire de
propriétés. En savoir plus ici - https://developers.google.com/earth-engine/image_info

Image collection: un ensemble d'images. Par exemple, la collection Landsat 8 TOA Reflectance
(LANDSAT/LC8_L1T_TOA) comprend toutes les images Landsat 8 recueillies depuis le 11 avril
2013, orthorectifiées et corrigées en fonction de la réflectance au sommet de l'atmosphère. Les
collections sont utiles pour l'analyse temporelle, ou pour créer des composites sans nuages qui incluent
des images provenant de plusieurs acquisitions.

D. Objets Vectoriels du Earth Engine

Earth Engine utilise le type de données Geometry (en tant que GeoJSON ou GeoJSON
GeometryCollection) pour stocker les données vectorielles ; Il s'agit de points, de lignes, d'anneaux
linéaires et de polygones. Vous pouvez créer des géométries de manière interactive à l'aide des outils
de dessin ou d'une liste de coordonnées. Les caractéristiques sont composées d'une géométrie et,
comme les images, d'un dictionnaire de propriétés.
Vous pouvez créer un objet avec une géométrie dans Earth Engine, une entité GeoJSON ou une
collection d'entités. Les fichiers de formes (Shapefiles ) peuvent être convertis en tables de fusion
(Fusion Tables), puis accessibles dans Earth Engine en tant que FeatureCollection.
EXERCICE 3: CREATION DE FONCTIONS
PERSONNALISEES ET CARTOGRAPHIE A TRAVERS LES
COLLECTIONS D'IMAGES

Introduction
Dans cet exercice, vous continuerez à découvrir la syntaxe JavaScript et certains nouveaux concepts
de données spatiales Earth Engine. Vous vous appuierez sur ce que vous avez appris dans l’exercice 2
sur les objets image; toutefois, vous allez maintenant vous concentrer sur l’utilisation de collections
d’images ou de piles d’objets image similaires. Dans cet exercice, vous allez vous concentrer sur les
concepts et méthodes de base associés aux collections d’images dans Earth Engine.

Objectifs
Pratiquez l'écriture et l'exécution de code dans l'éditeur de code du Earth Engine pour accéder à la
collection d'images raster, filtrer dans le temps (par plage de date) et dans l'espace (par zone d'étude,
par exemple), utiliser la géométrie, et explorer certaines fonctionnalités de traitement d'image

PARTIE 5: TRAVAILLER AVEC DES COLLECTIONS D'IMAGE

Une imageCollection fait référence à l'ensemble d'images dans Earth Engine. Par exemple, toutes les
images LandSat 8 de GEE sont dans une imageCollection.
Dans l'éditeur de code, vous pouvez travailler avec l'ensemble de la collection d'images, ou vous
pouvez utiliser des filtres pour créer des sous-ensembles de l' ImageCollection. (par exemple, sous-
ensemble spécifique à votre zone d'étude ou pour une période de temps déterminée). En savoir plus ici
- https://developers.google.com/earth-engine/ic_info

A. Ouvrir un nouveau script

1. Ouvrez la page Web de la rédaction de code dans Google Chrome, s’elle n'est pas déjà ouverte:
https://code.ararthengine.google.com/
2. Cliquez sur la flèche déroulante adjacente au bouton de réinitialisation et sélectionnez Effacer le
script.

B. Créer un objet Landsat Image Collection

1. Créez une variable faisant référence à la collection d'images de toutes les images Landsat 8
disponibles en tapant ou en copiant/collant le code ci-dessous dans l'éditeur de code.
// Obtenir une collection d'images LandSat 8.
var landsat8_collection = ee.ImageCollection('LANDSAT/LC08/C01/T1_TOA');

2. Pour ajouter cette collection à la carte, copiez le code ci-dessous et collez-le dans l'éditeur de code.
Cliquez ensuite sur Run pour exécuter toutes les lignes.

// Obtenez une collection d'images et centrez l'écran.

Map.addLayer(landsat8_collection, { min: 0.05, max: 0.8, bands: ['B6', 'B5', 'B4'] }, 'Landsat
Collection');
Map.setCenter(-5.5, 34.5, 7);

I. Qu'est-ce qui est cartographié ici ? La collection d'images comporte un certain nombre d'images,
mais toutes ne sont pas cartographiées. Lorsque vous utilisez la fonction Map.addLayer pour ajouter
une collection d'images à la fenêtre de la carte, le pixel le plus récent s'affiche par défaut.

3. (Facultatif) Si vous ajoutez une déclaration d'impression, vous pouvez déterminer combien d'images
se trouvent dans la collection. Copiez et collez les lignes suivantes dans le bas de votre script.

// Imprimez les informations sur la collection d'images.

print(landsat8_collection);

i. Cependant, comme la collection d'images est assez importante, un message d'erreur est
renvoyé dans la console « Collection query aborted after accumulating over 5,000 elements.
La requête d'impression de la collection a échoué après avoir accumulé les métadonnées de
plus de 5 000 éléments. Ensuite, vous filtrerez la collection en fonction de paramètres spatiaux
et temporels et apprendrez une meilleure façon d'obtenir un compte du nombre d'images dans
la collection d'images.
 ii. Mettez en commentaire l'instruction print. Vous y reviendrez plus tard.

// print(landsat8_collection);

PARTIE 6: FILTRER COLLECTION D'IMAGES AVEC UNE LIMITE

SPATIALE

A. Dessiner une géométrie à utiliser ultérieurement comme filtre géographique (limite

spatiale)

1. Dessiner une géométrie qui représente le domaine d'étude qui vous intéresse. Cliquez dans la
fenêtre d'affichage de la carte pour créer un polygone autour d'une zone qui vous intéresse (par
exemple, partie sud de la ville de Kénitra-voir exercice1). Rappelez-vous que vous pouvez
activer et désactiver l'image Landsat pour voir la couche de base en dessous. Double-cliquez
pour fermer le polygone.

2. Après avoir fermé votre polygone, il y aura un enregistrement d'importation en haut du

panneau de l'éditeur de code. Reportez-vous à la flèche et la case rouges dans l'image ci-
dessous.

3. 3. Cliquez sur le mot géométry. Changez le nom de la géométrie en studyArea.

4. Cliquez sur la flèche à côté de la ligne var studyArea pour voir les détails de la géométrie que vous
avez créée.

B. Collection d'images de filtre par géométrie

1. Vous êtes maintenant prêt à filtrer la collection d'images, landsat8_collection. De retour dans le
panneau de code, copiez les lignes ci-dessous et collez-les dans l'éditeur de code. Veillez à les copier
sous l'instruction qui crée initialement la collection d'images, landsat8_collection.

// filtrer les scènes qui recoupent votre région d'étude.

var landsat8_studyArea = landsat8_collection.filterBounds(studyArea);
1. Déplacez l'instruction Map.addlayer sous l'instruction qui crée la variable landsat8_studyArea. Et
changez la variable landsat8_collection par landsat8_studyArea (l'instruction adaptée est incluse
ci-dessous).
2. Changez l'instruction Map.setCenter par Map.centerObject et mettez à jour les paramètres
d'entrée. Cela permettra de centrer la fenêtre de la carte sur la géométrie que vous avez créée
(exemple inclus ci-dessous). Déplacez-la sous l'instruction qui crée la variable
landsat8_studyArea. Remplacer la paire la longitude-latitude (-5.5, 34.5, 7) par studyArea.

// Affiche l'image.
Map.addLayer(landsat8_studyArea,
{min: 0.05, max: 0.8, bands: ['B6', 'B5', 'B4']},'Landsat 8 in study region');

// Centre l'affichage sur la région d'étude.

Map.centerObject(studyArea, 7);

3. Cliquez à nouveau sur Exécuter. Maintenant, la collection d'images sera filtrée pour inclure
uniquement les images qui coupent le polygone que vous avez dessiné.

4. (Facultatif) Modifiez la déclaration d'impression pour imprimer les détails de votre nouvelle
collection d'images, landsat8_studyArea (assurez-vous de déplacer cette instruction dessous de la
création de la variable landsat8_studyArea). Si votre collection d'images a moins de 5000 images, des
informations sur la collection sont imprimées sur la console. La taille de votre collection d'images
varie en fonction de la taille de la géométrie que vous avez digues.

// Imprimer des informations sur la collection d'images filtrées.

print(landsat8_studyArea);

5. Nous pouvons également utiliser la méthode de la taille (size()) de la collection d'images pour
déterminer le nombre d'images dans la collection. Copiez les affirmations suivantes et collez-les en
bas de votre script. Puis exécutez le script.

// Comptez et imprimez le nombre d'images.

var count = landsat8_studyArea.size();
print('Count of landsat8_studyArea: ', count);
PARTIE 7: COLLECTION D'IMAGES FILTRANT TEMPORELLEMENT
A. Création de la collection d'images à la date limitée
1. Ajoutez ensuite une instruction qui filtre votre collection d'images par une durée, en utilisant la
méthode filterDate() (voir l'exemple de script ci-dessous). filterDate() nous permet de spécifier une
date de début et de fin en tant que paramètres afin de réduire la taille de la collection pour répondre
aux objectifs de votre projet. Les nouvelles lignes ajoutent un filtre à la collection de données,
landsat8_studyArea, basé sur la date à laquelle les images ont été prises.
2. Ensuite, ajoutez une instruction count et print pour voir combien d'images se trouvent dans la
nouvelle collection d'images.
3. Le script complet est copié ci-dessous pour votre référence. Modifiez votre script pour qu'il
corresponde et exécutez le code.

// Get an image collection.

var landsat8_collection = ee.ImageCollection('LANDSAT/LC08/C01/T1_TOA');
// Filter the collection to scenes that intersect your study region.
var landsat8_studyArea = landsat8_collection.filterBounds(studyArea);
// Filter the collection to a time period of interest.
var landsat8_SA_2021 = landsat8_studyArea.filterDate('2021-01-01', '2021-12-31');
// Display the image collection and
// center the map on the study region.
Map.addLayer(landsat8_SA_2021, { min: 0.05, max: 0.8, bands: ['B6', 'B5', 'B4']});
Map.centerObject(studyArea, 7);
// Count the number of images.
var count = landsat8_studyArea.size();
print('Count of landsat8_studyArea: ', count);
// Count the number of images.
var count21 = landsat8_SA_2021.size();
print('Count of landsat8_SA-2021: ', count21);

3. (Facultatif) Voici quelques méthodes supplémentaires que vous pouvez utiliser pour explorer votre
collection d'images. Celles-ci sont extraites de la page suivante de la documentation utilisateur:
https://developers.google.com/earth-engine/ic_info

// Obtenir des statistiques pour une propriété des images de la collection.

var sunStats = landsat8_studyArea.aggregate_stats('SUN_ELEVATION');
print('Sun elevation statistics: ', sunStats);

// Trier par une propriété de couverture nuageuse, obtenir l'image la moins nuageuse.
var LoCloudimage = ee.Image(landsat8_studyArea.sort('CLOUD_COVER').first());
print('Least cloudy image: ', LoCloudimage);
// Limiter la collection aux 10 images les plus récentes.
var recent = landsat8_studyArea.sort('system:time_start', false).limit(10);
print('Recent images: ', recent);
PARTIE 8: INTRODUCTION AUX REDUCTEURS

A. Réducteurs de collection d'images, valeur de pixel médiane

Cette section se concentre sur un type d'objet important dans Earth Engine, les réducteurs. Les
réducteurs travaillent sur des collections d'images en calculant des statistiques, comme la valeur
moyenne de chaque pixel. La sortie est un objet Image (couche raster unique) qui caractérise une
certaine qualité de la collection d'images complète. Pour en savoir plus sur les réducteurs, consultez le
Guide de l'utilisateur.: https://developers.google.com/earth-engine/reducers_image_collection.

1. Commencez avec une fenêtre de script vide et copiez les lignes ci-dessous dans l'éditeur de code -
assurez-vous simplement de redessiner votre région d'étude (il s’agit des mêmes instructions
modifiées du script avec lequel vous avez travaillé). Exécutez le script.

// Get a collection.
var landsat8_collection = ee.ImageCollection('LANDSAT/LC08/C01/T1_TOA');
// Filter to scenes that intersect your boundary.
var landsat8_studyArea = landsat8_collection.filterBounds(studyArea);
// Filter to scenes for time period of interest.
var landsat8_SA_2021 = landsat8_studyArea.filterDate('2021-01-01', '2021-12-31');
print(landsat8_SA_2021, 'landsat8_SA_2021');

2. Ajoutez maintenant les instructions ci-dessous pour créer et afficher un composite médian. Dans
ces instruction on utilise la méthode de réduction de la collection d'images median(). Cela créera
un objet Image (image unique) représentant la valeur médiane dans chaque bande de toutes les
images de votre collection filtrée.

// Reduce the ImageCollection to get the median in each pixel.

var median_landsat8_2021 = landsat8_SA_2021.median();
print(median_landsat8_2021, 'median_landsat8_2021');
// Display the result and center the map on the study region.
Map.addLayer(median_landsat8_2021,
{ "min": 0.05, "max": 0.8, bands: ['B6', 'B5', 'B4']});
Map.centerObject(studyArea, 7);

3. Examinez le résultat et notez ce qui suit:

i. Regardez la sortie des instructions d'impression. Voyez-vous la différence entre
landsat8_SA_2021 et median_landsat8_2021 ? Notez : l'un est un objet de collection d'images,
l'autre est un objet image (single raster).
ii. Vous pouvez désactiver l'affichage de votre région d'étude en désactivant la couche dans la
case Imports géométriques située dans la partie supérieure gauche de l'écran de la carte (voir la
figure suivante)
iii. L'image composite ne contient que les images Landsat référenciées par les PATH et
ROW(selon le système de référence mondial (WRS) de notation pour les données Landsat) qui
croisent votre zone d'étude (faites un zoom arrière pour voir toute l'étendue).

iv. L'image est également relativement exempte de nuages puisque vous visualisez la valeur
médiane des pixels pour toutes les images de la collection. Y a-t-il encore des nuages ?
Même en utilisant un réducteur de médiane, il peut y avoir des pixels qui ressemblent à des nuages. Il
est préférable de masquer les nuages dans chaque image de la collection d'images avant d'exécuter le
réducteur médian. Pour ce faire, vous allez appliquer une fonction sur la collection d'image.

4. Enregistrez votre script, nommez-le 'Exercice 3 Image Collection Part 8'. Vous pourrez y revenir
plus tard dans l'exercice.

PARTIE 9: INITIATION AUX FONCTIONS (FUNCTIONS PRIMER)

Jusqu'à présent, nous avons appris à effectuer des calculs sur des images individuelles. Si vous
souhaitez appliquer un calcul - tel que le calcul d'un index - à plusieurs images, vous devez utiliser
map(). Vous définissez d'abord une fonction qui prend une image et renvoie le résultat du calcul sur
cette image. Vous pouvez ensuite appliquer la fonction map() sur la collection d'images, ce qui donne
lieu à une nouvelle collection d'images contenant les résultats du calcul. C'est similaire à une for-loop
que vous connaissez peut-être, mais l'utilisation de map() permet d'exécuter le calcul en parallèle.
Pour en savoir plus, consultez le site Mapping over an ImageCollection.

En effet, au fur et à mesure que vous développez votre script, il peut commencer à devenir assez long.
Pour le garder organisé et créer un code plus efficace, vous pouvez réutiliser les pièces que vous avez
construites en tirant parti des fonctions. Les fonctions divisent votre code en morceaux séparés,
enveloppent ces morceaux et leur donnent un nom que vous pouvez appeler pour l'appliquer plus tard
en cas de besoin. Les fonctions sont essentiellement des morceaux modulaires de code réutilisables.
Par exemple, vous pouvez avoir une fonction pour obtenir le ou les ensembles de données d'intérêt,
une pour les analyser et enfin une autre pour les exporter. Vous pouvez diviser le code en trois parties
– chacune enveloppée comme une fonction.

Les fonctions sont également très utiles lorsque vous avez une série d'instructions que vous souhaitez
répéter plusieurs fois dans le code. Par exemple, supposons que vous vouliez calculer la moyenne des
données ou l'indice de végétation de différence normalisée (NDVI) d'une série de rasters. Vous pouvez
créer une fonction que vous pouvez appeler chaque fois que vous souhaitez exécuter l'un de ses
éléments dans votre code, plutôt que d'avoir à réécrire ces éléments à chaque fois.

A. Structure
Voici comment les fonctions sont construites:
i. var: déclare une variable dans laquelle stocker la fonction.
ii. functionName: Le mot fonction est suivi du nom que vous souhaitez donner à la fonction. Vous
pouvez nommer la fonction comme vous le souhaitez, les mêmes règles et suggestions de style sur la
façon de nommer les variables s'appliquent à la dénomination des fonctions (le nom ne peut pas
commencer par un nombre, il doit être descriptif de ce que la fonction fait, etc). Faites-le suivre d'un
signe égal.
iii. = function: Indiquez que la nouvelle variable est un objet de fonction. Écrivez le mot function
JavaScript, le tout en lettres minuscules.

iv. Input parameters: Après le mot fouction, ajoutez une parenthèse ouverte et une parenthèse
fermée. Ils seront remplis avec l'ensemble des paramètres d'entrée que l'utilisateur passe à la fonction,
ou laissés vides pour les fonctions qui n'ont pas de paramètres. Un paramètre d'entrée est un élément
d'information (il peut être stocké dans une variable) qui est transmis à la fonction lorsqu'elle est
appelée. Si vous souhaitez inclure plusieurs paramètres, séparez-les par des virgules. Par exemple,
pour créer une fonction permettant de calculer le NDVI d'une image, on doit définir l'image sur
laquelle vous calculez le NDVI comme paramètre d'entrée.

v. Curly brackets (Accolades): après les parenthèses contenant les paramètres d'entrée, ajoutez une
accolade ouverte et une accolade fermée.

vi. Code: Écrivez le code ou plusieurs codes que vous souhaitez exécuter dans votre fonction (une
instruction ou des centaines de lignes) entre les accolades ouvertes et fermées.
vi. Call the function (Appeler la fonction): Une fois que vous avez créé une fonction, elle ne
s'exécute que si vous l'appelez. Pour utiliser la fonction dans votre code, écrivez le nom de la fonction,
suivi de parenthèses à l'intérieur desquelles insérer les paramètres d'entrée requis, et terminez la
déclaration par un point-virgule.

var functionName = function(parameter_1, parameter_2){

// code to execute
// more code to execute
// …
}
// call the function
var storeOutput = functionName(input_1, input_2);

Il s'agit de la structure de base d'une fonction. Si cela vous semble compliqué, ne vous inquiétez pas,
tout prendra sens lorsque vous en écrirez une vous-même. Ci-dessous, vous allez vous entraîner en
créant une simple fonction calculate_sum.

Note : La convention commune déclare et spécifie (toutes) les fonctions en premier, puis les appelle
plus tard dans le script. Ce n'est pas obligatoire, mais cela rend le code plus facile à lire.

B. Créer une fonction pour calculer la somme des nombres

1. Ouvrez un nouvel espace de travail en effaçant l’ancien script. Ou ouvrez une nouvelle fenêtre sur :
code.earthengine.google.com.
2. Le code ci-dessous est un exemple de fonction qui calcule la somme de deux valeurs.
3. JavaScript utilise une instruction "return" pour renvoyer une valeur locale au programme principal.
4. En déclarant une variable et en lui attribuant la valeur de retour de la fonction, vous créez une
variable qui peut être utilisée ailleurs dans le script.
 var calculate_sum = function(in_value1, in_value2) {
// Calculate the sum.
var sum = ee.Number(in_value1).add(ee.Number(in_value2));
// Return the sum.
return sum;
}
// Now declare a variable and set it to the value the function returns. (Maintenant, déclarez une
variable et donnez-lui la valeur que la fonction renvoie)
// Include two numbers to sum as the input parameters. (Inclure deux nombres à additionner
comme paramètres d'entrée.)
var sum_test = calculate_sum(75, 82);
print(sum_test);

5. Une fois qu'une fonction a été créée, vous pouvez l'appeler autant de fois que vous le souhaitez.
Appelez-la à nouveau avec de nouveaux paramètres. Donc, il suffit d’ajouter les deux chiffres de votre
choix et imprimez le résultat.

var sum_test2 = calculate_sum(790, 1.555);

print(sum_test2);

var sum_test3 = calculate_sum(133, 765);

print(sum_test3);

PARTIE 10 : Créer une fonction de masque de nuage

Rappelez-vous dans l’exercice 2, vous avez appris à masquer les nuages. Maintenant, vous allez
l’écrire comme une fonction que vous pouvez appeler plus tard dans le script.
A. Ajouter des instructions de masquage des nuages à partir de l’exercice 2
1. Copiez et collez les lignes ci-dessous dans une fenêtre d'éditeur de code vide.
i. Le contenu devrait sembler familier, car c'est le processus que vous avez appris à l'exercice
2 pour masquer les nuages.
ii. nommer la fonction : le mot var et le nom de la variable enregistrent la fonction en tant
qu'objet auquel vous pouvez vous référer plus tard, « maskclouds ».
iii. function () indique que la variable maskClouds est un type d'objet function.
iv. Mettez en retrait toutes les lignes (le ou les codes à exécuter) de la fonction pour faciliter la
lecture.
v. l’instruction "return" va permettre à travers la méthode updateMask (cloudPixels) de
renvoyer l’image d’entrée (image) après l’avoir masquée par l’image cloudPixels qui constitue
le masque (non valide = 0, valide = 1).

// Get an image.
var lc8_image = ee.Image('LANDSAT/LC08/C01/T1_TOA/LC08_201036_20210520');
// Specify the cloud likelihood threshold.
var cloud_thresh = 40;
// Create the cloud masking function.
var maskClouds = function(image){
// Add the cloud likelihood band to the image.
var cloudScore = ee.Algorithms.Landsat.simpleCloudScore(image);
// Isolate the cloud likelihood band.
var cloudLikelihood = cloudScore.select('cloud');
// Compute a mask in which pixels below the threshold are 1. (Calculer un masque dans lequel les
pixels inférieurs au seuil sont 1)
var cloudPixels = cloudLikelihood.lt(cloud_thresh);
// Mask these pixels from the input image. ( Masquer ces pixels à partir de l’image d’entrée)
// Return the masked input image. (Renvoyer l’image d’entrée masquée par cloudPixels)
Enregistrez votre script sous "exercice 3_cloudmaskfunction".

PARTIE 11 : Fonctions de Cartographie à Travers les Collections d'Images

Maintenant que vous savez que la fonction fonctionne, appliquez-la à la collection d'images que vous
avez créée dans la première moitié de cet exercice à l'aide de map().
1. Remplacez lc8_image par la collection d'images filtrées dans le script. Voir l'exemple complet ci-
dessous.

// Get a collection.
var landsat8_collection = ee.ImageCollection('LANDSAT/LC08/C01/T1_TOA');
// Filter to scenes that intersect your boundary.
var landsat8_studyArea = landsat8_collection.filterBounds(studyArea);
// Filter to scenes for time period of interest.
var landsat8_SA_2021 = landsat8_studyArea.filterDate('2021-01-01', '2021-12-31');
// Specify the cloud likelihood threshold.
var cloud_thresh = 40;
// Create the cloud masking function.
var maskClouds = function(image){
// Add the cloud likelihood band to the image.
var cloudScore = ee.Algorithms.Landsat.simpleCloudScore(image);
// Isolate the cloud likelihood band.
var cloudLikelihood = cloudScore.select('cloud');
// Compute a mask in which pixels below the threshold are 1.
var cloudPixels = cloudLikelihood.lt(cloud_thresh);
// Mask these pixels from the input image.
// Return the masked input image.
return image.updateMask(cloudPixels);
};

2. Ajoutez maintenant une instruction qui fait correspondre la fonction à la collection d'images.
Ajoutez ensuite la collection d'images avec les nuages masqués à l'affichage de la carte. Voir
l'exemple de déclaration de carte ci-dessous.

// Mask the clouds from all images in the image collection

// with the map function.
var landsat8_SA_2021NoClouds = landsat8_SA_2021.map(maskClouds);
// Add the first masked image in the collection to the map window.
Map.addLayer(ee.Image(landsat8_SA_2021NoClouds.first()),
{min:0.05, max: 0.8, bands: 'B6, B5, B4'},
'first image with clouds masked');
// Center your map.
Map.centerObject(studyArea, 7);

3. Utilisez un réducteur médian sur la collection d'images landsat8_sa_2021noclouds que vous venez
de créer pour agréger les informations de toutes les images de la collection. Voir l'exemple de code ci-
dessous.

// Reduce the collection to the median value per pixel.

var median_L8_2021 = landsat8_SA_2021NoClouds.median();
// Print the information of the reduced image.
print(median_L8_2021, 'median_L8_2021');
EXERCICE 4: EXPORTATION DE DONNEES

Introduction
Dans les exercices précédents, vous avez travaillé avec des données et généré de nouvelles sorties
entièrement via l'éditeur de code GEE. Un avantage majeur du cloud computing est la possibilité
d'accomplir des tâches complexes avec la charge de calcul et le stockage de données déplacés vers le
cloud; cependant, pour de nombreuses applications, vous voudrez exporter et enregistrer vos résultats
à un moment donné. Dans cet exercice, vous apprendrez à utiliser l'éditeur de code pour exporter des
résultats que vous pouvez enregistrer, partager et utiliser dans vos analyses SIG sur votre bureau.

Objectifs
Apprenez à exporter des résultats et des images,
Exportez des données à partir d'un script de traitement d'image complet pour obtenir des données
utiles.

PARTIE 1 : CHARGEZ CERTAINES IMAGES QUE VOUS SOUHAITEZ

EXPORTER
Pour cette exportation, vous exporterez un sous-ensemble des données de hauteur de canopée de 2005
dérivées des données lidar spatiales du Geoscience Laser Altimeter System (GLAS) et des données
géospatiales auxiliaires.

1. Copiez et collez les instructions suivantes dans un panneau d'éditeur de code vide. Cliquez sur Run
pour explorer l'ensemble de données.

// Stockez l'image de la hauteur de la canopée en tant que variable, canopyheight.

var canopyHeight = ee.Image("NASA/JPL/global_forest_canopy_height_2005");
// Ajouter les données à la fenêtre de la carte.
Map.addLayer(canopyHeight, {min: 0, max: 36, palette: ['FFFFFF', '00FF00']}, 'canopy height');
Map.setCenter(-5, 34.5, 7);

2. Ensuite, utilisez les outils de dessin pour dessiner un petit polygone qui représente la région pour
laquelle vous souhaitez extraire les données de hauteur de canopée. Reportez-vous à l'exercice 3,
partie 2 si vous avez besoin d'un rappel sur comment numériser une géométrie. N'oubliez pas : plus le
polygone est petit, plus le temps de téléchargement est rapide.
PARTIE2 : (FACULTATIF) GENERER UN HISTOGRAMME
1. Vous trouverez ci-dessous le script permettant de générer un histogramme de la hauteur de la
canopée sur la région d'étude que vous venez de numériser. Copiez et collez-la dans votre panneau
d'édition de code pour étudier la gamme des hauteurs de la canopée dans votre région d'étude.

// Générer les données d'histogramme.

var canopyHeightHistogram = Chart.image.histogram(canopyHeight, geometry) .setOptions({title:
'Histogram of Canopy Height'});
// Afficher l'histogramme.
print(canopyHeightHistogram);

B. Exportation des Données

L'exportation de données à partir de l'éditeur de code est possible grâce aux fonctions d'exportation,
qui incluent des options d'exportation pour les images, les tableaux et les vidéos. Vous vous
concentrerez sur Export.image.toDrive() pour télécharger vos ensembles de données d'imagerie. Vous
pouvez également exporter vos images en tant qu'actif ou vers le stockage Google Cloud.
Les méthodes d'exportation prennent plusieurs arguments facultatifs afin que vous puissiez contrôler
les caractéristiques importantes de vos données de sortie, telles que la résolution et la projection.

C. Examiner la documentation pour Export.image.toDrive()

1. Sous l'onglet Docs, accédez à et ouvrez la documentation de la fonction Export.image.toDrive(),
logée dans le groupe Export. Passez en revue la documentation.

D. Créer une tâche d'exportation

Ajoutez les déclarations ci-dessous au bas de votre script. Cela créera une tâche dans l'onglet des
tâches que vous pourrez utiliser pour exporter votre image. Les images sont exportées dans votre
Google Drive. Reportez-vous à la zone de texte ci-dessous pour une discussion des paramètres
spécifiés ici.
// Exportez l'image sur votre Google Drive.
Export.image.toDrive({
image: canopyHeight,
description: "MyFirstExport",
maxPixels: 1e8,
region: geometry,
crs: 'EPSG:32647',
scale: 1000
});
 Note – Dans cet exemple, vous avez spécifié quelques-uns des arguments optionnels reconnus par
Export.image(). Bien que cette fonction prenne plusieurs paramètres facultatifs, il est utile de vous
familiariser avec ceux-ci:
maxPixels-Cela limite le nombre de pixels dans l'image exportée. Par défaut, cette valeur est définie
sur 10 000 000 pixels. Vous pouvez définir cet argument pour augmenter ou abaisser la limite.
“1e8” est de 10 à la 8ème puissance (10^8).

région-Par défaut, la fenêtre d'affichage de l'éditeur de code est exportée, mais vous pouvez
également spécifier une géométrie pour modifier l'étendue de l'exportation.

crs - Le système de référence de coordonnées pour l'image de sortie. Ceci est spécifié à l'aide du
code EPSG. Vous pouvez rechercher le code EPSG pour vos projections spatiales souhaitées à
http://spatialreference.org.

scale-La résolution en mètres par pixel. La résolution native de l'ensemble de données sur la
hauteur de la canopée est de 30 secondes d'arc, soit environ un kilomètre.

E. Exécutez la tâche pour exporter une image sur Google Drive Google Drive

Note: Google Drive est un lieu de maintien temporaire pour toutes les données que vous pouvez
télécharger.

1. Exécutez le script. Après un moment, l'onglet Tasks dans le coin supérieur droit de l'éditeur de code
doit être mis en évidence.

2. Cliquez sur l'onglet Tâches. Cliquez ensuite sur le bouton Blue Run (affiché ci-dessous) pour
exporter les données sur votre Google Drive..

3. Passez en revue les informations dans la fenêtre d'initiation d'exportation qui apparaît (ci-dessous).
Puis cliquez sur Run pour commencer.

Note: cette tâche sera exportée vers votre lecteur Google sous votre compte Google. Ce sera une
image GeoTiff de 1000 mètres de résolution avec le nom root MyFirstExport..

4. Une fois que vous avez cliqué sur Exécuter en bas de la fenêtre d'exportation initiale pour lancer
l'exportation, votre écran affiche l'exportation est en cours de traitement. La tâche dans le cadre de
l'onglet Tâches de l'éditeur de code doit maintenant avoir une icône GEE filant à côté. Cela peut
prendre un certain temps pour exporter la tâche. Lorsqu'elle est terminée, cette icône disparaîtra et le
nom de la tâche deviendra bleu. Regardez pour voir si le vôtre est devenu bleu.

Note: Si vous essayez d'exporter la scène LandSat sans premier sous-réglage de l'image pour
obtenir uniquement les bandes d'intérêt, vous obtiendrez un message d'erreur.
F. Examiner le résultat
1. Une fois l'exportation terminée, accédez à votre Google Drive en utilisant le lien ci-dessous:
https://drive.google.com/drive/my-drive/

2. Localisez les nouvelles images, appelées quelque chose de similaire à MyFirstExport-0000000000-

0000000000.tif, dans votre Google Drive.
3. Facultatif-Téléchargez l'une des images et visualisez-la dans votre logiciel SIG préféré (par
exemple, ArcMap ou QGIS).

Note-Une fois que vos données ont été exportées avec succès vers votre Google Drive, vous pouvez
les télécharger et les consulter dans votre logiciel SIG préféré. Les temps d'exportation peuvent
varier en fonction de la taille de vos données ainsi que de l'heure de la journée et de ce que les
autres utilisateurs demandent à Google Earth Engine.

Google Drive Data Management Note -Après avoir téléchargé les données de votre Google Drive,
vous pouvez envisager de les supprimer de votre Google Drive pour économiser de l'espace (en
fonction de la capacité de stockage de votre compte).

Assurez-vous qu'après les avoir placés dans la corbeille Google Drive, vous allez également et videz
votre corbeille pour vraiment libérer cet espace.

G. Enregistrez le script complet sur votre compte GEE

1. Cliquez sur le bouton Enregistrer dans la fenêtre de l'éditeur de code.
2. Entrez un nouveau nom ou acceptez le nom par défaut et cliquez sur le bouton ok.

Note -L'exemple ci-dessus met en évidence une tâche qui sera exportée vers votre Google Drive
sous votre compte Google. Chaque téléchargement sera une image GeoTIFF de résolution de 30
mètres. Pour la zone composite de Palawan, chaque composite exporté sera d'environ 370 Mo.
Assurez-vous d'avoir de la place sur votre Google Drive! Si nécessaire, supprimer et vider la
corbeille pour faire plus de place.
H : Exécutez la tâche pour exporter un composite Sentinel-2 sur Google Drive Google
Drive
Earth Engine permet d'exporter des données vectorielles et matricielles pour les utiliser dans un
programme externe. Les données vectorielles peuvent être exportées sous forme de CSV ou de
Shapefile, tandis que les données raster peuvent être exportées sous forme de fichiers GeoTIFF. Nous
allons maintenant exporter le composite Sentinel-2 sous forme de fichier GeoTIFF.
var geometry = ee.FeatureCollection("users/abdelilahenfighallab/CantonA_Mamora");
var s2 = ee.ImageCollection("COPERNICUS/S2")
var rgbVis = {
min: 0.0,
max: 3000,
bands: ['B4', 'B3', 'B2'],
};
var filtered = s2.filter(ee.Filter.lt('CLOUDY_PIXEL_PERCENTAGE', 30))
.filter(ee.Filter.date('2019-01-01', '2020-01-01'))
.filter(ee.Filter.bounds(geometry))

var image = filtered.median();

var clipped = image.clip(geometry)
Map.addLayer(clipped, rgbVis, 'Clipped')
var exportImage = clipped.select('B.*')
Export.image.toDrive({
image: exportImage,
description: 'Mamora_Composite_Raw',
folder: 'earthengine',
fileNamePrefix: 'Mamora_Composite_Raw',
region: geometry,
scale: 20,
maxPixels: 1e9
})
// Rather than exporting raw bands, we can apply a rendered image
// visualize() function allows you to apply the same parameters
// that are used in earth engine which exports a 3-band RGB image
print(clipped)
var visualized = clipped.visualize(rgbVis)
print(visualized)
// Now the 'visualized' image is RGB image, no need to give visParams
Map.addLayer(visualized, {}, 'Visualized Image')

Export.image.toDrive({
image: visualized,
description: 'Mamora_Composite_Raw',
folder: 'earthengine',
fileNamePrefix: 'Mamora_Composite_Raw',
region: geometry,
scale: 20,
maxPixels: 1e9
})