Earth Engine est conçu pour que vous n'ayez que rarement à vous soucier des projections cartographiques lorsque vous
effectuez des calculs. Comme pour l'échelle, la projection dans laquelle les calculs ont lieu est
déterminée sur une base "pull". Plus précisément, les entrées sont demandées dans la projection de sortie. La sortie peut être déterminée à partir d'un paramètre de fonction (par exemple, crs), objets cartographiques de l'éditeur de code et de geemap (qui ont une projection Mercator de cartes (EPSG:3857)), ou avec un appel reproject(). Lorsque vous
affichez des images dans l'éditeur de code ou geemap, les entrées sont demandées dans
Mercator de cartes. Considérez l'opération suivante sur une image MODIS, qui a une projection sinusoïdale :
Éditeur de code (JavaScript)
// The input image has a SR-ORG:6974 (sinusoidal) projection. var image = ee.Image('MODIS/061/MOD13A1/2014_05_09').select(0); // Normalize the image and add it to the map. var rescaled = image.unitScale(-2000, 10000); var visParams = {min: 0.15, max: 0.7}; Map.addLayer(rescaled, visParams, 'Rescaled');
import ee import geemap.core as geemap
Colab (Python)
# The input image has a SR-ORG:6974 (sinusoidal) projection. image = ee.Image('MODIS/061/MOD13A1/2014_05_09').select(0) # Normalize the image and add it to the map. rescaled = image.unitScale(-2000, 10000) vis_params = {'min': 0.15, 'max': 0.7} m = geemap.Map() m.add_layer(rescaled, vis_params, 'Rescaled') m
L'ordre des opérations pour cet exemple de code est illustré à la figure 1. Note que la projection de l'entrée est déterminée par la sortie, en particulier la projection Mercator de cartes de l'affichage cartographique dans l' éditeur de code. Cette projection se propage dans la séquence d'opérations de sorte que les entrées sont demandées dans Mercator de cartes, à une échelle déterminée par le niveau de zoom de la carte.
Dans Earth Engine, les projections sont spécifiées par un système de référence de coordonnées (CRS ou
le crs paramètre de nombreuses méthodes). Vous pouvez vérifier la projection d'une
image en appelant projection() sur celle-ci :
Éditeur de code (JavaScript)
var image = ee.Image('LANDSAT/LC08/C02/T1_TOA/LC08_044034_20140318').select(0); print('Projection, crs, and crs_transform:', image.projection()); print('Scale in meters:', image.projection().nominalScale());
import ee import geemap.core as geemap
Colab (Python)
image = ee.Image('LANDSAT/LC08/C02/T1_TOA/LC08_044034_20140318').select(0) display('Projection, crs, and crs_transform:', image.projection()) display('Scale in meters:', image.projection().nominalScale())
Notez qu'en appelant nominalScale() sur ee.Projection renvoyé
par projection(), vous pouvez déterminer la résolution native de l'image. La
résolution native est l'échelle de pixels nominale en mètres du niveau le plus bas de la
pyramide d'images. Étant donné que chaque bande d'une image peut avoir une
échelle et/ou une projection différentes, si vous appelez projection() sur une image
comportant au moins une bande qui n'a pas la même projection que les autres, vous pouvez voir une
erreur semblable à celle-ci :
Projection par défaut
Sauf si vous avez besoin que votre calcul se produise dans une projection spécifique, il n'est généralement
pas nécessaire de spécifier une projection. Ce n'est que pour les sorties ambiguës qu'Earth Engine
vous demandera de spécifier une projection et/ou une échelle. L'ambiguïté peut résulter de la
réduction d'une ImageCollection contenant des images avec des projections différentes
(c'est-à-dire la création d'une composition). Une image qui est une
composition ou une mosaïque d'images d'entrée avec des projections différentes aura la projection par défaut, qui est WGS84 avec une échelle de 1 degré.
Si cette projection par défaut ne convient pas à votre analyse (par exemple, si elle est trop
grossière ou si vous devez éviter les artefacts de rééchantillonnage dans les calculs en aval, comme l'analyse du terrain), vous pouvez définir une autre valeur par défaut à l'aide de
image.setDefaultProjection(crs). Cela garantit que si Earth
Engine doit choisir une projection pour un calcul impliquant l'image,
il utilisera celle spécifiée, plutôt que WGS84 à l'échelle de 1 degré.
Exemple :
Éditeur de code (JavaScript)
var collection = ee.ImageCollection('LANDSAT/LC08/C02/T1_TOA'); var mosaic = collection.filterDate('2018-01-01', '2019-01-01').mosaic(); print(mosaic.projection());
import ee import geemap.core as geemap
Colab (Python)
collection = ee.ImageCollection('LANDSAT/LC08/C02/T1_TOA') mosaic = collection.filterDate('2018-01-01', '2019-01-01').mosaic() display(mosaic.projection())
Si vous essayez d'utiliser une image comme celle-ci dans un calcul, vous pouvez voir une erreur semblable à celle-ci :
En règle générale, une agrégation à l'échelle de 1 degré n'est pas souhaitée ni prévue. Earth Engine vous rappelle donc de fournir une spécification complète pour la sortie.
Les utilisateurs trouvent souvent ce comportement déroutant et s'inquiètent des informations de projection "perdues" . Toutefois, les pixels ne sont pas calculés tant qu'ils ne sont pas nécessaires (en savoir plus). À ce stade, il existe toujours une projection de sortie qui accompagne la requête spécifiant comment calculer la composition.
Dans la grande majorité des cas d'utilisation, l'absence de projection ne pose pas de problème et constitue même une optimisation intéressante, car elle permet de prévisualiser les résultats à n'importe quel niveau de zoom sans avoir à attendre la fin du calcul en pleine résolution Toutefois, cela signifie que la sortie peut apparaître différemment à différents niveaux de zoom.
Si l'image d'affichage optimisée ne suffit pas, le calcul dans une projection spécifique peut être forcé en reprojetant la sortie, comme décrit dans la section suivante.
Reprojection
Vous pouvez forcer l'exécution des opérations dans une projection spécifique à l'aide de la
reproject() méthode. L'utilisation de reproject() entraîne la demande des entrées
étant demandées dans la projection spécifiée dans l'appel reproject().
Les calculs dans votre code avant l'appel reproject() seront effectués
dans la projection spécifiée. Par exemple, pour forcer la production d'une composition dans une
projection spécifique :
Éditeur de code (JavaScript)
// Some projection that is suitable for your area of interest. var proj = ee.Projection(...); var output = collection.reduce(...).reproject(proj);
import ee import geemap.core as geemap
Colab (Python)
# Some projection that is suitable for your area of interest. proj = ee.Projection(...) output = collection.reduce(...).reproject(proj)
Voici quelques cas qui nécessitent une projection fixe :
- Calcul des gradients (par exemple,
ee.Terrain.gradientouee.Terrain.slope). reduceResolution, lorsque vous souhaitez agréger des pixels de résolution supérieure pixels en résolution inférieure. (En savoir plus sur la réduction de la résolution).
Les fonctions du package ee.Terrain (par exemple, slope,
aspect, hillshade) calculent les valeurs en fonction des pixels voisins et sont sensibles aux artefacts de rééchantillonnage introduits lors de la reprojection. Lorsque la projection du calcul diffère de la projection native du MNT, le rééchantillonnage par défaut du voisin le plus proche peut créer
des motifs artificiels dans la sortie. Pour de meilleurs résultats, effectuez l'analyse du terrain
dans la projection native du MNT. Si vous utilisez une
ImageCollection de tuiles MNT, créez une mosaïque et utilisez
setDefaultProjection() avec la projection native de la collection pour vous assurer que l'analyse s'exécute sur la grille appropriée, comme décrit
dans la section Projection par défaut.
Il existe plusieurs raisons pour lesquelles vous devez éviter d'utiliser reproject() sauf si vous
en avez absolument besoin. Supposons, par exemple, que vous reprojetiez quelque chose et que vous l'ajoutiez à la
carte. Si l'échelle que vous avez spécifiée dans l'appel reproject() est beaucoup plus petite
que le niveau de zoom de la carte, Earth Engine demandera toutes les entrées à une très petite
échelle, sur une très large étendue spatiale. Cela peut entraîner une demande de données beaucoup trop importante à la fois et générer une erreur.
Si la sortie finale se trouve dans une projection différente de celle spécifiée dans le
reproject() appel, cela entraînera une autre reprojection. C'est
une autre raison d'être prudent quant à l'utilisation de reproject() dans votre code. Considérez
l'exemple suivant, qui force la reprojection de l'image MODIS vers
WGS84, puis vers
Mercator de cartes pour l'affichage dans la carte de l'éditeur de code :
Éditeur de code (JavaScript)
// The input image has a SR-ORG:6974 (sinusoidal) projection. var image = ee.Image('MODIS/061/MOD13A1/2014_05_09').select(0); // Operations *before* the reproject call will be done in the projection // specified by reproject(). The output results in another reprojection. var reprojected = image .unitScale(-2000, 10000) .reproject('EPSG:4326', null, 500); Map.addLayer(reprojected, {min: 0.15, max: 0.7}, 'Reprojected');
import ee import geemap.core as geemap
Colab (Python)
# The input image has a SR-ORG:6974 (sinusoidal) projection. image = ee.Image('MODIS/061/MOD13A1/2014_05_09').select(0) # Operations *before* the reproject call will be done in the projection # specified by reproject(). The output results in another reprojection. reprojected = image.unitScale(-2000, 10000).reproject('EPSG:4326', None, 500) m = geemap.Map() m.add_layer(reprojected, {'min': 0.15, 'max': 0.7}, 'Reprojected') m
La figure 2 illustre le flux d'opérations correspondant à cet exemple simple de reprojection
exemple. Notez que la première reprojection est explicite, comme spécifié dans l'
reproject() appel. La deuxième reprojection est implicite, effectuée automatiquement par
Earth Engine afin d'afficher le résultat sur la carte. Notez également que les
informations sur la projection à utiliser se propagent de la requête à l'entrée.
