ngio 0.1.4__tar.gz → 0.1.6__tar.gz

{ngio-0.1.4 → ngio-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ngio
-Version: 0.1.4
+Version: 0.1.6
 Summary: Next Generation file format IO
 Project-URL: homepage, https://github.com/lorenzocerrone/ngio
 Project-URL: repository, https://github.com/lorenzocerrone/ngio
@@ -13,6 +13,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Requires-Dist: aiohttp

{ngio-0.1.4 → ngio-0.1.6}/docs/notebooks/basic_usage.ipynb

@@ -194,9 +194,9 @@
    "outputs": [],
    "source": [
     "print(\"List of Tables: \", ngff_image.tables.list())\n",
-    "print(\" - Feature tables: \", ngff_image.tables.list(table_type='feature_table'))\n",
-    "print(\" - Roi tables: \", ngff_image.tables.list(table_type='roi_table'))\n",
-    "print(\" - Masking Roi tables: \", ngff_image.tables.list(table_type='masking_roi_table'))"
+    "print(\" - Feature tables: \", ngff_image.tables.list(table_type=\"feature_table\"))\n",
+    "print(\" - Roi tables: \", ngff_image.tables.list(table_type=\"roi_table\"))\n",
+    "print(\" - Masking Roi tables: \", ngff_image.tables.list(table_type=\"masking_roi_table\"))"
    ]
   },
   {
@@ -267,7 +267,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "new_ngff_image = ngff_image.derive_new_image(\"../../data/new_ome.zarr\", name=\"new_image\")\n",
+    "new_ngff_image = ngff_image.derive_new_image(\n",
+    "    \"../../data/new_ome.zarr\", name=\"new_image\"\n",
+    ")\n",
     "print(new_ngff_image)"
    ]
   },

{ngio-0.1.4 → ngio-0.1.6}/docs/notebooks/image.ipynb

@@ -19,7 +19,9 @@
     "\n",
     "from ngio.core.ngff_image import NgffImage\n",
     "\n",
-    "ngff_image = NgffImage(\"../../data/20200812-CardiomyocyteDifferentiation14-Cycle1_mip.zarr/B/03/0\")"
+    "ngff_image = NgffImage(\n",
+    "    \"../../data/20200812-CardiomyocyteDifferentiation14-Cycle1_mip.zarr/B/03/0\"\n",
+    ")"
    ]
   },
   {
@@ -88,7 +90,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "image_numpy = image.get_array(c=0, x=slice(0, 250), y=slice(0, 250), preserve_dimensions=False, mode=\"numpy\")\n",
+    "image_numpy = image.get_array(\n",
+    "    c=0, x=slice(0, 250), y=slice(0, 250), preserve_dimensions=False, mode=\"numpy\"\n",
+    ")\n",
     "\n",
     "print(f\"{image_numpy.shape=}\")"
    ]
@@ -112,7 +116,9 @@
     "roi = roi_table.get_roi(\"FOV_1\")\n",
     "print(f\"{roi=}\")\n",
     "\n",
-    "image_roi_1 = image.get_array_from_roi(roi=roi, c=0, preserve_dimensions=True, mode=\"dask\")\n",
+    "image_roi_1 = image.get_array_from_roi(\n",
+    "    roi=roi, c=0, preserve_dimensions=True, mode=\"dask\"\n",
+    ")\n",
     "image_roi_1"
    ]
   },
@@ -277,29 +283,35 @@
     "print(f\"List of feature table: {ngff_image.tables.list(table_type='feature_table')}\")\n",
     "\n",
     "\n",
-    "nuclei = ngff_image.labels.get_label('nuclei')\n",
+    "nuclei = ngff_image.labels.get_label(\"nuclei\")\n",
     "\n",
     "# Create a table with random features for each nuclei in each ROI\n",
     "list_of_records = []\n",
     "for roi in roi_table.rois:\n",
-    "    nuclei_in_roi = nuclei.get_array_from_roi(roi, mode='numpy')\n",
+    "    nuclei_in_roi = nuclei.get_array_from_roi(roi, mode=\"numpy\")\n",
     "    for nuclei_id in np.unique(nuclei_in_roi)[1:]:\n",
     "        list_of_records.append(\n",
-    "            {\"label\": nuclei_id,\n",
-    "             \"feat1\": np.random.rand(),\n",
-    "             \"feat2\": np.random.rand(),\n",
-    "         \"ROI\": roi.infos.get(\"FieldIndex\")}\n",
-    "    )\n",
+    "            {\n",
+    "                \"label\": nuclei_id,\n",
+    "                \"feat1\": np.random.rand(),\n",
+    "                \"feat2\": np.random.rand(),\n",
+    "                \"ROI\": roi.infos.get(\"FieldIndex\"),\n",
+    "            }\n",
+    "        )\n",
     "\n",
     "feat_df = pd.DataFrame.from_records(list_of_records)\n",
     "\n",
     "# Create a new feature table\n",
-    "feat_table = ngff_image.tables.new(name='new_feature_table',\n",
-    "                     label_image='../nuclei',\n",
-    "                     table_type='feature_table',\n",
-    "                     overwrite=True)\n",
-    "\n",
-    "print(f\"New list of feature table: {ngff_image.tables.list(table_type='feature_table')}\")\n",
+    "feat_table = ngff_image.tables.new(\n",
+    "    name=\"new_feature_table\",\n",
+    "    label_image=\"../nuclei\",\n",
+    "    table_type=\"feature_table\",\n",
+    "    overwrite=True,\n",
+    ")\n",
+    "\n",
+    "print(\n",
+    "    f\"New list of feature table: {ngff_image.tables.list(table_type='feature_table')}\"\n",
+    ")\n",
     "feat_table.set_table(feat_df)\n",
     "feat_table.consolidate()\n",
     "\n",

{ngio-0.1.4 → ngio-0.1.6}/docs/notebooks/processing.ipynb

@@ -37,7 +37,9 @@
     "\n",
     "from ngio.core import NgffImage\n",
     "\n",
-    "ngff_image = NgffImage(\"../../data/20200812-CardiomyocyteDifferentiation14-Cycle1.zarr/B/03/0\")"
+    "ngff_image = NgffImage(\n",
+    "    \"../../data/20200812-CardiomyocyteDifferentiation14-Cycle1.zarr/B/03/0\"\n",
+    ")"
    ]
   },
   {
@@ -53,9 +55,11 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "mip_ngff = ngff_image.derive_new_image(\"../../data/20200812-CardiomyocyteDifferentiation14-Cycle1.zarr/B/03/0_mip\",\n",
-    "                                       name=\"MIP\",\n",
-    "                                       on_disk_shape=(1, 1, 2160, 5120))"
+    "mip_ngff = ngff_image.derive_new_image(\n",
+    "    \"../../data/20200812-CardiomyocyteDifferentiation14-Cycle1.zarr/B/03/0_mip\",\n",
+    "    name=\"MIP\",\n",
+    "    on_disk_shape=(1, 1, 2160, 5120),\n",
+    ")"
    ]
   },
   {
@@ -93,15 +97,15 @@
     "    patch = source_image.get_array_from_roi(roi)\n",
     "    mip_patch = patch.max(axis=1, keepdims=True)\n",
     "    mip_image.set_array_from_roi(patch=mip_patch, roi=roi)\n",
-    "    \n",
+    "\n",
     "print(\"MIP image saved\")\n",
     "\n",
     "plt.figure(figsize=(5, 5))\n",
     "plt.title(\"Mip\")\n",
     "plt.imshow(mip_image.on_disk_array[0, 0, :, :], cmap=\"gray\")\n",
-    "plt.axis('off')\n",
+    "plt.axis(\"off\")\n",
     "plt.tight_layout()\n",
-    "plt.show()\n"
+    "plt.show()"
    ]
   },
   {
@@ -136,9 +140,9 @@
     "axs[1].set_title(\"After consolidation\")\n",
     "axs[1].imshow(image_after_consolidation, cmap=\"gray\")\n",
     "for ax in axs:\n",
-    "    ax.axis('off')\n",
+    "    ax.axis(\"off\")\n",
     "plt.tight_layout()\n",
-    "plt.show()\n"
+    "plt.show()"
    ]
   },
   {
@@ -162,7 +166,7 @@
     "roi_list = []\n",
     "for roi in roi_table.rois:\n",
     "    print(f\" - Processing ROI {roi.infos.get('field_index')}\")\n",
-    "    roi.z_length = 1 # In the MIP image, the z dimension is 1\n",
+    "    roi.z_length = 1  # In the MIP image, the z dimension is 1\n",
     "    roi_list.append(roi)\n",
     "\n",
     "mip_roi_table.set_rois(roi_list, overwrite=True)\n",
@@ -198,7 +202,7 @@
     "rand_cmap = ListedColormap(rand_cmap)\n",
     "\n",
     "\n",
-    "def otsu_threshold_segmentation(image: np.ndarray, max_label:int) -> np.ndarray:\n",
+    "def otsu_threshold_segmentation(image: np.ndarray, max_label: int) -> np.ndarray:\n",
     "    \"\"\"Simple segmentation using Otsu thresholding.\"\"\"\n",
     "    threshold = threshold_otsu(image)\n",
     "    binary = image > threshold\n",
@@ -271,11 +275,11 @@
     "axs[0].set_title(\"MIP\")\n",
     "axs[0].imshow(source_image.on_disk_array[0, 0], cmap=\"gray\")\n",
     "axs[1].set_title(\"Nuclei segmentation\")\n",
-    "axs[1].imshow(nuclei_image.on_disk_array[0], cmap=rand_cmap, interpolation='nearest')\n",
+    "axs[1].imshow(nuclei_image.on_disk_array[0], cmap=rand_cmap, interpolation=\"nearest\")\n",
     "for ax in axs:\n",
-    "    ax.axis('off')\n",
+    "    ax.axis(\"off\")\n",
     "plt.tight_layout()\n",
-    "plt.show()\n"
+    "plt.show()"
    ]
   },
   {

{ngio-0.1.4 → ngio-0.1.6}/pyproject.toml

@@ -29,6 +29,7 @@ classifiers = [
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Typing :: Typed",
 ]
 # add your package dependencies here
@@ -199,8 +200,6 @@ channels = ["conda-forge"]
 platforms = ["osx-arm64", "linux-64", "win-64"]
 
 [tool.pixi.pypi-dependencies]
-# zarr = { path = "../zarr-python/", editable = true }
-# anndata = { path = "../anndata/", editable = true }
 ngio = { path = ".", editable = true }
 
 [tool.pixi.feature.py310.dependencies]

{ngio-0.1.4 → ngio-0.1.6}/src/ngio/core/ngff_image.py

@@ -152,7 +152,7 @@ class NgffImage:
 
         if meta.omero is None:
             raise NotImplementedError(
-                "OMERO metadata not found. " " Please add OMERO metadata to the image."
+                "OMERO metadata not found.  Please add OMERO metadata to the image."
             )
 
         channel_list = meta.omero.channels
@@ -269,7 +269,7 @@ class NgffImage:
 
         if meta.omero is None:
             raise NotImplementedError(
-                "OMERO metadata not found. " " Please add OMERO metadata to the image."
+                "OMERO metadata not found.  Please add OMERO metadata to the image."
             )
 
         channel_list = meta.omero.channels

{ngio-0.1.4 → ngio-0.1.6}/src/ngio/core/utils.py

@@ -67,17 +67,17 @@ def _build_empty_pyramid(
 
     if chunks is not None and len(on_disk_shape) != len(chunks):
         raise ValueError(
-            "The shape and chunks must have the same number " "of dimensions."
+            "The shape and chunks must have the same number of dimensions."
         )
 
     if len(on_disk_shape) != len(scaling_factor):
         raise ValueError(
-            "The shape and scaling factor must have the same number " "of dimensions."
+            "The shape and scaling factor must have the same number of dimensions."
         )
 
     if len(on_disk_shape) != len(on_disk_axis):
         raise ValueError(
-            "The shape and on-disk axis must have the same number " "of dimensions."
+            "The shape and on-disk axis must have the same number of dimensions."
         )
 
     for dataset in image_meta.datasets:

{ngio-0.1.4 → ngio-0.1.6}/src/ngio/io/_zarr_group_utils.py

@@ -50,8 +50,7 @@ def open_group_wrapper(
     if isinstance(store, zarr.Group):
         _group = _pass_through_group(store, mode=mode, zarr_format=zarr_format)
         ngio_logger.debug(
-            f"Passing through group: {_group}, "
-            f"located in store: {_group.store.path}"
+            f"Passing through group: {_group}, located in store: {_group.store.path}"
         )
         return _group
 

{ngio-0.1.4 → ngio-0.1.6}/src/ngio/ngff_meta/v04/zarr_utils.py

@@ -110,7 +110,13 @@ def vanilla_omero_v04_to_fractal(omero04: Omero04) -> Omero:
     for channel04 in omero04.channels:
         # Convert the window to a dictionary
         label = channel04.label
-        wavelength_id = channel04.extra_fields.get("wavelength_id", label)
+
+        if "wavelength_id" in channel04.extra_fields:
+            # If the wavelength_id is present, pop it from the extra fields
+            # so that it is not added to the channel_visualisation
+            wavelength_id = channel04.extra_fields.pop("wavelength_id")
+        else:
+            wavelength_id = label
 
         if channel04.window is None:
             window04 = Window04(
@@ -161,6 +167,7 @@ def fractal_omero_to_vanilla_v04(omero: Omero) -> Omero04:
             color=channel.channel_visualisation.color,
             active=channel.channel_visualisation.active,
             window=window04,
+            wavelength_id=channel.wavelength_id,
             **channel.channel_visualisation.extra_fields,
         )
         list_channels04.append(channel04)

{ngio-0.1.4 → ngio-0.1.6}/src/ngio/pipes/_zoom_utils.py

@@ -4,7 +4,48 @@ from typing import Literal
 import dask.array as da
 import numpy as np
 import zarr
-from scipy.ndimage import zoom
+from scipy.ndimage import zoom as scipy_zoom
+
+
+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])
+        ]
+    )
+    return x_out.reshape(*rest, *x_out.shape[1:])
+
+
+def fast_zoom(x, zoom, order=1, mode="grid-constant", grid_mode=True, auto_stack=True):
+    """Fast zoom function.
+
+    Scipy zoom function that can handle singleton dimensions
+    but the performance degrades with the number of dimensions.
+
+    This function has two small optimizations:
+     - it removes singleton dimensions before calling zoom
+     - if it detects that the zoom is only on the last two dimensions
+         it stacks the first dimensions to call zoom only on the last two.
+    """
+    mask = np.isclose(x.shape, 1)
+    zoom = np.array(zoom)
+    singletons = tuple(np.where(mask)[0])
+    xs = np.squeeze(x, axis=singletons)
+    new_zoom = zoom[~mask]
+
+    *zoom_rest, zoom_y, zoom_x = new_zoom
+    if auto_stack and np.allclose(zoom_rest, 1):
+        xs = _stacked_zoom(
+            xs, zoom_y, zoom_x, order=order, mode=mode, grid_mode=grid_mode
+        )
+    else:
+        xs = scipy_zoom(xs, new_zoom, order=order, mode=mode, grid_mode=grid_mode)
+    x = np.expand_dims(xs, axis=singletons)
+    return x
 
 
 def _zoom_inputs_check(
@@ -73,7 +114,7 @@ def _dask_zoom(
     block_output_shape = tuple(np.ceil(better_source_chunks * _scale).astype(int))
 
     zoom_wrapper = partial(
-        zoom, zoom=_scale, order=order, mode="grid-constant", grid_mode=True
+        fast_zoom, zoom=_scale, order=order, mode="grid-constant", grid_mode=True
     )
 
     out_array = da.map_blocks(
@@ -109,7 +150,7 @@ def _numpy_zoom(
         source_array=source_array, scale=scale, target_shape=target_shape
     )
 
-    out_array = zoom(
+    out_array = fast_zoom(
         source_array, zoom=_scale, order=order, mode="grid-constant", grid_mode=True
     )
     assert isinstance(out_array, np.ndarray)
@@ -149,6 +190,7 @@ def on_disk_zoom(
     target_array = _dask_zoom(source_array, target_shape=target.shape, order=order)
 
     target_array = target_array.rechunk(target.chunks)
+    target_array.compute_chunk_sizes()
     target_array.to_zarr(target)
 
 
@@ -180,7 +222,7 @@ def on_disk_coarsen(
             coarsening_setup[i] = int(factor)
         else:
             raise ValueError(
-                "Coarsening factor must be an integer, got " f"{factor} on axis {i}"
+                f"Coarsening factor must be an integer, got {factor} on axis {i}"
             )
 
     out_target = da.coarsen(

{ngio-0.1.4 → ngio-0.1.6}/tests/core/test_ngff_image.py

@@ -1,5 +1,7 @@
 from pathlib import Path
 
+import pytest
+
 
 class TestNgffImage:
     def test_ngff_image(self, ome_zarr_image_v04_path: Path) -> None:
@@ -57,3 +59,29 @@ class TestNgffImage:
 
         assert ngff_image.tables.list() == new_ngff_image.tables.list()
         assert ngff_image.labels.list() == new_ngff_image.labels.list()
+
+    @pytest.mark.parametrize(
+        "shape, axis, chunks",
+        [
+            ((1, 4, 1, 1945, 1945), ("t", "c", "z", "y", "x"), (1, 1, 1, 1000, 1000)),
+            ((1, 4, 1, 1945, 1945), ("t", "c", "z", "y", "x"), None),
+            ((1, 4, 1, 1945, 2000), ("t", "c", "z", "y", "x"), None),
+            ((1, 1, 1000, 1000), ("c", "z", "y", "x"), (1, 1, 1000, 1000)),
+            ((1, 1, 1000, 1000), ("c", "z", "y", "x"), None),
+            ((739, 1033), ("y", "x"), (53, 173)),
+        ],
+    )
+    def test_ngff_image_consolidate(self, tmp_path, shape, axis, chunks) -> None:
+        from ngio import NgffImage
+        from ngio.core.utils import create_empty_ome_zarr_image
+
+        ome_zarr = tmp_path / "test_consolidate.zarr"
+        create_empty_ome_zarr_image(
+            ome_zarr,
+            on_disk_shape=shape,
+            on_disk_axis=axis,
+            chunks=chunks,
+        )
+
+        image = NgffImage(ome_zarr).get_image()
+        image.consolidate()

{ngio-0.1.4 → ngio-0.1.6}/tests/ngff_meta/test_utils.py

@@ -22,6 +22,7 @@ class TestUtils:
         )
 
         assert meta.channel_labels == ["DAPI", "nanog", "Lamin B1"]
+        assert meta.channel_wavelength_ids == ["A01_C01", "A02_C02", "A03_C03"]
         np.testing.assert_array_equal(meta.pixel_size(idx=0).zyx, [1.0, 1.0, 1.0])
         np.testing.assert_array_equal(meta.scale(idx=0), [1.0, 1.0, 1.0, 1.0, 1.0])
         np.testing.assert_array_equal(meta.pixel_size(path="2").zyx, [1.0, 4.0, 4.0])

{ngio-0.1.4 → ngio-0.1.6}/tests/ngff_meta/test_v04.py

@@ -4,6 +4,36 @@ import pytest
 
 
 class TestOMEZarrHandlerV04:
+    def test_create_image_meta(self, tmp_path):
+        from ngio.ngff_meta import create_image_metadata
+        from ngio.ngff_meta.v04.zarr_utils import (
+            fractal_ngff_image_meta_to_vanilla_v04,
+            vanilla_ngff_image_meta_v04_to_fractal,
+        )
+
+        meta = create_image_metadata(
+            on_disk_axis=("t", "c", "z", "y", "x"),
+            pixel_sizes=None,
+            xy_scaling_factor=2.0,
+            z_scaling_factor=1.0,
+            time_spacing=1.0,
+            time_units="s",
+            levels=5,
+            name="test",
+            channel_labels=["DAPI", "nanog", "Lamin B1"],
+            channel_wavelengths=["A01_C01", "A02_C02", "A03_C03"],
+            channel_visualization=None,
+            omero_kwargs=None,
+            version="0.4",
+        )
+
+        meta04 = fractal_ngff_image_meta_to_vanilla_v04(meta)
+        meta2 = vanilla_ngff_image_meta_v04_to_fractal(meta04)
+        assert meta.channel_labels == meta2.channel_labels
+        assert meta.channel_wavelength_ids == meta2.channel_wavelength_ids
+        assert meta.axes_names == meta2.axes_names
+        assert meta.scale(path="2") == meta2.scale(path="2")
+
     def test_basic_workflow(self, ome_zarr_image_v04_path):
         from ngio.ngff_meta import get_ngff_image_meta_handler
         from ngio.ngff_meta.v04.zarr_utils import NgffImageMeta04

{ngio-0.1.4 → ngio-0.1.6}/tests/pipes/test_zoom.py

@@ -75,3 +75,28 @@ class TestZoom:
         source, target = zarr_zoom_2d_array_not_int
         with pytest.raises(ValueError):
             self._test_coarsen(source, target)
+
+    @pytest.mark.parametrize(
+        "shape, zoom_factor",
+        [
+            ((10, 1, 1, 30, 30), (1, 1, 1, 0.5, 0.5)),  # with time
+            ((1, 1, 1, 300, 300), (1, 1, 1, 0.5, 0.5)),  # with singletons
+            ((1, 4, 10, 30, 30), (1, 1, 1, 0.5, 0.5)),  # with channels and z
+            ((1, 4, 10, 30, 30), (1, 1, 0.3234, 0.5, 0.5)),  # with channels and z
+            ((5, 4, 10, 30, 30), (0.5, 1, 0.3234, 0.5, 0.5)),  # with channels and z
+            ((1, 4, 10, 30, 30), (1, 1, 1, 0.5323, 0.5231)),  # with channels and z
+            ((4, 300, 300), (1, 0.5, 0.5)),  # without time and channels
+            ((3000, 3000), (0.5, 0.5)),  # without time and channels
+        ],
+    )
+    def test_fast_zoom(self, shape, zoom_factor) -> None:
+        from scipy.ndimage import zoom
+
+        from ngio.pipes._zoom_utils import fast_zoom
+
+        x = np.random.rand(*shape)
+        out1 = fast_zoom(
+            x, zoom=zoom_factor, order=1, mode="grid-constant", grid_mode=True
+        )
+        out2 = zoom(x, zoom=zoom_factor, order=1, mode="grid-constant", grid_mode=True)
+        np.testing.assert_allclose(out1, out2)