id int64 0 190k | prompt stringlengths 21 13.4M | docstring stringlengths 1 12k ⌀ |
|---|---|---|
12,238 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `ee_export_vector_to_feature_view` function. Write a Python function `def ee_export_vector_to_feature_view( collection, description="myExportTableTask", assetId=None, ingestionTimeParameters=None, **kwargs, )` to solve the following problem:
Creates a task to export a FeatureCollection to a FeatureView. Args: collection: The feature collection to be exported. description: Human-readable name of the task. assetId: The destination asset ID. ingestionTimeParameters: The FeatureView ingestion time parameters. **kwargs: Holds other keyword arguments that may have been deprecated.
Here is the function:
def ee_export_vector_to_feature_view(
collection,
description="myExportTableTask",
assetId=None,
ingestionTimeParameters=None,
**kwargs,
):
"""Creates a task to export a FeatureCollection to a FeatureView.
Args:
collection: The feature collection to be exported.
description: Human-readable name of the task.
assetId: The destination asset ID.
ingestionTimeParameters: The FeatureView ingestion time parameters.
**kwargs: Holds other keyword arguments that may have been deprecated.
"""
if not isinstance(collection, ee.FeatureCollection):
raise ValueError("The collection must be an ee.FeatureCollection.")
if os.environ.get("USE_MKDOCS") is not None: # skip if running GitHub CI.
return
print(
f"Exporting {description}... Please check the Task Manager from the JavaScript Code Editor."
)
task = ee.batch.Export.table.toFeatureView(
collection,
description,
assetId,
ingestionTimeParameters,
**kwargs,
)
task.start() | Creates a task to export a FeatureCollection to a FeatureView. Args: collection: The feature collection to be exported. description: Human-readable name of the task. assetId: The destination asset ID. ingestionTimeParameters: The FeatureView ingestion time parameters. **kwargs: Holds other keyword arguments that may have been deprecated. |
12,239 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `ee_export_video_to_drive` function. Write a Python function `def ee_export_video_to_drive( collection, description="myExportVideoTask", folder=None, fileNamePrefix=None, framesPerSecond=None, dimensions=None, region=None, scale=None, crs=None, crsTransform=None, maxPixels=None, maxFrames=None, **kwargs, )` to solve the following problem:
Creates a task to export an ImageCollection as a video to Drive. Args: collection: The image collection to be exported. The collection must only contain RGB images. description: Human-readable name of the task. folder: The name of a unique folder in your Drive account to export into. Defaults to the root of the drive. fileNamePrefix: The Google Drive filename for the export. Defaults to the name of the task. framesPerSecond: A number between .1 and 120 describing the framerate of the exported video. dimensions: The dimensions of the exported video. Takes either a single positive integer as the maximum dimension or "WIDTHxHEIGHT" where WIDTH and HEIGHT are each positive integers. region: The lon,lat coordinates for a LinearRing or Polygon specifying the region to export. Can be specified as a nested lists of numbers or a serialized string. Defaults to the first image's region. scale: The resolution in meters per pixel. crs: The coordinate reference system of the exported video's projection. Defaults to SR-ORG:6627. crsTransform: A comma-separated string of 6 numbers describing the affine transform of the coordinate reference system of the exported video's projection, in the order: xScale, xShearing, xTranslation, yShearing, yScale and yTranslation. Defaults to the image collection's native CRS transform. maxPixels: The maximum number of pixels per frame. Defaults to 1e8 pixels per frame. By setting this explicitly, you may raise or lower the limit. maxFrames: The maximum number of frames to export. Defaults to 1000 frames. By setting this explicitly, you may raise or lower the limit. **kwargs: Holds other keyword arguments that may have been deprecated such as 'crs_transform'.
Here is the function:
def ee_export_video_to_drive(
collection,
description="myExportVideoTask",
folder=None,
fileNamePrefix=None,
framesPerSecond=None,
dimensions=None,
region=None,
scale=None,
crs=None,
crsTransform=None,
maxPixels=None,
maxFrames=None,
**kwargs,
):
"""Creates a task to export an ImageCollection as a video to Drive.
Args:
collection: The image collection to be exported. The collection must
only contain RGB images.
description: Human-readable name of the task.
folder: The name of a unique folder in your Drive account to
export into. Defaults to the root of the drive.
fileNamePrefix: The Google Drive filename for the export.
Defaults to the name of the task.
framesPerSecond: A number between .1 and 120 describing the
framerate of the exported video.
dimensions: The dimensions of the exported video. Takes either a
single positive integer as the maximum dimension or "WIDTHxHEIGHT"
where WIDTH and HEIGHT are each positive integers.
region: The lon,lat coordinates for a LinearRing or Polygon
specifying the region to export. Can be specified as a nested
lists of numbers or a serialized string. Defaults to the first
image's region.
scale: The resolution in meters per pixel.
crs: The coordinate reference system of the exported video's
projection. Defaults to SR-ORG:6627.
crsTransform: A comma-separated string of 6 numbers describing
the affine transform of the coordinate reference system of the
exported video's projection, in the order: xScale, xShearing,
xTranslation, yShearing, yScale and yTranslation. Defaults to
the image collection's native CRS transform.
maxPixels: The maximum number of pixels per frame.
Defaults to 1e8 pixels per frame. By setting this explicitly,
you may raise or lower the limit.
maxFrames: The maximum number of frames to export.
Defaults to 1000 frames. By setting this explicitly, you may
raise or lower the limit.
**kwargs: Holds other keyword arguments that may have been deprecated
such as 'crs_transform'.
"""
if not isinstance(collection, ee.ImageCollection):
raise TypeError("collection must be an ee.ImageCollection")
if os.environ.get("USE_MKDOCS") is not None: # skip if running GitHub CI.
return
print(
f"Exporting {description}... Please check the Task Manager from the JavaScript Code Editor."
)
task = ee.batch.Export.video.toDrive(
collection,
description,
folder,
fileNamePrefix,
framesPerSecond,
dimensions,
region,
scale,
crs,
crsTransform,
maxPixels,
maxFrames,
**kwargs,
)
task.start() | Creates a task to export an ImageCollection as a video to Drive. Args: collection: The image collection to be exported. The collection must only contain RGB images. description: Human-readable name of the task. folder: The name of a unique folder in your Drive account to export into. Defaults to the root of the drive. fileNamePrefix: The Google Drive filename for the export. Defaults to the name of the task. framesPerSecond: A number between .1 and 120 describing the framerate of the exported video. dimensions: The dimensions of the exported video. Takes either a single positive integer as the maximum dimension or "WIDTHxHEIGHT" where WIDTH and HEIGHT are each positive integers. region: The lon,lat coordinates for a LinearRing or Polygon specifying the region to export. Can be specified as a nested lists of numbers or a serialized string. Defaults to the first image's region. scale: The resolution in meters per pixel. crs: The coordinate reference system of the exported video's projection. Defaults to SR-ORG:6627. crsTransform: A comma-separated string of 6 numbers describing the affine transform of the coordinate reference system of the exported video's projection, in the order: xScale, xShearing, xTranslation, yShearing, yScale and yTranslation. Defaults to the image collection's native CRS transform. maxPixels: The maximum number of pixels per frame. Defaults to 1e8 pixels per frame. By setting this explicitly, you may raise or lower the limit. maxFrames: The maximum number of frames to export. Defaults to 1000 frames. By setting this explicitly, you may raise or lower the limit. **kwargs: Holds other keyword arguments that may have been deprecated such as 'crs_transform'. |
12,240 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `ee_export_video_to_cloud_storage` function. Write a Python function `def ee_export_video_to_cloud_storage( collection, description="myExportVideoTask", bucket=None, fileNamePrefix=None, framesPerSecond=None, dimensions=None, region=None, scale=None, crs=None, crsTransform=None, maxPixels=None, maxFrames=None, **kwargs, )` to solve the following problem:
Creates a task to export an ImageCollection as a video to Cloud Storage. Args: collection: The image collection to be exported. The collection must only contain RGB images. description: Human-readable name of the task. bucket: The name of a Cloud Storage bucket for the export. fileNamePrefix: Cloud Storage object name prefix for the export. Defaults to the task's description. framesPerSecond: A number between .1 and 120 describing the framerate of the exported video. dimensions: The dimensions of the exported video. Takes either a single positive integer as the maximum dimension or "WIDTHxHEIGHT" where WIDTH and HEIGHT are each positive integers. region: The lon,lat coordinates for a LinearRing or Polygon specifying the region to export. Can be specified as a nested lists of numbers or a serialized string. Defaults to the first image's region. scale: The resolution in meters per pixel. crs: The coordinate reference system of the exported video's projection. Defaults to SR-ORG:6627. crsTransform: A comma-separated string of 6 numbers describing the affine transform of the coordinate reference system of the exported video's projection, in the order: xScale, xShearing, xTranslation, yShearing, yScale and yTranslation. Defaults to the image collection's native CRS transform. maxPixels: The maximum number of pixels per frame. Defaults to 1e8 pixels per frame. By setting this explicitly, you may raise or lower the limit. maxFrames: The maximum number of frames to export. Defaults to 1000 frames. By setting this explicitly, you may raise or lower the limit. **kwargs: Holds other keyword arguments that may have been deprecated such as 'crs_transform'.
Here is the function:
def ee_export_video_to_cloud_storage(
collection,
description="myExportVideoTask",
bucket=None,
fileNamePrefix=None,
framesPerSecond=None,
dimensions=None,
region=None,
scale=None,
crs=None,
crsTransform=None,
maxPixels=None,
maxFrames=None,
**kwargs,
):
"""Creates a task to export an ImageCollection as a video to Cloud Storage.
Args:
collection: The image collection to be exported. The collection must
only contain RGB images.
description: Human-readable name of the task.
bucket: The name of a Cloud Storage bucket for the export.
fileNamePrefix: Cloud Storage object name prefix for the export.
Defaults to the task's description.
framesPerSecond: A number between .1 and 120 describing the
framerate of the exported video.
dimensions: The dimensions of the exported video. Takes either a
single positive integer as the maximum dimension or "WIDTHxHEIGHT"
where WIDTH and HEIGHT are each positive integers.
region: The lon,lat coordinates for a LinearRing or Polygon
specifying the region to export. Can be specified as a nested
lists of numbers or a serialized string. Defaults to the first
image's region.
scale: The resolution in meters per pixel.
crs: The coordinate reference system of the exported video's
projection. Defaults to SR-ORG:6627.
crsTransform: A comma-separated string of 6 numbers describing
the affine transform of the coordinate reference system of the
exported video's projection, in the order: xScale, xShearing,
xTranslation, yShearing, yScale and yTranslation. Defaults to
the image collection's native CRS transform.
maxPixels: The maximum number of pixels per frame.
Defaults to 1e8 pixels per frame. By setting this explicitly,
you may raise or lower the limit.
maxFrames: The maximum number of frames to export.
Defaults to 1000 frames. By setting this explicitly, you may
raise or lower the limit.
**kwargs: Holds other keyword arguments that may have been deprecated
such as 'crs_transform'.
"""
if not isinstance(collection, ee.ImageCollection):
raise TypeError("collection must be an ee.ImageCollection")
if os.environ.get("USE_MKDOCS") is not None: # skip if running GitHub CI.
return
print(
f"Exporting {description}... Please check the Task Manager from the JavaScript Code Editor."
)
task = ee.batch.Export.video.toCloudStorage(
collection,
description,
bucket,
fileNamePrefix,
framesPerSecond,
dimensions,
region,
scale,
crs,
crsTransform,
maxPixels,
maxFrames,
**kwargs,
)
task.start() | Creates a task to export an ImageCollection as a video to Cloud Storage. Args: collection: The image collection to be exported. The collection must only contain RGB images. description: Human-readable name of the task. bucket: The name of a Cloud Storage bucket for the export. fileNamePrefix: Cloud Storage object name prefix for the export. Defaults to the task's description. framesPerSecond: A number between .1 and 120 describing the framerate of the exported video. dimensions: The dimensions of the exported video. Takes either a single positive integer as the maximum dimension or "WIDTHxHEIGHT" where WIDTH and HEIGHT are each positive integers. region: The lon,lat coordinates for a LinearRing or Polygon specifying the region to export. Can be specified as a nested lists of numbers or a serialized string. Defaults to the first image's region. scale: The resolution in meters per pixel. crs: The coordinate reference system of the exported video's projection. Defaults to SR-ORG:6627. crsTransform: A comma-separated string of 6 numbers describing the affine transform of the coordinate reference system of the exported video's projection, in the order: xScale, xShearing, xTranslation, yShearing, yScale and yTranslation. Defaults to the image collection's native CRS transform. maxPixels: The maximum number of pixels per frame. Defaults to 1e8 pixels per frame. By setting this explicitly, you may raise or lower the limit. maxFrames: The maximum number of frames to export. Defaults to 1000 frames. By setting this explicitly, you may raise or lower the limit. **kwargs: Holds other keyword arguments that may have been deprecated such as 'crs_transform'. |
12,241 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `ee_export_map_to_cloud_storage` function. Write a Python function `def ee_export_map_to_cloud_storage( image, description="myExportMapTask", bucket=None, fileFormat=None, path=None, writePublicTiles=None, maxZoom=None, scale=None, minZoom=None, region=None, skipEmptyTiles=None, mapsApiKey=None, **kwargs, )` to solve the following problem:
Creates a task to export an Image as a pyramid of map tiles. Exports a rectangular pyramid of map tiles for use with web map viewers. The map tiles will be accompanied by a reference index.html file that displays them using the Google Maps API, and an earth.html file for opening the map on Google Earth. Args: image: The image to export as tiles. description: Human-readable name of the task. bucket: The destination bucket to write to. fileFormat: The map tiles' file format, one of 'auto', 'png', or 'jpeg'. Defaults to 'auto', which means that opaque tiles will be encoded as 'jpg' and tiles with transparency will be encoded as 'png'. path: The string used as the output's path. A trailing '/' is optional. Defaults to the task's description. writePublicTiles: Whether to write public tiles instead of using the bucket's default object ACL. Defaults to True and requires the invoker to be an OWNER of bucket. maxZoom: The maximum zoom level of the map tiles to export. scale: The max image resolution in meters per pixel, as an alternative to 'maxZoom'. The scale will be converted to the most appropriate maximum zoom level at the equator. minZoom: The optional minimum zoom level of the map tiles to export. region: The lon,lat coordinates for a LinearRing or Polygon specifying the region to export. Can be specified as a nested lists of numbers or a serialized string. Map tiles will be produced in the rectangular region containing this geometry. Defaults to the image's region. skipEmptyTiles: If true, skip writing empty (i.e. fully-transparent) map tiles. Defaults to false. mapsApiKey: Used in index.html to initialize the Google Maps API. This removes the "development purposes only" message from the map. **kwargs: Holds other keyword arguments that may have been deprecated such as 'crs_transform'.
Here is the function:
def ee_export_map_to_cloud_storage(
image,
description="myExportMapTask",
bucket=None,
fileFormat=None,
path=None,
writePublicTiles=None,
maxZoom=None,
scale=None,
minZoom=None,
region=None,
skipEmptyTiles=None,
mapsApiKey=None,
**kwargs,
):
"""Creates a task to export an Image as a pyramid of map tiles.
Exports a rectangular pyramid of map tiles for use with web map
viewers. The map tiles will be accompanied by a reference
index.html file that displays them using the Google Maps API,
and an earth.html file for opening the map on Google Earth.
Args:
image: The image to export as tiles.
description: Human-readable name of the task.
bucket: The destination bucket to write to.
fileFormat: The map tiles' file format, one of 'auto', 'png',
or 'jpeg'. Defaults to 'auto', which means that opaque tiles
will be encoded as 'jpg' and tiles with transparency will be
encoded as 'png'.
path: The string used as the output's path. A trailing '/'
is optional. Defaults to the task's description.
writePublicTiles: Whether to write public tiles instead of using the
bucket's default object ACL. Defaults to True and requires the
invoker to be an OWNER of bucket.
maxZoom: The maximum zoom level of the map tiles to export.
scale: The max image resolution in meters per pixel, as an alternative
to 'maxZoom'. The scale will be converted to the most appropriate
maximum zoom level at the equator.
minZoom: The optional minimum zoom level of the map tiles to export.
region: The lon,lat coordinates for a LinearRing or Polygon
specifying the region to export. Can be specified as a nested
lists of numbers or a serialized string. Map tiles will be
produced in the rectangular region containing this geometry.
Defaults to the image's region.
skipEmptyTiles: If true, skip writing empty (i.e. fully-transparent)
map tiles. Defaults to false.
mapsApiKey: Used in index.html to initialize the Google Maps API. This
removes the "development purposes only" message from the map.
**kwargs: Holds other keyword arguments that may have been deprecated
such as 'crs_transform'.
"""
if not isinstance(image, ee.Image):
raise TypeError("image must be an ee.Image")
if os.environ.get("USE_MKDOCS") is not None: # skip if running GitHub CI.
return
print(
f"Exporting {description}... Please check the Task Manager from the JavaScript Code Editor."
)
task = ee.batch.Export.map.toCloudStorage(
image,
description,
bucket,
fileFormat,
path,
writePublicTiles,
maxZoom,
scale,
minZoom,
region,
skipEmptyTiles,
mapsApiKey,
**kwargs,
)
task.start() | Creates a task to export an Image as a pyramid of map tiles. Exports a rectangular pyramid of map tiles for use with web map viewers. The map tiles will be accompanied by a reference index.html file that displays them using the Google Maps API, and an earth.html file for opening the map on Google Earth. Args: image: The image to export as tiles. description: Human-readable name of the task. bucket: The destination bucket to write to. fileFormat: The map tiles' file format, one of 'auto', 'png', or 'jpeg'. Defaults to 'auto', which means that opaque tiles will be encoded as 'jpg' and tiles with transparency will be encoded as 'png'. path: The string used as the output's path. A trailing '/' is optional. Defaults to the task's description. writePublicTiles: Whether to write public tiles instead of using the bucket's default object ACL. Defaults to True and requires the invoker to be an OWNER of bucket. maxZoom: The maximum zoom level of the map tiles to export. scale: The max image resolution in meters per pixel, as an alternative to 'maxZoom'. The scale will be converted to the most appropriate maximum zoom level at the equator. minZoom: The optional minimum zoom level of the map tiles to export. region: The lon,lat coordinates for a LinearRing or Polygon specifying the region to export. Can be specified as a nested lists of numbers or a serialized string. Map tiles will be produced in the rectangular region containing this geometry. Defaults to the image's region. skipEmptyTiles: If true, skip writing empty (i.e. fully-transparent) map tiles. Defaults to false. mapsApiKey: Used in index.html to initialize the Google Maps API. This removes the "development purposes only" message from the map. **kwargs: Holds other keyword arguments that may have been deprecated such as 'crs_transform'. |
12,242 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `set_proxy` function. Write a Python function `def set_proxy(port=1080, ip="http://127.0.0.1", timeout=300)` to solve the following problem:
Sets proxy if needed. This is only needed for countries where Google services are not available. Args: port (int, optional): The proxy port number. Defaults to 1080. ip (str, optional): The IP address. Defaults to 'http://127.0.0.1'. timeout (int, optional): The timeout in seconds. Defaults to 300.
Here is the function:
def set_proxy(port=1080, ip="http://127.0.0.1", timeout=300):
"""Sets proxy if needed. This is only needed for countries where Google services are not available.
Args:
port (int, optional): The proxy port number. Defaults to 1080.
ip (str, optional): The IP address. Defaults to 'http://127.0.0.1'.
timeout (int, optional): The timeout in seconds. Defaults to 300.
"""
try:
if not ip.startswith("http"):
ip = "http://" + ip
proxy = "{}:{}".format(ip, port)
os.environ["HTTP_PROXY"] = proxy
os.environ["HTTPS_PROXY"] = proxy
a = requests.get("https://earthengine.google.com/", timeout=timeout)
if a.status_code != 200:
print(
"Failed to connect to Earth Engine. Please double check the port number and ip address."
)
except Exception as e:
print(e) | Sets proxy if needed. This is only needed for countries where Google services are not available. Args: port (int, optional): The proxy port number. Defaults to 1080. ip (str, optional): The IP address. Defaults to 'http://127.0.0.1'. timeout (int, optional): The timeout in seconds. Defaults to 300. |
12,243 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `is_drive_mounted` function. Write a Python function `def is_drive_mounted()` to solve the following problem:
Checks whether Google Drive is mounted in Google Colab. Returns: bool: Returns True if Google Drive is mounted, False otherwise.
Here is the function:
def is_drive_mounted():
"""Checks whether Google Drive is mounted in Google Colab.
Returns:
bool: Returns True if Google Drive is mounted, False otherwise.
"""
drive_path = "/content/drive/My Drive"
if os.path.exists(drive_path):
return True
else:
return False | Checks whether Google Drive is mounted in Google Colab. Returns: bool: Returns True if Google Drive is mounted, False otherwise. |
12,244 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `credentials_in_drive` function. Write a Python function `def credentials_in_drive()` to solve the following problem:
Checks if the ee credentials file exists in Google Drive. Returns: bool: Returns True if Google Drive is mounted, False otherwise.
Here is the function:
def credentials_in_drive():
"""Checks if the ee credentials file exists in Google Drive.
Returns:
bool: Returns True if Google Drive is mounted, False otherwise.
"""
credentials_path = "/content/drive/My Drive/.config/earthengine/credentials"
if os.path.exists(credentials_path):
return True
else:
return False | Checks if the ee credentials file exists in Google Drive. Returns: bool: Returns True if Google Drive is mounted, False otherwise. |
12,245 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `credentials_in_colab` function. Write a Python function `def credentials_in_colab()` to solve the following problem:
Checks if the ee credentials file exists in Google Colab. Returns: bool: Returns True if Google Drive is mounted, False otherwise.
Here is the function:
def credentials_in_colab():
"""Checks if the ee credentials file exists in Google Colab.
Returns:
bool: Returns True if Google Drive is mounted, False otherwise.
"""
credentials_path = "/root/.config/earthengine/credentials"
if os.path.exists(credentials_path):
return True
else:
return False | Checks if the ee credentials file exists in Google Colab. Returns: bool: Returns True if Google Drive is mounted, False otherwise. |
12,246 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `copy_credentials_to_drive` function. Write a Python function `def copy_credentials_to_drive()` to solve the following problem:
Copies ee credentials from Google Colab to Google Drive.
Here is the function:
def copy_credentials_to_drive():
"""Copies ee credentials from Google Colab to Google Drive."""
src = "/root/.config/earthengine/credentials"
dst = "/content/drive/My Drive/.config/earthengine/credentials"
wd = os.path.dirname(dst)
if not os.path.exists(wd):
os.makedirs(wd)
shutil.copyfile(src, dst) | Copies ee credentials from Google Colab to Google Drive. |
12,247 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `copy_credentials_to_colab` function. Write a Python function `def copy_credentials_to_colab()` to solve the following problem:
Copies ee credentials from Google Drive to Google Colab.
Here is the function:
def copy_credentials_to_colab():
"""Copies ee credentials from Google Drive to Google Colab."""
src = "/content/drive/My Drive/.config/earthengine/credentials"
dst = "/root/.config/earthengine/credentials"
wd = os.path.dirname(dst)
if not os.path.exists(wd):
os.makedirs(wd)
shutil.copyfile(src, dst) | Copies ee credentials from Google Drive to Google Colab. |
12,248 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def clone_repo(out_dir=".", unzip=True):
"""Clones the geemap GitHub repository.
Args:
out_dir (str, optional): Output folder for the repo. Defaults to '.'.
unzip (bool, optional): Whether to unzip the repository. Defaults to True.
"""
url = "https://github.com/gee-community/geemap/archive/master.zip"
filename = "geemap-master.zip"
download_from_url(url, out_file_name=filename, out_dir=out_dir, unzip=unzip)
The provided code snippet includes necessary dependencies for implementing the `update_package` function. Write a Python function `def update_package()` to solve the following problem:
Updates the geemap package from the geemap GitHub repository without the need to use pip or conda. In this way, I don't have to keep updating pypi and conda-forge with every minor update of the package.
Here is the function:
def update_package():
"""Updates the geemap package from the geemap GitHub repository without the need to use pip or conda.
In this way, I don't have to keep updating pypi and conda-forge with every minor update of the package.
"""
try:
download_dir = os.path.join(os.path.expanduser("~"), "Downloads")
if not os.path.exists(download_dir):
os.makedirs(download_dir)
clone_repo(out_dir=download_dir)
pkg_dir = os.path.join(download_dir, "geemap-master")
work_dir = os.getcwd()
os.chdir(pkg_dir)
if shutil.which("pip") is None:
cmd = "pip3 install ."
else:
cmd = "pip install ."
os.system(cmd)
os.chdir(work_dir)
print(
"\nPlease comment out 'geemap.update_package()' and restart the kernel to take effect:\nJupyter menu -> Kernel -> Restart & Clear Output"
)
except Exception as e:
raise Exception(e) | Updates the geemap package from the geemap GitHub repository without the need to use pip or conda. In this way, I don't have to keep updating pypi and conda-forge with every minor update of the package. |
12,249 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def download_from_url(url, out_file_name=None, out_dir=".", unzip=True, verbose=True):
"""Download a file from a URL (e.g., https://github.com/giswqs/whitebox/raw/master/examples/testdata.zip)
Args:
url (str): The HTTP URL to download.
out_file_name (str, optional): The output file name to use. Defaults to None.
out_dir (str, optional): The output directory to use. Defaults to '.'.
unzip (bool, optional): Whether to unzip the downloaded file if it is a zip file. Defaults to True.
verbose (bool, optional): Whether to display or not the output of the function
"""
in_file_name = os.path.basename(url)
if out_file_name is None:
out_file_name = in_file_name
out_file_path = os.path.join(os.path.abspath(out_dir), out_file_name)
if verbose:
print(f"Downloading {url} ...")
try:
urllib.request.urlretrieve(url, out_file_path)
except Exception:
raise Exception("The URL is invalid. Please double check the URL.")
final_path = out_file_path
if unzip:
# if it is a zip file
if ".zip" in out_file_name:
if verbose:
print(f"Unzipping {out_file_name} ...")
with zipfile.ZipFile(out_file_path, "r") as zip_ref:
zip_ref.extractall(out_dir)
final_path = os.path.join(
os.path.abspath(out_dir), out_file_name.replace(".zip", "")
)
# if it is a tar file
if ".tar" in out_file_name:
if verbose:
print(f"Unzipping {out_file_name} ...")
with tarfile.open(out_file_path, "r") as tar_ref:
with tarfile.open(out_file_path, "r") as tar_ref:
def is_within_directory(directory, target):
abs_directory = os.path.abspath(directory)
abs_target = os.path.abspath(target)
prefix = os.path.commonprefix([abs_directory, abs_target])
return prefix == abs_directory
def safe_extract(
tar, path=".", members=None, *, numeric_owner=False
):
for member in tar.getmembers():
member_path = os.path.join(path, member.name)
if not is_within_directory(path, member_path):
raise Exception("Attempted Path Traversal in Tar File")
tar.extractall(path, members, numeric_owner=numeric_owner)
safe_extract(tar_ref, out_dir)
final_path = os.path.join(
os.path.abspath(out_dir), out_file_name.replace(".tar", "")
)
if verbose:
print(f"Data downloaded to: {final_path}")
return
The provided code snippet includes necessary dependencies for implementing the `install_from_github` function. Write a Python function `def install_from_github(url)` to solve the following problem:
Install a package from a GitHub repository. Args: url (str): The URL of the GitHub repository.
Here is the function:
def install_from_github(url):
"""Install a package from a GitHub repository.
Args:
url (str): The URL of the GitHub repository.
"""
try:
download_dir = os.path.join(os.path.expanduser("~"), "Downloads")
if not os.path.exists(download_dir):
os.makedirs(download_dir)
repo_name = os.path.basename(url)
zip_url = os.path.join(url, "archive/master.zip")
filename = repo_name + "-master.zip"
download_from_url(
url=zip_url, out_file_name=filename, out_dir=download_dir, unzip=True
)
pkg_dir = os.path.join(download_dir, repo_name + "-master")
pkg_name = os.path.basename(url)
work_dir = os.getcwd()
os.chdir(pkg_dir)
print(f"Installing {pkg_name}...")
cmd = "pip install ."
os.system(cmd)
os.chdir(work_dir)
print(f"{pkg_name} has been installed successfully.")
# print("\nPlease comment out 'install_from_github()' and restart the kernel to take effect:\nJupyter menu -> Kernel -> Restart & Clear Output")
except Exception as e:
print(e) | Install a package from a GitHub repository. Args: url (str): The URL of the GitHub repository. |
12,250 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `open_github` function. Write a Python function `def open_github(subdir=None)` to solve the following problem:
Opens the GitHub repository for this package. Args: subdir (str, optional): Sub-directory of the repository. Defaults to None.
Here is the function:
def open_github(subdir=None):
"""Opens the GitHub repository for this package.
Args:
subdir (str, optional): Sub-directory of the repository. Defaults to None.
"""
import webbrowser
url = "https://github.com/gee-community/geemap"
if subdir == "source":
url += "/tree/master/geemap/"
elif subdir == "examples":
url += "/tree/master/examples"
elif subdir == "tutorials":
url += "/tree/master/tutorials"
webbrowser.open_new_tab(url) | Opens the GitHub repository for this package. Args: subdir (str, optional): Sub-directory of the repository. Defaults to None. |
12,251 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `open_youtube` function. Write a Python function `def open_youtube()` to solve the following problem:
Opens the YouTube tutorials for geemap.
Here is the function:
def open_youtube():
"""Opens the YouTube tutorials for geemap."""
import webbrowser
url = "https://www.youtube.com/playlist?list=PLAxJ4-o7ZoPccOFv1dCwvGI6TYnirRTg3"
webbrowser.open_new_tab(url) | Opens the YouTube tutorials for geemap. |
12,252 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
try:
from IPython.display import display, IFrame, Javascript
except ImportError:
pass
def download_file(
url=None,
output=None,
quiet=False,
proxy=None,
speed=None,
use_cookies=True,
verify=True,
id=None,
fuzzy=False,
resume=False,
unzip=True,
overwrite=False,
):
"""Download a file from URL, including Google Drive shared URL.
Args:
url (str, optional): Google Drive URL is also supported. Defaults to None.
output (str, optional): Output filename. Default is basename of URL.
quiet (bool, optional): Suppress terminal output. Default is False.
proxy (str, optional): Proxy. Defaults to None.
speed (float, optional): Download byte size per second (e.g., 256KB/s = 256 * 1024). Defaults to None.
use_cookies (bool, optional): Flag to use cookies. Defaults to True.
verify (bool | str, optional): Either a bool, in which case it controls whether the server's TLS certificate is verified, or a string, in which case it must be a path to a CA bundle to use. Default is True.. Defaults to True.
id (str, optional): Google Drive's file ID. Defaults to None.
fuzzy (bool, optional): Fuzzy extraction of Google Drive's file Id. Defaults to False.
resume (bool, optional): Resume the download from existing tmp file if possible. Defaults to False.
unzip (bool, optional): Unzip the file. Defaults to True.
overwrite (bool, optional): Overwrite the file if it already exists. Defaults to False.
Returns:
str: The output file path.
"""
import gdown
if output is None:
if isinstance(url, str) and url.startswith("http"):
output = os.path.basename(url)
if isinstance(url, str):
if os.path.exists(os.path.abspath(output)) and (not overwrite):
print(
f"{output} already exists. Skip downloading. Set overwrite=True to overwrite."
)
return os.path.abspath(output)
else:
url = github_raw_url(url)
if "https://drive.google.com/file/d/" in url:
fuzzy = True
output = gdown.download(
url, output, quiet, proxy, speed, use_cookies, verify, id, fuzzy, resume
)
if unzip and output.endswith(".zip"):
with zipfile.ZipFile(output, "r") as zip_ref:
if not quiet:
print("Extracting files...")
zip_ref.extractall(os.path.dirname(output))
return os.path.abspath(output)
The provided code snippet includes necessary dependencies for implementing the `show_image` function. Write a Python function `def show_image(img_path, width=None, height=None)` to solve the following problem:
Shows an image within Jupyter notebook. Args: img_path (str): The image file path. width (int, optional): Width of the image in pixels. Defaults to None. height (int, optional): Height of the image in pixels. Defaults to None.
Here is the function:
def show_image(img_path, width=None, height=None):
"""Shows an image within Jupyter notebook.
Args:
img_path (str): The image file path.
width (int, optional): Width of the image in pixels. Defaults to None.
height (int, optional): Height of the image in pixels. Defaults to None.
"""
from IPython.display import display
try:
out = widgets.Output()
# layout={'border': '1px solid black'})
# layout={'border': '1px solid black', 'width': str(width + 20) + 'px', 'height': str(height + 10) + 'px'},)
out.outputs = ()
display(out)
with out:
if isinstance(img_path, str) and img_path.startswith("http"):
file_path = download_file(img_path)
else:
file_path = img_path
file = open(file_path, "rb")
image = file.read()
if (width is None) and (height is None):
display(widgets.Image(value=image))
elif (width is not None) and (height is not None):
display(widgets.Image(value=image, width=width, height=height))
else:
print("You need set both width and height.")
return
except Exception as e:
print(e) | Shows an image within Jupyter notebook. Args: img_path (str): The image file path. width (int, optional): Width of the image in pixels. Defaults to None. height (int, optional): Height of the image in pixels. Defaults to None. |
12,253 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `show_html` function. Write a Python function `def show_html(html)` to solve the following problem:
Shows HTML within Jupyter notebook. Args: html (str): File path or HTML string. Raises: FileNotFoundError: If the file does not exist. Returns: ipywidgets.HTML: HTML widget.
Here is the function:
def show_html(html):
"""Shows HTML within Jupyter notebook.
Args:
html (str): File path or HTML string.
Raises:
FileNotFoundError: If the file does not exist.
Returns:
ipywidgets.HTML: HTML widget.
"""
if os.path.exists(html):
with open(html, "r") as f:
content = f.read()
widget = widgets.HTML(value=content)
return widget
else:
try:
widget = widgets.HTML(value=html)
return widget
except Exception as e:
raise Exception(e) | Shows HTML within Jupyter notebook. Args: html (str): File path or HTML string. Raises: FileNotFoundError: If the file does not exist. Returns: ipywidgets.HTML: HTML widget. |
12,254 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def check_install(package):
"""Checks whether a package is installed. If not, it will install the package.
Args:
package (str): The name of the package to check.
"""
import subprocess
try:
__import__(package)
# print('{} is already installed.'.format(package))
except ImportError:
print(f"{package} is not installed. Installing ...")
try:
subprocess.check_call(["python", "-m", "pip", "install", package])
except Exception as e:
print(f"Failed to install {package}")
print(e)
print(f"{package} has been installed successfully.")
def is_tool(name):
"""Check whether `name` is on PATH and marked as executable."""
# from shutil import which
return shutil.which(name) is not None
The provided code snippet includes necessary dependencies for implementing the `upload_to_imgur` function. Write a Python function `def upload_to_imgur(in_gif)` to solve the following problem:
Uploads an image to imgur.com Args: in_gif (str): The file path to the image.
Here is the function:
def upload_to_imgur(in_gif):
"""Uploads an image to imgur.com
Args:
in_gif (str): The file path to the image.
"""
import subprocess
pkg_name = "imgur-uploader"
if not is_tool(pkg_name):
check_install(pkg_name)
try:
IMGUR_API_ID = os.environ.get("IMGUR_API_ID", None)
IMGUR_API_SECRET = os.environ.get("IMGUR_API_SECRET", None)
credentials_path = os.path.join(
os.path.expanduser("~"), ".config/imgur_uploader/uploader.cfg"
)
if (
(IMGUR_API_ID is not None) and (IMGUR_API_SECRET is not None)
) or os.path.exists(credentials_path):
proc = subprocess.Popen(["imgur-uploader", in_gif], stdout=subprocess.PIPE)
for _ in range(0, 2):
line = proc.stdout.readline()
print(line.rstrip().decode("utf-8"))
# while True:
# line = proc.stdout.readline()
# if not line:
# break
# print(line.rstrip().decode("utf-8"))
else:
print(
"Imgur API credentials could not be found. Please check https://pypi.org/project/imgur-uploader/ for instructions on how to get Imgur API credentials"
)
return
except Exception as e:
print(e) | Uploads an image to imgur.com Args: in_gif (str): The file path to the image. |
12,255 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `hex_to_rgb` function. Write a Python function `def hex_to_rgb(value="FFFFFF")` to solve the following problem:
Converts hex color to RGB color. Args: value (str, optional): Hex color code as a string. Defaults to 'FFFFFF'. Returns: tuple: RGB color as a tuple.
Here is the function:
def hex_to_rgb(value="FFFFFF"):
"""Converts hex color to RGB color.
Args:
value (str, optional): Hex color code as a string. Defaults to 'FFFFFF'.
Returns:
tuple: RGB color as a tuple.
"""
value = value.lstrip("#")
lv = len(value)
return tuple(int(value[i : i + lv // 3], 16) for i in range(0, lv, lv // 3)) | Converts hex color to RGB color. Args: value (str, optional): Hex color code as a string. Defaults to 'FFFFFF'. Returns: tuple: RGB color as a tuple. |
12,256 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `download_from_gdrive` function. Write a Python function `def download_from_gdrive(gfile_url, file_name, out_dir=".", unzip=True, verbose=True)` to solve the following problem:
Download a file shared via Google Drive (e.g., https://drive.google.com/file/d/18SUo_HcDGltuWYZs1s7PpOmOq_FvFn04/view?usp=sharing) Args: gfile_url (str): The Google Drive shared file URL file_name (str): The output file name to use. out_dir (str, optional): The output directory. Defaults to '.'. unzip (bool, optional): Whether to unzip the output file if it is a zip file. Defaults to True. verbose (bool, optional): Whether to display or not the output of the function
Here is the function:
def download_from_gdrive(gfile_url, file_name, out_dir=".", unzip=True, verbose=True):
"""Download a file shared via Google Drive
(e.g., https://drive.google.com/file/d/18SUo_HcDGltuWYZs1s7PpOmOq_FvFn04/view?usp=sharing)
Args:
gfile_url (str): The Google Drive shared file URL
file_name (str): The output file name to use.
out_dir (str, optional): The output directory. Defaults to '.'.
unzip (bool, optional): Whether to unzip the output file if it is a zip file. Defaults to True.
verbose (bool, optional): Whether to display or not the output of the function
"""
try:
from google_drive_downloader import GoogleDriveDownloader as gdd
except ImportError:
raise Exception(
"Please install the google_drive_downloader package using `pip install googledrivedownloader`"
)
file_id = gfile_url.split("/")[5]
if verbose:
print(f"Google Drive file id: {file_id}")
dest_path = os.path.join(out_dir, file_name)
gdd.download_file_from_google_drive(file_id, dest_path, True, unzip)
return | Download a file shared via Google Drive (e.g., https://drive.google.com/file/d/18SUo_HcDGltuWYZs1s7PpOmOq_FvFn04/view?usp=sharing) Args: gfile_url (str): The Google Drive shared file URL file_name (str): The output file name to use. out_dir (str, optional): The output directory. Defaults to '.'. unzip (bool, optional): Whether to unzip the output file if it is a zip file. Defaults to True. verbose (bool, optional): Whether to display or not the output of the function |
12,257 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `edit_download_html` function. Write a Python function `def edit_download_html(htmlWidget, filename, title="Click here to download: ")` to solve the following problem:
Downloads a file from voila. Adopted from https://github.com/voila-dashboards/voila/issues/578#issuecomment-617668058 Args: htmlWidget (object): The HTML widget to display the URL. filename (str): File path to download. title (str, optional): Download description. Defaults to "Click here to download: ".
Here is the function:
def edit_download_html(htmlWidget, filename, title="Click here to download: "):
"""Downloads a file from voila. Adopted from https://github.com/voila-dashboards/voila/issues/578#issuecomment-617668058
Args:
htmlWidget (object): The HTML widget to display the URL.
filename (str): File path to download.
title (str, optional): Download description. Defaults to "Click here to download: ".
"""
# from IPython.display import HTML
# import ipywidgets as widgets
import base64
# Change widget html temporarily to a font-awesome spinner
htmlWidget.value = '<i class="fa fa-spinner fa-spin fa-2x fa-fw"></i><span class="sr-only">Loading...</span>'
# Process raw data
data = open(filename, "rb").read()
b64 = base64.b64encode(data)
payload = b64.decode()
basename = os.path.basename(filename)
# Create and assign html to widget
html = '<a download="{filename}" href="data:text/csv;base64,{payload}" target="_blank">{title}</a>'
htmlWidget.value = html.format(
payload=payload, title=title + basename, filename=basename
)
# htmlWidget = widgets.HTML(value = '')
# htmlWidget | Downloads a file from voila. Adopted from https://github.com/voila-dashboards/voila/issues/578#issuecomment-617668058 Args: htmlWidget (object): The HTML widget to display the URL. filename (str): File path to download. title (str, optional): Download description. Defaults to "Click here to download: ". |
12,258 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def csv_to_geojson(
in_csv,
out_geojson=None,
latitude="latitude",
longitude="longitude",
encoding="utf-8",
):
"""Creates points for a CSV file and exports data as a GeoJSON.
Args:
in_csv (str): The file path to the input CSV file.
out_geojson (str): The file path to the exported GeoJSON. Default to None.
latitude (str, optional): The name of the column containing latitude coordinates. Defaults to "latitude".
longitude (str, optional): The name of the column containing longitude coordinates. Defaults to "longitude".
encoding (str, optional): The encoding of characters. Defaults to "utf-8".
"""
import pandas as pd
in_csv = github_raw_url(in_csv)
if out_geojson is not None:
out_geojson = check_file_path(out_geojson)
df = pd.read_csv(in_csv)
geojson = df_to_geojson(
df, latitude=latitude, longitude=longitude, encoding=encoding
)
if out_geojson is None:
return geojson
else:
with open(out_geojson, "w", encoding=encoding) as f:
f.write(json.dumps(geojson))
def geojson_to_ee(geo_json, geodesic=False, encoding="utf-8"):
"""Converts a geojson to ee.Geometry()
Args:
geo_json (dict): A geojson geometry dictionary or file path.
geodesic (bool, optional): Whether line segments should be interpreted as spherical geodesics. If false, indicates that line segments should be interpreted as planar lines in the specified CRS. If absent, defaults to true if the CRS is geographic (including the default EPSG:4326), or to false if the CRS is projected. Defaults to False.
encoding (str, optional): The encoding of characters. Defaults to "utf-8".
Returns:
ee_object: An ee.Geometry object
"""
try:
if isinstance(geo_json, str):
if geo_json.startswith("http") and geo_json.endswith(".geojson"):
geo_json = github_raw_url(geo_json)
out_geojson = temp_file_path(extension=".geojson")
download_file(geo_json, out_geojson)
with open(out_geojson, "r", encoding=encoding) as f:
geo_json = json.loads(f.read())
os.remove(out_geojson)
elif os.path.isfile(geo_json):
with open(os.path.abspath(geo_json), encoding=encoding) as f:
geo_json = json.load(f)
# geo_json["geodesic"] = geodesic
if geo_json["type"] == "FeatureCollection":
for feature in geo_json["features"]:
if feature["geometry"]["type"] != "Point":
feature["geometry"]["geodesic"] = geodesic
features = ee.FeatureCollection(geo_json)
return features
elif geo_json["type"] == "Feature":
geom = None
if "style" in geo_json["properties"]:
keys = geo_json["properties"]["style"].keys()
if "radius" in keys: # Checks whether it is a circle
geom = ee.Geometry(geo_json["geometry"])
radius = geo_json["properties"]["style"]["radius"]
geom = geom.buffer(radius)
elif geo_json["geometry"]["type"] == "Point":
geom = ee.Geometry(geo_json["geometry"])
else:
geom = ee.Geometry(geo_json["geometry"], "", geodesic)
elif (
geo_json["geometry"]["type"] == "Point"
): # Checks whether it is a point
coordinates = geo_json["geometry"]["coordinates"]
longitude = coordinates[0]
latitude = coordinates[1]
geom = ee.Geometry.Point(longitude, latitude)
else:
geom = ee.Geometry(geo_json["geometry"], "", geodesic)
return geom
else:
raise Exception("Could not convert the geojson to ee.Geometry()")
except Exception as e:
print("Could not convert the geojson to ee.Geometry()")
raise Exception(e)
The provided code snippet includes necessary dependencies for implementing the `xy_to_points` function. Write a Python function `def xy_to_points(in_csv, latitude="latitude", longitude="longitude", encoding="utf-8")` to solve the following problem:
Converts a csv containing points (latitude and longitude) into an ee.FeatureCollection. Args: in_csv (str): File path or HTTP URL to the input csv file. For example, https://raw.githubusercontent.com/giswqs/data/main/world/world_cities.csv latitude (str, optional): Column name for the latitude column. Defaults to 'latitude'. longitude (str, optional): Column name for the longitude column. Defaults to 'longitude'. Returns: ee.FeatureCollection: The ee.FeatureCollection containing the points converted from the input csv.
Here is the function:
def xy_to_points(in_csv, latitude="latitude", longitude="longitude", encoding="utf-8"):
"""Converts a csv containing points (latitude and longitude) into an ee.FeatureCollection.
Args:
in_csv (str): File path or HTTP URL to the input csv file. For example, https://raw.githubusercontent.com/giswqs/data/main/world/world_cities.csv
latitude (str, optional): Column name for the latitude column. Defaults to 'latitude'.
longitude (str, optional): Column name for the longitude column. Defaults to 'longitude'.
Returns:
ee.FeatureCollection: The ee.FeatureCollection containing the points converted from the input csv.
"""
geojson = csv_to_geojson(in_csv, None, latitude, longitude, encoding)
fc = geojson_to_ee(geojson)
return fc | Converts a csv containing points (latitude and longitude) into an ee.FeatureCollection. Args: in_csv (str): File path or HTTP URL to the input csv file. For example, https://raw.githubusercontent.com/giswqs/data/main/world/world_cities.csv latitude (str, optional): Column name for the latitude column. Defaults to 'latitude'. longitude (str, optional): Column name for the longitude column. Defaults to 'longitude'. Returns: ee.FeatureCollection: The ee.FeatureCollection containing the points converted from the input csv. |
12,259 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def download_from_url(url, out_file_name=None, out_dir=".", unzip=True, verbose=True):
"""Download a file from a URL (e.g., https://github.com/giswqs/whitebox/raw/master/examples/testdata.zip)
Args:
url (str): The HTTP URL to download.
out_file_name (str, optional): The output file name to use. Defaults to None.
out_dir (str, optional): The output directory to use. Defaults to '.'.
unzip (bool, optional): Whether to unzip the downloaded file if it is a zip file. Defaults to True.
verbose (bool, optional): Whether to display or not the output of the function
"""
in_file_name = os.path.basename(url)
if out_file_name is None:
out_file_name = in_file_name
out_file_path = os.path.join(os.path.abspath(out_dir), out_file_name)
if verbose:
print(f"Downloading {url} ...")
try:
urllib.request.urlretrieve(url, out_file_path)
except Exception:
raise Exception("The URL is invalid. Please double check the URL.")
final_path = out_file_path
if unzip:
# if it is a zip file
if ".zip" in out_file_name:
if verbose:
print(f"Unzipping {out_file_name} ...")
with zipfile.ZipFile(out_file_path, "r") as zip_ref:
zip_ref.extractall(out_dir)
final_path = os.path.join(
os.path.abspath(out_dir), out_file_name.replace(".zip", "")
)
# if it is a tar file
if ".tar" in out_file_name:
if verbose:
print(f"Unzipping {out_file_name} ...")
with tarfile.open(out_file_path, "r") as tar_ref:
with tarfile.open(out_file_path, "r") as tar_ref:
def is_within_directory(directory, target):
abs_directory = os.path.abspath(directory)
abs_target = os.path.abspath(target)
prefix = os.path.commonprefix([abs_directory, abs_target])
return prefix == abs_directory
def safe_extract(
tar, path=".", members=None, *, numeric_owner=False
):
for member in tar.getmembers():
member_path = os.path.join(path, member.name)
if not is_within_directory(path, member_path):
raise Exception("Attempted Path Traversal in Tar File")
tar.extractall(path, members, numeric_owner=numeric_owner)
safe_extract(tar_ref, out_dir)
final_path = os.path.join(
os.path.abspath(out_dir), out_file_name.replace(".tar", "")
)
if verbose:
print(f"Data downloaded to: {final_path}")
return
The provided code snippet includes necessary dependencies for implementing the `csv_points_to_shp` function. Write a Python function `def csv_points_to_shp(in_csv, out_shp, latitude="latitude", longitude="longitude")` to solve the following problem:
Converts a csv file containing points (latitude, longitude) into a shapefile. Args: in_csv (str): File path or HTTP URL to the input csv file. For example, https://raw.githubusercontent.com/giswqs/data/main/world/world_cities.csv out_shp (str): File path to the output shapefile. latitude (str, optional): Column name for the latitude column. Defaults to 'latitude'. longitude (str, optional): Column name for the longitude column. Defaults to 'longitude'.
Here is the function:
def csv_points_to_shp(in_csv, out_shp, latitude="latitude", longitude="longitude"):
"""Converts a csv file containing points (latitude, longitude) into a shapefile.
Args:
in_csv (str): File path or HTTP URL to the input csv file. For example, https://raw.githubusercontent.com/giswqs/data/main/world/world_cities.csv
out_shp (str): File path to the output shapefile.
latitude (str, optional): Column name for the latitude column. Defaults to 'latitude'.
longitude (str, optional): Column name for the longitude column. Defaults to 'longitude'.
"""
import whitebox
if in_csv.startswith("http") and in_csv.endswith(".csv"):
out_dir = os.path.join(os.path.expanduser("~"), "Downloads")
out_name = os.path.basename(in_csv)
if not os.path.exists(out_dir):
os.makedirs(out_dir)
download_from_url(in_csv, out_dir=out_dir, verbose=False)
in_csv = os.path.join(out_dir, out_name)
wbt = whitebox.WhiteboxTools()
in_csv = os.path.abspath(in_csv)
out_shp = os.path.abspath(out_shp)
if not os.path.exists(in_csv):
raise Exception("The provided csv file does not exist.")
with open(in_csv, encoding="utf-8") as csv_file:
reader = csv.DictReader(csv_file)
fields = reader.fieldnames
xfield = fields.index(longitude)
yfield = fields.index(latitude)
wbt.csv_points_to_vector(in_csv, out_shp, xfield=xfield, yfield=yfield, epsg=4326) | Converts a csv file containing points (latitude, longitude) into a shapefile. Args: in_csv (str): File path or HTTP URL to the input csv file. For example, https://raw.githubusercontent.com/giswqs/data/main/world/world_cities.csv out_shp (str): File path to the output shapefile. latitude (str, optional): Column name for the latitude column. Defaults to 'latitude'. longitude (str, optional): Column name for the longitude column. Defaults to 'longitude'. |
12,260 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def download_file(
url=None,
output=None,
quiet=False,
proxy=None,
speed=None,
use_cookies=True,
verify=True,
id=None,
fuzzy=False,
resume=False,
unzip=True,
overwrite=False,
):
"""Download a file from URL, including Google Drive shared URL.
Args:
url (str, optional): Google Drive URL is also supported. Defaults to None.
output (str, optional): Output filename. Default is basename of URL.
quiet (bool, optional): Suppress terminal output. Default is False.
proxy (str, optional): Proxy. Defaults to None.
speed (float, optional): Download byte size per second (e.g., 256KB/s = 256 * 1024). Defaults to None.
use_cookies (bool, optional): Flag to use cookies. Defaults to True.
verify (bool | str, optional): Either a bool, in which case it controls whether the server's TLS certificate is verified, or a string, in which case it must be a path to a CA bundle to use. Default is True.. Defaults to True.
id (str, optional): Google Drive's file ID. Defaults to None.
fuzzy (bool, optional): Fuzzy extraction of Google Drive's file Id. Defaults to False.
resume (bool, optional): Resume the download from existing tmp file if possible. Defaults to False.
unzip (bool, optional): Unzip the file. Defaults to True.
overwrite (bool, optional): Overwrite the file if it already exists. Defaults to False.
Returns:
str: The output file path.
"""
import gdown
if output is None:
if isinstance(url, str) and url.startswith("http"):
output = os.path.basename(url)
if isinstance(url, str):
if os.path.exists(os.path.abspath(output)) and (not overwrite):
print(
f"{output} already exists. Skip downloading. Set overwrite=True to overwrite."
)
return os.path.abspath(output)
else:
url = github_raw_url(url)
if "https://drive.google.com/file/d/" in url:
fuzzy = True
output = gdown.download(
url, output, quiet, proxy, speed, use_cookies, verify, id, fuzzy, resume
)
if unzip and output.endswith(".zip"):
with zipfile.ZipFile(output, "r") as zip_ref:
if not quiet:
print("Extracting files...")
zip_ref.extractall(os.path.dirname(output))
return os.path.abspath(output)
def github_raw_url(url):
"""Get the raw URL for a GitHub file.
Args:
url (str): The GitHub URL.
Returns:
str: The raw URL.
"""
if isinstance(url, str) and url.startswith("https://github.com/") and "blob" in url:
url = url.replace("github.com", "raw.githubusercontent.com").replace(
"blob/", "", 1
)
return url
The provided code snippet includes necessary dependencies for implementing the `csv_to_shp` function. Write a Python function `def csv_to_shp( in_csv, out_shp, latitude="latitude", longitude="longitude", encoding="utf-8" )` to solve the following problem:
Converts a csv file with latlon info to a point shapefile. Args: in_csv (str): The input csv file containing longitude and latitude columns. out_shp (str): The file path to the output shapefile. latitude (str, optional): The column name of the latitude column. Defaults to 'latitude'. longitude (str, optional): The column name of the longitude column. Defaults to 'longitude'.
Here is the function:
def csv_to_shp(
in_csv, out_shp, latitude="latitude", longitude="longitude", encoding="utf-8"
):
"""Converts a csv file with latlon info to a point shapefile.
Args:
in_csv (str): The input csv file containing longitude and latitude columns.
out_shp (str): The file path to the output shapefile.
latitude (str, optional): The column name of the latitude column. Defaults to 'latitude'.
longitude (str, optional): The column name of the longitude column. Defaults to 'longitude'.
"""
import shapefile as shp
if in_csv.startswith("http") and in_csv.endswith(".csv"):
in_csv = github_raw_url(in_csv)
in_csv = download_file(in_csv, quiet=True, overwrite=True)
try:
points = shp.Writer(out_shp, shapeType=shp.POINT)
with open(in_csv, encoding=encoding) as csvfile:
csvreader = csv.DictReader(csvfile)
header = csvreader.fieldnames
[points.field(field) for field in header]
for row in csvreader:
points.point((float(row[longitude])), (float(row[latitude])))
points.record(*tuple([row[f] for f in header]))
out_prj = out_shp.replace(".shp", ".prj")
with open(out_prj, "w") as f:
prj_str = 'GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",SPHEROID["WGS_1984",6378137,298.257223563]],PRIMEM["Greenwich",0],UNIT["Degree",0.0174532925199433]] '
f.write(prj_str)
except Exception as e:
raise Exception(e) | Converts a csv file with latlon info to a point shapefile. Args: in_csv (str): The input csv file containing longitude and latitude columns. out_shp (str): The file path to the output shapefile. latitude (str, optional): The column name of the latitude column. Defaults to 'latitude'. longitude (str, optional): The column name of the longitude column. Defaults to 'longitude'. |
12,261 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def csv_to_gdf(in_csv, latitude="latitude", longitude="longitude", encoding="utf-8"):
"""Creates points for a CSV file and converts them to a GeoDataFrame.
Args:
in_csv (str): The file path to the input CSV file.
latitude (str, optional): The name of the column containing latitude coordinates. Defaults to "latitude".
longitude (str, optional): The name of the column containing longitude coordinates. Defaults to "longitude".
encoding (str, optional): The encoding of characters. Defaults to "utf-8".
Returns:
object: GeoDataFrame.
"""
check_package(name="geopandas", URL="https://geopandas.org")
import geopandas as gpd
out_dir = os.getcwd()
out_geojson = os.path.join(out_dir, random_string() + ".geojson")
csv_to_geojson(in_csv, out_geojson, latitude, longitude, encoding)
gdf = gpd.read_file(out_geojson)
os.remove(out_geojson)
return gdf
The provided code snippet includes necessary dependencies for implementing the `csv_to_vector` function. Write a Python function `def csv_to_vector( in_csv, output, latitude="latitude", longitude="longitude", encoding="utf-8", **kwargs, )` to solve the following problem:
Creates points for a CSV file and converts them to a vector dataset. Args: in_csv (str): The file path to the input CSV file. output (str): The file path to the output vector dataset. latitude (str, optional): The name of the column containing latitude coordinates. Defaults to "latitude". longitude (str, optional): The name of the column containing longitude coordinates. Defaults to "longitude". encoding (str, optional): The encoding of characters. Defaults to "utf-8".
Here is the function:
def csv_to_vector(
in_csv,
output,
latitude="latitude",
longitude="longitude",
encoding="utf-8",
**kwargs,
):
"""Creates points for a CSV file and converts them to a vector dataset.
Args:
in_csv (str): The file path to the input CSV file.
output (str): The file path to the output vector dataset.
latitude (str, optional): The name of the column containing latitude coordinates. Defaults to "latitude".
longitude (str, optional): The name of the column containing longitude coordinates. Defaults to "longitude".
encoding (str, optional): The encoding of characters. Defaults to "utf-8".
"""
gdf = csv_to_gdf(in_csv, latitude, longitude, encoding)
gdf.to_file(output, **kwargs) | Creates points for a CSV file and converts them to a vector dataset. Args: in_csv (str): The file path to the input CSV file. output (str): The file path to the output vector dataset. latitude (str, optional): The name of the column containing latitude coordinates. Defaults to "latitude". longitude (str, optional): The name of the column containing longitude coordinates. Defaults to "longitude". encoding (str, optional): The encoding of characters. Defaults to "utf-8". |
12,262 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def ee_to_gdf(
ee_object,
columns=None,
sort_columns=False,
**kwargs,
):
"""Converts an ee.FeatureCollection to GeoPandas GeoDataFrame.
Args:
ee_object (ee.FeatureCollection): ee.FeatureCollection.
columns (list): List of column names. Defaults to None.
sort_columns (bool): Whether to sort the column names. Defaults to False.
kwargs: Additional arguments passed to ee.data.computeFeature.
Raises:
TypeError: ee_object must be an ee.FeatureCollection
Returns:
gpd.GeoDataFrame: GeoPandas GeoDataFrame
"""
if isinstance(ee_object, ee.Feature):
ee_object = ee.FeatureCollection([ee_object])
if not isinstance(ee_object, ee.FeatureCollection):
raise TypeError("ee_object must be an ee.FeatureCollection")
try:
kwargs["expression"] = ee_object
kwargs["fileFormat"] = "GEOPANDAS_GEODATAFRAME"
crs = ee_object.first().geometry().projection().crs().getInfo()
gdf = ee.data.computeFeatures(kwargs)
if isinstance(columns, list):
gdf = gdf[columns]
if sort_columns:
gdf = gdf.reindex(sorted(gdf.columns), axis=1)
gdf.crs = crs
return gdf
except Exception as e:
raise Exception(e)
The provided code snippet includes necessary dependencies for implementing the `ee_to_shp` function. Write a Python function `def ee_to_shp( ee_object, filename, columns=None, sort_columns=False, **kwargs, )` to solve the following problem:
Downloads an ee.FeatureCollection as a shapefile. Args: ee_object (object): ee.FeatureCollection filename (str): The output filepath of the shapefile. columns (list, optional): A list of attributes to export. Defaults to None. sort_columns (bool, optional): Whether to sort the columns alphabetically. Defaults to False. kwargs: Additional arguments passed to ee_to_gdf().
Here is the function:
def ee_to_shp(
ee_object,
filename,
columns=None,
sort_columns=False,
**kwargs,
):
"""Downloads an ee.FeatureCollection as a shapefile.
Args:
ee_object (object): ee.FeatureCollection
filename (str): The output filepath of the shapefile.
columns (list, optional): A list of attributes to export. Defaults to None.
sort_columns (bool, optional): Whether to sort the columns alphabetically. Defaults to False.
kwargs: Additional arguments passed to ee_to_gdf().
"""
try:
if filename.lower().endswith(".shp"):
gdf = ee_to_gdf(ee_object, columns, sort_columns, **kwargs)
gdf.to_file(filename)
else:
print("The filename must end with .shp")
except Exception as e:
print(e) | Downloads an ee.FeatureCollection as a shapefile. Args: ee_object (object): ee.FeatureCollection filename (str): The output filepath of the shapefile. columns (list, optional): A list of attributes to export. Defaults to None. sort_columns (bool, optional): Whether to sort the columns alphabetically. Defaults to False. kwargs: Additional arguments passed to ee_to_gdf(). |
12,263 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def ee_to_df(
ee_object,
columns=None,
remove_geom=True,
sort_columns=False,
**kwargs,
):
"""Converts an ee.FeatureCollection to pandas dataframe.
Args:
ee_object (ee.FeatureCollection): ee.FeatureCollection.
columns (list): List of column names. Defaults to None.
remove_geom (bool): Whether to remove the geometry column. Defaults to True.
sort_columns (bool): Whether to sort the column names. Defaults to False.
kwargs: Additional arguments passed to ee.data.computeFeature.
Raises:
TypeError: ee_object must be an ee.FeatureCollection
Returns:
pd.DataFrame: pandas DataFrame
"""
if isinstance(ee_object, ee.Feature):
ee_object = ee.FeatureCollection([ee_object])
if not isinstance(ee_object, ee.FeatureCollection):
raise TypeError("ee_object must be an ee.FeatureCollection")
try:
property_names = ee_object.first().propertyNames().sort().getInfo()
if remove_geom:
data = ee_object.map(
lambda f: ee.Feature(None, f.toDictionary(property_names))
)
else:
data = ee_object
kwargs["expression"] = data
kwargs["fileFormat"] = "PANDAS_DATAFRAME"
df = ee.data.computeFeatures(kwargs)
if isinstance(columns, list):
df = df[columns]
if remove_geom and ("geo" in df.columns):
df = df.drop(columns=["geo"], axis=1)
if sort_columns:
df = df.reindex(sorted(df.columns), axis=1)
return df
except Exception as e:
raise Exception(e)
The provided code snippet includes necessary dependencies for implementing the `ee_to_csv` function. Write a Python function `def ee_to_csv( ee_object, filename, columns=None, remove_geom=True, sort_columns=False, **kwargs, )` to solve the following problem:
Downloads an ee.FeatureCollection as a CSV file. Args: ee_object (object): ee.FeatureCollection filename (str): The output filepath of the CSV file. columns (list, optional): A list of attributes to export. Defaults to None. remove_geom (bool, optional): Whether to remove the geometry column. Defaults to True. sort_columns (bool, optional): Whether to sort the columns alphabetically. Defaults to False. kwargs: Additional arguments passed to ee_to_df().
Here is the function:
def ee_to_csv(
ee_object,
filename,
columns=None,
remove_geom=True,
sort_columns=False,
**kwargs,
):
"""Downloads an ee.FeatureCollection as a CSV file.
Args:
ee_object (object): ee.FeatureCollection
filename (str): The output filepath of the CSV file.
columns (list, optional): A list of attributes to export. Defaults to None.
remove_geom (bool, optional): Whether to remove the geometry column. Defaults to True.
sort_columns (bool, optional): Whether to sort the columns alphabetically. Defaults to False.
kwargs: Additional arguments passed to ee_to_df().
"""
try:
if filename.lower().endswith(".csv"):
df = ee_to_df(ee_object, columns, remove_geom, sort_columns, **kwargs)
df.to_csv(filename, index=False)
else:
print("The filename must end with .csv")
except Exception as e:
print(e) | Downloads an ee.FeatureCollection as a CSV file. Args: ee_object (object): ee.FeatureCollection filename (str): The output filepath of the CSV file. columns (list, optional): A list of attributes to export. Defaults to None. remove_geom (bool, optional): Whether to remove the geometry column. Defaults to True. sort_columns (bool, optional): Whether to sort the columns alphabetically. Defaults to False. kwargs: Additional arguments passed to ee_to_df(). |
12,264 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def ee_export_vector(
ee_object,
filename,
selectors=None,
verbose=True,
keep_zip=False,
timeout=300,
proxies=None,
):
"""Exports Earth Engine FeatureCollection to other formats, including shp, csv, json, kml, and kmz.
Args:
ee_object (object): ee.FeatureCollection to export.
filename (str): Output file name.
selectors (list, optional): A list of attributes to export. Defaults to None.
verbose (bool, optional): Whether to print out descriptive text.
keep_zip (bool, optional): Whether to keep the downloaded shapefile as a zip file.
timeout (int, optional): Timeout in seconds. Defaults to 300 seconds.
proxies (dict, optional): A dictionary of proxies to use. Defaults to None.
"""
if not isinstance(ee_object, ee.FeatureCollection):
raise ValueError("ee_object must be an ee.FeatureCollection")
allowed_formats = ["csv", "geojson", "json", "kml", "kmz", "shp"]
# allowed_formats = ['csv', 'kml', 'kmz']
filename = os.path.abspath(filename)
basename = os.path.basename(filename)
name = os.path.splitext(basename)[0]
filetype = os.path.splitext(basename)[1][1:].lower()
if filetype == "shp":
filename = filename.replace(".shp", ".zip")
if not (filetype.lower() in allowed_formats):
raise ValueError(
"The file type must be one of the following: {}".format(
", ".join(allowed_formats)
)
)
if selectors is None:
selectors = ee_object.first().propertyNames().getInfo()
if filetype == "csv":
# remove .geo coordinate field
ee_object = ee_object.select([".*"], None, False)
if filetype == "geojson":
selectors = [".geo"] + selectors
elif not isinstance(selectors, list):
raise ValueError(
"selectors must be a list, such as ['attribute1', 'attribute2']"
)
else:
allowed_attributes = ee_object.first().propertyNames().getInfo()
for attribute in selectors:
if not (attribute in allowed_attributes):
raise ValueError(
"Attributes must be one chosen from: {} ".format(
", ".join(allowed_attributes)
)
)
try:
if verbose:
print("Generating URL ...")
url = ee_object.getDownloadURL(
filetype=filetype, selectors=selectors, filename=name
)
if verbose:
print(f"Downloading data from {url}\nPlease wait ...")
r = None
r = requests.get(url, stream=True, timeout=timeout, proxies=proxies)
if r.status_code != 200:
print("An error occurred while downloading. \n Retrying ...")
try:
new_ee_object = ee_object.map(filter_polygons)
print("Generating URL ...")
url = new_ee_object.getDownloadURL(
filetype=filetype, selectors=selectors, filename=name
)
print(f"Downloading data from {url}\nPlease wait ...")
r = requests.get(url, stream=True, timeout=timeout, proxies=proxies)
except Exception as e:
print(e)
raise ValueError
with open(filename, "wb") as fd:
for chunk in r.iter_content(chunk_size=1024):
fd.write(chunk)
except Exception as e:
print("An error occurred while downloading.")
if r is not None:
print(r.json()["error"]["message"])
raise ValueError(e)
try:
if filetype == "shp":
with zipfile.ZipFile(filename) as z:
z.extractall(os.path.dirname(filename))
if not keep_zip:
os.remove(filename)
filename = filename.replace(".zip", ".shp")
if verbose:
print(f"Data downloaded to {filename}")
except Exception as e:
raise ValueError(e)
The provided code snippet includes necessary dependencies for implementing the `dict_to_csv` function. Write a Python function `def dict_to_csv(data_dict, out_csv, by_row=False, timeout=300, proxies=None)` to solve the following problem:
Downloads an ee.Dictionary as a CSV file. Args: data_dict (ee.Dictionary): The input ee.Dictionary. out_csv (str): The output file path to the CSV file. by_row (bool, optional): Whether to use by row or by column. Defaults to False. timeout (int, optional): Timeout in seconds. Defaults to 300 seconds. proxies (dict, optional): Proxy settings. Defaults to None.
Here is the function:
def dict_to_csv(data_dict, out_csv, by_row=False, timeout=300, proxies=None):
"""Downloads an ee.Dictionary as a CSV file.
Args:
data_dict (ee.Dictionary): The input ee.Dictionary.
out_csv (str): The output file path to the CSV file.
by_row (bool, optional): Whether to use by row or by column. Defaults to False.
timeout (int, optional): Timeout in seconds. Defaults to 300 seconds.
proxies (dict, optional): Proxy settings. Defaults to None.
"""
out_dir = os.path.dirname(out_csv)
if not os.path.exists(out_dir):
os.makedirs(out_dir)
if not by_row:
csv_feature = ee.Feature(None, data_dict)
csv_feat_col = ee.FeatureCollection([csv_feature])
else:
keys = data_dict.keys()
data = keys.map(lambda k: ee.Dictionary({"name": k, "value": data_dict.get(k)}))
csv_feature = data.map(lambda f: ee.Feature(None, f))
csv_feat_col = ee.FeatureCollection(csv_feature)
ee_export_vector(csv_feat_col, out_csv, timeout=timeout, proxies=proxies) | Downloads an ee.Dictionary as a CSV file. Args: data_dict (ee.Dictionary): The input ee.Dictionary. out_csv (str): The output file path to the CSV file. by_row (bool, optional): Whether to use by row or by column. Defaults to False. timeout (int, optional): Timeout in seconds. Defaults to 300 seconds. proxies (dict, optional): Proxy settings. Defaults to None. |
12,265 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def numpy_to_ee(np_array, crs=None, transform=None, transformWkt=None, band_names=None):
"""
Creates an ee.Image from a 3D numpy array where each 2D numpy slice is added to a band, and a geospatial transform that indicates where to put the data. If the np_array is already 2D only, then it is only a one-band image.
Args:
np_array (np.array): the 3D (or 2D) numpy array to add to an image
crs (str): The base coordinate reference system of this Projection, given as a well-known authority code (e.g. 'EPSG:4326') or a WKT string.
transform (list): The transform between projected coordinates and the base coordinate system, specified as a 2x3 affine transform matrix in row-major order: [xScale, xShearing, xTranslation, yShearing, yScale, yTranslation]. May not specify both this and 'transformWkt'.
transformWkt (str): The transform between projected coordinates and the base coordinate system, specified as a WKT string. May not specify both this and 'transform'.
band_names (str or list, optional): The list of names for the bands. The default names are 'constant', and 'constant_1', 'constant_2', etc.
Returns:
image: An ee.Image
"""
import numpy as np
if not isinstance(np_array, np.ndarray):
print("The input must be a numpy.ndarray.")
return
if not len(np_array.shape) in [2, 3]:
print("The input must have 2 or 3 dimensions")
return
if band_names and not isinstance(band_names, (list, str)):
print("Band names must be a str or list")
return
try:
projection = ee.Projection(crs, transform, transformWkt)
coords = ee.Image.pixelCoordinates(projection).floor().int32()
x = coords.select("x")
y = coords.select("y")
s = np_array.shape
if len(s) < 3:
dimx = s[0]
dimy = s[1]
else:
dimx = s[1]
dimy = s[2]
dimz = s[0]
coord_mask = x.gte(0).And(y.gte(0)).And(x.lt(dimx)).And(y.lt(dimy))
coords = coords.updateMask(coord_mask)
def list_to_ee(a_list):
ee_data = ee.Array(a_list)
image = ee.Image(ee_data).arrayGet(coords)
return image
if len(s) < 3:
image = list_to_ee(np_array.tolist())
else:
image = list_to_ee(np_array[0].tolist())
for z in np.arange(1, dimz):
image = image.addBands(list_to_ee(np_array[z].tolist()))
if band_names:
image = image.rename(band_names)
return image
except Exception as e:
print(e)
The provided code snippet includes necessary dependencies for implementing the `netcdf_to_ee` function. Write a Python function `def netcdf_to_ee(nc_file, var_names, band_names=None, lon="lon", lat="lat")` to solve the following problem:
Creates an ee.Image from netCDF variables band_names that are read from nc_file. Currently only supports variables in a regular longitude/latitude grid (EPSG:4326). Args: nc_file (str): the name of the netCDF file to read var_names (str or list): the name(s) of the variable(s) to read band_names (list, optional): if given, the bands are renamed to band_names. Defaults to the original var_names lon (str, optional): the name of the longitude variable in the netCDF file. Defaults to "lon" lat (str, optional): the name of the latitude variable in the netCDF file. Defaults to "lat" Returns: image: An ee.Image
Here is the function:
def netcdf_to_ee(nc_file, var_names, band_names=None, lon="lon", lat="lat"):
"""
Creates an ee.Image from netCDF variables band_names that are read from nc_file. Currently only supports variables in a regular longitude/latitude grid (EPSG:4326).
Args:
nc_file (str): the name of the netCDF file to read
var_names (str or list): the name(s) of the variable(s) to read
band_names (list, optional): if given, the bands are renamed to band_names. Defaults to the original var_names
lon (str, optional): the name of the longitude variable in the netCDF file. Defaults to "lon"
lat (str, optional): the name of the latitude variable in the netCDF file. Defaults to "lat"
Returns:
image: An ee.Image
"""
try:
import xarray as xr
except Exception:
raise ImportError(
"You need to install xarray first. See https://github.com/pydata/xarray"
)
import numpy as np
try:
if not isinstance(nc_file, str):
print("The input file must be a string.")
return
if band_names and not isinstance(band_names, (list, str)):
print("Band names must be a string or list.")
return
if not isinstance(lon, str) or not isinstance(lat, str):
print("The longitude and latitude variable names must be a string.")
return
ds = xr.open_dataset(nc_file)
data = ds[var_names]
lon_data = data[lon]
lat_data = data[lat]
dim_lon = np.unique(np.ediff1d(lon_data))
dim_lat = np.unique(np.ediff1d(lat_data))
if (len(dim_lon) != 1) or (len(dim_lat) != 1):
print("The netCDF file is not a regular longitude/latitude grid")
return
try:
data = data.to_array()
# ^ this is only needed (and works) if we have more than 1 variable
# axis_for_roll will be used in case we need to use np.roll
# and should be 1 for the case with more than 1 variable
axis_for_roll = 1
except Exception:
axis_for_roll = 0
# .to_array() does not work (and is not needed!) if there is only 1 variable
# in this case, the axis_for_roll needs to be 0
data_np = np.array(data)
do_transpose = True # To do: figure out if we need to transpose the data or not
if do_transpose:
try:
data_np = np.transpose(data_np, (0, 2, 1))
except Exception:
data_np = np.transpose(data_np)
# Figure out if we need to roll the data or not
# (see https://github.com/gee-community/geemap/issues/285#issuecomment-791385176)
if np.max(lon_data) > 180:
data_np = np.roll(data_np, 180, axis=axis_for_roll)
west_lon = lon_data[0] - 180
else:
west_lon = lon_data[0]
transform = [dim_lon[0], 0, float(west_lon), 0, dim_lat[0], float(lat_data[0])]
if band_names is None:
band_names = var_names
image = numpy_to_ee(
data_np, "EPSG:4326", transform=transform, band_names=band_names
)
return image
except Exception as e:
print(e) | Creates an ee.Image from netCDF variables band_names that are read from nc_file. Currently only supports variables in a regular longitude/latitude grid (EPSG:4326). Args: nc_file (str): the name of the netCDF file to read var_names (str or list): the name(s) of the variable(s) to read band_names (list, optional): if given, the bands are renamed to band_names. Defaults to the original var_names lon (str, optional): the name of the longitude variable in the netCDF file. Defaults to "lon" lat (str, optional): the name of the latitude variable in the netCDF file. Defaults to "lat" Returns: image: An ee.Image |
12,266 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `ee_to_numpy` function. Write a Python function `def ee_to_numpy(ee_object, region=None, scale=None, bands=None, **kwargs)` to solve the following problem:
Extracts a rectangular region of pixels from an image into a numpy array. Args: ee_object (ee.Image): The image to sample. region (ee.Geometry, optional): The region to sample. Defaults to None. bands (list, optional): The list of band names to extract. Defaults to None. scale (int, optional): A nominal scale in meters of the projection to sample in. Defaults to None. Returns: np.ndarray: A 3D numpy array in the format of [row, column, band].
Here is the function:
def ee_to_numpy(ee_object, region=None, scale=None, bands=None, **kwargs):
"""Extracts a rectangular region of pixels from an image into a numpy array.
Args:
ee_object (ee.Image): The image to sample.
region (ee.Geometry, optional): The region to sample. Defaults to None.
bands (list, optional): The list of band names to extract. Defaults to None.
scale (int, optional): A nominal scale in meters of the projection to sample in. Defaults to None.
Returns:
np.ndarray: A 3D numpy array in the format of [row, column, band].
"""
import numpy as np
if (region is not None) or (scale is not None):
ee_object = ee_object.clipToBoundsAndScale(geometry=region, scale=scale)
kwargs["expression"] = ee_object
kwargs["fileFormat"] = "NUMPY_NDARRAY"
if bands is not None:
kwargs["bandIds"] = bands
try:
struct_array = ee.data.computePixels(kwargs)
array = np.dstack(([struct_array[band] for band in struct_array.dtype.names]))
return array
except Exception as e:
raise Exception(e) | Extracts a rectangular region of pixels from an image into a numpy array. Args: ee_object (ee.Image): The image to sample. region (ee.Geometry, optional): The region to sample. Defaults to None. bands (list, optional): The list of band names to extract. Defaults to None. scale (int, optional): A nominal scale in meters of the projection to sample in. Defaults to None. Returns: np.ndarray: A 3D numpy array in the format of [row, column, band]. |
12,267 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def install_package(package):
"""Install a Python package.
Args:
package (str | list): The package name or a GitHub URL or a list of package names or GitHub URLs.
"""
import subprocess
if isinstance(package, str):
packages = [package]
for package in packages:
if package.startswith("https"):
package = f"git+{package}"
# Execute pip install command and show output in real-time
command = f"pip install {package}"
process = subprocess.Popen(command.split(), stdout=subprocess.PIPE)
# Print output in real-time
while True:
output = process.stdout.readline()
if output == b"" and process.poll() is not None:
break
if output:
print(output.decode("utf-8").strip())
# Wait for process to complete
process.wait()
The provided code snippet includes necessary dependencies for implementing the `ee_to_xarray` function. Write a Python function `def ee_to_xarray( dataset, drop_variables=None, io_chunks=None, n_images=-1, mask_and_scale=True, decode_times=True, decode_timedelta=None, use_cftime=None, concat_characters=True, decode_coords=True, crs=None, scale=None, projection=None, geometry=None, primary_dim_name=None, primary_dim_property=None, ee_mask_value=None, ee_initialize=True, **kwargs, )` to solve the following problem:
Open an Earth Engine ImageCollection as an Xarray Dataset. This function is a wrapper for xee. EarthEngineBackendEntrypoint.open_dataset(). See https://github.com/google/Xee/blob/main/xee/ext.py#L886 Args: dataset: An asset ID for an ImageCollection, or an ee.ImageCollection object. drop_variables (optional): Variables or bands to drop before opening. io_chunks (optional): Specifies the chunking strategy for loading data from EE. By default, this automatically calculates optional chunks based on the `request_byte_limit`. n_images (optional): The max number of EE images in the collection to open. Useful when there are a large number of images in the collection since calculating collection size can be slow. -1 indicates that all images should be included. mask_and_scale (optional): Lazily scale (using scale_factor and add_offset) and mask (using _FillValue). decode_times (optional): Decode cf times (e.g., integers since "hours since 2000-01-01") to np.datetime64. decode_timedelta (optional): If True, decode variables and coordinates with time units in {"days", "hours", "minutes", "seconds", "milliseconds", "microseconds"} into timedelta objects. If False, leave them encoded as numbers. If None (default), assume the same value of decode_time. use_cftime (optional): Only relevant if encoded dates come from a standard calendar (e.g. "gregorian", "proleptic_gregorian", "standard", or not specified). If None (default), attempt to decode times to ``np.datetime64[ns]`` objects; if this is not possible, decode times to ``cftime.datetime`` objects. If True, always decode times to ``cftime.datetime`` objects, regardless of whether or not they can be represented using ``np.datetime64[ns]`` objects. If False, always decode times to ``np.datetime64[ns]`` objects; if this is not possible raise an error. concat_characters (optional): Should character arrays be concatenated to strings, for example: ["h", "e", "l", "l", "o"] -> "hello" decode_coords (optional): bool or {"coordinates", "all"}, Controls which variables are set as coordinate variables: - "coordinates" or True: Set variables referred to in the ``'coordinates'`` attribute of the datasets or individual variables as coordinate variables. - "all": Set variables referred to in ``'grid_mapping'``, ``'bounds'`` and other attributes as coordinate variables. crs (optional): The coordinate reference system (a CRS code or WKT string). This defines the frame of reference to coalesce all variables upon opening. By default, data is opened with `EPSG:4326'. scale (optional): The scale in the `crs` or `projection`'s units of measure -- either meters or degrees. This defines the scale that all data is represented in upon opening. By default, the scale is 1° when the CRS is in degrees or 10,000 when in meters. projection (optional): Specify an `ee.Projection` object to define the `scale` and `crs` (or other coordinate reference system) with which to coalesce all variables upon opening. By default, the scale and reference system is set by the the `crs` and `scale` arguments. geometry (optional): Specify an `ee.Geometry` to define the regional bounds when opening the data. When not set, the bounds are defined by the CRS's 'area_of_use` boundaries. If those aren't present, the bounds are derived from the geometry of the first image of the collection. primary_dim_name (optional): Override the name of the primary dimension of the output Dataset. By default, the name is 'time'. primary_dim_property (optional): Override the `ee.Image` property for which to derive the values of the primary dimension. By default, this is 'system:time_start'. ee_mask_value (optional): Value to mask to EE nodata values. By default, this is 'np.iinfo(np.int32).max' i.e. 2147483647. request_byte_limit: the max allowed bytes to request at a time from Earth Engine. By default, it is 48MBs. ee_initialize (optional): Whether to initialize ee with the high-volume endpoint. Defaults to True. Returns: An xarray.Dataset that streams in remote data from Earth Engine.
Here is the function:
def ee_to_xarray(
dataset,
drop_variables=None,
io_chunks=None,
n_images=-1,
mask_and_scale=True,
decode_times=True,
decode_timedelta=None,
use_cftime=None,
concat_characters=True,
decode_coords=True,
crs=None,
scale=None,
projection=None,
geometry=None,
primary_dim_name=None,
primary_dim_property=None,
ee_mask_value=None,
ee_initialize=True,
**kwargs,
):
"""Open an Earth Engine ImageCollection as an Xarray Dataset. This function is a wrapper for
xee. EarthEngineBackendEntrypoint.open_dataset().
See https://github.com/google/Xee/blob/main/xee/ext.py#L886
Args:
dataset: An asset ID for an ImageCollection, or an
ee.ImageCollection object.
drop_variables (optional): Variables or bands to drop before opening.
io_chunks (optional): Specifies the chunking strategy for loading data
from EE. By default, this automatically calculates optional chunks based
on the `request_byte_limit`.
n_images (optional): The max number of EE images in the collection to
open. Useful when there are a large number of images in the collection
since calculating collection size can be slow. -1 indicates that all
images should be included.
mask_and_scale (optional): Lazily scale (using scale_factor and
add_offset) and mask (using _FillValue).
decode_times (optional): Decode cf times (e.g., integers since "hours
since 2000-01-01") to np.datetime64.
decode_timedelta (optional): If True, decode variables and coordinates
with time units in {"days", "hours", "minutes", "seconds",
"milliseconds", "microseconds"} into timedelta objects. If False, leave
them encoded as numbers. If None (default), assume the same value of
decode_time.
use_cftime (optional): Only relevant if encoded dates come from a standard
calendar (e.g. "gregorian", "proleptic_gregorian", "standard", or not
specified). If None (default), attempt to decode times to
``np.datetime64[ns]`` objects; if this is not possible, decode times to
``cftime.datetime`` objects. If True, always decode times to
``cftime.datetime`` objects, regardless of whether or not they can be
represented using ``np.datetime64[ns]`` objects. If False, always
decode times to ``np.datetime64[ns]`` objects; if this is not possible
raise an error.
concat_characters (optional): Should character arrays be concatenated to
strings, for example: ["h", "e", "l", "l", "o"] -> "hello"
decode_coords (optional): bool or {"coordinates", "all"}, Controls which
variables are set as coordinate variables: - "coordinates" or True: Set
variables referred to in the ``'coordinates'`` attribute of the datasets
or individual variables as coordinate variables. - "all": Set variables
referred to in ``'grid_mapping'``, ``'bounds'`` and other attributes as
coordinate variables.
crs (optional): The coordinate reference system (a CRS code or WKT
string). This defines the frame of reference to coalesce all variables
upon opening. By default, data is opened with `EPSG:4326'.
scale (optional): The scale in the `crs` or `projection`'s units of
measure -- either meters or degrees. This defines the scale that all
data is represented in upon opening. By default, the scale is 1° when
the CRS is in degrees or 10,000 when in meters.
projection (optional): Specify an `ee.Projection` object to define the
`scale` and `crs` (or other coordinate reference system) with which to
coalesce all variables upon opening. By default, the scale and reference
system is set by the the `crs` and `scale` arguments.
geometry (optional): Specify an `ee.Geometry` to define the regional
bounds when opening the data. When not set, the bounds are defined by
the CRS's 'area_of_use` boundaries. If those aren't present, the bounds
are derived from the geometry of the first image of the collection.
primary_dim_name (optional): Override the name of the primary dimension of
the output Dataset. By default, the name is 'time'.
primary_dim_property (optional): Override the `ee.Image` property for
which to derive the values of the primary dimension. By default, this is
'system:time_start'.
ee_mask_value (optional): Value to mask to EE nodata values. By default,
this is 'np.iinfo(np.int32).max' i.e. 2147483647.
request_byte_limit: the max allowed bytes to request at a time from Earth
Engine. By default, it is 48MBs.
ee_initialize (optional): Whether to initialize ee with the high-volume endpoint. Defaults to True.
Returns:
An xarray.Dataset that streams in remote data from Earth Engine.
"""
try:
import xee
except ImportError:
install_package("xee")
import xee
import xarray as xr
kwargs["drop_variables"] = drop_variables
kwargs["io_chunks"] = io_chunks
kwargs["n_images"] = n_images
kwargs["mask_and_scale"] = mask_and_scale
kwargs["decode_times"] = decode_times
kwargs["decode_timedelta"] = decode_timedelta
kwargs["use_cftime"] = use_cftime
kwargs["concat_characters"] = concat_characters
kwargs["decode_coords"] = decode_coords
kwargs["crs"] = crs
kwargs["scale"] = scale
kwargs["projection"] = projection
kwargs["geometry"] = geometry
kwargs["primary_dim_name"] = primary_dim_name
kwargs["primary_dim_property"] = primary_dim_property
kwargs["ee_mask_value"] = ee_mask_value
kwargs["engine"] = "ee"
if ee_initialize:
opt_url = "https://earthengine-highvolume.googleapis.com"
ee.Initialize(opt_url=opt_url)
if isinstance(dataset, str):
if not dataset.startswith("ee://"):
dataset = "ee://" + dataset
elif isinstance(dataset, ee.Image):
dataset = ee.ImageCollection(dataset)
elif isinstance(dataset, ee.ImageCollection):
pass
elif isinstance(dataset, list):
items = []
for item in dataset:
if isinstance(item, str) and not item.startswith("ee://"):
item = "ee://" + item
items.append(item)
dataset = items
else:
raise ValueError(
"The dataset must be an ee.Image, ee.ImageCollection, or a list of ee.Image."
)
if isinstance(dataset, list):
ds = xr.open_mfdataset(dataset, **kwargs)
else:
ds = xr.open_dataset(dataset, **kwargs)
return ds | Open an Earth Engine ImageCollection as an Xarray Dataset. This function is a wrapper for xee. EarthEngineBackendEntrypoint.open_dataset(). See https://github.com/google/Xee/blob/main/xee/ext.py#L886 Args: dataset: An asset ID for an ImageCollection, or an ee.ImageCollection object. drop_variables (optional): Variables or bands to drop before opening. io_chunks (optional): Specifies the chunking strategy for loading data from EE. By default, this automatically calculates optional chunks based on the `request_byte_limit`. n_images (optional): The max number of EE images in the collection to open. Useful when there are a large number of images in the collection since calculating collection size can be slow. -1 indicates that all images should be included. mask_and_scale (optional): Lazily scale (using scale_factor and add_offset) and mask (using _FillValue). decode_times (optional): Decode cf times (e.g., integers since "hours since 2000-01-01") to np.datetime64. decode_timedelta (optional): If True, decode variables and coordinates with time units in {"days", "hours", "minutes", "seconds", "milliseconds", "microseconds"} into timedelta objects. If False, leave them encoded as numbers. If None (default), assume the same value of decode_time. use_cftime (optional): Only relevant if encoded dates come from a standard calendar (e.g. "gregorian", "proleptic_gregorian", "standard", or not specified). If None (default), attempt to decode times to ``np.datetime64[ns]`` objects; if this is not possible, decode times to ``cftime.datetime`` objects. If True, always decode times to ``cftime.datetime`` objects, regardless of whether or not they can be represented using ``np.datetime64[ns]`` objects. If False, always decode times to ``np.datetime64[ns]`` objects; if this is not possible raise an error. concat_characters (optional): Should character arrays be concatenated to strings, for example: ["h", "e", "l", "l", "o"] -> "hello" decode_coords (optional): bool or {"coordinates", "all"}, Controls which variables are set as coordinate variables: - "coordinates" or True: Set variables referred to in the ``'coordinates'`` attribute of the datasets or individual variables as coordinate variables. - "all": Set variables referred to in ``'grid_mapping'``, ``'bounds'`` and other attributes as coordinate variables. crs (optional): The coordinate reference system (a CRS code or WKT string). This defines the frame of reference to coalesce all variables upon opening. By default, data is opened with `EPSG:4326'. scale (optional): The scale in the `crs` or `projection`'s units of measure -- either meters or degrees. This defines the scale that all data is represented in upon opening. By default, the scale is 1° when the CRS is in degrees or 10,000 when in meters. projection (optional): Specify an `ee.Projection` object to define the `scale` and `crs` (or other coordinate reference system) with which to coalesce all variables upon opening. By default, the scale and reference system is set by the the `crs` and `scale` arguments. geometry (optional): Specify an `ee.Geometry` to define the regional bounds when opening the data. When not set, the bounds are defined by the CRS's 'area_of_use` boundaries. If those aren't present, the bounds are derived from the geometry of the first image of the collection. primary_dim_name (optional): Override the name of the primary dimension of the output Dataset. By default, the name is 'time'. primary_dim_property (optional): Override the `ee.Image` property for which to derive the values of the primary dimension. By default, this is 'system:time_start'. ee_mask_value (optional): Value to mask to EE nodata values. By default, this is 'np.iinfo(np.int32).max' i.e. 2147483647. request_byte_limit: the max allowed bytes to request at a time from Earth Engine. By default, it is 48MBs. ee_initialize (optional): Whether to initialize ee with the high-volume endpoint. Defaults to True. Returns: An xarray.Dataset that streams in remote data from Earth Engine. |
12,268 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `screen_capture` function. Write a Python function `def screen_capture(filename, monitor=1)` to solve the following problem:
Takes a full screenshot of the selected monitor. Args: filename (str): The output file path to the screenshot. monitor (int, optional): The monitor to take the screenshot. Defaults to 1.
Here is the function:
def screen_capture(filename, monitor=1):
"""Takes a full screenshot of the selected monitor.
Args:
filename (str): The output file path to the screenshot.
monitor (int, optional): The monitor to take the screenshot. Defaults to 1.
"""
try:
from mss import mss
except ImportError:
raise ImportError("Please install mss package using 'pip install mss'")
out_dir = os.path.dirname(filename)
if not os.path.exists(out_dir):
os.makedirs(out_dir)
if not isinstance(monitor, int):
print("The monitor number must be an integer.")
return
try:
with mss() as sct:
sct.shot(output=filename, mon=monitor)
return filename
except Exception as e:
print(e) | Takes a full screenshot of the selected monitor. Args: filename (str): The output file path to the screenshot. monitor (int, optional): The monitor to take the screenshot. Defaults to 1. |
12,269 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def in_colab_shell():
"""Tests if the code is being executed within Google Colab."""
import sys
if "google.colab" in sys.modules:
return True
else:
return False
The provided code snippet includes necessary dependencies for implementing the `open_url` function. Write a Python function `def open_url(url)` to solve the following problem:
Opens the URL in a new browser tab.
Here is the function:
def open_url(url):
"""Opens the URL in a new browser tab."""
if in_colab_shell():
display(
Javascript('window.open("{url}", "_blank", "noopener")'.format(url=url))
)
else:
import webbrowser
webbrowser.open_new_tab(url) | Opens the URL in a new browser tab. |
12,270 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `api_docs` function. Write a Python function `def api_docs()` to solve the following problem:
Open a browser and navigate to the geemap API documentation.
Here is the function:
def api_docs():
"""Open a browser and navigate to the geemap API documentation."""
import webbrowser
url = "https://geemap.org/geemap"
webbrowser.open_new_tab(url) | Open a browser and navigate to the geemap API documentation. |
12,271 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
try:
from IPython.display import display, IFrame, Javascript
except ImportError:
pass
The provided code snippet includes necessary dependencies for implementing the `show_youtube` function. Write a Python function `def show_youtube(id="h0pz3S6Tvx0")` to solve the following problem:
Displays a YouTube video within Jupyter notebooks. Args: id (str, optional): Unique ID of the video. Defaults to 'h0pz3S6Tvx0'.
Here is the function:
def show_youtube(id="h0pz3S6Tvx0"):
"""Displays a YouTube video within Jupyter notebooks.
Args:
id (str, optional): Unique ID of the video. Defaults to 'h0pz3S6Tvx0'.
"""
from IPython.display import YouTubeVideo, display
if "/" in id:
id = id.split("/")[-1]
try:
out = widgets.Output(layout={"width": "815px"})
# layout={'border': '1px solid black', 'width': '815px'})
out.outputs = ()
display(out)
with out:
display(YouTubeVideo(id, width=800, height=450))
except Exception as e:
print(e) | Displays a YouTube video within Jupyter notebooks. Args: id (str, optional): Unique ID of the video. Defaults to 'h0pz3S6Tvx0'. |
12,272 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def random_string(string_length=3):
"""Generates a random string of fixed length.
Args:
string_length (int, optional): Fixed length. Defaults to 3.
Returns:
str: A random string
"""
import random
import string
# random.seed(1001)
letters = string.ascii_lowercase
return "".join(random.choice(letters) for i in range(string_length))
def check_color(in_color):
"""Checks the input color and returns the corresponding hex color code.
Args:
in_color (str or tuple): It can be a string (e.g., 'red', '#ffff00', 'ffff00', 'ff0') or RGB tuple (e.g., (255, 127, 0)).
Returns:
str: A hex color code.
"""
import colour
out_color = "#000000" # default black color
if isinstance(in_color, tuple) and len(in_color) == 3:
# rescale color if necessary
if all(isinstance(item, int) for item in in_color):
in_color = [c / 255.0 for c in in_color]
return colour.Color(rgb=tuple(in_color)).hex_l
else:
# try to guess the color system
try:
return colour.Color(in_color).hex_l
except Exception as e:
pass
# try again by adding an extra # (GEE handle hex codes without #)
try:
return colour.Color(f"#{in_color}").hex_l
except Exception as e:
print(
f"The provided color ({in_color}) is invalid. Using the default black color."
)
print(e)
return out_color
def system_fonts(show_full_path=False):
"""Gets a list of system fonts
# Common font locations:
# Linux: /usr/share/fonts/TTF/
# Windows: C:/Windows/Fonts
# macOS: System > Library > Fonts
Args:
show_full_path (bool, optional): Whether to show the full path of each system font. Defaults to False.
Returns:
list: A list of system fonts.
"""
try:
import matplotlib.font_manager
font_list = matplotlib.font_manager.findSystemFonts(
fontpaths=None, fontext="ttf"
)
font_list.sort()
font_names = [os.path.basename(f) for f in font_list]
font_names.sort()
if show_full_path:
return font_list
else:
return font_names
except Exception as e:
print(e)
The provided code snippet includes necessary dependencies for implementing the `create_colorbar` function. Write a Python function `def create_colorbar( width=150, height=30, palette=["blue", "green", "red"], add_ticks=True, add_labels=True, labels=None, vertical=False, out_file=None, font_type="arial.ttf", font_size=12, font_color="black", add_outline=True, outline_color="black", )` to solve the following problem:
Creates a colorbar based on the provided palette. Args: width (int, optional): Width of the colorbar in pixels. Defaults to 150. height (int, optional): Height of the colorbar in pixels. Defaults to 30. palette (list, optional): Palette for the colorbar. Each color can be provided as a string (e.g., 'red'), a hex string (e.g., '#ff0000'), or an RGB tuple (255, 0, 255). Defaults to ['blue', 'green', 'red']. add_ticks (bool, optional): Whether to add tick markers to the colorbar. Defaults to True. add_labels (bool, optional): Whether to add labels to the colorbar. Defaults to True. labels (list, optional): A list of labels to add to the colorbar. Defaults to None. vertical (bool, optional): Whether to rotate the colorbar vertically. Defaults to False. out_file (str, optional): File path to the output colorbar in png format. Defaults to None. font_type (str, optional): Font type to use for labels. Defaults to 'arial.ttf'. font_size (int, optional): Font size to use for labels. Defaults to 12. font_color (str, optional): Font color to use for labels. Defaults to 'black'. add_outline (bool, optional): Whether to add an outline to the colorbar. Defaults to True. outline_color (str, optional): Color for the outline of the colorbar. Defaults to 'black'. Returns: str: File path of the output colorbar in png format.
Here is the function:
def create_colorbar(
width=150,
height=30,
palette=["blue", "green", "red"],
add_ticks=True,
add_labels=True,
labels=None,
vertical=False,
out_file=None,
font_type="arial.ttf",
font_size=12,
font_color="black",
add_outline=True,
outline_color="black",
):
"""Creates a colorbar based on the provided palette.
Args:
width (int, optional): Width of the colorbar in pixels. Defaults to 150.
height (int, optional): Height of the colorbar in pixels. Defaults to 30.
palette (list, optional): Palette for the colorbar. Each color can be provided as a string (e.g., 'red'), a hex string (e.g., '#ff0000'), or an RGB tuple (255, 0, 255). Defaults to ['blue', 'green', 'red'].
add_ticks (bool, optional): Whether to add tick markers to the colorbar. Defaults to True.
add_labels (bool, optional): Whether to add labels to the colorbar. Defaults to True.
labels (list, optional): A list of labels to add to the colorbar. Defaults to None.
vertical (bool, optional): Whether to rotate the colorbar vertically. Defaults to False.
out_file (str, optional): File path to the output colorbar in png format. Defaults to None.
font_type (str, optional): Font type to use for labels. Defaults to 'arial.ttf'.
font_size (int, optional): Font size to use for labels. Defaults to 12.
font_color (str, optional): Font color to use for labels. Defaults to 'black'.
add_outline (bool, optional): Whether to add an outline to the colorbar. Defaults to True.
outline_color (str, optional): Color for the outline of the colorbar. Defaults to 'black'.
Returns:
str: File path of the output colorbar in png format.
"""
import decimal
# import io
import pkg_resources
from colour import Color
from PIL import Image, ImageDraw, ImageFont
warnings.simplefilter("ignore")
pkg_dir = os.path.dirname(pkg_resources.resource_filename("geemap", "geemap.py"))
if out_file is None:
filename = "colorbar_" + random_string() + ".png"
out_dir = os.path.join(os.path.expanduser("~"), "Downloads")
out_file = os.path.join(out_dir, filename)
elif not out_file.endswith(".png"):
print("The output file must end with .png")
return
else:
out_file = os.path.abspath(out_file)
if not os.path.exists(os.path.dirname(out_file)):
os.makedirs(os.path.dirname(out_file))
im = Image.new("RGBA", (width, height))
ld = im.load()
def float_range(start, stop, step):
while start < stop:
yield float(start)
start += decimal.Decimal(step)
n_colors = len(palette)
decimal_places = 2
rgb_colors = [Color(check_color(c)).rgb for c in palette]
keys = [
round(c, decimal_places)
for c in list(float_range(0, 1.0001, 1.0 / (n_colors - 1)))
]
heatmap = []
for index, item in enumerate(keys):
pair = [item, rgb_colors[index]]
heatmap.append(pair)
def gaussian(x, a, b, c, d=0):
return a * math.exp(-((x - b) ** 2) / (2 * c**2)) + d
def pixel(x, width=100, map=[], spread=1):
width = float(width)
r = sum(
[
gaussian(x, p[1][0], p[0] * width, width / (spread * len(map)))
for p in map
]
)
g = sum(
[
gaussian(x, p[1][1], p[0] * width, width / (spread * len(map)))
for p in map
]
)
b = sum(
[
gaussian(x, p[1][2], p[0] * width, width / (spread * len(map)))
for p in map
]
)
return min(1.0, r), min(1.0, g), min(1.0, b)
for x in range(im.size[0]):
r, g, b = pixel(x, width=width, map=heatmap)
r, g, b = [int(256 * v) for v in (r, g, b)]
for y in range(im.size[1]):
ld[x, y] = r, g, b
if add_outline:
draw = ImageDraw.Draw(im)
draw.rectangle(
[(0, 0), (width - 1, height - 1)], outline=check_color(outline_color)
)
del draw
if add_ticks:
tick_length = height * 0.1
x = [key * width for key in keys]
y_top = height - tick_length
y_bottom = height
draw = ImageDraw.Draw(im)
for i in x:
shape = [(i, y_top), (i, y_bottom)]
draw.line(shape, fill="black", width=0)
del draw
if vertical:
im = im.transpose(Image.ROTATE_90)
width, height = im.size
if labels is None:
labels = [str(c) for c in keys]
elif len(labels) == 2:
try:
lowerbound = float(labels[0])
upperbound = float(labels[1])
step = (upperbound - lowerbound) / (len(palette) - 1)
labels = [str(lowerbound + c * step) for c in range(0, len(palette))]
except Exception as e:
print(e)
print("The labels are invalid.")
return
elif len(labels) == len(palette):
labels = [str(c) for c in labels]
else:
print("The labels must have the same length as the palette.")
return
if add_labels:
default_font = os.path.join(pkg_dir, "data/fonts/arial.ttf")
if font_type == "arial.ttf":
font = ImageFont.truetype(default_font, font_size)
else:
try:
font_list = system_fonts(show_full_path=True)
font_names = [os.path.basename(f) for f in font_list]
if (font_type in font_list) or (font_type in font_names):
font = ImageFont.truetype(font_type, font_size)
else:
print(
"The specified font type could not be found on your system. Using the default font instead."
)
font = ImageFont.truetype(default_font, font_size)
except Exception as e:
print(e)
font = ImageFont.truetype(default_font, font_size)
font_color = check_color(font_color)
draw = ImageDraw.Draw(im)
w, h = draw.textsize(labels[0], font=font)
for label in labels:
w_tmp, h_tmp = draw.textsize(label, font)
if w_tmp > w:
w = w_tmp
if h_tmp > h:
h = h_tmp
W, H = width + w * 2, height + h * 2
background = Image.new("RGBA", (W, H))
draw = ImageDraw.Draw(background)
if vertical:
xy = (0, h)
else:
xy = (w, 0)
background.paste(im, xy, im)
for index, label in enumerate(labels):
w_tmp, h_tmp = draw.textsize(label, font)
if vertical:
spacing = 5
x = width + spacing
y = int(height + h - keys[index] * height - h_tmp / 2 - 1)
draw.text((x, y), label, font=font, fill=font_color)
else:
x = int(keys[index] * width + w - w_tmp / 2)
spacing = int(h * 0.05)
y = height + spacing
draw.text((x, y), label, font=font, fill=font_color)
im = background.copy()
im.save(out_file)
return out_file | Creates a colorbar based on the provided palette. Args: width (int, optional): Width of the colorbar in pixels. Defaults to 150. height (int, optional): Height of the colorbar in pixels. Defaults to 30. palette (list, optional): Palette for the colorbar. Each color can be provided as a string (e.g., 'red'), a hex string (e.g., '#ff0000'), or an RGB tuple (255, 0, 255). Defaults to ['blue', 'green', 'red']. add_ticks (bool, optional): Whether to add tick markers to the colorbar. Defaults to True. add_labels (bool, optional): Whether to add labels to the colorbar. Defaults to True. labels (list, optional): A list of labels to add to the colorbar. Defaults to None. vertical (bool, optional): Whether to rotate the colorbar vertically. Defaults to False. out_file (str, optional): File path to the output colorbar in png format. Defaults to None. font_type (str, optional): Font type to use for labels. Defaults to 'arial.ttf'. font_size (int, optional): Font size to use for labels. Defaults to 12. font_color (str, optional): Font color to use for labels. Defaults to 'black'. add_outline (bool, optional): Whether to add an outline to the colorbar. Defaults to True. outline_color (str, optional): Color for the outline of the colorbar. Defaults to 'black'. Returns: str: File path of the output colorbar in png format. |
12,273 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `minimum_bounding_box` function. Write a Python function `def minimum_bounding_box(geojson)` to solve the following problem:
Gets the minimum bounding box for a geojson polygon. Args: geojson (dict): A geojson dictionary. Returns: tuple: Returns a tuple containing the minimum bounding box in the format of (lower_left(lat, lon), upper_right(lat, lon)), such as ((13, -130), (32, -120)).
Here is the function:
def minimum_bounding_box(geojson):
"""Gets the minimum bounding box for a geojson polygon.
Args:
geojson (dict): A geojson dictionary.
Returns:
tuple: Returns a tuple containing the minimum bounding box in the format of (lower_left(lat, lon), upper_right(lat, lon)), such as ((13, -130), (32, -120)).
"""
coordinates = []
try:
if "geometry" in geojson.keys():
coordinates = geojson["geometry"]["coordinates"][0]
else:
coordinates = geojson["coordinates"][0]
lower_left = min([x[1] for x in coordinates]), min(
[x[0] for x in coordinates]
) # (lat, lon)
upper_right = max([x[1] for x in coordinates]), max(
[x[0] for x in coordinates]
) # (lat, lon)
bounds = (lower_left, upper_right)
return bounds
except Exception as e:
raise Exception(e) | Gets the minimum bounding box for a geojson polygon. Args: geojson (dict): A geojson dictionary. Returns: tuple: Returns a tuple containing the minimum bounding box in the format of (lower_left(lat, lon), upper_right(lat, lon)), such as ((13, -130), (32, -120)). |
12,274 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `geocode` function. Write a Python function `def geocode(location, max_rows=10, reverse=False)` to solve the following problem:
Search location by address and lat/lon coordinates. Args: location (str): Place name or address max_rows (int, optional): Maximum number of records to return. Defaults to 10. reverse (bool, optional): Search place based on coordinates. Defaults to False. Returns: list: Returns a list of locations.
Here is the function:
def geocode(location, max_rows=10, reverse=False):
"""Search location by address and lat/lon coordinates.
Args:
location (str): Place name or address
max_rows (int, optional): Maximum number of records to return. Defaults to 10.
reverse (bool, optional): Search place based on coordinates. Defaults to False.
Returns:
list: Returns a list of locations.
"""
import geocoder
if not isinstance(location, str):
print("The location must be a string.")
return None
if not reverse:
locations = []
addresses = set()
g = geocoder.arcgis(location, maxRows=max_rows)
for result in g:
address = result.address
if address not in addresses:
addresses.add(address)
locations.append(result)
if len(locations) > 0:
return locations
else:
return None
else:
try:
if "," in location:
latlon = [float(x) for x in location.split(",")]
elif " " in location:
latlon = [float(x) for x in location.split(" ")]
else:
print(
"The lat-lon coordinates should be numbers only and separated by comma or space, such as 40.2, -100.3"
)
return
g = geocoder.arcgis(latlon, method="reverse")
locations = []
addresses = set()
for result in g:
address = result.address
if address not in addresses:
addresses.add(address)
locations.append(result)
if len(locations) > 0:
return locations
else:
return None
except Exception as e:
print(e)
return None | Search location by address and lat/lon coordinates. Args: location (str): Place name or address max_rows (int, optional): Maximum number of records to return. Defaults to 10. reverse (bool, optional): Search place based on coordinates. Defaults to False. Returns: list: Returns a list of locations. |
12,275 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `is_latlon_valid` function. Write a Python function `def is_latlon_valid(location)` to solve the following problem:
Checks whether a pair of coordinates is valid. Args: location (str): A pair of latlon coordinates separated by comma or space. Returns: bool: Returns True if valid.
Here is the function:
def is_latlon_valid(location):
"""Checks whether a pair of coordinates is valid.
Args:
location (str): A pair of latlon coordinates separated by comma or space.
Returns:
bool: Returns True if valid.
"""
latlon = []
if "," in location:
latlon = [float(x) for x in location.split(",")]
elif " " in location:
latlon = [float(x) for x in location.split(" ")]
else:
print(
"The coordinates should be numbers only and separated by comma or space, such as 40.2, -100.3"
)
return False
try:
lat, lon = float(latlon[0]), float(latlon[1])
if lat >= -90 and lat <= 90 and lon >= -180 and lon <= 180:
return True
else:
return False
except Exception as e:
print(e)
return False | Checks whether a pair of coordinates is valid. Args: location (str): A pair of latlon coordinates separated by comma or space. Returns: bool: Returns True if valid. |
12,276 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `latlon_from_text` function. Write a Python function `def latlon_from_text(location)` to solve the following problem:
Extracts latlon from text. Args: location (str): A pair of latlon coordinates separated by comma or space. Returns: bool: Returns (lat, lon) if valid.
Here is the function:
def latlon_from_text(location):
"""Extracts latlon from text.
Args:
location (str): A pair of latlon coordinates separated by comma or space.
Returns:
bool: Returns (lat, lon) if valid.
"""
latlon = []
try:
if "," in location:
latlon = [float(x) for x in location.split(",")]
elif " " in location:
latlon = [float(x) for x in location.split(" ")]
else:
print(
"The lat-lon coordinates should be numbers only and separated by comma or space, such as 40.2, -100.3"
)
return None
lat, lon = latlon[0], latlon[1]
if lat >= -90 and lat <= 90 and lon >= -180 and lon <= 180:
return lat, lon
else:
return None
except Exception as e:
print(e)
print(
"The lat-lon coordinates should be numbers only and separated by comma or space, such as 40.2, -100.3"
)
return None | Extracts latlon from text. Args: location (str): A pair of latlon coordinates separated by comma or space. Returns: bool: Returns (lat, lon) if valid. |
12,277 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `ee_data_thumbnail` function. Write a Python function `def ee_data_thumbnail(asset_id, timeout=300, proxies=None)` to solve the following problem:
Retrieves the thumbnail URL of an Earth Engine asset. Args: asset_id (str): An Earth Engine asset id. timeout (int, optional): Timeout in seconds. Defaults to 300. proxies (dict, optional): Proxy settings. Defaults to None. Returns: str: An http url of the thumbnail.
Here is the function:
def ee_data_thumbnail(asset_id, timeout=300, proxies=None):
"""Retrieves the thumbnail URL of an Earth Engine asset.
Args:
asset_id (str): An Earth Engine asset id.
timeout (int, optional): Timeout in seconds. Defaults to 300.
proxies (dict, optional): Proxy settings. Defaults to None.
Returns:
str: An http url of the thumbnail.
"""
import urllib
from bs4 import BeautifulSoup
asset_uid = asset_id.replace("/", "_")
asset_url = "https://developers.google.com/earth-engine/datasets/catalog/{}".format(
asset_uid
)
thumbnail_url = "https://mw1.google.com/ges/dd/images/{}_sample.png".format(
asset_uid
)
r = requests.get(thumbnail_url, timeout=timeout, proxies=proxies)
try:
if r.status_code != 200:
html_page = urllib.request.urlopen(asset_url)
soup = BeautifulSoup(html_page, features="html.parser")
for img in soup.findAll("img"):
if "sample.png" in img.get("src"):
thumbnail_url = img.get("src")
return thumbnail_url
return thumbnail_url
except Exception as e:
print(e) | Retrieves the thumbnail URL of an Earth Engine asset. Args: asset_id (str): An Earth Engine asset id. timeout (int, optional): Timeout in seconds. Defaults to 300. proxies (dict, optional): Proxy settings. Defaults to None. Returns: str: An http url of the thumbnail. |
12,278 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `ee_api_to_csv` function. Write a Python function `def ee_api_to_csv(outfile=None, timeout=300, proxies=None)` to solve the following problem:
Extracts Earth Engine API documentation from https://developers.google.com/earth-engine/api_docs as a csv file. Args: outfile (str, optional): The output file path to a csv file. Defaults to None. timeout (int, optional): Timeout in seconds. Defaults to 300. proxies (dict, optional): Proxy settings. Defaults to None.
Here is the function:
def ee_api_to_csv(outfile=None, timeout=300, proxies=None):
"""Extracts Earth Engine API documentation from https://developers.google.com/earth-engine/api_docs as a csv file.
Args:
outfile (str, optional): The output file path to a csv file. Defaults to None.
timeout (int, optional): Timeout in seconds. Defaults to 300.
proxies (dict, optional): Proxy settings. Defaults to None.
"""
import pkg_resources
from bs4 import BeautifulSoup
pkg_dir = os.path.dirname(pkg_resources.resource_filename("geemap", "geemap.py"))
data_dir = os.path.join(pkg_dir, "data")
template_dir = os.path.join(data_dir, "template")
csv_file = os.path.join(template_dir, "ee_api_docs.csv")
if outfile is None:
outfile = csv_file
else:
if not outfile.endswith(".csv"):
print("The output file must end with .csv")
return
else:
out_dir = os.path.dirname(outfile)
if not os.path.exists(out_dir):
os.makedirs(out_dir)
url = "https://developers.google.com/earth-engine/api_docs"
try:
r = requests.get(url, timeout=timeout, proxies=proxies)
soup = BeautifulSoup(r.content, "html.parser")
names = []
descriptions = []
functions = []
returns = []
arguments = []
types = []
details = []
names = [h2.text for h2 in soup.find_all("h2")]
descriptions = [h2.next_sibling.next_sibling.text for h2 in soup.find_all("h2")]
func_tables = soup.find_all("table", class_="blue")
functions = [func_table.find("code").text for func_table in func_tables]
returns = [func_table.find_all("td")[1].text for func_table in func_tables]
detail_tables = []
tables = soup.find_all("table", class_="blue")
for table in tables:
item = table.next_sibling
if item.attrs == {"class": ["details"]}:
detail_tables.append(item)
else:
detail_tables.append("")
for detail_table in detail_tables:
if detail_table != "":
items = [item.text for item in detail_table.find_all("code")]
else:
items = ""
arguments.append(items)
for detail_table in detail_tables:
if detail_table != "":
items = [item.text for item in detail_table.find_all("td")]
items = items[1::3]
else:
items = ""
types.append(items)
for detail_table in detail_tables:
if detail_table != "":
items = [item.text for item in detail_table.find_all("p")]
else:
items = ""
details.append(items)
with open(outfile, "w", encoding="utf-8") as csv_file:
csv_writer = csv.writer(csv_file, delimiter="\t")
csv_writer.writerow(
[
"name",
"description",
"function",
"returns",
"argument",
"type",
"details",
]
)
for i in range(len(names)):
name = names[i]
description = descriptions[i]
function = functions[i]
return_type = returns[i]
argument = "|".join(arguments[i])
argu_type = "|".join(types[i])
detail = "|".join(details[i])
csv_writer.writerow(
[
name,
description,
function,
return_type,
argument,
argu_type,
detail,
]
)
except Exception as e:
print(e) | Extracts Earth Engine API documentation from https://developers.google.com/earth-engine/api_docs as a csv file. Args: outfile (str, optional): The output file path to a csv file. Defaults to None. timeout (int, optional): Timeout in seconds. Defaults to 300. proxies (dict, optional): Proxy settings. Defaults to None. |
12,279 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def read_api_csv():
"""Extracts Earth Engine API from a csv file and returns a dictionary containing information about each function.
Returns:
dict: The dictionary containing information about each function, including name, description, function form, return type, arguments, html.
"""
import copy
import pkg_resources
pkg_dir = os.path.dirname(pkg_resources.resource_filename("geemap", "geemap.py"))
data_dir = os.path.join(pkg_dir, "data")
template_dir = os.path.join(data_dir, "template")
csv_file = os.path.join(template_dir, "ee_api_docs.csv")
html_file = os.path.join(template_dir, "ee_api_docs.html")
with open(html_file) as f:
in_html_lines = f.readlines()
api_dict = {}
with open(csv_file, "r", encoding="utf-8") as f:
csv_reader = csv.DictReader(f, delimiter="\t")
for line in csv_reader:
out_html_lines = copy.copy(in_html_lines)
out_html_lines[65] = in_html_lines[65].replace(
"function_name", line["name"]
)
out_html_lines[66] = in_html_lines[66].replace(
"function_description", line.get("description")
)
out_html_lines[74] = in_html_lines[74].replace(
"function_usage", line.get("function")
)
out_html_lines[75] = in_html_lines[75].replace(
"function_returns", line.get("returns")
)
arguments = line.get("argument")
types = line.get("type")
details = line.get("details")
if "|" in arguments:
argument_items = arguments.split("|")
else:
argument_items = [arguments]
if "|" in types:
types_items = types.split("|")
else:
types_items = [types]
if "|" in details:
details_items = details.split("|")
else:
details_items = [details]
out_argument_lines = []
for index in range(len(argument_items)):
in_argument_lines = in_html_lines[87:92]
in_argument_lines[1] = in_argument_lines[1].replace(
"function_argument", argument_items[index]
)
in_argument_lines[2] = in_argument_lines[2].replace(
"function_type", types_items[index]
)
in_argument_lines[3] = in_argument_lines[3].replace(
"function_details", details_items[index]
)
out_argument_lines.append("".join(in_argument_lines))
out_html_lines = (
out_html_lines[:87] + out_argument_lines + out_html_lines[92:]
)
contents = "".join(out_html_lines)
api_dict[line["name"]] = {
"description": line.get("description"),
"function": line.get("function"),
"returns": line.get("returns"),
"argument": line.get("argument"),
"type": line.get("type"),
"details": line.get("details"),
"html": contents,
}
return api_dict
def build_api_tree(api_dict, output_widget, layout_width="100%"):
"""Builds an Earth Engine API tree view.
Args:
api_dict (dict): The dictionary containing information about each Earth Engine API function.
output_widget (object): An Output widget.
layout_width (str, optional): The percentage width of the widget. Defaults to '100%'.
Returns:
tuple: Returns a tuple containing two items: a tree Output widget and a tree dictionary.
"""
warnings.filterwarnings("ignore")
tree = Tree()
tree_dict = {}
names = api_dict.keys()
def handle_click(event):
if event["new"]:
name = event["owner"].name
values = api_dict[name]
with output_widget:
output_widget.outputs = ()
html_widget = widgets.HTML(value=values["html"])
display(html_widget)
for name in names:
func_list = ee_function_tree(name)
first = func_list[0]
if first not in tree_dict.keys():
tree_dict[first] = Node(first)
tree_dict[first].opened = False
tree.add_node(tree_dict[first])
for index, func in enumerate(func_list):
if index > 0:
if func not in tree_dict.keys():
node = tree_dict[func_list[index - 1]]
node.opened = False
tree_dict[func] = Node(func)
node.add_node(tree_dict[func])
if index == len(func_list) - 1:
node = tree_dict[func_list[index]]
node.icon = "file"
node.observe(handle_click, "selected")
return tree, tree_dict
def search_api_tree(keywords, api_tree):
"""Search Earth Engine API and return functions containing the specified keywords
Args:
keywords (str): The keywords to search for.
api_tree (dict): The dictionary containing the Earth Engine API tree.
Returns:
object: An ipytree object/widget.
"""
warnings.filterwarnings("ignore")
sub_tree = Tree()
for key in api_tree.keys():
if keywords.lower() in key.lower():
sub_tree.add_node(api_tree[key])
return sub_tree
def build_asset_tree(limit=100):
import geeadd.ee_report as geeadd
warnings.filterwarnings("ignore")
# ee_initialize()
tree = Tree(multiple_selection=False)
tree_dict = {}
asset_types = {}
asset_icons = {
"FOLDER": "folder",
"TABLE": "table",
"IMAGE": "image",
"IMAGE_COLLECTION": "file",
}
info_widget = widgets.HBox()
import_btn = widgets.Button(
description="import",
button_style="primary",
tooltip="Click to import the selected asset",
disabled=True,
)
import_btn.layout.min_width = "57px"
import_btn.layout.max_width = "57px"
path_widget = widgets.Text()
path_widget.layout.min_width = "500px"
# path_widget.disabled = True
info_widget.children = [import_btn, path_widget]
user_id = ee_user_id()
if user_id is None:
print(
"Your GEE account does not have any assets. Please create a repository at https://code.earthengine.google.com"
)
return
user_path = "projects/earthengine-legacy/assets/" + user_id
root_node = Node(user_id)
root_node.opened = True
tree_dict[user_id] = root_node
tree.add_node(root_node)
collection_list, table_list, image_list, folder_paths = geeadd.fparse(user_path)
collection_list = collection_list[:limit]
table_list = table_list[:limit]
image_list = image_list[:limit]
folder_paths = folder_paths[:limit]
folders = [p[35:] for p in folder_paths[1:]]
asset_type = "FOLDER"
for folder in folders:
bare_folder = folder.replace(user_id + "/", "")
if folder not in tree_dict.keys():
node = Node(bare_folder)
node.opened = False
node.icon = asset_icons[asset_type]
root_node.add_node(node)
tree_dict[folder] = node
asset_types[folder] = asset_type
def import_btn_clicked(b):
if path_widget.value != "":
dataset_uid = "dataset_" + random_string(string_length=3)
layer_name = path_widget.value.split("/")[-1][:-2:]
line1 = "{} = {}\n".format(dataset_uid, path_widget.value)
line2 = "Map.addLayer(" + dataset_uid + ', {}, "' + layer_name + '")'
contents = "".join([line1, line2])
create_code_cell(contents)
import_btn.on_click(import_btn_clicked)
def handle_click(event):
if event["new"]:
cur_node = event["owner"]
for key in tree_dict.keys():
if cur_node is tree_dict[key]:
if asset_types[key] == "IMAGE":
path_widget.value = "ee.Image('{}')".format(key)
elif asset_types[key] == "IMAGE_COLLECTION":
path_widget.value = "ee.ImageCollection('{}')".format(key)
elif asset_types[key] == "TABLE":
path_widget.value = "ee.FeatureCollection('{}')".format(key)
if import_btn.disabled:
import_btn.disabled = False
break
assets = [collection_list, image_list, table_list]
for index, asset_list in enumerate(assets):
if index == 0:
asset_type = "IMAGE_COLLECTION"
elif index == 1:
asset_type = "IMAGE"
else:
asset_type = "TABLE"
for asset in asset_list:
items = asset.split("/")
parent = "/".join(items[:-1])
child = items[-1]
parent_node = tree_dict[parent]
child_node = Node(child)
child_node.icon = asset_icons[asset_type]
parent_node.add_node(child_node)
tree_dict[asset] = child_node
asset_types[asset] = asset_type
child_node.observe(handle_click, "selected")
return tree, info_widget, tree_dict
def build_repo_tree(out_dir=None, name="gee_repos"):
"""Builds a repo tree for GEE account.
Args:
out_dir (str): The output directory for the repos. Defaults to None.
name (str, optional): The output name for the repo directory. Defaults to 'gee_repos'.
Returns:
tuple: Returns a tuple containing a tree widget, an output widget, and a tree dictionary containing nodes.
"""
warnings.filterwarnings("ignore")
if out_dir is None:
out_dir = os.path.join(os.path.expanduser("~"))
repo_dir = os.path.join(out_dir, name)
if not os.path.exists(repo_dir):
os.makedirs(repo_dir)
URLs = {
# 'Owner': 'https://earthengine.googlesource.com/{ee_user_id()}/default',
"Writer": "",
"Reader": "https://github.com/gee-community/geemap",
"Examples": "https://github.com/giswqs/earthengine-py-examples",
"Archive": "https://earthengine.googlesource.com/EGU2017-EE101",
}
user_id = ee_user_id()
if user_id is not None:
URLs["Owner"] = f"https://earthengine.googlesource.com/{ee_user_id()}/default"
path_widget = widgets.Text(placeholder="Enter the link to a Git repository here...")
path_widget.layout.width = "475px"
clone_widget = widgets.Button(
description="Clone",
button_style="primary",
tooltip="Clone the repository to folder.",
)
info_widget = widgets.HBox()
groups = ["Owner", "Writer", "Reader", "Examples", "Archive"]
for group in groups:
group_dir = os.path.join(repo_dir, group)
if not os.path.exists(group_dir):
os.makedirs(group_dir)
example_dir = os.path.join(repo_dir, "Examples/earthengine-py-examples")
if not os.path.exists(example_dir):
clone_github_repo(URLs["Examples"], out_dir=example_dir)
left_widget, right_widget, tree_dict = file_browser(
in_dir=repo_dir,
add_root_node=False,
search_description="Filter scripts...",
use_import=True,
return_sep_widgets=True,
)
info_widget.children = [right_widget]
def handle_folder_click(event):
if event["new"]:
url = ""
selected = event["owner"]
if selected.name in URLs.keys():
url = URLs[selected.name]
path_widget.value = url
clone_widget.disabled = False
info_widget.children = [path_widget, clone_widget]
else:
info_widget.children = [right_widget]
for group in groups:
dirname = os.path.join(repo_dir, group)
node = tree_dict[dirname]
node.observe(handle_folder_click, "selected")
def handle_clone_click(b):
url = path_widget.value
default_dir = os.path.join(repo_dir, "Examples")
if url == "":
path_widget.value = "Please enter a valid URL to the repository."
else:
for group in groups:
key = os.path.join(repo_dir, group)
node = tree_dict[key]
if node.selected:
default_dir = key
try:
path_widget.value = "Cloning..."
clone_dir = os.path.join(default_dir, os.path.basename(url))
if url.find("github.com") != -1:
clone_github_repo(url, out_dir=clone_dir)
elif url.find("googlesource") != -1:
clone_google_repo(url, out_dir=clone_dir)
path_widget.value = "Cloned to {}".format(clone_dir)
clone_widget.disabled = True
except Exception as e:
path_widget.value = (
"An error occurred when trying to clone the repository " + str(e)
)
clone_widget.disabled = True
clone_widget.on_click(handle_clone_click)
return left_widget, info_widget, tree_dict
The provided code snippet includes necessary dependencies for implementing the `ee_search` function. Write a Python function `def ee_search(asset_limit=100)` to solve the following problem:
Search Earth Engine API and user assets. If you received a warning (IOPub message rate exceeded) in Jupyter notebook, you can relaunch Jupyter notebook using the following command: jupyter notebook --NotebookApp.iopub_msg_rate_limit=10000 Args: asset_limit (int, optional): The number of assets to display for each asset type, i.e., Image, ImageCollection, and FeatureCollection. Defaults to 100.
Here is the function:
def ee_search(asset_limit=100):
"""Search Earth Engine API and user assets. If you received a warning (IOPub message rate exceeded) in Jupyter notebook, you can relaunch Jupyter notebook using the following command:
jupyter notebook --NotebookApp.iopub_msg_rate_limit=10000
Args:
asset_limit (int, optional): The number of assets to display for each asset type, i.e., Image, ImageCollection, and FeatureCollection. Defaults to 100.
"""
warnings.filterwarnings("ignore")
class Flags:
def __init__(
self,
repos=None,
docs=None,
assets=None,
docs_dict=None,
asset_dict=None,
asset_import=None,
):
self.repos = repos
self.docs = docs
self.assets = assets
self.docs_dict = docs_dict
self.asset_dict = asset_dict
self.asset_import = asset_import
flags = Flags()
search_type = widgets.ToggleButtons(
options=["Scripts", "Docs", "Assets"],
tooltips=[
"Search Earth Engine Scripts",
"Search Earth Engine API",
"Search Earth Engine Assets",
],
button_style="primary",
)
search_type.style.button_width = "100px"
search_box = widgets.Text(placeholder="Filter scripts...", value="Loading...")
search_box.layout.width = "310px"
tree_widget = widgets.Output()
left_widget = widgets.VBox()
right_widget = widgets.VBox()
output_widget = widgets.Output()
output_widget.layout.max_width = "650px"
search_widget = widgets.HBox()
search_widget.children = [left_widget, right_widget]
display(search_widget)
repo_tree, repo_output, _ = build_repo_tree()
left_widget.children = [search_type, repo_tree]
right_widget.children = [repo_output]
flags.repos = repo_tree
search_box.value = ""
def search_type_changed(change):
search_box.value = ""
output_widget.outputs = ()
tree_widget.outputs = ()
if change["new"] == "Scripts":
search_box.placeholder = "Filter scripts..."
left_widget.children = [search_type, repo_tree]
right_widget.children = [repo_output]
elif change["new"] == "Docs":
search_box.placeholder = "Filter methods..."
search_box.value = "Loading..."
left_widget.children = [search_type, search_box, tree_widget]
right_widget.children = [output_widget]
if flags.docs is None:
api_dict = read_api_csv()
ee_api_tree, tree_dict = build_api_tree(api_dict, output_widget)
flags.docs = ee_api_tree
flags.docs_dict = tree_dict
else:
ee_api_tree = flags.docs
with tree_widget:
tree_widget.outputs = ()
display(ee_api_tree)
right_widget.children = [output_widget]
search_box.value = ""
elif change["new"] == "Assets":
search_box.placeholder = "Filter assets..."
left_widget.children = [search_type, search_box, tree_widget]
right_widget.children = [output_widget]
search_box.value = "Loading..."
if flags.assets is None:
asset_tree, asset_widget, asset_dict = build_asset_tree(
limit=asset_limit
)
flags.assets = asset_tree
flags.asset_dict = asset_dict
flags.asset_import = asset_widget
with tree_widget:
tree_widget.outputs = ()
display(flags.assets)
right_widget.children = [flags.asset_import]
search_box.value = ""
search_type.observe(search_type_changed, names="value")
def search_box_callback(text):
if search_type.value == "Docs":
with tree_widget:
if text.value == "":
print("Loading...")
tree_widget.outputs = ()
display(flags.docs)
else:
tree_widget.outputs = ()
print("Searching...")
tree_widget.outputs = ()
sub_tree = search_api_tree(text.value, flags.docs_dict)
display(sub_tree)
elif search_type.value == "Assets":
with tree_widget:
if text.value == "":
print("Loading...")
tree_widget.outputs = ()
display(flags.assets)
else:
tree_widget.outputs = ()
print("Searching...")
tree_widget.outputs = ()
sub_tree = search_api_tree(text.value, flags.asset_dict)
display(sub_tree)
search_box.on_submit(search_box_callback) | Search Earth Engine API and user assets. If you received a warning (IOPub message rate exceeded) in Jupyter notebook, you can relaunch Jupyter notebook using the following command: jupyter notebook --NotebookApp.iopub_msg_rate_limit=10000 Args: asset_limit (int, optional): The number of assets to display for each asset type, i.e., Image, ImageCollection, and FeatureCollection. Defaults to 100. |
12,280 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `legend_from_ee` function. Write a Python function `def legend_from_ee(ee_class_table)` to solve the following problem:
Extract legend from an Earth Engine class table on the Earth Engine Data Catalog page such as https://developers.google.com/earth-engine/datasets/catalog/MODIS_051_MCD12Q1 Args: ee_class_table (str): An Earth Engine class table with triple quotes. Returns: dict: Returns a legend dictionary that can be used to create a legend.
Here is the function:
def legend_from_ee(ee_class_table):
"""Extract legend from an Earth Engine class table on the Earth Engine Data Catalog page
such as https://developers.google.com/earth-engine/datasets/catalog/MODIS_051_MCD12Q1
Args:
ee_class_table (str): An Earth Engine class table with triple quotes.
Returns:
dict: Returns a legend dictionary that can be used to create a legend.
"""
try:
ee_class_table = ee_class_table.strip()
lines = ee_class_table.split("\n")[1:]
if lines[0] == "Value\tColor\tDescription":
lines = lines[1:]
legend_dict = {}
for _, line in enumerate(lines):
items = line.split("\t")
items = [item.strip() for item in items]
color = items[1]
key = items[0] + " " + items[2]
legend_dict[key] = color
return legend_dict
except Exception as e:
print(e) | Extract legend from an Earth Engine class table on the Earth Engine Data Catalog page such as https://developers.google.com/earth-engine/datasets/catalog/MODIS_051_MCD12Q1 Args: ee_class_table (str): An Earth Engine class table with triple quotes. Returns: dict: Returns a legend dictionary that can be used to create a legend. |
12,281 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `vis_to_qml` function. Write a Python function `def vis_to_qml(ee_class_table, out_qml)` to solve the following problem:
Create a QGIS Layer Style (.qml) based on an Earth Engine class table from the Earth Engine Data Catalog page such as https://developers.google.com/earth-engine/datasets/catalog/MODIS_051_MCD12Q1 Args: ee_class_table (str): An Earth Engine class table with triple quotes. out_qml (str): File path to the output QGIS Layer Style (.qml).
Here is the function:
def vis_to_qml(ee_class_table, out_qml):
"""Create a QGIS Layer Style (.qml) based on an Earth Engine class table from the Earth Engine Data Catalog page
such as https://developers.google.com/earth-engine/datasets/catalog/MODIS_051_MCD12Q1
Args:
ee_class_table (str): An Earth Engine class table with triple quotes.
out_qml (str): File path to the output QGIS Layer Style (.qml).
"""
import pkg_resources
pkg_dir = os.path.dirname(pkg_resources.resource_filename("geemap", "geemap.py"))
data_dir = os.path.join(pkg_dir, "data")
template_dir = os.path.join(data_dir, "template")
qml_template = os.path.join(template_dir, "NLCD.qml")
out_dir = os.path.dirname(out_qml)
if not os.path.exists(out_dir):
os.makedirs(out_dir)
with open(qml_template) as f:
lines = f.readlines()
header = lines[:31]
footer = lines[51:]
entries = []
try:
ee_class_table = ee_class_table.strip()
lines = ee_class_table.split("\n")[1:]
if lines[0] == "Value\tColor\tDescription":
lines = lines[1:]
for line in lines:
items = line.split("\t")
items = [item.strip() for item in items]
value = items[0]
color = items[1]
label = items[2]
entry = ' <paletteEntry alpha="255" color="#{}" value="{}" label="{}"/>\n'.format(
color, value, label
)
entries.append(entry)
out_lines = header + entries + footer
with open(out_qml, "w") as f:
f.writelines(out_lines)
except Exception as e:
print(e) | Create a QGIS Layer Style (.qml) based on an Earth Engine class table from the Earth Engine Data Catalog page such as https://developers.google.com/earth-engine/datasets/catalog/MODIS_051_MCD12Q1 Args: ee_class_table (str): An Earth Engine class table with triple quotes. out_qml (str): File path to the output QGIS Layer Style (.qml). |
12,282 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `create_nlcd_qml` function. Write a Python function `def create_nlcd_qml(out_qml)` to solve the following problem:
Create a QGIS Layer Style (.qml) for NLCD data Args: out_qml (str): File path to the output qml.
Here is the function:
def create_nlcd_qml(out_qml):
"""Create a QGIS Layer Style (.qml) for NLCD data
Args:
out_qml (str): File path to the output qml.
"""
import pkg_resources
pkg_dir = os.path.dirname(pkg_resources.resource_filename("geemap", "geemap.py"))
data_dir = os.path.join(pkg_dir, "data")
template_dir = os.path.join(data_dir, "template")
qml_template = os.path.join(template_dir, "NLCD.qml")
out_dir = os.path.dirname(out_qml)
if not os.path.exists(out_dir):
os.makedirs(out_dir)
shutil.copyfile(qml_template, out_qml) | Create a QGIS Layer Style (.qml) for NLCD data Args: out_qml (str): File path to the output qml. |
12,283 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def get_direct_url(url):
"""Get the direct URL for a given URL.
Args:
url (str): The URL to get the direct URL for.
Returns:
str: The direct URL.
"""
if not isinstance(url, str):
raise ValueError("url must be a string.")
if not url.startswith("http"):
raise ValueError("url must start with http.")
r = requests.head(url, allow_redirects=True)
return r.url
The provided code snippet includes necessary dependencies for implementing the `load_GeoTIFF` function. Write a Python function `def load_GeoTIFF(URL)` to solve the following problem:
Loads a Cloud Optimized GeoTIFF (COG) as an Image. Only Google Cloud Storage is supported. The URL can be one of the following formats: Option 1: gs://pdd-stac/disasters/hurricane-harvey/0831/20170831_172754_101c_3B_AnalyticMS.tif Option 2: https://storage.googleapis.com/pdd-stac/disasters/hurricane-harvey/0831/20170831_172754_101c_3B_AnalyticMS.tif Option 3: https://storage.cloud.google.com/gcp-public-data-landsat/LC08/01/044/034/LC08_L1TP_044034_20131228_20170307_01_T1/LC08_L1TP_044034_20131228_20170307_01_T1_B5.TIF Args: URL (str): The Cloud Storage URL of the GeoTIFF to load. Returns: ee.Image: an Earth Engine image.
Here is the function:
def load_GeoTIFF(URL):
"""Loads a Cloud Optimized GeoTIFF (COG) as an Image. Only Google Cloud Storage is supported. The URL can be one of the following formats:
Option 1: gs://pdd-stac/disasters/hurricane-harvey/0831/20170831_172754_101c_3B_AnalyticMS.tif
Option 2: https://storage.googleapis.com/pdd-stac/disasters/hurricane-harvey/0831/20170831_172754_101c_3B_AnalyticMS.tif
Option 3: https://storage.cloud.google.com/gcp-public-data-landsat/LC08/01/044/034/LC08_L1TP_044034_20131228_20170307_01_T1/LC08_L1TP_044034_20131228_20170307_01_T1_B5.TIF
Args:
URL (str): The Cloud Storage URL of the GeoTIFF to load.
Returns:
ee.Image: an Earth Engine image.
"""
uri = URL.strip()
if uri.startswith("http"):
uri = get_direct_url(uri)
if uri.startswith("https://storage.googleapis.com/"):
uri = uri.replace("https://storage.googleapis.com/", "gs://")
elif uri.startswith("https://storage.cloud.google.com/"):
uri = uri.replace("https://storage.cloud.google.com/", "gs://")
if not uri.startswith("gs://"):
raise Exception(
f'Invalid GCS URL: {uri}. Expected something of the form "gs://bucket/path/to/object.tif".'
)
if not uri.lower().endswith(".tif"):
raise Exception(
f'Invalid GCS URL: {uri}. Expected something of the form "gs://bucket/path/to/object.tif".'
)
cloud_image = ee.Image.loadGeoTIFF(uri)
return cloud_image | Loads a Cloud Optimized GeoTIFF (COG) as an Image. Only Google Cloud Storage is supported. The URL can be one of the following formats: Option 1: gs://pdd-stac/disasters/hurricane-harvey/0831/20170831_172754_101c_3B_AnalyticMS.tif Option 2: https://storage.googleapis.com/pdd-stac/disasters/hurricane-harvey/0831/20170831_172754_101c_3B_AnalyticMS.tif Option 3: https://storage.cloud.google.com/gcp-public-data-landsat/LC08/01/044/034/LC08_L1TP_044034_20131228_20170307_01_T1/LC08_L1TP_044034_20131228_20170307_01_T1_B5.TIF Args: URL (str): The Cloud Storage URL of the GeoTIFF to load. Returns: ee.Image: an Earth Engine image. |
12,284 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def get_direct_url(url):
"""Get the direct URL for a given URL.
Args:
url (str): The URL to get the direct URL for.
Returns:
str: The direct URL.
"""
if not isinstance(url, str):
raise ValueError("url must be a string.")
if not url.startswith("http"):
raise ValueError("url must start with http.")
r = requests.head(url, allow_redirects=True)
return r.url
The provided code snippet includes necessary dependencies for implementing the `load_GeoTIFFs` function. Write a Python function `def load_GeoTIFFs(URLs)` to solve the following problem:
Loads a list of Cloud Optimized GeoTIFFs (COG) as an ImageCollection. URLs is a list of URL, which can be one of the following formats: Option 1: gs://pdd-stac/disasters/hurricane-harvey/0831/20170831_172754_101c_3B_AnalyticMS.tif Option 2: https://storage.googleapis.com/pdd-stac/disasters/hurricane-harvey/0831/20170831_172754_101c_3B_AnalyticMS.tif Option 3: https://storage.cloud.google.com/gcp-public-data-landsat/LC08/01/044/034/LC08_L1TP_044034_20131228_20170307_01_T1/LC08_L1TP_044034_20131228_20170307_01_T1_B5.TIF Args: URLs (list): A list of Cloud Storage URL of the GeoTIFF to load. Returns: ee.ImageCollection: An Earth Engine ImageCollection.
Here is the function:
def load_GeoTIFFs(URLs):
"""Loads a list of Cloud Optimized GeoTIFFs (COG) as an ImageCollection. URLs is a list of URL, which can be one of the following formats:
Option 1: gs://pdd-stac/disasters/hurricane-harvey/0831/20170831_172754_101c_3B_AnalyticMS.tif
Option 2: https://storage.googleapis.com/pdd-stac/disasters/hurricane-harvey/0831/20170831_172754_101c_3B_AnalyticMS.tif
Option 3: https://storage.cloud.google.com/gcp-public-data-landsat/LC08/01/044/034/LC08_L1TP_044034_20131228_20170307_01_T1/LC08_L1TP_044034_20131228_20170307_01_T1_B5.TIF
Args:
URLs (list): A list of Cloud Storage URL of the GeoTIFF to load.
Returns:
ee.ImageCollection: An Earth Engine ImageCollection.
"""
if not isinstance(URLs, list):
raise Exception("The URLs argument must be a list.")
URIs = []
for URL in URLs:
uri = URL.strip()
if uri.startswith("http"):
uri = get_direct_url(uri)
if uri.startswith("https://storage.googleapis.com/"):
uri = uri.replace("https://storage.googleapis.com/", "gs://")
elif uri.startswith("https://storage.cloud.google.com/"):
uri = uri.replace("https://storage.cloud.google.com/", "gs://")
if not uri.startswith("gs://"):
raise Exception(
f'Invalid GCS URL: {uri}. Expected something of the form "gs://bucket/path/to/object.tif".'
)
if not uri.lower().endswith(".tif"):
raise Exception(
f'Invalid GCS URL: {uri}. Expected something of the form "gs://bucket/path/to/object.tif".'
)
URIs.append(uri)
URIs = ee.List(URIs)
collection = URIs.map(lambda uri: ee.Image.loadGeoTIFF(uri))
return ee.ImageCollection(collection) | Loads a list of Cloud Optimized GeoTIFFs (COG) as an ImageCollection. URLs is a list of URL, which can be one of the following formats: Option 1: gs://pdd-stac/disasters/hurricane-harvey/0831/20170831_172754_101c_3B_AnalyticMS.tif Option 2: https://storage.googleapis.com/pdd-stac/disasters/hurricane-harvey/0831/20170831_172754_101c_3B_AnalyticMS.tif Option 3: https://storage.cloud.google.com/gcp-public-data-landsat/LC08/01/044/034/LC08_L1TP_044034_20131228_20170307_01_T1/LC08_L1TP_044034_20131228_20170307_01_T1_B5.TIF Args: URLs (list): A list of Cloud Storage URL of the GeoTIFF to load. Returns: ee.ImageCollection: An Earth Engine ImageCollection. |
12,285 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def check_titiler_endpoint(titiler_endpoint=None):
"""Returns the default titiler endpoint.
Returns:
object: A titiler endpoint.
"""
if titiler_endpoint is None:
if os.environ.get("TITILER_ENDPOINT") is not None:
titiler_endpoint = os.environ.get("TITILER_ENDPOINT")
if titiler_endpoint == "planetary-computer":
titiler_endpoint = PlanetaryComputerEndpoint()
else:
titiler_endpoint = "https://titiler.xyz"
elif titiler_endpoint in ["planetary-computer", "pc"]:
titiler_endpoint = PlanetaryComputerEndpoint()
return titiler_endpoint
def cog_bands(url, titiler_endpoint=None, timeout=300):
"""Get band names of a Cloud Optimized GeoTIFF (COG).
Args:
url (str): HTTP URL to a COG, e.g., https://opendata.digitalglobe.com/events/mauritius-oil-spill/post-event/2020-08-12/105001001F1B5B00/105001001F1B5B00.tif
titiler_endpoint (str, optional): Titiler endpoint. Defaults to "https://titiler.xyz".
timeout (int, optional): Timeout in seconds. Defaults to 300.
Returns:
list: A list of band names
"""
titiler_endpoint = check_titiler_endpoint(titiler_endpoint)
url = get_direct_url(url)
r = requests.get(
f"{titiler_endpoint}/cog/info",
params={
"url": url,
},
timeout=timeout,
).json()
bands = [b[0] for b in r["band_descriptions"]]
return bands
def cog_stats(url, titiler_endpoint=None, timeout=300):
"""Get band statistics of a Cloud Optimized GeoTIFF (COG).
Args:
url (str): HTTP URL to a COG, e.g., https://opendata.digitalglobe.com/events/mauritius-oil-spill/post-event/2020-08-12/105001001F1B5B00/105001001F1B5B00.tif
titiler_endpoint (str, optional): Titiler endpoint. Defaults to "https://titiler.xyz".
timeout (int, optional): Timeout in seconds. Defaults to 300.
Returns:
list: A dictionary of band statistics.
"""
titiler_endpoint = check_titiler_endpoint(titiler_endpoint)
url = get_direct_url(url)
r = requests.get(
f"{titiler_endpoint}/cog/statistics",
params={
"url": url,
},
timeout=timeout,
).json()
return r
def get_direct_url(url):
"""Get the direct URL for a given URL.
Args:
url (str): The URL to get the direct URL for.
Returns:
str: The direct URL.
"""
if not isinstance(url, str):
raise ValueError("url must be a string.")
if not url.startswith("http"):
raise ValueError("url must start with http.")
r = requests.head(url, allow_redirects=True)
return r.url
The provided code snippet includes necessary dependencies for implementing the `cog_tile` function. Write a Python function `def cog_tile( url, bands=None, titiler_endpoint=None, timeout=300, proxies=None, **kwargs, )` to solve the following problem:
Get a tile layer from a Cloud Optimized GeoTIFF (COG). Source code adapted from https://developmentseed.org/titiler/examples/notebooks/Working_with_CloudOptimizedGeoTIFF_simple/ Args: url (str): HTTP URL to a COG, e.g., https://opendata.digitalglobe.com/events/mauritius-oil-spill/post-event/2020-08-12/105001001F1B5B00/105001001F1B5B00.tif titiler_endpoint (str, optional): Titiler endpoint. Defaults to "https://titiler.xyz". timeout (int, optional): Timeout in seconds. Defaults to 300. proxies (dict, optional): Proxies to use. Defaults to None. Returns: tuple: Returns the COG Tile layer URL and bounds.
Here is the function:
def cog_tile(
url,
bands=None,
titiler_endpoint=None,
timeout=300,
proxies=None,
**kwargs,
):
"""Get a tile layer from a Cloud Optimized GeoTIFF (COG).
Source code adapted from https://developmentseed.org/titiler/examples/notebooks/Working_with_CloudOptimizedGeoTIFF_simple/
Args:
url (str): HTTP URL to a COG, e.g., https://opendata.digitalglobe.com/events/mauritius-oil-spill/post-event/2020-08-12/105001001F1B5B00/105001001F1B5B00.tif
titiler_endpoint (str, optional): Titiler endpoint. Defaults to "https://titiler.xyz".
timeout (int, optional): Timeout in seconds. Defaults to 300.
proxies (dict, optional): Proxies to use. Defaults to None.
Returns:
tuple: Returns the COG Tile layer URL and bounds.
"""
titiler_endpoint = check_titiler_endpoint(titiler_endpoint)
url = get_direct_url(url)
kwargs["url"] = url
band_names = cog_bands(url, titiler_endpoint)
if bands is None and "bidx" not in kwargs:
if len(band_names) >= 3:
kwargs["bidx"] = [1, 2, 3]
elif bands is not None and "bidx" not in kwargs:
if all(isinstance(x, int) for x in bands):
kwargs["bidx"] = bands
elif all(isinstance(x, str) for x in bands):
kwargs["bidx"] = [band_names.index(x) + 1 for x in bands]
else:
raise ValueError("Bands must be a list of integers or strings.")
if "palette" in kwargs:
kwargs["colormap_name"] = kwargs.pop("palette")
if "colormap" in kwargs:
kwargs["colormap_name"] = kwargs.pop("colormap")
if "rescale" not in kwargs:
stats = cog_stats(url, titiler_endpoint)
percentile_2 = min([stats[s]["percentile_2"] for s in stats])
percentile_98 = max([stats[s]["percentile_98"] for s in stats])
kwargs["rescale"] = f"{percentile_2},{percentile_98}"
TileMatrixSetId = "WebMercatorQuad"
if "TileMatrixSetId" in kwargs.keys():
TileMatrixSetId = kwargs["TileMatrixSetId"]
kwargs.pop("TileMatrixSetId")
r = requests.get(
f"{titiler_endpoint}/cog/{TileMatrixSetId}/tilejson.json",
params=kwargs,
timeout=timeout,
proxies=proxies,
).json()
return r["tiles"][0] | Get a tile layer from a Cloud Optimized GeoTIFF (COG). Source code adapted from https://developmentseed.org/titiler/examples/notebooks/Working_with_CloudOptimizedGeoTIFF_simple/ Args: url (str): HTTP URL to a COG, e.g., https://opendata.digitalglobe.com/events/mauritius-oil-spill/post-event/2020-08-12/105001001F1B5B00/105001001F1B5B00.tif titiler_endpoint (str, optional): Titiler endpoint. Defaults to "https://titiler.xyz". timeout (int, optional): Timeout in seconds. Defaults to 300. proxies (dict, optional): Proxies to use. Defaults to None. Returns: tuple: Returns the COG Tile layer URL and bounds. |
12,286 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def check_titiler_endpoint(titiler_endpoint=None):
"""Returns the default titiler endpoint.
Returns:
object: A titiler endpoint.
"""
if titiler_endpoint is None:
if os.environ.get("TITILER_ENDPOINT") is not None:
titiler_endpoint = os.environ.get("TITILER_ENDPOINT")
if titiler_endpoint == "planetary-computer":
titiler_endpoint = PlanetaryComputerEndpoint()
else:
titiler_endpoint = "https://titiler.xyz"
elif titiler_endpoint in ["planetary-computer", "pc"]:
titiler_endpoint = PlanetaryComputerEndpoint()
return titiler_endpoint
def cog_mosaic(
links,
titiler_endpoint=None,
username="anonymous",
layername=None,
overwrite=False,
verbose=True,
timeout=300,
**kwargs,
):
"""Creates a COG mosaic from a list of COG URLs.
Args:
links (list): A list containing COG HTTP URLs.
titiler_endpoint (str, optional): Titiler endpoint. Defaults to "https://titiler.xyz".
username (str, optional): User name for the titiler endpoint. Defaults to "anonymous".
layername ([type], optional): Layer name to use. Defaults to None.
overwrite (bool, optional): Whether to overwrite the layer name if existing. Defaults to False.
verbose (bool, optional): Whether to print out descriptive information. Defaults to True.
timeout (int, optional): Timeout in seconds. Defaults to 300.
Raises:
Exception: If the COG mosaic fails to create.
Returns:
str: The tile URL for the COG mosaic.
"""
titiler_endpoint = check_titiler_endpoint(titiler_endpoint)
if layername is None:
layername = "layer_" + random_string(5)
try:
if verbose:
print("Creating COG masaic ...")
# Create token
r = requests.post(
f"{titiler_endpoint}/tokens/create",
json={"username": username, "scope": ["mosaic:read", "mosaic:create"]},
).json()
token = r["token"]
# Create mosaic
requests.post(
f"{titiler_endpoint}/mosaicjson/create",
json={
"username": username,
"layername": layername,
"files": links,
# "overwrite": overwrite
},
params={
"access_token": token,
},
).json()
r2 = requests.get(
f"{titiler_endpoint}/mosaicjson/{username}.{layername}/tilejson.json",
timeout=timeout,
).json()
return r2["tiles"][0]
except Exception as e:
raise Exception(e)
def mosaic(images, output, merge_args={}, verbose=True, **kwargs):
"""Mosaics a list of images into a single image. Inspired by https://bit.ly/3A6roDK.
Args:
images (str | list): An input directory containing images or a list of images.
output (str): The output image filepath.
merge_args (dict, optional): A dictionary of arguments to pass to the rasterio.merge function. Defaults to {}.
verbose (bool, optional): Whether to print progress. Defaults to True.
"""
from rasterio.merge import merge
import rasterio as rio
from pathlib import Path
output = os.path.abspath(output)
if isinstance(images, str):
path = Path(images)
raster_files = list(path.iterdir())
elif isinstance(images, list):
raster_files = images
else:
raise ValueError("images must be a list of raster files.")
raster_to_mosiac = []
if not os.path.exists(os.path.dirname(output)):
os.makedirs(os.path.dirname(output))
for index, p in enumerate(raster_files):
if verbose:
print(f"Reading {index+1}/{len(raster_files)}: {os.path.basename(p)}")
raster = rio.open(p, **kwargs)
raster_to_mosiac.append(raster)
if verbose:
print("Merging rasters...")
arr, transform = merge(raster_to_mosiac, **merge_args)
output_meta = raster.meta.copy()
output_meta.update(
{
"driver": "GTiff",
"height": arr.shape[1],
"width": arr.shape[2],
"transform": transform,
}
)
with rio.open(output, "w", **output_meta) as m:
m.write(arr)
The provided code snippet includes necessary dependencies for implementing the `cog_mosaic_from_file` function. Write a Python function `def cog_mosaic_from_file( filepath, skip_rows=0, titiler_endpoint=None, username="anonymous", layername=None, overwrite=False, verbose=True, **kwargs, )` to solve the following problem:
Creates a COG mosaic from a csv/txt file stored locally for through HTTP URL. Args: filepath (str): Local path or HTTP URL to the csv/txt file containing COG URLs. skip_rows (int, optional): The number of rows to skip in the file. Defaults to 0. titiler_endpoint (str, optional): Titiler endpoint. Defaults to "https://titiler.xyz". username (str, optional): User name for the titiler endpoint. Defaults to "anonymous". layername ([type], optional): Layer name to use. Defaults to None. overwrite (bool, optional): Whether to overwrite the layer name if existing. Defaults to False. verbose (bool, optional): Whether to print out descriptive information. Defaults to True. Returns: str: The tile URL for the COG mosaic.
Here is the function:
def cog_mosaic_from_file(
filepath,
skip_rows=0,
titiler_endpoint=None,
username="anonymous",
layername=None,
overwrite=False,
verbose=True,
**kwargs,
):
"""Creates a COG mosaic from a csv/txt file stored locally for through HTTP URL.
Args:
filepath (str): Local path or HTTP URL to the csv/txt file containing COG URLs.
skip_rows (int, optional): The number of rows to skip in the file. Defaults to 0.
titiler_endpoint (str, optional): Titiler endpoint. Defaults to "https://titiler.xyz".
username (str, optional): User name for the titiler endpoint. Defaults to "anonymous".
layername ([type], optional): Layer name to use. Defaults to None.
overwrite (bool, optional): Whether to overwrite the layer name if existing. Defaults to False.
verbose (bool, optional): Whether to print out descriptive information. Defaults to True.
Returns:
str: The tile URL for the COG mosaic.
"""
import urllib
titiler_endpoint = check_titiler_endpoint(titiler_endpoint)
links = []
if filepath.startswith("http"):
data = urllib.request.urlopen(filepath)
for line in data:
links.append(line.decode("utf-8").strip())
else:
with open(filepath) as f:
links = [line.strip() for line in f.readlines()]
links = links[skip_rows:]
# print(links)
mosaic = cog_mosaic(
links, titiler_endpoint, username, layername, overwrite, verbose, **kwargs
)
return mosaic | Creates a COG mosaic from a csv/txt file stored locally for through HTTP URL. Args: filepath (str): Local path or HTTP URL to the csv/txt file containing COG URLs. skip_rows (int, optional): The number of rows to skip in the file. Defaults to 0. titiler_endpoint (str, optional): Titiler endpoint. Defaults to "https://titiler.xyz". username (str, optional): User name for the titiler endpoint. Defaults to "anonymous". layername ([type], optional): Layer name to use. Defaults to None. overwrite (bool, optional): Whether to overwrite the layer name if existing. Defaults to False. verbose (bool, optional): Whether to print out descriptive information. Defaults to True. Returns: str: The tile URL for the COG mosaic. |
12,287 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def check_titiler_endpoint(titiler_endpoint=None):
"""Returns the default titiler endpoint.
Returns:
object: A titiler endpoint.
"""
if titiler_endpoint is None:
if os.environ.get("TITILER_ENDPOINT") is not None:
titiler_endpoint = os.environ.get("TITILER_ENDPOINT")
if titiler_endpoint == "planetary-computer":
titiler_endpoint = PlanetaryComputerEndpoint()
else:
titiler_endpoint = "https://titiler.xyz"
elif titiler_endpoint in ["planetary-computer", "pc"]:
titiler_endpoint = PlanetaryComputerEndpoint()
return titiler_endpoint
def cog_bounds(url, titiler_endpoint=None, timeout=300):
"""Get the bounding box of a Cloud Optimized GeoTIFF (COG).
Args:
url (str): HTTP URL to a COG, e.g., https://opendata.digitalglobe.com/events/mauritius-oil-spill/post-event/2020-08-12/105001001F1B5B00/105001001F1B5B00.tif
titiler_endpoint (str, optional): Titiler endpoint. Defaults to "https://titiler.xyz".
timeout (int, optional): Timeout in seconds. Defaults to 300.
Returns:
list: A list of values representing [left, bottom, right, top]
"""
titiler_endpoint = check_titiler_endpoint(titiler_endpoint)
url = get_direct_url(url)
r = requests.get(
f"{titiler_endpoint}/cog/bounds", params={"url": url}, timeout=timeout
).json()
if "bounds" in r.keys():
bounds = r["bounds"]
else:
bounds = None
return bounds
def get_direct_url(url):
"""Get the direct URL for a given URL.
Args:
url (str): The URL to get the direct URL for.
Returns:
str: The direct URL.
"""
if not isinstance(url, str):
raise ValueError("url must be a string.")
if not url.startswith("http"):
raise ValueError("url must start with http.")
r = requests.head(url, allow_redirects=True)
return r.url
The provided code snippet includes necessary dependencies for implementing the `cog_center` function. Write a Python function `def cog_center(url, titiler_endpoint=None)` to solve the following problem:
Get the centroid of a Cloud Optimized GeoTIFF (COG). Args: url (str): HTTP URL to a COG, e.g., https://opendata.digitalglobe.com/events/mauritius-oil-spill/post-event/2020-08-12/105001001F1B5B00/105001001F1B5B00.tif titiler_endpoint (str, optional): Titiler endpoint. Defaults to "https://titiler.xyz". Returns: tuple: A tuple representing (longitude, latitude)
Here is the function:
def cog_center(url, titiler_endpoint=None):
"""Get the centroid of a Cloud Optimized GeoTIFF (COG).
Args:
url (str): HTTP URL to a COG, e.g., https://opendata.digitalglobe.com/events/mauritius-oil-spill/post-event/2020-08-12/105001001F1B5B00/105001001F1B5B00.tif
titiler_endpoint (str, optional): Titiler endpoint. Defaults to "https://titiler.xyz".
Returns:
tuple: A tuple representing (longitude, latitude)
"""
titiler_endpoint = check_titiler_endpoint(titiler_endpoint)
url = get_direct_url(url)
bounds = cog_bounds(url, titiler_endpoint)
center = ((bounds[0] + bounds[2]) / 2, (bounds[1] + bounds[3]) / 2) # (lat, lon)
return center | Get the centroid of a Cloud Optimized GeoTIFF (COG). Args: url (str): HTTP URL to a COG, e.g., https://opendata.digitalglobe.com/events/mauritius-oil-spill/post-event/2020-08-12/105001001F1B5B00/105001001F1B5B00.tif titiler_endpoint (str, optional): Titiler endpoint. Defaults to "https://titiler.xyz". Returns: tuple: A tuple representing (longitude, latitude) |
12,288 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
class PlanetaryComputerEndpoint(TitilerEndpoint):
"""This class contains the methods for the Microsoft Planetary Computer endpoint."""
def __init__(
self,
endpoint="https://planetarycomputer.microsoft.com/api/data/v1",
name="item",
TileMatrixSetId="WebMercatorQuad",
):
"""Initialize the PlanetaryComputerEndpoint object.
Args:
endpoint (str, optional): The endpoint of the titiler server. Defaults to "https://planetarycomputer.microsoft.com/api/data/v1".
name (str, optional): The name to be used in the file path. Defaults to "item".
TileMatrixSetId (str, optional): The TileMatrixSetId to be used in the file path. Defaults to "WebMercatorQuad".
"""
super().__init__(endpoint, name, TileMatrixSetId)
def url_for_stac_collection(self):
return f"{self.endpoint}/collection/{self.TileMatrixSetId}/tilejson.json"
def url_for_collection_assets(self):
return f"{self.endpoint}/collection/assets"
def url_for_collection_bounds(self):
return f"{self.endpoint}/collection/bounds"
def url_for_collection_info(self):
return f"{self.endpoint}/collection/info"
def url_for_collection_info_geojson(self):
return f"{self.endpoint}/collection/info.geojson"
def url_for_collection_pixel_value(self, lon, lat):
return f"{self.endpoint}/collection/point/{lon},{lat}"
def url_for_collection_wmts(self):
return f"{self.endpoint}/collection/{self.TileMatrixSetId}/WMTSCapabilities.xml"
def url_for_collection_lat_lon_assets(self, lng, lat):
return f"{self.endpoint}/collection/{lng},{lat}/assets"
def url_for_collection_bbox_assets(self, minx, miny, maxx, maxy):
return f"{self.endpoint}/collection/{minx},{miny},{maxx},{maxy}/assets"
def url_for_stac_mosaic(self, searchid):
return f"{self.endpoint}/mosaic/{searchid}/{self.TileMatrixSetId}/tilejson.json"
def url_for_mosaic_info(self, searchid):
return f"{self.endpoint}/mosaic/{searchid}/info"
def url_for_mosaic_lat_lon_assets(self, searchid, lon, lat):
return f"{self.endpoint}/mosaic/{searchid}/{lon},{lat}/assets"
def check_titiler_endpoint(titiler_endpoint=None):
"""Returns the default titiler endpoint.
Returns:
object: A titiler endpoint.
"""
if titiler_endpoint is None:
if os.environ.get("TITILER_ENDPOINT") is not None:
titiler_endpoint = os.environ.get("TITILER_ENDPOINT")
if titiler_endpoint == "planetary-computer":
titiler_endpoint = PlanetaryComputerEndpoint()
else:
titiler_endpoint = "https://titiler.xyz"
elif titiler_endpoint in ["planetary-computer", "pc"]:
titiler_endpoint = PlanetaryComputerEndpoint()
return titiler_endpoint
def stac_stats(
url=None,
collection=None,
item=None,
assets=None,
titiler_endpoint=None,
timeout=300,
**kwargs,
):
"""Get band statistics of a STAC item.
Args:
url (str): HTTP URL to a STAC item, e.g., https://canada-spot-ortho.s3.amazonaws.com/canada_spot_orthoimages/canada_spot5_orthoimages/S5_2007/S5_11055_6057_20070622/S5_11055_6057_20070622.json
collection (str): The Microsoft Planetary Computer STAC collection ID, e.g., landsat-8-c2-l2.
item (str): The Microsoft Planetary Computer STAC item ID, e.g., LC08_L2SP_047027_20201204_02_T1.
assets (str | list): The Microsoft Planetary Computer STAC asset ID, e.g., ["SR_B7", "SR_B5", "SR_B4"].
titiler_endpoint (str, optional): Titiler endpoint, e.g., "https://titiler.xyz", "planetary-computer", "pc". Defaults to None.
timeout (int, optional): Timeout in seconds. Defaults to 300.
Returns:
list: A dictionary of band statistics.
"""
if url is None and collection is None:
raise ValueError("Either url or collection must be specified.")
if collection is not None and titiler_endpoint is None:
titiler_endpoint = "planetary-computer"
if url is not None:
url = get_direct_url(url)
kwargs["url"] = url
if collection is not None:
kwargs["collection"] = collection
if item is not None:
kwargs["item"] = item
if assets is not None:
kwargs["assets"] = assets
titiler_endpoint = check_titiler_endpoint(titiler_endpoint)
if isinstance(titiler_endpoint, str):
r = requests.get(
f"{titiler_endpoint}/stac/statistics", params=kwargs, timeout=timeout
).json()
else:
r = requests.get(
titiler_endpoint.url_for_stac_statistics(), params=kwargs, timeout=timeout
).json()
return r
def get_direct_url(url):
"""Get the direct URL for a given URL.
Args:
url (str): The URL to get the direct URL for.
Returns:
str: The direct URL.
"""
if not isinstance(url, str):
raise ValueError("url must be a string.")
if not url.startswith("http"):
raise ValueError("url must start with http.")
r = requests.head(url, allow_redirects=True)
return r.url
The provided code snippet includes necessary dependencies for implementing the `stac_tile` function. Write a Python function `def stac_tile( url=None, collection=None, item=None, assets=None, bands=None, titiler_endpoint=None, timeout=300, **kwargs, )` to solve the following problem:
Get a tile layer from a single SpatialTemporal Asset Catalog (STAC) item. Args: url (str): HTTP URL to a STAC item, e.g., https://canada-spot-ortho.s3.amazonaws.com/canada_spot_orthoimages/canada_spot5_orthoimages/S5_2007/S5_11055_6057_20070622/S5_11055_6057_20070622.json collection (str): The Microsoft Planetary Computer STAC collection ID, e.g., landsat-8-c2-l2. item (str): The Microsoft Planetary Computer STAC item ID, e.g., LC08_L2SP_047027_20201204_02_T1. assets (str | list): The Microsoft Planetary Computer STAC asset ID, e.g., ["SR_B7", "SR_B5", "SR_B4"]. bands (list): A list of band names, e.g., ["SR_B7", "SR_B5", "SR_B4"] titiler_endpoint (str, optional): Titiler endpoint, e.g., "https://titiler.xyz", "https://planetarycomputer.microsoft.com/api/data/v1", "planetary-computer", "pc". Defaults to None. timeout (int, optional): Timeout in seconds. Defaults to 300. Returns: str: Returns the STAC Tile layer URL.
Here is the function:
def stac_tile(
url=None,
collection=None,
item=None,
assets=None,
bands=None,
titiler_endpoint=None,
timeout=300,
**kwargs,
):
"""Get a tile layer from a single SpatialTemporal Asset Catalog (STAC) item.
Args:
url (str): HTTP URL to a STAC item, e.g., https://canada-spot-ortho.s3.amazonaws.com/canada_spot_orthoimages/canada_spot5_orthoimages/S5_2007/S5_11055_6057_20070622/S5_11055_6057_20070622.json
collection (str): The Microsoft Planetary Computer STAC collection ID, e.g., landsat-8-c2-l2.
item (str): The Microsoft Planetary Computer STAC item ID, e.g., LC08_L2SP_047027_20201204_02_T1.
assets (str | list): The Microsoft Planetary Computer STAC asset ID, e.g., ["SR_B7", "SR_B5", "SR_B4"].
bands (list): A list of band names, e.g., ["SR_B7", "SR_B5", "SR_B4"]
titiler_endpoint (str, optional): Titiler endpoint, e.g., "https://titiler.xyz", "https://planetarycomputer.microsoft.com/api/data/v1", "planetary-computer", "pc". Defaults to None.
timeout (int, optional): Timeout in seconds. Defaults to 300.
Returns:
str: Returns the STAC Tile layer URL.
"""
if url is None and collection is None:
raise ValueError("Either url or collection must be specified.")
if collection is not None and titiler_endpoint is None:
titiler_endpoint = "planetary-computer"
if url is not None:
url = get_direct_url(url)
kwargs["url"] = url
if collection is not None:
kwargs["collection"] = collection
if item is not None:
kwargs["item"] = item
if "palette" in kwargs:
kwargs["colormap_name"] = kwargs["palette"]
del kwargs["palette"]
if isinstance(bands, list) and len(set(bands)) == 1:
bands = bands[0]
if isinstance(assets, list) and len(set(assets)) == 1:
assets = assets[0]
titiler_endpoint = check_titiler_endpoint(titiler_endpoint)
if "expression" in kwargs and ("asset_as_band" not in kwargs):
kwargs["asset_as_band"] = True
if isinstance(titiler_endpoint, PlanetaryComputerEndpoint):
if isinstance(bands, str):
bands = bands.split(",")
if isinstance(assets, str):
assets = assets.split(",")
if assets is None and (bands is not None):
assets = bands
else:
kwargs["bidx"] = bands
kwargs["assets"] = assets
# if ("expression" in kwargs) and ("rescale" not in kwargs):
# stats = stac_stats(
# collection=collection,
# item=item,
# expression=kwargs["expression"],
# titiler_endpoint=titiler_endpoint,
# )
# kwargs[
# "rescale"
# ] = f"{stats[0]['percentile_2']},{stats[0]['percentile_98']}"
# if ("asset_expression" in kwargs) and ("rescale" not in kwargs):
# stats = stac_stats(
# collection=collection,
# item=item,
# expression=kwargs["asset_expression"],
# titiler_endpoint=titiler_endpoint,
# )
# kwargs[
# "rescale"
# ] = f"{stats[0]['percentile_2']},{stats[0]['percentile_98']}"
if (
(assets is not None)
and ("asset_expression" not in kwargs)
and ("expression" not in kwargs)
and ("rescale" not in kwargs)
):
stats = stac_stats(
collection=collection,
item=item,
assets=assets,
titiler_endpoint=titiler_endpoint,
)
if "detail" not in stats:
try:
percentile_2 = min([stats[s]["percentile_2"] for s in stats])
percentile_98 = max([stats[s]["percentile_98"] for s in stats])
except:
percentile_2 = min(
[
stats[s][list(stats[s].keys())[0]]["percentile_2"]
for s in stats
]
)
percentile_98 = max(
[
stats[s][list(stats[s].keys())[0]]["percentile_98"]
for s in stats
]
)
kwargs["rescale"] = f"{percentile_2},{percentile_98}"
else:
print(stats["detail"]) # When operation times out.
else:
if isinstance(bands, str):
bands = bands.split(",")
if isinstance(assets, str):
assets = assets.split(",")
if assets is None and (bands is not None):
assets = bands
else:
kwargs["asset_bidx"] = bands
kwargs["assets"] = assets
TileMatrixSetId = "WebMercatorQuad"
if "TileMatrixSetId" in kwargs.keys():
TileMatrixSetId = kwargs["TileMatrixSetId"]
kwargs.pop("TileMatrixSetId")
if isinstance(titiler_endpoint, str):
r = requests.get(
f"{titiler_endpoint}/stac/{TileMatrixSetId}/tilejson.json",
params=kwargs,
timeout=timeout,
).json()
else:
r = requests.get(
titiler_endpoint.url_for_stac_item(), params=kwargs, timeout=timeout
).json()
return r["tiles"][0] | Get a tile layer from a single SpatialTemporal Asset Catalog (STAC) item. Args: url (str): HTTP URL to a STAC item, e.g., https://canada-spot-ortho.s3.amazonaws.com/canada_spot_orthoimages/canada_spot5_orthoimages/S5_2007/S5_11055_6057_20070622/S5_11055_6057_20070622.json collection (str): The Microsoft Planetary Computer STAC collection ID, e.g., landsat-8-c2-l2. item (str): The Microsoft Planetary Computer STAC item ID, e.g., LC08_L2SP_047027_20201204_02_T1. assets (str | list): The Microsoft Planetary Computer STAC asset ID, e.g., ["SR_B7", "SR_B5", "SR_B4"]. bands (list): A list of band names, e.g., ["SR_B7", "SR_B5", "SR_B4"] titiler_endpoint (str, optional): Titiler endpoint, e.g., "https://titiler.xyz", "https://planetarycomputer.microsoft.com/api/data/v1", "planetary-computer", "pc". Defaults to None. timeout (int, optional): Timeout in seconds. Defaults to 300. Returns: str: Returns the STAC Tile layer URL. |
12,289 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def stac_bounds(
url=None, collection=None, item=None, titiler_endpoint=None, timeout=300, **kwargs
):
"""Get the bounding box of a single SpatialTemporal Asset Catalog (STAC) item.
Args:
url (str): HTTP URL to a STAC item, e.g., https://canada-spot-ortho.s3.amazonaws.com/canada_spot_orthoimages/canada_spot5_orthoimages/S5_2007/S5_11055_6057_20070622/S5_11055_6057_20070622.json
collection (str): The Microsoft Planetary Computer STAC collection ID, e.g., landsat-8-c2-l2.
item (str): The Microsoft Planetary Computer STAC item ID, e.g., LC08_L2SP_047027_20201204_02_T1.
titiler_endpoint (str, optional): Titiler endpoint, e.g., "https://titiler.xyz", "planetary-computer", "pc". Defaults to None.
timeout (int, optional): Timeout in seconds. Defaults to 300.
Returns:
list: A list of values representing [left, bottom, right, top]
"""
if url is None and collection is None:
raise ValueError("Either url or collection must be specified.")
if collection is not None and titiler_endpoint is None:
titiler_endpoint = "planetary-computer"
if url is not None:
url = get_direct_url(url)
kwargs["url"] = url
if collection is not None:
kwargs["collection"] = collection
if item is not None:
kwargs["item"] = item
titiler_endpoint = check_titiler_endpoint(titiler_endpoint)
if isinstance(titiler_endpoint, str):
r = requests.get(
f"{titiler_endpoint}/stac/bounds", params=kwargs, timeout=timeout
).json()
else:
r = requests.get(
titiler_endpoint.url_for_stac_bounds(), params=kwargs, timeout=timeout
).json()
bounds = r["bounds"]
return bounds
def get_direct_url(url):
"""Get the direct URL for a given URL.
Args:
url (str): The URL to get the direct URL for.
Returns:
str: The direct URL.
"""
if not isinstance(url, str):
raise ValueError("url must be a string.")
if not url.startswith("http"):
raise ValueError("url must start with http.")
r = requests.head(url, allow_redirects=True)
return r.url
The provided code snippet includes necessary dependencies for implementing the `stac_center` function. Write a Python function `def stac_center(url=None, collection=None, item=None, titiler_endpoint=None, **kwargs)` to solve the following problem:
Get the centroid of a single SpatialTemporal Asset Catalog (STAC) item. Args: url (str): HTTP URL to a STAC item, e.g., https://canada-spot-ortho.s3.amazonaws.com/canada_spot_orthoimages/canada_spot5_orthoimages/S5_2007/S5_11055_6057_20070622/S5_11055_6057_20070622.json collection (str): The Microsoft Planetary Computer STAC collection ID, e.g., landsat-8-c2-l2. item (str): The Microsoft Planetary Computer STAC item ID, e.g., LC08_L2SP_047027_20201204_02_T1. titiler_endpoint (str, optional): Titiler endpoint, e.g., "https://titiler.xyz", "planetary-computer", "pc". Defaults to None. Returns: tuple: A tuple representing (longitude, latitude)
Here is the function:
def stac_center(url=None, collection=None, item=None, titiler_endpoint=None, **kwargs):
"""Get the centroid of a single SpatialTemporal Asset Catalog (STAC) item.
Args:
url (str): HTTP URL to a STAC item, e.g., https://canada-spot-ortho.s3.amazonaws.com/canada_spot_orthoimages/canada_spot5_orthoimages/S5_2007/S5_11055_6057_20070622/S5_11055_6057_20070622.json
collection (str): The Microsoft Planetary Computer STAC collection ID, e.g., landsat-8-c2-l2.
item (str): The Microsoft Planetary Computer STAC item ID, e.g., LC08_L2SP_047027_20201204_02_T1.
titiler_endpoint (str, optional): Titiler endpoint, e.g., "https://titiler.xyz", "planetary-computer", "pc". Defaults to None.
Returns:
tuple: A tuple representing (longitude, latitude)
"""
if url is None and collection is None:
raise ValueError("Either url or collection must be specified.")
if isinstance(url, str):
url = get_direct_url(url)
bounds = stac_bounds(url, collection, item, titiler_endpoint, **kwargs)
center = ((bounds[0] + bounds[2]) / 2, (bounds[1] + bounds[3]) / 2) # (lon, lat)
return center | Get the centroid of a single SpatialTemporal Asset Catalog (STAC) item. Args: url (str): HTTP URL to a STAC item, e.g., https://canada-spot-ortho.s3.amazonaws.com/canada_spot_orthoimages/canada_spot5_orthoimages/S5_2007/S5_11055_6057_20070622/S5_11055_6057_20070622.json collection (str): The Microsoft Planetary Computer STAC collection ID, e.g., landsat-8-c2-l2. item (str): The Microsoft Planetary Computer STAC item ID, e.g., LC08_L2SP_047027_20201204_02_T1. titiler_endpoint (str, optional): Titiler endpoint, e.g., "https://titiler.xyz", "planetary-computer", "pc". Defaults to None. Returns: tuple: A tuple representing (longitude, latitude) |
12,290 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def check_titiler_endpoint(titiler_endpoint=None):
"""Returns the default titiler endpoint.
Returns:
object: A titiler endpoint.
"""
if titiler_endpoint is None:
if os.environ.get("TITILER_ENDPOINT") is not None:
titiler_endpoint = os.environ.get("TITILER_ENDPOINT")
if titiler_endpoint == "planetary-computer":
titiler_endpoint = PlanetaryComputerEndpoint()
else:
titiler_endpoint = "https://titiler.xyz"
elif titiler_endpoint in ["planetary-computer", "pc"]:
titiler_endpoint = PlanetaryComputerEndpoint()
return titiler_endpoint
def get_direct_url(url):
"""Get the direct URL for a given URL.
Args:
url (str): The URL to get the direct URL for.
Returns:
str: The direct URL.
"""
if not isinstance(url, str):
raise ValueError("url must be a string.")
if not url.startswith("http"):
raise ValueError("url must start with http.")
r = requests.head(url, allow_redirects=True)
return r.url
The provided code snippet includes necessary dependencies for implementing the `stac_bands` function. Write a Python function `def stac_bands( url=None, collection=None, item=None, titiler_endpoint=None, timeout=300, **kwargs )` to solve the following problem:
Get band names of a single SpatialTemporal Asset Catalog (STAC) item. Args: url (str): HTTP URL to a STAC item, e.g., https://canada-spot-ortho.s3.amazonaws.com/canada_spot_orthoimages/canada_spot5_orthoimages/S5_2007/S5_11055_6057_20070622/S5_11055_6057_20070622.json collection (str): The Microsoft Planetary Computer STAC collection ID, e.g., landsat-8-c2-l2. item (str): The Microsoft Planetary Computer STAC item ID, e.g., LC08_L2SP_047027_20201204_02_T1. titiler_endpoint (str, optional): Titiler endpoint, e.g., "https://titiler.xyz", "planetary-computer", "pc". Defaults to None. timeout (int, optional): Timeout in seconds. Defaults to 300. Returns: list: A list of band names
Here is the function:
def stac_bands(
url=None, collection=None, item=None, titiler_endpoint=None, timeout=300, **kwargs
):
"""Get band names of a single SpatialTemporal Asset Catalog (STAC) item.
Args:
url (str): HTTP URL to a STAC item, e.g., https://canada-spot-ortho.s3.amazonaws.com/canada_spot_orthoimages/canada_spot5_orthoimages/S5_2007/S5_11055_6057_20070622/S5_11055_6057_20070622.json
collection (str): The Microsoft Planetary Computer STAC collection ID, e.g., landsat-8-c2-l2.
item (str): The Microsoft Planetary Computer STAC item ID, e.g., LC08_L2SP_047027_20201204_02_T1.
titiler_endpoint (str, optional): Titiler endpoint, e.g., "https://titiler.xyz", "planetary-computer", "pc". Defaults to None.
timeout (int, optional): Timeout in seconds. Defaults to 300.
Returns:
list: A list of band names
"""
if url is None and collection is None:
raise ValueError("Either url or collection must be specified.")
if collection is not None and titiler_endpoint is None:
titiler_endpoint = "planetary-computer"
if url is not None:
url = get_direct_url(url)
kwargs["url"] = url
if collection is not None:
kwargs["collection"] = collection
if item is not None:
kwargs["item"] = item
titiler_endpoint = check_titiler_endpoint(titiler_endpoint)
if isinstance(titiler_endpoint, str):
r = requests.get(
f"{titiler_endpoint}/stac/assets", params=kwargs, timeout=timeout
).json()
else:
r = requests.get(
titiler_endpoint.url_for_stac_assets(), params=kwargs, timeout=timeout
).json()
return r | Get band names of a single SpatialTemporal Asset Catalog (STAC) item. Args: url (str): HTTP URL to a STAC item, e.g., https://canada-spot-ortho.s3.amazonaws.com/canada_spot_orthoimages/canada_spot5_orthoimages/S5_2007/S5_11055_6057_20070622/S5_11055_6057_20070622.json collection (str): The Microsoft Planetary Computer STAC collection ID, e.g., landsat-8-c2-l2. item (str): The Microsoft Planetary Computer STAC item ID, e.g., LC08_L2SP_047027_20201204_02_T1. titiler_endpoint (str, optional): Titiler endpoint, e.g., "https://titiler.xyz", "planetary-computer", "pc". Defaults to None. timeout (int, optional): Timeout in seconds. Defaults to 300. Returns: list: A list of band names |
12,291 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def check_titiler_endpoint(titiler_endpoint=None):
"""Returns the default titiler endpoint.
Returns:
object: A titiler endpoint.
"""
if titiler_endpoint is None:
if os.environ.get("TITILER_ENDPOINT") is not None:
titiler_endpoint = os.environ.get("TITILER_ENDPOINT")
if titiler_endpoint == "planetary-computer":
titiler_endpoint = PlanetaryComputerEndpoint()
else:
titiler_endpoint = "https://titiler.xyz"
elif titiler_endpoint in ["planetary-computer", "pc"]:
titiler_endpoint = PlanetaryComputerEndpoint()
return titiler_endpoint
def get_direct_url(url):
"""Get the direct URL for a given URL.
Args:
url (str): The URL to get the direct URL for.
Returns:
str: The direct URL.
"""
if not isinstance(url, str):
raise ValueError("url must be a string.")
if not url.startswith("http"):
raise ValueError("url must start with http.")
r = requests.head(url, allow_redirects=True)
return r.url
The provided code snippet includes necessary dependencies for implementing the `stac_info` function. Write a Python function `def stac_info( url=None, collection=None, item=None, assets=None, titiler_endpoint=None, timeout=300, **kwargs, )` to solve the following problem:
Get band info of a STAC item. Args: url (str): HTTP URL to a STAC item, e.g., https://canada-spot-ortho.s3.amazonaws.com/canada_spot_orthoimages/canada_spot5_orthoimages/S5_2007/S5_11055_6057_20070622/S5_11055_6057_20070622.json collection (str): The Microsoft Planetary Computer STAC collection ID, e.g., landsat-8-c2-l2. item (str): The Microsoft Planetary Computer STAC item ID, e.g., LC08_L2SP_047027_20201204_02_T1. assets (str | list): The Microsoft Planetary Computer STAC asset ID, e.g., ["SR_B7", "SR_B5", "SR_B4"]. titiler_endpoint (str, optional): Titiler endpoint, e.g., "https://titiler.xyz", "planetary-computer", "pc". Defaults to None. timeout (int, optional): Timeout in seconds. Defaults to 300. Returns: list: A dictionary of band info.
Here is the function:
def stac_info(
url=None,
collection=None,
item=None,
assets=None,
titiler_endpoint=None,
timeout=300,
**kwargs,
):
"""Get band info of a STAC item.
Args:
url (str): HTTP URL to a STAC item, e.g., https://canada-spot-ortho.s3.amazonaws.com/canada_spot_orthoimages/canada_spot5_orthoimages/S5_2007/S5_11055_6057_20070622/S5_11055_6057_20070622.json
collection (str): The Microsoft Planetary Computer STAC collection ID, e.g., landsat-8-c2-l2.
item (str): The Microsoft Planetary Computer STAC item ID, e.g., LC08_L2SP_047027_20201204_02_T1.
assets (str | list): The Microsoft Planetary Computer STAC asset ID, e.g., ["SR_B7", "SR_B5", "SR_B4"].
titiler_endpoint (str, optional): Titiler endpoint, e.g., "https://titiler.xyz", "planetary-computer", "pc". Defaults to None.
timeout (int, optional): Timeout in seconds. Defaults to 300.
Returns:
list: A dictionary of band info.
"""
if url is None and collection is None:
raise ValueError("Either url or collection must be specified.")
if collection is not None and titiler_endpoint is None:
titiler_endpoint = "planetary-computer"
if url is not None:
url = get_direct_url(url)
kwargs["url"] = url
if collection is not None:
kwargs["collection"] = collection
if item is not None:
kwargs["item"] = item
if assets is not None:
kwargs["assets"] = assets
titiler_endpoint = check_titiler_endpoint(titiler_endpoint)
if isinstance(titiler_endpoint, str):
r = requests.get(
f"{titiler_endpoint}/stac/info", params=kwargs, timeout=timeout
).json()
else:
r = requests.get(
titiler_endpoint.url_for_stac_info(), params=kwargs, timeout=timeout
).json()
return r | Get band info of a STAC item. Args: url (str): HTTP URL to a STAC item, e.g., https://canada-spot-ortho.s3.amazonaws.com/canada_spot_orthoimages/canada_spot5_orthoimages/S5_2007/S5_11055_6057_20070622/S5_11055_6057_20070622.json collection (str): The Microsoft Planetary Computer STAC collection ID, e.g., landsat-8-c2-l2. item (str): The Microsoft Planetary Computer STAC item ID, e.g., LC08_L2SP_047027_20201204_02_T1. assets (str | list): The Microsoft Planetary Computer STAC asset ID, e.g., ["SR_B7", "SR_B5", "SR_B4"]. titiler_endpoint (str, optional): Titiler endpoint, e.g., "https://titiler.xyz", "planetary-computer", "pc". Defaults to None. timeout (int, optional): Timeout in seconds. Defaults to 300. Returns: list: A dictionary of band info. |
12,292 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def check_titiler_endpoint(titiler_endpoint=None):
"""Returns the default titiler endpoint.
Returns:
object: A titiler endpoint.
"""
if titiler_endpoint is None:
if os.environ.get("TITILER_ENDPOINT") is not None:
titiler_endpoint = os.environ.get("TITILER_ENDPOINT")
if titiler_endpoint == "planetary-computer":
titiler_endpoint = PlanetaryComputerEndpoint()
else:
titiler_endpoint = "https://titiler.xyz"
elif titiler_endpoint in ["planetary-computer", "pc"]:
titiler_endpoint = PlanetaryComputerEndpoint()
return titiler_endpoint
def get_direct_url(url):
"""Get the direct URL for a given URL.
Args:
url (str): The URL to get the direct URL for.
Returns:
str: The direct URL.
"""
if not isinstance(url, str):
raise ValueError("url must be a string.")
if not url.startswith("http"):
raise ValueError("url must start with http.")
r = requests.head(url, allow_redirects=True)
return r.url
The provided code snippet includes necessary dependencies for implementing the `stac_info_geojson` function. Write a Python function `def stac_info_geojson( url=None, collection=None, item=None, assets=None, titiler_endpoint=None, timeout=300, **kwargs, )` to solve the following problem:
Get band info of a STAC item. Args: url (str): HTTP URL to a STAC item, e.g., https://canada-spot-ortho.s3.amazonaws.com/canada_spot_orthoimages/canada_spot5_orthoimages/S5_2007/S5_11055_6057_20070622/S5_11055_6057_20070622.json collection (str): The Microsoft Planetary Computer STAC collection ID, e.g., landsat-8-c2-l2. item (str): The Microsoft Planetary Computer STAC item ID, e.g., LC08_L2SP_047027_20201204_02_T1. assets (str | list): The Microsoft Planetary Computer STAC asset ID, e.g., ["SR_B7", "SR_B5", "SR_B4"]. titiler_endpoint (str, optional): Titiler endpoint, e.g., "https://titiler.xyz", "planetary-computer", "pc". Defaults to None. timeout (int, optional): Timeout in seconds. Defaults to 300. Returns: list: A dictionary of band info.
Here is the function:
def stac_info_geojson(
url=None,
collection=None,
item=None,
assets=None,
titiler_endpoint=None,
timeout=300,
**kwargs,
):
"""Get band info of a STAC item.
Args:
url (str): HTTP URL to a STAC item, e.g., https://canada-spot-ortho.s3.amazonaws.com/canada_spot_orthoimages/canada_spot5_orthoimages/S5_2007/S5_11055_6057_20070622/S5_11055_6057_20070622.json
collection (str): The Microsoft Planetary Computer STAC collection ID, e.g., landsat-8-c2-l2.
item (str): The Microsoft Planetary Computer STAC item ID, e.g., LC08_L2SP_047027_20201204_02_T1.
assets (str | list): The Microsoft Planetary Computer STAC asset ID, e.g., ["SR_B7", "SR_B5", "SR_B4"].
titiler_endpoint (str, optional): Titiler endpoint, e.g., "https://titiler.xyz", "planetary-computer", "pc". Defaults to None.
timeout (int, optional): Timeout in seconds. Defaults to 300.
Returns:
list: A dictionary of band info.
"""
if url is None and collection is None:
raise ValueError("Either url or collection must be specified.")
if collection is not None and titiler_endpoint is None:
titiler_endpoint = "planetary-computer"
if url is not None:
url = get_direct_url(url)
kwargs["url"] = url
if collection is not None:
kwargs["collection"] = collection
if item is not None:
kwargs["item"] = item
if assets is not None:
kwargs["assets"] = assets
titiler_endpoint = check_titiler_endpoint(titiler_endpoint)
if isinstance(titiler_endpoint, str):
r = requests.get(
f"{titiler_endpoint}/stac/info.geojson", params=kwargs, timeout=timeout
).json()
else:
r = requests.get(
titiler_endpoint.url_for_stac_info_geojson(), params=kwargs, timeout=timeout
).json()
return r | Get band info of a STAC item. Args: url (str): HTTP URL to a STAC item, e.g., https://canada-spot-ortho.s3.amazonaws.com/canada_spot_orthoimages/canada_spot5_orthoimages/S5_2007/S5_11055_6057_20070622/S5_11055_6057_20070622.json collection (str): The Microsoft Planetary Computer STAC collection ID, e.g., landsat-8-c2-l2. item (str): The Microsoft Planetary Computer STAC item ID, e.g., LC08_L2SP_047027_20201204_02_T1. assets (str | list): The Microsoft Planetary Computer STAC asset ID, e.g., ["SR_B7", "SR_B5", "SR_B4"]. titiler_endpoint (str, optional): Titiler endpoint, e.g., "https://titiler.xyz", "planetary-computer", "pc". Defaults to None. timeout (int, optional): Timeout in seconds. Defaults to 300. Returns: list: A dictionary of band info. |
12,293 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def check_package(name, URL=""):
try:
__import__(name.lower())
except Exception:
raise ImportError(
f"{name} is not installed. Please install it before proceeding. {URL}"
)
The provided code snippet includes necessary dependencies for implementing the `local_tile_vmin_vmax` function. Write a Python function `def local_tile_vmin_vmax( source, bands=None, **kwargs, )` to solve the following problem:
Get vmin and vmax from COG. Args: source (str | TileClient): A local COG file path or TileClient object. bands (str | list, optional): A list of band names. Defaults to None. Raises: ValueError: If source is not a TileClient object or a local COG file path. Returns: tuple: A tuple of vmin and vmax.
Here is the function:
def local_tile_vmin_vmax(
source,
bands=None,
**kwargs,
):
"""Get vmin and vmax from COG.
Args:
source (str | TileClient): A local COG file path or TileClient object.
bands (str | list, optional): A list of band names. Defaults to None.
Raises:
ValueError: If source is not a TileClient object or a local COG file path.
Returns:
tuple: A tuple of vmin and vmax.
"""
check_package("localtileserver", "https://github.com/banesullivan/localtileserver")
from localtileserver import TileClient
if isinstance(source, str):
tile_client = TileClient(source)
elif isinstance(source, TileClient):
tile_client = source
else:
raise ValueError("source must be a string or TileClient object.")
bandnames = tile_client.band_names
stats = tile_client.reader.statistics()
if isinstance(bands, str):
bands = [bands]
elif isinstance(bands, list):
pass
elif bands is None:
bands = bandnames
if all(b in bandnames for b in bands):
vmin = min([stats[b]["min"] for b in bands])
vmax = max([stats[b]["max"] for b in bands])
else:
vmin = min([stats[b]["min"] for b in bandnames])
vmax = max([stats[b]["max"] for b in bandnames])
return vmin, vmax | Get vmin and vmax from COG. Args: source (str | TileClient): A local COG file path or TileClient object. bands (str | list, optional): A list of band names. Defaults to None. Raises: ValueError: If source is not a TileClient object or a local COG file path. Returns: tuple: A tuple of vmin and vmax. |
12,294 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def check_package(name, URL=""):
try:
__import__(name.lower())
except Exception:
raise ImportError(
f"{name} is not installed. Please install it before proceeding. {URL}"
)
The provided code snippet includes necessary dependencies for implementing the `local_tile_bands` function. Write a Python function `def local_tile_bands(source)` to solve the following problem:
Get band names from COG. Args: source (str | TileClient): A local COG file path or TileClient Returns: list: A list of band names.
Here is the function:
def local_tile_bands(source):
"""Get band names from COG.
Args:
source (str | TileClient): A local COG file path or TileClient
Returns:
list: A list of band names.
"""
check_package("localtileserver", "https://github.com/banesullivan/localtileserver")
from localtileserver import TileClient
if isinstance(source, str):
tile_client = TileClient(source)
elif isinstance(source, TileClient):
tile_client = source
else:
raise ValueError("source must be a string or TileClient object.")
return tile_client.band_names | Get band names from COG. Args: source (str | TileClient): A local COG file path or TileClient Returns: list: A list of band names. |
12,295 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def bbox_to_geojson(bounds):
"""Convert coordinates of a bounding box to a geojson.
Args:
bounds (list): A list of coordinates representing [left, bottom, right, top].
Returns:
dict: A geojson feature.
"""
return {
"geometry": {
"type": "Polygon",
"coordinates": [
[
[bounds[0], bounds[3]],
[bounds[0], bounds[1]],
[bounds[2], bounds[1]],
[bounds[2], bounds[3]],
[bounds[0], bounds[3]],
]
],
},
"type": "Feature",
}
The provided code snippet includes necessary dependencies for implementing the `coords_to_geojson` function. Write a Python function `def coords_to_geojson(coords)` to solve the following problem:
Convert a list of bbox coordinates representing [left, bottom, right, top] to geojson FeatureCollection. Args: coords (list): A list of bbox coordinates representing [left, bottom, right, top]. Returns: dict: A geojson FeatureCollection.
Here is the function:
def coords_to_geojson(coords):
"""Convert a list of bbox coordinates representing [left, bottom, right, top] to geojson FeatureCollection.
Args:
coords (list): A list of bbox coordinates representing [left, bottom, right, top].
Returns:
dict: A geojson FeatureCollection.
"""
features = []
for bbox in coords:
features.append(bbox_to_geojson(bbox))
return {"type": "FeatureCollection", "features": features} | Convert a list of bbox coordinates representing [left, bottom, right, top] to geojson FeatureCollection. Args: coords (list): A list of bbox coordinates representing [left, bottom, right, top]. Returns: dict: A geojson FeatureCollection. |
12,296 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def get_bounds(geometry, north_up=True, transform=None):
"""Bounding box of a GeoJSON geometry, GeometryCollection, or FeatureCollection.
left, bottom, right, top
*not* xmin, ymin, xmax, ymax
If not north_up, y will be switched to guarantee the above.
Source code adapted from https://github.com/mapbox/rasterio/blob/master/rasterio/features.py#L361
Args:
geometry (dict): A GeoJSON dict.
north_up (bool, optional): . Defaults to True.
transform ([type], optional): . Defaults to None.
Returns:
list: A list of coordinates representing [left, bottom, right, top]
"""
if "bbox" in geometry:
return tuple(geometry["bbox"])
geometry = geometry.get("geometry") or geometry
# geometry must be a geometry, GeometryCollection, or FeatureCollection
if not (
"coordinates" in geometry or "geometries" in geometry or "features" in geometry
):
raise ValueError(
"geometry must be a GeoJSON-like geometry, GeometryCollection, "
"or FeatureCollection"
)
if "features" in geometry:
# Input is a FeatureCollection
xmins = []
ymins = []
xmaxs = []
ymaxs = []
for feature in geometry["features"]:
xmin, ymin, xmax, ymax = get_bounds(feature["geometry"])
xmins.append(xmin)
ymins.append(ymin)
xmaxs.append(xmax)
ymaxs.append(ymax)
if north_up:
return min(xmins), min(ymins), max(xmaxs), max(ymaxs)
else:
return min(xmins), max(ymaxs), max(xmaxs), min(ymins)
elif "geometries" in geometry:
# Input is a geometry collection
xmins = []
ymins = []
xmaxs = []
ymaxs = []
for geometry in geometry["geometries"]:
xmin, ymin, xmax, ymax = get_bounds(geometry)
xmins.append(xmin)
ymins.append(ymin)
xmaxs.append(xmax)
ymaxs.append(ymax)
if north_up:
return min(xmins), min(ymins), max(xmaxs), max(ymaxs)
else:
return min(xmins), max(ymaxs), max(xmaxs), min(ymins)
elif "coordinates" in geometry:
# Input is a singular geometry object
if transform is not None:
xyz = list(explode(geometry["coordinates"]))
xyz_px = [transform * point for point in xyz]
xyz = tuple(zip(*xyz_px))
return min(xyz[0]), max(xyz[1]), max(xyz[0]), min(xyz[1])
else:
xyz = tuple(zip(*list(explode(geometry["coordinates"]))))
if north_up:
return min(xyz[0]), min(xyz[1]), max(xyz[0]), max(xyz[1])
else:
return min(xyz[0]), max(xyz[1]), max(xyz[0]), min(xyz[1])
# all valid inputs returned above, so whatever falls through is an error
raise ValueError(
"geometry must be a GeoJSON-like geometry, GeometryCollection, "
"or FeatureCollection"
)
The provided code snippet includes necessary dependencies for implementing the `get_center` function. Write a Python function `def get_center(geometry, north_up=True, transform=None)` to solve the following problem:
Get the centroid of a GeoJSON. Args: geometry (dict): A GeoJSON dict. north_up (bool, optional): . Defaults to True. transform ([type], optional): . Defaults to None. Returns: list: [lon, lat]
Here is the function:
def get_center(geometry, north_up=True, transform=None):
"""Get the centroid of a GeoJSON.
Args:
geometry (dict): A GeoJSON dict.
north_up (bool, optional): . Defaults to True.
transform ([type], optional): . Defaults to None.
Returns:
list: [lon, lat]
"""
bounds = get_bounds(geometry, north_up, transform)
center = ((bounds[0] + bounds[2]) / 2, (bounds[1] + bounds[3]) / 2) # (lat, lon)
return center | Get the centroid of a GeoJSON. Args: geometry (dict): A GeoJSON dict. north_up (bool, optional): . Defaults to True. transform ([type], optional): . Defaults to None. Returns: list: [lon, lat] |
12,297 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def image_date(img, date_format="YYYY-MM-dd"):
"""Retrieves the image acquisition date.
Args:
img (object): ee.Image
date_format (str, optional): The date format to use. Defaults to 'YYYY-MM-dd'.
Returns:
str: A string representing the acquisition of the image.
"""
return ee.Date(img.get("system:time_start")).format(date_format)
The provided code snippet includes necessary dependencies for implementing the `image_props` function. Write a Python function `def image_props(img, date_format="YYYY-MM-dd")` to solve the following problem:
Gets image properties. Args: img (ee.Image): The input image. date_format (str, optional): The output date format. Defaults to 'YYYY-MM-dd HH:mm:ss'. Returns: dd.Dictionary: The dictionary containing image properties.
Here is the function:
def image_props(img, date_format="YYYY-MM-dd"):
"""Gets image properties.
Args:
img (ee.Image): The input image.
date_format (str, optional): The output date format. Defaults to 'YYYY-MM-dd HH:mm:ss'.
Returns:
dd.Dictionary: The dictionary containing image properties.
"""
if not isinstance(img, ee.Image):
print("The input object must be an ee.Image")
return
keys = img.propertyNames().remove("system:footprint").remove("system:bands")
values = keys.map(lambda p: img.get(p))
props = ee.Dictionary.fromLists(keys, values)
names = keys.getInfo()
bands = img.bandNames()
scales = bands.map(lambda b: img.select([b]).projection().nominalScale())
scale = ee.Algorithms.If(
scales.distinct().size().gt(1),
ee.Dictionary.fromLists(bands.getInfo(), scales),
scales.get(0),
)
props = props.set("NOMINAL_SCALE", scale)
if "system:time_start" in names:
image_date = ee.Date(img.get("system:time_start")).format(date_format)
time_start = ee.Date(img.get("system:time_start")).format("YYYY-MM-dd HH:mm:ss")
# time_end = ee.Date(img.get('system:time_end')).format('YYYY-MM-dd HH:mm:ss')
time_end = ee.Algorithms.If(
ee.List(img.propertyNames()).contains("system:time_end"),
ee.Date(img.get("system:time_end")).format("YYYY-MM-dd HH:mm:ss"),
time_start,
)
props = props.set("system:time_start", time_start)
props = props.set("system:time_end", time_end)
props = props.set("IMAGE_DATE", image_date)
if "system:asset_size" in names:
asset_size = (
ee.Number(img.get("system:asset_size"))
.divide(1e6)
.format()
.cat(ee.String(" MB"))
)
props = props.set("system:asset_size", asset_size)
return props | Gets image properties. Args: img (ee.Image): The input image. date_format (str, optional): The output date format. Defaults to 'YYYY-MM-dd HH:mm:ss'. Returns: dd.Dictionary: The dictionary containing image properties. |
12,298 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def image_max_value(img, region=None, scale=None):
"""Retrieves the maximum value of an image.
Args:
img (object): The image to calculate the maximum value.
region (object, optional): The region over which to reduce data. Defaults to the footprint of the image's first band.
scale (float, optional): A nominal scale in meters of the projection to work in. Defaults to None.
Returns:
object: ee.Number
"""
if region is None:
region = img.geometry()
if scale is None:
scale = image_scale(img)
max_value = img.reduceRegion(
**{
"reducer": ee.Reducer.max(),
"geometry": region,
"scale": scale,
"maxPixels": 1e12,
"bestEffort": True,
}
)
return max_value
def image_min_value(img, region=None, scale=None):
"""Retrieves the minimum value of an image.
Args:
img (object): The image to calculate the minimum value.
region (object, optional): The region over which to reduce data. Defaults to the footprint of the image's first band.
scale (float, optional): A nominal scale in meters of the projection to work in. Defaults to None.
Returns:
object: ee.Number
"""
if region is None:
region = img.geometry()
if scale is None:
scale = image_scale(img)
min_value = img.reduceRegion(
**{
"reducer": ee.Reducer.min(),
"geometry": region,
"scale": scale,
"maxPixels": 1e12,
"bestEffort": True,
}
)
return min_value
def image_mean_value(img, region=None, scale=None):
"""Retrieves the mean value of an image.
Args:
img (object): The image to calculate the mean value.
region (object, optional): The region over which to reduce data. Defaults to the footprint of the image's first band.
scale (float, optional): A nominal scale in meters of the projection to work in. Defaults to None.
Returns:
object: ee.Number
"""
if region is None:
region = img.geometry()
if scale is None:
scale = image_scale(img)
mean_value = img.reduceRegion(
**{
"reducer": ee.Reducer.mean(),
"geometry": region,
"scale": scale,
"maxPixels": 1e12,
"bestEffort": True,
}
)
return mean_value
def image_std_value(img, region=None, scale=None):
"""Retrieves the standard deviation of an image.
Args:
img (object): The image to calculate the standard deviation.
region (object, optional): The region over which to reduce data. Defaults to the footprint of the image's first band.
scale (float, optional): A nominal scale in meters of the projection to work in. Defaults to None.
Returns:
object: ee.Number
"""
if region is None:
region = img.geometry()
if scale is None:
scale = image_scale(img)
std_value = img.reduceRegion(
**{
"reducer": ee.Reducer.stdDev(),
"geometry": region,
"scale": scale,
"maxPixels": 1e12,
"bestEffort": True,
}
)
return std_value
def image_sum_value(img, region=None, scale=None):
"""Retrieves the sum of an image.
Args:
img (object): The image to calculate the standard deviation.
region (object, optional): The region over which to reduce data. Defaults to the footprint of the image's first band.
scale (float, optional): A nominal scale in meters of the projection to work in. Defaults to None.
Returns:
object: ee.Number
"""
if region is None:
region = img.geometry()
if scale is None:
scale = image_scale(img)
sum_value = img.reduceRegion(
**{
"reducer": ee.Reducer.sum(),
"geometry": region,
"scale": scale,
"maxPixels": 1e12,
"bestEffort": True,
}
)
return sum_value
The provided code snippet includes necessary dependencies for implementing the `image_stats` function. Write a Python function `def image_stats(img, region=None, scale=None)` to solve the following problem:
Gets image descriptive statistics. Args: img (ee.Image): The input image to calculate descriptive statistics. region (object, optional): The region over which to reduce data. Defaults to the footprint of the image's first band. scale (float, optional): A nominal scale in meters of the projection to work in. Defaults to None. Returns: ee.Dictionary: A dictionary containing the description statistics of the input image.
Here is the function:
def image_stats(img, region=None, scale=None):
"""Gets image descriptive statistics.
Args:
img (ee.Image): The input image to calculate descriptive statistics.
region (object, optional): The region over which to reduce data. Defaults to the footprint of the image's first band.
scale (float, optional): A nominal scale in meters of the projection to work in. Defaults to None.
Returns:
ee.Dictionary: A dictionary containing the description statistics of the input image.
"""
if not isinstance(img, ee.Image):
print("The input object must be an ee.Image")
return
stat_types = ["min", "max", "mean", "std", "sum"]
image_min = image_min_value(img, region, scale)
image_max = image_max_value(img, region, scale)
image_mean = image_mean_value(img, region, scale)
image_std = image_std_value(img, region, scale)
image_sum = image_sum_value(img, region, scale)
stat_results = ee.List([image_min, image_max, image_mean, image_std, image_sum])
stats = ee.Dictionary.fromLists(stat_types, stat_results)
return stats | Gets image descriptive statistics. Args: img (ee.Image): The input image to calculate descriptive statistics. region (object, optional): The region over which to reduce data. Defaults to the footprint of the image's first band. scale (float, optional): A nominal scale in meters of the projection to work in. Defaults to None. Returns: ee.Dictionary: A dictionary containing the description statistics of the input image. |
12,299 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def ee_export_vector(
ee_object,
filename,
selectors=None,
verbose=True,
keep_zip=False,
timeout=300,
proxies=None,
):
"""Exports Earth Engine FeatureCollection to other formats, including shp, csv, json, kml, and kmz.
Args:
ee_object (object): ee.FeatureCollection to export.
filename (str): Output file name.
selectors (list, optional): A list of attributes to export. Defaults to None.
verbose (bool, optional): Whether to print out descriptive text.
keep_zip (bool, optional): Whether to keep the downloaded shapefile as a zip file.
timeout (int, optional): Timeout in seconds. Defaults to 300 seconds.
proxies (dict, optional): A dictionary of proxies to use. Defaults to None.
"""
if not isinstance(ee_object, ee.FeatureCollection):
raise ValueError("ee_object must be an ee.FeatureCollection")
allowed_formats = ["csv", "geojson", "json", "kml", "kmz", "shp"]
# allowed_formats = ['csv', 'kml', 'kmz']
filename = os.path.abspath(filename)
basename = os.path.basename(filename)
name = os.path.splitext(basename)[0]
filetype = os.path.splitext(basename)[1][1:].lower()
if filetype == "shp":
filename = filename.replace(".shp", ".zip")
if not (filetype.lower() in allowed_formats):
raise ValueError(
"The file type must be one of the following: {}".format(
", ".join(allowed_formats)
)
)
if selectors is None:
selectors = ee_object.first().propertyNames().getInfo()
if filetype == "csv":
# remove .geo coordinate field
ee_object = ee_object.select([".*"], None, False)
if filetype == "geojson":
selectors = [".geo"] + selectors
elif not isinstance(selectors, list):
raise ValueError(
"selectors must be a list, such as ['attribute1', 'attribute2']"
)
else:
allowed_attributes = ee_object.first().propertyNames().getInfo()
for attribute in selectors:
if not (attribute in allowed_attributes):
raise ValueError(
"Attributes must be one chosen from: {} ".format(
", ".join(allowed_attributes)
)
)
try:
if verbose:
print("Generating URL ...")
url = ee_object.getDownloadURL(
filetype=filetype, selectors=selectors, filename=name
)
if verbose:
print(f"Downloading data from {url}\nPlease wait ...")
r = None
r = requests.get(url, stream=True, timeout=timeout, proxies=proxies)
if r.status_code != 200:
print("An error occurred while downloading. \n Retrying ...")
try:
new_ee_object = ee_object.map(filter_polygons)
print("Generating URL ...")
url = new_ee_object.getDownloadURL(
filetype=filetype, selectors=selectors, filename=name
)
print(f"Downloading data from {url}\nPlease wait ...")
r = requests.get(url, stream=True, timeout=timeout, proxies=proxies)
except Exception as e:
print(e)
raise ValueError
with open(filename, "wb") as fd:
for chunk in r.iter_content(chunk_size=1024):
fd.write(chunk)
except Exception as e:
print("An error occurred while downloading.")
if r is not None:
print(r.json()["error"]["message"])
raise ValueError(e)
try:
if filetype == "shp":
with zipfile.ZipFile(filename) as z:
z.extractall(os.path.dirname(filename))
if not keep_zip:
os.remove(filename)
filename = filename.replace(".zip", ".shp")
if verbose:
print(f"Data downloaded to {filename}")
except Exception as e:
raise ValueError(e)
The provided code snippet includes necessary dependencies for implementing the `zonal_stats` function. Write a Python function `def zonal_stats( in_value_raster, in_zone_vector, out_file_path=None, stat_type="MEAN", scale=None, crs=None, tile_scale=1.0, return_fc=False, verbose=True, timeout=300, proxies=None, **kwargs, )` to solve the following problem:
Summarizes the values of a raster within the zones of another dataset and exports the results as a csv, shp, json, kml, or kmz. Args: in_value_raster (object): An ee.Image or ee.ImageCollection that contains the values on which to calculate a statistic. in_zone_vector (object): An ee.FeatureCollection that defines the zones. out_file_path (str): Output file path that will contain the summary of the values in each zone. The file type can be: csv, shp, json, kml, kmz stat_type (str, optional): Statistical type to be calculated. Defaults to 'MEAN'. For 'HIST', you can provide three parameters: max_buckets, min_bucket_width, and max_raw. For 'FIXED_HIST', you must provide three parameters: hist_min, hist_max, and hist_steps. scale (float, optional): A nominal scale in meters of the projection to work in. Defaults to None. crs (str, optional): The projection to work in. If unspecified, the projection of the image's first band is used. If specified in addition to scale, rescaled to the specified scale. Defaults to None. tile_scale (float, optional): A scaling factor used to reduce aggregation tile size; using a larger tileScale (e.g. 2 or 4) may enable computations that run out of memory with the default. Defaults to 1.0. verbose (bool, optional): Whether to print descriptive text when the programming is running. Default to True. return_fc (bool, optional): Whether to return the results as an ee.FeatureCollection. Defaults to False. timeout (int, optional): Timeout in seconds. Default to 300. proxies (dict, optional): A dictionary of proxy servers to use for the request. Default to None.
Here is the function:
def zonal_stats(
in_value_raster,
in_zone_vector,
out_file_path=None,
stat_type="MEAN",
scale=None,
crs=None,
tile_scale=1.0,
return_fc=False,
verbose=True,
timeout=300,
proxies=None,
**kwargs,
):
"""Summarizes the values of a raster within the zones of another dataset and exports the results as a csv, shp, json, kml, or kmz.
Args:
in_value_raster (object): An ee.Image or ee.ImageCollection that contains the values on which to calculate a statistic.
in_zone_vector (object): An ee.FeatureCollection that defines the zones.
out_file_path (str): Output file path that will contain the summary of the values in each zone. The file type can be: csv, shp, json, kml, kmz
stat_type (str, optional): Statistical type to be calculated. Defaults to 'MEAN'. For 'HIST', you can provide three parameters: max_buckets, min_bucket_width, and max_raw. For 'FIXED_HIST', you must provide three parameters: hist_min, hist_max, and hist_steps.
scale (float, optional): A nominal scale in meters of the projection to work in. Defaults to None.
crs (str, optional): The projection to work in. If unspecified, the projection of the image's first band is used. If specified in addition to scale, rescaled to the specified scale. Defaults to None.
tile_scale (float, optional): A scaling factor used to reduce aggregation tile size; using a larger tileScale (e.g. 2 or 4) may enable computations that run out of memory with the default. Defaults to 1.0.
verbose (bool, optional): Whether to print descriptive text when the programming is running. Default to True.
return_fc (bool, optional): Whether to return the results as an ee.FeatureCollection. Defaults to False.
timeout (int, optional): Timeout in seconds. Default to 300.
proxies (dict, optional): A dictionary of proxy servers to use for the request. Default to None.
"""
if isinstance(in_value_raster, ee.ImageCollection):
in_value_raster = in_value_raster.toBands()
if not isinstance(in_value_raster, ee.Image):
print("The input raster must be an ee.Image.")
return
if not isinstance(in_zone_vector, ee.FeatureCollection):
print("The input zone data must be an ee.FeatureCollection.")
return
if out_file_path is None:
out_file_path = os.path.join(os.getcwd(), "zonal_stats.csv")
if "statistics_type" in kwargs:
stat_type = kwargs.pop("statistics_type")
allowed_formats = ["csv", "geojson", "kml", "kmz", "shp"]
filename = os.path.abspath(out_file_path)
basename = os.path.basename(filename)
# name = os.path.splitext(basename)[0]
filetype = os.path.splitext(basename)[1][1:].lower()
if not (filetype in allowed_formats):
print(
"The file type must be one of the following: {}".format(
", ".join(allowed_formats)
)
)
return
# Parameters for histogram
# The maximum number of buckets to use when building a histogram; will be rounded up to a power of 2.
max_buckets = None
# The minimum histogram bucket width, or null to allow any power of 2.
min_bucket_width = None
# The number of values to accumulate before building the initial histogram.
max_raw = None
hist_min = 1.0 # The lower (inclusive) bound of the first bucket.
hist_max = 100.0 # The upper (exclusive) bound of the last bucket.
hist_steps = 10 # The number of buckets to use.
if "max_buckets" in kwargs.keys():
max_buckets = kwargs["max_buckets"]
if "min_bucket_width" in kwargs.keys():
min_bucket_width = kwargs["min_bucket"]
if "max_raw" in kwargs.keys():
max_raw = kwargs["max_raw"]
if isinstance(stat_type, str):
if (
stat_type.upper() == "FIXED_HIST"
and ("hist_min" in kwargs.keys())
and ("hist_max" in kwargs.keys())
and ("hist_steps" in kwargs.keys())
):
hist_min = kwargs["hist_min"]
hist_max = kwargs["hist_max"]
hist_steps = kwargs["hist_steps"]
elif stat_type.upper() == "FIXED_HIST":
print(
"To use fixedHistogram, please provide these three parameters: hist_min, hist_max, and hist_steps."
)
return
allowed_statistics = {
"COUNT": ee.Reducer.count(),
"MEAN": ee.Reducer.mean(),
"MEAN_UNWEIGHTED": ee.Reducer.mean().unweighted(),
"MAXIMUM": ee.Reducer.max(),
"MEDIAN": ee.Reducer.median(),
"MINIMUM": ee.Reducer.min(),
"MODE": ee.Reducer.mode(),
"STD": ee.Reducer.stdDev(),
"MIN_MAX": ee.Reducer.minMax(),
"SUM": ee.Reducer.sum(),
"VARIANCE": ee.Reducer.variance(),
"HIST": ee.Reducer.histogram(
maxBuckets=max_buckets, minBucketWidth=min_bucket_width, maxRaw=max_raw
),
"FIXED_HIST": ee.Reducer.fixedHistogram(hist_min, hist_max, hist_steps),
"COMBINED_COUNT_MEAN": ee.Reducer.count().combine(
ee.Reducer.mean(), sharedInputs=True
),
"COMBINED_COUNT_MEAN_UNWEIGHTED": ee.Reducer.count().combine(
ee.Reducer.mean().unweighted(), sharedInputs=True
),
}
if isinstance(stat_type, str):
if not (stat_type.upper() in allowed_statistics.keys()):
print(
"The statistics type must be one of the following: {}".format(
", ".join(list(allowed_statistics.keys()))
)
)
return
reducer = allowed_statistics[stat_type.upper()]
elif isinstance(stat_type, ee.Reducer):
reducer = stat_type
else:
raise ValueError("statistics_type must be either a string or ee.Reducer.")
if scale is None:
scale = in_value_raster.projection().nominalScale().multiply(10)
try:
if verbose:
print("Computing statistics ...")
result = in_value_raster.reduceRegions(
collection=in_zone_vector,
reducer=reducer,
scale=scale,
crs=crs,
tileScale=tile_scale,
)
if return_fc:
return result
else:
ee_export_vector(result, filename, timeout=timeout, proxies=proxies)
except Exception as e:
raise Exception(e) | Summarizes the values of a raster within the zones of another dataset and exports the results as a csv, shp, json, kml, or kmz. Args: in_value_raster (object): An ee.Image or ee.ImageCollection that contains the values on which to calculate a statistic. in_zone_vector (object): An ee.FeatureCollection that defines the zones. out_file_path (str): Output file path that will contain the summary of the values in each zone. The file type can be: csv, shp, json, kml, kmz stat_type (str, optional): Statistical type to be calculated. Defaults to 'MEAN'. For 'HIST', you can provide three parameters: max_buckets, min_bucket_width, and max_raw. For 'FIXED_HIST', you must provide three parameters: hist_min, hist_max, and hist_steps. scale (float, optional): A nominal scale in meters of the projection to work in. Defaults to None. crs (str, optional): The projection to work in. If unspecified, the projection of the image's first band is used. If specified in addition to scale, rescaled to the specified scale. Defaults to None. tile_scale (float, optional): A scaling factor used to reduce aggregation tile size; using a larger tileScale (e.g. 2 or 4) may enable computations that run out of memory with the default. Defaults to 1.0. verbose (bool, optional): Whether to print descriptive text when the programming is running. Default to True. return_fc (bool, optional): Whether to return the results as an ee.FeatureCollection. Defaults to False. timeout (int, optional): Timeout in seconds. Default to 300. proxies (dict, optional): A dictionary of proxy servers to use for the request. Default to None. |
12,300 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def ee_export_vector(
ee_object,
filename,
selectors=None,
verbose=True,
keep_zip=False,
timeout=300,
proxies=None,
):
"""Exports Earth Engine FeatureCollection to other formats, including shp, csv, json, kml, and kmz.
Args:
ee_object (object): ee.FeatureCollection to export.
filename (str): Output file name.
selectors (list, optional): A list of attributes to export. Defaults to None.
verbose (bool, optional): Whether to print out descriptive text.
keep_zip (bool, optional): Whether to keep the downloaded shapefile as a zip file.
timeout (int, optional): Timeout in seconds. Defaults to 300 seconds.
proxies (dict, optional): A dictionary of proxies to use. Defaults to None.
"""
if not isinstance(ee_object, ee.FeatureCollection):
raise ValueError("ee_object must be an ee.FeatureCollection")
allowed_formats = ["csv", "geojson", "json", "kml", "kmz", "shp"]
# allowed_formats = ['csv', 'kml', 'kmz']
filename = os.path.abspath(filename)
basename = os.path.basename(filename)
name = os.path.splitext(basename)[0]
filetype = os.path.splitext(basename)[1][1:].lower()
if filetype == "shp":
filename = filename.replace(".shp", ".zip")
if not (filetype.lower() in allowed_formats):
raise ValueError(
"The file type must be one of the following: {}".format(
", ".join(allowed_formats)
)
)
if selectors is None:
selectors = ee_object.first().propertyNames().getInfo()
if filetype == "csv":
# remove .geo coordinate field
ee_object = ee_object.select([".*"], None, False)
if filetype == "geojson":
selectors = [".geo"] + selectors
elif not isinstance(selectors, list):
raise ValueError(
"selectors must be a list, such as ['attribute1', 'attribute2']"
)
else:
allowed_attributes = ee_object.first().propertyNames().getInfo()
for attribute in selectors:
if not (attribute in allowed_attributes):
raise ValueError(
"Attributes must be one chosen from: {} ".format(
", ".join(allowed_attributes)
)
)
try:
if verbose:
print("Generating URL ...")
url = ee_object.getDownloadURL(
filetype=filetype, selectors=selectors, filename=name
)
if verbose:
print(f"Downloading data from {url}\nPlease wait ...")
r = None
r = requests.get(url, stream=True, timeout=timeout, proxies=proxies)
if r.status_code != 200:
print("An error occurred while downloading. \n Retrying ...")
try:
new_ee_object = ee_object.map(filter_polygons)
print("Generating URL ...")
url = new_ee_object.getDownloadURL(
filetype=filetype, selectors=selectors, filename=name
)
print(f"Downloading data from {url}\nPlease wait ...")
r = requests.get(url, stream=True, timeout=timeout, proxies=proxies)
except Exception as e:
print(e)
raise ValueError
with open(filename, "wb") as fd:
for chunk in r.iter_content(chunk_size=1024):
fd.write(chunk)
except Exception as e:
print("An error occurred while downloading.")
if r is not None:
print(r.json()["error"]["message"])
raise ValueError(e)
try:
if filetype == "shp":
with zipfile.ZipFile(filename) as z:
z.extractall(os.path.dirname(filename))
if not keep_zip:
os.remove(filename)
filename = filename.replace(".zip", ".shp")
if verbose:
print(f"Data downloaded to {filename}")
except Exception as e:
raise ValueError(e)
The provided code snippet includes necessary dependencies for implementing the `zonal_stats_by_group` function. Write a Python function `def zonal_stats_by_group( in_value_raster, in_zone_vector, out_file_path=None, stat_type="SUM", decimal_places=0, denominator=1.0, scale=None, crs=None, crs_transform=None, best_effort=True, max_pixels=1e7, tile_scale=1.0, return_fc=False, verbose=True, timeout=300, proxies=None, **kwargs, )` to solve the following problem:
Summarizes the area or percentage of a raster by group within the zones of another dataset and exports the results as a csv, shp, json, kml, or kmz. Args: in_value_raster (object): An integer Image that contains the values on which to calculate area/percentage. in_zone_vector (object): An ee.FeatureCollection that defines the zones. out_file_path (str): Output file path that will contain the summary of the values in each zone. The file type can be: csv, shp, json, kml, kmz stat_type (str, optional): Can be either 'SUM' or 'PERCENTAGE' . Defaults to 'SUM'. decimal_places (int, optional): The number of decimal places to use. Defaults to 0. denominator (float, optional): To convert area units (e.g., from square meters to square kilometers). Defaults to 1.0. scale (float, optional): A nominal scale in meters of the projection to work in. Defaults to None. crs (str, optional): The projection to work in. If unspecified, the projection of the image's first band is used. If specified in addition to scale, rescaled to the specified scale. Defaults to None. crs_transform (list, optional): The list of CRS transform values. This is a row-major ordering of the 3x2 transform matrix. This option is mutually exclusive with 'scale', and replaces any transform already set on the projection. best_effort (bool, optional): If the polygon would contain too many pixels at the given scale, compute and use a larger scale which would allow the operation to succeed. max_pixels (int, optional): The maximum number of pixels to reduce. Defaults to 1e7. tile_scale (float, optional): A scaling factor used to reduce aggregation tile size; using a larger tileScale (e.g. 2 or 4) may enable computations that run out of memory with the default. Defaults to 1.0. verbose (bool, optional): Whether to print descriptive text when the programming is running. Default to True. return_fc (bool, optional): Whether to return the results as an ee.FeatureCollection. Defaults to False. timeout (int, optional): Timeout in seconds. Defaults to 300. proxies (dict, optional): A dictionary of proxies to use. Defaults to None.
Here is the function:
def zonal_stats_by_group(
in_value_raster,
in_zone_vector,
out_file_path=None,
stat_type="SUM",
decimal_places=0,
denominator=1.0,
scale=None,
crs=None,
crs_transform=None,
best_effort=True,
max_pixels=1e7,
tile_scale=1.0,
return_fc=False,
verbose=True,
timeout=300,
proxies=None,
**kwargs,
):
"""Summarizes the area or percentage of a raster by group within the zones of another dataset and exports the results as a csv, shp, json, kml, or kmz.
Args:
in_value_raster (object): An integer Image that contains the values on which to calculate area/percentage.
in_zone_vector (object): An ee.FeatureCollection that defines the zones.
out_file_path (str): Output file path that will contain the summary of the values in each zone. The file type can be: csv, shp, json, kml, kmz
stat_type (str, optional): Can be either 'SUM' or 'PERCENTAGE' . Defaults to 'SUM'.
decimal_places (int, optional): The number of decimal places to use. Defaults to 0.
denominator (float, optional): To convert area units (e.g., from square meters to square kilometers). Defaults to 1.0.
scale (float, optional): A nominal scale in meters of the projection to work in. Defaults to None.
crs (str, optional): The projection to work in. If unspecified, the projection of the image's first band is used. If specified in addition to scale, rescaled to the specified scale. Defaults to None.
crs_transform (list, optional): The list of CRS transform values. This is a row-major ordering of the 3x2 transform matrix. This option is mutually exclusive with 'scale', and replaces any transform already set on the projection.
best_effort (bool, optional): If the polygon would contain too many pixels at the given scale, compute and use a larger scale which would allow the operation to succeed.
max_pixels (int, optional): The maximum number of pixels to reduce. Defaults to 1e7.
tile_scale (float, optional): A scaling factor used to reduce aggregation tile size; using a larger tileScale (e.g. 2 or 4) may enable computations that run out of memory with the default. Defaults to 1.0.
verbose (bool, optional): Whether to print descriptive text when the programming is running. Default to True.
return_fc (bool, optional): Whether to return the results as an ee.FeatureCollection. Defaults to False.
timeout (int, optional): Timeout in seconds. Defaults to 300.
proxies (dict, optional): A dictionary of proxies to use. Defaults to None.
"""
if isinstance(in_value_raster, ee.ImageCollection):
in_value_raster = in_value_raster.toBands()
if not isinstance(in_value_raster, ee.Image):
print("The input raster must be an ee.Image.")
return
if out_file_path is None:
out_file_path = os.path.join(os.getcwd(), "zonal_stats_by_group.csv")
if "statistics_type" in kwargs:
stat_type = kwargs.pop("statistics_type")
band_count = in_value_raster.bandNames().size().getInfo()
band_name = ""
if band_count == 1:
band_name = in_value_raster.bandNames().get(0)
else:
print("The input image can only have one band.")
return
band_types = in_value_raster.bandTypes().get(band_name).getInfo()
band_type = band_types.get("precision")
if band_type != "int":
print("The input image band must be integer type.")
return
if not isinstance(in_zone_vector, ee.FeatureCollection):
print("The input zone data must be an ee.FeatureCollection.")
return
allowed_formats = ["csv", "geojson", "kml", "kmz", "shp"]
filename = os.path.abspath(out_file_path)
basename = os.path.basename(filename)
# name = os.path.splitext(basename)[0]
filetype = os.path.splitext(basename)[1][1:]
if not (filetype.lower() in allowed_formats):
print(
"The file type must be one of the following: {}".format(
", ".join(allowed_formats)
)
)
return
out_dir = os.path.dirname(filename)
if not os.path.exists(out_dir):
os.makedirs(out_dir)
allowed_statistics = ["SUM", "PERCENTAGE"]
if not (stat_type.upper() in allowed_statistics):
print(
"The statistics type can only be one of {}".format(
", ".join(allowed_statistics)
)
)
return
if scale is None:
scale = in_value_raster.projection().nominalScale().multiply(10)
try:
if verbose:
print("Computing ... ")
geometry = in_zone_vector.geometry()
hist = in_value_raster.reduceRegion(
ee.Reducer.frequencyHistogram(),
geometry=geometry,
scale=scale,
crs=crs,
crsTransform=crs_transform,
bestEffort=best_effort,
maxPixels=max_pixels,
tileScale=tile_scale,
)
class_values = (
ee.Dictionary(hist.get(band_name))
.keys()
.map(lambda v: ee.Number.parse(v))
.sort()
)
class_names = class_values.map(
lambda c: ee.String("Class_").cat(ee.Number(c).format())
)
# class_count = class_values.size().getInfo()
dataset = ee.Image.pixelArea().divide(denominator).addBands(in_value_raster)
init_result = dataset.reduceRegions(
**{
"collection": in_zone_vector,
"reducer": ee.Reducer.sum().group(
**{
"groupField": 1,
"groupName": "group",
}
),
"scale": scale,
}
)
# def build_dict(input_list):
# decimal_format = '%.{}f'.format(decimal_places)
# in_dict = input_list.map(lambda x: ee.Dictionary().set(ee.String('Class_').cat(
# ee.Number(ee.Dictionary(x).get('group')).format()), ee.Number.parse(ee.Number(ee.Dictionary(x).get('sum')).format(decimal_format))))
# return in_dict
def get_keys(input_list):
return input_list.map(
lambda x: ee.String("Class_").cat(
ee.Number(ee.Dictionary(x).get("group")).format()
)
)
def get_values(input_list):
decimal_format = "%.{}f".format(decimal_places)
return input_list.map(
lambda x: ee.Number.parse(
ee.Number(ee.Dictionary(x).get("sum")).format(decimal_format)
)
)
def set_attribute(f):
groups = ee.List(f.get("groups"))
keys = get_keys(groups)
values = get_values(groups)
total_area = ee.List(values).reduce(ee.Reducer.sum())
def get_class_values(x):
cls_value = ee.Algorithms.If(
keys.contains(x), values.get(keys.indexOf(x)), 0
)
cls_value = ee.Algorithms.If(
ee.String(stat_type).compareTo(ee.String("SUM")),
ee.Number(cls_value).divide(ee.Number(total_area)),
cls_value,
)
return cls_value
full_values = class_names.map(lambda x: get_class_values(x))
attr_dict = ee.Dictionary.fromLists(class_names, full_values)
attr_dict = attr_dict.set("Class_sum", total_area)
return f.set(attr_dict).set("groups", None)
final_result = init_result.map(set_attribute)
if return_fc:
return final_result
else:
ee_export_vector(final_result, filename, timeout=timeout, proxies=proxies)
except Exception as e:
raise Exception(e) | Summarizes the area or percentage of a raster by group within the zones of another dataset and exports the results as a csv, shp, json, kml, or kmz. Args: in_value_raster (object): An integer Image that contains the values on which to calculate area/percentage. in_zone_vector (object): An ee.FeatureCollection that defines the zones. out_file_path (str): Output file path that will contain the summary of the values in each zone. The file type can be: csv, shp, json, kml, kmz stat_type (str, optional): Can be either 'SUM' or 'PERCENTAGE' . Defaults to 'SUM'. decimal_places (int, optional): The number of decimal places to use. Defaults to 0. denominator (float, optional): To convert area units (e.g., from square meters to square kilometers). Defaults to 1.0. scale (float, optional): A nominal scale in meters of the projection to work in. Defaults to None. crs (str, optional): The projection to work in. If unspecified, the projection of the image's first band is used. If specified in addition to scale, rescaled to the specified scale. Defaults to None. crs_transform (list, optional): The list of CRS transform values. This is a row-major ordering of the 3x2 transform matrix. This option is mutually exclusive with 'scale', and replaces any transform already set on the projection. best_effort (bool, optional): If the polygon would contain too many pixels at the given scale, compute and use a larger scale which would allow the operation to succeed. max_pixels (int, optional): The maximum number of pixels to reduce. Defaults to 1e7. tile_scale (float, optional): A scaling factor used to reduce aggregation tile size; using a larger tileScale (e.g. 2 or 4) may enable computations that run out of memory with the default. Defaults to 1.0. verbose (bool, optional): Whether to print descriptive text when the programming is running. Default to True. return_fc (bool, optional): Whether to return the results as an ee.FeatureCollection. Defaults to False. timeout (int, optional): Timeout in seconds. Defaults to 300. proxies (dict, optional): A dictionary of proxies to use. Defaults to None. |
12,301 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `vec_area` function. Write a Python function `def vec_area(fc)` to solve the following problem:
Calculate the area (m2) of each each feature in a feature collection. Args: fc (object): The feature collection to compute the area. Returns: object: ee.FeatureCollection
Here is the function:
def vec_area(fc):
"""Calculate the area (m2) of each each feature in a feature collection.
Args:
fc (object): The feature collection to compute the area.
Returns:
object: ee.FeatureCollection
"""
return fc.map(lambda f: f.set({"area_m2": f.area(1).round()})) | Calculate the area (m2) of each each feature in a feature collection. Args: fc (object): The feature collection to compute the area. Returns: object: ee.FeatureCollection |
12,302 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `vec_area_km2` function. Write a Python function `def vec_area_km2(fc)` to solve the following problem:
Calculate the area (km2) of each each feature in a feature collection. Args: fc (object): The feature collection to compute the area. Returns: object: ee.FeatureCollection
Here is the function:
def vec_area_km2(fc):
"""Calculate the area (km2) of each each feature in a feature collection.
Args:
fc (object): The feature collection to compute the area.
Returns:
object: ee.FeatureCollection
"""
return fc.map(lambda f: f.set({"area_km2": f.area(1).divide(1e6).round()})) | Calculate the area (km2) of each each feature in a feature collection. Args: fc (object): The feature collection to compute the area. Returns: object: ee.FeatureCollection |
12,303 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `vec_area_mi2` function. Write a Python function `def vec_area_mi2(fc)` to solve the following problem:
Calculate the area (square mile) of each each feature in a feature collection. Args: fc (object): The feature collection to compute the area. Returns: object: ee.FeatureCollection
Here is the function:
def vec_area_mi2(fc):
"""Calculate the area (square mile) of each each feature in a feature collection.
Args:
fc (object): The feature collection to compute the area.
Returns:
object: ee.FeatureCollection
"""
return fc.map(lambda f: f.set({"area_mi2": f.area(1).divide(2.59e6).round()})) | Calculate the area (square mile) of each each feature in a feature collection. Args: fc (object): The feature collection to compute the area. Returns: object: ee.FeatureCollection |
12,304 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `vec_area_ha` function. Write a Python function `def vec_area_ha(fc)` to solve the following problem:
Calculate the area (hectare) of each each feature in a feature collection. Args: fc (object): The feature collection to compute the area. Returns: object: ee.FeatureCollection
Here is the function:
def vec_area_ha(fc):
"""Calculate the area (hectare) of each each feature in a feature collection.
Args:
fc (object): The feature collection to compute the area.
Returns:
object: ee.FeatureCollection
"""
return fc.map(lambda f: f.set({"area_ha": f.area(1).divide(1e4).round()})) | Calculate the area (hectare) of each each feature in a feature collection. Args: fc (object): The feature collection to compute the area. Returns: object: ee.FeatureCollection |
12,305 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `remove_geometry` function. Write a Python function `def remove_geometry(fc)` to solve the following problem:
Remove .geo coordinate field from a FeatureCollection Args: fc (object): The input FeatureCollection. Returns: object: The output FeatureCollection without the geometry field.
Here is the function:
def remove_geometry(fc):
"""Remove .geo coordinate field from a FeatureCollection
Args:
fc (object): The input FeatureCollection.
Returns:
object: The output FeatureCollection without the geometry field.
"""
return fc.select([".*"], None, False) | Remove .geo coordinate field from a FeatureCollection Args: fc (object): The input FeatureCollection. Returns: object: The output FeatureCollection without the geometry field. |
12,306 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `image_cell_size` function. Write a Python function `def image_cell_size(img)` to solve the following problem:
Retrieves the image cell size (e.g., spatial resolution) Args: img (object): ee.Image Returns: float: The nominal scale in meters.
Here is the function:
def image_cell_size(img):
"""Retrieves the image cell size (e.g., spatial resolution)
Args:
img (object): ee.Image
Returns:
float: The nominal scale in meters.
"""
bands = img.bandNames()
scales = bands.map(lambda b: img.select([b]).projection().nominalScale())
scale = ee.Algorithms.If(
scales.distinct().size().gt(1),
ee.Dictionary.fromLists(bands.getInfo(), scales),
scales.get(0),
)
return scale | Retrieves the image cell size (e.g., spatial resolution) Args: img (object): ee.Image Returns: float: The nominal scale in meters. |
12,307 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `image_band_names` function. Write a Python function `def image_band_names(img)` to solve the following problem:
Gets image band names. Args: img (ee.Image): The input image. Returns: ee.List: The returned list of image band names.
Here is the function:
def image_band_names(img):
"""Gets image band names.
Args:
img (ee.Image): The input image.
Returns:
ee.List: The returned list of image band names.
"""
return img.bandNames() | Gets image band names. Args: img (ee.Image): The input image. Returns: ee.List: The returned list of image band names. |
12,308 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def image_area(img, region=None, scale=None, denominator=1.0):
"""Calculates the area of an image.
Args:
img (object): ee.Image
region (object, optional): The region over which to reduce data. Defaults to the footprint of the image's first band.
scale (float, optional): A nominal scale in meters of the projection to work in. Defaults to None.
denominator (float, optional): The denominator to use for converting size from square meters to other units. Defaults to 1.0.
Returns:
object: ee.Dictionary
"""
if region is None:
region = img.geometry()
if scale is None:
scale = image_scale(img)
pixel_area = (
img.unmask().neq(ee.Image(0)).multiply(ee.Image.pixelArea()).divide(denominator)
)
img_area = pixel_area.reduceRegion(
**{
"geometry": region,
"reducer": ee.Reducer.sum(),
"scale": scale,
"maxPixels": 1e12,
}
)
return img_area
def image_value_list(img, region=None, scale=None, return_hist=False, **kwargs):
"""Get the unique values of an image.
Args:
img (ee.Image): The image to calculate the unique values.
region (ee.Geometry | ee.FeatureCollection, optional): The region over which to reduce data. Defaults to the footprint of the image's first band.
scale (float, optional): A nominal scale in meters of the projection to work in. Defaults to None.
return_hist (bool, optional): If True, return a histogram of the values. Defaults to False.
Returns:
ee.List | ee.Dictionary: A list of unique values or a dictionary containing a list of unique values and a histogram.
"""
if region is None:
geom = img.geometry().bounds()
region = ee.FeatureCollection([ee.Feature(geom)])
elif isinstance(region, ee.Geometry):
region = ee.FeatureCollection([ee.Feature(region)])
elif isinstance(region, ee.FeatureCollection):
pass
else:
raise ValueError("region must be an ee.Geometry or ee.FeatureCollection")
if scale is None:
scale = img.select(0).projection().nominalScale().multiply(10)
reducer = ee.Reducer.frequencyHistogram()
kwargs["scale"] = scale
kwargs["reducer"] = reducer
kwargs["collection"] = region
result = img.reduceRegions(**kwargs)
hist = ee.Dictionary(result.first().get("histogram"))
if return_hist:
return hist
else:
return hist.keys()
The provided code snippet includes necessary dependencies for implementing the `image_area_by_group` function. Write a Python function `def image_area_by_group( img, groups=None, region=None, scale=None, denominator=1.0, out_csv=None, labels=None, decimal_places=4, verbose=True, )` to solve the following problem:
Calculates the area of each class of an image. Args: img (object): ee.Image groups (object, optional): The groups to use for the area calculation. Defaults to None. region (object, optional): The region over which to reduce data. Defaults to the footprint of the image's first band. scale (float, optional): A nominal scale in meters of the projection to work in. Defaults to None. denominator (float, optional): The denominator to use for converting size from square meters to other units. Defaults to 1.0. out_csv (str, optional): The path to the output CSV file. Defaults to None. labels (object, optional): The class labels to use in the output CSV file. Defaults to None. decimal_places (int, optional): The number of decimal places to use for the output. Defaults to 2. verbose (bool, optional): If True, print the progress. Defaults to True. Returns: object: pandas.DataFrame
Here is the function:
def image_area_by_group(
img,
groups=None,
region=None,
scale=None,
denominator=1.0,
out_csv=None,
labels=None,
decimal_places=4,
verbose=True,
):
"""Calculates the area of each class of an image.
Args:
img (object): ee.Image
groups (object, optional): The groups to use for the area calculation. Defaults to None.
region (object, optional): The region over which to reduce data. Defaults to the footprint of the image's first band.
scale (float, optional): A nominal scale in meters of the projection to work in. Defaults to None.
denominator (float, optional): The denominator to use for converting size from square meters to other units. Defaults to 1.0.
out_csv (str, optional): The path to the output CSV file. Defaults to None.
labels (object, optional): The class labels to use in the output CSV file. Defaults to None.
decimal_places (int, optional): The number of decimal places to use for the output. Defaults to 2.
verbose (bool, optional): If True, print the progress. Defaults to True.
Returns:
object: pandas.DataFrame
"""
import pandas as pd
values = []
if region is None:
region = ee.Geometry.BBox(-179.9, -89.5, 179.9, 89.5)
if groups is None:
groups = image_value_list(img, region, scale)
if not isinstance(groups, list):
groups = groups.getInfo()
groups.sort(key=int)
for group in groups:
if verbose:
print(f"Calculating area for group {group} ...")
area = image_area(img.eq(float(group)), region, scale, denominator)
values.append(area.values().get(0).getInfo())
d = {"group": groups, "area": values}
df = pd.DataFrame(data=d)
df = df.set_index("group")
df["percentage"] = df["area"] / df["area"].sum()
df = df.astype(float).round(decimal_places)
if isinstance(labels, list) and len(labels) == len(values):
df["labels"] = labels
if out_csv is not None:
df.to_csv(out_csv)
else:
return df | Calculates the area of each class of an image. Args: img (object): ee.Image groups (object, optional): The groups to use for the area calculation. Defaults to None. region (object, optional): The region over which to reduce data. Defaults to the footprint of the image's first band. scale (float, optional): A nominal scale in meters of the projection to work in. Defaults to None. denominator (float, optional): The denominator to use for converting size from square meters to other units. Defaults to 1.0. out_csv (str, optional): The path to the output CSV file. Defaults to None. labels (object, optional): The class labels to use in the output CSV file. Defaults to None. decimal_places (int, optional): The number of decimal places to use for the output. Defaults to 2. verbose (bool, optional): If True, print the progress. Defaults to True. Returns: object: pandas.DataFrame |
12,309 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def image_value_list(img, region=None, scale=None, return_hist=False, **kwargs):
"""Get the unique values of an image.
Args:
img (ee.Image): The image to calculate the unique values.
region (ee.Geometry | ee.FeatureCollection, optional): The region over which to reduce data. Defaults to the footprint of the image's first band.
scale (float, optional): A nominal scale in meters of the projection to work in. Defaults to None.
return_hist (bool, optional): If True, return a histogram of the values. Defaults to False.
Returns:
ee.List | ee.Dictionary: A list of unique values or a dictionary containing a list of unique values and a histogram.
"""
if region is None:
geom = img.geometry().bounds()
region = ee.FeatureCollection([ee.Feature(geom)])
elif isinstance(region, ee.Geometry):
region = ee.FeatureCollection([ee.Feature(region)])
elif isinstance(region, ee.FeatureCollection):
pass
else:
raise ValueError("region must be an ee.Geometry or ee.FeatureCollection")
if scale is None:
scale = img.select(0).projection().nominalScale().multiply(10)
reducer = ee.Reducer.frequencyHistogram()
kwargs["scale"] = scale
kwargs["reducer"] = reducer
kwargs["collection"] = region
result = img.reduceRegions(**kwargs)
hist = ee.Dictionary(result.first().get("histogram"))
if return_hist:
return hist
else:
return hist.keys()
The provided code snippet includes necessary dependencies for implementing the `image_histogram` function. Write a Python function `def image_histogram( img, region=None, scale=None, x_label=None, y_label=None, title=None, width=None, height=500, plot_args={}, layout_args={}, return_df=False, **kwargs, )` to solve the following problem:
Create a histogram of an image. Args: img (ee.Image): The image to calculate the histogram. region (ee.Geometry | ee.FeatureCollection, optional): The region over which to reduce data. Defaults to the footprint of the image's first band. scale (float, optional): A nominal scale in meters of the projection to work in. Defaults to None. x_label (str, optional): Label for the x axis. Defaults to None. y_label (str, optional): Label for the y axis. Defaults to None. title (str, optional): Title for the plot. Defaults to None. width (int, optional): Width of the plot in pixels. Defaults to None. height (int, optional): Height of the plot in pixels. Defaults to 500. layout_args (dict, optional): Layout arguments for the plot to be passed to fig.update_layout(), return_df (bool, optional): If True, return a pandas dataframe. Defaults to False. Returns: pandas DataFrame | plotly figure object: A dataframe or plotly figure object.
Here is the function:
def image_histogram(
img,
region=None,
scale=None,
x_label=None,
y_label=None,
title=None,
width=None,
height=500,
plot_args={},
layout_args={},
return_df=False,
**kwargs,
):
"""Create a histogram of an image.
Args:
img (ee.Image): The image to calculate the histogram.
region (ee.Geometry | ee.FeatureCollection, optional): The region over which to reduce data. Defaults to the footprint of the image's first band.
scale (float, optional): A nominal scale in meters of the projection to work in. Defaults to None.
x_label (str, optional): Label for the x axis. Defaults to None.
y_label (str, optional): Label for the y axis. Defaults to None.
title (str, optional): Title for the plot. Defaults to None.
width (int, optional): Width of the plot in pixels. Defaults to None.
height (int, optional): Height of the plot in pixels. Defaults to 500.
layout_args (dict, optional): Layout arguments for the plot to be passed to fig.update_layout(),
return_df (bool, optional): If True, return a pandas dataframe. Defaults to False.
Returns:
pandas DataFrame | plotly figure object: A dataframe or plotly figure object.
"""
import pandas as pd
import plotly.express as px
hist = image_value_list(img, region, scale, return_hist=True, **kwargs).getInfo()
keys = sorted(hist, key=int)
values = [hist.get(key) for key in keys]
data = pd.DataFrame({"key": keys, "value": values})
if return_df:
return data
else:
labels = {}
if x_label is not None:
labels["key"] = x_label
if y_label is not None:
labels["value"] = y_label
try:
fig = px.bar(
data,
x="key",
y="value",
labels=labels,
title=title,
width=width,
height=height,
**plot_args,
)
if isinstance(layout_args, dict):
fig.update_layout(**layout_args)
return fig
except Exception as e:
raise Exception(e) | Create a histogram of an image. Args: img (ee.Image): The image to calculate the histogram. region (ee.Geometry | ee.FeatureCollection, optional): The region over which to reduce data. Defaults to the footprint of the image's first band. scale (float, optional): A nominal scale in meters of the projection to work in. Defaults to None. x_label (str, optional): Label for the x axis. Defaults to None. y_label (str, optional): Label for the y axis. Defaults to None. title (str, optional): Title for the plot. Defaults to None. width (int, optional): Width of the plot in pixels. Defaults to None. height (int, optional): Height of the plot in pixels. Defaults to 500. layout_args (dict, optional): Layout arguments for the plot to be passed to fig.update_layout(), return_df (bool, optional): If True, return a pandas dataframe. Defaults to False. Returns: pandas DataFrame | plotly figure object: A dataframe or plotly figure object. |
12,310 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def image_scale(img):
"""Retrieves the image cell size (e.g., spatial resolution)
Args:
img (object): ee.Image
Returns:
float: The nominal scale in meters.
"""
# bands = img.bandNames()
# scales = bands.map(lambda b: img.select([b]).projection().nominalScale())
# scale = ee.Algorithms.If(scales.distinct().size().gt(1), ee.Dictionary.fromLists(bands.getInfo(), scales), scales.get(0))
return img.select(0).projection().nominalScale()
def image_value_list(img, region=None, scale=None, return_hist=False, **kwargs):
"""Get the unique values of an image.
Args:
img (ee.Image): The image to calculate the unique values.
region (ee.Geometry | ee.FeatureCollection, optional): The region over which to reduce data. Defaults to the footprint of the image's first band.
scale (float, optional): A nominal scale in meters of the projection to work in. Defaults to None.
return_hist (bool, optional): If True, return a histogram of the values. Defaults to False.
Returns:
ee.List | ee.Dictionary: A list of unique values or a dictionary containing a list of unique values and a histogram.
"""
if region is None:
geom = img.geometry().bounds()
region = ee.FeatureCollection([ee.Feature(geom)])
elif isinstance(region, ee.Geometry):
region = ee.FeatureCollection([ee.Feature(region)])
elif isinstance(region, ee.FeatureCollection):
pass
else:
raise ValueError("region must be an ee.Geometry or ee.FeatureCollection")
if scale is None:
scale = img.select(0).projection().nominalScale().multiply(10)
reducer = ee.Reducer.frequencyHistogram()
kwargs["scale"] = scale
kwargs["reducer"] = reducer
kwargs["collection"] = region
result = img.reduceRegions(**kwargs)
hist = ee.Dictionary(result.first().get("histogram"))
if return_hist:
return hist
else:
return hist.keys()
def check_file_path(file_path, make_dirs=True):
"""Gets the absolute file path.
Args:
file_path ([str): The path to the file.
make_dirs (bool, optional): Whether to create the directory if it does not exist. Defaults to True.
Raises:
FileNotFoundError: If the directory could not be found.
TypeError: If the input directory path is not a string.
Returns:
str: The absolute path to the file.
"""
if isinstance(file_path, str):
if file_path.startswith("~"):
file_path = os.path.expanduser(file_path)
else:
file_path = os.path.abspath(file_path)
file_dir = os.path.dirname(file_path)
if not os.path.exists(file_dir) and make_dirs:
os.makedirs(file_dir)
return file_path
else:
raise TypeError("The provided file path must be a string.")
The provided code snippet includes necessary dependencies for implementing the `image_stats_by_zone` function. Write a Python function `def image_stats_by_zone( image, zones, out_csv=None, labels=None, region=None, scale=None, reducer="MEAN", bestEffort=True, **kwargs, )` to solve the following problem:
Calculate statistics for an image by zone. Args: image (ee.Image): The image to calculate statistics for. zones (ee.Image): The zones to calculate statistics for. out_csv (str, optional): The path to the output CSV file. Defaults to None. labels (list, optional): The list of zone labels to use for the output CSV. Defaults to None. region (ee.Geometry, optional): The region over which to reduce data. Defaults to the footprint of zone image. scale (float, optional): A nominal scale in meters of the projection to work in. Defaults to None. reducer (str | ee.Reducer, optional): The reducer to use. It can be one of MEAN, MAXIMUM, MINIMUM, MODE, STD, MIN_MAX, SUM, VARIANCE. Defaults to MEAN. bestEffort (bool, optional): If the polygon would contain too many pixels at the given scale, compute and use a larger scale which would allow the operation to succeed. Defaults to True. Returns: str | pd.DataFrame: The path to the output CSV file or a pandas DataFrame.
Here is the function:
def image_stats_by_zone(
image,
zones,
out_csv=None,
labels=None,
region=None,
scale=None,
reducer="MEAN",
bestEffort=True,
**kwargs,
):
"""Calculate statistics for an image by zone.
Args:
image (ee.Image): The image to calculate statistics for.
zones (ee.Image): The zones to calculate statistics for.
out_csv (str, optional): The path to the output CSV file. Defaults to None.
labels (list, optional): The list of zone labels to use for the output CSV. Defaults to None.
region (ee.Geometry, optional): The region over which to reduce data. Defaults to the footprint of zone image.
scale (float, optional): A nominal scale in meters of the projection to work in. Defaults to None.
reducer (str | ee.Reducer, optional): The reducer to use. It can be one of MEAN, MAXIMUM, MINIMUM, MODE, STD, MIN_MAX, SUM, VARIANCE. Defaults to MEAN.
bestEffort (bool, optional): If the polygon would contain too many pixels at the given scale, compute and use a larger scale which would allow the operation to succeed. Defaults to True.
Returns:
str | pd.DataFrame: The path to the output CSV file or a pandas DataFrame.
"""
import pandas as pd
if region is not None:
if isinstance(region, ee.Geometry):
pass
elif isinstance(region, ee.FeatureCollection):
region = region.geometry()
else:
raise ValueError("region must be an ee.Geometry or ee.FeatureCollection")
if scale is None:
scale = image_scale(image)
allowed_stats = {
"MEAN": ee.Reducer.mean(),
"MAXIMUM": ee.Reducer.max(),
"MEDIAN": ee.Reducer.median(),
"MINIMUM": ee.Reducer.min(),
"MODE": ee.Reducer.mode(),
"STD": ee.Reducer.stdDev(),
"MIN_MAX": ee.Reducer.minMax(),
"SUM": ee.Reducer.sum(),
"VARIANCE": ee.Reducer.variance(),
}
if isinstance(reducer, str):
if reducer.upper() not in allowed_stats:
raise ValueError(
"reducer must be one of: {}".format(", ".join(allowed_stats.keys()))
)
else:
reducer = allowed_stats[reducer.upper()]
elif isinstance(reducer, ee.Reducer):
pass
else:
raise ValueError(
"reducer must be one of: {}".format(", ".join(allowed_stats.keys()))
)
values = image_value_list(zones, region=region)
values = values.map(lambda x: ee.Number.parse(x))
def get_stats(value):
img = image.updateMask(zones.eq(ee.Number(value)))
kwargs["reducer"] = reducer
kwargs["scale"] = scale
kwargs["geometry"] = region
kwargs["bestEffort"] = bestEffort
stat = img.reduceRegion(**kwargs)
return ee.Image().set({"zone": value}).set({"stat": stat.values().get(0)})
collection = ee.ImageCollection(values.map(lambda x: get_stats(x)))
keys = collection.aggregate_array("zone").getInfo()
values = collection.aggregate_array("stat").getInfo()
if labels is not None and isinstance(labels, list):
if len(labels) != len(keys):
warnings.warn("labels are not the same length as keys, ignoring labels.")
df = pd.DataFrame({"zone": keys, "stat": values})
else:
df = pd.DataFrame({"zone": keys, "label": labels, "stat": values})
else:
df = pd.DataFrame({"zone": keys, "stat": values})
if out_csv is not None:
check_file_path(out_csv)
df.to_csv(out_csv, index=False)
return out_csv
else:
return df | Calculate statistics for an image by zone. Args: image (ee.Image): The image to calculate statistics for. zones (ee.Image): The zones to calculate statistics for. out_csv (str, optional): The path to the output CSV file. Defaults to None. labels (list, optional): The list of zone labels to use for the output CSV. Defaults to None. region (ee.Geometry, optional): The region over which to reduce data. Defaults to the footprint of zone image. scale (float, optional): A nominal scale in meters of the projection to work in. Defaults to None. reducer (str | ee.Reducer, optional): The reducer to use. It can be one of MEAN, MAXIMUM, MINIMUM, MODE, STD, MIN_MAX, SUM, VARIANCE. Defaults to MEAN. bestEffort (bool, optional): If the polygon would contain too many pixels at the given scale, compute and use a larger scale which would allow the operation to succeed. Defaults to True. Returns: str | pd.DataFrame: The path to the output CSV file or a pandas DataFrame. |
12,311 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `latitude_grid` function. Write a Python function `def latitude_grid(step=1.0, west=-180, east=180, south=-85, north=85)` to solve the following problem:
Create a latitude grid. Args: step (float, optional): The step size in degrees. Defaults to 1.0. west (int, optional): The west boundary in degrees. Defaults to -180. east (int, optional): The east boundary in degrees. Defaults to 180. south (int, optional): The south boundary in degrees. Defaults to -85. north (int, optional): The north boundary in degrees. Defaults to 85. Returns: ee.FeatureCollection: A feature collection of latitude grids.
Here is the function:
def latitude_grid(step=1.0, west=-180, east=180, south=-85, north=85):
"""Create a latitude grid.
Args:
step (float, optional): The step size in degrees. Defaults to 1.0.
west (int, optional): The west boundary in degrees. Defaults to -180.
east (int, optional): The east boundary in degrees. Defaults to 180.
south (int, optional): The south boundary in degrees. Defaults to -85.
north (int, optional): The north boundary in degrees. Defaults to 85.
Returns:
ee.FeatureCollection: A feature collection of latitude grids.
"""
values = ee.List.sequence(south, north - step, step)
def create_feature(lat):
return ee.Feature(
ee.Geometry.BBox(west, lat, east, ee.Number(lat).add(step))
).set(
{
"south": lat,
"west": west,
"north": ee.Number(lat).add(step),
"east": east,
}
)
features = ee.FeatureCollection(values.map(create_feature))
return features | Create a latitude grid. Args: step (float, optional): The step size in degrees. Defaults to 1.0. west (int, optional): The west boundary in degrees. Defaults to -180. east (int, optional): The east boundary in degrees. Defaults to 180. south (int, optional): The south boundary in degrees. Defaults to -85. north (int, optional): The north boundary in degrees. Defaults to 85. Returns: ee.FeatureCollection: A feature collection of latitude grids. |
12,312 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `longitude_grid` function. Write a Python function `def longitude_grid(step=1.0, west=-180, east=180, south=-85, north=85)` to solve the following problem:
Create a longitude grid. Args: step (float, optional): The step size in degrees. Defaults to 1.0. west (int, optional): The west boundary in degrees. Defaults to -180. east (int, optional): The east boundary in degrees. Defaults to 180. south (int, optional): The south boundary in degrees. Defaults to -85. north (int, optional): The north boundary in degrees. Defaults to 85. Returns: ee.FeatureCollection: A feature collection of longitude grids.
Here is the function:
def longitude_grid(step=1.0, west=-180, east=180, south=-85, north=85):
"""Create a longitude grid.
Args:
step (float, optional): The step size in degrees. Defaults to 1.0.
west (int, optional): The west boundary in degrees. Defaults to -180.
east (int, optional): The east boundary in degrees. Defaults to 180.
south (int, optional): The south boundary in degrees. Defaults to -85.
north (int, optional): The north boundary in degrees. Defaults to 85.
Returns:
ee.FeatureCollection: A feature collection of longitude grids.
"""
values = ee.List.sequence(west, east - step, step)
def create_feature(lon):
return ee.Feature(
ee.Geometry.BBox(lon, south, ee.Number(lon).add(step), north)
).set(
{
"south": south,
"west": lon,
"north": north,
"east": ee.Number(lon).add(step),
}
)
features = ee.FeatureCollection(values.map(create_feature))
return features | Create a longitude grid. Args: step (float, optional): The step size in degrees. Defaults to 1.0. west (int, optional): The west boundary in degrees. Defaults to -180. east (int, optional): The east boundary in degrees. Defaults to 180. south (int, optional): The south boundary in degrees. Defaults to -85. north (int, optional): The north boundary in degrees. Defaults to 85. Returns: ee.FeatureCollection: A feature collection of longitude grids. |
12,313 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def ee_export_vector(
ee_object,
filename,
selectors=None,
verbose=True,
keep_zip=False,
timeout=300,
proxies=None,
):
"""Exports Earth Engine FeatureCollection to other formats, including shp, csv, json, kml, and kmz.
Args:
ee_object (object): ee.FeatureCollection to export.
filename (str): Output file name.
selectors (list, optional): A list of attributes to export. Defaults to None.
verbose (bool, optional): Whether to print out descriptive text.
keep_zip (bool, optional): Whether to keep the downloaded shapefile as a zip file.
timeout (int, optional): Timeout in seconds. Defaults to 300 seconds.
proxies (dict, optional): A dictionary of proxies to use. Defaults to None.
"""
if not isinstance(ee_object, ee.FeatureCollection):
raise ValueError("ee_object must be an ee.FeatureCollection")
allowed_formats = ["csv", "geojson", "json", "kml", "kmz", "shp"]
# allowed_formats = ['csv', 'kml', 'kmz']
filename = os.path.abspath(filename)
basename = os.path.basename(filename)
name = os.path.splitext(basename)[0]
filetype = os.path.splitext(basename)[1][1:].lower()
if filetype == "shp":
filename = filename.replace(".shp", ".zip")
if not (filetype.lower() in allowed_formats):
raise ValueError(
"The file type must be one of the following: {}".format(
", ".join(allowed_formats)
)
)
if selectors is None:
selectors = ee_object.first().propertyNames().getInfo()
if filetype == "csv":
# remove .geo coordinate field
ee_object = ee_object.select([".*"], None, False)
if filetype == "geojson":
selectors = [".geo"] + selectors
elif not isinstance(selectors, list):
raise ValueError(
"selectors must be a list, such as ['attribute1', 'attribute2']"
)
else:
allowed_attributes = ee_object.first().propertyNames().getInfo()
for attribute in selectors:
if not (attribute in allowed_attributes):
raise ValueError(
"Attributes must be one chosen from: {} ".format(
", ".join(allowed_attributes)
)
)
try:
if verbose:
print("Generating URL ...")
url = ee_object.getDownloadURL(
filetype=filetype, selectors=selectors, filename=name
)
if verbose:
print(f"Downloading data from {url}\nPlease wait ...")
r = None
r = requests.get(url, stream=True, timeout=timeout, proxies=proxies)
if r.status_code != 200:
print("An error occurred while downloading. \n Retrying ...")
try:
new_ee_object = ee_object.map(filter_polygons)
print("Generating URL ...")
url = new_ee_object.getDownloadURL(
filetype=filetype, selectors=selectors, filename=name
)
print(f"Downloading data from {url}\nPlease wait ...")
r = requests.get(url, stream=True, timeout=timeout, proxies=proxies)
except Exception as e:
print(e)
raise ValueError
with open(filename, "wb") as fd:
for chunk in r.iter_content(chunk_size=1024):
fd.write(chunk)
except Exception as e:
print("An error occurred while downloading.")
if r is not None:
print(r.json()["error"]["message"])
raise ValueError(e)
try:
if filetype == "shp":
with zipfile.ZipFile(filename) as z:
z.extractall(os.path.dirname(filename))
if not keep_zip:
os.remove(filename)
filename = filename.replace(".zip", ".shp")
if verbose:
print(f"Data downloaded to {filename}")
except Exception as e:
raise ValueError(e)
def latlon_grid(lat_step=1.0, lon_step=1.0, west=-180, east=180, south=-85, north=85):
"""Create a rectangular grid of latitude and longitude.
Args:
lat_step (float, optional): The step size in degrees. Defaults to 1.0.
lon_step (float, optional): The step size in degrees. Defaults to 1.0.
west (int, optional): The west boundary in degrees. Defaults to -180.
east (int, optional): The east boundary in degrees. Defaults to 180.
south (int, optional): The south boundary in degrees. Defaults to -85.
north (int, optional): The north boundary in degrees. Defaults to 85.
Returns:
ee.FeatureCollection: A feature collection of latitude and longitude grids.
"""
longitudes = ee.List.sequence(west, east - lon_step, lon_step)
latitudes = ee.List.sequence(south, north - lat_step, lat_step)
def create_lat_feature(lat):
def create_lon_features(lon):
return ee.Feature(
ee.Geometry.BBox(
lon, lat, ee.Number(lon).add(lon_step), ee.Number(lat).add(lat_step)
)
).set(
{
"south": lat,
"west": lon,
"north": ee.Number(lat).add(lat_step),
"east": ee.Number(lon).add(lon_step),
}
)
return ee.FeatureCollection(longitudes.map(create_lon_features))
return ee.FeatureCollection(latitudes.map(create_lat_feature)).flatten()
def vector_to_ee(
filename,
bbox=None,
mask=None,
rows=None,
geodesic=True,
**kwargs,
):
"""Converts any geopandas-supported vector dataset to ee.FeatureCollection.
Args:
filename (str): Either the absolute or relative path to the file or URL to be opened, or any object with a read() method (such as an open file or StringIO).
bbox (tuple | GeoDataFrame or GeoSeries | shapely Geometry, optional): Filter features by given bounding box, GeoSeries, GeoDataFrame or a shapely geometry. CRS mis-matches are resolved if given a GeoSeries or GeoDataFrame. Cannot be used with mask. Defaults to None.
mask (dict | GeoDataFrame or GeoSeries | shapely Geometry, optional): Filter for features that intersect with the given dict-like geojson geometry, GeoSeries, GeoDataFrame or shapely geometry. CRS mis-matches are resolved if given a GeoSeries or GeoDataFrame. Cannot be used with bbox. Defaults to None.
rows (int or slice, optional): Load in specific rows by passing an integer (first n rows) or a slice() object.. Defaults to None.
geodesic (bool, optional): Whether line segments should be interpreted as spherical geodesics. If false, indicates that line segments should be interpreted as planar lines in the specified CRS. If absent, defaults to true if the CRS is geographic (including the default EPSG:4326), or to false if the CRS is projected.
Returns:
ee.FeatureCollection: Earth Engine FeatureCollection.
"""
geojson = vector_to_geojson(
filename, bbox=bbox, mask=mask, rows=rows, epsg="4326", **kwargs
)
return geojson_to_ee(geojson, geodesic=geodesic)
The provided code snippet includes necessary dependencies for implementing the `fishnet` function. Write a Python function `def fishnet( data, h_interval=1.0, v_interval=1.0, rows=None, cols=None, delta=1.0, intersect=True, output=None, **kwargs, )` to solve the following problem:
Create a fishnet (i.e., rectangular grid) based on an input vector dataset. Args: data (str | ee.Geometry | ee.Feature | ee.FeatureCollection): The input vector dataset. It can be a file path, HTTP URL, ee.Geometry, ee.Feature, or ee.FeatureCollection. h_interval (float, optional): The horizontal interval in degrees. It will be ignored if rows and cols are specified. Defaults to 1.0. v_interval (float, optional): The vertical interval in degrees. It will be ignored if rows and cols are specified. Defaults to 1.0. rows (int, optional): The number of rows. Defaults to None. cols (int, optional): The number of columns. Defaults to None. delta (float, optional): The buffer distance in degrees. Defaults to 1.0. intersect (bool, optional): If True, the output will be a feature collection of intersecting polygons. Defaults to True. output (str, optional): The output file path. Defaults to None. Returns: ee.FeatureCollection: The fishnet as an ee.FeatureCollection.
Here is the function:
def fishnet(
data,
h_interval=1.0,
v_interval=1.0,
rows=None,
cols=None,
delta=1.0,
intersect=True,
output=None,
**kwargs,
):
"""Create a fishnet (i.e., rectangular grid) based on an input vector dataset.
Args:
data (str | ee.Geometry | ee.Feature | ee.FeatureCollection): The input vector dataset. It can be a file path, HTTP URL, ee.Geometry, ee.Feature, or ee.FeatureCollection.
h_interval (float, optional): The horizontal interval in degrees. It will be ignored if rows and cols are specified. Defaults to 1.0.
v_interval (float, optional): The vertical interval in degrees. It will be ignored if rows and cols are specified. Defaults to 1.0.
rows (int, optional): The number of rows. Defaults to None.
cols (int, optional): The number of columns. Defaults to None.
delta (float, optional): The buffer distance in degrees. Defaults to 1.0.
intersect (bool, optional): If True, the output will be a feature collection of intersecting polygons. Defaults to True.
output (str, optional): The output file path. Defaults to None.
Returns:
ee.FeatureCollection: The fishnet as an ee.FeatureCollection.
"""
if isinstance(data, str):
data = vector_to_ee(data, **kwargs)
if isinstance(data, ee.FeatureCollection) or isinstance(data, ee.Feature):
data = data.geometry()
elif isinstance(data, ee.Geometry):
pass
else:
raise ValueError(
"data must be a string, ee.FeatureCollection, ee.Feature, or ee.Geometry."
)
coords = data.bounds().coordinates().getInfo()
west = coords[0][0][0]
east = coords[0][1][0]
south = coords[0][0][1]
north = coords[0][2][1]
if rows is not None and cols is not None:
v_interval = (north - south) / rows
h_interval = (east - west) / cols
# west = west - delta * h_interval
east = east + delta * h_interval
# south = south - delta * v_interval
north = north + delta * v_interval
grids = latlon_grid(v_interval, h_interval, west, east, south, north)
if intersect:
grids = grids.filterBounds(data)
if output is not None:
ee_export_vector(grids, output)
else:
return grids | Create a fishnet (i.e., rectangular grid) based on an input vector dataset. Args: data (str | ee.Geometry | ee.Feature | ee.FeatureCollection): The input vector dataset. It can be a file path, HTTP URL, ee.Geometry, ee.Feature, or ee.FeatureCollection. h_interval (float, optional): The horizontal interval in degrees. It will be ignored if rows and cols are specified. Defaults to 1.0. v_interval (float, optional): The vertical interval in degrees. It will be ignored if rows and cols are specified. Defaults to 1.0. rows (int, optional): The number of rows. Defaults to None. cols (int, optional): The number of columns. Defaults to None. delta (float, optional): The buffer distance in degrees. Defaults to 1.0. intersect (bool, optional): If True, the output will be a feature collection of intersecting polygons. Defaults to True. output (str, optional): The output file path. Defaults to None. Returns: ee.FeatureCollection: The fishnet as an ee.FeatureCollection. |
12,314 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def ee_export_vector(
ee_object,
filename,
selectors=None,
verbose=True,
keep_zip=False,
timeout=300,
proxies=None,
):
"""Exports Earth Engine FeatureCollection to other formats, including shp, csv, json, kml, and kmz.
Args:
ee_object (object): ee.FeatureCollection to export.
filename (str): Output file name.
selectors (list, optional): A list of attributes to export. Defaults to None.
verbose (bool, optional): Whether to print out descriptive text.
keep_zip (bool, optional): Whether to keep the downloaded shapefile as a zip file.
timeout (int, optional): Timeout in seconds. Defaults to 300 seconds.
proxies (dict, optional): A dictionary of proxies to use. Defaults to None.
"""
if not isinstance(ee_object, ee.FeatureCollection):
raise ValueError("ee_object must be an ee.FeatureCollection")
allowed_formats = ["csv", "geojson", "json", "kml", "kmz", "shp"]
# allowed_formats = ['csv', 'kml', 'kmz']
filename = os.path.abspath(filename)
basename = os.path.basename(filename)
name = os.path.splitext(basename)[0]
filetype = os.path.splitext(basename)[1][1:].lower()
if filetype == "shp":
filename = filename.replace(".shp", ".zip")
if not (filetype.lower() in allowed_formats):
raise ValueError(
"The file type must be one of the following: {}".format(
", ".join(allowed_formats)
)
)
if selectors is None:
selectors = ee_object.first().propertyNames().getInfo()
if filetype == "csv":
# remove .geo coordinate field
ee_object = ee_object.select([".*"], None, False)
if filetype == "geojson":
selectors = [".geo"] + selectors
elif not isinstance(selectors, list):
raise ValueError(
"selectors must be a list, such as ['attribute1', 'attribute2']"
)
else:
allowed_attributes = ee_object.first().propertyNames().getInfo()
for attribute in selectors:
if not (attribute in allowed_attributes):
raise ValueError(
"Attributes must be one chosen from: {} ".format(
", ".join(allowed_attributes)
)
)
try:
if verbose:
print("Generating URL ...")
url = ee_object.getDownloadURL(
filetype=filetype, selectors=selectors, filename=name
)
if verbose:
print(f"Downloading data from {url}\nPlease wait ...")
r = None
r = requests.get(url, stream=True, timeout=timeout, proxies=proxies)
if r.status_code != 200:
print("An error occurred while downloading. \n Retrying ...")
try:
new_ee_object = ee_object.map(filter_polygons)
print("Generating URL ...")
url = new_ee_object.getDownloadURL(
filetype=filetype, selectors=selectors, filename=name
)
print(f"Downloading data from {url}\nPlease wait ...")
r = requests.get(url, stream=True, timeout=timeout, proxies=proxies)
except Exception as e:
print(e)
raise ValueError
with open(filename, "wb") as fd:
for chunk in r.iter_content(chunk_size=1024):
fd.write(chunk)
except Exception as e:
print("An error occurred while downloading.")
if r is not None:
print(r.json()["error"]["message"])
raise ValueError(e)
try:
if filetype == "shp":
with zipfile.ZipFile(filename) as z:
z.extractall(os.path.dirname(filename))
if not keep_zip:
os.remove(filename)
filename = filename.replace(".zip", ".shp")
if verbose:
print(f"Data downloaded to {filename}")
except Exception as e:
raise ValueError(e)
def shp_to_ee(in_shp, **kwargs):
"""Converts a shapefile to Earth Engine objects. Note that the CRS of the shapefile must be EPSG:4326
Args:
in_shp (str): File path to a shapefile.
Returns:
object: Earth Engine objects representing the shapefile.
"""
# ee_initialize()
try:
if "encoding" in kwargs:
json_data = shp_to_geojson(in_shp, encoding=kwargs.pop("encoding"))
else:
json_data = shp_to_geojson(in_shp)
ee_object = geojson_to_ee(json_data)
return ee_object
except Exception as e:
print(e)
The provided code snippet includes necessary dependencies for implementing the `extract_values_to_points` function. Write a Python function `def extract_values_to_points( in_fc, image, out_fc=None, scale=None, crs=None, crsTransform=None, tileScale=1, stats_type="FIRST", timeout=300, proxies=None, **kwargs, )` to solve the following problem:
Extracts image values to points. Args: in_fc (object): ee.FeatureCollection. image (object): The ee.Image to extract pixel values. out_fc (object, optional): The output feature collection. Defaults to None. scale (ee.Projectoin, optional): A nominal scale in meters of the projection to sample in. If unspecified,the scale of the image's first band is used. crs (str, optional): The projection to work in. If unspecified, the projection of the image's first band is used. If specified in addition to scale, rescaled to the specified scale. Defaults to None. crsTransform (list, optional): The list of CRS transform values. This is a row-major ordering of the 3x2 transform matrix. This option is mutually exclusive with 'scale', and will replace any transform already set on the projection. tile_scale (float, optional): A scaling factor used to reduce aggregation tile size; using a larger tileScale (e.g. 2 or 4) may enable computations that run out of memory with the default. stats_type (str, optional): Statistic type to be calculated. Defaults to 'FIRST'. timeout (int, optional): The number of seconds after which the request will be terminated. Defaults to 300. proxies (dict, optional): A dictionary of proxy servers to use for each request. Defaults to None. Returns: object: ee.FeatureCollection
Here is the function:
def extract_values_to_points(
in_fc,
image,
out_fc=None,
scale=None,
crs=None,
crsTransform=None,
tileScale=1,
stats_type="FIRST",
timeout=300,
proxies=None,
**kwargs,
):
"""Extracts image values to points.
Args:
in_fc (object): ee.FeatureCollection.
image (object): The ee.Image to extract pixel values.
out_fc (object, optional): The output feature collection. Defaults to None.
scale (ee.Projectoin, optional): A nominal scale in meters of the projection to sample in. If unspecified,the scale of the image's first band is used.
crs (str, optional): The projection to work in. If unspecified, the projection of the image's first band is used. If specified in addition to scale, rescaled to the specified scale. Defaults to None.
crsTransform (list, optional): The list of CRS transform values. This is a row-major ordering of the 3x2 transform matrix. This option is mutually exclusive with 'scale', and will replace any transform already set on the projection.
tile_scale (float, optional): A scaling factor used to reduce aggregation tile size; using a larger tileScale (e.g. 2 or 4) may enable computations that run out of memory with the default.
stats_type (str, optional): Statistic type to be calculated. Defaults to 'FIRST'.
timeout (int, optional): The number of seconds after which the request will be terminated. Defaults to 300.
proxies (dict, optional): A dictionary of proxy servers to use for each request. Defaults to None.
Returns:
object: ee.FeatureCollection
"""
if "tile_scale" in kwargs:
tileScale = kwargs["tile_scale"]
if "crs_transform" in kwargs:
crsTransform = kwargs["crs_transform"]
allowed_stats = {
"FIRST": ee.Reducer.first(),
"MEAN": ee.Reducer.mean(),
"MAXIMUM": ee.Reducer.max(),
"MEDIAN": ee.Reducer.median(),
"MINIMUM": ee.Reducer.min(),
"STD": ee.Reducer.stdDev(),
"MIN_MAX": ee.Reducer.minMax(),
"SUM": ee.Reducer.sum(),
"VARIANCE": ee.Reducer.variance(),
}
if stats_type.upper() not in allowed_stats:
raise ValueError(
f"The statistics_type must be one of the following {', '.join(allowed_stats.keys())}"
)
if not isinstance(in_fc, ee.FeatureCollection):
try:
in_fc = shp_to_ee(in_fc)
except Exception as e:
print(e)
return
if not isinstance(image, ee.Image):
print("The image must be an instance of ee.Image.")
return
result = image.reduceRegions(
collection=in_fc,
reducer=allowed_stats[stats_type.upper()],
scale=scale,
crs=crs,
crsTransform=crsTransform,
tileScale=tileScale,
)
if out_fc is not None:
ee_export_vector(result, out_fc, timeout=timeout, proxies=proxies)
else:
return result | Extracts image values to points. Args: in_fc (object): ee.FeatureCollection. image (object): The ee.Image to extract pixel values. out_fc (object, optional): The output feature collection. Defaults to None. scale (ee.Projectoin, optional): A nominal scale in meters of the projection to sample in. If unspecified,the scale of the image's first band is used. crs (str, optional): The projection to work in. If unspecified, the projection of the image's first band is used. If specified in addition to scale, rescaled to the specified scale. Defaults to None. crsTransform (list, optional): The list of CRS transform values. This is a row-major ordering of the 3x2 transform matrix. This option is mutually exclusive with 'scale', and will replace any transform already set on the projection. tile_scale (float, optional): A scaling factor used to reduce aggregation tile size; using a larger tileScale (e.g. 2 or 4) may enable computations that run out of memory with the default. stats_type (str, optional): Statistic type to be calculated. Defaults to 'FIRST'. timeout (int, optional): The number of seconds after which the request will be terminated. Defaults to 300. proxies (dict, optional): A dictionary of proxy servers to use for each request. Defaults to None. Returns: object: ee.FeatureCollection |
12,315 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `image_reclassify` function. Write a Python function `def image_reclassify(img, in_list, out_list)` to solve the following problem:
Reclassify an image. Args: img (object): The image to which the remapping is applied. in_list (list): The source values (numbers or EEArrays). All values in this list will be mapped to the corresponding value in 'out_list'. out_list (list): The destination values (numbers or EEArrays). These are used to replace the corresponding values in 'from'. Must have the same number of values as 'in_list'. Returns: object: ee.Image
Here is the function:
def image_reclassify(img, in_list, out_list):
"""Reclassify an image.
Args:
img (object): The image to which the remapping is applied.
in_list (list): The source values (numbers or EEArrays). All values in this list will be mapped to the corresponding value in 'out_list'.
out_list (list): The destination values (numbers or EEArrays). These are used to replace the corresponding values in 'from'. Must have the same number of values as 'in_list'.
Returns:
object: ee.Image
"""
image = img.remap(in_list, out_list)
return image | Reclassify an image. Args: img (object): The image to which the remapping is applied. in_list (list): The source values (numbers or EEArrays). All values in this list will be mapped to the corresponding value in 'out_list'. out_list (list): The destination values (numbers or EEArrays). These are used to replace the corresponding values in 'from'. Must have the same number of values as 'in_list'. Returns: object: ee.Image |
12,316 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `image_smoothing` function. Write a Python function `def image_smoothing(img, reducer, kernel)` to solve the following problem:
Smooths an image. Args: img (object): The image to be smoothed. reducer (object): ee.Reducer kernel (object): ee.Kernel Returns: object: ee.Image
Here is the function:
def image_smoothing(img, reducer, kernel):
"""Smooths an image.
Args:
img (object): The image to be smoothed.
reducer (object): ee.Reducer
kernel (object): ee.Kernel
Returns:
object: ee.Image
"""
image = img.reduceNeighborhood(
**{
"reducer": reducer,
"kernel": kernel,
}
)
return image | Smooths an image. Args: img (object): The image to be smoothed. reducer (object): ee.Reducer kernel (object): ee.Kernel Returns: object: ee.Image |
12,317 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `rename_bands` function. Write a Python function `def rename_bands(img, in_band_names, out_band_names)` to solve the following problem:
Renames image bands. Args: img (object): The image to be renamed. in_band_names (list): The list of input band names. out_band_names (list): The list of output band names. Returns: object: The output image with the renamed bands.
Here is the function:
def rename_bands(img, in_band_names, out_band_names):
"""Renames image bands.
Args:
img (object): The image to be renamed.
in_band_names (list): The list of input band names.
out_band_names (list): The list of output band names.
Returns:
object: The output image with the renamed bands.
"""
return img.select(in_band_names, out_band_names) | Renames image bands. Args: img (object): The image to be renamed. in_band_names (list): The list of input band names. out_band_names (list): The list of output band names. Returns: object: The output image with the renamed bands. |
12,318 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `bands_to_image_collection` function. Write a Python function `def bands_to_image_collection(img)` to solve the following problem:
Converts all bands in an image to an image collection. Args: img (object): The image to convert. Returns: object: ee.ImageCollection
Here is the function:
def bands_to_image_collection(img):
"""Converts all bands in an image to an image collection.
Args:
img (object): The image to convert.
Returns:
object: ee.ImageCollection
"""
collection = ee.ImageCollection(img.bandNames().map(lambda b: img.select([b])))
return collection | Converts all bands in an image to an image collection. Args: img (object): The image to convert. Returns: object: ee.ImageCollection |
12,319 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `find_landsat_by_path_row` function. Write a Python function `def find_landsat_by_path_row(landsat_col, path_num, row_num)` to solve the following problem:
Finds Landsat images by WRS path number and row number. Args: landsat_col (str): The image collection id of Landsat. path_num (int): The WRS path number. row_num (int): the WRS row number. Returns: object: ee.ImageCollection
Here is the function:
def find_landsat_by_path_row(landsat_col, path_num, row_num):
"""Finds Landsat images by WRS path number and row number.
Args:
landsat_col (str): The image collection id of Landsat.
path_num (int): The WRS path number.
row_num (int): the WRS row number.
Returns:
object: ee.ImageCollection
"""
try:
if isinstance(landsat_col, str):
landsat_col = ee.ImageCollection(landsat_col)
collection = landsat_col.filter(ee.Filter.eq("WRS_PATH", path_num)).filter(
ee.Filter.eq("WRS_ROW", row_num)
)
return collection
except Exception as e:
print(e) | Finds Landsat images by WRS path number and row number. Args: landsat_col (str): The image collection id of Landsat. path_num (int): The WRS path number. row_num (int): the WRS row number. Returns: object: ee.ImageCollection |
12,320 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `str_to_num` function. Write a Python function `def str_to_num(in_str)` to solve the following problem:
Converts a string to an ee.Number. Args: in_str (str): The string to convert to a number. Returns: object: ee.Number
Here is the function:
def str_to_num(in_str):
"""Converts a string to an ee.Number.
Args:
in_str (str): The string to convert to a number.
Returns:
object: ee.Number
"""
return ee.Number.parse(str) | Converts a string to an ee.Number. Args: in_str (str): The string to convert to a number. Returns: object: ee.Number |
12,321 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `array_sum` function. Write a Python function `def array_sum(arr)` to solve the following problem:
Accumulates elements of an array along the given axis. Args: arr (object): Array to accumulate. Returns: object: ee.Number
Here is the function:
def array_sum(arr):
"""Accumulates elements of an array along the given axis.
Args:
arr (object): Array to accumulate.
Returns:
object: ee.Number
"""
return ee.Array(arr).accum(0).get([-1]) | Accumulates elements of an array along the given axis. Args: arr (object): Array to accumulate. Returns: object: ee.Number |
12,322 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `array_mean` function. Write a Python function `def array_mean(arr)` to solve the following problem:
Calculates the mean of an array along the given axis. Args: arr (object): Array to calculate mean. Returns: object: ee.Number
Here is the function:
def array_mean(arr):
"""Calculates the mean of an array along the given axis.
Args:
arr (object): Array to calculate mean.
Returns:
object: ee.Number
"""
total = ee.Array(arr).accum(0).get([-1])
size = arr.length()
return ee.Number(total.divide(size)) | Calculates the mean of an array along the given axis. Args: arr (object): Array to calculate mean. Returns: object: ee.Number |
12,323 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def get_annual_NAIP(year, RGBN=True):
"""Filters NAIP ImageCollection by year.
Args:
year (int): The year to filter the NAIP ImageCollection.
RGBN (bool, optional): Whether to retrieve 4-band NAIP imagery only. Defaults to True.
Returns:
object: ee.ImageCollection
"""
try:
collection = ee.ImageCollection("USDA/NAIP/DOQQ")
start_date = str(year) + "-01-01"
end_date = str(year) + "-12-31"
naip = collection.filterDate(start_date, end_date)
if RGBN:
naip = naip.filter(ee.Filter.listContains("system:band_names", "N"))
return naip
except Exception as e:
print(e)
The provided code snippet includes necessary dependencies for implementing the `get_all_NAIP` function. Write a Python function `def get_all_NAIP(start_year=2009, end_year=2019)` to solve the following problem:
Creates annual NAIP imagery mosaic. Args: start_year (int, optional): The starting year. Defaults to 2009. end_year (int, optional): The ending year. Defaults to 2019. Returns: object: ee.ImageCollection
Here is the function:
def get_all_NAIP(start_year=2009, end_year=2019):
"""Creates annual NAIP imagery mosaic.
Args:
start_year (int, optional): The starting year. Defaults to 2009.
end_year (int, optional): The ending year. Defaults to 2019.
Returns:
object: ee.ImageCollection
"""
try:
def get_annual_NAIP(year):
try:
collection = ee.ImageCollection("USDA/NAIP/DOQQ")
start_date = ee.Date.fromYMD(year, 1, 1)
end_date = ee.Date.fromYMD(year, 12, 31)
naip = collection.filterDate(start_date, end_date).filter(
ee.Filter.listContains("system:band_names", "N")
)
return ee.ImageCollection(naip)
except Exception as e:
print(e)
years = ee.List.sequence(start_year, end_year)
collection = years.map(get_annual_NAIP)
return collection
except Exception as e:
print(e) | Creates annual NAIP imagery mosaic. Args: start_year (int, optional): The starting year. Defaults to 2009. end_year (int, optional): The ending year. Defaults to 2019. Returns: object: ee.ImageCollection |
12,324 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def mosaic(images, output, merge_args={}, verbose=True, **kwargs):
"""Mosaics a list of images into a single image. Inspired by https://bit.ly/3A6roDK.
Args:
images (str | list): An input directory containing images or a list of images.
output (str): The output image filepath.
merge_args (dict, optional): A dictionary of arguments to pass to the rasterio.merge function. Defaults to {}.
verbose (bool, optional): Whether to print progress. Defaults to True.
"""
from rasterio.merge import merge
import rasterio as rio
from pathlib import Path
output = os.path.abspath(output)
if isinstance(images, str):
path = Path(images)
raster_files = list(path.iterdir())
elif isinstance(images, list):
raster_files = images
else:
raise ValueError("images must be a list of raster files.")
raster_to_mosiac = []
if not os.path.exists(os.path.dirname(output)):
os.makedirs(os.path.dirname(output))
for index, p in enumerate(raster_files):
if verbose:
print(f"Reading {index+1}/{len(raster_files)}: {os.path.basename(p)}")
raster = rio.open(p, **kwargs)
raster_to_mosiac.append(raster)
if verbose:
print("Merging rasters...")
arr, transform = merge(raster_to_mosiac, **merge_args)
output_meta = raster.meta.copy()
output_meta.update(
{
"driver": "GTiff",
"height": arr.shape[1],
"width": arr.shape[2],
"transform": transform,
}
)
with rio.open(output, "w", **output_meta) as m:
m.write(arr)
The provided code snippet includes necessary dependencies for implementing the `annual_NAIP` function. Write a Python function `def annual_NAIP(year, region)` to solve the following problem:
Create an NAIP mosaic of a specified year for a specified region. Args: year (int): The specified year to create the mosaic for. region (object): ee.Geometry Returns: object: ee.Image
Here is the function:
def annual_NAIP(year, region):
"""Create an NAIP mosaic of a specified year for a specified region.
Args:
year (int): The specified year to create the mosaic for.
region (object): ee.Geometry
Returns:
object: ee.Image
"""
start_date = ee.Date.fromYMD(year, 1, 1)
end_date = ee.Date.fromYMD(year, 12, 31)
collection = (
ee.ImageCollection("USDA/NAIP/DOQQ")
.filterDate(start_date, end_date)
.filterBounds(region)
)
time_start = ee.Date(
ee.List(collection.aggregate_array("system:time_start")).sort().get(0)
)
time_end = ee.Date(
ee.List(collection.aggregate_array("system:time_end")).sort().get(-1)
)
image = ee.Image(collection.mosaic().clip(region))
NDWI = ee.Image(image).normalizedDifference(["G", "N"]).select(["nd"], ["ndwi"])
NDVI = ee.Image(image).normalizedDifference(["N", "R"]).select(["nd"], ["ndvi"])
image = image.addBands(NDWI)
image = image.addBands(NDVI)
return image.set({"system:time_start": time_start, "system:time_end": time_end}) | Create an NAIP mosaic of a specified year for a specified region. Args: year (int): The specified year to create the mosaic for. region (object): ee.Geometry Returns: object: ee.Image |
12,325 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def mosaic(images, output, merge_args={}, verbose=True, **kwargs):
"""Mosaics a list of images into a single image. Inspired by https://bit.ly/3A6roDK.
Args:
images (str | list): An input directory containing images or a list of images.
output (str): The output image filepath.
merge_args (dict, optional): A dictionary of arguments to pass to the rasterio.merge function. Defaults to {}.
verbose (bool, optional): Whether to print progress. Defaults to True.
"""
from rasterio.merge import merge
import rasterio as rio
from pathlib import Path
output = os.path.abspath(output)
if isinstance(images, str):
path = Path(images)
raster_files = list(path.iterdir())
elif isinstance(images, list):
raster_files = images
else:
raise ValueError("images must be a list of raster files.")
raster_to_mosiac = []
if not os.path.exists(os.path.dirname(output)):
os.makedirs(os.path.dirname(output))
for index, p in enumerate(raster_files):
if verbose:
print(f"Reading {index+1}/{len(raster_files)}: {os.path.basename(p)}")
raster = rio.open(p, **kwargs)
raster_to_mosiac.append(raster)
if verbose:
print("Merging rasters...")
arr, transform = merge(raster_to_mosiac, **merge_args)
output_meta = raster.meta.copy()
output_meta.update(
{
"driver": "GTiff",
"height": arr.shape[1],
"width": arr.shape[2],
"transform": transform,
}
)
with rio.open(output, "w", **output_meta) as m:
m.write(arr)
The provided code snippet includes necessary dependencies for implementing the `find_NAIP` function. Write a Python function `def find_NAIP(region, add_NDVI=True, add_NDWI=True)` to solve the following problem:
Create annual NAIP mosaic for a given region. Args: region (object): ee.Geometry add_NDVI (bool, optional): Whether to add the NDVI band. Defaults to True. add_NDWI (bool, optional): Whether to add the NDWI band. Defaults to True. Returns: object: ee.ImageCollection
Here is the function:
def find_NAIP(region, add_NDVI=True, add_NDWI=True):
"""Create annual NAIP mosaic for a given region.
Args:
region (object): ee.Geometry
add_NDVI (bool, optional): Whether to add the NDVI band. Defaults to True.
add_NDWI (bool, optional): Whether to add the NDWI band. Defaults to True.
Returns:
object: ee.ImageCollection
"""
init_collection = (
ee.ImageCollection("USDA/NAIP/DOQQ")
.filterBounds(region)
.filterDate("2009-01-01", "2019-12-31")
.filter(ee.Filter.listContains("system:band_names", "N"))
)
yearList = ee.List(
init_collection.distinct(["system:time_start"]).aggregate_array(
"system:time_start"
)
)
init_years = yearList.map(lambda y: ee.Date(y).get("year"))
# remove duplicates
init_years = ee.Dictionary(
init_years.reduce(ee.Reducer.frequencyHistogram())
).keys()
years = init_years.map(lambda x: ee.Number.parse(x))
# years = init_years.map(lambda x: x)
# Available NAIP years with NIR band
def NAIPAnnual(year):
start_date = ee.Date.fromYMD(year, 1, 1)
end_date = ee.Date.fromYMD(year, 12, 31)
collection = init_collection.filterDate(start_date, end_date)
# .filterBounds(geometry)
# .filter(ee.Filter.listContains("system:band_names", "N"))
time_start = ee.Date(
ee.List(collection.aggregate_array("system:time_start")).sort().get(0)
).format("YYYY-MM-dd")
time_end = ee.Date(
ee.List(collection.aggregate_array("system:time_end")).sort().get(-1)
).format("YYYY-MM-dd")
col_size = collection.size()
image = ee.Image(collection.mosaic().clip(region))
if add_NDVI:
NDVI = (
ee.Image(image)
.normalizedDifference(["N", "R"])
.select(["nd"], ["ndvi"])
)
image = image.addBands(NDVI)
if add_NDWI:
NDWI = (
ee.Image(image)
.normalizedDifference(["G", "N"])
.select(["nd"], ["ndwi"])
)
image = image.addBands(NDWI)
return image.set(
{
"system:time_start": time_start,
"system:time_end": time_end,
"tiles": col_size,
}
)
# remove years with incomplete coverage
naip = ee.ImageCollection(years.map(NAIPAnnual))
mean_size = ee.Number(naip.aggregate_mean("tiles"))
total_sd = ee.Number(naip.aggregate_total_sd("tiles"))
threshold = mean_size.subtract(total_sd.multiply(1))
naip = naip.filter(
ee.Filter.Or(ee.Filter.gte("tiles", threshold), ee.Filter.gte("tiles", 15))
)
naip = naip.filter(ee.Filter.gte("tiles", 7))
naip_count = naip.size()
naip_seq = ee.List.sequence(0, naip_count.subtract(1))
def set_index(index):
img = ee.Image(naip.toList(naip_count).get(index))
return img.set({"system:uid": ee.Number(index).toUint8()})
naip = naip_seq.map(set_index)
return ee.ImageCollection(naip) | Create annual NAIP mosaic for a given region. Args: region (object): ee.Geometry add_NDVI (bool, optional): Whether to add the NDVI band. Defaults to True. add_NDWI (bool, optional): Whether to add the NDWI band. Defaults to True. Returns: object: ee.ImageCollection |
12,326 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `filter_NWI` function. Write a Python function `def filter_NWI(HUC08_Id, region, exclude_riverine=True)` to solve the following problem:
Retrieves NWI dataset for a given HUC8 watershed. Args: HUC08_Id (str): The HUC8 watershed id. region (object): ee.Geometry exclude_riverine (bool, optional): Whether to exclude riverine wetlands. Defaults to True. Returns: object: ee.FeatureCollection
Here is the function:
def filter_NWI(HUC08_Id, region, exclude_riverine=True):
"""Retrieves NWI dataset for a given HUC8 watershed.
Args:
HUC08_Id (str): The HUC8 watershed id.
region (object): ee.Geometry
exclude_riverine (bool, optional): Whether to exclude riverine wetlands. Defaults to True.
Returns:
object: ee.FeatureCollection
"""
nwi_asset_prefix = "users/wqs/NWI-HU8/HU8_"
nwi_asset_suffix = "_Wetlands"
nwi_asset_path = nwi_asset_prefix + HUC08_Id + nwi_asset_suffix
nwi_huc = ee.FeatureCollection(nwi_asset_path).filterBounds(region)
if exclude_riverine:
nwi_huc = nwi_huc.filter(
ee.Filter.notEquals(**{"leftField": "WETLAND_TY", "rightValue": "Riverine"})
)
return nwi_huc | Retrieves NWI dataset for a given HUC8 watershed. Args: HUC08_Id (str): The HUC8 watershed id. region (object): ee.Geometry exclude_riverine (bool, optional): Whether to exclude riverine wetlands. Defaults to True. Returns: object: ee.FeatureCollection |
12,327 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `filter_HUC08` function. Write a Python function `def filter_HUC08(region)` to solve the following problem:
Filters HUC08 watersheds intersecting a given region. Args: region (object): ee.Geometry Returns: object: ee.FeatureCollection
Here is the function:
def filter_HUC08(region):
"""Filters HUC08 watersheds intersecting a given region.
Args:
region (object): ee.Geometry
Returns:
object: ee.FeatureCollection
"""
USGS_HUC08 = ee.FeatureCollection("USGS/WBD/2017/HUC08") # Subbasins
HUC08 = USGS_HUC08.filterBounds(region)
return HUC08 | Filters HUC08 watersheds intersecting a given region. Args: region (object): ee.Geometry Returns: object: ee.FeatureCollection |
12,328 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `filter_HUC10` function. Write a Python function `def filter_HUC10(region)` to solve the following problem:
Filters HUC10 watersheds intersecting a given region. Args: region (object): ee.Geometry Returns: object: ee.FeatureCollection
Here is the function:
def filter_HUC10(region):
"""Filters HUC10 watersheds intersecting a given region.
Args:
region (object): ee.Geometry
Returns:
object: ee.FeatureCollection
"""
USGS_HUC10 = ee.FeatureCollection("USGS/WBD/2017/HUC10") # Watersheds
HUC10 = USGS_HUC10.filterBounds(region)
return HUC10 | Filters HUC10 watersheds intersecting a given region. Args: region (object): ee.Geometry Returns: object: ee.FeatureCollection |
12,329 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `find_HUC08` function. Write a Python function `def find_HUC08(HUC08_Id)` to solve the following problem:
Finds a HUC08 watershed based on a given HUC08 ID Args: HUC08_Id (str): The HUC08 ID. Returns: object: ee.FeatureCollection
Here is the function:
def find_HUC08(HUC08_Id):
"""Finds a HUC08 watershed based on a given HUC08 ID
Args:
HUC08_Id (str): The HUC08 ID.
Returns:
object: ee.FeatureCollection
"""
USGS_HUC08 = ee.FeatureCollection("USGS/WBD/2017/HUC08") # Subbasins
HUC08 = USGS_HUC08.filter(ee.Filter.eq("huc8", HUC08_Id))
return HUC08 | Finds a HUC08 watershed based on a given HUC08 ID Args: HUC08_Id (str): The HUC08 ID. Returns: object: ee.FeatureCollection |
12,330 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `find_HUC10` function. Write a Python function `def find_HUC10(HUC10_Id)` to solve the following problem:
Finds a HUC10 watershed based on a given HUC08 ID Args: HUC10_Id (str): The HUC10 ID. Returns: object: ee.FeatureCollection
Here is the function:
def find_HUC10(HUC10_Id):
"""Finds a HUC10 watershed based on a given HUC08 ID
Args:
HUC10_Id (str): The HUC10 ID.
Returns:
object: ee.FeatureCollection
"""
USGS_HUC10 = ee.FeatureCollection("USGS/WBD/2017/HUC10") # Watersheds
HUC10 = USGS_HUC10.filter(ee.Filter.eq("huc10", HUC10_Id))
return HUC10 | Finds a HUC10 watershed based on a given HUC08 ID Args: HUC10_Id (str): The HUC10 ID. Returns: object: ee.FeatureCollection |
12,331 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `find_NWI` function. Write a Python function `def find_NWI(HUC08_Id, exclude_riverine=True)` to solve the following problem:
Finds NWI dataset for a given HUC08 watershed. Args: HUC08_Id (str): The HUC08 watershed ID. exclude_riverine (bool, optional): Whether to exclude riverine wetlands. Defaults to True. Returns: object: ee.FeatureCollection
Here is the function:
def find_NWI(HUC08_Id, exclude_riverine=True):
"""Finds NWI dataset for a given HUC08 watershed.
Args:
HUC08_Id (str): The HUC08 watershed ID.
exclude_riverine (bool, optional): Whether to exclude riverine wetlands. Defaults to True.
Returns:
object: ee.FeatureCollection
"""
nwi_asset_prefix = "users/wqs/NWI-HU8/HU8_"
nwi_asset_suffix = "_Wetlands"
nwi_asset_path = nwi_asset_prefix + HUC08_Id + nwi_asset_suffix
nwi_huc = ee.FeatureCollection(nwi_asset_path)
if exclude_riverine:
nwi_huc = nwi_huc.filter(
ee.Filter.notEquals(**{"leftField": "WETLAND_TY", "rightValue": "Riverine"})
)
return nwi_huc | Finds NWI dataset for a given HUC08 watershed. Args: HUC08_Id (str): The HUC08 watershed ID. exclude_riverine (bool, optional): Whether to exclude riverine wetlands. Defaults to True. Returns: object: ee.FeatureCollection |
12,332 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `nwi_add_color` function. Write a Python function `def nwi_add_color(fc)` to solve the following problem:
Converts NWI vector dataset to image and add color to it. Args: fc (object): ee.FeatureCollection Returns: object: ee.Image
Here is the function:
def nwi_add_color(fc):
"""Converts NWI vector dataset to image and add color to it.
Args:
fc (object): ee.FeatureCollection
Returns:
object: ee.Image
"""
emergent = ee.FeatureCollection(
fc.filter(ee.Filter.eq("WETLAND_TY", "Freshwater Emergent Wetland"))
)
emergent = emergent.map(lambda f: f.set("R", 127).set("G", 195).set("B", 28))
# print(emergent.first())
forested = fc.filter(
ee.Filter.eq("WETLAND_TY", "Freshwater Forested/Shrub Wetland")
)
forested = forested.map(lambda f: f.set("R", 0).set("G", 136).set("B", 55))
pond = fc.filter(ee.Filter.eq("WETLAND_TY", "Freshwater Pond"))
pond = pond.map(lambda f: f.set("R", 104).set("G", 140).set("B", 192))
lake = fc.filter(ee.Filter.eq("WETLAND_TY", "Lake"))
lake = lake.map(lambda f: f.set("R", 19).set("G", 0).set("B", 124))
riverine = fc.filter(ee.Filter.eq("WETLAND_TY", "Riverine"))
riverine = riverine.map(lambda f: f.set("R", 1).set("G", 144).set("B", 191))
fc = ee.FeatureCollection(
emergent.merge(forested).merge(pond).merge(lake).merge(riverine)
)
# base = ee.Image(0).mask(0).toInt8()
base = ee.Image().byte()
img = base.paint(fc, "R").addBands(
base.paint(fc, "G").addBands(base.paint(fc, "B"))
)
return img | Converts NWI vector dataset to image and add color to it. Args: fc (object): ee.FeatureCollection Returns: object: ee.Image |
12,333 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
def nwi_rename(names):
name_dict = ee.Dictionary(
{
"Freshwater Emergent Wetland": "Emergent",
"Freshwater Forested/Shrub Wetland": "Forested",
"Estuarine and Marine Wetland": "Estuarine",
"Freshwater Pond": "Pond",
"Lake": "Lake",
"Riverine": "Riverine",
"Estuarine and Marine Deepwater": "Deepwater",
"Other": "Other",
}
)
new_names = ee.List(names).map(lambda name: name_dict.get(name))
return new_names | null |
12,334 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `summarize_by_group` function. Write a Python function `def summarize_by_group( collection, column, group, group_name, stats_type, return_dict=True )` to solve the following problem:
Calculates summary statistics by group. Args: collection (object): The input feature collection column (str): The value column to calculate summary statistics. group (str): The name of the group column. group_name (str): The new group name to use. stats_type (str): The type of summary statistics. return_dict (bool): Whether to return the result as a dictionary. Returns: object: ee.Dictionary or ee.List
Here is the function:
def summarize_by_group(
collection, column, group, group_name, stats_type, return_dict=True
):
"""Calculates summary statistics by group.
Args:
collection (object): The input feature collection
column (str): The value column to calculate summary statistics.
group (str): The name of the group column.
group_name (str): The new group name to use.
stats_type (str): The type of summary statistics.
return_dict (bool): Whether to return the result as a dictionary.
Returns:
object: ee.Dictionary or ee.List
"""
stats_type = stats_type.lower()
allowed_stats = ["min", "max", "mean", "median", "sum", "stdDev", "variance"]
if stats_type not in allowed_stats:
print(
"The stats type must be one of the following: {}".format(
",".join(allowed_stats)
)
)
return
stats_dict = {
"min": ee.Reducer.min(),
"max": ee.Reducer.max(),
"mean": ee.Reducer.mean(),
"median": ee.Reducer.median(),
"sum": ee.Reducer.sum(),
"stdDev": ee.Reducer.stdDev(),
"variance": ee.Reducer.variance(),
}
selectors = [column, group]
stats = collection.reduceColumns(
**{
"selectors": selectors,
"reducer": stats_dict[stats_type].group(
**{"groupField": 1, "groupName": group_name}
),
}
)
results = ee.List(ee.Dictionary(stats).get("groups"))
if return_dict:
keys = results.map(lambda k: ee.Dictionary(k).get(group_name))
values = results.map(lambda v: ee.Dictionary(v).get(stats_type))
results = ee.Dictionary.fromLists(keys, values)
return results | Calculates summary statistics by group. Args: collection (object): The input feature collection column (str): The value column to calculate summary statistics. group (str): The name of the group column. group_name (str): The new group name to use. stats_type (str): The type of summary statistics. return_dict (bool): Whether to return the result as a dictionary. Returns: object: ee.Dictionary or ee.List |
12,335 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `summary_stats` function. Write a Python function `def summary_stats(collection, column)` to solve the following problem:
Aggregates over a given property of the objects in a collection, calculating the sum, min, max, mean, sample standard deviation, sample variance, total standard deviation and total variance of the selected property. Args: collection (FeatureCollection): The input feature collection to calculate summary statistics. column (str): The name of the column to calculate summary statistics. Returns: dict: The dictionary containing information about the summary statistics.
Here is the function:
def summary_stats(collection, column):
"""Aggregates over a given property of the objects in a collection, calculating the sum, min, max, mean,
sample standard deviation, sample variance, total standard deviation and total variance of the selected property.
Args:
collection (FeatureCollection): The input feature collection to calculate summary statistics.
column (str): The name of the column to calculate summary statistics.
Returns:
dict: The dictionary containing information about the summary statistics.
"""
stats = collection.aggregate_stats(column).getInfo()
return eval(str(stats)) | Aggregates over a given property of the objects in a collection, calculating the sum, min, max, mean, sample standard deviation, sample variance, total standard deviation and total variance of the selected property. Args: collection (FeatureCollection): The input feature collection to calculate summary statistics. column (str): The name of the column to calculate summary statistics. Returns: dict: The dictionary containing information about the summary statistics. |
12,336 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `column_stats` function. Write a Python function `def column_stats(collection, column, stats_type)` to solve the following problem:
Aggregates over a given property of the objects in a collection, calculating the sum, min, max, mean, sample standard deviation, sample variance, total standard deviation and total variance of the selected property. Args: collection (FeatureCollection): The input feature collection to calculate statistics. column (str): The name of the column to calculate statistics. stats_type (str): The type of statistics to calculate. Returns: dict: The dictionary containing information about the requested statistics.
Here is the function:
def column_stats(collection, column, stats_type):
"""Aggregates over a given property of the objects in a collection, calculating the sum, min, max, mean,
sample standard deviation, sample variance, total standard deviation and total variance of the selected property.
Args:
collection (FeatureCollection): The input feature collection to calculate statistics.
column (str): The name of the column to calculate statistics.
stats_type (str): The type of statistics to calculate.
Returns:
dict: The dictionary containing information about the requested statistics.
"""
stats_type = stats_type.lower()
allowed_stats = ["min", "max", "mean", "median", "sum", "stdDev", "variance"]
if stats_type not in allowed_stats:
print(
"The stats type must be one of the following: {}".format(
",".join(allowed_stats)
)
)
return
stats_dict = {
"min": ee.Reducer.min(),
"max": ee.Reducer.max(),
"mean": ee.Reducer.mean(),
"median": ee.Reducer.median(),
"sum": ee.Reducer.sum(),
"stdDev": ee.Reducer.stdDev(),
"variance": ee.Reducer.variance(),
}
selectors = [column]
stats = collection.reduceColumns(
**{"selectors": selectors, "reducer": stats_dict[stats_type]}
)
return stats | Aggregates over a given property of the objects in a collection, calculating the sum, min, max, mean, sample standard deviation, sample variance, total standard deviation and total variance of the selected property. Args: collection (FeatureCollection): The input feature collection to calculate statistics. column (str): The name of the column to calculate statistics. stats_type (str): The type of statistics to calculate. Returns: dict: The dictionary containing information about the requested statistics. |
12,337 | import csv
import datetime
import io
import json
import math
import os
import requests
import shutil
import tarfile
import urllib.request
import warnings
import zipfile
import ee
import ipywidgets as widgets
from ipytree import Node, Tree
from typing import Union, List, Dict, Optional, Tuple
The provided code snippet includes necessary dependencies for implementing the `ee_num_round` function. Write a Python function `def ee_num_round(num, decimal=2)` to solve the following problem:
Rounds a number to a specified number of decimal places. Args: num (ee.Number): The number to round. decimal (int, optional): The number of decimal places to round. Defaults to 2. Returns: ee.Number: The number with the specified decimal places rounded.
Here is the function:
def ee_num_round(num, decimal=2):
"""Rounds a number to a specified number of decimal places.
Args:
num (ee.Number): The number to round.
decimal (int, optional): The number of decimal places to round. Defaults to 2.
Returns:
ee.Number: The number with the specified decimal places rounded.
"""
format_str = "%.{}f".format(decimal)
return ee.Number.parse(ee.Number(num).format(format_str)) | Rounds a number to a specified number of decimal places. Args: num (ee.Number): The number to round. decimal (int, optional): The number of decimal places to round. Defaults to 2. Returns: ee.Number: The number with the specified decimal places rounded. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.