Métodos basados en objetos

Ejecutar en Google Colab

Ver código fuente en GitHub

Los objetos de imagen son conjuntos de píxeles conectados que tienen el mismo valor de número 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 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.

Precaución: Los resultados de los métodos basados en objetos dependen de la escala, que se determina según lo siguiente:

• la escala solicitada de un resultado (p.ej., Export.image.toAsset() o Export.image.toDrive()).
• funciones que requieren una escala de análisis (p.ej., reduceRegions() o reduceToVectors()).
• Nivel de zoom del mapa.

Ten en cuenta la escala determinada por el nivel de zoom del mapa. Los resultados de los métodos basados en objetos variarán cuando se visualicen o inspeccionen las capas de imágenes en el mapa, ya que cada capa de la pirámide tiene una escala diferente. Para forzar una escala de análisis deseada en la exploración de mapas, usa reproject(). Sin embargo, se recomienda NO usar reproject(), ya que se solicitará toda el área visible en el mapa con la escala y la proyección establecidas. En gran medida, esto puede provocar que se soliciten demasiados datos, lo que a menudo genera errores. Dentro de la arquitectura basada en pirámides de imágenes de Earth Engine, la escala y la proyección solo se deben establecer para las operaciones que proporcionan scale y crs como parámetros. Consulta Escala de análisis y Reproyección para obtener más información.

Hotspots 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 calientes térmicos (> 303 grados Kelvin) para una pequeña región de San Francisco.

Editor de código (JavaScript)Colab (Python)

// 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');

Configuración de Python

Consulta la página Entorno de Python para obtener información sobre la API de Python y el uso de geemap para el desarrollo interactivo.

import ee
import geemap.core as geemap

# 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 calientes 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 los objetos de imagen y asignarles 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 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)Colab (Python)

// 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');

Configuración de Python

Consulta la página Entorno de Python para obtener información sobre la API de Python y el uso de geemap para el desarrollo interactivo.

import ee
import geemap.core as geemap

# 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 del parche se establece en 128 píxeles. Los objetos compuestos por más píxeles se enmascaran. La conectividad se especifica con 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 hotspot térmico 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 su área. 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)Colab (Python)

// 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');

Configuración de Python

Consulta la página Entorno de Python para obtener información sobre la API de Python y el uso de geemap para el desarrollo interactivo.

import ee
import geemap.core as geemap

# 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() muestra 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 o ocho vecinos determinada por un argumento booleano que se pasa 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 mostró 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 hotspot térmico etiquetados y con diseño según el tamaño

Área

Para calcular el área del objeto, multiplica 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 la proporciona una imagen generada a partir de ee.Image.pixelArea().

Editor de código (JavaScript)Colab (Python)

// 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');

Configuración de Python

Consulta la página Entorno de Python para obtener información sobre la API de Python y el uso de geemap para el desarrollo interactivo.

import ee
import geemap.core as geemap

# 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.

Cómo filtrar objetos por tamaño

El tamaño del objeto se puede usar como condición de máscara para enfocar el 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 un hectárea.

Editor de código (JavaScript)Colab (Python)

// 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');

Configuración de Python

Consulta la página Entorno de Python para obtener información sobre la API de Python y el uso de geemap para el desarrollo interactivo.

import ee
import geemap.core as geemap

# 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 ocultan los objetos de menos de un hectárea.

Figura 4a. Objetos de hotspot térmico etiquetados y con diseño según el ID único	Figura 4b. Objetos de hotspot térmico 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 promedio de los objetos de hotspot. reduceConnectedComponents() requiere una imagen de entrada con una o varias bandas que se reducirán y una banda que defina las etiquetas de objetos. Aquí, la banda de imagen "etiquetas" objectID se agrega a la imagen de temperatura kelvin para construir una imagen de entrada adecuada.

Editor de código (JavaScript)Colab (Python)

// 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'
);

Configuración de Python

Consulta la página Entorno de Python para obtener información sobre la API de Python y el uso de geemap para el desarrollo interactivo.

import ee
import geemap.core as geemap

# 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 que se usa 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.

Nota: reduceToVectors() proporciona una funcionalidad similar, excepto que el resultado es un ee.FeatureCollection, en el que cada componente de la colección representa un objeto y la reducción de los píxeles en cada objeto se expresa como una propiedad de componente para cada banda en la imagen de entrada. reduceToVectors() requiere muchos recursos, por lo que debes usar reduceConnectedComponents() siempre que sea posible. Consulta Conversión de imágenes de trama a vectoriales para obtener más información.