Client und Server im Vergleich

Earth Engine-Clientbibliotheken für Python und JavaScript übersetzen komplexe raumbezogene Analysen in Earth Engine-Anfragen. Code, den Sie für eine Clientbibliothek schreiben, kann eine Mischung aus Verweis auf clientseitige Objekte und Variablen enthalten, die serverseitige Objekte darstellen.

Es ist wichtig, Earth Engine-Objekte von anderen Python- oder JavaScript-Objekten oder ‑Primitiven zu unterscheiden, die in Ihrem Code enthalten sein könnten. Sie können Objekte auf dem Server bearbeiten, indem Sie clientseitige „Proxy“-Objekte in Ihrem Script bearbeiten. Proxyobjekte beginnen mit ee. Diese Earth Engine-Proxyobjekte enthalten keine Daten und sind nur Handles für Objekte auf dem Server. Betrachten wir zuerst ein clientseitiges Stringobjekt (kein Proxyobjekt):

var clientString = 'I am a String';
print(typeof clientString);  // string

import ee
import geemap.core as geemap

client_string = 'I am a String'
print(type(client_string))  # str

Sie sehen in der Ausgabe, dass der Client (der Webbrowser oder das Notebook) diesen Code interpretiert und ausgeführt hat und dabei festgestellt hat, dass die Variable vom Typ string ist. Angenommen, Sie möchten, dass Earth Engine etwas mit diesem String tun kann. Dazu müssen Sie den String in einen geeigneten Container einschließen und an Google senden. Dieser Container ist das Proxyobjekt. Beispiel:

var serverString = ee.String('I am not a String!');
print(typeof serverString);  // object
print('Is this an EE object?',
    serverString instanceof ee.ComputedObject);  // true

import ee
import geemap.core as geemap

server_string = ee.String('I am not a String!')
print(type(server_string))  # ee.ee_string.String
print(
    'Is this an EE object?', isinstance(server_string, ee.ee_string.String)
)  # True

Wie Sie in der Ausgabe sehen, ist ee.String ein object und KEIN string. Genauer gesagt ist es ein ee.computedObject, also ein Proxyobjekt für etwas auf dem Server. Stellen Sie sich ee.Thing als eine Möglichkeit vor, etwas in einen Container zu legen, um es an Google zu senden. Ihr Kunde weiß nicht, was sich im Container befindet. Sie können es herausfinden, indem Sie ihn drucken:

print(serverString);  // I am not a String

import ee
import geemap.core as geemap

print(server_string.getInfo())  # I am not a String

Wenn Sie sehen möchten, wie der Container selbst aussieht, drucken Sie die Stringdarstellung des Objekts aus:

print(serverString.toString());  // ee.String("I am not a String!")

import ee
import geemap.core as geemap

print(server_string)  # ee.String({"constantValue": "I am not a String!"})

Wenn Sie aus irgendeinem Grund Python oder JavaScript verwenden müssen, das im Client ausgeführt wird, um den Inhalt des Containers zu manipulieren, verwenden Sie getInfo(), um den Inhalt des Containers abzurufen und einer Variablen zuzuweisen:

var someString = serverString.getInfo();
var strings = someString + '  Am I?';
print(strings);  // I am not a String!  Am I?

import ee
import geemap.core as geemap

some_string = server_string.getInfo()
strings = some_string + '  Am I?'
print(strings)  # I am not a String!  Am I?

Looping

Da der Client nicht weiß, was in serverseitigen ee.Thing-Objekten enthalten ist, funktionieren clientseitige Vorgänge wie Bedingungen und For-Schleifen nicht mit ihnen. Aus diesem Grund und um synchrone Aufrufe von getInfo() zu vermeiden, sollten Sie nach Möglichkeit Serverfunktionen verwenden. Betrachten Sie beispielsweise die folgenden beiden Möglichkeiten zum Erstellen einer Liste:

Nicht empfohlen: clientseitige For-Schleife

var clientList = [];
for(var i = 0; i < 8; i++) {
  clientList.push(i + 1);
}
print(clientList);

import ee
import geemap.core as geemap

client_list = []
for i in range(8):
  client_list.append(i + 1)
print(client_list)

Empfohlen: serverseitige Zuordnung

var serverList = ee.List.sequence(0, 7);
serverList = serverList.map(function(n) {
  return ee.Number(n).add(1);
});
print(serverList);

import ee
import geemap.core as geemap

server_list = ee.List.sequence(0, 7)
server_list = server_list.map(lambda n: ee.Number(n).add(1))
print(server_list.getInfo())

Das Beispiel für die serverseitige Zuordnung ist ein wenig albern, da Sie dieselbe Liste einfach mit ee.List.sequence(1, 8) erstellen könnten. Es veranschaulicht jedoch einige wichtige Konzepte. Das erste Konzept ist map(), mit dem einfach dieselbe Funktion auf alle Elemente in der Liste angewendet wird. Da diese Funktion auf dem Server ausgeführt wird, funktionieren clientseitige Funktionen wie getInfo() und print() in einer zugeordneten Funktion nicht. Aus diesem Grund muss der i + 1-Code durch den entsprechenden serverseitigen Code ersetzt werden: ee.Number(n).add(1). Wichtig: n ist ein Objekt, das nur auf dem Server vorhanden ist. Da der Typ des Arguments der Funktion nicht bekannt ist, muss es in eine ee.Number umgewandelt werden.

Es ist auch erwähnenswert, dass clientseitige Funktionen gelegentlich praktisch sind. Mit der vorherigen For-Schleife kann beispielsweise eine Liste erstellt und in ein serverseitiges Objekt verpackt werden:

var toServerList = ee.List(clientList);

import ee
import geemap.core as geemap

to_server_list = ee.List(client_list)

Die clientseitige Verarbeitung erfolgt auf Ihrem Notebook oder Browser, also auf der CPU des Hostcomputers. Sie ist daher möglicherweise weniger effizient als die Verarbeitung mit Earth Engine auf dem Server. Außerdem sollten Sie Client- und Serverfunktionen in Ihren Scripts nicht mischen, um potenziell überraschende Ergebnisse zu vermeiden. Im Abschnitt Bedingungen finden Sie ein Beispiel für möglicherweise unbeabsichtigte Folgen.

Bedingungen

Serverseitige Objekte funktionieren nicht unbedingt mit clientseitigen Funktionen und umgekehrt. Betrachten wir beispielsweise eine serverseitige boolesche Variable:

var myList = ee.List([1, 2, 3]);
var serverBoolean = myList.contains(5);
print(serverBoolean);  // false

import ee
import geemap.core as geemap

my_list = ee.List([1, 2, 3])
server_boolean = my_list.contains(5)
print(server_boolean.getInfo())  # False

Wie im folgenden Beispiel gezeigt, funktioniert die Variable nicht in einer clientseitigen Bedingung, da es sich um ein serverseitiges Objekt handelt. Verwenden Sie eine serverseitige Funktion, um einen booleschen Wert auf der Serverseite korrekt zu prüfen:

Nicht empfohlen – clientseitige Bedingung

var clientConditional;
if (serverBoolean) {
  clientConditional = true;
} else {
  clientConditional = false;
}
print('Should be false:', clientConditional);  // True!

import ee
import geemap.core as geemap

if server_boolean:
  client_conditional = True
else:
  client_conditional = False
print('Should be False:', client_conditional)  # True!

Empfohlen: serverseitige Bedingung

var serverConditional = ee.Algorithms.If(serverBoolean, 'True!', 'False!');
print('Should be false:', serverConditional);  // False!

import ee
import geemap.core as geemap

server_conditional = ee.Algorithms.If(server_boolean, 'True!', 'False!')
print('Should be False:', server_conditional.getInfo())  # False!

Client- und Serverfunktionen

In den vorherigen Abschnitten wurden mehrere Gründe beschrieben, warum es ineffizient oder unlogisch ist, Client- und Serverobjekte und ‑funktionen zu mischen. Welche Objekte und Funktionen sind clientseitig und welche serverseitig? Im Allgemeinen ist alles, was als ee.Thing initialisiert wird, ein Serverobjekt und jede Methode dieses Objekts, ee.Thing.method(), ist eine Serverfunktion. Objekte und Funktionen, die in der Python- oder JavaScript-Referenz aufgeführt sind, sind clientseitig. Wie bereits erwähnt, können Sie clientseitige Funktionen verwenden, um ein Objekt zu erstellen, und es dann einschließen, indem Sie das clientseitige Objekt einem Earth Engine-Konstruktor wie ee.String() übergeben.