kuva-reader 1.0.4__tar.gz → 1.1.1__tar.gz

{kuva_reader-1.0.4 → kuva_reader-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kuva-reader
-Version: 1.0.4
+Version: 1.1.1
 Summary: Manipulate the Kuva Space image and metadata formats
 License: MIT
 Author: Guillem Ballesteros
@@ -11,14 +11,12 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: kuva-geometry
-Requires-Dist: kuva-metadata
+Requires-Dist: kuva-geometry (>=1.0.1,<2.0.0)
+Requires-Dist: kuva-metadata (>=1.1.1,<2.0.0)
 Requires-Dist: numpy (>=1.26.4,<2.0.0)
 Requires-Dist: numpy-quaternion (>=2022.4.4,<2023.0.0)
 Requires-Dist: pint (>=0.22,<0.23)
 Requires-Dist: rasterio (>=1.4.1,<2.0.0)
-Requires-Dist: rioxarray (>=0.12.4,<0.13.0)
-Requires-Dist: xarray (>=2022.12.0,<2023.0.0)
 Description-Content-Type: text/markdown
 
 <div align="center">
@@ -36,7 +34,7 @@ The Kuva Space images are in GeoTIFF format. The products consist of an image or
 images along with its metadata to give all the necessary information to use the products. 
 The metadata lives either in a Kuva Space database, or alternatively in a sidecar JSON file. 
 
-This library allows the reading of the image GeoTIFFs into `xarray.Dataset` objects that 
+This library allows the reading of the image GeoTIFFs into `rasterio.DatasetReader` objects that 
 allow convenient raster manipulations, along with their `kuva-metadata` metadata objects.
 
 # Installation
@@ -56,7 +54,7 @@ pip install kuva-reader
 This is a minimal example that allows you to read and print the image shape of a L2 product.
 
 The result product is in this case an L2A product (as seen from the folder name).
-The loaded product is stored in a `rioxarray` object, which contains extensive GIS functionalities [(examples for usage)](https://corteva.github.io/rioxarray/stable/examples/examples.html).
+The loaded product is stored in a `rasterio.DatasetReader` object, which contains extensive GIS functionalities [(examples for usage)](https://rasterio.readthedocs.io/en/stable/api/rasterio.io.html#rasterio.io.DatasetReader).
 
 ```python
 from kuva_reader import read_product

{kuva_reader-1.0.4 → kuva_reader-1.1.1}/README.md

@@ -13,7 +13,7 @@ The Kuva Space images are in GeoTIFF format. The products consist of an image or
 images along with its metadata to give all the necessary information to use the products. 
 The metadata lives either in a Kuva Space database, or alternatively in a sidecar JSON file. 
 
-This library allows the reading of the image GeoTIFFs into `xarray.Dataset` objects that 
+This library allows the reading of the image GeoTIFFs into `rasterio.DatasetReader` objects that 
 allow convenient raster manipulations, along with their `kuva-metadata` metadata objects.
 
 # Installation
@@ -33,7 +33,7 @@ pip install kuva-reader
 This is a minimal example that allows you to read and print the image shape of a L2 product.
 
 The result product is in this case an L2A product (as seen from the folder name).
-The loaded product is stored in a `rioxarray` object, which contains extensive GIS functionalities [(examples for usage)](https://corteva.github.io/rioxarray/stable/examples/examples.html).
+The loaded product is stored in a `rasterio.DatasetReader` object, which contains extensive GIS functionalities [(examples for usage)](https://rasterio.readthedocs.io/en/stable/api/rasterio.io.html#rasterio.io.DatasetReader).
 
 ```python
 from kuva_reader import read_product

{kuva_reader-1.0.4 → kuva_reader-1.1.1}/kuva_reader/__init__.py

@@ -17,17 +17,14 @@ Key Features
 Dependencies
 - kuva-metadata: A specialized library that handles the extraction and
   parsing of metadata associated with Kuva Space products.
-- xarray: Used for loading image data as arrays with extra functionality,
-  including labeled coordinates and metadata, which is useful for analysis and
+- rasterio: Used for loading image data as arrays with extra functionality,
+  including GIS specific functions and metadata, which are useful for analysis and
   visualization.
 """
 
 __version__ = "0.1.0"
 
 from .reader.image import (
-    image_to_dtype_range,
-    image_to_original_range,
-    image_to_uint16_range,
     image_footprint,
 )
 from .reader.level0 import Level0Product
@@ -40,9 +37,6 @@ __all__ = [
     "Level1ABProduct",
     "Level1CProduct",
     "Level2AProduct",
-    "image_to_dtype_range",
-    "image_to_original_range",
-    "image_to_uint16_range",
     "image_footprint",
     "read_product",
 ]

kuva_reader-1.1.1/kuva_reader/reader/image.py

@@ -0,0 +1,28 @@
+"""Utilities to process images related to product processing."""
+
+import rasterio as rio
+from shapely.geometry import box, Polygon
+from rasterio.warp import transform_bounds
+
+
+def image_footprint(image: rio.DatasetReader, crs: str = "") -> Polygon:
+    """Return a product footprint as a shapely polygon
+
+    Parameters
+    ----------
+    image
+        The product image
+    crs, optional
+        CRS to convert to, by default "", keeping the image's CRS
+
+    Returns
+    -------
+        A shapely polygon footprint
+    """
+    if crs:
+        # Transform the bounds to the new CRS using rasterio's built-in function
+        bounds = transform_bounds(image.crs, crs, *image.bounds)
+        footprint = box(*bounds)
+    else:
+        footprint = box(*image.bounds)
+    return footprint

{kuva_reader-1.0.4 → kuva_reader-1.1.1}/kuva_reader/reader/level0.py

@@ -2,13 +2,12 @@ from pathlib import Path
 from typing import cast
 
 import numpy as np
-import rioxarray as rx
-import xarray
+import rasterio as rio
 from kuva_metadata import MetadataLevel0
 from pint import UnitRegistry
 from shapely import Polygon
 
-from kuva_reader import image_to_dtype_range, image_to_original_range, image_footprint
+from kuva_reader import image_footprint
 
 from .product_base import ProductBase
 
@@ -39,13 +38,6 @@ class Level0Product(ProductBase[MetadataLevel0]):
     target_ureg, optional
         Pint Unit Registry to swap to. This is only relevant when parsing data from a
         JSON file, which by default uses the kuva-metadata ureg.
-    as_physical_unit
-        Whether to denormalize data from full data type range back to the physical
-        units stored with the data, by default False
-    target_dtype
-        Target data type to normalize data to. This will first denormalize the data
-        to its original range and then normalize to new data type range to keep a
-        scale and offset, by default None
 
     Attributes
     ----------
@@ -53,10 +45,9 @@ class Level0Product(ProductBase[MetadataLevel0]):
         Path to the folder containing the images.
     metadata: MetadataLevel0
         The metadata associated with the images
-    images: Dict[str, xarray.DataArray]
-        The arrays with the actual data. This have the rioxarray extension activated on
-        them so lots of GIS functionality are available on them. Imporantly, the GCPs
-        can be retrieved like so: `ds.rio.get_gcps()`
+    images: Dict[str, rasterio.DatasetReader]
+        A dictionary that maps camera names to their respective Rasterio DatasetReader
+        objects.
     data_tags: Dict[str, Any]
         Tags stored along with the data. These can be used e.g. to check the physical
         units of pixels or normalisation factors.
@@ -67,55 +58,42 @@ class Level0Product(ProductBase[MetadataLevel0]):
         image_path: Path,
         metadata: MetadataLevel0 | None = None,
         target_ureg: UnitRegistry | None = None,
-        as_physical_unit: bool = False,
-        target_dtype: np.dtype | None = None,
     ) -> None:
         super().__init__(image_path, metadata, target_ureg)
 
         self.images = {
             camera: cast(
-                xarray.DataArray,
-                rx.open_rasterio(
+                rio.DatasetReader,
+                rio.open(
                     self.image_path / (cube.camera.name + ".tif"),
                 ),
             )
             for camera, cube in self.metadata.image.data_cubes.items()  # type: ignore
         }
-        self.crs = self.images[list(self.images.keys())[0]].rio.crs
+        self.crs = self.images[list(self.images.keys())[0]].crs
 
         # Read tags for images and denormalize / renormalize if needed
-        self.data_tags = {camera: img.attrs for camera, img in self.images.items()}
-        if as_physical_unit or target_dtype:
-            for camera, img in self.images.items():
-                # Move from normalized full scale back to original data float values.
-                # pop() since values not true anymore after denormalization.
-                norm_img = image_to_original_range(
-                    img,
-                    self.data_tags[camera].pop("data_offset"),
-                    self.data_tags[camera].pop("data_scale"),
-                )
-                self.images[camera] = norm_img
-
-                if target_dtype:
-                    # For algorithm needs, cast and normalize to a specific dtype range
-                    # NOTE: This may remove data precision e.g. uint16 -> uint8
-                    norm_img, offset, scale = image_to_dtype_range(img, target_dtype)
-                    self.data_tags[camera]["data_offset"] = offset
-                    self.data_tags[camera]["data_scale"] = scale
+        self.data_tags = {camera: src.tags() for camera, src in self.images.items()}
 
     def __repr__(self):
         """Pretty printing of the object with the most important info"""
         if self.images is not None and len(self.images):
+            image_shapes = []
+            for camera_name, image in self.images.items():
+                shape_str = f"({image.count}, {image.height}, {image.width})"
+                image_shapes.append(f"{camera_name.upper()} shape {shape_str}")
+
+            shapes_description = " and ".join(image_shapes)
+
             return (
-                f"{self.__class__.__name__}"
-                f"with VIS shape {self.images['vis'].shape} "
-                f"and NIR shape {self.images['nir'].shape} "
-                f"(CRS '{self.crs}'). Loaded from: '{self.image_path}'."
+                f"{self.__class__.__name__} "
+                f"with {shapes_description} and "
+                f"CRS: '{self.crs}'. Loaded from: '{self.image_path}'."
             )
         else:
             return f"{self.__class__.__name__} loaded from '{self.image_path}'."
 
-    def __getitem__(self, camera: str) -> xarray.DataArray:
+    def __getitem__(self, camera: str) -> rio.DatasetReader:
         """Return the datarray for the chosen camera."""
         return self.images[camera]
 
@@ -192,7 +170,11 @@ class Level0Product(ProductBase[MetadataLevel0]):
     def read_frame(self, cube: str, band_id: int, frame_idx: int) -> np.ndarray:
         """Extract a specific frame from a cube and band."""
         frame_offset = self.calculate_frame_offset(cube, band_id, frame_idx)
-        return self[cube][frame_offset, :, :].to_numpy()
+
+        # Rasterio index starts at 1
+        frame_offset += 1
+
+        return self[cube].read(frame_offset)
 
     def read_band(self, cube: str, band_id: int) -> np.ndarray:
         """Extract a specific band from a cube"""
@@ -201,7 +183,12 @@ class Level0Product(ProductBase[MetadataLevel0]):
         # Calculate the final frame offset for this band and frame
         band_offset_ll = band_offsets[band_id]
         band_offset_ul = band_offset_ll + band_n_frames[band_id]
-        return self[cube][band_offset_ll:band_offset_ul, :, :].to_numpy()
+
+        # Rasterio index starts at 1
+        band_offset_ll += 1
+        band_offset_ul += 1
+
+        return self[cube].read(list(np.arange(band_offset_ll, band_offset_ul)))
 
     def read_data_units(self) -> np.ndarray:
         """Read unit of product and validate they match between cameras"""
@@ -213,7 +200,7 @@ class Level0Product(ProductBase[MetadataLevel0]):
             e_ = "Cameras have different physical units stored to them."
             raise ValueError(e_)
 
-    def get_bad_pixel_mask(self, camera: str | None = None) -> xarray.Dataset:
+    def get_bad_pixel_mask(self, camera: str | None = None) -> rio.DatasetReader:
         """Get the bad pixel mask associated to each camera of the L0 product
 
         Returns
@@ -226,7 +213,7 @@ class Level0Product(ProductBase[MetadataLevel0]):
         bad_pixel_filename = f"{camera}_per_frame_bad_pixel_mask.tif"
         return self._read_array(self.image_path / bad_pixel_filename)
 
-    def get_cloud_mask(self, camera: str | None = None) -> xarray.Dataset:
+    def get_cloud_mask(self, camera: str | None = None) -> rio.DatasetReader:
         """Get the cloud mask associated to the product.
 
         Returns
@@ -240,12 +227,12 @@ class Level0Product(ProductBase[MetadataLevel0]):
         return self._read_array(self.image_path / bad_pixel_filename)
 
     def release_memory(self):
-        """Explicitely releases the memory of the `images` variable.
-
-        NOTE: this function is implemented because of a memory leak inside the Rioxarray
-        library that doesn't release memory properly. Only use it when the image data is
-        not needed anymore.
+        """Explicitely closes the Rasterio DatasetReaders and releases the memory of
+        the `images` variable.
         """
+        for k in self.images.keys():
+            self.images[k].close()
+
         del self.images
         self.images = None
 

{kuva_reader-1.0.4 → kuva_reader-1.1.1}/kuva_reader/reader/level1.py

@@ -1,13 +1,12 @@
 from pathlib import Path
 from typing import cast
 
-import rioxarray as rx
-import xarray
-from kuva_reader import image_footprint
+import rasterio as rio
 from kuva_metadata import MetadataLevel1AB, MetadataLevel1C
 from pint import UnitRegistry
 from shapely import Polygon
-from xarray import Dataset
+
+from kuva_reader import image_footprint
 
 from .product_base import ProductBase
 
@@ -36,10 +35,8 @@ class Level1ABProduct(ProductBase[MetadataLevel1AB]):
         Path to the folder containing the image.
     metadata: MetadataLevel1AB
         The metadata associated with the images
-    image: xarray.DataArray
-        The arrays with the actual data. This have the rioxarray extension activated on
-        them so lots of GIS functionality are available on them. For example, the GCPs
-        if any could be retrieved like so: `ds.rio.get_gcps()`
+    image: rasterio.DatasetReader
+        The Rasterio DatasetReader to open the image and other metadata with.
     data_tags: dict
         Tags saved along with the product. The tag "data_unit" shows what the unit of
         the product actually is.
@@ -54,20 +51,22 @@ class Level1ABProduct(ProductBase[MetadataLevel1AB]):
         super().__init__(image_path, metadata, target_ureg)
 
         self.image = cast(
-            Dataset,
-            rx.open_rasterio(self.image_path / "L1B.tif"),
+            rio.DatasetReader,
+            rio.open(self.image_path / "L1B.tif"),
         )
-        self.data_tags = self.image.attrs
+
+        self.data_tags = self.image.tags()
         self.wavelengths = [
             b.wavelength.to("nm").magnitude for b in self.metadata.image.bands
         ]
-        self.crs = self.image.rio.crs
+        self.crs = self.image.crs
 
     def __repr__(self):
         """Pretty printing of the object with the most important info"""
         if self.image is not None:
+            shape_str = f"({self.image.count}, {self.image.height}, {self.image.width})"
             return (
-                f"{self.__class__.__name__} with shape {self.image.shape} "
+                f"{self.__class__.__name__} with shape {shape_str} "
                 f"and wavelengths {self.wavelengths} (CRS: '{self.crs}'). "
                 f"Loaded from: '{self.image_path}'."
             )
@@ -110,7 +109,7 @@ class Level1ABProduct(ProductBase[MetadataLevel1AB]):
 
     def get_bad_pixel_mask(
         self, camera: str | None = None, per_band: bool = False
-    ) -> xarray.Dataset:
+    ) -> rio.DatasetReader:
         """Get the bad pixel mask associated to each camera of the L0 product
         Returns
         -------
@@ -128,11 +127,8 @@ class Level1ABProduct(ProductBase[MetadataLevel1AB]):
         return self._read_array(self.image_path / bad_pixel_filename)
 
     def release_memory(self):
-        """Explicitely releases the memory of the `image` variable.
-
-        NOTE: this function is implemented because of a memory leak inside the Rioxarray
-        library that doesn't release memory properly. Only use it when the image data is
-        not needed anymore.
+        """Explicitely closes the Rasterio DatasetReader and releases the memory of
+        the `image` variable.
         """
         del self.image
         self.image = None
@@ -159,10 +155,8 @@ class Level1CProduct(ProductBase[MetadataLevel1C]):
         Path to the folder containing the image.
     metadata: MetadataLevel1C
         The metadata associated with the images
-    image: xarray.DataArray
-        The arrays with the actual data. This have the rioxarray extension activated on
-        them so lots of GIS functionality are available on them. For example, the GCPs
-        if any could be retrieved like so: `ds.rio.get_gcps()`
+    image: rio.DatasetReader
+        The Rasterio DatasetReader to open the image and other metadata with.
     data_tags: dict
         Tags saved along with the product. The tag "data_unit" shows what the unit of
         the product actually is.
@@ -177,20 +171,22 @@ class Level1CProduct(ProductBase[MetadataLevel1C]):
         super().__init__(image_path, metadata, target_ureg)
 
         self.image = cast(
-            Dataset,
-            rx.open_rasterio(self.image_path / "L1C.tif"),
+            rio.DatasetReader,
+            rio.open(self.image_path / "L1C.tif"),
         )
-        self.data_tags = self.image.attrs
+        self.data_tags = self.image.tags()
+
         self.wavelengths = [
             b.wavelength.to("nm").magnitude for b in self.metadata.image.bands
         ]
-        self.crs = self.image.rio.crs
+        self.crs = self.image.crs
 
     def __repr__(self):
         """Pretty printing of the object with the most important info"""
         if self.image is not None:
+            shape_str = f"({self.image.count}, {self.image.height}, {self.image.width})"
             return (
-                f"{self.__class__.__name__} with shape {self.image.shape} "
+                f"{self.__class__.__name__} with shape {shape_str} "
                 f"and wavelengths {self.wavelengths} (CRS: '{self.crs}'). "
                 f"Loaded from: '{self.image_path}'."
             )
@@ -232,12 +228,10 @@ class Level1CProduct(ProductBase[MetadataLevel1C]):
         return metadata
 
     def release_memory(self):
-        """Explicitely releases the memory of the `image` variable.
-
-        NOTE: this function is implemented because of a memory leak inside the Rioxarray
-        library that doesn't release memory properly. Only use it when the image data is
-        not needed anymore.
+        """Explicitely closes the Rasterio DatasetReader and releases the memory of
+        the `image` variable.
         """
+        self.image.close()
         del self.image
         self.image = None
 

{kuva_reader-1.0.4 → kuva_reader-1.1.1}/kuva_reader/reader/level2.py

@@ -1,12 +1,12 @@
 from pathlib import Path
 from typing import cast
 
-import rioxarray as rx
-from kuva_reader import image_footprint
+import rasterio as rio
 from kuva_metadata import MetadataLevel2A
 from pint import UnitRegistry
 from shapely import Polygon
-from xarray import Dataset
+
+from kuva_reader import image_footprint
 
 from .product_base import ProductBase
 
@@ -32,10 +32,8 @@ class Level2AProduct(ProductBase[MetadataLevel2A]):
         Path to the folder containing the image.
     metadata: MetadataLevel2A
         The metadata associated with the images
-    image: xarray.DataArray
-        The arrays with the actual data. This have the rioxarray extension activated on
-        them so lots of GIS functionality are available on them. For example, the GCPs
-        if any could be retrieved like so: `ds.rio.get_gcps()`
+    image: rasterio.DatasetReader
+        The Rasterio DatasetReader to open the image and other metadata with.
     data_tags: dict
         Tags saved along with the product. The tag "data_unit" shows what the unit of
         the product actually is.
@@ -50,20 +48,22 @@ class Level2AProduct(ProductBase[MetadataLevel2A]):
         super().__init__(image_path, metadata, target_ureg)
 
         self.image = cast(
-            Dataset,
-            rx.open_rasterio(self.image_path / "L2A.tif"),
+            rio.DatasetReader,
+            rio.open(self.image_path / "L2A.tif"),
         )
-        self.data_tags = self.image.attrs
+        self.data_tags = self.image.tags()
+
         self.wavelengths = [
             b.wavelength.to("nm").magnitude for b in self.metadata.image.bands
         ]
-        self.crs = self.image.rio.crs
+        self.crs = self.image.crs
 
     def __repr__(self):
         """Pretty printing of the object with the most important info"""
         if self.image is not None:
+            shape_str = f"({self.image.count}, {self.image.height}, {self.image.width})"
             return (
-                f"{self.__class__.__name__} with shape {self.image.shape} "
+                f"{self.__class__.__name__} with shape {shape_str} "
                 f"and wavelengths {self.wavelengths} (CRS: '{self.crs}'). "
                 f"Loaded from: '{self.image_path}'."
             )
@@ -105,12 +105,10 @@ class Level2AProduct(ProductBase[MetadataLevel2A]):
         return metadata
 
     def release_memory(self):
-        """Explicitely releases the memory of the `image` variable.
-
-        NOTE: this function is implemented because of a memory leak inside the Rioxarray
-        library that doesn't release memory properly. Only use it when the image data is
-        not needed anymore.
+        """Explicitely closes the Rasterio DatasetReader and releases the memory of
+        the `image` variable.
         """
+        self.image.close()
         del self.image
         self.image = None
 

{kuva_reader-1.0.4 → kuva_reader-1.1.1}/kuva_reader/reader/product_base.py

@@ -2,11 +2,10 @@ from abc import ABCMeta, abstractmethod
 from pathlib import Path
 from typing import Generic, TypeVar, cast
 
-import rioxarray as rx
+import rasterio as rio
 from kuva_metadata.sections_common import MetadataBase
 from pint import UnitRegistry
 from pydantic import BaseModel
-from xarray import Dataset
 
 TMetadata = TypeVar("TMetadata", bound=BaseModel)
 
@@ -66,17 +65,17 @@ class ProductBase(Generic[TMetadata], metaclass=ABCMeta):
         pass
 
     @staticmethod
-    def _read_array(array_path: Path) -> Dataset:
+    def _read_array(array_path: Path) -> rio.DatasetReader:
         if array_path.exists():
             return cast(
-                Dataset,
-                rx.open_rasterio(array_path),
+                rio.DatasetReader,
+                rio.open(array_path),
             )
         else:
             e_ = f"Product does not contain the array to be read at '{array_path}'"
             raise ValueError(e_)
 
-    def get_bad_pixel_mask(self, camera: str | None = None) -> Dataset:
+    def get_bad_pixel_mask(self, camera: str | None = None) -> rio.DatasetReader:
         """Get the bad pixel mask associated to the product.
 
         Parameters
@@ -94,7 +93,7 @@ class ProductBase(Generic[TMetadata], metaclass=ABCMeta):
             raise ValueError(e_)
         return self._read_array(self.image_path / "bad_pixel_mask_aggregated.tif")
 
-    def get_cloud_mask(self, camera: str | None = None) -> Dataset:
+    def get_cloud_mask(self, camera: str | None = None) -> rio.DatasetReader:
         """Get the cloud mask associated to the product.
 
         Parameters

{kuva_reader-1.0.4 → kuva_reader-1.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "kuva-reader"
-version = "1.0.4"
+version = "1.1.1"
 description = "Manipulate the Kuva Space image and metadata formats"
 authors = ["Guillem Ballesteros <guillem@kuvaspace.com>" , "Lennert Antson <lennert.antson@kuvaspace.com>", "Arthur Vandenhoeke <arthur.vandenhoeke@kuvaspace.com>", "Olli Eloranta <olli.eloranta@kuvaspace.com>"]
 readme = "README.md"
@@ -28,10 +28,8 @@ numpy = "^1.26.4"
 numpy-quaternion = "^2022.4.4"
 pint = "^0.22"
 rasterio = "^1.4.1"
-xarray = "^2022.12.0"
-rioxarray = "^0.12.4"
-kuva-geometry = "*"
-kuva-metadata = "*"
+kuva-geometry = "^1.0.1"
+kuva-metadata = "^1.1.1"
 
 [tool.ruff.lint]
 select = [ "E", "F", "A", "DTZ", "NPY", "I", "ISC", "B003", "B004", "B015", "PTH", "D100", "D101", "D102", "D103", "D104", "D105", "D200", "W191", "W291", "W293", "N801", "N804", "N805", "T100", "S105", "S106", "S108", "S604", "S602", "S609", "UP003", "UP005", "UP006", "UP007", "UP008", "UP032", "UP035", "RUF001", "RUF200", "RUF013", "C901", "COM818", "RSE102", "EM101",]

kuva_reader-1.0.4/kuva_reader/reader/image.py

@@ -1,203 +0,0 @@
-"""Utilities to process images related to product processing."""
-
-from typing import cast, overload
-
-import numpy as np
-import xarray
-from shapely.geometry import box
-from pyproj import Transformer
-from shapely import Polygon
-
-# Helper type for image processing purposes. The same operations work both for EO
-# DataArrays and Numpy arrays.
-ImageArray_ = np.ndarray | xarray.DataArray
-
-def image_footprint(image: xarray.DataArray, crs: str = "") -> Polygon:
-    """Return a product footprint as a shapely polygon
-
-    Parameters
-    ----------
-    image
-        The product image
-    crs, optional
-        CRS to convert to, by default "", keeping the image's CRS
-
-    Returns
-    -------
-        A shapely polygon footprint
-    """
-    if crs:
-        transformer = Transformer.from_crs(image.rio.crs, crs, always_xy=True)
-        bounds = image.rio.bounds()
-        minx, miny = transformer.transform(bounds[0], bounds[1])
-        maxx, maxy = transformer.transform(bounds[2], bounds[3])
-        footprint = box(minx, miny, maxx, maxy)
-    else:
-        footprint = box(*image.rio.bounds())
-    return footprint
-
-
-@overload
-def image_to_dtype_range(
-    img: np.ndarray,
-    dtype: np.dtype,
-    offset: float | None = None,
-    scale: float | None = None,
-) -> tuple[xarray.DataArray, float, float]: ...
-
-
-@overload
-def image_to_dtype_range(
-    img: xarray.DataArray,
-    dtype: np.dtype,
-    offset: float | None = None,
-    scale: float | None = None,
-) -> tuple[xarray.DataArray, float, float]: ...
-
-
-def image_to_dtype_range(
-    img: ImageArray_,
-    dtype: np.dtype,
-    offset: float | None = None,
-    scale: float | None = None,
-) -> tuple[ImageArray_, float, float]:
-    """Normalize an image to the bounds of whatever numpy datatype. E.g. np.uint16
-    results in a np.uint16 image with values between entire range [0, 65535]
-
-    Parameters
-    ----------
-    img
-        Image to normalize
-    dtype
-        Target data type, only integer subtypes currently sensible and are supported
-    offset, optional
-        Offset if that was already precomputed. If not, it will be calculated from `arr`
-    scale, optional
-        Scale if that was already precomputed. If not, it will be calculated from `arr`
-
-    Returns
-    -------
-        The normalized image along casted to given data type, along with the offset and
-        scale used to normalize it
-
-    Raises
-    ------
-    ValueError
-        Unsupported data type
-    """
-    if np.issubdtype(dtype, np.integer):
-        type_info = np.iinfo(dtype)
-    else:
-        e_ = f"Unsupported dtype {dtype} for normalization"
-        raise ValueError(e_)
-
-    dtype_min = type_info.min
-    dtype_max = type_info.max
-
-    if offset is None or scale is None:
-        offset_ = cast(float, np.min(img))
-        scale_ = cast(float, np.max(img) - offset_)
-    else:
-        offset_ = offset
-        scale_ = scale
-
-    normed_to_0_1 = (img - offset_) / scale_
-
-    normalized_image = normed_to_0_1 * (dtype_max - dtype_min) + dtype_min
-    normalized_image = normalized_image.astype(dtype)
-
-    return normalized_image, offset_, scale_
-
-
-@overload
-def image_to_uint16_range(img: np.ndarray) -> tuple[np.ndarray, float, float]: ...
-
-
-@overload
-def image_to_uint16_range(
-    img: xarray.DataArray,
-) -> tuple[xarray.DataArray, float, float]: ...
-
-
-def image_to_uint16_range(img: ImageArray_) -> tuple[ImageArray_, float, float]:
-    """Normalise image to bounds of uint16, see above function for details
-
-    Parameters
-    ----------
-    img
-        Image to normalize
-
-    Returns
-    -------
-        The normalized image along casted to given data type, along with the offset and
-        scale used to normalize it
-    """
-    return image_to_dtype_range(img, np.dtype(np.uint16))
-
-
-@overload
-def image_to_original_range(
-    img: np.ndarray,
-    offset: float,
-    scale: float,
-    dtype: np.dtype | None = None,
-) -> xarray.DataArray: ...
-
-
-@overload
-def image_to_original_range(
-    img: xarray.DataArray,
-    offset: float,
-    scale: float,
-    dtype: np.dtype | None = None,
-) -> xarray.DataArray: ...
-
-
-def image_to_original_range(
-    img: ImageArray_,
-    offset: float,
-    scale: float,
-    dtype: np.dtype | None = None,
-) -> ImageArray_:
-    """Revert normalisation applied to an image. The image 'arr' must have the same
-    data type as the result from normalization, or it must be given separately
-
-    Parameters
-    ----------
-    arr
-        Image to revert back to original values
-    offset
-        Offset that was applied to the image
-    scale
-        Scale that was applied to the image
-    dtype, optional
-        The data type that the image was casted to during normalization, by default None
-        where the data type of `arr` will be assumed to be correct.
-
-    Returns
-    -------
-        Image that is back in original range of values before normalization
-
-    Raises
-    ------
-    ValueError
-        Unsupported data type
-    """
-    if not dtype:
-        dtype = img.dtype
-
-    # Check real bounds from numpy data types
-    if np.issubdtype(dtype, np.integer) and isinstance(dtype, np.dtype):
-        type_info = np.iinfo(dtype)
-    else:
-        e_ = f"Unsupported dtype {dtype} for normalization"
-        raise ValueError(e_)
-
-    dtype_min = type_info.min
-    dtype_max = type_info.max
-
-    # Reverse the normalization
-    denormed_to_0_1 = (img - dtype_min) / (dtype_max - dtype_min)
-    original_image = denormed_to_0_1 * scale + offset
-
-    return original_image