Méthodes basées sur les objets

Exécuter dans Google Colab

Afficher la source sur GitHub

Les objets Image sont des ensembles de pixels connectés ayant la même valeur entière. Les données d'image catégorielles, groupées et booléennes sont adaptées à l'analyse d'objets.

Earth Engine propose des méthodes permettant d'étiqueter chaque objet avec un ID unique, de compter le nombre de pixels composant les objets et de calculer des statistiques sur les valeurs des pixels qui croisent les objets.

• connectedComponents(): attribuez un identifiant unique à chaque objet.
• connectedPixelCount(): calcule le nombre de pixels dans chaque objet.
• reduceConnectedComponents(): calcule une statistique pour les pixels de chaque objet.

Attention:Les résultats des méthodes basées sur les objets dépendent de l'échelle, qui est déterminée par:

• l'échelle demandée pour une sortie (par exemple, Export.image.toAsset() ou Export.image.toDrive()).
• fonctions nécessitant une échelle d'analyse (par exemple, reduceRegions() ou reduceToVectors()).
• Niveau de zoom de la carte.

Prêtez une attention particulière à l'échelle déterminée par le niveau de zoom de la carte. Les résultats des méthodes basées sur les objets varient lorsque vous affichez ou inspectez des calques d'images dans la carte, car chaque calque de pyramide a une échelle différente. Pour forcer une échelle d'analyse souhaitée dans l'exploration Map, utilisez reproject(). Toutefois, nous vous recommandons vivement de NE PAS utiliser reproject(), car l'ensemble de la zone visible sur la carte sera demandé à l'échelle et à la projection définies. À grande échelle, cela peut entraîner la demande de trop de données, ce qui déclenche souvent des erreurs. Dans l'architecture basée sur une pyramide d'images d'Earth Engine, l'échelle et la projection ne doivent être définies que pour les opérations qui fournissent scale et crs comme paramètres. Pour en savoir plus, consultez les pages Échelle d'analyse et Reprojection.

Points chauds thermiques

Les sections suivantes fournissent des exemples de méthodes basées sur des objets appliquées à la température de surface de Landsat 8, chaque section s'appuyant sur la précédente. Exécutez l'extrait suivant pour générer l'image de base: points chauds thermiques (> 303 degrés Kelvin) pour une petite région de San Francisco.

Éditeur de code (JavaScript)

// Make an area of interest geometry centered on San Francisco.
var point = ee.Geometry.Point(-122.1899, 37.5010);
var aoi = point.buffer(10000);

// Import a Landsat 8 image, subset the thermal band, and clip to the
// area of interest.
var kelvin = ee.Image('LANDSAT/LC08/C02/T1_TOA/LC08_044034_20140318')
  .select(['B10'], ['kelvin'])
  .clip(aoi);

// Display the thermal band.
Map.centerObject(point, 13);
Map.addLayer(kelvin, {min: 288, max: 305}, 'Kelvin');

// Threshold the thermal band to set hot pixels as value 1, mask all else.
var hotspots = kelvin.gt(303)
  .selfMask()
  .rename('hotspots');

// Display the thermal hotspots on the Map.
Map.addLayer(hotspots, {palette: 'FF0000'}, 'Hotspots');

Configuration de Python

Consultez la page Environnement Python pour en savoir plus sur l'API Python et l'utilisation de geemap pour le développement interactif.

import ee
import geemap.core as geemap

Colab (Python)

# Make an area of interest geometry centered on San Francisco.
point = ee.Geometry.Point(-122.1899, 37.5010)
aoi = point.buffer(10000)

# Import a Landsat 8 image, subset the thermal band, and clip to the
# area of interest.
kelvin = (
    ee.Image('LANDSAT/LC08/C02/T1_TOA/LC08_044034_20140318')
    .select(['B10'], ['kelvin'])
    .clip(aoi)
)

# Threshold the thermal band to set hot pixels as value 1, mask all else.
hotspots = kelvin.gt(303).selfMask().rename('hotspots')

# Define a map centered on Redwood City, California.
map_objects = geemap.Map(center=[37.5010, -122.1899], zoom=13)

# Add the image layers to the map.
map_objects.add_layer(kelvin, {'min': 288, 'max': 305}, 'Kelvin')
map_objects.add_layer(hotspots, {'palette': 'FF0000'}, 'Hotspots')

Figure 1. Température d'une région de San Francisco. Les pixels dont la température est supérieure à 303 degrés Kelvin sont représentés par la couleur rouge (points chauds thermiques).

Étiqueter des objets

L'étiquetage des objets est souvent la première étape de l'analyse des objets. Ici, la fonction connectedComponents() permet d'identifier les objets image et d'attribuer un ID unique à chacun d'eux. Tous les pixels appartenant à un objet se voient attribuer la même valeur d'ID entier. Le résultat est une copie de l'image d'entrée avec une bande "libellés" supplémentaire associant les pixels à une valeur d'ID d'objet en fonction de la connectivité des pixels dans la première bande de l'image.

Éditeur de code (JavaScript)

// Uniquely label the hotspot image objects.
var objectId = hotspots.connectedComponents({
  connectedness: ee.Kernel.plus(1),
  maxSize: 128
});

// Display the uniquely ID'ed objects to the Map.
Map.addLayer(objectId.randomVisualizer(), null, 'Objects');

Configuration de Python

Consultez la page Environnement Python pour en savoir plus sur l'API Python et l'utilisation de geemap pour le développement interactif.

import ee
import geemap.core as geemap

Colab (Python)

# Uniquely label the hotspot image objects.
object_id = hotspots.connectedComponents(
    connectedness=ee.Kernel.plus(1), maxSize=128
)

# Add the uniquely ID'ed objects to the map.
map_objects.add_layer(object_id.randomVisualizer(), None, 'Objects')

Notez que la taille maximale de la correction est définie sur 128 pixels. Les objets composés de plus de pixels sont masqués. La connectivité est spécifiée par un noyau ee.Kernel.plus(1), qui définit la connectivité à quatre voisins. Utilisez ee.Kernel.square(1) pour huit voisins.

Figure 2. Objets de points chauds thermiques libellés et stylisés à l'aide d'un ID unique.

Taille de l'objet

Nombre de pixels

Calculez le nombre de pixels composant les objets à l'aide de la méthode d'image connectedPixelCount(). Connaître le nombre de pixels d'un objet peut être utile pour masquer les objets par taille et calculer leur surface. L'extrait suivant applique connectedPixelCount() à la bande "labels" de l'image objectId définie dans la section précédente.

Éditeur de code (JavaScript)

// Compute the number of pixels in each object defined by the "labels" band.
var objectSize = objectId.select('labels')
  .connectedPixelCount({
    maxSize: 128, eightConnected: false
  });

// Display object pixel count to the Map.
Map.addLayer(objectSize, null, 'Object n pixels');

Configuration de Python

Consultez la page Environnement Python pour en savoir plus sur l'API Python et l'utilisation de geemap pour le développement interactif.

import ee
import geemap.core as geemap

Colab (Python)

# Compute the number of pixels in each object defined by the "labels" band.
object_size = object_id.select('labels').connectedPixelCount(
    maxSize=128, eightConnected=False
)

# Add the object pixel count to the map.
map_objects.add_layer(object_size, None, 'Object n pixels')

connectedPixelCount() renvoie une copie de l'image d'entrée, où chaque pixel de chaque bande contient le nombre de voisins connectés selon la règle de connectivité à quatre ou huit voisins déterminée par un argument booléen transmis au paramètre eightConnected. Notez que la connectivité est déterminée indépendamment pour chaque bande de l'image d'entrée. Dans cet exemple, une image à bande unique (objectId) représentant l'ID de l'objet a été fournie en entrée. Une image à bande unique a donc été renvoyée avec une bande "labels" (présente en tant que telle dans l'image d'entrée), mais les valeurs représentent désormais le nombre de pixels composant les objets. Chaque pixel de chaque objet aura la même valeur de nombre de pixels.

Figure 3. Objets de zone chaude thermique libellés et stylisés en fonction de la taille.

Zone

Calculez la surface de l'objet en multipliant la surface d'un seul pixel par le nombre de pixels composant un objet (déterminé par connectedPixelCount()). La surface des pixels est fournie par une image générée à partir de ee.Image.pixelArea().

Éditeur de code (JavaScript)

// Get a pixel area image.
var pixelArea = ee.Image.pixelArea();

// Multiply pixel area by the number of pixels in an object to calculate
// the object area. The result is an image where each pixel
// of an object relates the area of the object in m^2.
var objectArea = objectSize.multiply(pixelArea);

// Display object area to the Map.
Map.addLayer(objectArea,
             {min: 0, max: 30000, palette: ['0000FF', 'FF00FF']},
             'Object area m^2');

Configuration de Python

Consultez la page Environnement Python pour en savoir plus sur l'API Python et l'utilisation de geemap pour le développement interactif.

import ee
import geemap.core as geemap

Colab (Python)

# Get a pixel area image.
pixel_area = ee.Image.pixelArea()

# Multiply pixel area by the number of pixels in an object to calculate
# the object area. The result is an image where each pixel
# of an object relates the area of the object in m^2.
object_area = object_size.multiply(pixel_area)

# Add the object area to the map.
map_objects.add_layer(
    object_area,
    {'min': 0, 'max': 30000, 'palette': ['0000FF', 'FF00FF']},
    'Object area m^2',
)

Le résultat est une image dans laquelle chaque pixel d'un objet indique la surface de l'objet en mètres carrés. Dans cet exemple, l'image objectSize contient une seule bande. S'il s'agissait d'une image multibande, l'opération de multiplication serait appliquée à chaque bande de l'image.

Filtrer les objets par taille

La taille de l'objet peut être utilisée comme condition de masquage pour concentrer votre analyse sur des objets d'une certaine taille (par exemple, masquer les objets trop petits). Ici, l'image objectArea calculée à l'étape précédente est utilisée comme masque pour supprimer les objets dont la superficie est inférieure à un hectare.

Éditeur de code (JavaScript)

// Threshold the `objectArea` image to define a mask that will mask out
// objects below a given size (1 hectare in this case).
var areaMask = objectArea.gte(10000);

// Update the mask of the `objectId` layer defined previously using the
// minimum area mask just defined.
objectId = objectId.updateMask(areaMask);
Map.addLayer(objectId, null, 'Large hotspots');

Configuration de Python

Consultez la page Environnement Python pour en savoir plus sur l'API Python et l'utilisation de geemap pour le développement interactif.

import ee
import geemap.core as geemap

Colab (Python)

# Threshold the `object_area` image to define a mask that will mask out
# objects below a given size (1 hectare in this case).
area_mask = object_area.gte(10000)

# Update the mask of the `object_id` layer defined previously using the
# minimum area mask just defined.
object_id = object_id.updateMask(area_mask)
map_objects.add_layer(object_id, None, 'Large hotspots')

Le résultat est une copie de l'image objectId dans laquelle les objets de moins d'un hectare sont masqués.

Figure 4a. Objets de points chauds thermiques libellés et stylisés par identifiant unique.	Figure 4b. Objets de point chaud thermique filtrés par superficie minimale (1 hectare).

Statistiques zonales

La méthode reduceConnectedComponents() applique un réducteur aux pixels composant des objets uniques. L'extrait suivant l'utilise pour calculer la température moyenne des objets hotspot. reduceConnectedComponents() nécessite une image d'entrée avec une bande (ou plusieurs bandes) à réduire et une bande qui définit les libellés d'objet. Ici, la bande d'image "libellés" objectID est ajoutée à l'image de température kelvin pour créer une image d'entrée appropriée.

Éditeur de code (JavaScript)

// Make a suitable image for `reduceConnectedComponents()` by adding a label
// band to the `kelvin` temperature image.
kelvin = kelvin.addBands(objectId.select('labels'));

// Calculate the mean temperature per object defined by the previously added
// "labels" band.
var patchTemp = kelvin.reduceConnectedComponents({
  reducer: ee.Reducer.mean(),
  labelBand: 'labels'
});

// Display object mean temperature to the Map.
Map.addLayer(
  patchTemp,
  {min: 303, max: 304, palette: ['yellow', 'red']},
  'Mean temperature'
);

Configuration de Python

Consultez la page Environnement Python pour en savoir plus sur l'API Python et l'utilisation de geemap pour le développement interactif.

import ee
import geemap.core as geemap

Colab (Python)

# Make a suitable image for `reduceConnectedComponents()` by adding a label
# band to the `kelvin` temperature image.
kelvin = kelvin.addBands(object_id.select('labels'))

# Calculate the mean temperature per object defined by the previously added
# "labels" band.
patch_temp = kelvin.reduceConnectedComponents(
    reducer=ee.Reducer.mean(), labelBand='labels'
)

# Add object mean temperature to the map and display it.
map_objects.add_layer(
    patch_temp,
    {'min': 303, 'max': 304, 'palette': ['yellow', 'red']},
    'Mean temperature',
)
display(map_objects)

Le résultat est une copie de l'image d'entrée sans la bande utilisée pour définir les objets, où les valeurs de pixel représentent le résultat de la réduction par objet et par bande.

Figure 5. Pixel de l'objet hotspot thermique résumé et stylisé en fonction de la température moyenne.

Remarque :reduceToVectors() fournit une fonctionnalité similaire, sauf que le résultat est un ee.FeatureCollection, où chaque élément géographique de la collection représente un objet et que la réduction des pixels de chaque objet est exprimée en tant que propriété d'élément géographique pour chaque bande de l'image d'entrée. reduceToVectors() est gourmand en ressources. Utilisez donc reduceConnectedComponents() dans la mesure du possible. Pour en savoir plus, consultez la section Conversion de raster en vecteur.