patchworks 2.6.9__tar.gz → 2.6.10__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: patchworks
-Version: 2.6.9
+Version: 2.6.10
 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.9 → patchworks-2.6.10}/docs/api/plugins/cellpose.md

@@ -1,3 +1,5 @@
 # Cellpose plugin
 
 ::: patchworks.plugins.cellpose.cellpose_fn
+
+::: patchworks.plugins.cellpose.cellpose_anisotropy

patchworks-2.6.10/docs/api/volume_filter.md

@@ -0,0 +1,9 @@
+# Volume filtering
+
+::: patchworks.filter_labels_by_size
+
+::: patchworks.voxel_volume
+
+::: patchworks.min_voxels_for_volume
+
+::: patchworks.max_voxels_for_volume

{patchworks-2.6.9 → patchworks-2.6.10}/docs/examples/cellpose_3d.md

@@ -14,19 +14,19 @@ plane orientations and takes a 3-D consensus.
 from functools import partial
 from patchworks import auto_tile_shape_cellpose, make_local_cluster, tile_process
 from patchworks.plugins.cellpose import cellpose_fn
+from patchworks.plugins.ome_zarr import read_pixel_size
 
 IMAGE = "image.zarr"
 OUTPUT = "labels_3d.zarr"
 CHANNEL = 0
 DIAMETER = 20  # pixels
-ANISOTROPY = 3.0  # z_spacing / xy_spacing
 
 fn = cellpose_fn(
     "cyto3",
     gpu=True,
     do_3D=True,
     diameter=DIAMETER,
-    anisotropy=ANISOTROPY,
+    voxel_size=read_pixel_size(IMAGE),  # -> anisotropy = z / lateral
 )
 
 # Tile shape: full z, xy tiled for memory
@@ -59,6 +59,15 @@ finally:
     cluster.close()
 ```
 
+!!! tip "Anisotropy is derived from the calibration, not retyped"
+    `do_3D` without `anisotropy` assumes isotropic voxels, which fragments
+    objects across z for any real (anisotropic) dataset. Passing
+    `voxel_size` derives it as `z / lateral` via
+    [`cellpose_anisotropy`](../api/plugins/cellpose.md) instead of keeping a
+    second, driftable copy of the calibration in code. An explicit
+    `anisotropy=` still wins if you pass one. The Snakemake workflow does
+    this automatically — see [Configure the run](../guide/snakemake.md#3-configure-the-run).
+
 ## Memory notes
 
 In `do_3D=True` mode, each tile has shape `(z_full, y_tile, x_tile)`.

{patchworks-2.6.9 → patchworks-2.6.10}/docs/examples/cellpose_3d.py

@@ -12,19 +12,19 @@ from patchworks import (
     tile_process,
 )
 from patchworks.plugins.cellpose import cellpose_fn
+from patchworks.plugins.ome_zarr import read_pixel_size
 
 IMAGE = "image.zarr"
 OUTPUT = "labels_3d.zarr"
 CHANNEL = 0
 DIAMETER = 20  # pixels
-ANISOTROPY = 3.0  # z-spacing / xy-spacing
 
 fn = cellpose_fn(
     "cyto3",
     gpu=True,
     do_3D=True,
     diameter=DIAMETER,
-    anisotropy=ANISOTROPY,
+    voxel_size=read_pixel_size(IMAGE),  # -> anisotropy = z / lateral
 )
 
 tile_fn = partial(

{patchworks-2.6.9 → patchworks-2.6.10}/docs/guide/merging.md

@@ -133,6 +133,59 @@ merged = merge_tile_labels(
 )
 ```
 
+## Filtering by size after merge
+
+Once labels are globally consistent, [`filter_labels_by_size`](../api/volume_filter.md)
+can drop objects outside a voxel-count range, in place — too small, too large,
+or both:
+
+```python
+from patchworks import filter_labels_by_size, merge_tile_labels
+
+merged = merge_tile_labels("stage.zarr", write_to="labels.zarr", sequential_labels=True)
+# drop anything under 500 voxels, over 50000, or both -- give either bound alone
+n_kept, n_removed = filter_labels_by_size(
+    "labels.zarr", "labels", min_voxels=500, max_voxels=50000
+)
+```
+
+This has to run **after** the merge, not per tile: a tile only sees whatever
+fragment of an object landed inside its own bounds, so a per-tile filter would
+judge (and possibly drop) an object crossing a tile boundary as if it were
+only that fragment's size — including judging it too *large*, for a
+`max_voxels` filter, when several separate objects in one tile would in fact
+merge back into one across the boundary.
+
+Like the merge itself, it is a two-pass streaming zarr scan — the array never
+has to fit in RAM. `relabel=True` (the default) folds the size filter into
+the same lookup table that renumbers survivors to a contiguous `1..N` range,
+so dropping out-of-range objects costs no extra pass over the volume beyond
+the scan that already counts them.
+
+Physical thresholds (µm³) convert to a voxel count via
+[`min_voxels_for_volume`](../api/volume_filter.md)/[`max_voxels_for_volume`](../api/volume_filter.md),
+using the same `{"z": .., "y": .., "x": ..}` calibration deconvolution and
+Cellpose's `anisotropy` are derived from. The two round in opposite
+directions — `min_voxels_for_volume` rounds up (an object must *reach* the
+threshold), `max_voxels_for_volume` rounds down (an object must not *exceed*
+it):
+
+```python
+from patchworks import max_voxels_for_volume, min_voxels_for_volume
+from patchworks.plugins.ome_zarr import read_pixel_size
+
+voxel_size = read_pixel_size("image.zarr")
+min_voxels = min_voxels_for_volume(5.0, voxel_size)
+max_voxels = max_voxels_for_volume(500.0, voxel_size)
+n_kept, n_removed = filter_labels_by_size(
+    "labels.zarr", "labels", min_voxels, max_voxels
+)
+```
+
+On the cluster, set `min_volume: 5.0`/`max_volume: 500.0` in the config
+instead — see [Configure the run](snakemake.md#3-configure-the-run). Either
+or both run automatically between `merge` and the pyramid build.
+
 ## Sequential label numbering
 
 By default, merged labels are globally unique but may be **gappy** — boundary

{patchworks-2.6.9 → patchworks-2.6.10}/docs/guide/snakemake.md

@@ -68,12 +68,16 @@ method: "cellpose"             # "cellpose" (GPU), "threshold" (no GPU), "custom
 label_name: "cellpose"         # name under image.zarr/labels/
 dilate: 0                      # optional: pixels to grow labels by, any method
 dilate_gpu: false               # dilate via cupy instead of scipy (needs a GPU)
+min_volume: null               # optional: drop objects smaller than this many µm³
+max_volume: null               # optional: drop objects larger than this many µm³
 cellpose:
   model: "cyto3"
   diameter: 30
   do_3D: true
   gpu: true
   # extra model.eval() kwargs, e.g. flow_threshold: 0.4
+  # anisotropy: 2.2   # optional: overrides the value derived automatically
+  #                   # from image.zarr's calibration for do_3D (see tip below)
 
 # label pyramid
 pyramid_levels: 5
@@ -94,6 +98,29 @@ sequential_labels: true        # renumber labels to a contiguous 1..N
     labels afterwards](custom_segmentation.md#growing-labels-afterwards-dilation)
     for how it works and the equivalent direct-API call.
 
+!!! tip "Dropping objects by size with `min_volume`/`max_volume`"
+    `min_volume: N` drops any object smaller than `N` µm³; `max_volume: N`
+    drops any object larger than `N` µm³ (e.g. several objects merged into
+    one blob). Set either, both, or neither (`null`, the default, disables
+    each). Both run once on the **fully merged** image — not per tile, where
+    an object crossing a tile boundary would look smaller or larger than it
+    really is. Runs after `merge` and before the pyramid is built, so every
+    pyramid level reflects the filtered result, and needs `image.zarr` to
+    carry a pixel size (the same calibration deconvolution's voxel sizes and
+    Cellpose's `anisotropy` are derived from — see the tip below); an
+    uncalibrated store raises rather than silently skipping the filter. See
+    [Filtering by size after merge](merging.md#filtering-by-size-after-merge)
+    for the equivalent direct-API call.
+
+!!! tip "3-D anisotropy is derived automatically"
+    Cellpose's `do_3D` assumes isotropic voxels unless told otherwise —
+    without an `anisotropy`, a real (anisotropic) dataset gets objects
+    fragmented or distorted across z. `segment` now derives it from
+    `image.zarr`'s own calibration (`z` voxel size ÷ lateral voxel size)
+    whenever `do_3D: true` and `cellpose.anisotropy` isn't set explicitly, so
+    there's usually nothing to configure. Set `anisotropy:` yourself in the
+    `cellpose:` block to override it.
+
 !!! tip "Tile size vs runtime"
     `tile_shape: "auto"` sizes each tile to your GPU's VRAM. Smaller tiles =
     more (faster) jobs; very large 3-D tiles are slow. Keep `do_3D: false` (2-D

{patchworks-2.6.9 → patchworks-2.6.10}/mkdocs.yml

@@ -58,6 +58,7 @@ nav:
   - tile_process: api/tile_process.md
   - merge_tile_labels: api/merge_tile_labels.md
   - dilate_labels: api/postprocess.md
+  - Volume filtering: api/volume_filter.md
   - Tile sizing: api/chunks.md
   - I/O helpers: api/io.md
   - Relabelling: api/relabel.md

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

@@ -57,6 +57,7 @@ from ._relabel import relabel_sequential_array, relabel_sequential_zarr
 from ._relations import label_relations
 from ._volume_filter import (
     filter_labels_by_size,
+    max_voxels_for_volume,
     min_voxels_for_volume,
     voxel_volume,
 )
@@ -92,5 +93,6 @@ __all__ = [
     "dilate_labels",
     "filter_labels_by_size",
     "min_voxels_for_volume",
+    "max_voxels_for_volume",
     "voxel_volume",
 ]

{patchworks-2.6.9 → patchworks-2.6.10}/src/patchworks/_volume_filter.py

@@ -1,17 +1,18 @@
-"""Drop label objects below a volume threshold, in place, after merge.
+"""Drop label objects outside a size range, 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*).
+filter would clip or drop objects that are only small, or only large,
+*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.
+that zeroes labels outside ``[min_voxels, max_voxels]`` -- 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
@@ -86,6 +87,36 @@ def min_voxels_for_volume(
     return math.ceil(min_volume / voxel_volume(voxel_size))
 
 
+def max_voxels_for_volume(
+    max_volume: float, voxel_size: "dict[str, float]"
+) -> int:
+    """Convert a physical volume threshold to a voxel count.
+
+    Rounds down, the mirror image of :func:`min_voxels_for_volume`: an
+    object must not *exceed* *max_volume*, so a voxel count whose volume
+    would tip past it must not survive.
+
+    Parameters
+    ----------
+    max_volume : float
+        Maximum 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
+        Maximum voxel count for an object to survive filtering.
+
+    Examples
+    --------
+    >>> max_voxels_for_volume(5.0, {"z": 0.24, "y": 0.10833, "x": 0.10833})
+    1775
+    """
+    return math.floor(max_volume / voxel_volume(voxel_size))
+
+
 def _chunk_slices(shape, chunks):
     """Every zarr chunk's index expression, in all dimensions.
 
@@ -105,11 +136,12 @@ def _chunk_slices(shape, chunks):
 def filter_labels_by_size(
     store_path: str,
     component: str,
-    min_voxels: int,
+    min_voxels: "int | None" = None,
+    max_voxels: "int | None" = None,
     *,
     relabel: bool = True,
 ) -> "tuple[int, int]":
-    """Drop label objects smaller than *min_voxels*, in place.
+    """Drop label objects outside ``[min_voxels, max_voxels]``, in place.
 
     Two-pass streaming scan (see module docstring) -- the array never has
     to fit in RAM.
@@ -120,15 +152,21 @@ def filter_labels_by_size(
         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.
+    min_voxels : int, optional
+        Objects with fewer voxels than this are zeroed (dropped). ``None``
+        (default) sets no lower bound. Use :func:`min_voxels_for_volume` to
+        derive this from a physical volume and calibration.
+    max_voxels : int, optional
+        Objects with more voxels than this are zeroed (dropped) -- e.g. a
+        segmentation artifact where several objects merged into one giant
+        blob. ``None`` (default) sets no upper bound. Use
+        :func:`max_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.
+        the same LUT that drops the out-of-range ones (default ``True``)
+        -- otherwise the removed ids leave permanent gaps and survivors
+        keep their original ids.
 
     Returns
     -------
@@ -150,6 +188,11 @@ def filter_labels_by_size(
     >>> filter_labels_by_size("labels.zarr", "labels", min_voxels=2)  # doctest: +SKIP
     (1, 1)
     """
+    if min_voxels is None and max_voxels is None:
+        raise ValueError(
+            "filter_labels_by_size needs min_voxels, max_voxels, or both"
+        )
+
     root = zarr.open_group(store_path, mode="r+")
     z = root[component]
     slices = _chunk_slices(z.shape, z.chunks)
@@ -162,7 +205,12 @@ def filter_labels_by_size(
                 continue
             counts[label_id] = counts.get(label_id, 0) + count
 
-    kept = sorted(i for i, c in counts.items() if c >= min_voxels)
+    kept = sorted(
+        i
+        for i, c in counts.items()
+        if (min_voxels is None or c >= min_voxels)
+        and (max_voxels is None or c <= max_voxels)
+    )
     n_kept = len(kept)
     n_removed = len(counts) - n_kept
 
@@ -187,12 +235,15 @@ def filter_labels_by_size(
         block = np.asarray(z[sl])
         z[sl] = lut[block].astype(out_dtype)
 
+    bounds = "-".join(
+        str(v) if v is not None else "" for v in (min_voxels, max_voxels)
+    )
     logger.info(
-        "filter_labels_by_size: dropped %d/%d object(s) under %d voxels, "
+        "filter_labels_by_size: dropped %d/%d object(s) outside [%s] voxels, "
         "%d remain",
         n_removed,
         len(counts),
-        min_voxels,
+        bounds,
         n_kept,
     )
     return n_kept, n_removed

{patchworks-2.6.9 → patchworks-2.6.10}/tests/test_pw.py

@@ -80,3 +80,44 @@ def test_validate_config_rejects_a_non_positive_min_volume():
         validate_config({"method": "threshold", "min_volume": -1.0})
     with pytest.raises(ValueError, match="min_volume"):
         validate_config({"method": "threshold", "min_volume": "5"})
+
+
+def test_validate_config_accepts_a_positive_max_volume():
+    from _pw import validate_config
+
+    validate_config({"method": "threshold", "max_volume": 500.0})
+    validate_config({"method": "threshold", "max_volume": None})
+
+
+def test_validate_config_rejects_a_non_positive_max_volume():
+    import pytest
+    from _pw import validate_config
+
+    with pytest.raises(ValueError, match="max_volume"):
+        validate_config({"method": "threshold", "max_volume": 0})
+    with pytest.raises(ValueError, match="max_volume"):
+        validate_config({"method": "threshold", "max_volume": -1.0})
+    with pytest.raises(ValueError, match="max_volume"):
+        validate_config({"method": "threshold", "max_volume": "5"})
+
+
+def test_validate_config_accepts_max_volume_above_min_volume():
+    from _pw import validate_config
+
+    validate_config(
+        {"method": "threshold", "min_volume": 5.0, "max_volume": 500.0}
+    )
+
+
+def test_validate_config_rejects_max_volume_at_or_below_min_volume():
+    import pytest
+    from _pw import validate_config
+
+    with pytest.raises(ValueError, match="max_volume"):
+        validate_config(
+            {"method": "threshold", "min_volume": 5.0, "max_volume": 5.0}
+        )
+    with pytest.raises(ValueError, match="max_volume"):
+        validate_config(
+            {"method": "threshold", "min_volume": 500.0, "max_volume": 5.0}
+        )

{patchworks-2.6.9 → patchworks-2.6.10}/tests/test_volume_filter.py

@@ -25,6 +25,13 @@ def test_min_voxels_for_volume_rounds_up():
     assert min_voxels_for_volume(5.0, calibration) == 1776
 
 
+def test_max_voxels_for_volume_rounds_down():
+    from patchworks import max_voxels_for_volume
+
+    calibration = {"z": 0.24, "y": 0.10833, "x": 0.10833}
+    assert max_voxels_for_volume(5.0, calibration) == 1775
+
+
 def _write_labels(path, array, chunks):
     root = zarr.open_group(path, mode="w")
     arr = root.create_array(
@@ -133,3 +140,54 @@ def test_filter_labels_by_size_works_across_multiple_chunks(tmp_path):
     out = np.asarray(root["labels"])
     assert set(np.unique(out).tolist()) == {0, 1, 2}
     assert out[0, 3] == 0
+
+
+def test_filter_labels_by_size_drops_large_objects(tmp_path):
+    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))
+
+    n_kept, n_removed = filter_labels_by_size(path, "labels", max_voxels=2)
+
+    assert (n_kept, n_removed) == (1, 1)
+    assert np.array_equal(
+        np.asarray(root["labels"]),
+        [
+            [1, 0, 0, 0],
+            [0, 0, 0, 0],
+        ],
+    )
+
+
+def test_filter_labels_by_size_min_and_max_together_keeps_the_middle(tmp_path):
+    from patchworks import filter_labels_by_size
+
+    array = np.array([1, 0, 2, 2, 0, 3, 3, 3])  # sizes: 1, 2, 3
+    path = str(tmp_path / "labels.zarr")
+    root = _write_labels(path, array, chunks=(8,))
+
+    n_kept, n_removed = filter_labels_by_size(
+        path, "labels", min_voxels=2, max_voxels=2, relabel=False
+    )
+
+    assert (n_kept, n_removed) == (1, 2)
+    assert np.array_equal(np.asarray(root["labels"]), [0, 0, 2, 2, 0, 0, 0, 0])
+
+
+def test_filter_labels_by_size_requires_at_least_one_bound(tmp_path):
+    import pytest
+    from patchworks import filter_labels_by_size
+
+    array = np.array([1, 1, 0, 2])
+    path = str(tmp_path / "labels.zarr")
+    _write_labels(path, array, chunks=(4,))
+
+    with pytest.raises(ValueError, match="min_voxels.*max_voxels"):
+        filter_labels_by_size(path, "labels")

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

@@ -23,11 +23,13 @@ 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.
+# min_volume: 5.0 # optional: drop objects smaller than this many µm³
+# max_volume: 500.0 # optional: drop objects larger than this many µm³
+#                 # (e.g. several cilia merged into one blob). Either or both
+#                 # -- runs once on the whole merged image (not per tile,
+#                 # where an object crossing a tile boundary would look
+#                 # smaller/larger 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.9 → patchworks-2.6.10}/workflow/config/config_cyto.yaml

@@ -32,6 +32,13 @@ overlap: [4, 30, 30]
 
 method: "cellpose"
 label_name: "cyto_labels"
+# min_volume: 100.0 # optional: drop objects smaller than this many µm³
+# max_volume: 5000.0 # optional: drop objects larger than this many µm³
+#                 # (e.g. several cells merged into one blob). Either or both
+#                 # -- runs once on the whole merged image (not per tile,
+#                 # where an object crossing a tile boundary would look
+#                 # smaller/larger than it really is) and needs image.zarr
+#                 # to carry a pixel size -- see common.yaml/convert.
 cellpose:
   model: "cyto3"
   diameter: 30

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

@@ -279,6 +279,29 @@ def validate_config(cfg) -> None:
             f"(e.g. 5.0); got {min_volume!r}"
         )
 
+    max_volume = cfg.get("max_volume")
+    if max_volume is not None and (
+        isinstance(max_volume, bool)
+        or not isinstance(max_volume, (int, float))
+        or max_volume <= 0
+    ):
+        problems.append(
+            "max_volume must be null or a positive number of micrometers³ "
+            f"(e.g. 500.0); got {max_volume!r}"
+        )
+
+    if (
+        isinstance(min_volume, (int, float))
+        and not isinstance(min_volume, bool)
+        and isinstance(max_volume, (int, float))
+        and not isinstance(max_volume, bool)
+        and max_volume <= min_volume
+    ):
+        problems.append(
+            f"max_volume ({max_volume}) must be greater than min_volume "
+            f"({min_volume}), or nothing would ever survive the filter"
+        )
+
     method = cfg.get("method", "cellpose")
     if method not in KNOWN_METHODS:
         listed = ", ".join(f'"{m}"' for m in KNOWN_METHODS)

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

@@ -20,6 +20,7 @@ from patchworks import (
 from patchworks._chunks import _get_available_memory
 from patchworks._volume_filter import (
     filter_labels_by_size,
+    max_voxels_for_volume,
     min_voxels_for_volume,
 )
 from patchworks.plugins.ome_zarr import read_pixel_size, register_labels
@@ -105,24 +106,33 @@ _, n_objects = merge_tile_labels(
 # 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:
+max_volume = cfg.get("max_volume")
+if min_volume or max_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"
+            f"min_volume/max_volume filtering needs calibration in "
+            f"{image_store}, which has none -- set both to null, or make "
+            "sure the source carries a pixel size at conversion time"
         )
-    min_voxels = min_voxels_for_volume(min_volume, voxel_size)
+    min_voxels = (
+        min_voxels_for_volume(min_volume, voxel_size) if min_volume else None
+    )
+    max_voxels = (
+        max_voxels_for_volume(max_volume, voxel_size) if max_volume else None
+    )
     n_objects, n_removed = filter_labels_by_size(
         label_group,
         "0",
         min_voxels,
+        max_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"
+        f"[patchworks] volume filter: dropped {n_removed} object(s) outside "
+        f"[{min_volume or 0}, {max_volume or 'inf'}] µm³ "
+        f"([{min_voxels or 0}, {max_voxels or 'inf'}] voxels), "
+        f"{n_objects} remain"
     )
 
 group = register_labels(