O Earth Engine foi projetado para que você raramente precise se preocupar com projeções de mapas ao
fazer cálculos. Assim como na escala, a projeção em que os cálculos ocorrem é determinada com base em "pull". 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), pelo Editor de Código e por objetos de mapa do geemap (que têm uma projeção Mercator
de mapas (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
maps mercator. Considere a
operação a seguir em uma imagem MODIS, que tem uma projeção sinusoidal:
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 das operações para este exemplo de código está diagramada na Figura 1. A projeção da entrada é determinada pela saída, especificamente a projeção maps mercator 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 no Maps Mercator, 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 de pixels nominal 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 que as outras, poderá ver um
erro como:
A projeção padrão
A menos que você precise que o cálculo ocorra em uma projeção específica, geralmente não é necessário especificar uma projeção. O Earth Engine só vai exigir que você especifique uma projeção e/ou escala para saídas ambíguas. A ambiguidade pode resultar da
redução de uma ImageCollection imagem do contêiner que contém imagens com projeções diferentes
(ou seja, criar uma composição). Uma imagem que é uma composição ou um mosaico de imagens de entrada com projeções diferentes terá a projeção padrão, que é WGS84 com escala de 1 grau.
Se essa projeção padrão não for adequada para sua análise (por exemplo, se for muito
grosseira ou se você precisar evitar artefatos de reamostragem em cálculos
posteriores, como análise de terreno), defina um padrão diferente usando
image.setDefaultProjection(crs). Isso garante que, se o Earth Engine precisar escolher uma projeção para um cálculo que envolva a imagem, ele usará a especificada, em vez de WGS84 em 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á ver um erro como:
Em geral, uma agregação em escala de 1 grau não é desejada ou pretendida. Por isso, o Earth Engine mostra esse lembrete para fornecer uma especificação completa para a saída.
Os usuários geralmente acham esse comportamento confuso e se preocupam com as informações de projeção "perdidas", mas os pixels não são realmente calculados até que sejam necessários (saiba mais). Nesse momento, há sempre uma projeção de saída que acompanha a solicitação que especificou 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. No entanto, isso significa que a saída pode parecer diferente em níveis de zoom distintos.
Se a imagem de exibição otimizada não for suficiente, o cálculo em uma projeção específica pode ser forçado pela reprojeção da saída, conforme descrito na seção a seguir.
Reprojetar
É possível forçar a execução de operações em uma projeção específica com o
método reproject(). O uso de reproject() resulta nas entradas
solicitadas na projeção especificada na chamada reproject().
Os cálculos no código antes da chamada reproject() serão feitos
na projeção especificada. Por exemplo, para forçar a produção de um 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:
- Gradientes de computação (por exemplo,
ee.Terrain.gradientouee.Terrain.slope). reduceResolution, para quando você quiser agregar pixels de resolução mais alta em uma resolução mais baixa. Saiba mais sobre como reduzir a resolução.
As funções no pacote ee.Terrain (por exemplo, slope,
aspect, hillshade) calculam valores com base em pixels
vizinhos e são sensíveis a artefatos de reamostragem introduzidos durante
a reprojeção. Quando a projeção do cálculo é diferente da projeção nativa do DEM, a reamostragem padrão do vizinho mais próximo pode criar padrões artificiais na saída. Para melhores resultados, faça a análise de terreno na projeção nativa do DEM. Se estiver trabalhando com uma
ImageCollection de blocos de DEM, crie um mosaico e use
setDefaultProjection() com a projeção nativa
da coleção para garantir que a análise seja executada na grade correta, conforme descrito
na seção A projeção padrão.
Há vários motivos para evitar o uso de reproject(), a menos que seja
absolutamente necessário. Suponha, por exemplo, 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 na solicitação de muitos dados de uma só vez e levar a um erro.
Se a saída final estiver em uma projeção diferente da especificada na chamada
reproject(), isso vai resultar em outra reprojeção. Esse é
outro motivo para ter cuidado ao usar reproject() no código. Considere
o exemplo a seguir, que força a imagem MODIS a ser reprojetada primeiro para
WGS84 e, em seguida, para
maps mercator 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, realizada pelo
Earth Engine automaticamente para exibir 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.