Métodos baseados em objeto

Executar no Google Colab

Ver código-fonte no GitHub

Os objetos de imagem são conjuntos de pixels conectados com o mesmo valor inteiro. Os dados categóricos, agrupados e booleanos de imagem são adequados para a análise de objetos.

O Earth Engine oferece métodos para rotular cada objeto com um ID exclusivo, contar o número de pixels que compõem objetos e calcular estatísticas para valores de pixels que cruzam objetos.

• connectedComponents(): rotule cada objeto com um identificador exclusivo.
• connectedPixelCount(): calcula o número de pixels em cada objeto.
• reduceConnectedComponents(): calcula uma estatística para pixels em cada objeto.

Atenção:os resultados de métodos baseados em objetos dependem da escala, que é determinada por:

• a escala solicitada de uma saída (por exemplo, Export.image.toAsset() ou Export.image.toDrive()).
• funções que exigem uma escala de análise (por exemplo, reduceRegions() ou reduceToVectors()).
• Nível de zoom do mapa.

Preste atenção especial à escala determinada pelo nível de zoom do mapa. Os resultados dos métodos baseados em objetos variam ao visualizar ou inspecionar camadas de imagem no mapa, já que cada camada da pirâmide tem uma escala diferente. Para forçar uma escala de análise desejada na análise detalhada do mapa, use reproject(). No entanto, recomendamos NÃO usar reproject() porque toda a área visível no mapa será solicitada na escala e projeção definidas. Em grandes extensões, isso pode causar a solicitação de muitos dados, muitas vezes, causando erros. Na arquitetura baseada em pirâmide de imagens do Earth Engine, a escala e a projeção só precisam ser definidas para operações que fornecem scale e crs como parâmetros. Consulte Escala de análise e Reprojetar para mais informações.

Pontos de acesso térmicos

As seções a seguir fornecem exemplos de métodos baseados em objetos aplicados à temperatura da superfície do Landsat 8, com cada seção se baseando na anterior. Execute o snippet a seguir para gerar a imagem base: pontos térmicos (mais de 303 graus Kelvin) para uma pequena região de São 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');

Configuração do Python

Consulte a página Ambiente Python para informações sobre a API Python e o uso de geemap para desenvolvimento interativo.

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 uma região de São Francisco. Os pixels com temperatura maior que 303 graus Kelvin são diferenciados pela cor vermelha (pontos quentes térmicos).

Rotular objetos

A rotulagem de objetos geralmente é a primeira etapa da análise de objetos. Aqui, a função connectedComponents() é usada para identificar objetos de imagem e atribuir um ID exclusivo a cada um. Todos os pixels pertencentes a um objeto recebem o mesmo valor de ID de número inteiro. O resultado é uma cópia da imagem de entrada com uma banda adicional de "rótulos" que associa pixels a um valor de ID do objeto com base na conectividade de pixels na primeira banda da imagem.

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

Configuração do Python

Consulte a página Ambiente Python para informações sobre a API Python e o uso de geemap para desenvolvimento interativo.

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

O tamanho máximo do patch é definido como 128 pixels. Os objetos compostos por mais pixels são mascarados. A conectividade é especificada por um kernel ee.Kernel.plus(1), que define a conectividade de quatro vizinhos. Use ee.Kernel.square(1) para oito vizinhos.

Figura 2. Objetos de ponto de acesso térmico rotulados e estilizados por um ID exclusivo.

Tamanho do objeto

Número de pixels

Calcule o número de pixels que compõem objetos usando o método de imagem connectedPixelCount(). Saber o número de pixels em um objeto pode ser útil para mascarar objetos por tamanho e calcular a área deles. O snippet a seguir aplica connectedPixelCount() à faixa "rótulos" da imagem objectId definida na seção 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');

Configuração do Python

Consulte a página Ambiente Python para informações sobre a API Python e o uso de geemap para desenvolvimento interativo.

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() retorna uma cópia da imagem de entrada em que cada pixel de cada banda contém o número de vizinhos conectados de acordo com a regra de conectividade de quatro ou oito vizinhos determinada por um argumento booleano transmitido para o parâmetro eightConnected. A conectividade é determinada de forma independente para cada banda da imagem de entrada. Neste exemplo, uma imagem de banda única (objectId) que representa o ID do objeto foi fornecida como entrada. Portanto, uma imagem de banda única foi retornada com uma banda de "rótulos" (presente na imagem de entrada), mas agora os valores representam o número de pixels que compõem os objetos. Cada pixel de cada objeto terá o mesmo valor de contagem de pixels.

Figura 3. Objetos de ponto de acesso térmico rotulados e estilizados por tamanho.

Área

Calcule a área do objeto multiplicando a área de um único pixel pelo número de pixels que compõem um objeto (determinado por connectedPixelCount()). A área do pixel é fornecida por uma imagem gerada 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');

Configuração do Python

Consulte a página Ambiente Python para informações sobre a API Python e o uso de geemap para desenvolvimento interativo.

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',
)

O resultado é uma imagem em que cada pixel de um objeto relaciona a área do objeto em metros quadrados. Neste exemplo, a imagem objectSize contém uma única banda. Se fosse multibanda, a operação de multiplicação seria aplicada a cada banda da imagem.

Filtrar objetos por tamanho

O tamanho do objeto pode ser usado como uma condição de máscara para focar a análise em objetos de um determinado tamanho (por exemplo, mascarar objetos muito pequenos). Aqui, a imagem objectArea calculada na etapa anterior é usada como uma máscara para remover objetos com área menor que um hectare.

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

Configuração do Python

Consulte a página Ambiente Python para informações sobre a API Python e o uso de geemap para desenvolvimento interativo.

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

O resultado é uma cópia da imagem objectId em que objetos menores que um hectare são mascarados.

Figura 4a. Objetos de ponto de acesso térmico rotulados e estilizados por ID exclusivo.	Figura 4b. Objetos de ponto térmico filtrados por área mínima (1 hectare).

Estatísticas da zona

O método reduceConnectedComponents() aplica um redutor aos pixels que compõem objetos únicos. O snippet a seguir usa essa função para calcular a temperatura média dos objetos de ponto de acesso. reduceConnectedComponents() requer uma imagem de entrada com uma ou mais faixas para redução e uma faixa que define rótulos de objetos. Aqui, a banda de imagem objectID "labels" é adicionada à imagem de temperatura kelvin para construir uma imagem de entrada adequada.

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

Configuração do Python

Consulte a página Ambiente Python para informações sobre a API Python e o uso de geemap para desenvolvimento interativo.

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)

O resultado é uma cópia da imagem de entrada sem a faixa usada para definir objetos, em que os valores de pixel representam o resultado da redução por objeto, por faixa.

Figura 5. Os pixels do objeto do ponto de acesso térmico resumidos e estilizados pela temperatura média.

Observação: reduceToVectors() oferece uma funcionalidade semelhante, exceto que o resultado é um ee.FeatureCollection, em que cada elemento da coleção representa um objeto e a redução dos pixels em cada objeto é expressa como uma propriedade de elemento para cada banda na imagem de entrada. reduceToVectors() usa muitos recursos, então use reduceConnectedComponents() sempre que possível. Consulte Conversão de raster em vetor para mais informações.