diff --git a/docs/_toc.yml b/docs/_toc.yml index 0e182b2..d57d292 100644 --- a/docs/_toc.yml +++ b/docs/_toc.yml @@ -22,4 +22,4 @@ parts: - file: content/03/03_00_Clip_to_vec - file: content/03/04_00_Spyndex - file: content/03/05_00_Count_valid - - file: content/03/06_00_STAC_Data + - file: content/03/06_00_STAC_data diff --git a/docs/content/03/06_00_STAC_Data.md b/docs/content/03/06_00_STAC_Data.md deleted file mode 100644 index d5d4303..0000000 --- a/docs/content/03/06_00_STAC_Data.md +++ /dev/null @@ -1,5 +0,0 @@ -# ...load data from remote STAC Catalogs? - -_Coming soon..._ - -![https://media.giphy.com/media/26vUKLfpzAS2QIVVK/giphy.gif](https://media.giphy.com/media/26vUKLfpzAS2QIVVK/giphy.gif) diff --git a/docs/content/03/06_00_STAC_data.ipynb b/docs/content/03/06_00_STAC_data.ipynb new file mode 100644 index 0000000..df8498f --- /dev/null +++ b/docs/content/03/06_00_STAC_data.ipynb @@ -0,0 +1,2341 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# ...load data from remote STAC Catalogs?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In order to load data products from remote [SpatioTemporal Asset Catalogs (STAC)](https://stacspec.org/en/), we can make use of the `load_from_stac` function provided by the `sdc-tools` package. Currently, this function supports loading data products hosted by [Microsoft Planetary Computer (MPC)](https://planetarycomputer.microsoft.com/catalog) and [Digital Earth Africa (DEA)](https://explorer.digitalearth.africa/).\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```{warning}\n", + "Please be aware that working with remote data products might be quite inefficient. This is especially true, if the data is loaded with inappropriatly chosen parameters. Before loading a data product, you should get to know its basic characteristics. If you know the answer to at least the following questions, you are good to go:\n", + "- **What is the pixel spacing / resolution of the data?** \n", + " - Override the default `resolution` parameter if necessary.\n", + "- **Is the data categorical or continuous?** E.g., land cover is categorical, while spectral bands are continuous.\n", + " - If the data is categorical you should override the default `resampling` method to `'nearest'`.\n", + "- **In which datatype is the data stored and are there differences between the bands?** Common types are `uint8`, `uint16` and `float32`, for example. \n", + " - If there are differences in datatype between the bands you're interested in, it's probably best to load these separately by specifiying the `bands` parameter and using the appropriate `dtype` for each band.\n", + "\n", + "You should get an idea of how to handle these cases by having a look at the examples below. If something is unclear, please let me know!\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```{note}\n", + "In both examples we will use the bounding box of an entire SALDi site as an example. If you have a specific area of interest, you can replace the bounding box with your own. E.g., by using the utility function `sdc.vec.get_vec_bounds`. In general it is recommended to try things out on a small subset first, before scaling up to larger areas and time periods.\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example: Planetary Computer" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this example, we load the `MCD64A1 Version 6.1 Burned Area data product` from MPC. You can find more details about this data product [here](https://planetarycomputer.microsoft.com/dataset/modis-64A1-061) on the MPC website and [here](https://lpdaac.usgs.gov/products/mcd64a1v061/) from the original data source, the USGS Land Processes Distributed Active Archive Center (LP DAAC)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[INFO] odc.stac.load parameters: {'crs': 'EPSG:4326', 'resolution': 0.005, 'resampling': 'nearest', 'chunks': {'time': 'auto', 'y': 'auto', 'x': 'auto'}}\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'Burn_Date' (time: 71, latitude: 220, longitude: 260)> Size: 8MB\n",
+       "dask.array<Burn_Date, shape=(71, 220, 260), dtype=int16, chunksize=(71, 220, 260), chunktype=numpy.ndarray>\n",
+       "Coordinates:\n",
+       "  * latitude     (latitude) float64 2kB -24.9 -24.91 -24.91 ... -25.99 -26.0\n",
+       "  * longitude    (longitude) float64 2kB 30.75 30.76 30.76 ... 32.04 32.04 32.05\n",
+       "    spatial_ref  int32 4B 4326\n",
+       "  * time         (time) datetime64[ns] 568B 2018-01-01 2018-02-01 ... 2023-12-01\n",
+       "Attributes:\n",
+       "    nodata:   -1
" + ], + "text/plain": [ + " Size: 8MB\n", + "dask.array\n", + "Coordinates:\n", + " * latitude (latitude) float64 2kB -24.9 -24.91 -24.91 ... -25.99 -26.0\n", + " * longitude (longitude) float64 2kB 30.75 30.76 30.76 ... 32.04 32.04 32.05\n", + " spatial_ref int32 4B 4326\n", + " * time (time) datetime64[ns] 568B 2018-01-01 2018-02-01 ... 2023-12-01\n", + "Attributes:\n", + " nodata: -1" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sdc.products.remote import load_from_stac\n", + "from sdc.vec import get_site_bounds\n", + "import xarray as xr\n", + "import folium\n", + "\n", + "bounds = get_site_bounds(site=\"site06\")\n", + "time_range = (\"2018\", \"2023\")\n", + "override_defaults = {'crs': 'EPSG:4326', # this is already the default, but just to be explicit I wanted to show it here\n", + " 'resolution': 0.005, # equal to approx. 500 m pixel spacing, similar to the original data\n", + " 'resampling': 'nearest', # the data is categorical, so `nearest` resampling is appropriate!\n", + " 'chunks': {'time': 'auto', 'y': 'auto', 'x': 'auto'}} # if you're not sure, you can set all to 'auto'\n", + "\n", + "modis_burned = load_from_stac(\n", + " stac_endpoint='pc',\n", + " collection=\"modis-64A1-061\",\n", + " bounds=bounds,\n", + " time_range=time_range,\n", + " bands=[\"Burn_Date\"],\n", + " nodata=-1,\n", + " dtype='int16',\n", + " override_defaults=override_defaults\n", + " )\n", + "\n", + "modis_burned.Burn_Date" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " The MODIS Burn Date product has fill values below 0. Let's set these to 0, calculate the average, per-pixel burn date for the year 2020 and plot the result on a map." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'Burn_Date' (latitude: 220, longitude: 260)> Size: 458kB\n",
+       "dask.array<mean_agg-aggregate, shape=(220, 260), dtype=float64, chunksize=(220, 260), chunktype=numpy.ndarray>\n",
+       "Coordinates:\n",
+       "  * latitude     (latitude) float64 2kB -24.9 -24.91 -24.91 ... -25.99 -26.0\n",
+       "  * longitude    (longitude) float64 2kB 30.75 30.76 30.76 ... 32.04 32.04 32.05\n",
+       "    spatial_ref  int32 4B 4326\n",
+       "Attributes:\n",
+       "    nodata:   -1
" + ], + "text/plain": [ + " Size: 458kB\n", + "dask.array\n", + "Coordinates:\n", + " * latitude (latitude) float64 2kB -24.9 -24.91 -24.91 ... -25.99 -26.0\n", + " * longitude (longitude) float64 2kB 30.75 30.76 30.76 ... 32.04 32.04 32.05\n", + " spatial_ref int32 4B 4326\n", + "Attributes:\n", + " nodata: -1" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mbd = xr.where(modis_burned.Burn_Date > 0, modis_burned.Burn_Date, 0)\n", + "\n", + "mbd_mean_2020 = mbd.sel(time='2020').mean(dim='time')\n", + "mbd_mean_2020" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Make this Notebook Trusted to load map: File -> Trust Notebook
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "m = folium.Map()\n", + "mbd_mean_2020.odc.add_to(m, cmap='inferno', opacity=0.5)\n", + "\n", + "m.fit_bounds(mbd_mean_2020.odc.map_bounds())\n", + "display(m)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example: Digital Earth Africa" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This example demonstrates how to load a cropland extent map created by DEA. The data explorer linked in the beginning of this notebook lists multiple `crop_mask` products for different regions of Africa. We will load the product `crop_mask_southern`, which covers all of South Africa as you can see [here](https://explorer.digitalearth.africa/products/crop_mask_southern). More details about the data product itself can be found [here](https://docs.digitalearthafrica.org/en/latest/data_specs/Cropland_extent_specs.html) and [here](https://docs.digitalearthafrica.org/en/latest/sandbox/notebooks/Datasets/Cropland_extent.html)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[INFO] odc.stac.load parameters: {'crs': 'EPSG:4326', 'resolution': 0.0001, 'resampling': 'nearest', 'chunks': {'time': -1, 'y': -1, 'x': -1}}\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'mask' (time: 1, latitude: 10000, longitude: 10500)> Size: 105MB\n",
+       "dask.array<mask, shape=(1, 10000, 10500), dtype=uint8, chunksize=(1, 10000, 10500), chunktype=numpy.ndarray>\n",
+       "Coordinates:\n",
+       "  * latitude     (latitude) float64 80kB -29.0 -29.0 -29.0 ... -30.0 -30.0 -30.0\n",
+       "  * longitude    (longitude) float64 84kB 26.45 26.45 26.45 ... 27.5 27.5 27.5\n",
+       "    spatial_ref  int32 4B 4326\n",
+       "  * time         (time) datetime64[ns] 8B 2019-01-01\n",
+       "Attributes:\n",
+       "    nodata:   0
" + ], + "text/plain": [ + " Size: 105MB\n", + "dask.array\n", + "Coordinates:\n", + " * latitude (latitude) float64 80kB -29.0 -29.0 -29.0 ... -30.0 -30.0 -30.0\n", + " * longitude (longitude) float64 84kB 26.45 26.45 26.45 ... 27.5 27.5 27.5\n", + " spatial_ref int32 4B 4326\n", + " * time (time) datetime64[ns] 8B 2019-01-01\n", + "Attributes:\n", + " nodata: 0" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sdc.products.remote import load_from_stac\n", + "from sdc.vec import get_site_bounds\n", + "\n", + "bounds = get_site_bounds(site=\"site04\")\n", + "time_range = (\"2019\", \"2019\") # only a mask for the year 2019 is available\n", + "override_defaults = {'crs': 'EPSG:4326', # this is already the default, but just to be explicit I wanted to show it here\n", + " 'resolution': 0.0001, # equal to approx. 10 m pixel spacing, similar to the original data\n", + " 'resampling': 'nearest', # the data is categorical, so `nearest` resampling is appropriate!\n", + " 'chunks': {'time': -1, 'y': -1, 'x': -1}} # it's a single time slice and the dtype is uint8 (\"smaller\" data), so we can load it all into one chunk\n", + "\n", + "crop_2019 = load_from_stac(\n", + " stac_endpoint='deafrica',\n", + " collection=\"crop_mask_southern\",\n", + " bounds=bounds,\n", + " time_range=time_range,\n", + " bands=[\"mask\", \"prob\"], # both of these bands have the same dtype and nodata value!\n", + " nodata=0,\n", + " dtype='uint8',\n", + " override_defaults=override_defaults\n", + " )\n", + "\n", + "crop_2019.mask" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Only one time step is available representing the year 2019, but the data is loaded as a 3-dimensional array as you can see in the representation above.\n", + "We can drop the unnecessary time-dimension using the [`squeeze`](https://docs.xarray.dev/en/stable/generated/xarray.Dataset.squeeze.html#xarray.Dataset.squeeze) method:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'mask' (latitude: 10000, longitude: 10500)> Size: 105MB\n",
+       "dask.array<getitem, shape=(10000, 10500), dtype=uint8, chunksize=(10000, 10500), chunktype=numpy.ndarray>\n",
+       "Coordinates:\n",
+       "  * latitude     (latitude) float64 80kB -29.0 -29.0 -29.0 ... -30.0 -30.0 -30.0\n",
+       "  * longitude    (longitude) float64 84kB 26.45 26.45 26.45 ... 27.5 27.5 27.5\n",
+       "    spatial_ref  int32 4B 4326\n",
+       "    time         datetime64[ns] 8B 2019-01-01\n",
+       "Attributes:\n",
+       "    nodata:   0
" + ], + "text/plain": [ + " Size: 105MB\n", + "dask.array\n", + "Coordinates:\n", + " * latitude (latitude) float64 80kB -29.0 -29.0 -29.0 ... -30.0 -30.0 -30.0\n", + " * longitude (longitude) float64 84kB 26.45 26.45 26.45 ... 27.5 27.5 27.5\n", + " spatial_ref int32 4B 4326\n", + " time datetime64[ns] 8B 2019-01-01\n", + "Attributes:\n", + " nodata: 0" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "crop_2019 = crop_2019.squeeze()\n", + "crop_2019.mask" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, let's create a quick plot of the crop mask. The value `1` represents the presence of crops and `0` the absence:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "crop_2019.mask.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/environment-dev.yml b/environment-dev.yml index d0886a2..e5d946f 100644 --- a/environment-dev.yml +++ b/environment-dev.yml @@ -16,6 +16,7 @@ dependencies: - nodejs - numbagg>=0.8.0 - odc-stac<=0.3.9 + - planetary-computer - rioxarray - rio-cogeo - rio-stac diff --git a/environment.yml b/environment.yml index 864c763..171402a 100644 --- a/environment.yml +++ b/environment.yml @@ -15,6 +15,7 @@ dependencies: - nodejs - numbagg>=0.8.0 - odc-stac<=0.3.9 + - planetary-computer - rioxarray - spyndex - xarray>=2024.2.0 diff --git a/pyproject.toml b/pyproject.toml index 8661005..403d0e0 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -20,6 +20,7 @@ dependencies = [ "nodejs", "numbagg>=0.8.0", "odc-stac<=0.3.9", + "planetary-computer", "rioxarray", "spyndex", "xarray>=2024.2.0", diff --git a/sdc/products/remote.py b/sdc/products/remote.py index 92a6385..0ac7229 100644 --- a/sdc/products/remote.py +++ b/sdc/products/remote.py @@ -1,5 +1,7 @@ -from pystac_client import Client +import pystac_client +import planetary_computer from odc.stac import configure_rio, stac_load +import numpy as np from sdc import dask_client from sdc.products import _ancillary as anc @@ -8,37 +10,43 @@ from xarray import Dataset -def load_from_dea_stac(bounds: tuple[float, float, float, float], - collection: str, - time_range: tuple[str, str], - stac_filter: Optional[dict] = None, - bands: Optional[list[str]] = None, - nodata: Optional[int | float] = None, - dtype: Optional[str] = None, - override_defaults: Optional[dict] = None, - verbose: Optional[bool] = False - ) -> Dataset: +def load_from_stac(stac_endpoint: str, + collection: str, + bounds: tuple[float, float, float, float], + time_range: tuple[str, str], + dtype: str, + nodata: Optional[int | float] = None, + stac_filter: Optional[dict] = None, + bands: Optional[list[str]] = None, + override_defaults: Optional[dict] = None, + verbose: Optional[bool] = False + ) -> Dataset: """ Load data from the DEA STAC Catalog. Parameters ---------- - bounds: tuple of float - The bounding box of the area of interest in the format (minx, miny, maxx, maxy). - Will be used to filter the STAC Catalog for intersecting STAC Collections. + stac_endpoint : str + The URL of the STAC endpoint to load data from. Two special cases are supported: + - 'deafrica': loads data from the Digital Earth Africa STAC endpoint. + - 'pc': loads data from the Planetary Computer STAC endpoint. collection : str The name of the STAC Collection to load data from. + bounds : tuple of float + The bounding box of the area of interest in the format (minx, miny, maxx, maxy). + Will be used to filter the STAC Catalog for intersecting STAC Collections. time_range : tuple of str The time range in the format (start_time, end_time) to filter STAC Items by. + dtype : str, optional + The data type to cast the loaded data to. Defaults to None. + nodata : int or float, optional + The nodata value to use for the loaded data. If `dtype` is a floating point + type, the default nodata value is `np.nan` else it will default to None. stac_filter : dict, optional A dictionary of additional filters to apply to the STAC Items. See the STAC API filter extension for more information. bands : list of str, optional A list of band names to load. Defaults to None, which will load all bands. - nodata : int or float, optional - The nodata value to use for the loaded data. Defaults to None. - dtype : str, optional - The data type to cast the loaded data to. Defaults to None. override_defaults : dict, optional Dictionary of loading parameters to override the default parameters with. Partial overriding is possible, i.e. only override a specific parameter while @@ -50,7 +58,6 @@ def load_from_dea_stac(bounds: tuple[float, float, float, float], - resolution: 0.0002 - resampling: 'bilinear' - chunks: {'time': -1, 'latitude': 'auto', 'longitude': 'auto'} - verbose : bool, optional Whether to print information about the loading process. Defaults to False. @@ -59,19 +66,32 @@ def load_from_dea_stac(bounds: tuple[float, float, float, float], Dataset An xarray Dataset containing the loaded data. """ - configure_rio( - cloud_defaults=True, - aws={"aws_unsigned": True}, - AWS_S3_ENDPOINT="s3.af-south-1.amazonaws.com", - client=dask_client - ) + if nodata is None: + if isinstance(np.random.rand(1).astype(dtype)[0], np.floating): + nodata = np.nan - catalog = Client.open("https://explorer.digitalearth.africa/stac") + modifier = None + if stac_endpoint == 'deafrica': + configure_rio( + cloud_defaults=True, + aws={"aws_unsigned": True}, + AWS_S3_ENDPOINT="s3.af-south-1.amazonaws.com", + client=dask_client + ) + stac_endpoint = "https://explorer.digitalearth.africa/stac" + elif stac_endpoint == 'pc': + modifier = planetary_computer.sign_inplace + stac_endpoint = "https://planetarycomputer.microsoft.com/api/stac/v1" + else: + stac_endpoint = stac_endpoint + + catalog = pystac_client.Client.open(stac_endpoint, + modifier=modifier) query = catalog.search( - bbox=bounds, collections=[collection], - filter=stac_filter, - datetime=f"{time_range[0]}/{time_range[1]}" + bbox=bounds, + datetime=f"{time_range[0]}/{time_range[1]}", + filter=stac_filter ) items = list(query.items())