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

ngio/common/_roi.py

@@ -4,41 +4,32 @@ These are the interfaces bwteen the ROI tables / masking ROI tables and
     the ImageLikeHandler.
 """
 
-from collections.abc import Callable, Sequence
-from typing import Generic, TypeVar
+from typing import TypeVar
 from warnings import warn
 
-import dask.array as da
-import numpy as np
-import zarr
 from pydantic import BaseModel, ConfigDict
 
-from ngio.common._array_io_pipes import (
-    build_dask_getter,
-    build_dask_setter,
-    build_masked_dask_getter,
-    build_masked_dask_setter,
-    build_masked_numpy_getter,
-    build_masked_numpy_setter,
-    build_numpy_getter,
-    build_numpy_setter,
-)
-from ngio.common._array_io_utils import SlicingInputType, TransformProtocol
 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 | None) -> int:
-    """Convert to raster coordinates."""
-    round_value = int(np.round(value / pixel_size))
-    # Ensure the value is within the image shape boundaries
-    if max_shape is not None:
-        return max(0, min(round_value, max_shape))
-    return round_value
+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
 
@@ -46,24 +37,24 @@ def _to_world(value: int, pixel_size: float) -> float:
 T = TypeVar("T", int, float)
 
 
-class GenericRoi(BaseModel, Generic[T]):
+class GenericRoi(BaseModel):
     """A generic Region of Interest (ROI) model."""
 
     name: str | None
-    x: T
-    y: T
-    z: T | None = None
-    t: T | None = None
-    x_length: T
-    y_length: T
-    z_length: T | None = None
-    t_length: T | None = None
+    x: float
+    y: float
+    z: float | None = None
+    t: float | None = None
+    x_length: float
+    y_length: float
+    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 intersection(self, other: "GenericRoi[T]") -> "GenericRoi[T] | None":
+    def intersection(self, other: "GenericRoi") -> "GenericRoi | None":
         """Calculate the intersection of this ROI with another ROI."""
         return roi_intersection(self, other)
 
@@ -129,9 +120,7 @@ def _1d_intersection(
     return start, length
 
 
-def roi_intersection(
-    ref_roi: GenericRoi[T], other_roi: GenericRoi[T]
-) -> GenericRoi[T] | None:
+def roi_intersection(ref_roi: GenericRoi, other_roi: GenericRoi) -> GenericRoi | None:
     """Calculate the intersection of two ROIs."""
     if (
         ref_roi.unit is not None
@@ -200,52 +189,29 @@ def roi_intersection(
     )
 
 
-class Roi(GenericRoi[float]):
+class Roi(GenericRoi):
     x: float = 0.0
     y: float = 0.0
     unit: SpaceUnits | str | None = DefaultSpaceUnit
 
-    def to_roi_pixels(
-        self, pixel_size: PixelSize, dimensions: Dimensions | None = None
-    ) -> "RoiPixels":
+    def to_roi_pixels(self, pixel_size: PixelSize) -> "RoiPixels":
         """Convert to raster coordinates."""
-        if dimensions is None:
-            # No check for dimensions
-            dim_x, dim_y, dim_z, dim_t = None, None, None, None
-        else:
-            dim_x, dim_y, dim_z, dim_t = (
-                dimensions.get("x"),
-                dimensions.get("y"),
-                dimensions.get("z"),
-                dimensions.get("t"),
-            )
-
-        x = _to_raster(self.x, pixel_size.x, dim_x)
-        x_length = _to_raster(self.x_length, pixel_size.x, dim_x)
-        y = _to_raster(self.y, pixel_size.y, dim_y)
-        y_length = _to_raster(self.y_length, pixel_size.y, dim_y)
+        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 = None
+            z, z_length = None, None
         else:
-            z = _to_raster(self.z, pixel_size.z, dim_z)
-
-        if self.z_length is None:
-            z_length = None
-        else:
-            z_length = _to_raster(self.z_length, pixel_size.z, dim_z)
+            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 = None
-        else:
-            t = _to_raster(self.t, pixel_size.t, dim_t)
-
-        if self.t_length is None:
-            t_length = None
+            t, t_length = None, None
         else:
-            t_length = _to_raster(self.t_length, pixel_size.t, dim_t)
-
+            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=x,
@@ -272,7 +238,7 @@ class Roi(GenericRoi[float]):
             stacklevel=2,
         )
 
-        return self.to_roi_pixels(pixel_size=pixel_size, dimensions=dimensions)
+        return self.to_roi_pixels(pixel_size=pixel_size)
 
     def zoom(self, zoom_factor: float = 1) -> "Roi":
         """Zoom the ROI by a factor.
@@ -286,11 +252,11 @@ class Roi(GenericRoi[float]):
         return zoom_roi(self, zoom_factor)
 
 
-class RoiPixels(GenericRoi[int]):
+class RoiPixels(GenericRoi):
     """Region of interest (ROI) in pixel coordinates."""
 
-    x: int = 0
-    y: int = 0
+    x: float = 0
+    y: float = 0
     unit: SpaceUnits | str | None = None
 
     def to_roi(self, pixel_size: PixelSize) -> "Roi":
@@ -336,17 +302,12 @@ class RoiPixels(GenericRoi[int]):
             **extra_dict,
         )
 
-    def to_slicing_dict(self) -> dict[str, SlicingInputType]:
-        x_slice = slice(self.x, self.x + self.x_length)
-        y_slice = slice(self.y, self.y + self.y_length)
-        if self.z is not None and self.z_length is not None:
-            z_slice = slice(self.z, self.z + self.z_length)
-        else:
-            z_slice = slice(None)
-        if self.t is not None and self.t_length is not None:
-            t_slice = slice(self.t, self.t + self.t_length)
-        else:
-            t_slice = slice(None)
+    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": x_slice,
             "y": y_slice,
@@ -391,328 +352,3 @@ def zoom_roi(roi: Roi, zoom_factor: float = 1) -> Roi:
         unit=roi.unit,
     )
     return new_roi
-
-
-def roi_to_slicing_dict(
-    roi: Roi | RoiPixels,
-    dimensions: Dimensions,
-    pixel_size: PixelSize | None = None,
-    slicing_dict: dict[str, SlicingInputType] | None = None,
-) -> dict[str, SlicingInputType]:
-    """Convert a ROI to a slicing dictionary."""
-    if isinstance(roi, Roi):
-        if pixel_size is None:
-            raise NgioValueError(
-                "pixel_size must be provided when converting a Roi to slice_kwargs."
-            )
-        roi = roi.to_roi_pixels(pixel_size=pixel_size, dimensions=dimensions)
-
-    roi_slicing_dict = roi.to_slicing_dict()
-    if slicing_dict is None:
-        return roi_slicing_dict
-
-    # Additional slice kwargs can be provided
-    # and will override the ones from the ROI
-    roi_slicing_dict.update(slicing_dict)
-    return roi_slicing_dict
-
-
-def build_roi_numpy_getter(
-    zarr_array: zarr.Array,
-    dimensions: Dimensions,
-    roi: Roi | RoiPixels,
-    pixel_size: PixelSize | None = None,
-    axes_order: Sequence[str] | None = None,
-    transforms: Sequence[TransformProtocol] | None = None,
-    slicing_dict: dict[str, SlicingInputType] | None = None,
-    remove_channel_selection: bool = False,
-) -> Callable[[], np.ndarray]:
-    """Prepare slice kwargs for setting an array."""
-    input_slice_kwargs = roi_to_slicing_dict(
-        roi=roi,
-        dimensions=dimensions,
-        pixel_size=pixel_size,
-        slicing_dict=slicing_dict,
-    )
-    return build_numpy_getter(
-        zarr_array=zarr_array,
-        dimensions=dimensions,
-        axes_order=axes_order,
-        transforms=transforms,
-        slicing_dict=input_slice_kwargs,
-        remove_channel_selection=remove_channel_selection,
-    )
-
-
-def build_roi_numpy_setter(
-    zarr_array: zarr.Array,
-    dimensions: Dimensions,
-    roi: Roi | RoiPixels,
-    pixel_size: PixelSize | None = None,
-    axes_order: Sequence[str] | None = None,
-    transforms: Sequence[TransformProtocol] | None = None,
-    slicing_dict: dict[str, SlicingInputType] | None = None,
-    remove_channel_selection: bool = False,
-) -> Callable[[np.ndarray], None]:
-    """Prepare slice kwargs for setting an array."""
-    input_slice_kwargs = roi_to_slicing_dict(
-        roi=roi,
-        dimensions=dimensions,
-        pixel_size=pixel_size,
-        slicing_dict=slicing_dict,
-    )
-    return build_numpy_setter(
-        zarr_array=zarr_array,
-        dimensions=dimensions,
-        axes_order=axes_order,
-        transforms=transforms,
-        slicing_dict=input_slice_kwargs,
-        remove_channel_selection=remove_channel_selection,
-    )
-
-
-def build_roi_dask_getter(
-    zarr_array: zarr.Array,
-    dimensions: Dimensions,
-    roi: Roi | RoiPixels,
-    pixel_size: PixelSize | None = None,
-    axes_order: Sequence[str] | None = None,
-    transforms: Sequence[TransformProtocol] | None = None,
-    slicing_dict: dict[str, SlicingInputType] | None = None,
-    remove_channel_selection: bool = False,
-) -> Callable[[], da.Array]:
-    """Prepare slice kwargs for getting an array."""
-    input_slice_kwargs = roi_to_slicing_dict(
-        roi=roi,
-        dimensions=dimensions,
-        pixel_size=pixel_size,
-        slicing_dict=slicing_dict,
-    )
-    return build_dask_getter(
-        zarr_array=zarr_array,
-        dimensions=dimensions,
-        axes_order=axes_order,
-        transforms=transforms,
-        slicing_dict=input_slice_kwargs,
-        remove_channel_selection=remove_channel_selection,
-    )
-
-
-def build_roi_dask_setter(
-    zarr_array: zarr.Array,
-    dimensions: Dimensions,
-    roi: Roi | RoiPixels,
-    pixel_size: PixelSize | None = None,
-    axes_order: Sequence[str] | None = None,
-    transforms: Sequence[TransformProtocol] | None = None,
-    slicing_dict: dict[str, SlicingInputType] | None = None,
-    remove_channel_selection: bool = False,
-) -> Callable[[da.Array], None]:
-    """Prepare slice kwargs for setting an array."""
-    input_slice_kwargs = roi_to_slicing_dict(
-        roi=roi,
-        dimensions=dimensions,
-        pixel_size=pixel_size,
-        slicing_dict=slicing_dict,
-    )
-    return build_dask_setter(
-        zarr_array=zarr_array,
-        dimensions=dimensions,
-        axes_order=axes_order,
-        transforms=transforms,
-        slicing_dict=input_slice_kwargs,
-        remove_channel_selection=remove_channel_selection,
-    )
-
-
-################################################################
-#
-# Masked ROIs array pipes
-#
-################################################################
-
-
-def build_roi_masked_numpy_getter(
-    *,
-    roi: Roi | RoiPixels,
-    zarr_array: zarr.Array,
-    dimensions: Dimensions,
-    pixel_size: PixelSize | None = None,
-    label_zarr_array: zarr.Array,
-    label_dimensions: Dimensions,
-    label_pixel_size: PixelSize | None = None,
-    axes_order: Sequence[str] | None = None,
-    transforms: Sequence[TransformProtocol] | None = None,
-    label_transforms: Sequence[TransformProtocol] | None = None,
-    slicing_dict: dict[str, SlicingInputType] | None = None,
-    label_slicing_dict: dict[str, SlicingInputType] | None = None,
-    fill_value: int | float = 0,
-    allow_scaling: bool = True,
-    remove_channel_selection: bool = False,
-) -> Callable[[], np.ndarray]:
-    """Prepare slice kwargs for getting a masked array."""
-    input_slice_kwargs = roi_to_slicing_dict(
-        roi=roi,
-        dimensions=dimensions,
-        pixel_size=pixel_size,
-        slicing_dict=slicing_dict,
-    )
-    label_slice_kwargs = roi_to_slicing_dict(
-        roi=roi,
-        dimensions=label_dimensions,
-        pixel_size=label_pixel_size,
-        slicing_dict=label_slicing_dict,
-    )
-    return build_masked_numpy_getter(
-        zarr_array=zarr_array,
-        dimensions=dimensions,
-        label_zarr_array=label_zarr_array,
-        label_dimensions=label_dimensions,
-        label_id=roi.label,
-        axes_order=axes_order,
-        transforms=transforms,
-        label_transforms=label_transforms,
-        slicing_dict=input_slice_kwargs,
-        label_slicing_dict=label_slice_kwargs,
-        fill_value=fill_value,
-        allow_scaling=allow_scaling,
-        remove_channel_selection=remove_channel_selection,
-    )
-
-
-def build_roi_masked_numpy_setter(
-    *,
-    roi: Roi | RoiPixels,
-    zarr_array: zarr.Array,
-    dimensions: Dimensions,
-    pixel_size: PixelSize | None = None,
-    label_zarr_array: zarr.Array,
-    label_dimensions: Dimensions,
-    label_pixel_size: PixelSize | None = None,
-    axes_order: Sequence[str] | None = None,
-    transforms: Sequence[TransformProtocol] | None = None,
-    label_transforms: Sequence[TransformProtocol] | None = None,
-    slicing_dict: dict[str, SlicingInputType] | None = None,
-    label_slicing_dict: dict[str, SlicingInputType] | None = None,
-    allow_scaling: bool = True,
-    remove_channel_selection: bool = False,
-) -> Callable[[np.ndarray], None]:
-    """Prepare slice kwargs for setting a masked array."""
-    input_slice_kwargs = roi_to_slicing_dict(
-        roi=roi,
-        dimensions=dimensions,
-        pixel_size=pixel_size,
-        slicing_dict=slicing_dict,
-    )
-    label_slice_kwargs = roi_to_slicing_dict(
-        roi=roi,
-        dimensions=label_dimensions,
-        pixel_size=label_pixel_size,
-        slicing_dict=label_slicing_dict,
-    )
-    return build_masked_numpy_setter(
-        zarr_array=zarr_array,
-        dimensions=dimensions,
-        label_zarr_array=label_zarr_array,
-        label_dimensions=label_dimensions,
-        label_id=roi.label,
-        axes_order=axes_order,
-        transforms=transforms,
-        label_transforms=label_transforms,
-        slicing_dict=input_slice_kwargs,
-        label_slicing_dict=label_slice_kwargs,
-        allow_scaling=allow_scaling,
-        remove_channel_selection=remove_channel_selection,
-    )
-
-
-def build_roi_masked_dask_getter(
-    *,
-    roi: Roi | RoiPixels,
-    zarr_array: zarr.Array,
-    dimensions: Dimensions,
-    pixel_size: PixelSize | None = None,
-    label_zarr_array: zarr.Array,
-    label_dimensions: Dimensions,
-    label_pixel_size: PixelSize | None = None,
-    axes_order: Sequence[str] | None = None,
-    transforms: Sequence[TransformProtocol] | None = None,
-    label_transforms: Sequence[TransformProtocol] | None = None,
-    slicing_dict: dict[str, SlicingInputType] | None = None,
-    label_slicing_dict: dict[str, SlicingInputType] | None = None,
-    allow_scaling: bool = True,
-    remove_channel_selection: bool = False,
-) -> Callable[[], da.Array]:
-    """Prepare slice kwargs for getting a masked array."""
-    input_slice_kwargs = roi_to_slicing_dict(
-        roi=roi,
-        dimensions=dimensions,
-        pixel_size=pixel_size,
-        slicing_dict=slicing_dict,
-    )
-    label_slice_kwargs = roi_to_slicing_dict(
-        roi=roi,
-        dimensions=label_dimensions,
-        pixel_size=label_pixel_size,
-        slicing_dict=label_slicing_dict,
-    )
-    return build_masked_dask_getter(
-        zarr_array=zarr_array,
-        dimensions=dimensions,
-        label_zarr_array=label_zarr_array,
-        label_dimensions=label_dimensions,
-        label_id=roi.label,
-        axes_order=axes_order,
-        transforms=transforms,
-        label_transforms=label_transforms,
-        slicing_dict=input_slice_kwargs,
-        label_slicing_dict=label_slice_kwargs,
-        allow_scaling=allow_scaling,
-        remove_channel_selection=remove_channel_selection,
-    )
-
-
-def build_roi_masked_dask_setter(
-    *,
-    roi: Roi | RoiPixels,
-    zarr_array: zarr.Array,
-    dimensions: Dimensions,
-    pixel_size: PixelSize | None = None,
-    label_zarr_array: zarr.Array,
-    label_dimensions: Dimensions,
-    label_pixel_size: PixelSize | None = None,
-    axes_order: Sequence[str] | None = None,
-    transforms: Sequence[TransformProtocol] | None = None,
-    label_transforms: Sequence[TransformProtocol] | None = None,
-    slicing_dict: dict[str, SlicingInputType] | None = None,
-    label_slicing_dict: dict[str, SlicingInputType] | None = None,
-    allow_scaling: bool = True,
-    remove_channel_selection: bool = False,
-) -> Callable[[da.Array], None]:
-    """Prepare slice kwargs for setting a masked array."""
-    input_slice_kwargs = roi_to_slicing_dict(
-        roi=roi,
-        dimensions=dimensions,
-        pixel_size=pixel_size,
-        slicing_dict=slicing_dict,
-    )
-    label_slice_kwargs = roi_to_slicing_dict(
-        roi=roi,
-        dimensions=label_dimensions,
-        pixel_size=label_pixel_size,
-        slicing_dict=label_slicing_dict,
-    )
-    return build_masked_dask_setter(
-        zarr_array=zarr_array,
-        dimensions=dimensions,
-        label_zarr_array=label_zarr_array,
-        label_dimensions=label_dimensions,
-        label_id=roi.label,
-        axes_order=axes_order,
-        transforms=transforms,
-        label_transforms=label_transforms,
-        slicing_dict=input_slice_kwargs,
-        label_slicing_dict=label_slice_kwargs,
-        allow_scaling=allow_scaling,
-        remove_channel_selection=remove_channel_selection,
-    )

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()