ngio 0.2.0a3__tar.gz → 0.2.0b1__tar.gz

{ngio-0.2.0a3 → ngio-0.2.0b1}/.gitignore

@@ -116,7 +116,10 @@ ENV/
 pixi.lock
 *.egg-info
 
+# Ignore all .zarr directories
 *.zarr
+# but allow .zarr in tests/data
+!tests/data/**/**/test_*.zarr
 
 # ignore data directory
 ./data/

{ngio-0.2.0a3 → ngio-0.2.0b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ngio
-Version: 0.2.0a3
+Version: 0.2.0b1
 Summary: Next Generation file format IO
 Project-URL: homepage, https://github.com/lorenzocerrone/ngio
 Project-URL: repository, https://github.com/lorenzocerrone/ngio
@@ -29,6 +29,7 @@ Requires-Dist: requests
 Requires-Dist: xarray
 Requires-Dist: zarr<3
 Provides-Extra: dev
+Requires-Dist: devtools; extra == 'dev'
 Requires-Dist: matplotlib; extra == 'dev'
 Requires-Dist: mypy; extra == 'dev'
 Requires-Dist: napari; extra == 'dev'
@@ -38,6 +39,7 @@ Requires-Dist: pre-commit; extra == 'dev'
 Requires-Dist: pyqt5; extra == 'dev'
 Requires-Dist: rich; extra == 'dev'
 Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: scikit-image; extra == 'dev'
 Provides-Extra: docs
 Requires-Dist: mkdocs; extra == 'docs'
 Requires-Dist: mkdocs-autorefs; extra == 'docs'
@@ -50,6 +52,7 @@ Requires-Dist: scikit-image; extra == 'docs'
 Provides-Extra: test
 Requires-Dist: pytest; extra == 'test'
 Requires-Dist: pytest-cov; extra == 'test'
+Requires-Dist: scikit-image; extra == 'test'
 Description-Content-Type: text/markdown
 
 # NGIO - Next Generation file format IO

{ngio-0.2.0a3 → ngio-0.2.0b1}/docs/notebooks/basic_usage.ipynb

@@ -86,10 +86,10 @@
     "print(image)\n",
     "\n",
     "# 3. Get image from a specific pixel size using the pixel_size keyword\n",
-    "image = omezarr_container.get_image(\n",
-    "    pixel_size=PixelSize(x=0.65, y=0.65, z=1000), strict=True\n",
-    ")\n",
-    "print(image)"
+    "# image = omezarr_container.get_image(\n",
+    "#    pixel_size=PixelSize(x=0.65, y=0.65, z=1), strict=True\n",
+    "# )\n",
+    "print(image.pixel_size == PixelSize(x=0.325, y=0.325, z=1))"
    ]
   },
   {
@@ -287,6 +287,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "import fsspec\n",
     "import fsspec.implementations.http\n",
     "\n",
     "url = (\n",
@@ -298,7 +299,6 @@
     "\n",
     "fs = fsspec.implementations.http.HTTPFileSystem(client_kwargs={})\n",
     "store = fs.get_mapper(url)\n",
-    "\n",
     "omezarr = open_omezarr_container(store)\n",
     "omezarr"
    ]
@@ -319,40 +319,6 @@
     "omezarr\n",
     "```"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from ngio import open_omezarr_container\n",
-    "from ngio.utils import fractal_fsspec_store\n",
-    "\n",
-    "store = fractal_fsspec_store(\n",
-    "    url=\"https://fractal.mls.uzh.ch/vizarr/data/data/active/lorcerr/fractal/104_altmeyer_10097/443_experiment3/AP411_U2OS.zarr/A/1/0\",\n",
-    "    fractal_token=\"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiI0MCIsImF1ZCI6WyJmYXN0YXBpLXVzZXJzOmF1dGgiXSwiZXhwIjoxNzQxMzY1NzY2fQ.wnpJSL6rtkKIoFeW7D31sVpEXeDcD0VrahwbF4CGbNI\",\n",
-    ")\n",
-    "omezarr = open_omezarr_container(store)\n",
-    "print(omezarr)\n",
-    "print(omezarr.get_image(path=\"3\").get_array())"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "omezarr.get_image(path=\"3\").get_array()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {

{ngio-0.2.0a3 → ngio-0.2.0b1}/pyproject.toml

@@ -51,18 +51,20 @@ dependencies = [
 # https://peps.python.org/pep-0621/#dependencies-optional-dependencies
 # "extras" (e.g. for `pip install .[test]`)
 [project.optional-dependencies]
-test = ["pytest", "pytest-cov"]
+test = ["pytest", "pytest-cov", "scikit-image"]
 
 dev = [
     "napari",
     "pyqt5",
     "matplotlib",
+    "devtools",
     "notebook",
     "mypy",
-    "pdbpp",      # https://github.com/pdbpp/pdbpp
+    "pdbpp",        # https://github.com/pdbpp/pdbpp
     "pre-commit",
-    "rich",       # https://github.com/Textualize/rich
+    "rich",         # https://github.com/Textualize/rich
     "ruff",
+    "scikit-image",
 ] # add anything else you like to have in your dev environment here
 
 docs = [
@@ -212,18 +214,12 @@ test13 = { features = ["py13", "test"], solve-group = "py13" }
 # dev env
 dev = { features = ["dev", "test"], solve-group = "py11" }
 
-
-[tool.pixi.feature.py11.tasks]
-pytest_test11 = "pytest"
+[tool.pixi.tasks]
+serve_docs = "mkdocs serve"
+run_tests = "pytest"
+clean_nb_data = "rm -rf ./docs/notebooks/**/*.zarr"
 test_nb = { cmd = "jupyter-execute ./docs/notebooks/*.ipynb" }
-
-[tool.pixi.feature.py12.tasks]
-pytest_test12 = "pytest"
-
-[tool.pixi.feature.py13.tasks]
-pytest_test13 = "pytest"
-
-[tool.pixi.feature.task-feat.tasks]
+test = { depends-on = ["run_tests", "clean_nb_data", "test_nb"] }
 pre_commit_install = "pre-commit install"
 
 ruff-fix-imports = "ruff check --select I --fix"
@@ -233,12 +229,3 @@ pre-commit = { cmd = "pre-commit run --all-files", depends-on = [
     "pre_commit_install",
     "ruff-format",
 ] }
-
-[tool.pixi.tasks]
-serve_docs = "mkdocs serve"
-test = { depends-on = [
-    "pytest_test11",
-    "pytest_test12",
-    "pytest_test13",
-    "test_nb",
-] }

{ngio-0.2.0a3 → ngio-0.2.0b1}/src/ngio/__init__.py

@@ -10,7 +10,7 @@ __author__ = "Lorenzo Cerrone"
 __email__ = "lorenzo.cerrone@uzh.ch"
 
 from ngio.common import ArrayLike, Dimensions
-from ngio.hcs import OmeZarrPlate, OmeZarrWell, open_omezarr_plate, open_omezarr_well
+from ngio.hcs import OmeZarrPlate, create_empty_plate, open_omezarr_plate
 from ngio.images import (
     Image,
     Label,
@@ -20,22 +20,22 @@ from ngio.images import (
     open_image,
     open_omezarr_container,
 )
-from ngio.ome_zarr_meta.ngio_specs import AxesSetup, PixelSize
+from ngio.ome_zarr_meta.ngio_specs import AxesSetup, ImageInWellPath, PixelSize
 
 __all__ = [
     "ArrayLike",
     "AxesSetup",
     "Dimensions",
     "Image",
+    "ImageInWellPath",
     "Label",
     "OmeZarrContainer",
     "OmeZarrPlate",
-    "OmeZarrWell",
     "PixelSize",
     "create_empty_omezarr",
+    "create_empty_plate",
     "create_omezarr_from_array",
     "open_image",
     "open_omezarr_container",
     "open_omezarr_plate",
-    "open_omezarr_well",
 ]

{ngio-0.2.0a3 → ngio-0.2.0b1}/src/ngio/common/__init__.py

@@ -1,6 +1,11 @@
 """Common classes and functions that are used across the package."""
 
-from ngio.common._array_pipe import get_pipe, set_pipe
+from ngio.common._array_pipe import (
+    get_masked_pipe,
+    get_pipe,
+    set_masked_pipe,
+    set_pipe,
+)
 from ngio.common._axes_transforms import (
     transform_dask_array,
     transform_list,
@@ -8,8 +13,9 @@ from ngio.common._axes_transforms import (
 )
 from ngio.common._common_types import ArrayLike
 from ngio.common._dimensions import Dimensions
+from ngio.common._masking_roi import compute_masking_roi
 from ngio.common._pyramid import consolidate_pyramid, init_empty_pyramid, on_disk_zoom
-from ngio.common._roi import RasterCooROI, WorldCooROI
+from ngio.common._roi import RasterCooROI, WorldCooROI, roi_to_slice_kwargs
 from ngio.common._slicer import (
     SliceTransform,
     compute_and_slices,
@@ -27,16 +33,20 @@ __all__ = [
     "SliceTransform",
     "WorldCooROI",
     "compute_and_slices",
+    "compute_masking_roi",
     "consolidate_pyramid",
     "dask_get_slice",
     "dask_set_slice",
     "dask_zoom",
+    "get_masked_pipe",
     "get_pipe",
     "init_empty_pyramid",
     "numpy_get_slice",
     "numpy_set_slice",
     "numpy_zoom",
     "on_disk_zoom",
+    "roi_to_slice_kwargs",
+    "set_masked_pipe",
     "set_pipe",
     "transform_dask_array",
     "transform_list",

{ngio-0.2.0a3 → ngio-0.2.0b1}/src/ngio/common/_array_pipe.py

@@ -158,3 +158,109 @@ def set_pipe(
         )
     else:
         raise NgioValueError("Unknown patch type, expected numpy, dask or delayed.")
+
+
+def _mask_pipe_common(
+    array: zarr.Array,
+    label_array: zarr.Array,
+    label: int,
+    *,
+    dimensions_array: Dimensions,
+    dimensions_label: Dimensions,
+    axes_order: Collection[str] | None = None,
+    mode: Literal["numpy", "dask", "delayed"] = "numpy",
+    **slice_kwargs: slice | int | Iterable[int],
+):
+    array_patch = get_pipe(
+        array,
+        dimensions=dimensions_array,
+        axes_order=axes_order,
+        mode=mode,
+        **slice_kwargs,
+    )
+
+    if "c" in slice_kwargs.keys():
+        # This makes the strong assumption that the
+        # user is passing the channel axis as "c"
+        # This will fail if the channel axis is queried
+        # with a different on-disk name
+        slice_kwargs.pop("c")
+
+    label_patch = get_pipe(
+        label_array,
+        dimensions=dimensions_label,
+        axes_order=axes_order,
+        mode=mode,
+        **slice_kwargs,
+    )
+
+    if isinstance(array_patch, np.ndarray):
+        label_patch = np.broadcast_to(label_patch, array_patch.shape)
+    elif isinstance(array_patch, dask.array.Array):
+        label_patch = dask.array.broadcast_to(label_patch, array_patch.shape)
+    else:
+        raise NgioValueError(f"Mode {mode} not yet supported for masked array.")
+
+    mask = label_patch == label
+    return array_patch, mask
+
+
+def get_masked_pipe(
+    array: zarr.Array,
+    label_array: zarr.Array,
+    label: int,
+    *,
+    dimensions_array: Dimensions,
+    dimensions_label: Dimensions,
+    axes_order: Collection[str] | None = None,
+    mode: Literal["numpy", "dask", "delayed"] = "numpy",
+    **slice_kwargs: slice | int | Iterable[int],
+):
+    array_patch, mask = _mask_pipe_common(
+        array=array,
+        label_array=label_array,
+        label=label,
+        dimensions_array=dimensions_array,
+        dimensions_label=dimensions_label,
+        axes_order=axes_order,
+        mode=mode,
+        **slice_kwargs,
+    )
+    array_patch[~mask] = 0
+    return array_patch
+
+
+def set_masked_pipe(
+    array: zarr.Array,
+    label_array: zarr.Array,
+    label: int,
+    patch: ArrayLike,
+    *,
+    dimensions_array: Dimensions,
+    dimensions_label: Dimensions,
+    axes_order: Collection[str] | None = None,
+    **slice_kwargs: slice | int | Iterable[int],
+):
+    if isinstance(patch, dask.array.Array):
+        mode = "dask"
+    elif isinstance(patch, np.ndarray):
+        mode = "numpy"
+    else:
+        raise NgioValueError(
+            "Mode not yet supported for masked array. Expected a numpy or dask array."
+        )
+
+    array_patch, mask = _mask_pipe_common(
+        array=array,
+        label_array=label_array,
+        label=label,
+        dimensions_array=dimensions_array,
+        dimensions_label=dimensions_label,
+        axes_order=axes_order,
+        mode=mode,
+        **slice_kwargs,
+    )
+    patch = np.where(mask, patch, array_patch)
+    set_pipe(
+        array, patch, dimensions=dimensions_array, axes_order=axes_order, **slice_kwargs
+    )

{ngio-0.2.0a3 → ngio-0.2.0b1}/src/ngio/common/_axes_transforms.py

@@ -9,6 +9,7 @@ from ngio.ome_zarr_meta.ngio_specs._axes import (
     AxesTransformation,
     AxesTranspose,
 )
+from ngio.utils import NgioValueError
 
 T = TypeVar("T")
 
@@ -44,7 +45,7 @@ def transform_numpy_array(
         elif isinstance(operation, AxesSqueeze):
             array = np.squeeze(array, axis=operation.axes)
         else:
-            raise ValueError(f"Unknown operation {operation}")
+            raise NgioValueError(f"Unknown operation {operation}")
     return array
 
 
@@ -59,5 +60,5 @@ def transform_dask_array(
         elif isinstance(operation, AxesSqueeze):
             array = da.squeeze(array, axis=operation.axes)
         else:
-            raise ValueError(f"Unknown operation {operation}")
+            raise NgioValueError(f"Unknown operation {operation}")
     return array

{ngio-0.2.0a3 → ngio-0.2.0b1}/src/ngio/common/_dimensions.py

@@ -57,6 +57,13 @@ class Dimensions:
             return 1
         return self._shape[index]
 
+    def has_axis(self, axis_name: str) -> bool:
+        """Return whether the axis exists."""
+        index = self._axes_mapper.get_axis(axis_name)
+        if index is None:
+            return False
+        return True
+
     def get_shape(self, axes_order: Collection[str]) -> tuple[int, ...]:
         """Return the shape in the given axes order."""
         transforms = self._axes_mapper.to_order(axes_order)

ngio-0.2.0b1/src/ngio/common/_masking_roi.py

@@ -0,0 +1,158 @@
+"""Utilities to build masking regions of interest (ROIs)."""
+
+import itertools
+
+import dask
+import dask.array as da
+import dask.delayed
+import numpy as np
+import scipy.ndimage as ndi
+
+from ngio.common._roi import RasterCooROI, WorldCooROI
+from ngio.ome_zarr_meta import PixelSize
+from ngio.utils import NgioValueError
+
+
+def _compute_offsets(chunks):
+    """Given a chunks tuple, compute cumulative offsets for each axis.
+
+    Returns a list where each element is a list of offsets for that dimension.
+    """
+    offsets = []
+    for dim_chunks in chunks:
+        dim_offsets = [0]
+        for size in dim_chunks:
+            dim_offsets.append(dim_offsets[-1] + size)
+        offsets.append(dim_offsets)
+    return offsets
+
+
+def _adjust_slices(slices, offset):
+    """Adjust slices to global coordinates using the provided offset."""
+    adjusted_slices = {}
+    for label, s in slices.items():
+        adjusted = tuple(
+            slice(s_dim.start + off, s_dim.stop + off)
+            for s_dim, off in zip(s, offset, strict=True)
+        )
+        adjusted_slices[label] = adjusted
+    return adjusted_slices
+
+
+@dask.delayed
+def _process_chunk(chunk, offset):
+    """Process a single chunk.
+
+    run ndi.find_objects and adjust the slices
+    to global coordinates using the provided offset.
+    """
+    local_slices = compute_slices(chunk)
+    local_slices = _adjust_slices(local_slices, offset)
+    return local_slices
+
+
+def _merge_slices(
+    slice1: tuple[slice, ...], slice2: tuple[slice, ...]
+) -> tuple[slice, ...]:
+    """Merge two slices."""
+    merged = []
+    for s1, s2 in zip(slice1, slice2, strict=True):
+        start = min(s1.start, s2.start)
+        stop = max(s1.stop, s2.stop)
+        merged.append(slice(start, stop))
+    return tuple(merged)
+
+
+@dask.delayed
+def _collect_slices(
+    local_slices: list[dict[int, tuple[slice, ...]]],
+) -> dict[int, tuple[slice]]:
+    """Collect the slices from the delayed results."""
+    global_slices = {}
+    for result in local_slices:
+        for label, s in result.items():
+            if label in global_slices:
+                global_slices[label] = _merge_slices(global_slices[label], s)
+            else:
+                global_slices[label] = s
+    return global_slices
+
+
+def compute_slices(segmentation: np.ndarray) -> dict[int, tuple[slice, ...]]:
+    """Compute slices for each label in a segmentation.
+
+    Args:
+        segmentation (ndarray): The segmentation array.
+
+    Returns:
+        dict[int, tuple[slice]]: A dictionary with the label as key
+            and the slice as value.
+    """
+    slices = ndi.find_objects(segmentation)
+    slices_dict = {}
+    for label, s in enumerate(slices, start=1):
+        if s is None:
+            continue
+        else:
+            slices_dict[label] = s
+    return slices_dict
+
+
+def lazy_compute_slices(segmentation: da.Array) -> dict[int, tuple[slice, ...]]:
+    """Compute slices for each label in a segmentation."""
+    global_offsets = _compute_offsets(segmentation.chunks)
+    delayed_chunks = segmentation.to_delayed()
+
+    grid_shape = tuple(len(c) for c in segmentation.chunks)
+
+    grid_indices = list(itertools.product(*[range(n) for n in grid_shape]))
+    delayed_results = []
+    for idx, chunk in zip(grid_indices, np.ravel(delayed_chunks), strict=True):
+        offset = tuple(global_offsets[dim][idx[dim]] for dim in range(len(idx)))
+        delayed_result = _process_chunk(chunk, offset)
+        delayed_results.append(delayed_result)
+
+    return _collect_slices(delayed_results).compute()
+
+
+def compute_masking_roi(
+    segmentation: np.ndarray | da.Array, pixel_size: PixelSize
+) -> list[WorldCooROI]:
+    """Compute a ROIs for each label in a segmentation.
+
+    This function expects a 2D or 3D segmentation array.
+    And this function expects the axes order to be 'zyx' or 'yx'.
+    Other axes orders are not supported.
+
+    """
+    if segmentation.ndim not in [2, 3]:
+        raise NgioValueError("Only 2D and 3D segmentations are supported.")
+
+    if isinstance(segmentation, da.Array):
+        slices = lazy_compute_slices(segmentation)
+    else:
+        slices = compute_slices(segmentation)
+
+    rois = []
+    for label, slice_ in slices.items():
+        if len(slice_) == 2:
+            min_z, min_y, min_x = 0, slice_[0].start, slice_[1].start
+            max_z, max_y, max_x = 1, slice_[0].stop, slice_[1].stop
+        elif len(slice_) == 3:
+            min_z, min_y, min_x = slice_[0].start, slice_[1].start, slice_[2].start
+            max_z, max_y, max_x = slice_[0].stop, slice_[1].stop, slice_[2].stop
+        else:
+            raise ValueError("Invalid slice length.")
+        roi = RasterCooROI(
+            name=str(label),
+            x_length=max_x - min_x,
+            y_length=max_y - min_y,
+            z_length=max_z - min_z,
+            x=min_x,
+            y=min_y,
+            z=min_z,
+        )
+
+        roi = roi.to_world_coo_roi(pixel_size)
+        rois.append(roi)
+    return rois

{ngio-0.2.0a3 → ngio-0.2.0b1}/src/ngio/common/_pyramid.py

@@ -7,7 +7,12 @@ import numpy as np
 import zarr
 
 from ngio.common._zoom import _zoom_inputs_check, dask_zoom, numpy_zoom
-from ngio.utils import AccessModeLiteral, StoreOrGroup, open_group_wrapper
+from ngio.utils import (
+    AccessModeLiteral,
+    NgioValueError,
+    StoreOrGroup,
+    open_group_wrapper,
+)
 
 
 def _on_disk_numpy_zoom(
@@ -64,7 +69,7 @@ def _on_disk_coarsen(
         elif _order == 0:
             aggregation_function = np.max
         else:
-            raise ValueError(
+            raise NgioValueError(
                 f"Aggregation function must be provided for order {_order}"
             )
 
@@ -77,7 +82,7 @@ def _on_disk_coarsen(
         if factor.is_integer():
             coarsening_setup[i] = int(factor)
         else:
-            raise ValueError(
+            raise NgioValueError(
                 f"Coarsening factor must be an integer, got {factor} on axis {i}"
             )
 
@@ -103,13 +108,13 @@ def on_disk_zoom(
         mode (Literal["dask", "numpy", "coarsen"]): The mode to use. Defaults to "dask".
     """
     if not isinstance(source, zarr.Array):
-        raise ValueError("source must be a zarr array")
+        raise NgioValueError("source must be a zarr array")
 
     if not isinstance(target, zarr.Array):
-        raise ValueError("target must be a zarr array")
+        raise NgioValueError("target must be a zarr array")
 
     if source.dtype != target.dtype:
-        raise ValueError("source and target must have the same dtype")
+        raise NgioValueError("source and target must have the same dtype")
 
     match mode:
         case "numpy":
@@ -122,7 +127,7 @@ def on_disk_zoom(
                 target,
             )
         case _:
-            raise ValueError("mode must be either 'dask', 'numpy' or 'coarsen'")
+            raise NgioValueError("mode must be either 'dask', 'numpy' or 'coarsen'")
 
 
 def _find_closest_arrays(
@@ -181,19 +186,19 @@ def init_empty_pyramid(
 ) -> None:
     # Return the an Image object
     if chunks is not None and len(chunks) != len(ref_shape):
-        raise ValueError(
+        raise NgioValueError(
             "The shape and chunks must have the same number of dimensions."
         )
 
     if len(ref_shape) != len(scaling_factors):
-        raise ValueError(
+        raise NgioValueError(
             "The shape and scaling factor must have the same number of dimensions."
         )
 
     root_group, _ = open_group_wrapper(store, mode=mode)
     for path in paths:
         if any(s < 1 for s in ref_shape):
-            raise ValueError(
+            raise NgioValueError(
                 "Level shape must be at least 1 on all dimensions. "
                 f"Calculated shape: {ref_shape} at level {path}."
             )
@@ -218,6 +223,6 @@ def init_empty_pyramid(
         if chunks is None:
             chunks = new_arr.chunks
             if chunks is None:
-                raise ValueError("Something went wrong with the chunks")
+                raise NgioValueError("Something went wrong with the chunks")
         chunks = [min(c, s) for c, s in zip(chunks, ref_shape, strict=True)]
     return None