Los objetos de imagen son conjuntos de píxeles conectados que tienen el mismo valor entero. Los datos de imágenes categóricos, agrupados y booleanos son adecuados para el análisis de objetos.
Earth Engine ofrece métodos para etiquetar cada objeto con un ID único, contar la cantidad de píxeles que componen los objetos y calcular estadísticas para los valores de los píxeles que se cruzan con los objetos.
connectedComponents(): Etiqueta cada objeto con un identificador único.connectedPixelCount(): Calcula la cantidad de píxeles en cada objeto.reduceConnectedComponents(): Calcula una estadística para los píxeles de cada objeto.
Puntos de acceso térmicos
En las siguientes secciones, se proporcionan ejemplos de métodos basados en objetos aplicados a la temperatura de la superficie de Landsat 8, y cada sección se basa en la anterior. Ejecuta el siguiente fragmento para generar la imagen base: puntos de acceso térmicos (>303 grados Kelvin) para una pequeña región de San Francisco.
Editor de código (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');
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')

Figura 1. Temperatura de una región de San Francisco. Los píxeles con una temperatura superior a 303 grados Kelvin se distinguen por el color rojo (puntos de acceso térmicos).
Etiqueta objetos
Etiquetar objetos suele ser el primer paso en el análisis de objetos. Aquí, se usa la función connectedComponents() para identificar objetos de imagen y asignar un
ID único a cada uno. A todos los píxeles que pertenecen a un objeto se les asigna el mismo
valor de ID de número entero. El resultado es una copia de la imagen de entrada con una banda adicional de "etiquetas" que asocia los píxeles con un valor de ID de objeto según la conectividad de los píxeles en la primera banda de la imagen.
Editor de código (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');
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')
Ten en cuenta que el tamaño máximo de los parches se establece en 128 píxeles; los objetos compuestos por más
píxeles se enmascaran. La conectividad se especifica mediante un kernel ee.Kernel.plus(1),
que define la conectividad de cuatro vecinos; usa ee.Kernel.square(1) para
ocho vecinos.

Figura 2. Objetos de puntos de acceso térmicos etiquetados y con diseño según un ID único.
Tamaño del objeto
Cantidad de píxeles
Calcula la cantidad de píxeles que componen los objetos con el método de imagen connectedPixelCount(). Conocer la cantidad de píxeles de un objeto
puede ser útil para enmascarar objetos por tamaño
y calcular el área de los objetos. En el siguiente fragmento, se aplica connectedPixelCount()
a la banda "labels" de la imagen objectId definida en la sección anterior.
Editor de código (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');
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() devuelve una copia de la imagen de entrada en la que cada píxel de
cada banda contiene la cantidad de vecinos conectados según
la regla de conectividad de cuatro u ocho vecinos determinada por un argumento booleano
pasado al parámetro eightConnected. Ten en cuenta que la conectividad se determina de forma independiente para cada banda de la imagen de entrada. En este ejemplo, se proporcionó como entrada una imagen de una sola banda (objectId) que representa el ID del objeto, por lo que se devolvió una imagen de una sola banda con una banda de "etiquetas" (presente como tal en la imagen de entrada), pero ahora los valores representan la cantidad de píxeles que componen los objetos; cada píxel de cada objeto tendrá el mismo valor de recuento de píxeles.

Figura 3. Objetos de zonas térmicas activas etiquetados y con estilo según el tamaño.
Área
Calcula el área del objeto multiplicando el área de un solo píxel por la cantidad de
píxeles que componen un objeto (determinado por connectedPixelCount()). El área de píxeles
se proporciona mediante una imagen generada a partir de ee.Image.pixelArea().
Editor de código (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');
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', )
El resultado es una imagen en la que cada píxel de un objeto relaciona el área del objeto en metros cuadrados. En este ejemplo, la imagen objectSize contiene una
sola banda. Si fuera multibanda, la operación de multiplicación se
aplicaría a cada banda de la imagen.
Filtrar objetos por tamaño
El tamaño del objeto se puede usar como una condición de máscara para enfocar tu análisis en objetos
de un tamaño determinado (p.ej., enmascarar objetos que son demasiado pequeños). Aquí, la imagen objectArea calculada en el paso anterior se usa como máscara para quitar los objetos cuya área es inferior a una hectárea.
Editor de código (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');
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')
El resultado es una copia de la imagen objectId en la que se enmascaran los objetos de menos de una hectárea.
![]() |
![]() |
|---|---|
| Figura 4a. Objetos de puntos de acceso térmicos etiquetados y con diseño según el ID único. | Figura 4b. Objetos de puntos de acceso térmicos filtrados por área mínima (1 hectárea). |
Estadísticas zonales
El método reduceConnectedComponents() aplica un reductor a los píxeles
que componen objetos únicos. En el siguiente fragmento, se usa para calcular la temperatura media
de los objetos de hotspot. reduceConnectedComponents() requiere una imagen de entrada
con una o más bandas para reducir y una banda que defina las etiquetas de
los objetos. Aquí, la banda de imagen de "etiquetas" objectID se agrega a la imagen de temperatura kelvin para construir una imagen de entrada adecuada.
Editor de código (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' );
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)
El resultado es una copia de la imagen de entrada sin la banda usada para definir objetos, en la que los valores de píxeles representan el resultado de la reducción por objeto y por banda.

Figura 5. Píxeles de objetos de hotspot térmico resumidos y con diseño según la temperatura media.
Ejecutar en Google Colab
Ver el código fuente en GitHub

