patchworks 2.6.9__tar.gz → 2.6.11__tar.gz

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

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

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

patchworks-2.6.11/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.11}/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.11}/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.11}/docs/examples/dog.md

@@ -102,6 +102,21 @@ decon_kwargs=dict(psf=psf, dxpsf=0.05, dzpsf=0.1, wavelength=525, ...)
     so edge tiles keep enough context (a plain intensity/threshold halo is
     too thin).
 
+!!! note "cudaDecon can return a smaller volume than it was given"
+    It rounds each axis down to an FFT-efficient length — e.g. a
+    `(32, 1084, 1084)` tile comes back `(32, 1080, 1080)`, because
+    `1080 = 2³·3³·5` while `1084 = 4·271` — and trims the excess off the
+    **high end**, leaving voxel `(0, 0, 0)` where it was. patchworks restores
+    the input shape before the DoG step (one label per input voxel is
+    required) anchored at that origin, and logs a WARNING with both shapes.
+
+    Anchoring matters: restoring it *centred* instead moves every voxel by
+    `excess // 2` — a 2 px y/x shift for the tile above, identical on every
+    tile. That is invisible on a cell tens of voxels wide and obvious on a
+    cilium a few voxels wide, which is how it was eventually caught. If the
+    logged difference is more than a few voxels, the PSF or the voxel sizes
+    are wrong.
+
 ## Growing the labels afterwards
 
 DoG spots/threads are often thin — grow each label by a few pixels with

{patchworks-2.6.9 → patchworks-2.6.11}/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.11}/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
@@ -417,10 +444,14 @@ results/image.zarr/labels/cyto_labels/
 
 !!! tip "The relate step's log"
     Unlike `prepare`/`segment`/`merge`, the relate step isn't a Snakemake
-    rule, so it doesn't get a `log:` directive for free. It writes its own
-    log to `<work_dir>/logs/relate.log` (override with `relate.py --log`),
-    the same tee-to-file-and-stdout behaviour as the other steps — check
-    there instead of scrolling back through `srun`'s live output.
+    rule, so it doesn't get a `log:` directive for free. Standalone (or
+    under plain `multi`), it writes to `<work_dir>/logs/relate.log`
+    (override with `relate.py --log`), the same tee-to-file-and-stdout
+    behaviour as the other steps. Under `multi-slurm`, where each pair is
+    its own concurrent job, `run_multi.py` points each one at its own file
+    instead — `<work_dir>/logs/relate/<a>_to_<b>.log` — so concurrent pairs
+    don't interleave into one log; check there instead of scrolling back
+    through `srun`'s live output.
 
 See [Relating labels across segmentations](label_relations.md) for what
 `label_relations()` returns and how to save it yourself — the cluster
@@ -471,15 +502,29 @@ abort the others; you get a per-config status and a non-zero exit.
 
 !!! tip "The relate step runs on the cluster too, under `multi-slurm`"
     `label_relations()` streams every chunk of two full-resolution label
-    volumes — real CPU/IO work, not orchestration. Under `multi-slurm` it is
-    submitted as its own `srun` job (`scripts/relate.py`) instead of running
-    in the driver process on the login node, the same fix already applied to
-    the occupancy map. Tune its allocation with `--relate-partition`,
-    `--relate-mem`, `--relate-cpus` and `--relate-time` (defaults: `scicore`,
-    `32G`, `8`, `180` minutes) — these are wide-margin guesses, not measured
-    numbers, so raise them for a very large or very object-dense pair. Under
-    plain `multi` (no `--profile`), it still runs locally, in-process, as
-    before.
+    volumes — real CPU/IO work, not orchestration. Under `multi-slurm`,
+    **each pair in `relations:` is submitted as its own `srun` job**
+    (`scripts/relate.py`) instead of running in the driver process on the
+    login node, the same fix already applied to the occupancy map. Tune the
+    allocation with `--relate-partition`, `--relate-mem`, `--relate-cpus`
+    and `--relate-time` (defaults: `scicore`, `32G`, `8`, `180` minutes,
+    **per relation**) — these are wide-margin guesses, not measured numbers,
+    so raise them for a very large or very object-dense pair; a pair needing
+    a chunk-layout rechunk first (see below) is the usual reason one runs
+    long. Set `--relate-qos` if your account's default QOS for the partition
+    caps the wall time below `--relate-time` — `srun` fails immediately with
+    `QOSMaxWallDurationPerJobLimit` when that happens; `sacctmgr -p show
+    assoc user=$USER` and `sacctmgr -p show qos` list what's available and
+    each one's `MaxWall`. Under plain `multi` (no `--profile`), relations
+    still run locally, in-process, one after another, as before.
+
+    Because every pair gets its own job, one running long no longer starves
+    the others out of a shared time budget, and a pair that gets killed no
+    longer takes an already-finished sibling's workbook down with it.
+    `relate.py` also skips a pair whose `.xlsx` is already newer than both
+    labels' merge marker, so **re-running the exact same `multi-slurm`
+    command only recomputes what's still missing or stale** — delete a
+    specific `.xlsx` yourself to force just that one to recompute.
 
 !!! tip "After a killed run"
     Snakemake only releases its lock on a clean exit, so a run that was killed

{patchworks-2.6.9 → patchworks-2.6.11}/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.11}/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.11}/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.11}/src/patchworks/plugins/dog.py

@@ -239,18 +239,23 @@ def _run(block: np.ndarray, dog_dict: dict[str, Any]) -> np.ndarray:
 
 
 def _restore_shape(arr: np.ndarray, shape: tuple[int, ...]) -> np.ndarray:
-    """Centre *arr* back into an array of *shape*, cropping or edge-padding.
+    """Restore *arr* to *shape*, anchored at the origin, cropping or padding.
 
     Deconvolution must not change the field of view: patchworks writes the
     result into a destination slice derived from the tile's geometry, so one
     label per input voxel is required.
 
-    Centring is the right correction for a symmetric crop, which is what
-    apodisation produces. The discrepancies observed are small (a voxel in z,
-    a few in x/y) and land inside the halo, which is discarded anyway -- so
-    the labels that survive the trim are unaffected. It is logged at WARNING
-    with the exact shapes so a larger, non-symmetric crop cannot pass
-    silently.
+    The alignment is **origin-anchored**, not centred: cudaDecon rounds each
+    axis down to an FFT-efficient length (e.g. 1084 -> 1080, since
+    1080 = 2**3 * 3**3 * 5 while 1084 = 4 * 271) and trims the excess off the
+    high end, leaving voxel (0, 0, 0) where it was. Re-centring content that
+    was never centred shifts every voxel by ``excess // 2`` -- measured at 2
+    px in y and x on a real (32, 1084, 1084) tile, in the same direction on
+    every tile. That is invisible on a cell tens of voxels across and glaring
+    on a cilium a few voxels across, which is exactly how it was found.
+
+    A mismatch is still logged at WARNING with the exact shapes, since a
+    large one means the PSF or voxel sizes are wrong.
 
     Parameters
     ----------
@@ -271,22 +276,22 @@ def _restore_shape(arr: np.ndarray, shape: tuple[int, ...]) -> np.ndarray:
     (14, 1024)
     """
     logger.warning(
-        "deconvolution returned %s for a %s input; re-centring to the input "
-        "shape. patchworks needs one label per input voxel. A large or "
-        "asymmetric difference here would shift labels -- check the PSF and "
-        "voxel sizes if this is more than a few voxels.",
+        "deconvolution returned %s for a %s input; restoring the input shape "
+        "from the origin. patchworks needs one label per input voxel. A large "
+        "difference here means the PSF or voxel sizes are wrong -- check them "
+        "if this is more than a few voxels.",
         arr.shape,
         shape,
     )
     # Crop first, so an axis that grew is handled before padding the rest.
+    # Both keep voxel 0 where it is: cudaDecon trims off the high end (see the
+    # docstring), so the low corner is the one landmark known to be unmoved.
     crop = tuple(
-        slice((a - s) // 2, (a - s) // 2 + s) if a > s else slice(None)
-        for a, s in zip(arr.shape, shape)
+        slice(0, s) if a > s else slice(None) for a, s in zip(arr.shape, shape)
     )
     arr = arr[crop]
     pad = tuple(
-        ((s - a) // 2, s - a - (s - a) // 2) if a < s else (0, 0)
-        for a, s in zip(arr.shape, shape)
+        (0, s - a) if a < s else (0, 0) for a, s in zip(arr.shape, shape)
     )
     if any(lo or hi for lo, hi in pad):
         arr = np.pad(arr, pad, mode="edge")

{patchworks-2.6.9 → patchworks-2.6.11}/tests/test_dog.py

@@ -109,20 +109,32 @@ def test_explicit_decon_kwargs_win_over_the_calibration(monkeypatch):
     assert captured["dzpsf"] == 0.2
 
 
-def test_restore_shape_recentres_a_cropped_decon():
+def test_restore_shape_anchors_a_cropped_decon_at_the_origin():
     """cudaDecon can hand back a smaller volume than it was given.
 
-    Observed on a real edge tile: (14, 1024, 1024) in, (13, 1020, 1020) out.
-    patchworks needs one label per input voxel, so the field of view has to be
-    restored before the DoG step.
+    Observed on a real tile: (32, 1084, 1084) in, (32, 1080, 1080) out --
+    each axis rounded down to an FFT-efficient length, with the excess taken
+    off the high end. Restoring it *centred* (what this used to do) moved
+    every voxel by excess // 2, measured as a 2 px y/x shift on real data:
+    invisible on a cell, glaring on a cilium a few voxels across.
     """
     from patchworks.plugins.dog import _restore_shape
 
     arr = np.arange(13 * 1020 * 1020, dtype="float32").reshape(13, 1020, 1020)
     out = _restore_shape(arr, (14, 1024, 1024))
     assert out.shape == (14, 1024, 1024)
-    # The original content is preserved, centred, not resampled.
-    assert np.array_equal(out[0:13, 2:1022, 2:1022], arr)
+    # Content keeps its original indices -- voxel 0 stays voxel 0.
+    assert np.array_equal(out[0:13, 0:1020, 0:1020], arr)
+
+
+def test_restore_shape_crops_from_the_high_end():
+    """The mirror case: an axis that came back too long keeps its low corner."""
+    from patchworks.plugins.dog import _restore_shape
+
+    arr = np.arange(6 * 12, dtype="float32").reshape(6, 12)
+    out = _restore_shape(arr, (4, 8))
+    assert out.shape == (4, 8)
+    assert np.array_equal(out, arr[0:4, 0:8])
 
 
 def test_restore_shape_handles_growth_and_exact_fit():

{patchworks-2.6.9 → patchworks-2.6.11}/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}
+        )