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 as computações ocorrem é
determinada por uma base de "pull". Especificamente, as entradas são solicitadas na projeção de saída. A saída pode ser determinada a partir de um parâmetro de função (por exemplo, crs), do Code Editor e de objetos de mapa do geemap (que têm uma projeção maps mercator (EPSG:3857)) ou com uma chamada reproject(). Quando você
mostra imagens no Code Editor ou no geemap, as entradas são solicitadas em
maps mercator. Considere a
seguinte operação simples em uma imagem MODIS, que tem uma projeção
sinusoidal:
// 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
# 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á mostrada no diagrama da 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, de modo que as entradas sejam solicitadas no Mercator dos 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 (SRC ou o parâmetro crs de muitos métodos). É possível verificar a projeção de uma
imagem chamando projection() nela:
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
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())
Chamando 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 diferentes, se você chamar projection() em uma imagem
com pelo menos uma banda que não tenha a mesma projeção que as 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. 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 um ImageCollection que contém imagens com projeções diferentes,
ou seja, criando uma composição. Uma imagem que é um
composto ou mosaico de imagens de entrada com projeções diferentes terá a projeção
padrão, que é WGS84 com escala de 1 grau.
Exemplo:
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
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 uma computação, poderá encontrar um erro como:
Geralmente, uma agregação na escala de 1 grau não é desejada ou pretendida. Por isso, o Earth Engine oferece este lembrete amigável para fornecer uma especificação completa da saída.
Os usuários costumam achar esse comportamento confuso e se preocupar com as informações de projeção "perdidas", mas os pixels não são computados até que sejam necessários (saiba mais). Nesse ponto, sempre há uma projeção de saída que acompanha a solicitação que especificou como computar o composto.
Na maioria dos casos de uso, não ter projeção não é um problema e é, na verdade, uma otimização valiosa, porque permite visualizar os resultados em qualquer nível de zoom sem ter que esperar a conclusão do cálculo da resolução completa. Mas isso significa que a saída pode aparecer de maneira diferente em níveis de zoom diferentes.
Se a imagem de exibição 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.
Reprojetar
É possível forçar operações a serem realizadas em uma projeção específica com o
método reproject(). O uso de reproject() faz com que as entradas
sejam 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:
// 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
# 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.
Existem vários motivos para evitar o uso de reproject(), a menos que
seja absolutamente necessário. Suponha que você reprojete algo e o adicione ao mapa. Se a escala especificada na chamada reproject() for muito menor do que o nível de zoom do mapa, o Earth Engine vai solicitar todas as entradas em escala muito pequena, em uma extensão espacial muito ampla. Isso pode resultar em muitos dados sendo
solicitados 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 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 depois para
maps mercator para exibição no mapa do Code Editor:
// 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
# 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 diagrama do 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.
