O Earth Engine foi projetado para que você raramente precise se preocupar com projeções de mapa ao fazer cálculos. Assim como a escala, a projeção em que os cálculos são realizados é determinada com base em uma ação de "extração". Especificamente, as entradas são solicitadas na projeção de saída. A saída pode ser determinada por um parâmetro de função (por exemplo, crs), objetos de mapa do Editor de código e do geemap (que têm uma projeção maps mercator (EPSG:3857)) ou com uma chamada reproject(). Quando você
mostra imagens no Editor de código ou no geemap, as entradas são solicitadas em
mercator de mapas. Considere a seguinte operação em uma imagem do MODIS, que tem uma projeção senoidal:
Editor de código (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
A ordem de operações para este exemplo de código está diagramada na Figura 1. Observe que a projeção da entrada é determinada pela saída, especificamente a projeção mercator de mapas da exibição do mapa no Editor de código. Essa projeção é propagada de volta pela sequência de operações para que as entradas sejam solicitadas em mercator de mapas, em uma escala determinada pelo nível de zoom do mapa.
No Earth Engine, as projeções são especificadas por um sistema de referência de coordenadas (CRS ou o parâmetro crs de muitos métodos). Para verificar a projeção de uma imagem, chame projection() nela:
Editor de código (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())
Ao chamar nominalScale() no ee.Projection retornado por projection(), é possível determinar a resolução nativa da imagem. A resolução nativa é a escala nominal de pixels em metros do nível mais baixo da pirâmide de imagens. Como cada banda de uma imagem pode ter uma escala e/ou projeção diferente, se você chamar projection() em uma imagem com pelo menos uma banda que não tenha a mesma projeção das outras, poderá aparecer um erro como:
A projeção padrão
A menos que você precise que a computação ocorra em uma projeção específica, geralmente não é necessário especificar uma projeção. Somente para saída ambígua, o Earth Engine exige que você especifique uma projeção e/ou escala. A ambiguidade pode resultar da
redução de um ImageCollection que contém imagens com projeções diferentes
(ou seja, criação de um composto). Uma imagem que é um
composite ou mosaico de imagens de entrada com projeções diferentes terá a projeção
padrão, que é WGS84 com escala de 1 grau.
Exemplo:
Editor de código (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 você tentar usar uma imagem como essa em um cálculo, poderá receber um erro como:
Geralmente, uma agregação em escala de 1 grau não é desejada nem pretendida. Por isso, o Earth Engine envia esse lembrete para fornecer uma especificação completa da saída.
Os usuários geralmente acham esse comportamento confuso e se preocupam com as informações "perdidas" da projeção. No entanto, os pixels só são calculados quando são necessários (saiba mais). Nesse momento, sempre há uma projeção de saída que acompanha a solicitação e especifica como calcular o composto.
Na grande maioria dos casos de uso, não ter uma projeção não é um problema e, na verdade, é uma otimização valiosa, já que permite visualizar os resultados em qualquer nível de zoom sem precisar esperar que o cálculo de resolução total seja concluído. Mas isso significa que a saída pode ter uma aparência diferente em níveis de zoom diferentes.
Se a imagem otimizada não for suficiente, a computação em uma projeção específica poderá ser forçada reprojetando a saída, conforme descrito na seção a seguir.
Reprojetando
É possível forçar a execução de operações em uma projeção específica com o método
reproject(). Usar reproject() resulta na solicitação das entradas na projeção especificada na chamada reproject().
Os cálculos no seu código antes da chamada reproject() serão feitos na projeção especificada. Por exemplo, para forçar a produção de um tipo composto em uma projeção específica:
Editor de código (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)
Alguns casos que exigem uma projeção fixa incluem:
- Cálculo de gradientes (por exemplo,
ee.Terrain.gradientouee.Terrain.slope). reduceResolution, para quando você quer agregar pixels de resolução mais alta em uma resolução mais baixa. Saiba mais sobre como reduzir a resolução.
Há vários motivos para evitar o uso de reproject(), a menos que seja absolutamente necessário. Por exemplo, suponha que você reprojete algo e adicione ao mapa. Se a escala especificada na chamada reproject() for muito menor que o nível de zoom do mapa, o Earth Engine vai solicitar todas as entradas em uma escala muito pequena, em uma extensão espacial muito ampla. Isso pode resultar em muitos dados sendo
solicitados de uma só vez e causar um erro.
Se a saída final estiver em uma projeção diferente da especificada na chamada reproject(), isso resultará em outra reprojeção. Esse é outro motivo para ter cautela ao usar reproject() no código. Considere o exemplo a seguir, que força a imagem do MODIS a ser reprojetada primeiro para WGS84 e depois para mercator do Google Maps para exibição no mapa do Editor de código:
Editor de código (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
A Figura 2 mostra o fluxo de operações correspondente a esse exemplo simples de reprojeção. A primeira reprojeção é explícita, conforme especificado na chamada
reproject(). A segunda reprojeção é implícita e realizada automaticamente pelo Earth Engine para mostrar o resultado no mapa. Observe também que as informações sobre qual projeção usar são propagadas da solicitação para a entrada.
