ngio 0.4.0a2__py3-none-any.whl → 0.4.0a4__py3-none-any.whl

ngio/common/_zoom.py

@@ -7,6 +7,19 @@ from scipy.ndimage import zoom as scipy_zoom
 
 from ngio.utils import NgioValueError
 
+InterpolationOrder = Literal["nearest", "linear", "cubic"]
+
+
+def order_to_int(order: InterpolationOrder | Literal[0, 1, 2]) -> Literal[0, 1, 2]:
+    if order == "nearest" or order == 0:
+        return 0
+    elif order == "linear" or order == 1:
+        return 1
+    elif order == "cubic" or order == 2:
+        return 2
+    else:
+        raise NgioValueError(f"Invalid order: {order}")
+
 
 def _stacked_zoom(x, zoom_y, zoom_x, order=1, mode="grid-constant", grid_mode=True):
     *rest, yshape, xshape = x.shape
@@ -32,6 +45,10 @@ def fast_zoom(x, zoom, order=1, mode="grid-constant", grid_mode=True, auto_stack
          it stacks the first dimensions to call zoom only on the last two.
     """
     mask = np.isclose(x.shape, 1)
+    # Always keep the last two dimensions
+    # To avoid issues with singleton x or y dimensions
+    mask[-1] = False
+    mask[-2] = False
     zoom = np.array(zoom)
     singletons = tuple(np.where(mask)[0])
     xs = np.squeeze(x, axis=singletons)
@@ -71,7 +88,7 @@ def _zoom_inputs_check(
         _target_shape = target_shape
     else:
         _scale = np.array(scale)
-        _target_shape = tuple(np.array(source_array.shape) * scale)
+        _target_shape = tuple(map(int, np.round(np.array(source_array.shape) * scale)))
 
     if len(_scale) != source_array.ndim:
         raise NgioValueError(
@@ -86,7 +103,7 @@ def dask_zoom(
     source_array: da.Array,
     scale: tuple[float | int, ...] | None = None,
     target_shape: tuple[int, ...] | None = None,
-    order: Literal[0, 1, 2] = 1,
+    order: InterpolationOrder = "linear",
 ) -> da.Array:
     """Dask implementation of zooming an array.
 
@@ -96,7 +113,8 @@ def dask_zoom(
         source_array (da.Array): The source array to zoom.
         scale (tuple[int, ...] | None): The scale factor to zoom by.
         target_shape (tuple[int, ...], None): The target shape to zoom to.
-        order (Literal[0, 1, 2]): The order of interpolation. Defaults to 1.
+        order (Literal["nearest", "linear", "cubic"]): The order of interpolation.
+            Defaults to "linear".
 
     Returns:
         da.Array: The zoomed array.
@@ -105,7 +123,6 @@ def dask_zoom(
     # https://github.com/ome/ome-zarr-py/blob/master/ome_zarr/dask_utils.py
     # The module was contributed by Andreas Eisenbarth @aeisenbarth
     # See https://github.com/toloudis/ome-zarr-py/pull/
-
     _scale, _target_shape = _zoom_inputs_check(
         source_array=source_array, scale=scale, target_shape=target_shape
     )
@@ -120,7 +137,11 @@ def dask_zoom(
     block_output_shape = tuple(np.ceil(better_source_chunks * _scale).astype(int))
 
     zoom_wrapper = partial(
-        fast_zoom, zoom=_scale, order=order, mode="grid-constant", grid_mode=True
+        fast_zoom,
+        zoom=_scale,
+        order=order_to_int(order),
+        mode="grid-constant",
+        grid_mode=True,
     )
 
     out_array = da.map_blocks(
@@ -137,7 +158,7 @@ def numpy_zoom(
     source_array: np.ndarray,
     scale: tuple[int | float, ...] | None = None,
     target_shape: tuple[int, ...] | None = None,
-    order: Literal[0, 1, 2] = 1,
+    order: InterpolationOrder = "linear",
 ) -> np.ndarray:
     """Numpy implementation of zooming an array.
 
@@ -157,7 +178,11 @@ def numpy_zoom(
     )
 
     out_array = fast_zoom(
-        source_array, zoom=_scale, order=order, mode="grid-constant", grid_mode=True
+        source_array,
+        zoom=_scale,
+        order=order_to_int(order),
+        mode="grid-constant",
+        grid_mode=True,
     )
     assert isinstance(out_array, np.ndarray)
     return out_array

ngio/experimental/iterators/_abstract_iterator.py

@@ -156,7 +156,7 @@ class AbstractIteratorBuilder(ABC):
     def map_as_numpy(self, func: Callable) -> None:
         """Apply a transformation function to the ROI pixels."""
         for roi in self.rois:
-            data = self.build_numpy_getter(roi)
+            data = self.build_numpy_getter(roi)()
             data = func(data)
             self.build_numpy_setter(roi)
         self.post_consolidate()
@@ -164,7 +164,7 @@ class AbstractIteratorBuilder(ABC):
     def map_as_dask(self, func: Callable) -> None:
         """Apply a transformation function to the ROI pixels."""
         for roi in self.rois:
-            data = self.build_dask_getter(roi)
+            data = self.build_dask_getter(roi)()
             data = func(data)
             self.build_dask_setter(roi)
         self.post_consolidate()

ngio/experimental/iterators/_feature.py

@@ -3,18 +3,14 @@ from collections.abc import Callable, Generator, Sequence
 import dask.array as da
 import numpy as np
 
-from ngio.common import (
-    Roi,
-    TransformProtocol,
-    build_roi_dask_getter,
-    build_roi_numpy_getter,
-)
+from ngio.common import Roi
 from ngio.experimental.iterators._abstract_iterator import AbstractIteratorBuilder
 from ngio.images import Image, Label
 from ngio.images._image import (
     ChannelSlicingInputType,
     add_channel_selection_to_slicing_dict,
 )
+from ngio.io_pipes import DaskRoiGetter, NumpyRoiGetter, TransformProtocol
 
 
 class FeatureExtractorIterator(AbstractIteratorBuilder):
@@ -47,7 +43,7 @@ class FeatureExtractorIterator(AbstractIteratorBuilder):
         self._input = input_image
         self._input_label = input_label
         self._ref_image = input_image
-        self._rois = input_image.build_image_roi_table().rois()
+        self._rois = input_image.build_image_roi_table(name=None).rois()
 
         # Set iteration parameters
         self._input_slicing_kwargs = add_channel_selection_to_slicing_dict(
@@ -58,6 +54,9 @@ class FeatureExtractorIterator(AbstractIteratorBuilder):
         self._input_transforms = input_transforms
         self._label_transforms = label_transforms
 
+        self._input.require_axes_match(self._input_label)
+        self._input.require_can_be_rescaled(self._input_label)
+
     def get_init_kwargs(self) -> dict:
         """Return the initialization arguments for the iterator."""
         return {
@@ -70,21 +69,19 @@ class FeatureExtractorIterator(AbstractIteratorBuilder):
         }
 
     def build_numpy_getter(self, roi: Roi):
-        data_getter = build_roi_numpy_getter(
+        data_getter = NumpyRoiGetter(
             zarr_array=self._input.zarr_array,
             dimensions=self._input.dimensions,
             axes_order=self._axes_order,
             transforms=self._input_transforms,
-            pixel_size=self._input.pixel_size,
             roi=roi,
             slicing_dict=self._input_slicing_kwargs,
         )
-        label_getter = build_roi_numpy_getter(
+        label_getter = NumpyRoiGetter(
             zarr_array=self._input_label.zarr_array,
             dimensions=self._input_label.dimensions,
             axes_order=self._axes_order,
             transforms=self._label_transforms,
-            pixel_size=self._input_label.pixel_size,
             roi=roi,
             remove_channel_selection=True,
         )
@@ -94,21 +91,19 @@ class FeatureExtractorIterator(AbstractIteratorBuilder):
         return None
 
     def build_dask_getter(self, roi: Roi):
-        data_getter = build_roi_dask_getter(
+        data_getter = DaskRoiGetter(
             zarr_array=self._input.zarr_array,
             dimensions=self._input.dimensions,
             axes_order=self._axes_order,
             transforms=self._input_transforms,
-            pixel_size=self._input.pixel_size,
             roi=roi,
             slicing_dict=self._input_slicing_kwargs,
         )
-        label_getter = build_roi_dask_getter(
+        label_getter = DaskRoiGetter(
             zarr_array=self._input_label.zarr_array,
             dimensions=self._input_label.dimensions,
             axes_order=self._axes_order,
             transforms=self._label_transforms,
-            pixel_size=self._input_label.pixel_size,
             roi=roi,
             remove_channel_selection=True,
         )

ngio/experimental/iterators/_image_processing.py

@@ -3,21 +3,20 @@ from collections.abc import Callable, Generator, Sequence
 import dask.array as da
 import numpy as np
 
-from ngio.common import (
-    Roi,
-    TransformProtocol,
-    build_roi_dask_getter,
-    build_roi_dask_setter,
-    build_roi_numpy_getter,
-    build_roi_numpy_setter,
-)
+from ngio.common import Roi
 from ngio.experimental.iterators._abstract_iterator import AbstractIteratorBuilder
 from ngio.images import Image
 from ngio.images._image import (
     ChannelSlicingInputType,
     add_channel_selection_to_slicing_dict,
 )
-from ngio.utils._errors import NgioValidationError
+from ngio.io_pipes import (
+    DaskRoiGetter,
+    DaskRoiSetter,
+    NumpyRoiGetter,
+    NumpyRoiSetter,
+    TransformProtocol,
+)
 
 
 class ImageProcessingIterator(AbstractIteratorBuilder):
@@ -53,7 +52,7 @@ class ImageProcessingIterator(AbstractIteratorBuilder):
         self._input = input_image
         self._output = output_image
         self._ref_image = input_image
-        self._rois = input_image.build_image_roi_table().rois()
+        self._rois = input_image.build_image_roi_table(name=None).rois()
 
         # Set iteration parameters
         self._input_slicing_kwargs = add_channel_selection_to_slicing_dict(
@@ -72,12 +71,7 @@ class ImageProcessingIterator(AbstractIteratorBuilder):
         self._input_transforms = input_transforms
         self._output_transforms = output_transforms
 
-        # Check compatibility between input and output images
-        if not self._input.dimensions.is_compatible_with(self._output.dimensions):
-            raise NgioValidationError(
-                "Input image and output label have incompatible dimensions. "
-                f"Input: {self._input.dimensions}, Output: {self._output.dimensions}."
-            )
+        self._input.require_dimensions_match(self._output, allow_singleton=True)
 
     def get_init_kwargs(self) -> dict:
         """Return the initialization arguments for the iterator."""
@@ -92,46 +86,42 @@ class ImageProcessingIterator(AbstractIteratorBuilder):
         }
 
     def build_numpy_getter(self, roi: Roi):
-        return build_roi_numpy_getter(
+        return NumpyRoiGetter(
             zarr_array=self._input.zarr_array,
             dimensions=self._input.dimensions,
+            roi=roi,
             axes_order=self._axes_order,
             transforms=self._input_transforms,
-            pixel_size=self._input.pixel_size,
-            roi=roi,
             slicing_dict=self._input_slicing_kwargs,
         )
 
     def build_numpy_setter(self, roi: Roi):
-        return build_roi_numpy_setter(
+        return NumpyRoiSetter(
             zarr_array=self._output.zarr_array,
             dimensions=self._output.dimensions,
+            roi=roi,
             axes_order=self._axes_order,
             transforms=self._output_transforms,
-            pixel_size=self._output.pixel_size,
-            roi=roi,
             slicing_dict=self._output_slicing_kwargs,
         )
 
     def build_dask_getter(self, roi: Roi):
-        return build_roi_dask_getter(
+        return DaskRoiGetter(
             zarr_array=self._input.zarr_array,
             dimensions=self._input.dimensions,
+            roi=roi,
             axes_order=self._axes_order,
             transforms=self._input_transforms,
-            pixel_size=self._input.pixel_size,
-            roi=roi,
             slicing_dict=self._input_slicing_kwargs,
         )
 
     def build_dask_setter(self, roi: Roi):
-        return build_roi_dask_setter(
+        return DaskRoiSetter(
             zarr_array=self._output.zarr_array,
             dimensions=self._output.dimensions,
+            roi=roi,
             axes_order=self._axes_order,
             transforms=self._output_transforms,
-            pixel_size=self._output.pixel_size,
-            roi=roi,
             slicing_dict=self._output_slicing_kwargs,
         )
 

ngio/experimental/iterators/_rois_utils.py

@@ -24,7 +24,7 @@ def grid(
     stride_y: int | None = None,
     stride_z: int | None = None,
     stride_t: int | None = None,
-    base_name: str = "",
+    base_name: str | None = None,
 ) -> list[Roi]:
     """This method is a placeholder for creating a regular grid of ROIs."""
     t_dim = ref_image.dimensions.get("t", default=1)
@@ -49,7 +49,7 @@ def grid(
             for y in range(0, y_dim, stride_y):
                 for x in range(0, x_dim, stride_x):
                     roi = RoiPixels(
-                        name=f"{base_name}({t}, {z}, {y}, {x})",
+                        name=base_name,
                         x=x,
                         y=y,
                         z=z,
@@ -100,10 +100,10 @@ def by_chunks(
 ) -> list[Roi]:
     """This method is a placeholder for chunked processing."""
     chunk_size = ref_image.chunks
-    t_axis = ref_image.axes_mapper.get_index("t")
-    z_axis = ref_image.axes_mapper.get_index("z")
-    y_axis = ref_image.axes_mapper.get_index("y")
-    x_axis = ref_image.axes_mapper.get_index("x")
+    t_axis = ref_image.axes_handler.get_index("t")
+    z_axis = ref_image.axes_handler.get_index("z")
+    y_axis = ref_image.axes_handler.get_index("y")
+    x_axis = ref_image.axes_handler.get_index("x")
 
     size_x = chunk_size[x_axis] if x_axis is not None else None
     size_y = chunk_size[y_axis] if y_axis is not None else None

ngio/experimental/iterators/_segmentation.py

@@ -3,18 +3,7 @@ from collections.abc import Callable, Generator, Sequence
 import dask.array as da
 import numpy as np
 
-from ngio.common import (
-    Roi,
-    TransformProtocol,
-    build_roi_dask_getter,
-    build_roi_dask_setter,
-    build_roi_masked_dask_getter,
-    build_roi_masked_dask_setter,
-    build_roi_masked_numpy_getter,
-    build_roi_masked_numpy_setter,
-    build_roi_numpy_getter,
-    build_roi_numpy_setter,
-)
+from ngio.common import Roi
 from ngio.experimental.iterators._abstract_iterator import AbstractIteratorBuilder
 from ngio.images import Image, Label
 from ngio.images._image import (
@@ -22,7 +11,19 @@ from ngio.images._image import (
     add_channel_selection_to_slicing_dict,
 )
 from ngio.images._masked_image import MaskedImage
-from ngio.utils._errors import NgioValidationError
+from ngio.io_pipes import (
+    DaskGetterMasked,
+    DaskRoiGetter,
+    DaskRoiSetter,
+    DaskSetterMasked,
+    DataGetter,
+    DataSetter,
+    NumpyGetterMasked,
+    NumpyRoiGetter,
+    NumpyRoiSetter,
+    NumpySetterMasked,
+    TransformProtocol,
+)
 
 
 class SegmentationIterator(AbstractIteratorBuilder):
@@ -55,7 +56,7 @@ class SegmentationIterator(AbstractIteratorBuilder):
         self._input = input_image
         self._output = output_label
         self._ref_image = input_image
-        self._rois = input_image.build_image_roi_table().rois()
+        self._rois = input_image.build_image_roi_table(name=None).rois()
 
         # Set iteration parameters
         self._input_slicing_kwargs = add_channel_selection_to_slicing_dict(
@@ -66,12 +67,7 @@ class SegmentationIterator(AbstractIteratorBuilder):
         self._input_transforms = input_transforms
         self._output_transforms = output_transforms
 
-        # Check compatibility between input and output images
-        if not self._input.dimensions.is_compatible_with(self._output.dimensions):
-            raise NgioValidationError(
-                "Input image and output label have incompatible dimensions. "
-                f"Input: {self._input.dimensions}, Output: {self._output.dimensions}."
-            )
+        self._input.require_dimensions_match(self._output, allow_singleton=False)
 
     def get_init_kwargs(self) -> dict:
         """Return the initialization arguments for the iterator."""
@@ -84,47 +80,43 @@ class SegmentationIterator(AbstractIteratorBuilder):
             "output_transforms": self._output_transforms,
         }
 
-    def build_numpy_getter(self, roi: Roi):
-        return build_roi_numpy_getter(
+    def build_numpy_getter(self, roi: Roi) -> DataGetter[np.ndarray]:
+        return NumpyRoiGetter(
             zarr_array=self._input.zarr_array,
             dimensions=self._input.dimensions,
+            roi=roi,
             axes_order=self._axes_order,
             transforms=self._input_transforms,
-            pixel_size=self._input.pixel_size,
-            roi=roi,
             slicing_dict=self._input_slicing_kwargs,
         )
 
-    def build_numpy_setter(self, roi: Roi):
-        return build_roi_numpy_setter(
+    def build_numpy_setter(self, roi: Roi) -> DataSetter[np.ndarray]:
+        return NumpyRoiSetter(
             zarr_array=self._output.zarr_array,
             dimensions=self._output.dimensions,
+            roi=roi,
             axes_order=self._axes_order,
             transforms=self._output_transforms,
-            pixel_size=self._output.pixel_size,
-            roi=roi,
             remove_channel_selection=True,
         )
 
-    def build_dask_getter(self, roi: Roi):
-        return build_roi_dask_getter(
+    def build_dask_getter(self, roi: Roi) -> DataGetter[da.Array]:
+        return DaskRoiGetter(
             zarr_array=self._input.zarr_array,
             dimensions=self._input.dimensions,
+            roi=roi,
             axes_order=self._axes_order,
             transforms=self._input_transforms,
-            pixel_size=self._input.pixel_size,
-            roi=roi,
             slicing_dict=self._input_slicing_kwargs,
         )
 
-    def build_dask_setter(self, roi: Roi):
-        return build_roi_dask_setter(
+    def build_dask_setter(self, roi: Roi) -> DataSetter[da.Array]:
+        return DaskRoiSetter(
             zarr_array=self._output.zarr_array,
             dimensions=self._output.dimensions,
+            roi=roi,
             axes_order=self._axes_order,
             transforms=self._output_transforms,
-            pixel_size=self._output.pixel_size,
-            roi=roi,
             remove_channel_selection=True,
         )
 
@@ -205,11 +197,11 @@ class MaskedSegmentationIterator(SegmentationIterator):
         self._output_transforms = output_transforms
 
         # Check compatibility between input and output images
-        if not self._input.dimensions.is_compatible_with(self._output.dimensions):
-            raise NgioValidationError(
-                "Input image and output label have incompatible dimensions. "
-                f"Input: {self._input.dimensions}, Output: {self._output.dimensions}."
-            )
+        # if not self._input.dimensions.is_compatible_with(self._output.dimensions):
+        #    raise NgioValidationError(
+        #        "Input image and output label have incompatible dimensions. "
+        #        f"Input: {self._input.dimensions}, Output: {self._output.dimensions}."
+        #    )
 
     def get_init_kwargs(self) -> dict:
         """Return the initialization arguments for the iterator."""
@@ -223,58 +215,50 @@ class MaskedSegmentationIterator(SegmentationIterator):
         }
 
     def build_numpy_getter(self, roi: Roi):
-        return build_roi_masked_numpy_getter(
-            roi=roi,
+        return NumpyGetterMasked(
             zarr_array=self._input.zarr_array,
             dimensions=self._input.dimensions,
+            roi=roi,
             label_zarr_array=self._input._label.zarr_array,
             label_dimensions=self._input._label.dimensions,
-            label_pixel_size=self._input._label.pixel_size,
             axes_order=self._axes_order,
             transforms=self._input_transforms,
-            pixel_size=self._input.pixel_size,
             slicing_dict=self._input_slicing_kwargs,
         )
 
     def build_numpy_setter(self, roi: Roi):
-        return build_roi_masked_numpy_setter(
+        return NumpySetterMasked(
             roi=roi,
             zarr_array=self._output.zarr_array,
             dimensions=self._output.dimensions,
             label_zarr_array=self._input._label.zarr_array,
             label_dimensions=self._input._label.dimensions,
-            label_pixel_size=self._input._label.pixel_size,
             axes_order=self._axes_order,
             transforms=self._output_transforms,
-            pixel_size=self._output.pixel_size,
             remove_channel_selection=True,
         )
 
     def build_dask_getter(self, roi: Roi):
-        return build_roi_masked_dask_getter(
+        return DaskGetterMasked(
             roi=roi,
             zarr_array=self._input.zarr_array,
             dimensions=self._input.dimensions,
             label_zarr_array=self._input._label.zarr_array,
             label_dimensions=self._input._label.dimensions,
-            label_pixel_size=self._input._label.pixel_size,
             axes_order=self._axes_order,
             transforms=self._input_transforms,
-            pixel_size=self._input.pixel_size,
             slicing_dict=self._input_slicing_kwargs,
         )
 
     def build_dask_setter(self, roi: Roi):
-        return build_roi_masked_dask_setter(
+        return DaskSetterMasked(
             roi=roi,
             zarr_array=self._output.zarr_array,
             dimensions=self._output.dimensions,
             label_zarr_array=self._input._label.zarr_array,
             label_dimensions=self._input._label.dimensions,
-            label_pixel_size=self._input._label.pixel_size,
             axes_order=self._axes_order,
             transforms=self._output_transforms,
-            pixel_size=self._output.pixel_size,
             remove_channel_selection=True,
         )