docs: 📝 document dilate_labels, API and cluster config usage

Adds an API reference page, a cluster-workflow guide section covering
both the dilate: N config key and calling dilate_labels() directly, and
a DoG-specific example since thin cilia/spot labels are the motivating
case.

Author: lguerard

docs/api/postprocess.md

@@ -0,0 +1,3 @@
+# dilate_labels
+
+::: patchworks.dilate_labels

docs/examples/dog.md

@@ -81,6 +81,24 @@ result = tile_process(IMAGE, fn, tile_shape=(1, 1024, 1024), overlap=32)
     so edge tiles keep enough context (a plain intensity/threshold halo is
     too thin).
 
+## Growing the labels afterwards
+
+DoG spots/threads are often thin — grow each label by a few pixels with
+[`dilate_labels`](../api/postprocess.md):
+
+```python
+from patchworks import tile_process, dilate_labels
+from patchworks.plugins.dog import dog_label_fn
+
+fn = dog_label_fn(low_sigma=1.0, high_sigma=3.0, threshold=0.02)
+fn = dilate_labels(fn, iterations=2)
+tile_process(IMAGE, fn, tile_shape=(1, 1024, 1024), overlap=8, write_to=OUTPUT)
+```
+
+On the cluster, set `dilate: 2` in the YAML config instead — it applies to
+`method: "custom"` (this plugin) the same way it does for `cellpose`/
+`threshold`, see [Growing labels after segmentation](../guide/snakemake.md#growing-labels-afterwards-dilation).
+
 ## Using it in the Snakemake workflow
 
 No dedicated wiring needed — `patchworks.plugins.dog` exposes a `segment(tile, **kwargs)`

docs/guide/snakemake.md

@@ -62,8 +62,9 @@ skip_empty: true               # skip background tiles
 empty_threshold: null          # null → Otsu
 
 # segmentation
-method: "cellpose"             # "cellpose" (GPU) or "threshold" (no GPU)
+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
 cellpose:
   model: "cyto3"
   diameter: 30
@@ -77,6 +78,18 @@ pyramid_downscale: 2
 sequential_labels: true        # renumber labels to a contiguous 1..N
 ```
 
+!!! tip "Growing labels after segmentation"
+    `dilate: N` grows every label by `N` pixels once segmentation finishes,
+    regardless of `method` (`cellpose`, `threshold`, or `custom`). It runs
+    per-tile, before the overlap halo is trimmed and tiles are merged, so
+    dilated labels still stitch correctly across tile boundaries — just make
+    sure `overlap` covers the dilation amount plus the usual object-diameter
+    halo. `0` (default) disables it. Under the hood this wraps whatever
+    segmentation function `method` builds with
+    [`patchworks.dilate_labels`](../api/postprocess.md); see [Custom
+    segmentation function](#custom-segmentation-function) below for using it
+    directly from Python instead of via config.
+
 !!! 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
@@ -433,6 +446,29 @@ custom:
     sigma: 1.5
 ```
 
+### Growing labels afterwards (dilation)
+
+To grow every label by a few pixels after segmentation — any method, not
+just `custom` — set `dilate: N` in the config (see the tip above), or wrap
+your function directly with
+[`patchworks.dilate_labels`](../api/postprocess.md) when calling the API
+yourself:
+
+```python
+from patchworks import tile_process, dilate_labels
+from patchworks.plugins.dog import dog_label_fn
+
+fn = dog_label_fn(low_sigma=1.0, high_sigma=3.0, threshold=0.02)
+fn = dilate_labels(fn, iterations=2)   # grow each label by 2 px, then run
+result = tile_process("image.zarr", fn, tile_shape=(1, 2048, 2048),
+                       overlap=8, write_to="labels.zarr")
+```
+
+`dilate_labels` wraps any `(tile) -> labels` function — the same contract
+described above — so it works with `dog_label_fn`, `cellpose_fn`, or your
+own `segment`. It dilates each tile's labels before the halo is trimmed and
+tiles are merged, so `overlap` must still cover the dilation amount.
+
 ### Real example: StarDist 3-D, with model caching
 
 Heavy models must be loaded **once**, not per tile. On SLURM each tile is its

mkdocs.yml

@@ -54,6 +54,7 @@ nav:
 - API Reference:
   - tile_process: api/tile_process.md
   - merge_tile_labels: api/merge_tile_labels.md
+  - dilate_labels: api/postprocess.md
   - Tile sizing: api/chunks.md
   - I/O helpers: api/io.md
   - Relabelling: api/relabel.md