Google Earth Engine Documentation

https://github.com/wybert/earthengine-doc-md
Admin
This project provides markdown versions of the Google Earth Engine documentation, excluding the...
Tokens:3,245,435
Snippets:19,734
Trust Score:7.4
Update:4 weeks ago
Show doc for...
Tokens:
Raw
### Python setup and example for ee.String.compareTo

Source: https://github.com/wybert/earthengine-doc-md/blob/main/docs/apidocs/ee-string-compareto.md

Python setup and example for Colab. The setup imports the Earth Engine and geemap libraries. The example prints the results of comparing strings with ee.String.compareTo, using getInfo() to retrieve the values.

```python
import ee
import geemap.core as geemap
```

```python
print(ee.String('a').compareTo('b').getInfo())  # -1
print(ee.String('a').compareTo('a').getInfo())  # 0
print(ee.String('b').compareTo('a').getInfo())  # 1

print(ee.String('a').compareTo(ee.String('b')).getInfo())  # -1
```

--------------------------------

### ee.List.cat Python examples with setup

Source: https://github.com/wybert/earthengine-doc-md/blob/main/docs/apidocs/ee-list-cat.md

Python setup and examples for ee.List.cat. The setup imports the Earth Engine API and geemap. The examples show concatenating lists with various element types and empty lists, using getInfo() to retrieve the result.

```python
import ee
import geemap.core as geemap
```

```python
print(ee.List(['dog']).cat(['squirrel']).getInfo()) # ['dog', 'squirrel']
# ['moose', '&', 'squirrel']
print(ee.List(['moose']).cat(['&', 'squirrel']).getInfo())
# [['a', 'b'], ['1', 1]]
print(ee.List([['a', 'b']]).cat(ee.List([['1', 1]])).getInfo())
print(ee.List([]).cat(ee.List([])).getInfo()) # []
print(ee.List([1]).cat(ee.List([])).getInfo()) # [1]
print(ee.List([]).cat(ee.List([2])).getInfo()) # [2]
```

--------------------------------

### Python: Setup and Get Geometry Type

Source: https://github.com/wybert/earthengine-doc-md/blob/main/docs/apidocs/ee-geometry-type.md

Example demonstrating the necessary imports and the usage of the type method in a Python environment using geemap.

```python
importee
importgeemap.coreasgeemap
```

```python
# Define a Geometry object.
geometry = ee.Geometry({
    'type': 'Polygon',
    'coordinates': [[
        [-122.081, 37.417],
        [-122.086, 37.421],
        [-122.084, 37.418],
        [-122.089, 37.416],
    ]],
})

# Apply the type method to the Geometry object.
geometry_type = geometry.type()

# Print the result.
display('geometry.type(...) =', geometry_type)

# Display relevant geometries on the map.
m = geemap.Map()
m.set_center(-122.085, 37.422, 15)
m.add_layer(geometry, {'color': 'black'}, 'Geometry [black]: geometry')
m
```

--------------------------------

### Python setup and example for ee.Image.not()

Source: https://github.com/wybert/earthengine-doc-md/blob/main/docs/apidocs/ee-image-not.md

Python setup and example for Colab. The setup imports ee and geemap.core. The example authenticates, initializes, creates an image with constant 3, applies Not() twice, prints results, and samples at a point.

```python
import ee
import geemap.core as geemap
```

```python
"""Demonstrates the ee.Image.Not method.

This example uses positive integers; non-integer and negative
values are allowed.
"""

import pprint
import ee
ee.Authenticate()
ee.Initialize()

not_zeros = ee.Image(3)  # Define an image where all pixels are not zero.
zeros = not_zeros.Not()  # Pixels are not zeros, return zeros.
ones = zeros.Not()  # Pixels are zeros, return ones.

print('zeros:')
pprint.pprint(zeros.getInfo())
print('\nones:')
pprint.pprint(ones.getInfo())

# Sample images at a location and print the results.
loc = ee.Geometry.Point(0, 0)  # Location to sample image values.
print('not_zeros:', not_zeros.sample(loc, 1).first().get('constant').getInfo())
print('zeros:', zeros.sample(loc, 1).first().get('constant').getInfo())
print('ones:', ones.sample(loc, 1).first().get('constant').getInfo())
```

--------------------------------

### Python setup and example: ee.Array.eq

Source: https://github.com/wybert/earthengine-doc-md/blob/main/docs/apidocs/ee-array-eq.md

Shows the Python setup required to run Earth Engine examples interactively (importing ee and geemap), followed by the Python version of the ee.Array.eq example. The setup is a prerequisite for using the Python API with geemap.

```Python
import ee
import geemap.core as geemap
```

```Python
empty = ee.Array([], ee.PixelType.int8())
display(empty.eq(empty))  # []

display(ee.Array([0]).eq(ee.Array([1])))  # 0
display(ee.Array([0]).eq(ee.Array([0])))  # 1

display(ee.Array([1.1]).eq(ee.Array([1.1])))  # 1
display(ee.Array([1.1]).float().eq(ee.Array([1.1])))  # 0
display(ee.Array([1.1]).double().eq(ee.Array([1.1])))  # 1

display(ee.Array([1]).int8().eq(ee.Array([1])))  # 1
display(ee.Array([1]).int8().eq(ee.Array([1]).int32()))  # 1
```

--------------------------------

### Python: Setup and clustering example

Source: https://github.com/wybert/earthengine-doc-md/blob/main/docs/guides/clustering.md

Python setup imports and a complete clustering example using geemap, including region definition, Landsat composite loading, training, clustering, and map display.

```Python
import ee
import geemap.core as geemap
```

```Python
# Define a region in which to generate a segmented map.
region = ee.Geometry.Rectangle(29.7, 30, 32.5, 31.7)

# Load a Landsat composite for input.
input = (
    ee.ImageCollection('LANDSAT/COMPOSITES/C02/T1_L2_32DAY')
    .filterDate('2001-05', '2001-06')
    .first()
    .clip(region)
)

# Display the sample region.
m = geemap.Map()
m.set_center(31.5, 31.0, 8)
m.add_layer(ee.Image().paint(region, 0, 2), {}, 'region')

# Make the training dataset.
training = input.sample(region=region, scale=30, numPixels=5000)

# Instantiate the clusterer and train it.
clusterer = ee.Clusterer.wekaKMeans(15).train(training)

# Cluster the input using the trained clusterer.
result = input.cluster(clusterer)

# Display the clusters with random colors.
m.add_layer(result.randomVisualizer(), {}, 'clusters')
m
```

--------------------------------

### ee.Array.first Python example with setup

Source: https://github.com/wybert/earthengine-doc-md/blob/main/docs/apidocs/ee-array-first.md

Python setup and example for ee.Array.first. Requires the Earth Engine Python API and geemap for interactive development. The example mirrors the JavaScript version, using display() instead of print().

```python
import ee
import geemap.core as geemap
```

```python
empty = ee.Array([], ee.PixelType.int8())
display(empty.first(empty))  # []

display(ee.Array([0]).first(0))  # [0]
display(ee.Array([0, 1, 2]).first(1))  # [0,1,2]
display(ee.Array([0, 1, 2]).first(ee.Array([3, 4, 5])))  # [0, 1, 2]
display(ee.Array([3, 4, 5]).first(ee.Array([0, 1, 2])))  # [3, 4, 5]
```

--------------------------------

### Python: ee.Geometry.MultiPoint.centroid example with setup

Source: https://github.com/wybert/earthengine-doc-md/blob/main/docs/apidocs/ee-geometry-multipoint-centroid.md

Python setup and example for the Earth Engine API. The setup imports the Earth Engine and geemap core modules. The example defines a MultiPoint, applies the centroid method with maxError=1, prints the result, and displays the geometries on an interactive map.

```python
importee
importgeemap.coreasgeemap
```

```python
# Define a MultiPoint object.
multipoint = ee.Geometry.MultiPoint([[-122.082, 37.420], [-122.081, 37.426]])

# Apply the centroid method to the MultiPoint object.
multipoint_centroid = multipoint.centroid(maxError=1)

# Print the result.
display('multipoint.centroid(...) =', multipoint_centroid)

# Display relevant geometries on the map.
m = geemap.Map()
m.set_center(-122.085, 37.422, 15)
m.add_layer(multipoint, {'color': 'black'}, 'Geometry [black]: multipoint')
m.add_layer(
    multipoint_centroid, {'color': 'red'}, 'Result [red]: multipoint.centroid'
)
m
```

--------------------------------

### Python example for ee.Number.gte with setup

Source: https://github.com/wybert/earthengine-doc-md/blob/main/docs/apidocs/ee-number-gte.md

Colab (Python) example for ee.Number.gte. The first block shows the required setup for the Python API and geemap. The second block prints the results of gte comparisons using getInfo().

```python
importee
importgeemap.coreasgeemap
```

```python
# 0
print('5 greater than or equal to 10?',
      ee.Number(5).gte(ee.Number(10)).getInfo())
# 1
print('10 greater than or equal to 5?',
      ee.Number(10).gte(ee.Number(5)).getInfo())
# 1
print('5 greater than or equal to 5?',
      ee.Number(5).gte(ee.Number(5)).getInfo())
```

--------------------------------

### Python setup and example for ee.Number.gamma()

Source: https://github.com/wybert/earthengine-doc-md/blob/main/docs/apidocs/ee-number-gamma.md

Python setup code for importing the Earth Engine API and geemap, followed by an example usage. The example prints gamma function outputs and notes that values less than or equal to 0 are invalid.

```Python
import ee
import geemap.core as geemap

```

```Python
# Values less than or equal to 0 are invalid.
print('Gamma for 0.001:', ee.Number(0.001).gamma().getInfo())  # 999.423772484
print('Gamma for 0.5:', ee.Number(0.5).gamma().getInfo())  # 1.772453850
print('Gamma for 1:', ee.Number(1).gamma().getInfo())  # 1
print('Gamma for 100:', ee.Number(100).gamma().getInfo())  # 9.332621544e+155
print('Gamma for 200:', ee.Number(200).gamma().getInfo())  # Infinity

```

--------------------------------

### Python setup and example of ee.Number.min

Source: https://github.com/wybert/earthengine-doc-md/blob/main/docs/apidocs/ee-number-min.md

Python setup for using the Earth Engine API with geemap, followed by an example that prints the minimum of 5 and 10 using ee.Number.min. The output is 5.

```python
importee
importgeemap.coreasgeemap
```

```python
print('Given 5 and 10, min is 5:',
      ee.Number(5).min(ee.Number(10)).getInfo())  # 5
```

--------------------------------

### Python: Point.projection() example with geemap

Source: https://github.com/wybert/earthengine-doc-md/blob/main/docs/apidocs/ee-geometry-point-projection.md

Python setup and example for Colab. The setup imports ee and geemap.core. The example creates a Point, calls projection(), prints the result, and displays the geometry on an interactive map.

```python
importee
importgeemap.coreasgeemap
```

```python
# Define a Point object.
point = ee.Geometry.Point(-122.082, 37.42)

# Apply the projection method to the Point object.
point_projection = point.projection()

# Print the result.
display('point.projection(...) =', point_projection)

# Display relevant geometries on the map.
m = geemap.Map()
m.set_center(-122.085, 37.422, 15)
m.add_layer(point, {'color': 'black'}, 'Geometry [black]: point')
m
```

--------------------------------

### Python: ee.Geometry.MultiLineString.union example with setup

Source: https://github.com/wybert/earthengine-doc-md/blob/main/docs/apidocs/ee-geometry-multilinestring-union.md

Colab (Python) example for ee.Geometry.MultiLineString.union. Includes the required Python setup imports (ee and geemap) and the main example that defines a MultiLineString, applies union with maxError=1, prints the result, and displays the geometries on a geemap map.

```python
importee
importgeemap.coreasgeemap
```

```python
# Define a MultiLineString object.
multilinestring = ee.Geometry.MultiLineString([
    [[-122.088, 37.418], [-122.086, 37.422], [-122.082, 37.418]],
    [[-122.087, 37.416], [-122.083, 37.416], [-122.082, 37.419]],
])

# Define other inputs.
input_geom = ee.Geometry.BBox(-122.085, 37.415, -122.075, 37.425)

# Apply the union method to the MultiLineString object.
multilinestring_union = multilinestring.union(right=input_geom, maxError=1)

# Print the result.
display('multilinestring.union(...) =', multilinestring_union)

# Display relevant geometries on the map.
m = geemap.Map()
m.set_center(-122.085, 37.422, 15)
m.add_layer(
    multilinestring, {'color': 'black'}, 'Geometry [black]: multilinestring'
)
m.add_layer(input_geom, {'color': 'blue'}, 'Parameter [blue]: input_geom')
m.add_layer(
    multilinestring_union,
    {'color': 'red'},
    'Result [red]: multilinestring.union',
)
m
```

--------------------------------

### Python: Setup and create dictionary with size

Source: https://github.com/wybert/earthengine-doc-md/blob/main/docs/apidocs/ee-dictionary-size.md

Python setup imports ee and geemap.core. Then creates an ee.Dictionary with three entries and prints the size using dic.size().getInfo().

```Python
importee
importgeemap.coreasgeemap
```

```Python
# A dictionary (e.g. results of ee.Image.reduceRegion of an S2 image).
dic = ee.Dictionary({
    'B1': 182,
    'B2': 219,
    'B3': 443
})

print('The number of dictionary entries:', dic.size().getInfo())
```

--------------------------------

### Python: Setup and get first and second 3 images from Landsat 8 collection

Source: https://github.com/wybert/earthengine-doc-md/blob/main/docs/apidocs/ee-imagecollection-tolist.md

Python setup for using the Earth Engine API with geemap, followed by an example that fetches the first and second 3 images from a Landsat 8 TOA collection using toList with count and offset. Includes the same memory warning as the JavaScript example.

```Python
import ee
import geemap.core as geemap
```

```Python
# Note: ee.ImageCollection.toList may take a lot of time and memory to run,
# since it must generate all of the results in order to gather them into a
# list. Large collections and/or complex computations can produce memory
# limitation errors.

# A Landsat 8 TOA image collection (1 year of images at a specific point).
col = ee.ImageCollection('LANDSAT/LC08/C02/T1_TOA').filterBounds(
    ee.Geometry.Point(-90.70, 34.71)).filterDate('2020-01-01', '2021-01-01')
print('Image collection:', col.getInfo())

# Get the first 3 images as a list of images.
img_list_first3 = col.toList(3)
print('First 3 images:', img_list_first3.getInfo())

# Get the second 3 images as a list of images (use the offset parameter).
img_list_second3 = col.toList(3, 3)
print('Second 3 images:', img_list_second3.getInfo())
```

--------------------------------

### Get rectangle info in Python with geemap

Source: https://github.com/wybert/earthengine-doc-md/blob/main/docs/apidocs/ee-geometry-rectangle-getinfo.md

Python setup and example for calling getInfo() on a ee.Geometry.Rectangle. Requires the Earth Engine Python API and geemap for interactive development.

```python
importee
importgeemap.coreasgeemap
```

```python
# Define a Rectangle object.
rectangle = ee.Geometry.Rectangle(-122.09, 37.42, -122.08, 37.43)

# Apply the getInfo method to the Rectangle object.
rectangle_get_info = rectangle.getInfo()

# Print the result.
display('rectangle.getInfo(...) =', rectangle_get_info)

# Display relevant geometries on the map.
m = geemap.Map()
m.set_center(-122.085, 37.422, 15)
m.add_layer(rectangle, {'color': 'black'}, 'Geometry [black]: rectangle')
m
```

--------------------------------

### Set and get Feature properties (JavaScript and Python)

Source: https://github.com/wybert/earthengine-doc-md/blob/main/docs/guides/features.md

Demonstrates setting and getting Feature properties. Properties can be set with key-value pairs or with a dictionary, and feature.set() overwrites existing properties. The Python setup import block is required before using the Colab example.

```javascript
// Make a feature and set some properties.
varfeature=ee.Feature(ee.Geometry.Point([-122.22599,37.17605]))
.set('genus','Sequoia').set('species','sempervirens');

// Get a property from the feature.
varspecies=feature.get('species');
print(species);

// Set a new property.
feature=feature.set('presence',1);

// Overwrite the old properties with a new dictionary.
varnewDict={genus:'Brachyramphus',species:'marmoratus'};
varfeature=feature.set(newDict);

// Check the result.
print(feature);
```

```python
importee
importgeemap.coreasgeemap
```

```python
# Make a feature and set some properties.
feature = (
    ee.Feature(ee.Geometry.Point([-122.22599, 37.17605]))
    .set('genus', 'Sequoia')
    .set('species', 'sempervirens')
)

# Get a property from the feature.
species = feature.get('species')
display(species)

# Set a new property.
feature = feature.set('presence', 1)

# Overwrite the old properties with a new dictionary.
new_dic = {'genus': 'Brachyramphus', 'species': 'marmoratus'}
feature = feature.set(new_dic)

# Check the result.
display(feature)
```

--------------------------------

### Install Algorithm and Interactive Interface

Source: https://github.com/wybert/earthengine-doc-md/blob/main/docs/tutorials/community/detecting-changes-in-sentinel-1-imagery-pt-4.md

Installs the ipyleaflet package, clones the eesarseq repository, changes to the source directory, and runs the setup script. This must be executed from a fresh runtime before using the algorithm and interactive interface.

```python
!pip install -q ipyleaflet
!git clone https://github.com/mortcanty/eesarseq
%cd /content/eesarseq/src
%run setup install

```

--------------------------------

### Get LinearRing info synchronously in Python

Source: https://github.com/wybert/earthengine-doc-md/blob/main/docs/apidocs/ee-geometry-linearring-getinfo.md

Python setup imports the Earth Engine API and geemap. The main example defines a LinearRing, calls getInfo() synchronously, prints the result, and displays the geometry on an interactive map. This is the Colab (Python) example.

```python
importee
importgeemap.coreasgeemap
```

```python
# Define a LinearRing object.
linearring = ee.Geometry.LinearRing(
    [[-122.091, 37.420], [-122.085, 37.422], [-122.080, 37.430]]
)

# Apply the getInfo method to the LinearRing object.
linearring_get_info = linearring.getInfo()

# Print the result.
display('linearring.getInfo(...) =', linearring_get_info)

# Display relevant geometries on the map.
m = geemap.Map()
m.set_center(-122.085, 37.422, 15)
m.add_layer(linearring, {'color': 'black'}, 'Geometry [black]: linearring')
m
```

--------------------------------

### Get MultiLineString type in Colab (Python)

Source: https://github.com/wybert/earthengine-doc-md/blob/main/docs/apidocs/ee-geometry-multilinestring-type.md

Colab (Python) example for ee.Geometry.MultiLineString.type(). Includes the required Python setup imports (ee and geemap.core) and the main example that defines a MultiLineString, applies the type() method, prints the result, and displays the geometry on an interactive map.

```Python
importee
importgeemap.coreasgeemap
```

```Python
# Define a MultiLineString object.
multilinestring = ee.Geometry.MultiLineString([
    [[-122.088, 37.418], [-122.086, 37.422], [-122.082, 37.418]],
    [[-122.087, 37.416], [-122.083, 37.416], [-122.082, 37.419]],
])

# Apply the type method to the MultiLineString object.
multilinestring_type = multilinestring.type()

# Print the result.
display('multilinestring.type(...) =', multilinestring_type)

# Display relevant geometries on the map.
m = geemap.Map()
m.set_center(-122.085, 37.422, 15)
m.add_layer(
    multilinestring, {'color': 'black'}, 'Geometry [black]: multilinestring'
)
m
```

--------------------------------

### Python setup and example for ee.Number.bitwiseNot

Source: https://github.com/wybert/earthengine-doc-md/blob/main/docs/apidocs/ee-number-bitwisenot.md

Python setup and example for Colab. The setup imports the Earth Engine API and geemap. The example prints the result of bitwiseNot on 25, which is -26.

```python
import ee
import geemap.core as geemap
```

```python
"""Unsigned 8-bit type example.

25 as binary:    00011001
Flip each digit: 11100110

11100110 is signed 8-bit binary for -26.
(binary interpreted using smallest signed integer type containing the input).
"""

print(ee.Number(25).bitwiseNot().getInfo())
```

--------------------------------

### Python: ee.Dictionary.fromLists example with setup

Source: https://github.com/wybert/earthengine-doc-md/blob/main/docs/apidocs/ee-dictionary-fromlists.md

Python setup for the Earth Engine API and geemap, followed by an example that constructs a Dictionary from parallel lists of keys and values and prints the result using getInfo(). Requires the Python environment and geemap for interactive development.

```python
importee
importgeemap.coreasgeemap
```

```python
# Corresponding lists of keys and values.
keys = ['B1', 'B2', 'B3']
values = [182, 219, 443]
print('Dictionary from lists of keys and values:',
      ee.Dictionary.fromLists(keys, values).getInfo())
```

--------------------------------

### Set and get ImageCollection properties (Python)

Source: https://github.com/wybert/earthengine-doc-md/blob/main/docs/apidocs/ee-imagecollection-get.md

Python equivalent of the JavaScript example, using the Earth Engine Python API and geemap. Requires the Python environment setup with geemap for interactive development. Demonstrates setting and getting collection properties, with getInfo() to retrieve values.

```Python
importee
importgeemap.coreasgeemap
```

```Python
frompprintimport pprint

# A contrived, empty image collection for simple demonstration.
col = ee.ImageCollection([])
print('Collection without properties:')
pprint(col.getInfo())

# Set collection properties using a dictionary.
col = col.set({
    'project_name': 'biomass_tracking',
    'project_id': 3,
    'plot_ids': ee.Array([7, 11, 20])
})

# Set collection properties using a series of key-value pairs.
col = col.set('project_year', 2018,
              'rgb_vis', 'false_color')

print('Collection with properties:')
pprint(col.getInfo())

# Get a dictionary of collection property keys and values.
print('Property keys and values (ee.Dictionary):')
pprint(col.toDictionary().getInfo())

# Get the value of a collection property. To use the result of
# ee.ImageCollection.get in further computation, you need to cast it to the
# appropriate class, for example, ee.Number(result) or ee.String(result).
print('Project ID (ambiguous object):', col.get('project_id').getInfo())

# Get the value of a string collection property as an ee.String object.
print('Project name (ee.String):', col.getString('project_name').getInfo())

# Get the value of a numeric collection property as an ee.Number object.
print('Project year (ee.Number):', col.getNumber('project_year').getInfo())

# Get the value of an ee.Array collection property as an ee.Array object.
print('Plot IDs (ee.Array):', col.getArray('plot_ids').getInfo())
```

--------------------------------

### Get rectangle coordinates in Colab (Python)

Source: https://github.com/wybert/earthengine-doc-md/blob/main/docs/apidocs/ee-geometry-rectangle-coordinates.md

Python setup imports the Earth Engine API and geemap. The example defines a rectangle, calls coordinates(), prints the result, and displays the geometry on an interactive map.

```Python
importee
importgeemap.coreasgeemap
```

```Python
# Define a Rectangle object.
rectangle = ee.Geometry.Rectangle(-122.09, 37.42, -122.08, 37.43)

# Apply the coordinates method to the Rectangle object.
rectangle_coordinates = rectangle.coordinates()

# Print the result.
display('rectangle.coordinates(...) =', rectangle_coordinates)

# Display relevant geometries on the map.
m = geemap.Map()
m.set_center(-122.085, 37.422, 15)
m.add_layer(rectangle, {'color': 'black'}, 'Geometry [black]: rectangle')
m
```

--------------------------------

### ee.Algorithms.If Python example with setup

Source: https://github.com/wybert/earthengine-doc-md/blob/main/docs/apidocs/ee-algorithms-if.md

Python example for Colab. The first block shows the required setup for the Earth Engine Python API and geemap. The second block demonstrates ee.Algorithms.If with boolean and string comparison conditions, using getInfo() to retrieve results. The comment notes that remap is preferred for mapping numbers to classes.

```python
import ee
import geemap.core as geemap
```

```python
# The string "*false*"
print(ee.Algorithms.If(False, '*true*', '*false*').getInfo())

# The string "*true*"
print(ee.Algorithms.If(True, '*true*', '*false*').getInfo())

# Consider using remap rather than If for tasks like numbers for classes.
print(ee.Algorithms.If(ee.String('Tree').compareTo('Tree'), 0, 1).getInfo())
print(ee.Algorithms.If(ee.String('NotTree').compareTo('Tree'), 0, 1).getInfo())
```

--------------------------------

### Install and import Altair

Source: https://github.com/wybert/earthengine-doc-md/blob/main/docs/guides/quickstart_python.md

Installs the Altair charting library and imports it as alt. Run this before creating charts.

```python
%pip install -q --upgrade altair
import altair as alt
```

--------------------------------

### Get MultiLineString coordinates in Colab (Python)

Source: https://github.com/wybert/earthengine-doc-md/blob/main/docs/apidocs/ee-geometry-multilinestring-coordinates.md

Python setup for the Earth Engine API and geemap, followed by an example that calls coordinates() on a MultiLineString and displays the result. Requires the Python environment and geemap for interactive development.

```Python
importee
importgeemap.coreasgeemap
```

```Python
# Define a MultiLineString object.
multilinestring = ee.Geometry.MultiLineString([
  [[-122.088, 37.418], [-122.086, 37.422], [-122.082, 37.418]],
  [[-122.087, 37.416], [-122.083, 37.416], [-122.082, 37.419]],
])
# Apply the coordinates method to the MultiLineString object.
multilinestring_coordinates = multilinestring.coordinates()
# Print the result.
display('multilinestring.coordinates(...) =', multilinestring_coordinates)
# Display relevant geometries on the map.
m = geemap.Map()
m.set_center(-122.085, 37.422, 15)
m.add_layer(
  multilinestring, {'color': 'black'}, 'Geometry [black]: multilinestring'
)
m
```

--------------------------------

### Create ee.DateRange with various input types (Python)

Source: https://github.com/wybert/earthengine-doc-md/blob/main/docs/apidocs/ee-daterange.md

Python example for Colab. Requires the Earth Engine Python API and geemap (see the Python Environment guide). The setup block imports ee and geemap.core as geemap. The main block mirrors the JavaScript example, calling .getInfo() on each ee.DateRange to retrieve and print the result.

```python
importee
importgeemap.coreasgeemap
```

```python
print('String date inputs (interpreted as UTC by default):',
      ee.DateRange('2017-06-24', '2017-07-24').getInfo())

print('String date inputs with timeZone argument:',
      ee.DateRange('2017-06-24', '2017-07-24', 'America/Los_Angeles').getInfo())

print('String date-time inputs with timeZone argument:',
      ee.DateRange('2017-06-24T07:00:00', '2017-07-24T07:00:00',
                   'America/Los_Angeles').getInfo())

print('A single date input results in a 1-millisecond range:',
      ee.DateRange('2017-06-24').getInfo())

print('ee.Date inputs',
      ee.DateRange(ee.Date('2017-06-24'), ee.Date('2017-07-24')).getInfo())

print('ee.Date date-time inputs (UTC by default):',
      ee.DateRange(ee.Date('2017-06-24T07:00:00'),
                   ee.Date('2017-07-24T07:00:00')).getInfo())

print('ee.Date date-time inputs with timeZone arguments:',
      ee.DateRange(ee.Date('2017-06-24T07:00:00', 'UTC'),
                   ee.Date('2017-07-24T07:00:00',
                           'America/Los_Angeles')).getInfo())

print('Number inputs as milliseconds from Unix epoch (2017-06-24, 2017-07-24):',
      ee.DateRange(1498262400000, 1500854400000).getInfo())
```

--------------------------------

### JavaScript example for ee.DateRange.isEmpty

Source: https://github.com/wybert/earthengine-doc-md/blob/main/docs/apidocs/ee-daterange-isempty.md

This example creates three ee.DateRange objects and checks if each is empty using the `isEmpty()` method. The ranges include start before end, start after end, and start equal to end.

```JavaScript
// A series of ee.DateRange objects.
vardateRange1=ee.DateRange('2017-06-24','2017-07-24');
vardateRange2=ee.DateRange('2017-07-24','2017-06-24');
vardateRange3=ee.DateRange('2017-07-24','2017-07-24');

// Determine if the ee.DateRange is empty.
print('Is dateRange1 empty?',dateRange1.isEmpty());
print('Is dateRange2 empty?',dateRange2.isEmpty());
print('Is dateRange3 empty?',dateRange3.isEmpty());

```
Tokens:
Raw