Calculs d'images 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. Imaginons que vous souhaitiez appliquer un calcul aux pixels avant d'obtenir le résultat. Ce guide explique comment prototyper un calcul avec l'une des bibliothèques clientes, sérialiser le graphique de calcul et utiliser l'API REST pour obtenir le résultat calculé. L'envoi de requêtes de calcul via l'API REST correspond à une requête POST à l'un des points de terminaison de calcul, par exemple computePixels, computeFeatures ou le point de terminaison générique value.compute. Plus précisément, cet exemple montre comment obtenir un composite médian d'images Sentinel-2 dans une petite région.

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 Image.

coords = [
  -121.58626826832939,
  38.059141484827485,
]
region = ee.Geometry.Point(coords)

collection = ee.ImageCollection('COPERNICUS/S2')
collection = collection.filterBounds(region)
collection = collection.filterDate('2020-04-01', '2020-09-01')
image = collection.median()

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.

serialized = ee.serializer.encode(image)

Créez la projection souhaitée (WGS84) à l'échelle souhaitée (10 mètres pour Sentinel-2). Il s'agit simplement de découvrir l'échelle souhaitée en degrés, les unités de la projection. Ces échelles seront utilisées pour spécifier la transformation affine dans la requête.

# Make a projection to discover the scale in degrees.
proj = ee.Projection('EPSG:4326').atScale(10).getInfo()

# Get scales out of the transform.
scale_x = proj['transform'][0]
scale_y = -proj['transform'][4]

Envoyer la requête

Envoyez une requête POST au point de terminaison computePixels. Notez que la requête contient Expression, qui correspond au calcul sérialisé. Il contient également un PixelGrid. Le PixelGrid contient dimensions pour la sortie souhaitée et un AffineTransform dans les unités du système de coordonnées demandé. Ici, le système de coordonnées est géographique. La transformation est donc spécifiée avec une échelle en degrés et les coordonnées géographiques de l'angle supérieur gauche du patch d'image demandé.

import json

url = 'https://earthengine.googleapis.com/v1beta/projects/{}/image:computePixels'
url = url.format(PROJECT)

response = session.post(
  url=url,
  data=json.dumps({
    'expression': serialized,
    'fileFormat': 'PNG',
    'bandIds': ['B4','B3','B2'],
    'grid': {
      'dimensions': {
        'width': 640,
        'height': 640
      },
      'affineTransform': {
        'scaleX': scale_x,
        'shearX': 0,
        'translateX': coords[0],
        'shearY': 0,
        'scaleY': scale_y,
        'translateY': coords[1]
      },
      'crsCode': 'EPSG:4326',
    },
    'visualizationOptions': {'ranges': [{'min': 0, 'max': 3000}]},
  })
)

image_content = response.content

Si vous exécutez cette opération dans un notebook, vous pouvez afficher les résultats à l'aide du widget d'affichage d'images IPython.

# Import the Image function from the IPython.display module.
from IPython.display import Image
Image(image_content)