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

ngio/common/_synt_images_utils.py

@@ -0,0 +1,101 @@
+from math import ceil
+
+import numpy as np
+
+
+def _center_crop(arr: np.ndarray, target: int, axis: int) -> np.ndarray:
+    # Center-crop the array `arr` along dimension `axis` to size `target`.
+    # This assumes target < arr.shape[axis].
+    n = arr.shape[axis]
+    start = (n - target) // 2
+    end = start + target
+    slc = [slice(None)] * arr.ndim
+    slc[axis] = slice(start, end)
+    return arr[tuple(slc)]
+
+
+def _tile_to(
+    arr: np.ndarray, target: int, axis: int, label_mode: bool = False
+) -> np.ndarray:
+    # Tile the array `arr` along dimension `axis` to size `target`.
+    # This assumes target > arr.shape[axis].
+    n = arr.shape[axis]
+    reps = ceil(target / n)
+
+    tiles = []
+    flip = False
+    max_label = 0
+    for _ in range(reps):
+        if flip:
+            t_arr = np.flip(arr, axis=axis)
+        else:
+            t_arr = 1 * arr
+        if label_mode:
+            # Remove duplicate labels
+            t_arr = np.where(t_arr > 0, t_arr + max_label, 0)
+            max_label = t_arr.max()
+        tiles.append(t_arr)
+        flip = not flip
+
+    tiled = np.concatenate(tiles, axis=axis)
+
+    slc = [slice(None)] * arr.ndim
+    slc[axis] = slice(0, target)
+    return tiled[tuple(slc)]
+
+
+def _fit_to_shape_2d(
+    src: np.ndarray, out_shape: tuple[int, int], label_mode: bool = False
+) -> np.ndarray:
+    """Fit a 2D array to a target shape by center-cropping or tiling as necessary."""
+    out_r, out_c = out_shape
+    arr = src
+    if out_r < arr.shape[0]:
+        arr = _center_crop(arr, out_r, axis=0)
+    else:
+        arr = _tile_to(arr, out_r, axis=0, label_mode=label_mode)
+
+    if out_c < arr.shape[1]:
+        arr = _center_crop(arr, out_c, axis=1)
+    else:
+        arr = _tile_to(arr, out_c, axis=1, label_mode=label_mode)
+    return arr
+
+
+def fit_to_shape(
+    arr: np.ndarray, out_shape: tuple[int, ...], ensure_unique_info: bool = False
+) -> np.ndarray:
+    """Fit a 2D array to a target shape.
+
+    The x,y dimensions of `arr` are fitted to the last two dimensions of
+    `out_shape` by center-cropping or tiling as necessary.
+    The other dimensions are broadcasted as necessary.
+
+    WARNING: This does not zoom the image, it only crops or tiles it.
+
+    Args:
+        arr (np.ndarray): The input 2D array.
+        out_shape (tuple[int, ...]): The target shape. Must have at least 2
+            and at most 5 dimensions.
+        ensure_unique_info (bool, optional): If True, assumes that `arr` is a label
+            image and ensures that labels do not overlap when tiling. Defaults to False.
+
+    Returns:
+        np.ndarray: The fitted array with shape `out_shape`.
+    """
+    if len(out_shape) < 2:
+        raise ValueError("`out_shape` must contain at least 2 dimensions.")
+
+    if len(out_shape) > 5:
+        raise ValueError("`out_shape` must contain at most 5 dimensions.")
+
+    if any(d <= 0 for d in out_shape):
+        raise ValueError("`out_shape` must contain positive integers.")
+
+    if arr.ndim != 2:
+        raise ValueError("`arr` must be a 2D array.")
+
+    *_, sy, sx = out_shape
+    arr = _fit_to_shape_2d(arr, out_shape=(sy, sx), label_mode=ensure_unique_info)
+    arr = np.broadcast_to(arr, out_shape)
+    return arr

ngio/common/_zoom.py

@@ -7,17 +7,29 @@ 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
     x = x.reshape(-1, yshape, xshape)
     scale_xy = (zoom_y, zoom_x)
-    x_out = np.stack(
-        [
-            scipy_zoom(x[i], scale_xy, order=order, mode=mode, grid_mode=True)
-            for i in range(x.shape[0])
-        ]
-    )
+    _x_out = [
+        scipy_zoom(x[i], scale_xy, order=order, mode=mode, grid_mode=grid_mode)
+        for i in range(x.shape[0])
+    ]
+    x_out = np.stack(_x_out)  # type: ignore (scipy_zoom returns np.ndarray, but type is not inferred correctly)
     return x_out.reshape(*rest, *x_out.shape[1:])
 
 
@@ -33,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)
@@ -45,13 +61,13 @@ def fast_zoom(x, zoom, order=1, mode="grid-constant", grid_mode=True, auto_stack
         )
     else:
         xs = scipy_zoom(xs, new_zoom, order=order, mode=mode, grid_mode=grid_mode)
-    x = np.expand_dims(xs, axis=singletons)
+    x = np.expand_dims(xs, axis=singletons)  # type: ignore (scipy_zoom returns np.ndarray, but type is not inferred correctly)
     return x
 
 
 def _zoom_inputs_check(
     source_array: np.ndarray | da.Array,
-    scale: tuple[int, ...] | None = None,
+    scale: tuple[int | float, ...] | None = None,
     target_shape: tuple[int, ...] | None = None,
 ) -> tuple[np.ndarray, tuple[int, ...]]:
     if scale is None and target_shape is None:
@@ -72,16 +88,22 @@ 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(
+            f"Cannot scale array of shape {source_array.shape} with factors {_scale}."
+            " Target shape must have the same number of dimensions as the source array."
+        )
 
     return _scale, _target_shape
 
 
 def dask_zoom(
     source_array: da.Array,
-    scale: tuple[int, ...] | None = None,
+    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.
 
@@ -91,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.
@@ -100,22 +123,25 @@ 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
     )
 
     # Rechunk to better match the scaling operation
-    source_chunks = np.array(source_array.chunksize)
+    source_chunks = np.array(source_array.chunksize)  # type: ignore (da.Array.chunksize is a tuple of ints)
     better_source_chunks = np.maximum(1, np.round(source_chunks * _scale) / _scale)
     better_source_chunks = better_source_chunks.astype(int)
-    source_array = source_array.rechunk(better_source_chunks)  # type: ignore
+    source_array = source_array.rechunk(better_source_chunks)  # type: ignore (better_source_chunks is a valid input for rechunk)
 
     # Calculate the block output shape
     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(
@@ -130,9 +156,9 @@ def dask_zoom(
 
 def numpy_zoom(
     source_array: np.ndarray,
-    scale: tuple[int, ...] | None = None,
+    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.
 
@@ -152,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/__init__.py

@@ -0,0 +1,5 @@
+"""This module provides experimental features.
+
+Use with caution as these features may change or be removed in future releases
+without notice.
+"""

ngio/experimental/iterators/__init__.py

@@ -0,0 +1,15 @@
+"""This file is part of NGIO, a library for working with OME-Zarr data."""
+
+from ngio.experimental.iterators._feature import FeatureExtractorIterator
+from ngio.experimental.iterators._image_processing import ImageProcessingIterator
+from ngio.experimental.iterators._segmentation import (
+    MaskedSegmentationIterator,
+    SegmentationIterator,
+)
+
+__all__ = [
+    "FeatureExtractorIterator",
+    "ImageProcessingIterator",
+    "MaskedSegmentationIterator",
+    "SegmentationIterator",
+]

ngio/experimental/iterators/_abstract_iterator.py

@@ -0,0 +1,390 @@
+from abc import ABC, abstractmethod
+from collections.abc import Callable, Generator
+from typing import Generic, Literal, Self, TypeVar, overload
+
+from ngio import Roi
+from ngio.experimental.iterators._mappers import BasicMapper, MapperProtocol
+from ngio.experimental.iterators._rois_utils import (
+    by_chunks,
+    by_yx,
+    by_zyx,
+    grid,
+    rois_product,
+)
+from ngio.images._abstract_image import AbstractImage
+from ngio.io_pipes._io_pipes_types import DataGetterProtocol, DataSetterProtocol
+from ngio.io_pipes._ops_slices_utils import check_if_regions_overlap
+from ngio.tables import GenericRoiTable
+from ngio.utils import NgioValueError
+
+NumpyPipeType = TypeVar("NumpyPipeType")
+DaskPipeType = TypeVar("DaskPipeType")
+
+
+class AbstractIteratorBuilder(ABC, Generic[NumpyPipeType, DaskPipeType]):
+    """Base class for building iterators over ROIs."""
+
+    _rois: list[Roi]
+    _ref_image: AbstractImage
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(regions={len(self._rois)})"
+
+    @abstractmethod
+    def get_init_kwargs(self) -> dict:
+        """Return the initialization arguments for the iterator.
+
+        This is used to clone the iterator with the same parameters
+        after every "product" operation.
+        """
+        pass
+
+    @property
+    def rois(self) -> list[Roi]:
+        """Get the list of ROIs for the iterator."""
+        return self._rois
+
+    def _set_rois(self, rois: list[Roi]) -> None:
+        """Set the list of ROIs for the iterator."""
+        self._rois = rois
+
+    @property
+    def ref_image(self) -> AbstractImage:
+        """Get the reference image for the iterator."""
+        return self._ref_image
+
+    def _new_from_rois(self, rois: list[Roi]) -> Self:
+        """Create a new instance of the iterator with a different set of ROIs."""
+        init_kwargs = self.get_init_kwargs()
+        new_instance = self.__class__(**init_kwargs)
+        new_instance._set_rois(rois)
+        return new_instance
+
+    def grid(
+        self,
+        size_x: int | None = None,
+        size_y: int | None = None,
+        size_z: int | None = None,
+        size_t: int | None = None,
+        stride_x: int | None = None,
+        stride_y: int | None = None,
+        stride_z: int | None = None,
+        stride_t: int | None = None,
+        base_name: str = "",
+    ) -> Self:
+        """Create a grid of ROIs based on the input image dimensions."""
+        rois = grid(
+            rois=self.rois,
+            ref_image=self.ref_image,
+            size_x=size_x,
+            size_y=size_y,
+            size_z=size_z,
+            size_t=size_t,
+            stride_x=stride_x,
+            stride_y=stride_y,
+            stride_z=stride_z,
+            stride_t=stride_t,
+            base_name=base_name,
+        )
+        return self._new_from_rois(rois)
+
+    def by_yx(self) -> Self:
+        """Return a new iterator that iterates over ROIs by YX coordinates."""
+        rois = by_yx(self.rois, self.ref_image)
+        return self._new_from_rois(rois)
+
+    def by_zyx(self, strict: bool = True) -> Self:
+        """Return a new iterator that iterates over ROIs by ZYX coordinates.
+
+        Args:
+            strict (bool): If True, only iterate over ZYX if a Z axis
+                is present and not of size 1.
+
+        """
+        rois = by_zyx(self.rois, self.ref_image, strict=strict)
+        return self._new_from_rois(rois)
+
+    def by_chunks(self, overlap_xy: int = 0, overlap_z: int = 0) -> Self:
+        """Return a new iterator that iterates over ROIs by chunks.
+
+        Args:
+            overlap_xy (int): Overlap in XY dimensions.
+            overlap_z (int): Overlap in Z dimension.
+
+        Returns:
+            SegmentationIterator: A new iterator with chunked ROIs.
+        """
+        rois = by_chunks(
+            self.rois, self.ref_image, overlap_xy=overlap_xy, overlap_z=overlap_z
+        )
+        return self._new_from_rois(rois)
+
+    def product(self, other: list[Roi] | GenericRoiTable) -> Self:
+        """Cartesian product of the current ROIs with an arbitrary list of ROIs."""
+        if isinstance(other, GenericRoiTable):
+            other = other.rois()
+        rois = rois_product(self.rois, other)
+        return self._new_from_rois(rois)
+
+    @abstractmethod
+    def build_numpy_getter(self, roi: Roi) -> DataGetterProtocol[NumpyPipeType]:
+        """Build a getter function for the given ROI."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def build_numpy_setter(self, roi: Roi) -> DataSetterProtocol[NumpyPipeType] | None:
+        """Build a setter function for the given ROI."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def build_dask_getter(self, roi: Roi) -> DataGetterProtocol[DaskPipeType]:
+        """Build a Dask reader function for the given ROI."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def build_dask_setter(self, roi: Roi) -> DataSetterProtocol[DaskPipeType] | None:
+        """Build a Dask setter function for the given ROI."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def post_consolidate(self) -> None:
+        """Post-process the consolidated data."""
+        raise NotImplementedError
+
+    def _numpy_getters_generator(self) -> Generator[DataGetterProtocol[NumpyPipeType]]:
+        """Return a list of numpy getter functions for all ROIs."""
+        yield from (self.build_numpy_getter(roi) for roi in self.rois)
+
+    def _dask_getters_generator(self) -> Generator[DataGetterProtocol[DaskPipeType]]:
+        """Return a list of dask getter functions for all ROIs."""
+        yield from (self.build_dask_getter(roi) for roi in self.rois)
+
+    def _numpy_setters_generator(
+        self,
+    ) -> Generator[DataSetterProtocol[NumpyPipeType] | None]:
+        """Return a list of numpy setter functions for all ROIs."""
+        yield from (self.build_numpy_setter(roi) for roi in self.rois)
+
+    def _dask_setters_generator(
+        self,
+    ) -> Generator[DataSetterProtocol[DaskPipeType] | None]:
+        """Return a list of dask setter functions for all ROIs."""
+        yield from (self.build_dask_setter(roi) for roi in self.rois)
+
+    def _read_and_write_generator(
+        self,
+        getters: Generator[
+            DataGetterProtocol[NumpyPipeType] | DataGetterProtocol[DaskPipeType]
+        ],
+        setters: Generator[
+            DataSetterProtocol[NumpyPipeType] | DataSetterProtocol[DaskPipeType] | None
+        ],
+    ) -> Generator[
+        tuple[
+            DataGetterProtocol[NumpyPipeType] | DataGetterProtocol[DaskPipeType],
+            DataSetterProtocol[NumpyPipeType] | DataSetterProtocol[DaskPipeType],
+        ]
+    ]:
+        """Create an iterator over the pixels of the ROIs."""
+        for getter, setter in zip(getters, setters, strict=True):
+            if setter is None:
+                name = self.__class__.__name__
+                raise NgioValueError(f"Iterator is read-only: {name}")
+            yield getter, setter
+        self.post_consolidate()
+
+    @overload
+    def iter(
+        self,
+        lazy: Literal[True],
+        data_mode: Literal["numpy"],
+        iterator_mode: Literal["readwrite"],
+    ) -> Generator[
+        tuple[DataGetterProtocol[NumpyPipeType], DataSetterProtocol[NumpyPipeType]]
+    ]: ...
+
+    @overload
+    def iter(
+        self,
+        lazy: Literal[True],
+        data_mode: Literal["numpy"],
+        iterator_mode: Literal["readonly"] = ...,
+    ) -> Generator[DataGetterProtocol[NumpyPipeType]]: ...
+
+    @overload
+    def iter(
+        self,
+        lazy: Literal[True],
+        data_mode: Literal["dask"],
+        iterator_mode: Literal["readwrite"],
+    ) -> Generator[
+        tuple[DataGetterProtocol[DaskPipeType], DataSetterProtocol[DaskPipeType]]
+    ]: ...
+
+    @overload
+    def iter(
+        self,
+        lazy: Literal[True],
+        data_mode: Literal["dask"],
+        iterator_mode: Literal["readonly"] = ...,
+    ) -> Generator[DataGetterProtocol[DaskPipeType]]: ...
+
+    @overload
+    def iter(
+        self,
+        lazy: Literal[False],
+        data_mode: Literal["numpy"],
+        iterator_mode: Literal["readwrite"],
+    ) -> Generator[tuple[NumpyPipeType, DataSetterProtocol[NumpyPipeType]]]: ...
+
+    @overload
+    def iter(
+        self,
+        lazy: Literal[False],
+        data_mode: Literal["numpy"],
+        iterator_mode: Literal["readonly"] = ...,
+    ) -> Generator[NumpyPipeType]: ...
+
+    @overload
+    def iter(
+        self,
+        lazy: Literal[False],
+        data_mode: Literal["dask"],
+        iterator_mode: Literal["readwrite"],
+    ) -> Generator[tuple[DaskPipeType, DataSetterProtocol[DaskPipeType]]]: ...
+
+    @overload
+    def iter(
+        self,
+        lazy: Literal[False],
+        data_mode: Literal["dask"],
+        iterator_mode: Literal["readonly"] = ...,
+    ) -> Generator[DaskPipeType]: ...
+
+    def iter(
+        self,
+        lazy: bool = False,
+        data_mode: Literal["numpy", "dask"] = "dask",
+        iterator_mode: Literal["readwrite", "readonly"] = "readwrite",
+    ) -> Generator:
+        """Create an iterator over the pixels of the ROIs."""
+        if data_mode == "numpy":
+            getters = self._numpy_getters_generator()
+            setters = self._numpy_setters_generator()
+        elif data_mode == "dask":
+            getters = self._dask_getters_generator()
+            setters = self._dask_setters_generator()
+        else:
+            raise NgioValueError(f"Invalid mode: {data_mode}")
+
+        if iterator_mode == "readonly":
+            if lazy:
+                return getters
+            else:
+                return (getter() for getter in getters)
+        if lazy:
+            return self._read_and_write_generator(getters, setters)
+        else:
+            gen = self._read_and_write_generator(getters, setters)
+            return ((getter(), setter) for getter, setter in gen)
+
+    def iter_as_numpy(
+        self,
+    ):
+        """Create an iterator over the pixels of the ROIs."""
+        return self.iter(lazy=False, data_mode="numpy", iterator_mode="readwrite")
+
+    def iter_as_dask(
+        self,
+    ):
+        """Create an iterator over the pixels of the ROIs."""
+        return self.iter(lazy=False, data_mode="dask", iterator_mode="readwrite")
+
+    def map_as_numpy(
+        self,
+        func: Callable[[NumpyPipeType], NumpyPipeType],
+        mapper: MapperProtocol[NumpyPipeType] | None = None,
+    ) -> None:
+        """Apply a transformation function to the ROI pixels."""
+        if mapper is None:
+            _mapper = BasicMapper[NumpyPipeType]()
+        else:
+            _mapper = mapper
+
+        _mapper(
+            func=func,
+            getters=self._numpy_getters_generator(),
+            setters=self._numpy_setters_generator(),
+        )
+        self.post_consolidate()
+
+    def map_as_dask(
+        self,
+        func: Callable[[DaskPipeType], DaskPipeType],
+        mapper: MapperProtocol[DaskPipeType] | None = None,
+    ) -> None:
+        """Apply a transformation function to the ROI pixels."""
+        if mapper is None:
+            _mapper = BasicMapper[DaskPipeType]()
+        else:
+            _mapper = mapper
+
+        _mapper(
+            func=func,
+            getters=self._dask_getters_generator(),
+            setters=self._dask_setters_generator(),
+        )
+        self.post_consolidate()
+
+    def check_if_regions_overlap(self) -> bool:
+        """Check if any of the ROIs overlap logically.
+
+        If two ROIs cover the same pixel, they are considered to overlap.
+        This does not consider chunking or other storage details.
+
+        Returns:
+            bool: True if any ROIs overlap. False otherwise.
+        """
+        if len(self.rois) < 2:
+            # Less than 2 ROIs cannot overlap
+            return False
+
+        slicing_tuples = (
+            g.slicing_ops.normalized_slicing_tuple
+            for g in self._numpy_getters_generator()
+        )
+        x = check_if_regions_overlap(slicing_tuples)
+        return x
+
+    def require_no_regions_overlap(self) -> None:
+        """Ensure that the Iterator's ROIs do not overlap."""
+        if self.check_if_regions_overlap():
+            raise NgioValueError("Some rois overlap.")
+
+    def check_if_chunks_overlap(self) -> bool:
+        """Check if any of the ROIs overlap in terms of chunks.
+
+        If two ROIs cover the same chunk, they are considered to overlap in chunks.
+        This does not consider pixel-level overlaps.
+
+        Returns:
+            bool: True if any ROIs overlap in chunks, False otherwise.
+        """
+        from ngio.io_pipes._ops_slices_utils import check_if_chunks_overlap
+
+        if len(self.rois) < 2:
+            # Less than 2 ROIs cannot overlap
+            return False
+
+        slicing_tuples = (
+            g.slicing_ops.normalized_slicing_tuple
+            for g in self._numpy_getters_generator()
+        )
+        shape = self.ref_image.shape
+        chunks = self.ref_image.chunks
+        return check_if_chunks_overlap(slicing_tuples, shape, chunks)
+
+    def require_no_chunks_overlap(self) -> None:
+        """Ensure that the ROIs do not overlap in terms of chunks."""
+        if self.check_if_chunks_overlap():
+            raise NgioValueError("Some rois overlap in chunks.")