eoml 0.9.0__py3-none-any.whl

eoml/data/persistence/serializer.py

@@ -0,0 +1,82 @@
+"""MessagePack-based serializers for geospatial data and headers.
+
+This module provides efficient binary serialization using MessagePack format
+for geospatial dataset headers and numpy array data. MessagePack offers compact
+representation and fast serialization/deserialization, making it ideal for
+high-performance machine learning pipelines.
+
+Geometries are serialized as WKT (Well-Known Text) strings for portability
+and ease of reconstruction.
+"""
+
+import msgpack
+import numpy as np
+import shapely
+import shapely.wkt
+
+from eoml.data.basic_geo_data import GeoDataHeader
+from eoml.data.persistence.generic import GeoDataHeaderSerializer, GeoDataSerializer
+
+
+class MsgpackGeoDataHeaderSerializer(GeoDataHeaderSerializer):
+    """MessagePack serializer for GeoDataHeader objects.
+
+    Serializes geospatial sample headers including geometry (as WKT),
+    source file information, and sample identifiers.
+    """
+    def decode_geodata_header(self, obj):
+        """
+        if the field __header__ is in the obj to deserialize, create a GeodataHeader from the dic
+        """
+        if '__header__' in obj:
+            obj = GeoDataHeader(obj["id"], shapely.wkt.loads(obj["geometry"]), obj["file_name"])
+        return obj
+
+    def encode_geodata_header(self, obj):
+        """
+        transform the header to a dictionary of known type and add a field to recognise the type
+        """
+        if isinstance(obj, GeoDataHeader):
+            return {'__header__': True,
+                    "id": obj.idx,
+                    "geometry": obj.geometry.wkt,
+                    "file_name": obj.file_name.stem}
+        return obj
+
+    def serialize(self, header) -> bytes:
+        return msgpack.packb(header, default=self.encode_geodata_header, use_bin_type=True)
+
+    def deserialize(self, msg):
+        return msgpack.unpackb(msg, object_hook=self.decode_geodata_header, raw=False)
+
+
+class MsgpackGeoDataSerializer(GeoDataSerializer):
+    """MessagePack serializer for numpy array data.
+
+    Efficiently serializes numpy arrays by storing dtype, shape, and raw bytes,
+    enabling fast reconstruction without data loss.
+    """
+    def encode_geodata(self, obj):
+        """
+        Assum the data are a numpy array. Save it to bytes adding info about type and shape to reconstruct it
+        """
+        if isinstance(obj, np.ndarray):
+            return {'__array__': True,
+                    "dtype": obj.dtype.str,
+                    "shape": obj.shape,
+                    "data": obj.tobytes()}
+        return obj
+
+    def decode_geodata(self, obj):
+        """
+        Reconstruct numpy array
+        """
+        if '__array__' in obj:
+            obj = np.frombuffer(obj["data"], dtype=np.dtype(obj["dtype"])).reshape(obj["shape"])
+        return obj
+
+    def serialize(self, data)-> bytes:
+        return msgpack.packb(data, default=self.encode_geodata, use_bin_type=True)
+
+    def deserialize(self, msg):
+        return msgpack.unpackb(msg, object_hook=self.decode_geodata, raw=False)

eoml/raster/__init__.py

@@ -0,0 +1,7 @@
+"""
+Raster Module for EOML.
+
+This module provides utilities for reading, processing, and extracting data
+from raster files (GeoTIFFs). It includes raster readers, band management,
+and dataset extraction tools for machine learning applications.
+"""

eoml/raster/band.py

@@ -0,0 +1,141 @@
+"""
+Band management module for raster operations.
+
+This module provides the Band class for managing raster band selections,
+supporting both 0-indexed and 1-indexed band numbering systems used by
+different rasterio operations.
+"""
+from pathlib import Path
+
+import rasterio
+
+
+class Band:
+    """
+    Manage band numbers with support for both 0-indexed and 1-indexed access.
+
+    This class facilitates working with raster bands by maintaining both
+    0-indexed (Python-style) and 1-indexed (rasterio-style) band lists.
+    This is particularly useful when interfacing with rasterio, which uses
+    1-based indexing for band operations.
+
+    Attributes:
+        length (int): Number of bands in the selection.
+
+    Properties:
+        selected (list): 0-indexed list of band numbers (Python-style).
+        selected1 (list): 1-indexed list of band numbers (rasterio-style).
+
+    Examples:
+        >>> # Create a band selection for bands 0, 1, 2
+        >>> bands = Band([0, 1, 2])
+        >>> print(bands.selected)   # [0, 1, 2]
+        >>> print(bands.selected1)  # [1, 2, 3]
+        >>>
+        >>> # Create from a file
+        >>> bands = Band.from_file("path/to/raster.tif")
+    """
+
+    def __init__(self, selected):
+        """
+        Initialize a Band instance with a list of band numbers.
+
+        Args:
+            selected (list): List of 0-indexed band numbers to select.
+
+        Raises:
+            Exception: If selected is None.
+
+        Examples:
+            >>> bands = Band([0, 2, 4])  # Select bands 0, 2, and 4
+        """
+        if selected == None:
+            raise Exception("specify a band range")
+
+        self._selected = selected.copy()
+        self._selected1 = [b+1 for b in selected]
+        self.length = len(self.selected)
+
+    @classmethod
+    def from_file(cls, raster_path:Path):
+        """
+        Create a Band instance from a raster file, selecting all bands.
+
+        This class method reads a raster file and creates a Band object
+        containing all bands present in the file.
+
+        Args:
+            raster_path (str): Path to the raster file.
+
+        Returns:
+            Band: Band instance containing all bands from the raster.
+
+        Examples:
+            >>> bands = Band.from_file("/path/to/satellite_image.tif")
+            >>> print(len(bands))  # Number of bands in the file
+        """
+        with rasterio.open(raster_path) as src:
+            length = src.count
+
+        selected = list(range(length))
+
+        return cls(selected)
+
+    def remove(self, band):
+        """
+        Remove a band from the selection.
+
+        Args:
+            band (int): 0-indexed band number to remove.
+
+        Examples:
+            >>> bands = Band([0, 1, 2, 3])
+            >>> bands.remove(2)  # Remove band 2
+            >>> print(bands.selected)  # [0, 1, 3]
+        """
+        self._selected.remove(band)
+        self._selected1.remove(band+1)
+
+    def append(self, band):
+        """
+        Add a band to the selection.
+
+        Args:
+            band (int): 0-indexed band number to add.
+
+        Examples:
+            >>> bands = Band([0, 1])
+            >>> bands.append(2)  # Add band 2
+            >>> print(bands.selected)  # [0, 1, 2]
+        """
+        self._selected.append(band)
+        self._selected1.append(band+1)
+
+    @property
+    def selected(self):
+        """
+        Get the 0-indexed band list (Python-style).
+
+        Returns:
+            list: List of 0-indexed band numbers.
+        """
+        return self._selected
+
+    @property
+    def selected1(self):
+        """
+        Get the 1-indexed band list (rasterio-style).
+
+        Returns:
+            list: List of 1-indexed band numbers.
+        """
+        return self._selected1
+
+    def __len__(self):
+        """
+        Get the number of bands in the selection.
+
+        Returns:
+            int: Number of selected bands.
+        """
+        return self.length

eoml/raster/dataset/__init__.py

@@ -0,0 +1,6 @@
+"""
+Raster Dataset Submodule.
+
+This submodule provides tools for extracting training datasets from raster
+files, including efficient window extraction and multi-threaded processing.
+"""