ngio 0.3.4__py3-none-any.whl → 0.4.0__py3-none-any.whl

ngio/common/_pyramid.py

@@ -1,12 +1,18 @@
 import math
-from collections.abc import Collection
+from collections.abc import Callable, Sequence
 from typing import Literal
 
 import dask.array as da
 import numpy as np
 import zarr
+from zarr.types import DIMENSION_SEPARATOR
 
-from ngio.common._zoom import _zoom_inputs_check, dask_zoom, numpy_zoom
+from ngio.common._zoom import (
+    InterpolationOrder,
+    _zoom_inputs_check,
+    dask_zoom,
+    numpy_zoom,
+)
 from ngio.utils import (
     AccessModeLiteral,
     NgioValueError,
@@ -18,7 +24,7 @@ from ngio.utils import (
 def _on_disk_numpy_zoom(
     source: zarr.Array,
     target: zarr.Array,
-    order: Literal[0, 1, 2] = 1,
+    order: InterpolationOrder,
 ) -> None:
     target[...] = numpy_zoom(source[...], target_shape=target.shape, order=order)
 
@@ -26,7 +32,7 @@ def _on_disk_numpy_zoom(
 def _on_disk_dask_zoom(
     source: zarr.Array,
     target: zarr.Array,
-    order: Literal[0, 1, 2] = 1,
+    order: InterpolationOrder,
 ) -> None:
     source_array = da.from_zarr(source)
     target_array = dask_zoom(source_array, target_shape=target.shape, order=order)
@@ -39,18 +45,18 @@ def _on_disk_dask_zoom(
 def _on_disk_coarsen(
     source: zarr.Array,
     target: zarr.Array,
-    _order: Literal[0, 1] = 1,
-    aggregation_function: np.ufunc | None = None,
+    order: InterpolationOrder = "linear",
+    aggregation_function: Callable | None = None,
 ) -> None:
     """Apply a coarsening operation from a source zarr array to a target zarr array.
 
     Args:
         source (zarr.Array): The source array to coarsen.
         target (zarr.Array): The target array to save the coarsened result to.
-        _order (Literal[0, 1]): The order of interpolation is not really implemented
+        order (InterpolationOrder): The order of interpolation is not really implemented
             for coarsening, but it is kept for compatibility with the zoom function.
-            _order=1 -> linear interpolation ~ np.mean
-            _order=0 -> nearest interpolation ~ np.max
+            order="linear" -> linear interpolation ~ np.mean
+            order="nearest" -> nearest interpolation ~ np.max
         aggregation_function (np.ufunc): The aggregation function to use.
     """
     source_array = da.from_zarr(source)
@@ -64,13 +70,15 @@ def _on_disk_coarsen(
     )
 
     if aggregation_function is None:
-        if _order == 1:
+        if order == "linear":
             aggregation_function = np.mean
-        elif _order == 0:
+        elif order == "nearest":
             aggregation_function = np.max
+        elif order == "cubic":
+            raise NgioValueError("Cubic interpolation is not supported for coarsening.")
         else:
             raise NgioValueError(
-                f"Aggregation function must be provided for order {_order}"
+                f"Aggregation function must be provided for order {order}"
             )
 
     coarsening_setup = {}
@@ -96,7 +104,7 @@ def _on_disk_coarsen(
 def on_disk_zoom(
     source: zarr.Array,
     target: zarr.Array,
-    order: Literal[0, 1, 2] = 1,
+    order: InterpolationOrder = "linear",
     mode: Literal["dask", "numpy", "coarsen"] = "dask",
 ) -> None:
     """Apply a zoom operation from a source zarr array to a target zarr array.
@@ -104,7 +112,7 @@ def on_disk_zoom(
     Args:
         source (zarr.Array): The source array to zoom.
         target (zarr.Array): The target array to save the zoomed result to.
-        order (Literal[0, 1, 2]): The order of interpolation. Defaults to 1.
+        order (InterpolationOrder): The order of interpolation. Defaults to "linear".
         mode (Literal["dask", "numpy", "coarsen"]): The mode to use. Defaults to "dask".
     """
     if not isinstance(source, zarr.Array):
@@ -132,7 +140,7 @@ def on_disk_zoom(
 
 def _find_closest_arrays(
     processed: list[zarr.Array], to_be_processed: list[zarr.Array]
-) -> tuple[int, int]:
+) -> tuple[np.intp, np.intp]:
     dist_matrix = np.zeros((len(processed), len(to_be_processed)))
     for i, arr_to_proc in enumerate(to_be_processed):
         for j, proc_arr in enumerate(processed):
@@ -147,13 +155,15 @@ def _find_closest_arrays(
                 )
             )
 
-    return np.unravel_index(dist_matrix.argmin(), dist_matrix.shape)
+    indices = np.unravel_index(dist_matrix.argmin(), dist_matrix.shape)
+    assert len(indices) == 2, "Indices must be of length 2"
+    return indices
 
 
 def consolidate_pyramid(
     source: zarr.Array,
     targets: list[zarr.Array],
-    order: Literal[0, 1, 2] = 1,
+    order: InterpolationOrder = "linear",
     mode: Literal["dask", "numpy", "coarsen"] = "dask",
 ) -> None:
     """Consolidate the Zarr array."""
@@ -175,14 +185,25 @@ def consolidate_pyramid(
         processed.append(target_image)
 
 
+def _maybe_int(value: float | int) -> float | int:
+    """Convert a float to an int if it is an integer."""
+    if isinstance(value, int):
+        return value
+    if value.is_integer():
+        return int(value)
+    return value
+
+
 def init_empty_pyramid(
     store: StoreOrGroup,
     paths: list[str],
-    ref_shape: Collection[int],
-    scaling_factors: Collection[float],
-    chunks: Collection[int] | None = None,
+    ref_shape: Sequence[int],
+    scaling_factors: Sequence[float],
+    chunks: Sequence[int] | None = None,
     dtype: str = "uint16",
     mode: AccessModeLiteral = "a",
+    dimension_separator: DIMENSION_SEPARATOR = "/",
+    compressor="default",
 ) -> None:
     # Return the an Image object
     if chunks is not None and len(chunks) != len(ref_shape):
@@ -198,6 +219,10 @@ def init_empty_pyramid(
             "The shape and scaling factor must have the same number of dimensions."
         )
 
+    # Ensure scaling factors are int if possible
+    # To reduce the risk of floating point issues
+    scaling_factors = [_maybe_int(s) for s in scaling_factors]
+
     root_group = open_group_wrapper(store, mode=mode)
 
     for path in paths:
@@ -211,22 +236,18 @@ def init_empty_pyramid(
             shape=ref_shape,
             dtype=dtype,
             chunks=chunks,
-            dimension_separator="/",
+            dimension_separator=dimension_separator,
             overwrite=True,
+            compressor=compressor,
         )
 
-        # Todo redo this with when a proper build of pyramid is implemented
-        _shape = []
-        for s, sc in zip(ref_shape, scaling_factors, strict=True):
-            if math.floor(s / sc) % 2 == 0:
-                _shape.append(math.floor(s / sc))
-            else:
-                _shape.append(math.ceil(s / sc))
+        _shape = [
+            math.floor(s / sc) for s, sc in zip(ref_shape, scaling_factors, strict=True)
+        ]
         ref_shape = _shape
 
         if chunks is None:
             chunks = new_arr.chunks
-            if chunks is None:
-                raise NgioValueError("Something went wrong with the chunks")
+            assert chunks is not None
         chunks = [min(c, s) for c, s in zip(chunks, ref_shape, strict=True)]
     return None

ngio/common/_roi.py

@@ -4,62 +4,242 @@ These are the interfaces bwteen the ROI tables / masking ROI tables and
     the ImageLikeHandler.
 """
 
-from collections.abc import Iterable
+from typing import TypeVar
+from warnings import warn
 
-import numpy as np
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict
 
 from ngio.common._dimensions import Dimensions
 from ngio.ome_zarr_meta.ngio_specs import DefaultSpaceUnit, PixelSize, SpaceUnits
 from ngio.utils import NgioValueError
 
 
-def _to_raster(value: float, pixel_size: float, max_shape: int) -> int:
-    """Convert to raster coordinates."""
-    round_value = int(np.round(value / pixel_size))
-    # Ensure the value is within the image shape boundaries
-    return max(0, min(round_value, max_shape))
+def _to_raster(value: float, length: float, pixel_size: float) -> tuple[float, float]:
+    raster_value = value / pixel_size
+    raster_length = length / pixel_size
+    return raster_value, raster_length
 
 
-def _to_world(value: int, pixel_size: float) -> float:
+def _to_slice(start: float | None, length: float | None) -> slice:
+    if length is not None:
+        assert start is not None
+        end = start + length
+    else:
+        end = None
+    return slice(start, end)
+
+
+def _to_world(value: int | float, pixel_size: float) -> float:
     """Convert to world coordinates."""
     return value * pixel_size
 
 
-class Roi(BaseModel):
-    """Region of interest (ROI) metadata."""
+T = TypeVar("T", int, float)
+
 
-    name: str
+class GenericRoi(BaseModel):
+    """A generic Region of Interest (ROI) model."""
+
+    name: str | None = None
+    x: float
+    y: float
+    z: float | None = None
+    t: float | None = None
     x_length: float
     y_length: float
-    z_length: float = 1.0
-    x: float = 0.0
-    y: float = 0.0
-    z: float = 0.0
-    unit: SpaceUnits | str | None = Field(DefaultSpaceUnit, repr=False)
+    z_length: float | None = None
+    t_length: float | None = None
+    label: int | None = None
+    unit: SpaceUnits | str | None = None
 
     model_config = ConfigDict(extra="allow")
 
-    def to_pixel_roi(
-        self, pixel_size: PixelSize, dimensions: Dimensions
-    ) -> "RoiPixels":
+    def intersection(self, other: "GenericRoi") -> "GenericRoi | None":
+        """Calculate the intersection of this ROI with another ROI."""
+        return roi_intersection(self, other)
+
+    def _nice_str(self) -> str:
+        if self.t is not None:
+            t_str = f"t={self.t}->{self.t_length}"
+        else:
+            t_str = "t=None"
+        if self.z is not None:
+            z_str = f"z={self.z}->{self.z_length}"
+        else:
+            z_str = "z=None"
+
+        y_str = f"y={self.y}->{self.y_length}"
+        x_str = f"x={self.x}->{self.x_length}"
+
+        if self.label is not None:
+            label_str = f", label={self.label}"
+        else:
+            label_str = ""
+        cls_name = self.__class__.__name__
+        return f"{cls_name}({t_str}, {z_str}, {y_str}, {x_str}{label_str})"
+
+    def get_name(self) -> str:
+        """Get the name of the ROI, or a default if not set."""
+        if self.name is not None:
+            return self.name
+        return self._nice_str()
+
+    def __repr__(self) -> str:
+        return self._nice_str()
+
+    def __str__(self) -> str:
+        return self._nice_str()
+
+
+def _1d_intersection(
+    a: T | None, a_length: T | None, b: T | None, b_length: T | None
+) -> tuple[T | None, T | None]:
+    """Calculate the intersection of two 1D intervals."""
+    if a is None:
+        if b is not None and b_length is not None:
+            return b, b_length
+        return None, None
+    if b is None:
+        if a is not None and a_length is not None:
+            return a, a_length
+        return None, None
+
+    assert (
+        a is not None
+        and a_length is not None
+        and b is not None
+        and b_length is not None
+    )
+    start = max(a, b)
+    end = min(a + a_length, b + b_length)
+    length = end - start
+
+    if length <= 0:
+        return None, None
+
+    return start, length
+
+
+def roi_intersection(ref_roi: GenericRoi, other_roi: GenericRoi) -> GenericRoi | None:
+    """Calculate the intersection of two ROIs."""
+    if (
+        ref_roi.unit is not None
+        and other_roi.unit is not None
+        and ref_roi.unit != other_roi.unit
+    ):
+        raise NgioValueError(
+            "Cannot calculate intersection of ROIs with different units."
+        )
+
+    x, x_length = _1d_intersection(
+        ref_roi.x, ref_roi.x_length, other_roi.x, other_roi.x_length
+    )
+    if x is None and x_length is None:
+        # No intersection
+        return None
+    assert x is not None and x_length is not None
+
+    y, y_length = _1d_intersection(
+        ref_roi.y, ref_roi.y_length, other_roi.y, other_roi.y_length
+    )
+    if y is None and y_length is None:
+        # No intersection
+        return None
+    assert y is not None and y_length is not None
+
+    z, z_length = _1d_intersection(
+        ref_roi.z, ref_roi.z_length, other_roi.z, other_roi.z_length
+    )
+    t, t_length = _1d_intersection(
+        ref_roi.t, ref_roi.t_length, other_roi.t, other_roi.t_length
+    )
+
+    if (z_length is not None and z_length <= 0) or (
+        t_length is not None and t_length <= 0
+    ):
+        # No intersection
+        return None
+
+    # Find label
+    if ref_roi.label is not None and other_roi.label is not None:
+        if ref_roi.label != other_roi.label:
+            raise NgioValueError(
+                "Cannot calculate intersection of ROIs with different labels."
+            )
+    label = ref_roi.label or other_roi.label
+
+    if ref_roi.name is not None and other_roi.name is not None:
+        name = f"{ref_roi.name}:{other_roi.name}"
+    else:
+        name = ref_roi.name or other_roi.name
+
+    cls_ref = ref_roi.__class__
+    return cls_ref(
+        name=name,
+        x=x,
+        y=y,
+        z=z,
+        t=t,
+        x_length=x_length,
+        y_length=y_length,
+        z_length=z_length,
+        t_length=t_length,
+        unit=ref_roi.unit,
+        label=label,
+    )
+
+
+class Roi(GenericRoi):
+    x: float = 0.0
+    y: float = 0.0
+    unit: SpaceUnits | str | None = DefaultSpaceUnit
+
+    def to_roi_pixels(self, pixel_size: PixelSize) -> "RoiPixels":
         """Convert to raster coordinates."""
-        dim_x = dimensions.get("x")
-        dim_y = dimensions.get("y")
-        # Will default to 1 if z does not exist
-        dim_z = dimensions.get("z", strict=False)
+        x, x_length = _to_raster(self.x, self.x_length, pixel_size.x)
+        y, y_length = _to_raster(self.y, self.y_length, pixel_size.y)
+
+        if self.z is None:
+            z, z_length = None, None
+        else:
+            assert self.z_length is not None
+            z, z_length = _to_raster(self.z, self.z_length, pixel_size.z)
+
+        if self.t is None:
+            t, t_length = None, None
+        else:
+            assert self.t_length is not None
+            t, t_length = _to_raster(self.t, self.t_length, pixel_size.t)
+        extra_dict = self.model_extra if self.model_extra else {}
 
         return RoiPixels(
             name=self.name,
-            x=_to_raster(self.x, pixel_size.x, dim_x),
-            y=_to_raster(self.y, pixel_size.y, dim_y),
-            z=_to_raster(self.z, pixel_size.z, dim_z),
-            x_length=_to_raster(self.x_length, pixel_size.x, dim_x),
-            y_length=_to_raster(self.y_length, pixel_size.y, dim_y),
-            z_length=_to_raster(self.z_length, pixel_size.z, dim_z),
-            **self.model_extra,
+            x=x,
+            y=y,
+            z=z,
+            t=t,
+            x_length=x_length,
+            y_length=y_length,
+            z_length=z_length,
+            t_length=t_length,
+            label=self.label,
+            unit=self.unit,
+            **extra_dict,
         )
 
+    def to_pixel_roi(
+        self, pixel_size: PixelSize, dimensions: Dimensions | None = None
+    ) -> "RoiPixels":
+        """Convert to raster coordinates."""
+        warn(
+            "to_pixel_roi is deprecated and will be removed in a future release. "
+            "Use to_roi_pixels instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
+        return self.to_roi_pixels(pixel_size=pixel_size)
+
     def zoom(self, zoom_factor: float = 1) -> "Roi":
         """Zoom the ROI by a factor.
 
@@ -72,38 +252,67 @@ class Roi(BaseModel):
         return zoom_roi(self, zoom_factor)
 
 
-class RoiPixels(BaseModel):
-    """Region of interest (ROI) metadata."""
+class RoiPixels(GenericRoi):
+    """Region of interest (ROI) in pixel coordinates."""
 
-    name: str
-    x: int
-    y: int
-    z: int
-    x_length: int
-    y_length: int
-    z_length: int
-    model_config = ConfigDict(extra="allow")
+    x: float = 0
+    y: float = 0
+    unit: SpaceUnits | str | None = None
 
-    def to_roi(self, pixel_size: PixelSize) -> Roi:
-        """Convert to world coordinates."""
+    def to_roi(self, pixel_size: PixelSize) -> "Roi":
+        """Convert to raster coordinates."""
+        x = _to_world(self.x, pixel_size.x)
+        x_length = _to_world(self.x_length, pixel_size.x)
+        y = _to_world(self.y, pixel_size.y)
+        y_length = _to_world(self.y_length, pixel_size.y)
+
+        if self.z is None:
+            z = None
+        else:
+            z = _to_world(self.z, pixel_size.z)
+
+        if self.z_length is None:
+            z_length = None
+        else:
+            z_length = _to_world(self.z_length, pixel_size.z)
+
+        if self.t is None:
+            t = None
+        else:
+            t = _to_world(self.t, pixel_size.t)
+
+        if self.t_length is None:
+            t_length = None
+        else:
+            t_length = _to_world(self.t_length, pixel_size.t)
+
+        extra_dict = self.model_extra if self.model_extra else {}
         return Roi(
             name=self.name,
-            x=_to_world(self.x, pixel_size.x),
-            y=_to_world(self.y, pixel_size.y),
-            z=_to_world(self.z, pixel_size.z),
-            x_length=_to_world(self.x_length, pixel_size.x),
-            y_length=_to_world(self.y_length, pixel_size.y),
-            z_length=_to_world(self.z_length, pixel_size.z),
-            unit=pixel_size.space_unit,
-            **self.model_extra,
+            x=x,
+            y=y,
+            z=z,
+            t=t,
+            x_length=x_length,
+            y_length=y_length,
+            z_length=z_length,
+            t_length=t_length,
+            label=self.label,
+            unit=self.unit,
+            **extra_dict,
         )
 
-    def to_slices(self) -> dict[str, slice]:
-        """Return the slices for the ROI."""
+    def to_slicing_dict(self) -> dict[str, slice]:
+        """Convert to a slicing dictionary."""
+        x_slice = _to_slice(self.x, self.x_length)
+        y_slice = _to_slice(self.y, self.y_length)
+        z_slice = _to_slice(self.z, self.z_length)
+        t_slice = _to_slice(self.t, self.t_length)
         return {
-            "x": slice(self.x, self.x + self.x_length),
-            "y": slice(self.y, self.y + self.y_length),
-            "z": slice(self.z, self.z + self.z_length),
+            "x": x_slice,
+            "y": y_slice,
+            "z": z_slice,
+            "t": t_slice,
         }
 
 
@@ -118,7 +327,7 @@ def zoom_roi(roi: Roi, zoom_factor: float = 1) -> Roi:
             If the zoom factor is 1 the ROI will not be changed.
     """
     if zoom_factor <= 0:
-        raise ValueError("Zoom factor must be greater than 0.")
+        raise NgioValueError("Zoom factor must be greater than 0.")
 
     # the zoom factor needs to be rescaled
     # from the range [-1, inf) to [0, inf)
@@ -134,34 +343,12 @@ def zoom_roi(roi: Roi, zoom_factor: float = 1) -> Roi:
         x=new_x,
         y=new_y,
         z=roi.z,
+        t=roi.t,
         x_length=roi.x_length + diff_x,
         y_length=roi.y_length + diff_y,
         z_length=roi.z_length,
+        t_length=roi.t_length,
+        label=roi.label,
         unit=roi.unit,
     )
-
     return new_roi
-
-
-def roi_to_slice_kwargs(
-    roi: Roi,
-    pixel_size: PixelSize,
-    dimensions: Dimensions,
-    **slice_kwargs: slice | int | Iterable[int],
-) -> dict[str, slice | int | Iterable[int]]:
-    """Convert a WorldCooROI to slice_kwargs."""
-    raster_roi = roi.to_pixel_roi(
-        pixel_size=pixel_size, dimensions=dimensions
-    ).to_slices()
-
-    if not dimensions.has_axis(axis_name="z"):
-        raster_roi.pop("z")
-
-    for key in slice_kwargs.keys():
-        if key in raster_roi:
-            raise NgioValueError(
-                f"Key {key} is already in the slice_kwargs. "
-                "Ambiguous which one to use: "
-                f"{key}={slice_kwargs[key]} or roi_{key}={raster_roi[key]}"
-            )
-    return {**raster_roi, **slice_kwargs}