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

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):
@@ -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):
@@ -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

@@ -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):
@@ -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,
         )