Évolutivité

Comprendre comment Earth Engine gère l'échelle est essentiel pour interpréter les résultats scientifiques obtenus avec Earth Engine. Ici, l'échelle correspond à la résolution en pixels. Contrairement aux autres plates-formes SIG et de traitement d'images, l'échelle d'analyse est déterminée à partir de la sortie, et non de l'entrée. Plus précisément, lorsque vous demandez des résultats, une image à afficher ou une statistique, par exemple, vous spécifiez l'échelle à laquelle les données sont saisies dans l'analyse. Ce concept est illustré dans la figure 1.

Pyramides d'images

Les éléments Image dans Earth Engine existent à plusieurs échelles, dans des pyramides d'images. La stratégie de pyramidage (représentée par des lignes en pointillés dans la figure 1) détermine comment chaque pixel à un niveau donné de la pyramide est calculé à partir de l'agrégation d'un bloc de pixels 2x2 au niveau inférieur. Pour les images à valeurs continues, les valeurs de pixel des niveaux supérieurs de la pyramide correspondent à la moyenne des pixels du niveau inférieur suivant. Pour les images à valeurs discrètes, les valeurs de pixel des niveaux supérieurs de la pyramide sont un échantillon (généralement le pixel en haut à gauche) des pixels du niveau inférieur suivant.

Le niveau le plus bas de la pyramide d'images représente les données d'image à la résolution native, lorsqu'elles sont ingérées dans Earth Engine. Lors de l'ingestion, les données sont agrégées (selon la règle de pyramidisation) pour créer des niveaux de pyramide plus élevés. Les données sont agrégées jusqu'à ce que l'image entière s'affiche dans une tuile de 256 x 256 pixels. Lorsque vous utilisez une image dans votre code, Earth Engine choisit un niveau de la pyramide dont l'échelle est la plus proche, inférieure ou égale à celle spécifiée par votre analyse, et effectue des reéchantillonnages (à l'aide du voisin le plus proche par défaut) si nécessaire.

Échelle d'analyse

L'échelle d'analyse dans Earth Engine est déterminée par "pull". L'échelle à laquelle demander des entrées pour un calcul est déterminée à partir de la sortie. Par exemple, si vous ajoutez une image à l'éditeur de code ou à l'élément de carte geemap, le niveau de zoom de la carte détermine l'échelle à laquelle les entrées sont demandées à la pyramide d'images. Pour les autres calculs, vous spécifiez scale comme argument. Par exemple, en utilisant la bande NIR d'une image Landsat, qui a une résolution native de 30 mètres:

var image = ee.Image('LANDSAT/LC08/C02/T1_TOA/LC08_044034_20140318').select('B4');

var printAtScale = function(scale) {
  print('Pixel value at '+scale+' meters scale',
    image.reduceRegion({
      reducer: ee.Reducer.first(),
      geometry: image.geometry().centroid(),
      // The scale determines the pyramid level from which to pull the input
      scale: scale
  }).get('B4'));
};

printAtScale(10); // 0.10394100844860077
printAtScale(30); // 0.10394100844860077
printAtScale(50); // 0.09130698442459106
printAtScale(70); // 0.1150854229927063
printAtScale(200); // 0.102478988468647
printAtScale(500); // 0.09072770178318024

import ee
import geemap.core as geemap

image = ee.Image('LANDSAT/LC08/C02/T1_TOA/LC08_044034_20140318').select('B4')


def print_at_scale(scale):
  display(
      f'Pixel value at {scale} meters scale',
      image.reduceRegion(
          reducer=ee.Reducer.first(),
          geometry=image.geometry().centroid(),
          # The scale determines the pyramid level from which to pull the input
          scale=scale,
      ).get('B4'),
  )


print_at_scale(10)  # 0.10394100844860077
print_at_scale(30)  # 0.10394100844860077
print_at_scale(50)  # 0.09130698442459106
print_at_scale(70)  # 0.1150854229927063
print_at_scale(200)  # 0.102478988468647
print_at_scale(500)  # 0.09072770178318024

Dans cet exemple, notez que la valeur des pixels à un emplacement constant (le centre de gravité de l'image) varie en fonction de l'échelle. Cela est dû au fait que différents niveaux de pyramide sont sélectionnés pour différentes échelles. Pour des échelles similaires, le reéchantillonnage par voisin le plus proche renvoie la même valeur de pixel. L'essentiel est qu'en faisant varier l'échelle, différentes entrées d'images sont demandées.

Lorsque vous visualisez une image en l'ajoutant à la carte, Earth Engine détermine l'échelle à partir du niveau de zoom. Prenons l'exemple simple suivant, qui affiche simplement une image Landsat:

var image = ee.Image('LANDSAT/LC08/C02/T1_TOA/LC08_044034_20140318');
Map.centerObject(image, 17);
Map.addLayer(image, {bands: ['B4', 'B3', 'B2'], max: 0.35}, 'image');

import ee
import geemap.core as geemap

image = ee.Image('LANDSAT/LC08/C02/T1_TOA/LC08_044034_20140318')
m = geemap.Map()
m.center_object(image, 17)
m.add_layer(image, {'bands': ['B4', 'B3', 'B2'], 'max': 0.35}, 'image')
m

La carte commence à être entièrement agrandie, de sorte que les pixels de la résolution native sont clairement visibles. Si vous faites un zoom arrière suffisamment important, les mêmes pixels ne s'affichent pas, mais des niveaux supérieurs de la pyramide d'images. Notez également que les cartes de l'éditeur de code et de geemap utilisent la projection maps mercator (EPSG:3857). Par conséquent, le niveau approprié de la pyramide d'images doit également être reprojeté avant l'affichage. Découvrez comment Earth Engine gère les projections dans le document sur les projections.