Earth Engine è progettato in modo che raramente tu debba preoccuparti delle proiezioni delle mappe durante i calcoli. Come per la scala, la proiezione in cui vengono eseguiti i calcoli viene determinata su base "pull". In particolare, gli input sono richiesti nella proiezione di output. L'output può essere determinato da un parametro della funzione (ad es. crs),
dagli oggetti mappa dell'editor di codice e di geemap (che hanno una proiezione Mercatore (EPSG:3857)) o con una chiamata reproject(). Quando
visualizzi le immagini nell'editor di codice o in geemap, gli input vengono richiesti in
Mercator per mappe. Considera la seguente operazione su un'immagine MODIS, che ha una proiezione sinusoidale:
Editor di codice (JavaScript)
// The input image has a SR-ORG:6974 (sinusoidal) projection. var image = ee.Image('MODIS/061/MOD13A1/2014_05_09').select(0); // Normalize the image and add it to the map. var rescaled = image.unitScale(-2000, 10000); var visParams = {min: 0.15, max: 0.7}; Map.addLayer(rescaled, visParams, 'Rescaled');
import ee import geemap.core as geemap
Colab (Python)
# The input image has a SR-ORG:6974 (sinusoidal) projection. image = ee.Image('MODIS/061/MOD13A1/2014_05_09').select(0) # Normalize the image and add it to the map. rescaled = image.unitScale(-2000, 10000) vis_params = {'min': 0.15, 'max': 0.7} m = geemap.Map() m.add_layer(rescaled, vis_params, 'Rescaled') m
L'ordine delle operazioni per questo esempio di codice è illustrato nella Figura 1. Tieni presente che la proiezione dell'input è determinata dall'output, in particolare dalla proiezione maps mercator della visualizzazione della mappa nell'editor di codice. Questa proiezione si propaga a ritroso attraverso la sequenza di operazioni in modo che gli input vengano richiesti in Mercator di Maps, a una scala determinata dal livello di zoom della mappa.
In Earth Engine, le proiezioni sono specificate da un sistema di riferimento di coordinate (CRS o parametro crs di molti metodi). Puoi controllare la proiezione di un'immagine chiamando projection():
Editor di codice (JavaScript)
var image = ee.Image('LANDSAT/LC08/C02/T1_TOA/LC08_044034_20140318').select(0); print('Projection, crs, and crs_transform:', image.projection()); print('Scale in meters:', image.projection().nominalScale());
import ee import geemap.core as geemap
Colab (Python)
image = ee.Image('LANDSAT/LC08/C02/T1_TOA/LC08_044034_20140318').select(0) display('Projection, crs, and crs_transform:', image.projection()) display('Scale in meters:', image.projection().nominalScale())
Tieni presente che chiamando nominalScale() su ee.Projection restituito da projection(), puoi determinare la risoluzione nativa dell'immagine. La risoluzione nativa è la scala nominale dei pixel in metri del livello più basso della piramide di immagini. Poiché ogni banda di un'immagine può avere una scala e/o una proiezione diverse, se chiami projection() su un'immagine con almeno una banda che non ha la stessa proiezione delle altre, potresti visualizzare un errore come:
La proiezione predefinita
A meno che non sia necessario che il calcolo avvenga in una proiezione specifica, in genere non è necessario specificare una proiezione. Earth Engine richiede di specificare una proiezione e/o una scala solo per l'output ambiguo. L'ambiguità può derivare dalla riduzione di un ImageCollection immagine container contenente immagini con proiezioni diverse (ovvero dalla creazione di un composito). Un'immagine che è un composito o un mosaico di immagini di input con proiezioni diverse avrà la proiezione predefinita, ovvero WGS84 con scala di 1 grado.
Se questa proiezione predefinita non è adatta alla tua analisi (ad esempio, è troppo grossolana o devi evitare artefatti di ricampionamento nei calcoli downstream come l'analisi del terreno), puoi impostare un valore predefinito diverso utilizzando image.setDefaultProjection(crs). In questo modo, se Earth Engine deve scegliere una proiezione per un calcolo che coinvolge l'immagine, utilizzerà quella specificata, anziché WGS84 su una scala di 1 grado.
Ad esempio:
Editor di codice (JavaScript)
var collection = ee.ImageCollection('LANDSAT/LC08/C02/T1_TOA'); var mosaic = collection.filterDate('2018-01-01', '2019-01-01').mosaic(); print(mosaic.projection());
import ee import geemap.core as geemap
Colab (Python)
collection = ee.ImageCollection('LANDSAT/LC08/C02/T1_TOA') mosaic = collection.filterDate('2018-01-01', '2019-01-01').mosaic() display(mosaic.projection())
Se provi a utilizzare un'immagine di questo tipo in un calcolo, potresti visualizzare un errore simile al seguente:
In genere, un'aggregazione su una scala di 1 grado non è desiderata o prevista, quindi Earth Engine fornisce questo promemoria per fornire una specifica completa per l'output.
Gli utenti spesso trovano questo comportamento confuso e si preoccupano delle informazioni di proiezione "perse", ma i pixel non vengono effettivamente calcolati finché non sono necessari (scopri di più) e, a quel punto, esiste sempre una proiezione di output che accompagna la richiesta che ha specificato come calcolare il composito.
Nella stragrande maggioranza dei casi d'uso, l'assenza di proiezione non è un problema ed è in realtà un'ottimizzazione preziosa, in quanto consente di visualizzare l'anteprima dei risultati a qualsiasi livello di zoom senza dover attendere il completamento del calcolo della risoluzione completa. Tuttavia, l'output può apparire diverso a seconda dei livelli di zoom.
Se l'immagine di visualizzazione ottimizzata non è sufficiente, il calcolo in una proiezione specifica può essere forzato riproiettando l'output come descritto nella sezione seguente.
Riproietta
Puoi forzare l'esecuzione delle operazioni in una proiezione specifica con il metodo reproject(). L'utilizzo di reproject() comporta la richiesta degli input nella proiezione specificata nella chiamata reproject().
I calcoli nel codice prima della chiamata reproject() verranno eseguiti nella proiezione specificata. Ad esempio, per forzare la produzione di un composito in una proiezione specifica:
Editor di codice (JavaScript)
// Some projection that is suitable for your area of interest. var proj = ee.Projection(...); var output = collection.reduce(...).reproject(proj);
import ee import geemap.core as geemap
Colab (Python)
# Some projection that is suitable for your area of interest. proj = ee.Projection(...) output = collection.reduce(...).reproject(proj)
Alcuni casi che richiedono una proiezione fissa includono:
- Calcolo dei gradienti (ad es.
ee.Terrain.gradientoee.Terrain.slope). reduceResolution, per quando vuoi aggregare pixel con una risoluzione più alta in una risoluzione più bassa. (Scopri di più sulla riduzione della risoluzione).
Le funzioni nel pacchetto ee.Terrain (ad es. slope, aspect, hillshade) calcolano i valori in base ai pixel adiacenti e sono sensibili agli artefatti di ricampionamento introdotti durante la riproiezione. Quando la proiezione del calcolo è diversa dalla proiezione nativa del DEM, il ricampionamento predefinito del vicino più prossimo può creare pattern artificiali nell'output. Per risultati ottimali, esegui l'analisi del terreno nella proiezione nativa del DEM. Se utilizzi un
ImageCollection di tile DEM, crea un mosaico e utilizza
setDefaultProjection() con la proiezione nativa
della raccolta per assicurarti che l'analisi venga eseguita sulla griglia corretta, come descritto
nella sezione La proiezione predefinita.
Esistono diversi motivi per cui dovresti evitare di utilizzare reproject(), a meno che non sia assolutamente necessario. Supponiamo, ad esempio, di riproiettare un elemento e di aggiungerlo alla mappa. Se la scala specificata nella chiamata reproject() è molto più piccola del livello di zoom della mappa, Earth Engine richiederà tutti gli input su una scala molto piccola, in un'estensione spaziale molto ampia. Ciò può comportare la richiesta di troppi dati contemporaneamente e causare un errore.
Se l'output finale si trova in una proiezione diversa da quella specificata nella chiamata reproject(), verrà eseguita un'altra riproiezione. Questo è un altro motivo per cui è consigliabile prestare attenzione all'utilizzo di reproject() nel codice. Considera
il seguente esempio, che forza la riproiezione dell'immagine MODIS prima in
WGS84, poi in
Mercatore di Maps per la visualizzazione nella mappa dell'editor di codice:
Editor di codice (JavaScript)
// The input image has a SR-ORG:6974 (sinusoidal) projection. var image = ee.Image('MODIS/061/MOD13A1/2014_05_09').select(0); // Operations *before* the reproject call will be done in the projection // specified by reproject(). The output results in another reprojection. var reprojected = image .unitScale(-2000, 10000) .reproject('EPSG:4326', null, 500); Map.addLayer(reprojected, {min: 0.15, max: 0.7}, 'Reprojected');
import ee import geemap.core as geemap
Colab (Python)
# The input image has a SR-ORG:6974 (sinusoidal) projection. image = ee.Image('MODIS/061/MOD13A1/2014_05_09').select(0) # Operations *before* the reproject call will be done in the projection # specified by reproject(). The output results in another reprojection. reprojected = image.unitScale(-2000, 10000).reproject('EPSG:4326', None, 500) m = geemap.Map() m.add_layer(reprojected, {'min': 0.15, 'max': 0.7}, 'Reprojected') m
La Figura 2 mostra il flusso di operazioni corrispondente a questo semplice esempio di riproiezione. Tieni presente che la prima riproiezione è esplicita, come specificato nella chiamata reproject(). La seconda riproiezione è implicita ed eseguita automaticamente da Earth Engine per visualizzare il risultato sulla mappa. Osserva inoltre che le informazioni sulla proiezione da utilizzare vengono propagate dalla richiesta all'input.