Calculs de tableaux avec l'API REST Earth Engine

Logo Colab Exécuter dans Google Colab Logo GitHub Afficher la source sur GitHub

Remarque : L'API REST contient des fonctionnalités nouvelles et avancées qui peuvent ne pas convenir à tous les utilisateurs. Si vous débutez avec Earth Engine, veuillez commencer par le guide JavaScript.

Le guide de démarrage rapide de l'API REST Earth Engine explique comment accéder à des blocs de pixels à partir d'un élément Earth Engine. L'exemple de pixels de calcul montre comment appliquer un calcul aux pixels avant d'obtenir le résultat. Cet exemple montre comment obtenir la moyenne des pixels de chaque image d'un ImageCollection dans chaque caractéristique d'un FeatureCollection. Plus précisément, il s'agit d'une requête POST au point de terminaison computeFeatures.

Avant de commencer

Suivez ces instructions pour :

  1. Demander à utiliser Earth Engine
  2. Créer un projet Google Cloud
  3. Activez l'API Earth Engine sur le projet.
  4. Créer un compte de service
  5. Accorder au compte de service une autorisation au niveau du projet pour effectuer des calculs Earth Engine

Remarque : Pour suivre ce tutoriel, vous aurez besoin d'un compte de service enregistré pour accéder à Earth Engine. Consultez ces instructions pour enregistrer un compte de service avant de continuer.

S'authentifier sur Google Cloud

La première chose à faire est de vous connecter pour pouvoir envoyer des requêtes authentifiées à Google Cloud. Vous définirez le projet en même temps. Suivez les instructions fournies dans le résultat pour finaliser la connexion.

# INSERT YOUR PROJECT HERE
PROJECT = 'your-project'

!gcloud auth login --project {PROJECT}

Obtenir un fichier de clé privée pour votre compte de service

Vous devriez déjà disposer d'un compte de service enregistré pour utiliser Earth Engine. Si ce n'est pas le cas, suivez ces instructions pour en obtenir un. Copiez l'adresse e-mail de votre compte de service dans la cellule suivante. (Le compte de service doit déjà être enregistré pour utiliser Earth Engine.) Dans la cellule suivante, la ligne de commande gsutil est utilisée pour générer un fichier de clé pour le compte de service. Le fichier de clé sera créé sur la VM du notebook.

# INSERT YOUR SERVICE ACCOUNT HERE
SERVICE_ACCOUNT='your-service-account@your-project.iam.gserviceaccount.com'
KEY = 'key.json'

!gcloud iam service-accounts keys create {KEY} --iam-account {SERVICE_ACCOUNT}

Démarrer un AuthorizedSession et tester vos identifiants

Testez la clé privée en l'utilisant pour obtenir des identifiants. Utilisez les identifiants pour créer une session autorisée permettant d'effectuer des requêtes HTTP. Envoyez une requête GET via la session pour vérifier que les identifiants fonctionnent.

from google.auth.transport.requests import AuthorizedSession
from google.oauth2 import service_account

credentials = service_account.Credentials.from_service_account_file(KEY)
scoped_credentials = credentials.with_scopes(
    ['https://www.googleapis.com/auth/cloud-platform'])

session = AuthorizedSession(scoped_credentials)

url = 'https://earthengine.googleapis.com/v1beta/projects/earthengine-public/assets/LANDSAT'

response = session.get(url)

from pprint import pprint
import json
pprint(json.loads(response.content))

Sérialiser un calcul

Avant de pouvoir envoyer une requête pour calculer quelque chose, le calcul doit être mis au format du graphe d'expression Earth Engine. L'exemple suivant montre comment obtenir le graphique d'expression.

S'authentifier auprès d'Earth Engine

Obtenez des identifiants à portée Earth Engine à partir du compte de service. Utilisez-les pour initialiser Earth Engine.

import ee

# Get some new credentials since the other ones are cloud scope.
ee_creds = ee.ServiceAccountCredentials(SERVICE_ACCOUNT, KEY)
ee.Initialize(ee_creds)

Définir un calcul

Prototyper un calcul simple avec l'API cliente Notez que le résultat du calcul est un FeatureCollection. Pour vérifier que le calcul peut réussir sans erreur, obtenez une valeur à partir du premier Feature (NDVI moyen dans le polygone).

# A collection of polygons.
states = ee.FeatureCollection('TIGER/2018/States')
maine = states.filter(ee.Filter.eq('NAME', 'Maine'))

# Imagery: NDVI vegetation index from MODIS.
band = 'NDVI'
images = ee.ImageCollection('MODIS/006/MOD13Q1').select(band)
image = images.first()

computation = image.reduceRegions(
  collection=maine, 
  reducer=ee.Reducer.mean().setOutputs([band]), 
  scale=image.projection().nominalScale()
)

# Print the value to test.
print(computation.first().get(band).getInfo())

Sérialiser le graphique d'expression

Cela créera un objet qui représente le graphique d'expression Earth Engine (plus précisément, un Expression). En général, vous devez les créer avec l'une des API clientes.

# Serialize the computation.
serialized = ee.serializer.encode(computation)

Envoyer la requête

Envoyez une requête POST au point de terminaison computeFeatures. Notez que la requête contient Expression, qui correspond au calcul sérialisé.

import json

url = 'https://earthengine.googleapis.com/v1beta/projects/{}/table:computeFeatures'

response = session.post(
  url = url.format(PROJECT),
  data = json.dumps({'expression': serialized})
)

import json
pprint(json.loads(response.content))

La réponse contient le FeatureCollection résultant au format GeoJSON, qui peut être utilisé par d'autres applications ou processus.