O Google Earth Engine

O bom e velho Google Earth

Muitos (se não todos) de nós, pessoas que gostam de mapas, estamos acostumados com o Google Earth. Na verdade, o Google Earth é uma ferramenta velha de guerra que sempre foi (e continua sendo) muito útil para explorar o mundo sem sair de casa, principalmente depois que implementaram a funcionalidade “street view”, disponível tanto na versão Web quando na versão Desktop do aplicativo.

Como uma ferramenta de SIG Desktop, o Google Earth Pro (que é gratuito) permite um acesso a uma coleção imensa de imagens de satélite com resolução sub-métrica em muitas regiões, principalmente cidades. Esse acesso não é estático, mas dinâmico com o tempo: é possível “voltar no tempo” com a ferramenta de linha do tempo, e observar mudanças da superfície da terra.

Para projetos na escala urbana (um loteamento, por exemplo), o Google Earth Pro pode ser de grande valia, pois permite o uso de informação vetorial na forma de arquivos KML e KMZ. Ou seja: você pode importar feições vetoriais no Google Earth Pro e visualizar seu projeto, inclusive gravar vídeos e animações.

O acesso às imagens de satélite do Google Earth Pro, contudo, é apenas para visualização em tela. Não podemos processar os dados que compõe as bandas das imagens. Nesse sentido, o Google Earth Pro é uma ferramenta limitante.

Google Earth Engine: a nuvem e o motor

Com a ambição de disponibilizar para os usuários os dados em formato processável de diversos produtos de sensoriamento remoto, o Google lançou a plataforma Google Earth Engine. Como veremos, ainda que tenham origens parecidas, o Google Earth Engine não tem muito a ver com o bom e velho Google Earth Pro.

Considere que você deseja analisar a série histórica de imagens Landsat para criar uma classificação de uso do solo para todos os biomas do Brasil. É um projeto de fôlego, certo? Pois foi exatamente isso que o Projeto Mapbiomas executou, usando o Google Earth Engine. Agora imagine operacionalizar esse projeto de forma “convencional”, em SIG Desktop.

Já mostrei aqui o portal Earth Explorer, do USGS, quando construímos um modelo digital de elevação do zero . Nesse portal também temos as imagens Landsat disponíveis. Na lógica convencional, precisaríamos fazer o download de todas as imagens da série histórica que cobrem o território dos biomas do Brasil. Só para fazer isso, certamente um punhado (se não dezenas) de HDs externos seriam ocupados. Depois vem a parte de seleção de imagens e mosaicagem, o que iria também ocupar mais uma boa parte da memória de disco. Depois vem a parte de processamento e classificação, o que vai requerer muita memória RAM. O ponto é que o custo computacional de executar esse projeto em SIG Desktop é altíssimo.

Com o Google Earth Engine a situação muda completamente de figura pois ele faz uso de computação em nuvem. Veja bem, com uma conexão de internet, não é preciso armazenar os dados em um disco local para processar dados e obter resultados. Basta enviar as instruções de processamento para o computador em que os dados estão armazenados e processá-los remotamente. Assim, muitos usuários podem fazer suas análises sem baixar os dados brutos (ainda que eventualmente precisem baixar os dados processados!).

Essa mudança de paradigma viabiliza que o Google Earth Engine mantenha disponível para processamento um grande acervo de produtos de sensoriamento remoto, incluindo as imagens Landsat. Com a infraestrutura da Google Cloud, o usuário precisa submeter um código para acessar, processar e obter os resultados desejados. Claro, também é possível visualizar os dados brutos e processados, ainda que isso não seja essencial.

Usando o Code Editor

Uma das formas de usar o Google Earth Engine (existe mais de uma) é pelo Code Editor. Para usar essa plataforma, tudo que você precisa é uma conta Google e um navegador de internet. A seguir, vá em https://code.earthengine.google.com/ e solicite o acesso gratuito.

O Code Editor possui essencialmente cinco ambientes:

  • Um Painel de Navegação, que fica na esquerda;
  • Um Editor de Código, no centro;
  • Um Painal de Status, inspeção e tarefas, na direita;
  • O Canvas do Mapa, que ocupa toda e extensão inferior, e;
  • Um localizador de catálogo, que fica no topo.

Como dito antes, é preciso escrever e submeter um código para fazer o Google Earth Engine funcionar. No Code Editor, esse código é em JavaScript e deve fazer uso de um repertório de funções, classes e métodos disponíveis pelos desenvolvedores do Google Earth Engine.

A estrutura básica de um código no Google Earth Engine

Um algoritmo é, por definição, a mesma coisa que uma receita. Receitas costumam dar certo quando bem estruturadas em uma sequência lógica e eficiente. A mesma coisa se aplica para qualquer código, incluindo os códigos no Google Earth Engine, de deverá incluir:

  1. Uma seção de importação dos dados de insumo a partir do catálogo disponível, o que deverá incluir todas as formas de seleção e pré-processamento (exemplo: selecionar imagens com poucas nuvens em uma janela de tempo específica);
  2. Uma seção de processamento dos dados, ou seja, as operações, cruzamentos, etc, que resulta no produto, ou produtos.
  3. Uma seção de visualização no canvas do mapa os dados de insumo e resultados. Essa seção poderá ser mais fragmentada, dependendo da complexidade do fluxo de dados.
  4. Uma seção, que poderá ser opcional, para exportar os dados obtidos no processamento para o Google Drive (de onde poderá ser finalmente baixado para aplicações de SIG Desktop).

Exemplo: derivando NDVI a partir de Landsat no Google Earth Engine

A fórmula do NDVI

O NDVI (em português, Índice de Vegetação por diferença normalizada) é um índice de bandas, calculado pela seguinte fórmula:

NDVI = (NIR – Red) / (NIR + Red)

Onde NIR e Red são a reflectância espectral do infra-vermelho próximo e do vermelho visível, respectivamente. Isso significa que o NDVI indica o quanto essas respostas espectrais estão “equilibradas”, variando de -1 (infra-vermelho próximo absorvido totalmente), passando por 0 (respostas iguais) até 1 (vermelho visível absorvido totalmente).

Mas o que isso significa na prática? É uma boa pergunta. Valores próximos de 1 apresentam uma boa correlação com a vegetação “saudável” e ativa (ou seja, verde, que absorve a radiação na faixa do vermelho visível). Isso torna o NDVI um bom indicador da vegetação.

Acessando imagens Landsat no Google Earth Engine

Séries históricas de imagens, como as Landsat, são consideradas coleções de imagens no Google Earth Engine. Assim, para acessar uma coleção Landsat, precisamos instanciar uma variável que receba os atributos e dados da coleção.

Em programação orientada a objetos, que é o caso de JavaScript, uma classe possui métodos internos. E como as coleções são classes, podemos aplicar métodos de filtros nos metadados, como filtro por data .filterDate(), por localização .filterBounds() e por atributo .filterMetadata() – como cobertura de nuvens. Para economizar variáveis e linhas de código (sacrificando um pouco da legibilidade), podemos concatenar todos os métodos de seleção:

// Importar coleção de imagens Landsat com filtro de data, de geometria e de nuvens
var collection = ee.ImageCollection('LANDSAT/LC08/C01/T1_SR')
  .filterDate('2020-01-01', '2020-12-31')
  .filterBounds(ee.Geometry.Point(-51, -30))
  .filterMetadata('CLOUD_COVER', 'less_than', 10);

A seguir, podemos instanciar uma imagem, nova variável que recebe apenas uma das imagens da coleção. Aqui aplicamos (de forma concatenada) o método de ordenar a coleção pelo atributo de cobertura de nuvens [.sort()] seguido do método de extração do primeiro da lista [.first()]:

// Obter a melhor imagem (menor cobertura de nuvens)
var image = collection.sort('CLOUD_COVER').first();

Agora precisamos só escalonar os valores de banda pelo multiplicador indicado na documentação da coleção Landsat que estamos acessando (os valores originais estão em número inteiro para economizar memória de disco e de transmissão). Como não vamos usar os valores originais, podemos sobrescrever a mesma variável:

// Escalonar os valores de banda
image = image.multiply(ee.Number(0.0001));

Agora sim, estamos prontos para processar os dados e obter o NDVI.

Processando as bandas

Aqui instanciamos uma nova variável, que chamamos de ndvi, para receber o resultado da fórmula do NDVI. Como estamos lidando com Landsat, as bandas são as B5 (NIR) e B4 (vermelho visível). Aplicamos o método para normalizar a diferença das bandas, o que retorna uma nova imagem, que damos o nome da banda de “NDVI”:

// ******** Processamento dos dados de insumo ******** 
// Calcular o NDVI com base na diferenca normalizada
var ndvi = image.normalizedDifference(['B5', 'B4']).rename('NDVI');

Visualizando no canvas do mapa

É natural querer visualizar tanto os dados de insumo quanto os dados de processamento no canvas do mapa. Diferentemente de SIG Desktop, precisamos configurar precisamente a simbologia para as renderizações. Uma dica é usar a biblioteca ee-palletes para obter paletas de cores pré-formatadas:

// ******** Visualizacao dos insumos e produtos ******** 
// Importar paletas de cores pre-definidas (https://github.com/gee-community/ee-palettes) 
var palettes = require('users/gena/packages:palettes');

// obter a paleta de cores desejada 
var palette = palettes.colorbrewer.RdYlGn[11]

Acessando o objeto Map, podemos adicionar as camadas de dados pelo método .addLayer():

// Exibir as imagens Landsat no mapa em composicao de banda natural
Map.addLayer(image, {min: 0.05, max: 0.45, bands: ['B6', 'B5', 'B4']}, 'Composicao colorida', false);

// Exibir a camada processada de NDVI no mapa com a paleta de cores definida anteriormente
Map.addLayer(ndvi, {min: -0.1, max: 1, palette: palette}, 'NDVI');

Exportando os produtos para o Google Drive

Finalmente podemos, se preciso, exportar os resultados para o Google Drive e depois baixar para um disco local. Uma dica para reduzir o tamanho do arquivo é selecionar apenas uma região do mapa, criando uma geometria retangular:

// ******** Exportar produtos (opcional) ******** 
// Criar uma geometria retangular da area de interesse, com base em vértices xMin, yMin, xMax, yMax.
var aoi = ee.Geometry.Rectangle([-51.2242, -30.1782, -50.0106, -30.0802]);

Com o objeto Export.image, o método .toDrive() faz o resto do trabalho.

// Exportar resultado para o Google Drive
Export.image.toDrive({
  image: ndvi,
  description: 'NDVI',
  scale: 30,
  region: aoi
});

Por padrão, o formato do arquivo exportado é geotiff, e pode ser aberto em qualquer aplicação SIG Desktop, como o QGIS:

1 comentário

Deixe um comentário

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair /  Alterar )

Foto do Google

Você está comentando utilizando sua conta Google. Sair /  Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair /  Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair /  Alterar )

Conectando a %s

%d blogueiros gostam disto: