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

mapchete_eo/image_operations/filters.py

@@ -0,0 +1,319 @@
+import logging
+
+import numpy as np
+from PIL import Image, ImageFilter
+from rasterio.plot import reshape_as_image, reshape_as_raster
+from scipy import ndimage
+
+logger = logging.getLogger(__name__)
+
+
+# filters for 8 bit data:
+#########################
+
+FILTERS = {
+    "blur": ImageFilter.BLUR,
+    "contour": ImageFilter.CONTOUR,
+    "detail": ImageFilter.DETAIL,
+    "edge_enhance": ImageFilter.EDGE_ENHANCE,
+    "edge_enhance_more": ImageFilter.EDGE_ENHANCE_MORE,
+    "emboss": ImageFilter.EMBOSS,
+    "find_edges": ImageFilter.FIND_EDGES,
+    "sharpen": ImageFilter.SHARPEN,
+    "smooth": ImageFilter.SMOOTH,
+    "smooth_more": ImageFilter.SMOOTH_MORE,
+}
+
+FILTER_FUNCTIONS = {
+    "unsharp_mask": ImageFilter.UnsharpMask,
+    "median": ImageFilter.MedianFilter,
+    "gaussian_blur": ImageFilter.GaussianBlur,
+}
+
+
+def _apply_filter(arr: np.ndarray, img_filter: str, **kwargs) -> np.ndarray:
+    if arr.dtype != "uint8":
+        raise TypeError("input array type must be uint8")
+    if arr.ndim != 3:
+        raise TypeError("input array must be 3-dimensional")
+    if arr.shape[0] != 3:
+        raise TypeError("input array must have exactly three bands")
+    if img_filter in FILTERS:
+        return np.clip(
+            reshape_as_raster(
+                Image.fromarray(reshape_as_image(arr)).filter(FILTERS[img_filter])
+            ),
+            1,
+            255,
+        ).astype("uint8", copy=False)
+    elif img_filter in FILTER_FUNCTIONS:
+        return np.clip(
+            reshape_as_raster(
+                Image.fromarray(reshape_as_image(arr)).filter(
+                    FILTER_FUNCTIONS[img_filter](**kwargs)
+                )
+            ),
+            1,
+            255,
+        ).astype("uint8", copy=False)
+    else:
+        raise KeyError(f"{img_filter} not found")
+
+
+def blur(arr: np.ndarray) -> np.ndarray:
+    """
+    Apply PIL blur filter to array and return.
+
+    Parameters
+    ----------
+    arr : 3-dimensional uint8 NumPy array
+
+    Returns
+    -------
+    NumPy array
+    """
+    return _apply_filter(arr, "blur")
+
+
+def contour(arr: np.ndarray) -> np.ndarray:
+    """
+    Apply PIL contour filter to array and return.
+
+    Parameters
+    ----------
+    arr : 3-dimensional uint8 NumPy array
+
+    Returns
+    -------
+    NumPy array
+    """
+    return _apply_filter(arr, "contour")
+
+
+def detail(arr: np.ndarray) -> np.ndarray:
+    """
+    Apply PIL detail filter to array and return.
+
+    Parameters
+    ----------
+    arr : 3-dimensional uint8 NumPy array
+
+    Returns
+    -------
+    NumPy array
+    """
+    return _apply_filter(arr, "detail")
+
+
+def edge_enhance(arr: np.ndarray) -> np.ndarray:
+    """
+    Apply PIL edge_enhance filter to array and return.
+
+    Parameters
+    ----------
+    arr : 3-dimensional uint8 NumPy array
+
+    Returns
+    -------
+    NumPy array
+    """
+    return _apply_filter(arr, "edge_enhance")
+
+
+def edge_enhance_more(arr: np.ndarray) -> np.ndarray:
+    """
+    Apply PIL edge_enhance_more filter to array and return.
+
+    Parameters
+    ----------
+    arr : 3-dimensional uint8 NumPy array
+
+    Returns
+    -------
+    NumPy array
+    """
+    return _apply_filter(arr, "edge_enhance_more")
+
+
+def emboss(arr: np.ndarray) -> np.ndarray:
+    """
+    Apply PIL emboss filter to array and return.
+
+    Parameters
+    ----------
+    arr : 3-dimensional uint8 NumPy array
+
+    Returns
+    -------
+    NumPy array
+    """
+    return _apply_filter(arr, "emboss")
+
+
+def find_edges(arr: np.ndarray) -> np.ndarray:
+    """
+    Apply PIL find_edges filter to array and return.
+
+    Parameters
+    ----------
+    arr : 3-dimensional uint8 NumPy array
+
+    Returns
+    -------
+    NumPy array
+    """
+    return _apply_filter(arr, "find_edges")
+
+
+def sharpen(arr: np.ndarray) -> np.ndarray:
+    """
+    Apply PIL sharpen filter to array and return.
+
+    Parameters
+    ----------
+    arr : 3-dimensional uint8 NumPy array
+
+    Returns
+    -------
+    NumPy array
+    """
+    return _apply_filter(arr, "sharpen")
+
+
+def smooth(arr: np.ndarray) -> np.ndarray:
+    """
+    Apply PIL smooth filter to array and return.
+
+    Parameters
+    ----------
+    arr : 3-dimensional uint8 NumPy array
+
+    Returns
+    -------
+    NumPy array
+    """
+    return _apply_filter(arr, "smooth")
+
+
+def smooth_more(arr: np.ndarray) -> np.ndarray:
+    """
+    Apply PIL smooth_more filter to array and return.
+
+    Parameters
+    ----------
+    arr : 3-dimensional uint8 NumPy array
+
+    Returns
+    -------
+    NumPy array
+    """
+    return _apply_filter(arr, "smooth_more")
+
+
+def unsharp_mask(
+    arr: np.ndarray, radius: int = 2, percent: float = 150, threshold: float = 3
+) -> np.ndarray:
+    """
+    Apply PIL UnsharpMask filter to array and return.
+
+    Parameters
+    ----------
+    arr : 3-dimensional uint8 NumPy array
+
+    Returns
+    -------
+    NumPy array
+    """
+    return _apply_filter(
+        arr, "unsharp_mask", radius=radius, percent=percent, threshold=threshold
+    )
+
+
+def median(arr: np.ndarray, size: int = 3) -> np.ndarray:
+    """
+    Apply PIL MedianFilter to array and return.
+
+    Parameters
+    ----------
+    arr : 3-dimensional uint8 NumPy array
+
+    Returns
+    -------
+    NumPy array
+    """
+    return _apply_filter(arr, "median", size=size)
+
+
+def gaussian_blur(arr: np.ndarray, radius: int = 2) -> np.ndarray:
+    """
+    Apply PIL GaussianBlur to array and return.
+
+    Parameters
+    ----------
+    arr : 3-dimensional uint8 NumPy array
+
+    Returns
+    -------
+    NumPy array
+    """
+    return _apply_filter(arr, "gaussian_blur", radius=radius)
+
+
+# filters for 16 bit data:
+##########################
+
+
+def sharpen_16bit(arr: np.ndarray) -> np.ndarray:
+    # kernel_3x3_highpass = np.array([
+    #     0, -1, 0,
+    #     -1, 5, -1,
+    #     0, -1, 0
+    # ]).reshape((3, 3))
+    # kernel_3x3_highpass = np.array([
+    #     0, -1/4, 0,
+    #     -1/4, 2, -1/4,
+    #     0, -1/4, 0
+    # ]).reshape((3, 3))
+    # kernel_5x5_highpass = np.array([
+    #     0, -1, -1, -1, 0,
+    #     -1, -2, -4, 2, -1,
+    #     -1, -4, 13, -4, -1,
+    #     -1, 2, -4, 2, -1,
+    #     0, -1, -1, -1, 0
+    # ]).reshape((5, 5))
+    # kernel_mean = np.array([
+    #     1, 1, 1,
+    #     1, 1, 1,
+    #     1, 1, 1
+    # ]).reshape((3, 3))
+    # kernel = np.array([
+    #     [1, 1, 1],
+    #     [1, 1, 0],
+    #     [1, 0, 0]
+    # ]).reshape((3, 3))
+    # kernel = np.array([
+    #     0, -1, 0,
+    #     -1, 8, -1,
+    #     0, -1, 0
+    # ]).reshape((3, 3))
+    # Various High Pass Filters
+    # b = ndimage.minimum_filter(b, 3)
+    # b = ndimage.percentile_filter(b, 50, 3)
+    # imgsharp = ndimage.convolve(b_smoothed, kernel_3x3_highpass, mode='nearest')
+    # imgsharp = ndimage.median_filter(imgsharp, 2)
+    # imgsharp = reshape_as_raster(np.asarray(imgsharp))
+    # Official SciPy unsharpen mask filter not working
+
+    # Unshapen Mask Filter, working version as the one above is not working
+    return np.stack(
+        [
+            ndimage.percentile_filter(
+                b
+                + (b - ndimage.percentile_filter(b, 35, arr.shape[0], mode="nearest")),
+                45,
+                2,
+                mode="nearest",
+            )
+            for b in arr
+        ]
+    ).astype(arr.dtype, copy=False)

mapchete_eo/image_operations/linear_normalization.py

@@ -0,0 +1,81 @@
+from typing import Optional, Tuple
+
+import numpy as np
+import numpy.ma as ma
+from numpy.typing import DTypeLike
+from rasterio.dtypes import dtype_ranges
+
+
+def linear_normalization(
+    bands: ma.MaskedArray,
+    bands_minmax_values: Tuple[Tuple[int, int], Tuple[int, int], Tuple[int, int]] = (
+        (5, 3350),
+        (0, 3150),
+        (0, 3200),
+    ),
+    out_dtype: DTypeLike = np.uint8,
+    out_min: Optional[int] = None,
+) -> ma.MaskedArray:
+    """
+    Scale and normalize bands to individual minimum and maximum values.
+
+    From eox_preprocessing.image_utils
+
+    See: https://en.wikipedia.org/wiki/Normalization_(image_processing)
+
+    Parameters
+    ----------
+    bands : np.ndarray
+        Input bands as a 3D array.
+    bands_minmax_values : list of lists
+        Individual minimum and maximum values for each band. Must have the same length as
+        number of bands.
+    out_min : float or int
+        Override dtype minimum. Useful when nodata value is equal to dtype minimum (e.g. 0
+        at uint8). In that case out_min can be set to 1.
+
+    Returns
+    -------
+    scaled bands : ma.MaskedArray
+    """
+    if len(bands_minmax_values) != bands.shape[0]:
+        raise ValueError("bands and bands_minmax_values must have the same length")
+    try:
+        if isinstance(out_dtype, str):
+            dtype_str = out_dtype
+        else:
+            dtype_str = str(out_dtype).split(".")[1].split("'")[0]
+        if out_min is None:
+            out_min, out_max = dtype_ranges[dtype_str]
+        else:
+            out_max = dtype_ranges[dtype_str][1]
+    except KeyError:
+        raise KeyError(f"invalid out_dtype: {out_dtype}")
+
+    # Clip the Input values first to avoid awkward data
+    clipped_bands = np.stack(
+        [
+            np.where(
+                np.where(b > b_max, b_max, b) < b_min,
+                b_min,
+                np.where(b > b_max, b_max, b),
+            )
+            for b, (b_min, b_max) in zip(bands, bands_minmax_values)
+        ]
+    )
+
+    lin_normalized = np.clip(
+        np.stack(
+            [
+                (b - b_min) * (out_max / (b_max - b_min)) + out_min
+                for b, (b_min, b_max) in zip(clipped_bands, bands_minmax_values)
+            ]
+        ),
+        out_min,
+        out_max,
+    ).astype(out_dtype, copy=False)
+
+    # (2) clip and return using the original nodata mask
+    return ma.MaskedArray(
+        data=lin_normalized, mask=bands.mask, fill_value=bands.fill_value
+    )

mapchete_eo/image_operations/sigmoidal.py

@@ -0,0 +1,114 @@
+import numpy as np
+from numpy.typing import DTypeLike
+
+# The type to be used for all intermediate math
+# operations. Should be a float because values will
+# be scaled to the range 0..1 for all work.
+
+math_type = np.float16
+
+epsilon = float(np.finfo(math_type).eps)
+
+
+def sigmoidal(
+    arr: np.ndarray,
+    contrast: int,
+    bias: float,
+    out_dtype: DTypeLike = np.float16,
+):
+    """
+    Taken from rio-color (consult sevcikp for changes)
+
+    Sigmoidal contrast is type of contrast control that
+    adjusts the contrast without saturating highlights or shadows.
+    It allows control over two factors:
+    the contrast range from light to dark, and where the middle value
+    of the mid-tones falls. The result is a non-linear and smooth
+    contrast change.
+
+    Parameters
+    ----------
+    arr : ndarray, float, 0 .. 1
+        Array of color values to adjust
+    contrast : integer
+        Enhances the intensity differences between the lighter and darker
+        elements of the image. For example, 0 is none, 3 is typical and
+        20 is a lot.
+    bias : float, between 0 and 1
+        Threshold level for the contrast function to center on
+        (typically centered at 0.5)
+
+    Notes
+    ----------
+
+    Sigmoidal contrast is based on the sigmoidal transfer function:
+
+    .. math:: g(u) = ( 1/(1 + e^{- \alpha * u + \beta)})
+
+    This sigmoid function is scaled so that the output is bound by
+    the interval [0, 1].
+
+    .. math:: ( 1/(1 + e^(\beta * (\alpha - u))) - 1/(1 + e^(\beta * \alpha)))/
+        ( 1/(1 + e^(\beta*(\alpha - 1))) - 1/(1 + e^(\beta * \alpha)) )
+
+    Where :math: `\alpha` is the threshold level, and :math: `\beta` the
+    contrast factor to be applied.
+
+    References
+    ----------
+    .. [CT] Hany Farid "Fundamentals of Image Processing"
+            http://www.cs.dartmouth.edu/farid/downloads/tutorials/fip.pdf
+
+    """
+    if isinstance(out_dtype, str):
+        out_dtype = np.dtype(getattr(np, out_dtype))
+    if not isinstance(out_dtype, np.dtype):
+        raise TypeError(
+            f"Harmonization dtype needs to be valid numpy dtype is: {type(out_dtype)}"
+        )
+
+    if (arr.max() > 1.0 + epsilon) or (arr.min() < 0 - epsilon):
+        raise ValueError("Input array must have float values between 0 and 1")
+
+    if (bias > 1.0 + epsilon) or (bias < 0 - epsilon):
+        raise ValueError("bias must be a scalar float between 0 and 1")
+
+    alpha, beta = bias, contrast
+    # We use the names a and b to match documentation.
+
+    if alpha == 0.0:
+        alpha = epsilon
+
+    if beta == 0.0:
+        return arr.astype(out_dtype, copy=False)
+
+    np.seterr(divide="ignore", invalid="ignore")
+    if beta > 0:
+        numerator = 1 / (1 + np.exp(beta * (alpha - arr))) - 1 / (
+            1 + np.exp(beta * alpha)
+        )
+        denominator = 1 / (1 + np.exp(beta * (alpha - 1))) - 1 / (
+            1 + np.exp(beta * alpha)
+        )
+        return (numerator / denominator).astype(out_dtype, copy=False)
+
+    else:
+        # Inverse sigmoidal function:
+        # todo: account for 0s
+        return (
+            (
+                (beta * alpha)
+                - np.log(
+                    (
+                        1
+                        / (
+                            (arr / (1 + np.exp(beta * alpha - beta)))
+                            - (arr / (1 + np.exp(beta * alpha)))
+                            + (1 / (1 + np.exp(beta * alpha)))
+                        )
+                    )
+                    - 1
+                )
+            )
+            / beta
+        ).astype(out_dtype, copy=False)

mapchete_eo/io/__init__.py

@@ -0,0 +1,37 @@
+from mapchete_eo.io.assets import (
+    convert_asset,
+    copy_asset,
+    get_assets,
+    read_mask_as_raster,
+)
+from mapchete_eo.io.items import get_item_property, item_fix_footprint, item_to_np_array
+from mapchete_eo.io.levelled_cubes import (
+    read_levelled_cube_to_np_array,
+    read_levelled_cube_to_xarray,
+)
+from mapchete_eo.io.path import get_product_cache_path, open_xml, path_in_paths
+from mapchete_eo.io.products import (
+    merge_products,
+    products_to_np_array,
+    products_to_slices,
+    products_to_xarray,
+)
+
+__all__ = [
+    "get_assets",
+    "convert_asset",
+    "copy_asset",
+    "item_to_np_array",
+    "products_to_xarray",
+    "products_to_np_array",
+    "products_to_slices",
+    "merge_products",
+    "get_item_property",
+    "item_fix_footprint",
+    "open_xml",
+    "get_product_cache_path",
+    "path_in_paths",
+    "read_mask_as_raster",
+    "read_levelled_cube_to_np_array",
+    "read_levelled_cube_to_xarray",
+]