patchworks 2.6.7__tar.gz → 2.6.9__tar.gz

{patchworks-2.6.7 → patchworks-2.6.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: patchworks
-Version: 2.6.7
+Version: 2.6.9
 Summary: Tiled processing of arbitrarily large images with globally consistent labels
 Project-URL: Homepage, https://github.com/imcf/patchworks
 Project-URL: Issues, https://github.com/imcf/patchworks/issues

{patchworks-2.6.7 → patchworks-2.6.9}/docs/guide/ome_zarr_napari.md

@@ -229,6 +229,20 @@ just one channel instead: `view_in_napari("scan.zarr", channel=0)`.
     napari ships in `patchworks[all]`, or install just it with
     `pip install "patchworks[napari]"`.
 
+!!! tip "From the cluster workflow"
+    `workflow/pixi.toml` has a separate `viewer` environment (napari's Qt/GUI
+    dependencies are kept out of the default headless workflow env on
+    purpose):
+
+    ```bash
+    pixi install -e viewer
+    pixi run -e viewer napari /path/to/work_dir/image.zarr
+    ```
+
+    This wraps `view_in_napari` with its `labels=` argument left at the
+    default, so every label group in the store loads automatically — needs a
+    display (`ssh -X`, or a remote-desktop/VNC session).
+
 !!! tip "Measuring all the objects"
     Once labels are loaded, use
     [napari-chunked-regionprops](https://github.com/imcf/napari-chunked-regionprops)'s

{patchworks-2.6.7 → patchworks-2.6.9}/src/patchworks/__init__.py

@@ -55,6 +55,11 @@ from ._occupancy import (
 from ._postprocess import dilate_labels
 from ._relabel import relabel_sequential_array, relabel_sequential_zarr
 from ._relations import label_relations
+from ._volume_filter import (
+    filter_labels_by_size,
+    min_voxels_for_volume,
+    voxel_volume,
+)
 
 try:
     __version__ = _pkg_version("patchworks")
@@ -85,4 +90,7 @@ __all__ = [
     "create_stage",
     "stage_tile",
     "dilate_labels",
+    "filter_labels_by_size",
+    "min_voxels_for_volume",
+    "voxel_volume",
 ]

patchworks-2.6.9/src/patchworks/_volume_filter.py

@@ -0,0 +1,198 @@
+"""Drop label objects below a volume threshold, in place, after merge.
+
+Meant to run once, globally, on the fully merged label array -- not per
+tile, where an object's true size isn't known yet (a tile only sees
+whatever fragment of it landed inside that tile's bounds, so a per-tile
+filter would clip or drop objects that are only small *within one tile*).
+
+Two-pass streaming algorithm, mirroring :func:`patchworks.relabel_sequential_zarr`
+-- safe for arrays far larger than RAM. Pass 1 does a chunk-wise
+unique+count to get every label's voxel count (bounded memory: a Python
+dict keyed by label id, not the voxels themselves). Pass 2 builds a LUT
+that zeroes labels under the threshold -- optionally renumbering the
+survivors to a contiguous range in the same pass -- and applies it chunk by
+chunk, writing back into the same store.
+"""
+
+from __future__ import annotations
+
+import logging
+import math
+from itertools import product as _iproduct
+
+import numpy as np
+import zarr
+
+logger = logging.getLogger(__name__)
+
+_LUT_WARN_THRESHOLD = 100_000_000  # warn when max_label > 100 M (LUT > 800 MB)
+
+
+def voxel_volume(voxel_size: "dict[str, float]") -> float:
+    """Physical volume of one voxel, from a per-axis calibration.
+
+    Axes missing from *voxel_size* are treated as 1.0 -- e.g. a 2-D
+    calibration with no ``z`` gives an area, not a bogus volume shrunk by a
+    fake axis. Units follow whatever *voxel_size* is in (micrometers for
+    :func:`patchworks.plugins.ome_zarr.read_pixel_size`).
+
+    Parameters
+    ----------
+    voxel_size : dict
+        Per-axis physical size, e.g. ``{"z": .., "y": .., "x": ..}``.
+
+    Returns
+    -------
+    float
+        Product of the given axis sizes.
+
+    Examples
+    --------
+    >>> voxel_volume({"z": 0.24, "y": 0.10833, "x": 0.10833})
+    0.0028164933359999997
+    """
+    vol = 1.0
+    for size in voxel_size.values():
+        vol *= size
+    return vol
+
+
+def min_voxels_for_volume(
+    min_volume: float, voxel_size: "dict[str, float]"
+) -> int:
+    """Convert a physical volume threshold to a voxel count.
+
+    Rounds up: an object must reach *min_volume* to survive, so a partial
+    voxel's worth of extra volume should not tip it over the line.
+
+    Parameters
+    ----------
+    min_volume : float
+        Minimum object volume to keep, in the same physical units as
+        *voxel_size* (micrometers³ for an NGFF calibration).
+    voxel_size : dict
+        Per-axis physical size -- see :func:`voxel_volume`.
+
+    Returns
+    -------
+    int
+        Minimum voxel count for an object to survive filtering.
+
+    Examples
+    --------
+    >>> min_voxels_for_volume(5.0, {"z": 0.24, "y": 0.10833, "x": 0.10833})
+    1776
+    """
+    return math.ceil(min_volume / voxel_volume(voxel_size))
+
+
+def _chunk_slices(shape, chunks):
+    """Every zarr chunk's index expression, in all dimensions.
+
+    Iterating actual chunk boundaries (rather than z-slabs) keeps each read
+    bounded to one chunk's worth of memory, whatever the array's shape.
+    """
+    n_per_dim = [(s + c - 1) // c for s, c in zip(shape, chunks)]
+    return [
+        tuple(
+            slice(i * c, min((i + 1) * c, s))
+            for i, c, s in zip(idx, chunks, shape)
+        )
+        for idx in _iproduct(*[range(n) for n in n_per_dim])
+    ]
+
+
+def filter_labels_by_size(
+    store_path: str,
+    component: str,
+    min_voxels: int,
+    *,
+    relabel: bool = True,
+) -> "tuple[int, int]":
+    """Drop label objects smaller than *min_voxels*, in place.
+
+    Two-pass streaming scan (see module docstring) -- the array never has
+    to fit in RAM.
+
+    Parameters
+    ----------
+    store_path : str
+        Path to the zarr store containing the label array.
+    component : str
+        Array name inside the store to filter in place.
+    min_voxels : int
+        Objects with fewer voxels than this are zeroed (dropped). Use
+        :func:`min_voxels_for_volume` to derive this from a physical
+        volume and calibration.
+    relabel : bool, optional
+        Renumber the surviving objects to a contiguous ``1..N`` range in
+        the same LUT that drops the small ones (default ``True``) --
+        otherwise the removed ids leave permanent gaps and survivors keep
+        their original ids.
+
+    Returns
+    -------
+    tuple of int
+        ``(n_kept, n_removed)``.
+
+    Examples
+    --------
+    >>> import zarr
+    >>> root = zarr.open_group("labels.zarr", mode="w")  # doctest: +SKIP
+    >>> root.create_array(
+    ...     "labels", shape=(4, 4), chunks=(4, 4), dtype="int32"
+    ... )[:] = [
+    ...     [0, 1, 1, 0],
+    ...     [0, 1, 1, 0],
+    ...     [0, 0, 0, 2],
+    ...     [0, 0, 0, 0],
+    ... ]  # doctest: +SKIP
+    >>> filter_labels_by_size("labels.zarr", "labels", min_voxels=2)  # doctest: +SKIP
+    (1, 1)
+    """
+    root = zarr.open_group(store_path, mode="r+")
+    z = root[component]
+    slices = _chunk_slices(z.shape, z.chunks)
+
+    counts: "dict[int, int]" = {}
+    for sl in slices:
+        ids, n = np.unique(np.asarray(z[sl]), return_counts=True)
+        for label_id, count in zip(ids.tolist(), n.tolist()):
+            if label_id == 0:
+                continue
+            counts[label_id] = counts.get(label_id, 0) + count
+
+    kept = sorted(i for i, c in counts.items() if c >= min_voxels)
+    n_kept = len(kept)
+    n_removed = len(counts) - n_kept
+
+    # Sized to the largest id *seen*, not just the largest surviving one --
+    # a removed object's id can still exceed every kept id and must stay
+    # in bounds so the LUT gather below maps it to 0 rather than indexing
+    # past the end.
+    max_label = max(counts) if counts else 0
+    if max_label > _LUT_WARN_THRESHOLD:
+        logger.warning(
+            "filter_labels_by_size: max_label=%d -> LUT size ~%.0f MB.",
+            max_label,
+            max_label * 8 / 1024**2,
+        )
+    lut = np.zeros(max_label + 1, dtype=np.int64)
+    if kept:
+        lut[kept] = np.arange(1, n_kept + 1) if relabel else np.asarray(kept)
+
+    max_out = n_kept if relabel else max_label
+    out_dtype = np.uint16 if max_out < np.iinfo(np.uint16).max else np.uint32
+    for sl in slices:
+        block = np.asarray(z[sl])
+        z[sl] = lut[block].astype(out_dtype)
+
+    logger.info(
+        "filter_labels_by_size: dropped %d/%d object(s) under %d voxels, "
+        "%d remain",
+        n_removed,
+        len(counts),
+        min_voxels,
+        n_kept,
+    )
+    return n_kept, n_removed

{patchworks-2.6.7 → patchworks-2.6.9}/src/patchworks/plugins/cellpose.py

@@ -75,6 +75,40 @@ def _require_cellpose():
         )
 
 
+def cellpose_anisotropy(voxel_size: dict[str, float]) -> float | None:
+    """Cellpose's ``anisotropy`` (z voxel size / lateral voxel size) from a calibration.
+
+    ``do_3D`` assumes isotropic voxels unless told otherwise: without this,
+    Cellpose builds its 3-D flow-field consensus across z-planes it thinks
+    are spaced the same as the xy pixels, which for real data rarely holds
+    and fragments or distorts objects across z. Getting this wrong does not
+    fail loudly -- it just produces a subtly (or not so subtly) wrong
+    segmentation, which is why deriving it beats retyping it.
+
+    Parameters
+    ----------
+    voxel_size : dict
+        Image calibration, e.g. from
+        :func:`patchworks.plugins.ome_zarr.read_pixel_size`. Needs ``z`` and
+        ``x`` (or ``y``) for the lateral size.
+
+    Returns
+    -------
+    float or None
+        ``z / lateral``, or None if the calibration lacks what is needed.
+
+    Examples
+    --------
+    >>> cellpose_anisotropy({"z": 0.24, "y": 0.10833, "x": 0.10833})
+    2.215452783162559
+    """
+    lateral = voxel_size.get("x") or voxel_size.get("y")
+    z = voxel_size.get("z")
+    if not lateral or not z:
+        return None
+    return z / lateral
+
+
 def cellpose_fn(
     model: str = "cyto3",
     *,
@@ -83,6 +117,7 @@ def cellpose_fn(
     do_3D: bool = False,
     channels: list[int] | None = None,
     channel_axis: int | None = None,
+    voxel_size: dict[str, float] | None = None,
     **cellpose_kwargs: Any,
 ) -> Callable[[np.ndarray], np.ndarray]:
     """Return a ready-to-use Cellpose function for ``tile_process``.
@@ -107,6 +142,15 @@ def cellpose_fn(
     channel_axis:
         *Cellpose 4 only.* Index of the channel axis in the input array.
         ``None`` → greyscale input.
+    voxel_size:
+        Physical voxel size as ``{"z": .., "y": .., "x": ..}``. When
+        ``do_3D`` is set and ``anisotropy`` is not already in
+        ``cellpose_kwargs``, it is derived from this via
+        :func:`cellpose_anisotropy` -- an explicit ``anisotropy=`` always
+        wins. The Snakemake workflow passes the image's own calibration
+        automatically; from the API,
+        :func:`patchworks.plugins.ome_zarr.read_pixel_size` reads it from a
+        store.
     **cellpose_kwargs:
         Extra kwargs forwarded to ``model.eval()``
         (e.g. ``flow_threshold``, ``cellprob_threshold``, ``anisotropy``).
@@ -128,15 +172,31 @@ def cellpose_fn(
     >>> fn = cellpose_fn("nuclei", diameter=15)
     >>> result = tile_process("image.zarr", fn, channel=1)
 
-    3-D with anisotropy:
+    3-D with an explicit anisotropy:
 
     >>> fn = cellpose_fn("cyto3", gpu=True, do_3D=True, anisotropy=3.0, diameter=20)
     >>> from functools import partial
     >>> from patchworks import auto_tile_shape_cellpose, tile_process
     >>> tile_fn = partial(auto_tile_shape_cellpose, do_3D=True, use_gpu=True, diameter=20)
     >>> result = tile_process("image.zarr", fn, tile_shape=tile_fn, overlap=10)
+
+    3-D with anisotropy derived from the image's own calibration:
+
+    >>> fn = cellpose_fn("cyto3", gpu=True, do_3D=True, diameter=20,
+    ...                  voxel_size={"z": 0.24, "y": 0.10833, "x": 0.10833})
     """
     _require_cellpose()
+    if do_3D and voxel_size and "anisotropy" not in cellpose_kwargs:
+        anisotropy = cellpose_anisotropy(voxel_size)
+        if anisotropy is not None:
+            logger.info(
+                "anisotropy derived from image calibration: %.4g "
+                "(z=%.4g, lateral=%.4g)",
+                anisotropy,
+                voxel_size.get("z"),
+                voxel_size.get("x") or voxel_size.get("y"),
+            )
+            cellpose_kwargs = {**cellpose_kwargs, "anisotropy": anisotropy}
     cfg = _make_config(
         model, gpu, channels, channel_axis, diameter, do_3D, **cellpose_kwargs
     )

patchworks-2.6.9/tests/test_cellpose.py

@@ -0,0 +1,49 @@
+"""Tests for the cellpose plugin's anisotropy handling.
+
+cellpose itself is not a test dependency (heavy, GPU-oriented), and
+cellpose_fn() calls _require_cellpose() as its very first line, so it can't
+be exercised end-to-end here. cellpose_anisotropy() is a pure function with
+no cellpose import at all, and is where the actual math lives -- that's
+what's covered directly. The wiring that fills cellpose_fn's voxel_size
+parameter in from the image's calibration (workflow/scripts/_pw.py's
+_with_voxel_size) is covered in tests/test_pw.py.
+"""
+
+import inspect
+
+
+def test_cellpose_anisotropy_from_calibration():
+    from patchworks.plugins.cellpose import cellpose_anisotropy
+
+    calibration = {"z": 0.24, "y": 0.10833, "x": 0.10833}
+    assert cellpose_anisotropy(calibration) == 0.24 / 0.10833
+
+
+def test_cellpose_anisotropy_falls_back_to_y_when_x_is_missing():
+    from patchworks.plugins.cellpose import cellpose_anisotropy
+
+    assert cellpose_anisotropy({"z": 0.2, "y": 0.1}) == 2.0
+
+
+def test_cellpose_anisotropy_missing_calibration_returns_none():
+    from patchworks.plugins.cellpose import cellpose_anisotropy
+
+    assert cellpose_anisotropy({}) is None
+    assert cellpose_anisotropy({"z": 0.2}) is None  # no lateral size at all
+    assert cellpose_anisotropy({"x": 0.1}) is None  # no z size
+
+
+def test_cellpose_fn_declares_a_voxel_size_parameter():
+    """workflow/scripts/_pw.py's _with_voxel_size() finds this by signature
+
+    inspection to decide whether to fill it in -- if this parameter were
+    ever renamed, that wiring would silently stop working rather than error.
+    """
+    from patchworks.plugins.cellpose import cellpose_fn
+
+    params = inspect.signature(cellpose_fn).parameters
+    assert "voxel_size" in params
+    # anisotropy itself goes through **cellpose_kwargs (it's a cellpose
+    # model.eval() argument, not a patchworks-specific one) -- only the raw
+    # calibration is a named parameter.
+    assert "anisotropy" not in params

patchworks-2.6.9/tests/test_pw.py

@@ -0,0 +1,82 @@
+"""Tests for workflow/scripts/_pw.py's config-to-segmentation-function wiring."""
+
+import sys
+from pathlib import Path
+
+sys.path.insert(
+    0, str(Path(__file__).resolve().parents[1] / "workflow" / "scripts")
+)
+
+import numpy as np  # noqa: E402
+
+
+def test_with_voxel_size_fills_in_cellposes_calibration(tmp_path):
+    """The same auto-fill a custom function's voxel_size gets (see
+
+    _with_voxel_size's docstring) must also reach cellpose_fn, or do_3D
+    silently assumes isotropic voxels -- fragmenting objects across z for
+    any real (anisotropic) calibration. This checks the actual calibration
+    read + injection against a real store, not just that the parameter
+    exists (see test_cellpose.py for that).
+    """
+    from _pw import _with_voxel_size
+    from patchworks.plugins.cellpose import cellpose_fn
+    from patchworks.plugins.ome_zarr import to_ome_zarr
+
+    arr = np.zeros((4, 8, 8), dtype="uint16")
+    to_ome_zarr(
+        arr,
+        str(tmp_path / "image.zarr"),
+        axes="zyx",
+        pixel_size={"z": 0.24, "y": 0.10833, "x": 0.10833},
+        n_levels=1,
+        progress=False,
+    )
+    cfg = {"work_dir": str(tmp_path)}
+
+    kwargs = _with_voxel_size(cellpose_fn, {}, cfg)
+
+    assert kwargs["voxel_size"]["z"] == 0.24
+    assert kwargs["voxel_size"]["x"] == 0.10833
+
+
+def test_with_voxel_size_never_overrides_an_explicit_value(tmp_path):
+    """An explicit voxel_size must win, and win *cheaply*: no image.zarr
+
+    exists in work_dir at all here, so if this read past the early return it
+    would raise, not just return the wrong value.
+    """
+    from _pw import _with_voxel_size
+    from patchworks.plugins.cellpose import cellpose_fn
+
+    cfg = {"work_dir": str(tmp_path)}
+    explicit = {"z": 1.0, "y": 1.0, "x": 1.0}
+
+    kwargs = _with_voxel_size(cellpose_fn, {"voxel_size": explicit}, cfg)
+
+    assert kwargs["voxel_size"] == explicit
+
+
+def test_validate_config_accepts_a_positive_min_volume():
+    from _pw import validate_config
+
+    validate_config({"method": "threshold", "min_volume": 5.0})
+
+
+def test_validate_config_accepts_no_min_volume():
+    from _pw import validate_config
+
+    validate_config({"method": "threshold"})
+    validate_config({"method": "threshold", "min_volume": None})
+
+
+def test_validate_config_rejects_a_non_positive_min_volume():
+    import pytest
+    from _pw import validate_config
+
+    with pytest.raises(ValueError, match="min_volume"):
+        validate_config({"method": "threshold", "min_volume": 0})
+    with pytest.raises(ValueError, match="min_volume"):
+        validate_config({"method": "threshold", "min_volume": -1.0})
+    with pytest.raises(ValueError, match="min_volume"):
+        validate_config({"method": "threshold", "min_volume": "5"})

{patchworks-2.6.7 → patchworks-2.6.9}/tests/test_run_multi.py

@@ -188,6 +188,32 @@ def test_relate_script_has_the_real_bookkeeping():
     assert "openpyxl" in src
 
 
+def test_view_script_loads_every_label_by_default():
+    """view.py must not override labels=, or auto-load stops working.
+
+    view_in_napari's labels=None default is what auto-loads every label
+    group under <image>/labels/<name>/ as its own layer -- passing an
+    explicit labels= here would silently drop that and show only one.
+    """
+    src = (_workflow_dir() / "scripts" / "view.py").read_text()
+    assert "from patchworks.plugins.napari import view_in_napari" in src
+    assert "labels=" not in src
+
+
+def test_viewer_is_a_separate_opt_in_pixi_environment():
+    """napari's Qt/GUI deps must stay out of the default headless env.
+
+    Adding them to the default `[pypi-dependencies]` would pull heavy GUI
+    dependencies into every SLURM job's environment for a feature only used
+    interactively.
+    """
+    src = (_workflow_dir() / "pixi.toml").read_text()
+    default_deps = src.split("[pypi-dependencies]")[1].split("[feature")[0]
+    assert "napari" not in default_deps
+    assert 'viewer = { features = ["viewer"] }' in src
+    assert 'extras = ["napari"]' in src
+
+
 def test_relate_writes_its_own_log():
     """relate.py runs via srun, not a Snakemake rule -- nothing else wires up
 

patchworks-2.6.9/tests/test_volume_filter.py

@@ -0,0 +1,135 @@
+"""Tests for the global, post-merge label volume filter."""
+
+import numpy as np
+import zarr
+
+
+def test_voxel_volume_multiplies_given_axes():
+    from patchworks import voxel_volume
+
+    assert voxel_volume({"z": 0.24, "y": 0.10833, "x": 0.10833}) == (
+        0.24 * 0.10833 * 0.10833
+    )
+
+
+def test_voxel_volume_missing_axis_treated_as_one():
+    from patchworks import voxel_volume
+
+    assert voxel_volume({"y": 0.5, "x": 0.5}) == 0.25
+
+
+def test_min_voxels_for_volume_rounds_up():
+    from patchworks import min_voxels_for_volume
+
+    calibration = {"z": 0.24, "y": 0.10833, "x": 0.10833}
+    assert min_voxels_for_volume(5.0, calibration) == 1776
+
+
+def _write_labels(path, array, chunks):
+    root = zarr.open_group(path, mode="w")
+    arr = root.create_array(
+        "labels", shape=array.shape, chunks=chunks, dtype="int32"
+    )
+    arr[:] = array
+    return root
+
+
+def test_filter_labels_by_size_drops_small_objects(tmp_path):
+    from patchworks import filter_labels_by_size
+
+    array = np.array(
+        [
+            [0, 1, 1, 0],
+            [0, 1, 1, 0],
+            [0, 0, 0, 2],
+            [0, 0, 0, 0],
+        ]
+    )
+    path = str(tmp_path / "labels.zarr")
+    root = _write_labels(path, array, chunks=(4, 4))
+
+    n_kept, n_removed = filter_labels_by_size(path, "labels", min_voxels=2)
+
+    assert (n_kept, n_removed) == (1, 1)
+    assert np.array_equal(
+        np.asarray(root["labels"]),
+        [
+            [0, 1, 1, 0],
+            [0, 1, 1, 0],
+            [0, 0, 0, 0],
+            [0, 0, 0, 0],
+        ],
+    )
+
+
+def test_filter_labels_by_size_relabels_surviving_ids_sequentially(tmp_path):
+    """Dropping id 1 must not leave id 2 with a gap where 1 used to be."""
+    from patchworks import filter_labels_by_size
+
+    array = np.array(
+        [
+            [1, 0, 2, 2],
+            [0, 0, 2, 2],
+        ]
+    )
+    path = str(tmp_path / "labels.zarr")
+    root = _write_labels(path, array, chunks=(2, 4))
+
+    filter_labels_by_size(path, "labels", min_voxels=2)
+
+    assert np.array_equal(
+        np.asarray(root["labels"]),
+        [
+            [0, 0, 1, 1],
+            [0, 0, 1, 1],
+        ],
+    )
+
+
+def test_filter_labels_by_size_relabel_false_keeps_original_ids(tmp_path):
+    from patchworks import filter_labels_by_size
+
+    array = np.array(
+        [
+            [1, 0, 5, 5],
+            [0, 0, 5, 5],
+        ]
+    )
+    path = str(tmp_path / "labels.zarr")
+    root = _write_labels(path, array, chunks=(2, 4))
+
+    filter_labels_by_size(path, "labels", min_voxels=2, relabel=False)
+
+    assert np.array_equal(
+        np.asarray(root["labels"]),
+        [
+            [0, 0, 5, 5],
+            [0, 0, 5, 5],
+        ],
+    )
+
+
+def test_filter_labels_by_size_works_across_multiple_chunks(tmp_path):
+    """A removed object's id can exceed every surviving id and still must
+
+    stay in bounds of the LUT built from the largest id *seen*, not just
+    the largest surviving one -- this is the case a single-chunk array
+    can't exercise, since chunking is what makes the scan streaming at all.
+    """
+    from patchworks import filter_labels_by_size
+
+    array = np.zeros((4, 4), dtype="int32")
+    array[0:2, 0:2] = 1  # 4 voxels, kept
+    array[2:4, 2:4] = 2  # 4 voxels, kept
+    array[0, 3] = (
+        3  # 1 voxel, dropped -- id 3 exceeds nothing survives above it
+    )
+    path = str(tmp_path / "labels.zarr")
+    root = _write_labels(path, array, chunks=(2, 2))
+
+    n_kept, n_removed = filter_labels_by_size(path, "labels", min_voxels=2)
+
+    assert (n_kept, n_removed) == (2, 1)
+    out = np.asarray(root["labels"])
+    assert set(np.unique(out).tolist()) == {0, 1, 2}
+    assert out[0, 3] == 0

{patchworks-2.6.7 → patchworks-2.6.9}/workflow/config/config_cilia.yaml

@@ -23,6 +23,11 @@ overlap: [8, 30, 30]
 method: "custom"
 # dilate: 2       # optional: pixels to grow labels by after segmentation
 # dilate_gpu: true # optional: dilate via cupy instead of scipy, needs a GPU
+# min_volume: 5.0 # optional: drop objects smaller than this many µm³.
+#                 # Runs once on the whole merged image (not per tile, where
+#                 # an object crossing a tile boundary would look smaller
+#                 # than it really is) and needs image.zarr to carry a pixel
+#                 # size -- see common.yaml/convert.
 label_name: "cilia_labels"
 custom:
   module: "patchworks.plugins.dog"

{patchworks-2.6.7 → patchworks-2.6.9}/workflow/pixi.toml

@@ -6,6 +6,9 @@
 #   pixi run multi        # run several segmentations + relate their labels (local)
 #   pixi run multi-slurm  # same, on SLURM
 #   pixi run multi-dry    # dry-run every segmentation in config/multi.yaml
+#   pixi install -e viewer && pixi run -e viewer napari <image.zarr>
+#                          # open a store in napari, every label auto-loaded
+#                          # (needs a display -- ssh -X or remote-desktop/VNC)
 #
 # On a cluster, put this project on a shared filesystem the compute nodes can
 # read: the SLURM jobs re-launch snakemake from this env's interpreter.
@@ -31,11 +34,21 @@ cellpose = ">=3.0,<4"
 [feature.cp4.pypi-dependencies]
 cellpose = ">=4"
 
-# Named environments: pixi install -e cellpose3 / -e cellpose4
+# napari pulls in a lot of Qt/GUI dependencies that don't belong in the
+# default headless SLURM environment, so it's a separate opt-in feature --
+# pixi install -e viewer, not part of the default `pixi install`.
+[feature.viewer.pypi-dependencies]
+patchworks = { version = "*", extras = ["napari"] }
+
+[feature.viewer.tasks]
+napari = "python scripts/view.py"
+
+# Named environments: pixi install -e cellpose3 / -e cellpose4 / -e viewer
 # The base patchworks[cellpose] (>=3.0) is further constrained by each feature.
 [environments]
 cellpose3 = { features = ["cp3"], solve-group = "cp3" }
 cellpose4 = { features = ["cp4"], solve-group = "cp4" }
+viewer = { features = ["viewer"] }
 
 [tasks]
 # --rerun-triggers mtime: don't redo finished steps (e.g. the conversion) just

{patchworks-2.6.7 → patchworks-2.6.9}/workflow/scripts/_pw.py

@@ -268,6 +268,17 @@ def validate_config(cfg) -> None:
                 "which segments a single channel"
             )
 
+    min_volume = cfg.get("min_volume")
+    if min_volume is not None and (
+        isinstance(min_volume, bool)
+        or not isinstance(min_volume, (int, float))
+        or min_volume <= 0
+    ):
+        problems.append(
+            "min_volume must be null or a positive number of micrometers³ "
+            f"(e.g. 5.0); got {min_volume!r}"
+        )
+
     method = cfg.get("method", "cellpose")
     if method not in KNOWN_METHODS:
         listed = ", ".join(f'"{m}"' for m in KNOWN_METHODS)
@@ -425,6 +436,12 @@ def _build_method_fn(cfg):
             # Cellpose where they are. setdefault so an explicit
             # cellpose.channel_axis in the config still wins.
             extra.setdefault("channel_axis", 0)
+        # do_3D without anisotropy assumes isotropic voxels, which fragments
+        # objects across z for any real (anisotropic) calibration -- fill it
+        # in from the image's own calibration the same way a custom
+        # function's voxel_size gets filled in, unless the config already
+        # set anisotropy explicitly.
+        extra = _with_voxel_size(cellpose_fn, extra, cfg)
         return cellpose_fn(
             cp.get("model", "cyto3"),
             gpu=cp.get("gpu", True),

{patchworks-2.6.7 → patchworks-2.6.9}/workflow/scripts/merge.py

@@ -18,7 +18,11 @@ from patchworks import (
     safe_worker_count,
 )
 from patchworks._chunks import _get_available_memory
-from patchworks.plugins.ome_zarr import register_labels
+from patchworks._volume_filter import (
+    filter_labels_by_size,
+    min_voxels_for_volume,
+)
+from patchworks.plugins.ome_zarr import read_pixel_size, register_labels
 
 from _pw import load_tiles_json, stage_path, start_log
 
@@ -96,6 +100,31 @@ _, n_objects = merge_tile_labels(
     return_count=True,
     label_counts=label_counts,
 )
+
+# Global, exact volume filter -- runs once on the fully merged array so an
+# object's size is never judged from just the fragment one tile happened to
+# see. Runs before the pyramid so every level reflects the filtered result.
+min_volume = cfg.get("min_volume")
+if min_volume:
+    voxel_size = read_pixel_size(image_store)
+    if not voxel_size:
+        raise RuntimeError(
+            f"min_volume filtering needs calibration in {image_store}, "
+            "which has none -- set min_volume: null, or make sure the "
+            "source carries a pixel size at conversion time"
+        )
+    min_voxels = min_voxels_for_volume(min_volume, voxel_size)
+    n_objects, n_removed = filter_labels_by_size(
+        label_group,
+        "0",
+        min_voxels,
+        relabel=cfg.get("sequential_labels", True),
+    )
+    print(
+        f"[patchworks] volume filter: dropped {n_removed} object(s) under "
+        f"{min_volume} µm³ ({min_voxels} voxels), {n_objects} remain"
+    )
+
 group = register_labels(
     image_store,
     label_name,

{patchworks-2.6.7 → patchworks-2.6.9}/workflow/scripts/relate.py

@@ -155,9 +155,7 @@ def run_relations(
                 )
 
         ws_b = wb.create_sheet(title=b_name[:31])
-        ws_b.append(
-            [f"{b_name}_id", f"{a_name}_count", "total_overlap_voxels"]
-        )
+        ws_b.append([f"{b_name}_id", f"{a_name}_count", "total_overlap_voxels"])
         for b_id in b_ids:
             agg = per_b[b_id]
             ws_b.append([b_id, agg["count"], agg["overlap_voxels"]])

{patchworks-2.6.7 → patchworks-2.6.9}/workflow/scripts/run_multi.py

@@ -356,7 +356,9 @@ def _resolve_shared_tile_shape(
                 gpu_memory=gpu_bytes,
                 n_channels=n_channels,
             )
-        candidates.append(tuple(int(x) for x in sizer(image.shape, image.dtype)))
+        candidates.append(
+            tuple(int(x) for x in sizer(image.shape, image.dtype))
+        )
 
     tile_shape = min(candidates, key=lambda t: int(np.prod(t)))
     print(

patchworks-2.6.9/workflow/scripts/view.py

@@ -0,0 +1,47 @@
+"""Open an OME-ZARR store in napari, auto-loading every label group.
+
+Usage:
+    pixi run -e viewer napari /path/to/image.zarr
+    pixi run -e viewer napari /path/to/image.zarr --channel 1
+
+Needs the `viewer` pixi environment (`pixi install -e viewer`) -- napari's
+Qt/GUI dependencies live there, not in the default headless workflow env --
+and a display: an X11-forwarded SSH session (`ssh -X`) or a remote-desktop/
+VNC session. It cannot open over a plain headless SSH session.
+"""
+
+from __future__ import annotations
+
+import argparse
+
+from patchworks.plugins.napari import view_in_napari
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "image", help="OME-ZARR store to open, e.g. work_dir/image.zarr"
+    )
+    parser.add_argument(
+        "--channel",
+        type=int,
+        default=None,
+        help="show only this channel (default: every channel)",
+    )
+    parser.add_argument(
+        "--no-glasbey",
+        action="store_true",
+        help="use napari's default label colours instead of glasbey",
+    )
+    args = parser.parse_args()
+
+    # Leaving the labels argument at its default auto-loads every label
+    # group under <image>/labels/<name>/ as its own Labels layer -- exactly
+    # what's wanted here, so there is nothing further to wire up.
+    view_in_napari(
+        args.image, channel=args.channel, glasbey=not args.no_glasbey
+    )
+
+
+if __name__ == "__main__":
+    main()