Deferred Execution

The Client vs. Server doc descibes how objects referenced in your script can be either client-side or server-side. The complete script contains not only the objects you want to use, but also a set of instructions that tell Earth Engine what to do with them. This doc describes how those instructions are sent to Google for processing and how the results are sent back to your web browser (the client) for display.

When you write a script in Earth Engine (either JavaScript or Python), that code does NOT run directly on Earth Engine servers at Google. Instead, the client library encodes the script into a set of JSON objects, sends the objects to Google and waits for a response. Each object represents a set of operations required to get a particular output, an image to display in the client, for example. Consider the following JavaScript code, run in the Code Editor:

var image = ee.Image('CGIAR/SRTM90_V4');
var operation = image.add(10);
print(operation.toString());
print(operation);
    

The first print statement will output the JSON structure that the client library uses to describe that image to the server at Google:

ee.Image({
  "type": "Invocation",
  "arguments": {
    "image1": {
      "type": "Invocation",
      "arguments": {
        "id": "CGIAR/SRTM90_V4"
      },
      "functionName": "Image.load"
    },
    "image2": {
      "type": "Invocation",
      "arguments": {
        "value": 10
      },
      "functionName": "Image.constant"
    }
  },
  "functionName": "Image.add"
})
    

The second print statement will send the request to Google and output the POST response from Google servers. To see the response in all its JSON glory, click the JSON link on the right side of the console, next to the printed object:

{
  "type": "Image",
  "bands": [
    {
      "id": "elevation",
      "data_type": {
        "type": "PixelType",
        "precision": "int",
        "min": -32758,
        "max": 32777
      },
      "crs": "EPSG:4326",
      "crs_transform": [
        0.0008333333535119891,
        0,
        -180,
        0,
        -0.0008333333535119891,
        60
      ]
    }
  ]
}
    

Nothing is sent to Google for processing until there is a request for it. In this example, print() is sufficient to request the result of the computation. (In Python, it's necessary to call getInfo() on the object being printed; otherwise the request JSON is printed). No processing is done on the server until that result is explicitly requested.

Another example of requesting something is displaying it on the map with Map.addLayer(). When this request is sent to Google, only the tiles necessary to display the result in the Code Editor are returned. Specifically, the position of the map and the zoom level determine which data get processed and turned into images that can be displayed on the map. If you pan or zoom, note that other tiles are computed lazily. This on-demand system allows for parallelization and efficient processing, but also means that the image displayed on the map is produced from different inputs depending on the zoom level and location of the map bounds as visible in the Code Editor. Learn more about how inputs to a computation are determined from the request in the Scale doc.

发送以下问题的反馈:

此网页
Google Earth Engine API