patchworks 2.8.0__tar.gz → 3.0.0__tar.gz

patchworks-3.0.0/.github/min-versions.txt

@@ -0,0 +1,6 @@
+# Oldest releases patchworks claims to support (pyproject floors).
+# The "minimum versions" CI job installs against these.
+dask==2024.10.0
+numpy==1.26.0
+zarr==3.1.3
+scipy==1.11.1

patchworks-3.0.0/.github/workflows/lint.yml

@@ -0,0 +1,69 @@
+name: Lint
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+jobs:
+  ruff:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: ruff check
+        uses: astral-sh/ruff-action@v3
+        with:
+          version: "0.15.18"
+          args: "check"
+
+      - name: ruff format --check
+        uses: astral-sh/ruff-action@v3
+        with:
+          version: "0.15.18"
+          args: "format --check"
+
+  markdownlint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: markdownlint
+        uses: DavidAnson/markdownlint-cli2-action@v20
+        with:
+          globs: "**/*.md"
+
+  docs:
+    # The deploy workflow only runs on main; catch a broken reference or a
+    # docstring mkdocstrings cannot render before it gets there.
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: pip
+
+      - name: Install docs dependencies
+        run: pip install "mkdocs-material>=9.0" "mkdocstrings[python]>=0.24" .
+
+      - name: mkdocs build --strict
+        run: mkdocs build --strict
+
+  mypy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: pip
+
+      - name: Install
+        run: pip install -e ".[dev]"
+
+      - name: mypy (config in pyproject.toml)
+        run: mypy

patchworks-3.0.0/.github/workflows/test.yml

@@ -0,0 +1,110 @@
+name: Tests
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+jobs:
+  pytest:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        # The floor (requires-python) and the newest release.
+        python-version: ["3.11", "3.12", "3.13", "3.14"]
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: pip
+
+      - name: Install
+        run: pip install -e ".[dev]"
+
+      - name: pytest
+        run: pytest -q
+
+      - name: docstring examples
+        run: pytest -q --doctest-modules src
+
+  other-platforms:
+    # Not yet verified on macOS or Windows (no CI ran there before), so this
+    # job reports without failing the build; promote it into the matrix
+    # above once it is green.
+    runs-on: ${{ matrix.os }}
+    continue-on-error: true
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [macos-latest, windows-latest]
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: pip
+
+      - name: Install
+        run: pip install -e ".[dev]"
+
+      - name: pytest
+        run: pytest -q
+
+  minimum-versions:
+    # The pyproject floors are only true if something runs on them.
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+          cache: pip
+
+      - name: Install at the declared minimums
+        run: pip install -e ".[dev]" -c .github/min-versions.txt
+
+      - name: pytest
+        run: pytest -q
+
+  benchmarks:
+    # Head vs base on the same runner, reported in the job summary with a
+    # warning per case >25% slower. Never fails the build: shared runners
+    # are too noisy for a hard gate.
+    if: github.event_name == 'pull_request'
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: pip
+
+      - name: Benchmark the pull request
+        run: |
+          cp -r benchmarks "$RUNNER_TEMP/bench"
+          pip install -e .
+          python "$RUNNER_TEMP/bench/bench.py" "$RUNNER_TEMP/head.json"
+
+      - name: Benchmark the base branch
+        run: |
+          git worktree add "$RUNNER_TEMP/base" "origin/${{ github.base_ref }}"
+          python -m venv "$RUNNER_TEMP/venv-base"
+          "$RUNNER_TEMP/venv-base/bin/pip" install "$RUNNER_TEMP/base"
+          "$RUNNER_TEMP/venv-base/bin/python" "$RUNNER_TEMP/bench/bench.py" \
+            "$RUNNER_TEMP/base.json"
+
+      - name: Compare
+        run: |
+          python "$RUNNER_TEMP/bench/compare.py" \
+            "$RUNNER_TEMP/base.json" "$RUNNER_TEMP/head.json" \
+            | tee -a "$GITHUB_STEP_SUMMARY"

patchworks-3.0.0/.pre-commit-config.yaml

@@ -0,0 +1,11 @@
+# Same checks as .github/workflows/lint.yml, at the same versions.
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.15.18
+    hooks:
+      - id: ruff-check
+      - id: ruff-format
+  - repo: https://github.com/DavidAnson/markdownlint-cli2
+    rev: v0.18.1
+    hooks:
+      - id: markdownlint-cli2

{patchworks-2.8.0 → patchworks-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: patchworks
-Version: 2.8.0
+Version: 3.0.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
@@ -8,20 +8,21 @@ Author-email: Laurent Guerard <laurent.guerard@unibas.ch>
 License: GPL-3.0-only
 License-File: LICENSE
 Keywords: bioimage,chunked,dask,image processing,segmentation,tiling,zarr
-Classifier: Development Status :: 5 - Production/Stable
+Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering :: Image Processing
-Requires-Python: >=3.9
-Requires-Dist: dask[array]>=2023.1.0
-Requires-Dist: numpy>=1.24
-Requires-Dist: scipy>=1.9
-Requires-Dist: zarr>=2.14
+Requires-Python: >=3.11
+Requires-Dist: dask[array]>=2024.10.0
+Requires-Dist: numpy>=1.26
+Requires-Dist: psutil
+Requires-Dist: scipy>=1.11
+Requires-Dist: zarr>=3.1.3
 Provides-Extra: all
 Requires-Dist: bioio; extra == 'all'
 Requires-Dist: bioio-bioformats; extra == 'all'
@@ -30,6 +31,7 @@ Requires-Dist: bioio-lif; extra == 'all'
 Requires-Dist: bioio-nd2; extra == 'all'
 Requires-Dist: bioio-ome-tiff; extra == 'all'
 Requires-Dist: bioio-tifffile; extra == 'all'
+Requires-Dist: dask[diagnostics,distributed]; extra == 'all'
 Requires-Dist: glasbey; extra == 'all'
 Requires-Dist: imaris-ims-file-reader; extra == 'all'
 Requires-Dist: ipykernel<7; extra == 'all'
@@ -58,11 +60,16 @@ Provides-Extra: cellpose4
 Requires-Dist: cellpose>=4; extra == 'cellpose4'
 Provides-Extra: dev
 Requires-Dist: jsonschema>=4.18; extra == 'dev'
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: openpyxl; extra == 'dev'
 Requires-Dist: psutil; extra == 'dev'
 Requires-Dist: pytest; extra == 'dev'
 Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: ruff==0.15.18; extra == 'dev'
 Requires-Dist: scikit-image; extra == 'dev'
 Requires-Dist: tqdm; extra == 'dev'
+Provides-Extra: distributed
+Requires-Dist: dask[diagnostics,distributed]; extra == 'distributed'
 Provides-Extra: docs
 Requires-Dist: mkdocs-material>=9.0; extra == 'docs'
 Requires-Dist: mkdocstrings[python]>=0.24; extra == 'docs'
@@ -83,6 +90,8 @@ Requires-Dist: napari-chunked-regionprops>=0.1.0; extra == 'napari'
 Requires-Dist: napari[all]>=0.7.1; extra == 'napari'
 Requires-Dist: numpy<2.5; extra == 'napari'
 Requires-Dist: pyqt6<6.10; extra == 'napari'
+Provides-Extra: remote
+Requires-Dist: fsspec[gcs,http,s3]; extra == 'remote'
 Provides-Extra: workflow
 Requires-Dist: openpyxl; extra == 'workflow'
 Requires-Dist: snakemake-executor-plugin-slurm; extra == 'workflow'
@@ -135,6 +144,7 @@ Optional extras:
 
 ```bash
 pip install "patchworks[gpu]"       # GPU VRAM querying (nvidia-ml-py)
+pip install "patchworks[distributed]" # Dask cluster + live dashboard
 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+
@@ -276,6 +286,18 @@ from disk, so terabyte volumes convert in bounded RAM. See the
 
 ---
 
+## From the command line
+
+```bash
+patchworks convert scan.czi scan.zarr
+patchworks segment scan.zarr --method cellpose --model cyto3 --diameter 30 --gpu
+patchworks info scan.zarr
+patchworks view scan.zarr
+```
+
+See [Command line](https://imcf.one/patchworks/guide/cli/) for every method
+and flag.
+
 ## Common patterns
 
 ### Auto-size tiles from available memory
@@ -409,12 +431,12 @@ Full docs, guides and tutorials: **<https://imcf.one/patchworks/>**
 
 ## Requirements
 
-- Python ≥ 3.9
-- dask[array], numpy, zarr, scipy
+- Python ≥ 3.11
+- dask[array], numpy, zarr ≥ 3.1.3, scipy, psutil (RAM-aware tile and worker
+  sizing)
 
 Optional:
 
-- `psutil` — accurate RAM sizing for `tile_shape="auto"`
 - `nvidia-ml-py` — accurate GPU VRAM sizing
 - `tqdm` — progress bars
 - `cellpose` — Cellpose plugin, v3 or v4 (`patchworks[cellpose]`);

{patchworks-2.8.0 → patchworks-3.0.0}/README.md

@@ -44,6 +44,7 @@ Optional extras:
 
 ```bash
 pip install "patchworks[gpu]"       # GPU VRAM querying (nvidia-ml-py)
+pip install "patchworks[distributed]" # Dask cluster + live dashboard
 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+
@@ -185,6 +186,18 @@ from disk, so terabyte volumes convert in bounded RAM. See the
 
 ---
 
+## From the command line
+
+```bash
+patchworks convert scan.czi scan.zarr
+patchworks segment scan.zarr --method cellpose --model cyto3 --diameter 30 --gpu
+patchworks info scan.zarr
+patchworks view scan.zarr
+```
+
+See [Command line](https://imcf.one/patchworks/guide/cli/) for every method
+and flag.
+
 ## Common patterns
 
 ### Auto-size tiles from available memory
@@ -318,12 +331,12 @@ Full docs, guides and tutorials: **<https://imcf.one/patchworks/>**
 
 ## Requirements
 
-- Python ≥ 3.9
-- dask[array], numpy, zarr, scipy
+- Python ≥ 3.11
+- dask[array], numpy, zarr ≥ 3.1.3, scipy, psutil (RAM-aware tile and worker
+  sizing)
 
 Optional:
 
-- `psutil` — accurate RAM sizing for `tile_shape="auto"`
 - `nvidia-ml-py` — accurate GPU VRAM sizing
 - `tqdm` — progress bars
 - `cellpose` — Cellpose plugin, v3 or v4 (`patchworks[cellpose]`);

patchworks-3.0.0/benchmarks/bench.py

@@ -0,0 +1,186 @@
+"""Timing benchmarks for patchworks' hot paths.
+
+    python benchmarks/bench.py out.json          # run, write JSON
+    python benchmarks/compare.py base.json head.json
+
+Each case runs a few times on synthetic but realistic data and keeps the
+fastest run (the least disturbed by a noisy machine). A case the installed
+patchworks cannot run (e.g. a feature newer than a base branch) is recorded
+as null, so a head/base comparison still works across such changes.
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+import sys
+import tempfile
+import time
+from pathlib import Path
+
+import numpy as np
+import zarr
+
+REPEATS = 3
+
+
+def _blob_labels(shape, n, seed=0, r=4):
+    """Many small blobs, labelled per tile as a stage store holds them."""
+    from scipy import ndimage as ndi
+
+    rng = np.random.default_rng(seed)
+    mask = np.zeros(shape, bool)
+    radii = np.array([max(1, min(r, (d - 1) // 2)) for d in shape])
+    centres = rng.integers(radii, np.array(shape) - radii, (n, len(shape)))
+    for c in centres:
+        mask[tuple(slice(x - q, x + q) for x, q in zip(c, radii))] = True
+    return ndi.label(mask)[0].astype("int32")
+
+
+def _staged(tmp, shape=(8, 1024, 1024), tile=(8, 256, 256), n=4000):
+    """A stage store: dense 1..n ids per tile, plus each tile's count."""
+    lab = _blob_labels(shape, n)
+    path = str(tmp / "stage.zarr")
+    arr = zarr.open_group(path, mode="w").create_array(
+        "staged", shape=shape, chunks=tile, dtype="int32"
+    )
+    import itertools
+
+    # Only public API and plain numpy here: the base branch of a comparison
+    # may predate any internal helper.
+    counts = []
+    grid = [range(0, n, t) for n, t in zip(shape, tile)]
+    for starts in itertools.product(*grid):
+        sl = tuple(slice(o, o + t) for o, t in zip(starts, tile))
+        ids = np.unique(lab[sl])
+        lut = np.zeros(int(ids.max()) + 1, dtype="int32")
+        lut[ids[ids > 0]] = np.arange(1, int((ids > 0).sum()) + 1)
+        block = lut[lab[sl]]
+        arr[sl] = block
+        counts.append(int(block.max()))
+    return path, counts
+
+
+def case_merge_touch(tmp):
+    from patchworks._merge import zarr_native_merge
+
+    path, counts = _staged(tmp)
+    t = time.perf_counter()
+    zarr_native_merge(
+        path,
+        "staged",
+        str(tmp / "out.zarr"),
+        "labels",
+        n_workers=2,
+        label_counts=counts,
+    )
+    return time.perf_counter() - t
+
+
+def case_merge_renumber(tmp):
+    """The merge without per-tile counts: includes the renumber pass."""
+    from patchworks._merge import zarr_native_merge
+
+    path, _ = _staged(tmp)
+    t = time.perf_counter()
+    zarr_native_merge(
+        path, "staged", str(tmp / "out.zarr"), "labels", n_workers=2
+    )
+    return time.perf_counter() - t
+
+
+def case_image_pyramid(tmp):
+    from patchworks.plugins.ome_zarr import to_ome_zarr
+
+    img = np.random.default_rng(0).integers(0, 4000, (16, 1024, 1024))
+    img = img.astype("uint16")
+    t = time.perf_counter()
+    to_ome_zarr(img, tmp / "img.zarr", axes="zyx", n_levels=5, progress=False)
+    return time.perf_counter() - t
+
+
+def case_label_pyramid(tmp):
+    from patchworks.plugins.ome_zarr import (
+        add_pyramid,
+        to_ome_zarr,
+        write_labels,
+    )
+
+    lab = _blob_labels((16, 1024, 1024), 6000)
+    store = to_ome_zarr(
+        np.zeros((1, 8, 8), "uint16"),
+        tmp / "i.zarr",
+        axes="zyx",
+        n_levels=1,
+        progress=False,
+    )
+    write_labels(store, lab, name="l", n_levels=1, progress=False)
+    t = time.perf_counter()
+    add_pyramid(f"{store}/labels/l", n_levels=5, progress=False)
+    return time.perf_counter() - t
+
+
+def case_filter_by_size(tmp):
+    from patchworks import filter_labels_by_size
+
+    lab = _blob_labels((16, 1024, 1024), 6000)
+    path = str(tmp / "f.zarr")
+    z = zarr.open_group(path, mode="w").create_array(
+        "l", shape=lab.shape, chunks=(16, 256, 256), dtype="int32"
+    )
+    z[:] = lab
+    t = time.perf_counter()
+    filter_labels_by_size(path, "l", min_voxels=50)
+    return time.perf_counter() - t
+
+
+def case_tile_process(tmp):
+    import dask.array as da
+    from scipy import ndimage as ndi
+
+    from patchworks import tile_process
+
+    img = (_blob_labels((8, 512, 512), 1500) > 0).astype("uint16") * 1000
+    arr = da.from_array(img, chunks=(8, 128, 128))
+    t = time.perf_counter()
+    tile_process(
+        arr,
+        lambda b: ndi.label(b > 500)[0].astype("int32"),
+        overlap=8,
+        write_to=tmp / "o.zarr",
+        progress=False,
+    )
+    return time.perf_counter() - t
+
+
+CASES = {
+    name[5:]: fn
+    for name, fn in sorted(globals().items())
+    if name.startswith("case_")
+}
+
+
+def run() -> dict[str, float | None]:
+    results: dict[str, float | None] = {}
+    for name, fn in CASES.items():
+        times = []
+        for _ in range(REPEATS):
+            tmp = Path(tempfile.mkdtemp(prefix="pwbench_"))
+            try:
+                times.append(fn(tmp))
+            except Exception as exc:  # a case this version cannot run
+                print(f"{name}: skipped ({type(exc).__name__}: {exc})")
+                times = []
+                break
+            finally:
+                shutil.rmtree(tmp, ignore_errors=True)
+        results[name] = min(times) if times else None
+        if times:
+            print(f"{name}: {results[name]:.3f}s")
+    return results
+
+
+if __name__ == "__main__":
+    out = run()
+    if len(sys.argv) > 1:
+        Path(sys.argv[1]).write_text(json.dumps(out, indent=2))

patchworks-3.0.0/benchmarks/compare.py

@@ -0,0 +1,46 @@
+"""Compare two benchmark runs as a Markdown table.
+
+    python benchmarks/compare.py base.json head.json [--threshold 1.25]
+
+Prints the table (append it to $GITHUB_STEP_SUMMARY in CI) and a GitHub
+warning annotation per case that got slower than *threshold*. It never fails:
+shared CI runners are too noisy for a hard gate, so this is for a human to
+read on every pull request.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("base")
+    ap.add_argument("head")
+    ap.add_argument("--threshold", type=float, default=1.25)
+    args = ap.parse_args()
+    base = json.loads(Path(args.base).read_text())
+    head = json.loads(Path(args.head).read_text())
+
+    print("| case | base (s) | head (s) | head / base |")
+    print("| --- | ---: | ---: | ---: |")
+    slow = []
+    for name in sorted(set(base) | set(head)):
+        b, h = base.get(name), head.get(name)
+        ratio = h / b if b and h else None
+        mark = ""
+        if ratio is not None and ratio > args.threshold:
+            mark = " ⚠️"
+            slow.append((name, ratio))
+        fmt = lambda v: "n/a" if v is None else f"{v:.3f}"  # noqa: E731
+        r = "n/a" if ratio is None else f"{ratio:.2f}x{mark}"
+        print(f"| {name} | {fmt(b)} | {fmt(h)} | {r} |")
+    for name, ratio in slow:
+        print(f"::warning title=benchmark::{name} is {ratio:.2f}x slower")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{patchworks-2.8.0 → patchworks-3.0.0}/docs/api/io.md

@@ -17,3 +17,9 @@ used as a skip list. See [Skipping empty tiles](../guide/skip_empty.md).
 ::: patchworks.tile_occupancy
 
 ::: patchworks.auto_empty_threshold
+
+## Compression
+
+::: patchworks.compression
+
+::: patchworks.set_compression

{patchworks-2.8.0 → patchworks-3.0.0}/docs/api/plugins/ome_zarr.md

@@ -42,7 +42,7 @@ matches the store, and reads both.
 ::: patchworks.plugins.ome_zarr.ngff_version
 
 Every writer takes an `ngff_version=` keyword: `"auto"` (default) follows the
-installed zarr — 0.5 on v3, 0.4 on v2 — and `"0.4"` pins the older, zarr-v2
+installed zarr (0.5, since patchworks requires zarr-python 3) and `"0.4"` pins the older, zarr-v2
 layout. Writing into an existing store always follows *that store's* format,
 so a label pyramid added later can never disagree with the image it sits in.
 NGFF 0.6 is released but not written: RFC-5 replaces `axes` with

patchworks-3.0.0/docs/api/provenance.md

@@ -0,0 +1,17 @@
+# Provenance
+
+Every label image patchworks writes records how it was made: the
+segmentation function and its bound settings, tiling, overlap, stitching,
+level, channel, codec, the input, the library versions and a UTC timestamp.
+It sits in the label group's attrs under `"patchworks"` (for `write_to=`
+stores, on the labels array), so it travels with the data.
+
+```python
+from patchworks import read_provenance
+
+read_provenance("scan.zarr/labels/cilia_labels")["settings"]["custom"]
+```
+
+::: patchworks.read_provenance
+
+::: patchworks.provenance

patchworks-3.0.0/docs/api/seams.md

@@ -0,0 +1,9 @@
+# Seam report
+
+::: patchworks.seam_report
+
+## Choosing the overlap
+
+::: patchworks.suggest_overlap
+
+::: patchworks.object_f1

{patchworks-2.8.0 → patchworks-3.0.0}/docs/getting_started.md

@@ -2,7 +2,7 @@
 
 ## Installation
 
-patchworks can be installed from PyPI on all operating systems, for Python ≥ 3.9.
+patchworks can be installed from PyPI on all operating systems, for Python ≥ 3.11.
 
 !!! tip "Virtual environment (recommended)"
     We recommend creating a dedicated environment:

patchworks-3.0.0/docs/guide/cli.md

@@ -0,0 +1,40 @@
+# Command line
+
+Installing patchworks also installs a `patchworks` command: the same building
+blocks as the Python API, for a one-off run without writing a script or a
+Snakemake config.
+
+```bash
+# Convert anything bioio reads (or an existing store) to a pyramidal OME-ZARR
+patchworks convert scan.czi scan.zarr
+
+# Segment it; labels go into scan.zarr/labels/labels
+patchworks segment scan.zarr --method cellpose --model cyto3 --diameter 30 --gpu
+
+# What is in the store: levels, chunks, codecs, calibration, label images
+patchworks info scan.zarr
+
+# Did the tiling leave marks in the labels?
+patchworks seams scan.zarr/labels/labels --tile-shape 16,1024,1024
+
+# Look at the result (needs patchworks[napari])
+patchworks view scan.zarr
+```
+
+## Segmentation methods
+
+| `--method` | What it does | Main flags |
+| --- | --- | --- |
+| `threshold` (default) | one global threshold (Otsu over the image unless `--threshold`), then connected components | `--threshold` |
+| `cellpose` | [Cellpose](../api/plugins/cellpose.md) | `--model`, `--diameter`, `--do-3d`, `--gpu` |
+| `dog` | [difference of Gaussians](../api/plugins/dog.md) | `--low-sigma`, `--high-sigma`, `--threshold` |
+| `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.
+
+Tiling and stitching take the same options as
+[`tile_process`](../api/tile_process.md): `--tile-shape` (`z,y,x`, `auto` or
+`none`), `--overlap` (`N` or `z,y,x`), `--stitch iou`, `--resume`,
+`--skip-empty`, `--level`, `--channel` (an index, or `none` for every channel),
+`--compression`. Run `patchworks <command> --help` for the full list.