mapchete-eo 2025.7.0__py2.py3-none-any.whl

mapchete_eo/__init__.py

@@ -0,0 +1 @@
+__version__ = "2025.7.0"

mapchete_eo/archives/base.py

@@ -0,0 +1,65 @@
+from abc import ABC
+import logging
+from typing import Any, Callable, Dict, Generator, List, Optional, Union
+
+from mapchete.io.vector import IndexedFeatures
+from mapchete.types import Bounds
+from pystac import Item
+from shapely.errors import GEOSException
+from shapely.geometry.base import BaseGeometry
+
+from mapchete_eo.exceptions import ItemGeometryError
+from mapchete_eo.search.base import CatalogSearcher
+from mapchete_eo.types import TimeRange
+
+logger = logging.getLogger(__name__)
+
+
+class Archive(ABC):
+    """
+    An archive combines a Catalog and a Storage.
+    """
+
+    time: Union[TimeRange, List[TimeRange]]
+    area: BaseGeometry
+    catalog: CatalogSearcher
+    search_kwargs: Dict[str, Any]
+    _items: Optional[IndexedFeatures] = None
+    item_modifier_funcs: Optional[List[Callable[[Item], Item]]] = None
+
+    def __init__(
+        self,
+        time: Union[TimeRange, List[TimeRange]],
+        bounds: Optional[Bounds] = None,
+        area: Optional[BaseGeometry] = None,
+        search_kwargs: Optional[Dict[str, Any]] = None,
+        catalog: Optional[CatalogSearcher] = None,
+    ):
+        if bounds is None and area is None:
+            raise ValueError("either bounds or area have to be provided")
+        elif area is None:
+            area = Bounds.from_inp(bounds).geometry
+        self.time = time
+        self.area = area
+        self.search_kwargs = search_kwargs or {}
+        if catalog:
+            self.catalog = catalog
+
+    def get_catalog_config(self):
+        return self.catalog.config_cls(**self.search_kwargs)
+
+    def apply_item_modifier_funcs(self, item: Item) -> Item:
+        try:
+            for modifier in self.item_modifier_funcs or []:
+                item = modifier(item)
+        except GEOSException as exc:
+            raise ItemGeometryError(
+                f"item {item.get_self_href()} geometry could not be resolved: {str(exc)}"
+            )
+        return item
+
+    def items(self) -> Generator[Item, None, None]:
+        for item in self.catalog.search(
+            time=self.time, area=self.area, search_kwargs=self.search_kwargs
+        ):
+            yield self.apply_item_modifier_funcs(item)

mapchete_eo/array/buffer.py

@@ -0,0 +1,16 @@
+from typing import Optional
+
+import numpy as np
+from numpy.typing import DTypeLike
+from scipy.ndimage import binary_dilation
+
+
+def buffer_array(
+    array: np.ndarray, buffer: int = 0, out_array_dtype: Optional[DTypeLike] = None
+) -> np.ndarray:
+    if out_array_dtype is None:
+        out_array_dtype = array.dtype
+    if buffer == 0:
+        return array.astype(out_array_dtype, copy=False)
+
+    return binary_dilation(array, iterations=buffer).astype(out_array_dtype, copy=False)

mapchete_eo/array/color.py

@@ -0,0 +1,29 @@
+import numpy as np
+import numpy.ma as ma
+
+
+def color_array(shape: tuple, hex_color: str):
+    colors = hex_to_rgb(hex_color)
+    return ma.masked_array(
+        [np.full(shape, color, dtype=np.uint8) for color in colors],
+        mask=ma.zeros((len(colors), *shape)),
+    )
+
+
+def hex_to_rgb(hex_color):
+    """
+    Convert hex color to tuple of RGB(A) colors.
+
+    e.g. "#FFFFFF" --> (255, 255, 255) or "#00FF00FF" --> (0, 255, 0, 255)
+    """
+    channels = iter(hex_color.lstrip("#"))
+    return tuple(int("".join(channel), 16) for channel in zip(channels, channels))
+
+
+def outlier_pixels(
+    arr: np.ndarray,
+    axis: int = 0,
+    range_threshold: int = 100,
+) -> np.ndarray:
+    """Detect outlier pixels containing extreme colors."""
+    return arr.max(axis=axis) - arr.min(axis=axis) >= range_threshold

mapchete_eo/array/convert.py

@@ -0,0 +1,157 @@
+from typing import List, Optional, Union
+
+import numpy as np
+import numpy.ma as ma
+import xarray as xr
+from mapchete.types import NodataVal
+
+# dtypes from https://numpy.org/doc/stable/user/basics.types.html
+_NUMPY_FLOAT_DTYPES = [
+    np.half,
+    np.float16,
+    np.single,
+    np.double,
+    np.longdouble,
+    np.csingle,
+    np.cdouble,
+    np.clongdouble,
+]
+
+
+def to_masked_array(
+    xarr: Union[xr.Dataset, xr.DataArray], copy: bool = False
+) -> ma.MaskedArray:
+    """Convert xr.DataArray to ma.MaskedArray."""
+    if isinstance(xarr, xr.Dataset):
+        xarr = xarr.to_array()
+
+    fill_value = xarr.attrs.get("_FillValue")
+    if fill_value is None:
+        raise ValueError(
+            "Cannot create masked_array because DataArray fill value is None"
+        )
+
+    if xarr.dtype in _NUMPY_FLOAT_DTYPES:
+        return ma.masked_values(xarr, fill_value, copy=copy, shrink=False)
+    else:
+        out = ma.masked_equal(xarr, fill_value, copy=copy)
+        # in case of a shrinked mask we have to expand it to the full array shape
+        if not isinstance(out.mask, np.ndarray):
+            out.mask = np.full(out.mask.shape, out.mask, dtype=bool)
+        return out
+
+
+def to_dataarray(
+    masked_arr: ma.MaskedArray,
+    nodataval: NodataVal = None,
+    name: Optional[str] = None,
+    band_names: Optional[List[str]] = None,
+    band_axis_name: str = "bands",
+    x_axis_name: str = "x",
+    y_axis_name: str = "y",
+    attrs: Optional[dict] = None,
+) -> xr.DataArray:
+    """
+    Convert ma.MaskedArray to xr.DataArray.
+
+    Depending on whether the array is 2D or 3D, the axes will be named accordingly.
+
+    A 2-dimensional array indicates that we only have a spatial x- and y-axis. A
+    3rd dimension will be interpreted as bands.
+    """
+    # nodata handling is weird.
+    #
+    # xr.DataArray cannot hold a masked_array but will turn it into
+    # a usual NumPy array, replacing the masked values with np.nan.
+    # However, this also seems to change the dtype to float32 which
+    # is not desirable.
+    nodataval = masked_arr.fill_value if nodataval is None else nodataval
+    attrs = attrs or dict()
+
+    if masked_arr.ndim == 2:
+        dims = [x_axis_name, y_axis_name]
+        coords = None
+    elif masked_arr.ndim == 3:
+        bands_count = masked_arr.shape[0]
+        band_names = band_names or [f"{band_axis_name}-{i}" for i in range(bands_count)]
+        dims = [band_axis_name, x_axis_name, y_axis_name]
+        coords = {band_axis_name: band_names}
+    else:  # pragma: no cover
+        raise TypeError("only a 2D or 3D ma.MaskedArray is allowed.")
+
+    return xr.DataArray(
+        data=masked_arr.filled(nodataval),
+        dims=dims,
+        name=name,
+        attrs=dict(attrs, _FillValue=nodataval),
+        coords=coords,
+    )
+
+
+def to_dataset(
+    masked_arr: ma.MaskedArray,
+    nodataval: NodataVal = None,
+    slice_names: Optional[List[str]] = None,
+    band_names: Optional[List[str]] = None,
+    slices_attrs: Optional[List[Union[dict, None]]] = None,
+    slice_axis_name: str = "time",
+    band_axis_name: str = "bands",
+    x_axis_name: str = "x",
+    y_axis_name: str = "y",
+    attrs: Optional[dict] = None,
+):
+    """Convert a 3D or 4D ma.MaskedArray to an xarray.Dataset."""
+    attrs = attrs or dict()
+    nodataval = masked_arr.fill_value if nodataval is None else nodataval
+
+    if masked_arr.ndim == 3:
+        bands = masked_arr.shape[0]
+        band_names = band_names or [f"{band_axis_name}-{i}" for i in range(bands)]
+        raise NotImplementedError()
+    elif masked_arr.ndim == 4:
+        slices, bands = masked_arr.shape[:2]
+        band_names = band_names or [f"{band_axis_name}-{i}" for i in range(bands)]
+        slice_names = slice_names or [f"{slice_axis_name}-{i}" for i in range(slices)]
+        slices_attrs = (
+            [None for _ in range(slices)] if slices_attrs is None else slices_attrs
+        )
+        coords = {slice_axis_name: slice_names}
+        return xr.Dataset(
+            data_vars={
+                # every slice gets its own xarray Dataset
+                slice_name: to_dataarray(
+                    slice_array,
+                    nodataval=nodataval,
+                    band_names=band_names,
+                    name=slice_name,
+                    attrs=slice_attrs,
+                    band_axis_name=band_axis_name,
+                    x_axis_name=x_axis_name,
+                    y_axis_name=y_axis_name,
+                )
+                for slice_name, slice_attrs, slice_array in zip(
+                    slice_names,
+                    slices_attrs,
+                    masked_arr,
+                )
+            },
+            coords=coords,
+            attrs=dict(attrs, _FillValue=nodataval),
+        ).transpose(slice_axis_name, band_axis_name, x_axis_name, y_axis_name)
+
+    else:  # pragma: no cover
+        raise TypeError("only a 3D or 4D ma.MaskedArray is allowed.")
+
+
+def to_bands_mask(arr: np.ndarray, bands: int = 1) -> np.ndarray:
+    """Expands a 2D mask to a full band mask."""
+    if arr.ndim != 2:
+        raise TypeError("input array has to have exactly 2 dimensions.")
+    return np.repeat(
+        np.expand_dims(
+            arr,
+            axis=0,
+        ),
+        bands,
+        axis=0,
+    )