Metodi basati sugli oggetti

Esegui in Google Colab

Visualizza il codice sorgente su GitHub

Gli oggetti immagine sono insiemi di pixel collegati con lo stesso valore intero. I dati delle immagini categoriche, raggruppate e booleane sono adatti per l'analisi degli oggetti.

Earth Engine offre metodi per etichettare ogni oggetto con un ID univoco, contare il numero di pixel che compongono gli oggetti e calcolare le statistiche per i valori dei pixel che intersecano gli oggetti.

• connectedComponents(): etichetta ogni oggetto con un identificatore univoco.
• connectedPixelCount(): calcola il numero di pixel in ogni oggetto.
• reduceConnectedComponents(): calcola una statistica per i pixel di ogni oggetto.

Attenzione: i risultati dei metodi basati sugli oggetti dipendono dalla scala, che viene determinata da:

• la scala richiesta di un output (ad es. Export.image.toAsset() o Export.image.toDrive()).
• funzioni che richiedono una scala di analisi (ad es. reduceRegions() o reduceToVectors()).
• Livello di zoom della mappa.

Fai particolare attenzione alla scala determinata dal livello di zoom della mappa. I risultati dei metodi basati sugli oggetti varieranno quando visualizzi o ispezioni i livelli di immagine nella mappa, poiché ogni livello della piramide ha una scala diversa. Per forzare una scala di analisi preferita nell'esplorazione della mappa, utilizza reproject(). Tuttavia, ti consigliamo vivamente di NON utilizzare reproject() perché l'intera area visibile nella mappa verrà richiesta con la scala e la proiezione impostate. In misura maggiore, questo può causare la richiesta di troppi dati, spesso attivando errori. Nell'architettura basata su piramidi di immagini di Earth Engine, la scala e la proiezione devono essere impostate solo per le operazioni che forniscono scale e crs come parametri. Per ulteriori informazioni, consulta Scala di analisi e Riproiezione.

Hotspot termici

Le sezioni seguenti forniscono esempi di metodi basati sugli oggetti applicati alla temperatura superficiale di Landsat 8, con ogni sezione che si basa sulla precedente. Esegui lo snippet successivo per generare l'immagine di base: hotspot termici (> 303 gradi Kelvin) per una piccola regione di San Francisco.

Editor di codice (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');

Configurazione di Python

Per informazioni sull'API Python e sull'utilizzo di geemap per lo sviluppo interattivo, consulta la pagina Ambiente Python.

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 di una regione di San Francisco. I pixel con temperatura superiore a 303 gradi Kelvin sono contraddistinti dal colore rosso (hotspot termici).

Etichettare gli oggetti

L'etichettatura degli oggetti è spesso il primo passaggio nell'analisi degli oggetti. Qui, la funzione connectedComponents() viene utilizzata per identificare gli oggetti immagine e assegnare a ciascuno un ID univoco. A tutti i pixel appartenenti a un oggetto viene assegnato lo stesso valore di ID intero. Il risultato è una copia dell'immagine di input con un'altra banda "etichette" che associa i pixel a un valore ID oggetto in base alla connettività dei pixel nella prima banda dell'immagine.

Editor di codice (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');

Configurazione di Python

Per informazioni sull'API Python e sull'utilizzo di geemap per lo sviluppo interattivo, consulta la pagina Ambiente Python.

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

Tieni presente che la dimensione massima della patch è impostata su 128 pixel; gli oggetti composti da più pixel vengono mascherati. La connettività è specificata da un kernel ee.Kernel.plus(1), che definisce la connettività con quattro vicini; utilizza ee.Kernel.square(1) per la connettività con otto vicini.

Figura 2. Oggetti hotspot termici etichettati e stilizzati da un ID univoco.

Dimensioni dell'oggetto

Numero di pixel

Calcola il numero di pixel che compongono gli oggetti utilizzando il metodoconnectedPixelCount() immagine. Conoscere il numero di pixel di un oggetto può essere utile per mascherare gli oggetti in base alle dimensioni e calcolare la loro area. Lo snippet seguente applica connectedPixelCount() alla banda "etichette" dell'immagine objectId definita nella sezione precedente.

Editor di codice (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');

Configurazione di Python

Per informazioni sull'API Python e sull'utilizzo di geemap per lo sviluppo interattivo, consulta la pagina Ambiente Python.

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() restituisce una copia dell'immagine di input in cui ogni pixel di ogni banda contiene il numero di vicini connessi in base alla regola di connettività a quattro o otto vicini determinata da un argomento booleano passato al parametro eightConnected. Tieni presente che la connettività viene determinata in modo indipendente per ogni banda dell'immagine di input. In questo esempio, è stata fornita come input un'immagine a banda singola (objectId) che rappresenta l'ID oggetto, pertanto è stata restituita un'immagine a banda singola con una banda "etichette" (presente come tale nell'immagine di input), ma ora i valori rappresentano il numero di pixel che compongono gli oggetti. Ogni pixel di ogni oggetto avrà lo stesso valore di conteggio pixel.

Figura 3. Oggetti hotspot termici etichettati e stilizzati in base alle dimensioni.

Area

Calcola l'area dell'oggetto moltiplicando l'area di un singolo pixel per il numero di pixel che compongono un oggetto (determinato da connectedPixelCount()). L'area del pixel viene fornita da un'immagine generata da connectedPixelCount().ee.Image.pixelArea()

Editor di codice (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');

Configurazione di Python

Per informazioni sull'API Python e sull'utilizzo di geemap per lo sviluppo interattivo, consulta la pagina Ambiente Python.

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

Il risultato è un'immagine in cui ogni pixel di un oggetto indica l'area dell'oggetto in metri quadrati. In questo esempio, l'immagine objectSize contiene un singolo canale. Se fosse multicanale, l'operazione di moltiplicazione verrebbe applicata a ogni canale dell'immagine.

Filtrare gli oggetti per dimensione

La dimensione dell'oggetto può essere utilizzata come condizione di maschera per concentrare l'analisi su oggetti di una determinata dimensione (ad es. mascherare gli oggetti troppo piccoli). Qui l'immagineobjectArea calcolata nel passaggio precedente viene utilizzata come maschera per rimuovere gli oggetti la cui area è inferiore a un ettaro.

Editor di codice (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');

Configurazione di Python

Per informazioni sull'API Python e sull'utilizzo di geemap per lo sviluppo interattivo, consulta la pagina Ambiente Python.

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

Il risultato è una copia dell'immagine objectId in cui gli oggetti di meno di un ettaro sono mascherati.

Figura 4a. Oggetti hotspot termici etichettati e stilizzati in base all'ID univoco.	Figura 4b. Oggetti hotspot termici filtrati in base all'area minima (1 ettaro).

Statistiche zonali

Il metodo reduceConnectedComponents() applica un riduttore ai pixel che compongono oggetti unici. Lo snippet seguente lo utilizza per calcolare la temperatura media degli oggetti hotspot. reduceConnectedComponents() richiede un'immagine di input con una o più bande da ridurre e una banda che definisce le etichette degli oggetti. In questo caso, la banda di immagini "etichette" objectID viene aggiunta all'immagine della temperatura kelvin per creare un'immagine di input adatta.

Editor di codice (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'
);

Configurazione di Python

Per informazioni sull'API Python e sull'utilizzo di geemap per lo sviluppo interattivo, consulta la pagina Ambiente Python.

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)

Il risultato è una copia dell'immagine di input senza la banda utilizzata per definire gli oggetti, dove i valori dei pixel rappresentano il risultato della riduzione per oggetto e per banda.

Figura 5. Pixel dell'oggetto hotspot termico riassunti e stilizzati in base alla temperatura media.

Nota: reduceToVectors() fornisce funzionalità simili, tranne per il fatto che il risultato è un ee.FeatureCollection, in cui ogni elemento della raccolta rappresenta un oggetto e la riduzione dei pixel in ogni oggetto è espressa come proprietà dell'elemento per ogni banda nell'immagine di input. reduceToVectors() richiede molte risorse, quindi utilizza reduceConnectedComponents() quando possibile. Per ulteriori informazioni, consulta la sezione Conversione da raster a vettoriale.