Las bibliotecas cliente de Earth Engine para Python y JavaScript traducen análisis geoespaciales complejos en solicitudes de Earth Engine. El código que escribes para una biblioteca cliente puede contener una combinación de referencias a objetos y variables del cliente que representan objetos del servidor.
Es importante distinguir los objetos de Earth Engine de otros objetos o primitivos de Python o JavaScript que puedan estar en tu código. Puedes manipular objetos en el servidor manipulando los objetos "proxy" del cliente en tu secuencia de comandos. Puedes reconocer un objeto proxy como cualquier elemento que comience con ee. Estos objetos de proxy de Earth Engine no contienen datos reales y son solo identificadores de objetos en el servidor. Para comenzar, considera un objeto de cadena del cliente (que NO es un objeto de proxy):
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
Observa en el resultado que el cliente (el navegador web o la notebook) interpretó este código y lo ejecutó, y determinó que la variable es del tipo string. Ahora supongamos que quieres que Earth Engine pueda hacer algo con esta cadena. Para ello, debes unir la cadena en un contenedor ordenado
y enviarla a Google. Ese contenedor es el objeto proxy. Por ejemplo:
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
Observa en el resultado que ee.String es object,
NO string. Más específicamente, es un ee.computedObject, lo que significa que es un objeto proxy para algo en el servidor. Piensa en ee.Thing como
la forma de colocar un elemento en un contenedor para enviarlo a Google. Tu cliente no sabe qué hay en el contenedor, pero puedes averiguarlo si lo imprimes:
print(serverString); // I am not a String
import ee import geemap.core as geemap
print(server_string.getInfo()) # I am not a String
Para ver cómo se ve el contenedor, imprime la representación de cadena del objeto:
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!"})
Si, por algún motivo, necesitas usar Python o JavaScript
en ejecución en el cliente para manipular lo que está en el contenedor, usa
getInfo() para obtener el contenido del contenedor y asignarlo a una variable:
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?
Repetición
Debido a que el cliente no sabe qué contiene los objetos ee.Thing del servidor, las operaciones del cliente, como las condicionales y los bucles for, no funcionan con ellos. Por
ese motivo, y para evitar llamadas síncronas a getInfo(), usa funciones
del servidor en la medida de lo posible. Por ejemplo, considera las siguientes dos formas de crear una lista:
No se recomienda: bucle for del cliente
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)
Recomendado: Asignación del servidor
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())
El ejemplo de asignación del servidor es un poco porque podrías hacer la misma lista solo con ee.List.sequence(1, 8), pero ilustra algunos conceptos importantes. El primer concepto es map(), que simplemente aplica la misma función a todo lo que está en la lista. Debido a que esta función se ejecuta en el servidor, las funciones del cliente, como getInfo() y print(), no funcionarán en una función asignada. Por esa razón, el código i + 1 debe reemplazarse por el código del servidor equivalente: ee.Number(n).add(1). Es importante tener en cuenta que n es un objeto que solo existe en el servidor. Como la función no conoce el tipo de su argumento, se debe transmitir a un ee.Number.
También es importante tener en cuenta que, en ocasiones, la funcionalidad del cliente es conveniente. Por ejemplo, el bucle for anterior se podría usar para crear una lista y unirla con un objeto del servidor:
var toServerList = ee.List(clientList);
import ee import geemap.core as geemap
to_server_list = ee.List(client_list)
Ten en cuenta que el procesamiento del cliente se realiza en tu notebook o navegador, la CPU de la máquina anfitrión, por lo que puede ser menos eficiente que usar Earth Engine para realizar el trabajo en el servidor. Además, para evitar resultados potencialmente sorprendentes, se recomienda evitar mezclar la funcionalidad del cliente y del servidor en tus secuencias de comandos. En la sección Condicionales, se proporciona un ejemplo de consecuencias posiblemente no deseadas.
Condicionales
Los objetos del servidor no necesariamente funcionan con funciones del cliente y viceversa. Por ejemplo, considera el caso de una variable booleana del servidor:
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
Como se muestra en el siguiente ejemplo, la variable no se comporta en una sentencia condicional del cliente porque es un objeto del servidor. Para verificar correctamente un valor booleano del servidor, usa una función del servidor:
No se recomienda: Condicional del cliente
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!
Recomendado: Condicional del servidor
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!
Funciones del cliente y del servidor
En las secciones anteriores, se describen varios motivos por los que es ineficiente o ilógico mezclar objetos y funciones de cliente y servidor. ¿Qué objetos y funciones son del cliente y cuáles son del servidor? En general, todo lo que se inicializa como ee.Thing es un objeto de servidor, y cualquier método en ese objeto, ee.Thing.method(), es una función de servidor. Los objetos y las funciones que aparecen en la referencia de Python o JavaScript son del cliente. Como se señaló anteriormente, puedes usar la funcionalidad del cliente para crear un objeto y, luego, unirlo proporcionando el objeto del cliente a un constructor de Earth Engine, por ejemplo, ee.String().