patchworks 3.1.0__tar.gz → 3.2.0__tar.gz

{patchworks-3.1.0 → patchworks-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: patchworks
-Version: 3.1.0
+Version: 3.2.0
 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
@@ -52,6 +52,8 @@ Requires-Dist: bioio-lif; extra == 'bioio'
 Requires-Dist: bioio-nd2; extra == 'bioio'
 Requires-Dist: bioio-ome-tiff; extra == 'bioio'
 Requires-Dist: bioio-tifffile; extra == 'bioio'
+Provides-Extra: careamics
+Requires-Dist: careamics>=0.3; extra == 'careamics'
 Provides-Extra: cellpose
 Requires-Dist: cellpose>=3.0; extra == 'cellpose'
 Provides-Extra: cellpose3
@@ -99,6 +101,7 @@ Requires-Dist: pandas>=2.0; extra == 'review'
 Provides-Extra: workflow
 Requires-Dist: openpyxl; extra == 'workflow'
 Requires-Dist: pandas>=2.0; extra == 'workflow'
+Requires-Dist: scikit-image; extra == 'workflow'
 Requires-Dist: snakemake-executor-plugin-slurm; extra == 'workflow'
 Requires-Dist: snakemake>=8; extra == 'workflow'
 Description-Content-Type: text/markdown
@@ -154,6 +157,7 @@ pip install "patchworks[cellpose]"  # Cellpose plugin (>=3.0, v3 or v4)
 pip install "patchworks[cellpose3]" # Cellpose plugin, pinned to v3.x
 pip install "patchworks[cellpose4]" # Cellpose plugin, pinned to v4+
 pip install "patchworks[dog]"       # deconvolution + DoG plugin (pycudadecon)
+pip install "patchworks[careamics]" # Noise2Void denoising before segmenting
 pip install "patchworks[bioio]"     # convert any image format to OME-ZARR
 pip install "patchworks[imaris]"    # convert Imaris .ims files to OME-ZARR
 pip install "patchworks[napari]"    # interactive napari viewer plugin
@@ -457,6 +461,13 @@ Optional:
 - `cellpose` — Cellpose plugin, v3 or v4 (`patchworks[cellpose]`);
   pin with `[cellpose3]` or `[cellpose4]`
 - `pycudadecon` — deconvolution step of the `dog` plugin (`patchworks[dog]`)
+- `careamics` — denoise tiles before segmenting them (Noise2Void),
+  `patchworks[careamics]`
+- `plant-seg` — PlantSeg plugin (boundary U-Net + GASP/multicut), from
+  conda-forge only (`conda install -c conda-forge plant-seg`, or the
+  workflow's `pixi install -e plantseg`). The nuclei-seeded watershed plugin
+  needs only scikit-image. See the
+  [membrane cells guide](https://imcf.one/patchworks/guide/membrane_cells/).
 - `bioio` + readers — convert CZI/LIF/ND2/OME-TIFF/… to OME-ZARR
   (`patchworks[bioio]`)
 - `imaris-ims-file-reader` — convert Imaris `.ims` (`patchworks[imaris]`)

{patchworks-3.1.0 → patchworks-3.2.0}/README.md

@@ -49,6 +49,7 @@ pip install "patchworks[cellpose]"  # Cellpose plugin (>=3.0, v3 or v4)
 pip install "patchworks[cellpose3]" # Cellpose plugin, pinned to v3.x
 pip install "patchworks[cellpose4]" # Cellpose plugin, pinned to v4+
 pip install "patchworks[dog]"       # deconvolution + DoG plugin (pycudadecon)
+pip install "patchworks[careamics]" # Noise2Void denoising before segmenting
 pip install "patchworks[bioio]"     # convert any image format to OME-ZARR
 pip install "patchworks[imaris]"    # convert Imaris .ims files to OME-ZARR
 pip install "patchworks[napari]"    # interactive napari viewer plugin
@@ -352,6 +353,13 @@ Optional:
 - `cellpose` — Cellpose plugin, v3 or v4 (`patchworks[cellpose]`);
   pin with `[cellpose3]` or `[cellpose4]`
 - `pycudadecon` — deconvolution step of the `dog` plugin (`patchworks[dog]`)
+- `careamics` — denoise tiles before segmenting them (Noise2Void),
+  `patchworks[careamics]`
+- `plant-seg` — PlantSeg plugin (boundary U-Net + GASP/multicut), from
+  conda-forge only (`conda install -c conda-forge plant-seg`, or the
+  workflow's `pixi install -e plantseg`). The nuclei-seeded watershed plugin
+  needs only scikit-image. See the
+  [membrane cells guide](https://imcf.one/patchworks/guide/membrane_cells/).
 - `bioio` + readers — convert CZI/LIF/ND2/OME-TIFF/… to OME-ZARR
   (`patchworks[bioio]`)
 - `imaris-ims-file-reader` — convert Imaris `.ims` (`patchworks[imaris]`)

patchworks-3.2.0/docs/api/plugins/careamics.md

@@ -0,0 +1,11 @@
+# CAREamics denoising plugin
+
+See [Denoising first](../../guide/membrane_cells.md#denoising-first-careamics).
+
+::: patchworks.plugins.careamics.denoise_fn
+
+::: patchworks.plugins.careamics.denoise
+
+::: patchworks.plugins.careamics.train_n2v
+
+::: patchworks.plugins.careamics.training_crops

patchworks-3.2.0/docs/api/plugins/plantseg.md

@@ -0,0 +1,11 @@
+# PlantSeg plugin
+
+See [Cells from a membrane stain](../../guide/membrane_cells.md#plantseg).
+
+::: patchworks.plugins.plantseg.plantseg_fn
+
+::: patchworks.plugins.plantseg.fetch_model
+
+::: patchworks.plugins.plantseg.available_models
+
+::: patchworks.plugins.plantseg.rescale_factors

patchworks-3.2.0/docs/api/plugins/watershed.md

@@ -0,0 +1,11 @@
+# Nuclei-seeded watershed plugin
+
+See [Cells from a membrane stain](../../guide/membrane_cells.md).
+
+::: patchworks.plugins.watershed.watershed_fn
+
+::: patchworks.plugins.watershed.nuclei_seeds
+
+::: patchworks.plugins.watershed.foreground_mask
+
+::: patchworks.plugins.watershed.seeded_watershed

{patchworks-3.1.0 → patchworks-3.2.0}/docs/guide/cli.md

@@ -46,7 +46,16 @@ gives a child touching no parent the nearest one. See
 | `custom` | any importable function | `--fn module:function`, `--fn-kwargs '{"k": 1}'` |
 
 Cellpose's anisotropy and the DoG plugin's voxel size are read from the
-store's own calibration, at the level being segmented.
+store's own calibration, at the level being segmented -- as is `voxel_size`
+for a custom function that takes one, such as the PlantSeg and watershed
+plugins: `--method custom --fn patchworks.plugins.plantseg:segment
+--fn-kwargs '{"segmentation": "gasp"}' --stitch iou` (`iou`: these fill
+space, so neighbouring cells touch at every seam).
+
+`--denoise MODEL` denoises every tile with a CAREamics model before any
+method segments it; `patchworks denoise-train STORE --channel 0 --out
+n2v.ckpt` trains one (Noise2Void, no ground truth). See
+[Cells from a membrane stain](membrane_cells.md).
 
 Tiling and stitching take the same options as
 [`tile_process`](../api/tile_process.md): `--tile-shape` (`z,y,x`, `auto` or

{patchworks-3.1.0 → patchworks-3.2.0}/docs/guide/custom_segmentation.md

@@ -29,6 +29,14 @@ That is the whole interface. Anything that turns an image tile into a label
 image works: classic image processing, StarDist, a trained model, an external
 binary you shell out to, …
 
+Ready-made ones ship with patchworks: `patchworks.plugins.dog` (spots,
+cilia), and for cells from a membrane stain `patchworks.plugins.watershed`
+(nuclei-seeded watershed) and `patchworks.plugins.plantseg` (PlantSeg) --
+see [Cells from a membrane stain](membrane_cells.md). With
+`nuclei_channel` set, the tile is `(2, z, y, x)`: `[channel,
+nuclei_channel]` on the first axis. Any method can also run on
+[denoised tiles](membrane_cells.md#denoising-first-careamics).
+
 ## Minimal example (no GPU, no deps beyond scikit-image)
 
 ```python

patchworks-3.2.0/docs/guide/membrane_cells.md

@@ -0,0 +1,253 @@
+# Cells from a membrane stain
+
+Epithelia, organoids and tissues are often imaged with a **membrane** (or
+cortex) marker plus a **nuclear** dye. Cellpose struggles there in a
+recognisable way: Cellpose 4 (`cpsam`) reads every channel it is given
+without a "cytoplasm" or "nucleus" role, so with a bright nuclear channel
+next to a faint membrane it segments the **nuclei**; and on the membrane
+alone, a wall that is faint in places merges two cells. Patchworks ships
+three plugins for this case, plus an optional denoising step in front of any
+method.
+
+| | Needs | Cells come from | Best when |
+| --- | --- | --- | --- |
+| [Nuclei-seeded watershed](#nuclei-seeded-watershed) | scikit-image | the membrane, flooded from the nuclei | every cell has one nucleus; start here |
+| [PlantSeg](#plantseg) | `plant-seg` (conda-forge) | a boundary U-Net, then GASP / multicut | the membrane is uneven or noisy |
+| [PlantSeg + nuclei](#plantseg) | same | the U-Net's boundaries and the nuclei | both of the above |
+| Cellpose, membrane only | cellpose | Cellpose | `nuclei_channel: null`, `do_3D: true` |
+| [Denoising first](#denoising-first-careamics) | `careamics` | any of these, on denoised tiles | noisy acquisitions |
+
+All of them are ordinary [custom functions](custom_segmentation.md): one
+config block, the same tiling, merge, tables and review as any other run.
+
+## Nuclei-seeded watershed
+
+The nuclei are the easy part of the image: bright, compact, separated. They
+say how many cells there are and where; flooding the membrane image from
+them grows each nucleus out to its cell's walls. A cell can then not be
+split (one seed each) or merged with its neighbour (two seeds never join),
+even across a gap in the wall.
+
+```yaml
+channel: 0              # membrane
+nuclei_channel: 1       # stacked onto each tile as [membrane, nuclei]
+method: "custom"
+label_name: "cyto_labels"
+stitch: "iou"           # required: see below
+custom:
+  module: "patchworks.plugins.watershed"
+  kwargs:
+    nuclei_min_size: 200    # voxels: specks smaller than a nucleus
+    foreground: "otsu"      # stop at the tissue edge
+    # max_radius_um: 15     # or: no further than this from the nucleus
+    # nuclei_threshold: 800 # intensity, if Otsu misses dim nuclei
+```
+
+`stitch: "iou"` is required with this plugin and with PlantSeg, and
+`prepare` refuses the config without it. They give every voxel to some
+cell, so neighbouring cells touch at every tile seam, and the default
+`"touch"` stitching would join each such pair: on a test grid of 12 cells
+cut by six tiles, 5 came out. `"iou"` joins two pieces only where both tiles
+agree on their overlap, and gives the 12. (From the command line, pass
+`--stitch iou` yourself: nothing checks it there.)
+
+Two nuclei touching each other give one seed, so one cell for two: raise
+`nuclei_threshold` if that happens -- or grow the cells from nuclei you have
+already segmented, with `seed_labels` instead of `nuclei_channel` (see
+[the example below](#how-seed_labels-works)). Each tile's halo (`overlap`) must hold a
+whole cell, as for any method.
+
+## PlantSeg
+
+[PlantSeg](https://github.com/kreshuklab/plant-seg) predicts cell
+boundaries with a 3-D U-Net trained on membrane stains, then partitions the
+boundary map into cells (supervoxels by a distance-transform watershed,
+merged by GASP, mutex watershed or multicut). A wall the U-Net sees at all
+gets closed by the partitioning, where Cellpose would merge across it.
+
+PlantSeg is on conda-forge only, so it has its own pixi environment:
+
+```bash
+pixi install -e plantseg
+pixi run -e plantseg plantseg-fetch generic_confocal_3D_unet   # once, with internet
+pixi run -e plantseg multi-slurm
+```
+
+```yaml
+method: "custom"
+stitch: "iou"                           # required, as for the watershed
+custom:
+  module: "patchworks.plugins.plantseg"
+  kwargs:
+    model: "generic_confocal_3D_unet"   # or generic_light_sheet_3D_unet, ...
+    segmentation: "gasp"                # gasp | mutex_ws | multicut | dt_watershed
+    beta: 0.6                           # lower merges more, higher splits more
+    foreground: "otsu"                  # a boundary U-Net puts cells everywhere
+```
+
+With `nuclei_channel` set, two more `segmentation` modes use the nuclei:
+
+- `"nuclei_watershed"` -- the U-Net's boundary map flooded from the nuclei:
+  the watershed above, on a much cleaner boundary image.
+- `"lifted_multicut"` -- PlantSeg's lifted multicut: supervoxels in one
+  nucleus pulled together, in different nuclei pushed apart.
+
+Each tile is resampled to the voxel size the model was trained at (from the
+image's own calibration, `rescale: true`), which matters more than any other
+setting for a pretrained U-Net; the prediction is resampled back.
+
+## Example: Cellpose nuclei + PlantSeg cells in one run
+
+The workflow ships this pairing ready to edit: Cellpose segments the nuclei,
+then PlantSeg grows the cells from **exactly those nuclei** -- one cell per
+nucleus Cellpose found -- and the two are related. Three files, next to
+`config/multi.yaml`:
+
+```yaml
+# config/multi_plantseg.yaml
+common: config/common.yaml           # input, work_dir, tile_shape, level: shared
+
+segmentations:
+- config/config_nuclei.yaml          # Cellpose "nuclei" model on channel 1
+- config/config_cyto_plantseg.yaml   # PlantSeg on channel 0, seeded by nuclei_labels
+
+relations:
+- a: nuclei_labels
+  b: cyto_labels
+  output: nuclei_to_cyto.xlsx
+
+review:                              # a sanity check: one nucleus per cell
+  expect:
+    cyto_labels:
+      nuclei_labels: 1
+```
+
+```yaml
+# config/config_nuclei.yaml (unchanged)
+channel: 1
+overlap: [4, 30, 30]
+method: "cellpose"
+label_name: "nuclei_labels"
+cellpose:
+  model: "nuclei"
+  diameter: 15
+  do_3D: true
+  gpu: true
+```
+
+```yaml
+# config/config_cyto_plantseg.yaml
+channel: 0                  # membrane
+seed_labels: "nuclei_labels" # each tile becomes [membrane, nuclei labels]
+overlap: [4, 40, 40]        # the halo must hold a whole cell
+stitch: "iou"               # cells touch at every seam: join on agreement only
+method: "custom"
+label_name: "cyto_labels"
+custom:
+  module: "patchworks.plugins.plantseg"
+  function: "segment"
+  kwargs:
+    model: "generic_confocal_3D_unet"   # generic_light_sheet_3D_unet for light-sheet
+    segmentation: "nuclei_watershed"    # U-Net boundaries flooded from the nuclei
+    foreground: "otsu"                  # keep the tissue only
+    # max_radius_um: 15
+```
+
+Set `input` and `work_dir` in `config/common.yaml`, then, from `workflow/`:
+
+```bash
+pixi install -e plantseg
+pixi run -e plantseg plantseg-fetch generic_confocal_3D_unet   # once, with internet
+pixi run -e plantseg multi-plantseg-dry                        # check the plan
+pixi run -e plantseg multi-plantseg-slurm                      # submit
+```
+
+The `plantseg` environment is the default one plus PlantSeg, so the
+Cellpose run comes from it too. Afterwards, `nuclei_to_cyto.xlsx` gives
+each nucleus its cell, and `pixi run -e viewer review <work_dir>/image.zarr`
+lists any cell not holding exactly one nucleus.
+
+### How `seed_labels` works
+
+- **Order.** `run_multi` starts the cells' config only once the config
+  producing `nuclei_labels` has finished; everything else listed (cilia,
+  say) runs alongside. If the nuclei fail, the cells are skipped, not run
+  without seeds. Two configs seeding each other are refused up front. A
+  dry run (`-n`) waits for nothing.
+- **Tiles.** The nuclei label image is stacked onto the membrane as each
+  tile's second channel, halo included, so neighbouring tiles see the same
+  nuclei and a cell crossing a seam is grown from the same nucleus on both
+  sides. Both runs must use the same `level`, which `run_multi` already
+  enforces; the plugin is told `seeds: "labels"` automatically.
+- **Seeds as given.** Two touching nuclei that Cellpose split stay two
+  cells; a dim nucleus Cellpose found still gets its cell. Cellpose's
+  mistakes carry over the same way: a nucleus split in two makes two
+  cells. Correcting the nuclei first (`patchworks review`, then
+  `--write-labels nuclei_labels` and `seed_labels: nuclei_labels_reviewed`)
+  gives the cells the corrected nuclei.
+- **On its own**, outside `run_multi`, the cells' config needs
+  `labels/nuclei_labels` already in `image.zarr`: `prepare` checks, and
+  stops with a message rather than segmenting without seeds.
+- **Re-segmenting the nuclei** does not re-run the cells by itself: delete
+  `<work_dir>/cyto_labels` and `image.zarr/labels/cyto_labels` to grow them
+  again from the new nuclei.
+
+`nuclei_channel: 1` instead of `seed_labels` makes the plugin find the
+nuclei itself, in the nuclear stain (Otsu per tile, `nuclei_*` options),
+independently of Cellpose -- both segmentations then run at the same time.
+
+Without PlantSeg, the same works with the plain
+[nuclei-seeded watershed](#nuclei-seeded-watershed): set `module:
+"patchworks.plugins.watershed"` with only the `foreground` and
+`max_radius_um` keys, and use the default environment (`pixi run
+multi-slurm` with this pair listed in `config/multi.yaml`).
+
+## Cellpose: membrane only, in 3-D
+
+If you stay with Cellpose on such images:
+
+- Give it **only the membrane** (`nuclei_channel: null`): `cpsam` then has
+  nothing brighter to lock onto.
+- `do_3D: true` combines the three orthogonal views, so a wall faint in one
+  plane is found in the others. `stitch_threshold` instead joins
+  independent 2-D masks across z and fixes nothing in the masks
+  themselves. A GPU (`gpu: true`) only changes the speed.
+
+## Denoising first (CAREamics)
+
+Noise breaks segmentations: a wall lost in the noise merges two cells.
+[Noise2Void](https://careamics.github.io) learns to remove the noise from
+the image itself (no clean ground truth, no annotation), so a model trained
+once on a few crops of the store denoises every tile before any method sees
+it.
+
+```bash
+pixi install -e careamics
+# on a GPU node: the brightest crops of the channel, ~30 epochs
+pixi run -e careamics denoise-train <work_dir>/image.zarr --channel 0 --out n2v_membrane.ckpt
+pixi run -e careamics denoise-train <work_dir>/image.zarr --channel 1 --out n2v_nuclei.ckpt
+```
+
+then, in the segmentation config, with any `method`:
+
+```yaml
+denoise:
+  model: "/path/to/n2v_membrane.ckpt"      # .ckpt, or a BioImage.IO .zip
+  nuclei_model: "/path/to/n2v_nuclei.ckpt" # optional, for nuclei_channel
+  # tile_size: [16, 256, 256]              # CAREamics' tiling inside a tile (VRAM)
+```
+
+and run from the `careamics` environment (`plantseg-careamics` for both).
+The model paths are checked during `prepare`; the denoised image is not
+stored, only used for segmenting. From the command line, `patchworks segment
+... --denoise n2v_membrane.ckpt` does the same.
+
+Look at a denoised tile before a full run:
+
+```python
+from patchworks import load_ome_zarr
+from patchworks.plugins.careamics import denoise
+
+tile = load_ome_zarr("image.zarr", channel=0)[20:44, 1000:1512, 1000:1512]
+clean = denoise(tile.compute(), model="n2v_membrane.ckpt")
+```

{patchworks-3.1.0 → patchworks-3.2.0}/docs/guide/snakemake.md

@@ -696,6 +696,14 @@ cellpose:
 usually improves cytoplasm segmentation. Both indices are 0-based, like
 `channel`.
 
+!!! tip "Cellpose 4 and a bright nuclear channel"
+
+    `cpsam` gives the two channels no roles, so next to a faint membrane it
+    may segment the nuclei instead of the cells. Give it the membrane alone
+    (`nuclei_channel: null`), or use the nuclei the other way round: as
+    seeds, with the nuclei-seeded watershed or PlantSeg plugins. See
+    [Cells from a membrane stain](membrane_cells.md).
+
 Only the `segment` step reads it. The pair is stacked on a leading axis that
 is *carried* into each tile rather than tiled, so the tile geometry, the
 occupancy map and the staged labels are byte-for-byte what a single-channel
@@ -833,6 +841,11 @@ relations:
     output: nuclei_to_cyto.xlsx # written into work_dir
 ```
 
+A second example, `config/multi_plantseg.yaml`, pairs Cellpose nuclei with
+PlantSeg cells seeded from the nuclei (`pixi run -e plantseg
+multi-plantseg-slurm`); see [Cells from a membrane
+stain](membrane_cells.md#example-cellpose-nuclei-plantseg-cells-in-one-run).
+
 `common:` is optional — leave it out and each config must be self-contained,
 as before. With it, changing the input path or turning on `shard` is a
 one-line edit in one file instead of the same edit repeated per config.
@@ -1075,6 +1088,11 @@ pixi run go           # run locally (8 cores)
 pixi run slurm        # submit to SLURM (edit profile/slurm/config.yaml first)
 ```
 
+Optional environments add methods: `-e plantseg` (PlantSeg, from
+conda-forge), `-e careamics` (the `denoise:` step and `pixi run denoise-train`),
+`-e plantseg-careamics` for both -- see
+[Cells from a membrane stain](membrane_cells.md).
+
 `pixi run …` activates the env, so the rule scripts execute in that env — do
 **not** pass `--use-conda`. On a cluster, keep the `workflow/` directory on a
 shared filesystem the compute nodes can read: the SLURM executor re-launches

{patchworks-3.1.0 → patchworks-3.2.0}/mkdocs.yml

@@ -42,6 +42,7 @@ nav:
   - GPU & distributed: guide/gpu_distributed.md
   - Performance & memory: guide/performance.md
   - Custom segmentation function: guide/custom_segmentation.md
+  - Cells from a membrane stain: guide/membrane_cells.md
   - Relating labels across segmentations: guide/label_relations.md
   - Reviewing and correcting results: guide/review.md
   - Measurements: guide/measurements.md
@@ -72,6 +73,9 @@ nav:
   - Plugins:
     - Cellpose: api/plugins/cellpose.md
     - Difference of Gaussians: api/plugins/dog.md
+    - Nuclei-seeded watershed: api/plugins/watershed.md
+    - PlantSeg: api/plugins/plantseg.md
+    - CAREamics denoising: api/plugins/careamics.md
     - OME-ZARR conversion: api/plugins/ome_zarr.md
     - napari viewer: api/plugins/napari.md
 

{patchworks-3.1.0 → patchworks-3.2.0}/pyproject.toml

@@ -59,6 +59,11 @@ cellpose4 = ["cellpose>=4"]
 # path, isn't included here — it's CUDA-version-specific (e.g.
 # cupy-cuda12x), install it separately to match your CUDA version.
 dog = ["pycudadecon"]
+# careamics: Noise2Void denoising before segmentation (patchworks.plugins.
+# careamics, the workflow's `denoise:` step, `patchworks denoise-train`).
+# Brings PyTorch. PlantSeg (patchworks.plugins.plantseg) has no extra: it is
+# on conda-forge only (`plant-seg`; the workflow's `-e plantseg`).
+careamics = ["careamics>=0.3"]
 gpu = ["nvidia-ml-py"]
 # remote reads/writes s3://, gs:// and https:// stores through fsspec
 # (credentials come from the usual AWS/GCP environment or config files).
@@ -117,6 +122,8 @@ workflow = [
     "snakemake-executor-plugin-slurm",
     "openpyxl",
     "pandas>=2.0",
+    # method: "threshold" and the nuclei-seeded watershed plugin
+    "scikit-image",
 ]
 # review: the object tables' corrected view and exports, without napari
 # (`patchworks review --summary/--export`). The napari panel needs [napari].

{patchworks-3.1.0 → patchworks-3.2.0}/src/patchworks/cli.py

@@ -14,6 +14,7 @@ from __future__ import annotations
 
 import argparse
 import importlib
+import inspect
 import json
 import logging
 import sys
@@ -111,6 +112,15 @@ def _build_fn(args: argparse.Namespace, image: Any) -> Callable:
     module, _, name = args.fn.partition(":")
     fn = getattr(importlib.import_module(module), name or "segment")
     kwargs = json.loads(args.fn_kwargs) if args.fn_kwargs else {}
+    # A function asking for voxel_size gets the store's calibration (as in
+    # the workflow); a **kwargs passthrough names its real target.
+    target = getattr(fn, "patchworks_kwargs_target", fn)
+    try:
+        takes_voxel = "voxel_size" in inspect.signature(target).parameters
+    except (TypeError, ValueError):
+        takes_voxel = False
+    if takes_voxel and voxel and "voxel_size" not in kwargs:
+        kwargs["voxel_size"] = voxel
     return partial(fn, **kwargs) if kwargs else fn
 
 
@@ -143,6 +153,10 @@ def _cmd_segment(args: argparse.Namespace) -> int:
         raise SystemExit("--method custom needs --fn module:function")
     image = load_ome_zarr(args.image, channel=args.channel, level=args.level)
     fn = _build_fn(args, image)
+    if args.denoise:
+        from .plugins.careamics import denoise_fn
+
+        fn = denoise_fn(fn, args.denoise)
     tile_shape: Any = args.tile_shape
     if tile_shape not in (None, "auto"):
         tile_shape = _ints(tile_shape)
@@ -353,6 +367,25 @@ def _cmd_review(args: argparse.Namespace) -> int:
     return 0
 
 
+def _cmd_denoise_train(args: argparse.Namespace) -> int:
+    from .plugins.careamics import train_n2v
+
+    out = train_n2v(
+        args.image,
+        args.out,
+        channel=args.channel,
+        level=args.level,
+        crop_shape=args.crop_shape,
+        n_crops=args.crops,
+        patch_size=args.patch_size,
+        batch_size=args.batch_size,
+        epochs=args.epochs,
+        n2v2=args.n2v2,
+    )
+    print(out)
+    return 0
+
+
 def build_parser() -> argparse.ArgumentParser:
     """The ``patchworks`` argument parser (exposed for tests and docs)."""
     parser = argparse.ArgumentParser(
@@ -463,8 +496,40 @@ def build_parser() -> argparse.ArgumentParser:
     g = p.add_argument_group("custom")
     g.add_argument("--fn", help="module:function returning labels")
     g.add_argument("--fn-kwargs", help="JSON object of keyword arguments")
+    p.add_argument(
+        "--denoise",
+        metavar="MODEL",
+        help="denoise each tile with this CAREamics model (.ckpt or .zip) "
+        "before segmenting it; see `patchworks denoise-train`",
+    )
     p.set_defaults(func=_cmd_segment)
 
+    p = sub.add_parser(
+        "denoise-train",
+        help="train a Noise2Void denoiser on a store (CAREamics)",
+        description="Train a Noise2Void model on the brightest crops of one "
+        "channel -- no ground truth needed -- for `segment --denoise` or the "
+        "workflow's denoise: block. Run it on a GPU node.",
+    )
+    p.add_argument("image", help="OME-ZARR store")
+    p.add_argument("--out", required=True, help="checkpoint to write (.ckpt)")
+    p.add_argument("--channel", type=int, default=0)
+    p.add_argument("--level", type=int, default=0, help="pyramid level")
+    p.add_argument(
+        "--crop-shape",
+        type=_ints,
+        default=(32, 512, 512),
+        help="z,y,x of each training crop (default 32,512,512)",
+    )
+    p.add_argument("--crops", type=int, default=4, help="how many crops")
+    p.add_argument(
+        "--patch-size", type=_ints, help="training patch (default 16,64,64)"
+    )
+    p.add_argument("--batch-size", type=int, default=8)
+    p.add_argument("--epochs", type=int, default=30)
+    p.add_argument("--n2v2", action="store_true", help="use Noise2Void2")
+    p.set_defaults(func=_cmd_denoise_train)
+
     p = sub.add_parser("seams", help="does the tiling show in the labels?")
     p.add_argument("labels", help="label group (or any zarr group)")
     p.add_argument("--tile-shape", type=_ints, required=True)