Merge pull request #209 from siapy/fix

Author: janezlapajne

Makefile

@@ -58,6 +58,10 @@ generate-docs:
 
 .PHONY: serve-docs  ## Serve the docs
 serve-docs:
+	pdm run mkdocs serve
+
+.PHONY: serve-docs-mike  ## Serve the docs using mike
+serve-docs-mike:
 	pdm run mike serve
 
 .PHONY: version  ## Check project version

docs/api/entities/helpers.md

@@ -0,0 +1 @@
+::: siapy.entities.helpers

docs/api/entities/images/mock.md

@@ -0,0 +1 @@
+::: siapy.entities.images.mock

mkdocs.yml

@@ -87,19 +87,21 @@ nav:
               - Interfaces: api/entities/images/interfaces.md
               - Rasterio Library: api/entities/images/rasterio_lib.md
               - Spectral Library: api/entities/images/spectral_lib.md
+              - Mock Image: api/entities/images/mock.md
               - Spectral Images: api/entities/images/spimage.md
           - Shape: api/entities/shapes/shape.md
           - Image Sets: api/entities/imagesets.md
           - Pixels: api/entities/pixels.md
           - Signatures: api/entities/signatures.md
+          - Helpers: api/entities/helpers.md
       - Features:
           - Features: api/features/features.md
           - Helpers: api/features/helpers.md
           - Spectral Indices: api/features/spectral_indices.md
       - Optimizers:
           - Configs: api/optimizers/configs.md
           - Evaluators: api/optimizers/evaluators.md
-          - Metrics: api/models/metrics.md
+          - Metrics: api/optimizers/metrics.md
           - Optimizers: api/optimizers/optimizers.md
           - Parameters: api/optimizers/parameters.md
           - Scorers: api/optimizers/scorers.md

siapy/datasets/tabular.py

@@ -9,6 +9,7 @@
 from siapy.core.types import ImageContainerType
 from siapy.datasets.schemas import TabularDatasetData
 from siapy.entities import Signatures, SpectralImage, SpectralImageSet
+from siapy.entities.helpers import get_signatures_within_convex_hull
 
 __all__ = [
     "TabularDataset",
@@ -62,9 +63,8 @@ def process_image_data(self) -> None:
         self.data_entities.clear()
         for image_idx, image in enumerate(self.image_set):
             for shape_idx, shape in enumerate(image.geometric_shapes.shapes):
-                convex_hulls = shape.get_pixels_within_convex_hull()
-                for geometry_idx, pixels in enumerate(convex_hulls):
-                    signatures = image.to_signatures(pixels)
+                signatures_hull = get_signatures_within_convex_hull(image, shape)
+                for geometry_idx, signatures in enumerate(signatures_hull):
                     entity = TabularDataEntity(
                         image_idx=image_idx,
                         shape_idx=shape_idx,

siapy/entities/helpers.py

@@ -0,0 +1,64 @@
+import itertools
+
+from shapely.geometry import MultiPoint, Point
+from shapely.prepared import prep as shapely_prep
+
+from siapy.core.exceptions import InvalidTypeError
+from siapy.entities import Shape, Signatures, SpectralImage
+from siapy.entities.pixels import Pixels
+from siapy.entities.signatures import Signals
+
+
+def get_signatures_within_convex_hull(image: SpectralImage, shape: Shape) -> list[Signatures]:
+    image_xarr = image.to_xarray()
+    signatures = []
+
+    if shape.is_point:
+        for g in shape.geometry:
+            if isinstance(g, MultiPoint):
+                points = list(g.geoms)
+            elif isinstance(g, Point):
+                points = [g]
+            else:
+                raise InvalidTypeError(
+                    input_value=g,
+                    allowed_types=(Point, MultiPoint),
+                    message="Geometry must be Point or MultiPoint",
+                )
+            signals = []
+            pixels = []
+            for p in points:
+                signals.append(image_xarr.sel(x=p.x, y=p.y, method="nearest").values)
+                pixels.append((p.x, p.y))
+
+            signatures.append(Signatures(Pixels.from_iterable(pixels), Signals.from_iterable(signals)))
+
+    else:
+        for hull in shape.convex_hull:
+            minx, miny, maxx, maxy = hull.bounds
+
+            x_coords = image_xarr.x[(image_xarr.x >= minx) & (image_xarr.x <= maxx)].values
+            y_coords = image_xarr.y[(image_xarr.y >= miny) & (image_xarr.y <= maxy)].values
+
+            if len(x_coords) == 0 or len(y_coords) == 0:
+                continue
+
+            # Create a prepared geometry for faster contains check
+            prepared_hull = shapely_prep(hull)
+
+            signals = []
+            pixels = []
+            for x, y in itertools.product(x_coords, y_coords):
+                point = Point(x, y)
+                # Check if point is: inside the hull or intersects with the hull
+                if prepared_hull.contains(point) or prepared_hull.intersects(point):
+                    try:
+                        signal = image_xarr.sel(x=x, y=y).values
+                    except (KeyError, IndexError):
+                        continue
+                    signals.append(signal)
+                    pixels.append((x, y))
+
+            signatures.append(Signatures(Pixels.from_iterable(pixels), Signals.from_iterable(signals)))
+
+    return signatures

siapy/entities/images/mock.py

@@ -0,0 +1,103 @@
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+import xarray as xr
+from numpy.typing import NDArray
+from PIL import Image
+
+from siapy.core.exceptions import InvalidInputError
+from siapy.entities.images.interfaces import ImageBase
+
+if TYPE_CHECKING:
+    from siapy.core.types import XarrayType
+
+
+class MockImage(ImageBase):
+    def __init__(
+        self,
+        array: NDArray[np.floating[Any]],
+    ) -> None:
+        if len(array.shape) != 3:
+            raise InvalidInputError(
+                input_value=array.shape,
+                message="Input array must be 3-dimensional (height, width, bands)",
+            )
+
+        self._array = array.astype(np.float32)
+
+    @classmethod
+    def open(cls, array: NDArray[np.floating[Any]]) -> "MockImage":
+        return cls(array=array)
+
+    @property
+    def filepath(self) -> Path:
+        return Path()
+
+    @property
+    def metadata(self) -> dict[str, Any]:
+        return {}
+
+    @property
+    def shape(self) -> tuple[int, int, int]:
+        x = self._array.shape[1]
+        y = self._array.shape[0]
+        bands = self._array.shape[2]
+        return (y, x, bands)
+
+    @property
+    def bands(self) -> int:
+        return self._array.shape[2]
+
+    @property
+    def default_bands(self) -> list[int]:
+        if self.bands >= 3:
+            return [0, 1, 2]
+        return list(range(min(3, self.bands)))
+
+    @property
+    def wavelengths(self) -> list[float]:
+        return list(range(self.bands))
+
+    @property
+    def camera_id(self) -> str:
+        return ""
+
+    def to_display(self, equalize: bool = True) -> Image.Image:
+        if self.bands >= 3:
+            display_bands = self._array[:, :, self.default_bands]
+        else:
+            display_bands = np.stack([self._array[:, :, 0]] * 3, axis=2)
+
+        if equalize:
+            for i in range(display_bands.shape[2]):
+                band = display_bands[:, :, i]
+                non_nan = ~np.isnan(band)
+                if np.any(non_nan):
+                    min_val = np.nanmin(band)
+                    max_val = np.nanmax(band)
+                    if max_val > min_val:
+                        band = (band - min_val) / (max_val - min_val) * 255
+                    display_bands[:, :, i] = band
+
+        display_array = np.nan_to_num(display_bands).astype(np.uint8)
+        return Image.fromarray(display_array)
+
+    def to_numpy(self, nan_value: float | None = None) -> NDArray[np.floating[Any]]:
+        if nan_value is not None:
+            return np.nan_to_num(self._array, nan=nan_value)
+        return self._array.copy()
+
+    def to_xarray(self) -> "XarrayType":
+        return xr.DataArray(
+            self._array,
+            dims=["y", "x", "band"],
+            coords={
+                "band": self.wavelengths,
+                "x": np.arange(self.shape[1]),
+                "y": np.arange(self.shape[0]),
+            },
+            attrs={
+                "camera_id": self.camera_id,
+            },
+        )

siapy/entities/images/spimage.py

@@ -9,6 +9,7 @@
 from ..shapes import GeometricShapes, Shape
 from ..signatures import Signatures
 from .interfaces import ImageBase
+from .mock import MockImage
 from .rasterio_lib import RasterioLibImage
 from .spectral_lib import SpectralLibImage
 
@@ -36,10 +37,7 @@ def __init__(
         self._geometric_shapes = GeometricShapes(self, geometric_shapes)
 
     def __repr__(self) -> str:
-        return repr(self._image)
-
-    def __str__(self) -> str:
-        return str(self._image)
+        return f"SpectralImage(\n{self.image}\n)"
 
     def __lt__(self, other: "SpectralImage[Any]") -> bool:
         return self.filepath.name < other.filepath.name
@@ -61,6 +59,11 @@ def rasterio_open(cls, filepath: str | Path) -> "SpectralImage[RasterioLibImage]
         image = RasterioLibImage.open(filepath)
         return SpectralImage(image)
 
+    @classmethod
+    def from_numpy(cls, array: NDArray[np.floating[Any]]) -> "SpectralImage[MockImage]":
+        image = MockImage.open(array)
+        return SpectralImage(image)
+
     @property
     def image(self) -> T:
         return self._image
@@ -81,6 +84,14 @@ def metadata(self) -> dict[str, Any]:
     def shape(self) -> tuple[int, int, int]:
         return self.image.shape
 
+    @property
+    def width(self) -> int:
+        return self.shape[1]
+
+    @property
+    def height(self) -> int:
+        return self.shape[0]
+
     @property
     def bands(self) -> int:
         return self.image.bands

siapy/entities/shapes/shape.py

@@ -1,14 +1,14 @@
+from dataclasses import dataclass
 from enum import Enum
 from pathlib import Path
-from typing import Optional, Any
+from typing import Any, Optional
 
 import geopandas as gpd
 import numpy as np
 import pandas as pd
 from numpy.typing import NDArray
 from shapely.geometry import LineString, MultiLineString, MultiPoint, MultiPolygon, Point, Polygon
 from shapely.geometry.base import BaseGeometry
-from shapely.prepared import prep as shapely_prep
 
 from siapy.core.exceptions import ConfigurationError, InvalidFilepathError, InvalidInputError, InvalidTypeError
 from siapy.entities.pixels import PixelCoordinate, Pixels
@@ -38,6 +38,7 @@ class ShapeGeometryEnum(Enum):
     MULTIPOLYGON = "multipolygon"
 
 
+@dataclass
 class Shape:
     """
     Unified shape class that can be created from shapefiles or programmatically.
@@ -65,6 +66,9 @@ def __init__(
         else:
             raise ConfigurationError("Must provide either geometry or geodataframe")
 
+    def __repr__(self) -> str:
+        return f"Shape(label='{self.label}', geometry_type={self.shape_type})"
+
     def __len__(self) -> int:
         return len(self.df)
 
@@ -285,50 +289,3 @@ def to_file(self, filepath: str | Path, driver: str = "ESRI Shapefile") -> None:
 
     def to_numpy(self) -> NDArray[np.floating[Any]]:
         return self.df.to_numpy()
-
-    def get_pixels_within_convex_hull(self, resolution: float = 1.0) -> list[Pixels]:
-        pixels: list[Pixels] = []
-
-        if self.is_point:
-            for g in self.geometry:
-                if isinstance(g, MultiPoint):
-                    points = list(g.geoms)
-                elif isinstance(g, Point):
-                    points = [g]
-                else:
-                    raise InvalidTypeError(
-                        input_value=g,
-                        allowed_types=(Point, MultiPoint),
-                        message="Geometry must be Point or MultiPoint",
-                    )
-                pixels.append(Pixels.from_iterable([(p.x, p.y) for p in points]))
-
-            return pixels
-
-        if resolution <= 0:
-            raise InvalidInputError({"resolution": resolution}, "Resolution must be positive")
-
-        for hull in self.convex_hull:
-            minx, miny, maxx, maxy = hull.bounds
-
-            u_min = np.ceil(minx / resolution) * resolution
-            v_min = np.ceil(miny / resolution) * resolution
-            u_max = np.floor(maxx / resolution) * resolution
-            v_max = np.floor(maxy / resolution) * resolution
-
-            # Creating a prepared geometry improves performance for contains checks
-            hull_prep = shapely_prep(hull)
-
-            u_values = np.arange(u_min, u_max + resolution / 2, resolution)
-            v_values = np.arange(v_min, v_max + resolution / 2, resolution)
-
-            contained_points = []
-            for u in u_values:
-                for v in v_values:
-                    point = Point(u, v)
-                    if hull_prep.contains(point) or hull_prep.intersects(point):
-                        contained_points.append((u, v))
-
-            pixels.append(Pixels.from_iterable(contained_points))
-
-        return pixels

siapy/entities/signatures.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any
+from typing import Any, Iterable
 
 import numpy as np
 import pandas as pd
@@ -32,6 +32,11 @@ def __getitem__(self, indices: Any) -> "Signals":
             df_slice = df_slice.to_frame().T
         return Signals(df_slice)
 
+    @classmethod
+    def from_iterable(cls, iterable: Iterable) -> "Signals":
+        df = pd.DataFrame(iterable)
+        return cls(df)
+
     @classmethod
     def load_from_parquet(cls, filepath: str | Path) -> "Signals":
         df = pd.read_parquet(filepath)