kuva-reader 1.0.3__py3-none-any.whl → 1.1.0__py3-none-any.whl

kuva_reader/__init__.py

@@ -17,17 +17,15 @@ 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
 from .reader.level1 import Level1ABProduct, Level1CProduct
@@ -39,8 +37,6 @@ __all__ = [
     "Level1ABProduct",
     "Level1CProduct",
     "Level2AProduct",
-    "image_to_dtype_range",
-    "image_to_original_range",
-    "image_to_uint16_range",
+    "image_footprint",
     "read_product",
 ]

kuva_reader/reader/image.py

@@ -1,176 +1,28 @@
 """Utilities to process images related to product processing."""
 
-from typing import cast, overload
+import rasterio as rio
+from shapely.geometry import box, Polygon
+from rasterio.warp import transform_bounds
 
-import numpy as np
-import xarray
 
-# Helper type for image processing purposes. The same operations work both for EO
-# DataArrays and Numpy arrays.
-ImageArray_ = np.ndarray | xarray.DataArray
-
-
-@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]
+def image_footprint(image: rio.DatasetReader, crs: str = "") -> Polygon:
+    """Return a product footprint as a shapely polygon
 
     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`
+    image
+        The product image
+    crs, optional
+        CRS to convert to, by default "", keeping the image's CRS
 
     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
+        A shapely polygon footprint
     """
-    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_)
+    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:
-        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
+        footprint = box(*image.bounds)
+    return footprint

kuva_reader/reader/level0.py

@@ -2,12 +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
+from kuva_reader import image_footprint
 
 from .product_base import ProductBase
 
@@ -38,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
     ----------
@@ -52,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.
@@ -66,54 +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]].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 {len(self.images)} frames of shape {self.images[0].shape} "
-                f"and CRS '{self.images[0].rio.crs}'. "
-                f"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]
 
@@ -121,6 +101,10 @@ class Level0Product(ProductBase[MetadataLevel0]):
         """Easy access to the camera keys."""
         return list(self.images.keys())
 
+    def footprint(self, crs="") -> Polygon:
+        """The product footprint as a Shapely polygon."""
+        return image_footprint(self.images["vis"], crs)
+
     def _get_data_from_sidecar(
         self, sidecar_path: Path, target_ureg: UnitRegistry | None = None
     ) -> MetadataLevel0:
@@ -186,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"""
@@ -195,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"""
@@ -207,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
@@ -220,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
@@ -234,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/reader/level1.py

@@ -1,11 +1,12 @@
 from pathlib import Path
 from typing import cast
 
-import rioxarray as rx
-import xarray
+import rasterio as rio
 from kuva_metadata import MetadataLevel1AB, MetadataLevel1C
 from pint import UnitRegistry
-from xarray import Dataset
+from shapely import Polygon
+
+from kuva_reader import image_footprint
 
 from .product_base import ProductBase
 
@@ -34,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.
@@ -52,10 +51,31 @@ 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.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 {shape_str} "
+                f"and wavelengths {self.wavelengths} (CRS: '{self.crs}'). "
+                f"Loaded from: '{self.image_path}'."
+            )
+        else:
+            return f"{self.__class__.__name__} loaded from '{self.image_path}'"
+
+    def footprint(self, crs="") -> Polygon:
+        """The product footprint as a Shapely polygon."""
+        return image_footprint(self.image, crs)
 
     def _get_data_from_sidecar(
         self, sidecar_path: Path, target_ureg: UnitRegistry | None = None
@@ -89,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
         -------
@@ -107,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
@@ -138,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.
@@ -156,25 +171,32 @@ 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.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"and wavelengths {self.wavelengths} (CRS: '{self.image.rio.crs}'). "
+                f"{self.__class__.__name__} with shape {shape_str} "
+                f"and wavelengths {self.wavelengths} (CRS: '{self.crs}'). "
                 f"Loaded from: '{self.image_path}'."
             )
         else:
             return f"{self.__class__.__name__} loaded from '{self.image_path}'"
 
+    def footprint(self, crs="") -> Polygon:
+        """The product footprint as a Shapely polygon."""
+        return image_footprint(self.image, crs)
+
     def _get_data_from_sidecar(
         self, sidecar_path: Path, target_ureg: UnitRegistry | None = None
     ) -> MetadataLevel1C:
@@ -206,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/reader/level2.py

@@ -1,10 +1,12 @@
 from pathlib import Path
 from typing import cast
 
-import rioxarray as rx
+import rasterio as rio
 from kuva_metadata import MetadataLevel2A
 from pint import UnitRegistry
-from xarray import Dataset
+from shapely import Polygon
+
+from kuva_reader import image_footprint
 
 from .product_base import ProductBase
 
@@ -30,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.
@@ -48,25 +48,32 @@ 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.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"and wavelengths {self.wavelengths} (CRS: '{self.image.rio.crs}'). "
+                f"{self.__class__.__name__} with shape {shape_str} "
+                f"and wavelengths {self.wavelengths} (CRS: '{self.crs}'). "
                 f"Loaded from: '{self.image_path}'."
             )
         else:
             return f"{self.__class__.__name__} loaded from '{self.image_path}'"
 
+    def footprint(self, crs="") -> Polygon:
+        """The product footprint as a Shapely polygon."""
+        return image_footprint(self.image, crs)
+
     def _get_data_from_sidecar(
         self, sidecar_path: Path, target_ureg: UnitRegistry | None = None
     ) -> MetadataLevel2A:
@@ -98,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/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/reader/read.py

@@ -25,7 +25,7 @@ def read_product(
 
     product_map = {
         "L0": Level0Product,
-        "L1AB": Level1ABProduct,
+        "L1B": Level1ABProduct,
         "L1C": Level1CProduct,
         "L2A": Level2AProduct,
     }

{kuva_reader-1.0.3.dist-info → kuva_reader-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kuva-reader
-Version: 1.0.3
+Version: 1.1.0
 Summary: Manipulate the Kuva Space image and metadata formats
 License: MIT
 Author: Guillem Ballesteros
@@ -17,8 +17,6 @@ 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,13 +54,13 @@ 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
 
-l2a_product = read_product("my_data_folder/hyperfield1a_L2A_20250105T092548")
-print(l2a_product)  # Will show some main information such as image shape and CRS
+product = read_product("my_data_folder/hyperfield1a_L2A_20250105T092548")
+print(product)  # Will show some main information such as image shape and CRS
 ```
 
 This assumes a mostly untouched folder after distributing. Otherwise, you may need to
@@ -75,7 +73,21 @@ l2a_product = Level2AProduct("your/l2a/folder")
 ```
 
 The actual raster image is stored and can be analysed in `product.image`, while metadata
-information of the product is in `product.metadata`. 
+information of the product is in `product.metadata`.
+
+## Other tips
+
+The product object attributes and methods allow the retrieval of other interesting information as well:
+
+```python
+from kuva_reader import read_product
+
+product = read_product("your/product/folder")
+product.footprint(crs="EPSG:4326")  # Footprint with option to transform CRS
+product.image.shape  # The image attribute contains all the image data
+product.wavelengths  # Wavelengths corresponding to image bands
+product.crs  # CRS
+```
 
 ## Processing levels
 

kuva_reader-1.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+kuva_reader/__init__.py,sha256=y0ViXqCoRSWvGPXEUFP9TOohcJIS24-WIarkZrDgcKs,1389
+kuva_reader/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kuva_reader/reader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kuva_reader/reader/image.py,sha256=rqzs5C7nzRArFfVepydRUECd3u55McTZlKINg76nMX4,785
+kuva_reader/reader/level0.py,sha256=u61sKRXmx4uljlnqPfuLdtdEGfkw5NdtiR9N6XfUsrA,9352
+kuva_reader/reader/level1.py,sha256=HRvhSasDEzB03qJi6wrQiv-r9kSdWITuWIf-2IbYqX4,8355
+kuva_reader/reader/level2.py,sha256=kGd-6qTZXiNWuYwwLf_-UWS0Oeng8iTpeQFXtAfyPXA,4106
+kuva_reader/reader/product_base.py,sha256=4NpZQk3FvSPsN2kKde8lHJA_0Wwy6DQBMfOh4ItlO00,4299
+kuva_reader/reader/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kuva_reader/reader/read.py,sha256=b5hGFbeJ-7sg-iilSJn29Hcqj4e7kiWT2S0BH2JwcDE,1761
+kuva_reader/reader/utils.py,sha256=oZ1G43nm8lCxzfbdqBs0KhKaXWe_uf-78uBXWvmZigs,1566
+kuva_reader-1.1.0.dist-info/METADATA,sha256=5nnnCGRiKQbC_Q0U6RZgx6hbX2MxZ5dXcOnjv6R8etY,5007
+kuva_reader-1.1.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+kuva_reader-1.1.0.dist-info/entry_points.txt,sha256=YJysY9EChfOb1W_IEht2oE5Z8Y9jA0J6-kofaPv-NdI,149
+kuva_reader-1.1.0.dist-info/RECORD,,

kuva_reader-1.0.3.dist-info/RECORD

@@ -1,15 +0,0 @@
-kuva_reader/__init__.py,sha256=qqsgtVNCkqXFuXOXf5v51ZT_Dcipj1ty0mGUw8fU3sU,1509
-kuva_reader/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kuva_reader/reader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kuva_reader/reader/image.py,sha256=Ep54Tzila3hKF2I_u-54xnFUf8WqP2fiKAJnbyZxasA,4647
-kuva_reader/reader/level0.py,sha256=-ONYaBH9YFHGaFvJDiDRlmXUWTYPQyQt0XZeuv5sEL4,10370
-kuva_reader/reader/level1.py,sha256=V1gNjz9y185nCJkYpQVcXrmAOQVMaFwIPeIhQJBzaI4,7815
-kuva_reader/reader/level2.py,sha256=lyEbVSLkBxz32ZIEnJih4ln-F_d8h6FTOu1Npt7VHg0,4091
-kuva_reader/reader/product_base.py,sha256=_O96DACi2bWEXhNJVuIU328RJ1y1gs7_rMyyEaMo4aA,4294
-kuva_reader/reader/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kuva_reader/reader/read.py,sha256=l2x-vlOLP8AUMzqSjHLaT7xt0YJtYUjiYWm6btV-rqo,1762
-kuva_reader/reader/utils.py,sha256=oZ1G43nm8lCxzfbdqBs0KhKaXWe_uf-78uBXWvmZigs,1566
-kuva_reader-1.0.3.dist-info/METADATA,sha256=XDxxOJM_4pUzFthDkE8vLYlLTbXtSCRzkOvCCTxYECs,4612
-kuva_reader-1.0.3.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-kuva_reader-1.0.3.dist-info/entry_points.txt,sha256=YJysY9EChfOb1W_IEht2oE5Z8Y9jA0J6-kofaPv-NdI,149
-kuva_reader-1.0.3.dist-info/RECORD,,