patchworks 0.9.1__tar.gz → 0.11.0__tar.gz

{patchworks-0.9.1 → patchworks-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: patchworks
-Version: 0.9.1
+Version: 0.11.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
@@ -63,6 +63,9 @@ Requires-Dist: psutil; extra == 'io'
 Requires-Dist: tqdm; extra == 'io'
 Provides-Extra: napari
 Requires-Dist: napari[all]; extra == 'napari'
+Provides-Extra: workflow
+Requires-Dist: snakemake-executor-plugin-slurm; extra == 'workflow'
+Requires-Dist: snakemake>=8; extra == 'workflow'
 Description-Content-Type: text/markdown
 
 # patchworks

patchworks-0.11.0/docs/guide/snakemake.md

@@ -0,0 +1,213 @@
+# Cluster workflow (Snakemake + SLURM)
+
+`tile_process` runs every tile **serially on one GPU**. For a large 3-D image
+that can be days. The bundled Snakemake workflow instead submits **one GPU job
+per tile**, so with *N* GPUs the segmentation is ~*N*× faster. This page walks
+through running it from scratch.
+
+```text
+convert ──▶ prepare (checkpoint) ──▶ segment {tile}  ──▶ merge
+                                     one GPU SLURM job per tile
+```
+
+## 1. Get the workflow
+
+The workflow lives in the `workflow/` directory of the patchworks repository
+(it is not shipped inside the pip package — it is a set of Snakemake files you
+run):
+
+```bash
+git clone https://github.com/imcf/patchworks
+cd patchworks/workflow
+```
+
+## 2. Install the dependencies
+
+You need patchworks with the workflow + reader + segmentation extras, in the
+environment Snakemake will use:
+
+```bash
+pip install "patchworks[workflow,cellpose,imaris,bioio]"
+```
+
+- `workflow` → Snakemake + the SLURM executor plugin
+- `cellpose` → the segmentation model
+- `imaris` / `bioio` → read your input format (`.ims`, `.czi`, `.lif`, …)
+
+On a cluster, do this inside a conda/venv that the compute nodes can see, or let
+each rule activate a conda env (see *Conda*, below).
+
+## 3. Configure the run
+
+Copy and edit `config/config.yaml`. Every field:
+
+```yaml
+# input / output
+input: "/data/scan.ims"        # .ims/.czi/.lif/.nd2/ome-tiff/.zarr
+work_dir: "/scratch/results"   # everything is written here
+
+# conversion (input → pyramidal OME-ZARR)
+reuse_pyramid: true            # .ims: copy its own pyramid (fast)
+convert_chunks: null           # null → bounded auto chunks; or [c,z,y,x]
+shard: false                   # true → pack chunks into shards (fewer files)
+
+# tiling
+channel: 0                     # channel to segment (null = keep all)
+level: 0                       # pyramid level (0 = full resolution)
+tile_shape: "auto"             # "auto", or e.g. [16, 1024, 1024] (zyx)
+overlap: 30                    # halo ≈ one object diameter
+skip_empty: true               # skip background tiles
+empty_threshold: null          # null → Otsu
+
+# segmentation
+method: "cellpose"             # "cellpose" (GPU) or "threshold" (no GPU)
+label_name: "cellpose"         # name under image.zarr/labels/
+cellpose:
+  model: "cyto3"
+  diameter: 30
+  do_3D: true
+  gpu: true
+  # extra model.eval() kwargs, e.g. flow_threshold: 0.4
+
+# label pyramid
+pyramid_levels: 5
+pyramid_downscale: 2
+sequential_labels: true        # renumber labels to a contiguous 1..N
+```
+
+!!! 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
+    per slice) if your objects segment fine per slice — it is much faster.
+
+## 4. Dry-run (always do this first)
+
+Check the plan without running anything:
+
+```bash
+python -m snakemake -s Snakefile --configfile config/config.yaml -n -p
+```
+
+You should see `convert`, `prepare`, and a note that the **checkpoint** will add
+the `segment` jobs after `prepare` runs. (The number of segment jobs is only
+known after `prepare` decides which tiles are non-empty.)
+
+## 5a. Run locally (single machine)
+
+```bash
+python -m snakemake -s Snakefile --configfile config/config.yaml --cores 8
+```
+
+Tiles run on the local machine (one at a time on the GPU). Good for a small
+image or a smoke test.
+
+## 5b. Run on SLURM (one GPU job per tile)
+
+Edit `profile/slurm/config.yaml` for **your** cluster — partitions, account,
+and the GPU request:
+
+```yaml
+executor: slurm
+jobs: 64                       # max concurrent SLURM jobs ≈ GPUs you can grab
+default-resources:
+  slurm_partition: "cpu"       # your CPU partition
+  # slurm_account: "my_account"
+  mem_mb: 16000
+  cpus_per_task: 4
+  runtime: 60
+set-resources:
+  segment:                     # the GPU step
+    slurm_partition: "gpu"     # your GPU partition
+    slurm_extra: "'--gres=gpu:1'"
+    mem_mb: 32000
+    runtime: 120
+  merge:
+    mem_mb: 128000
+    runtime: 240
+```
+
+Then launch (from a login node — Snakemake submits and watches the jobs):
+
+```bash
+python -m snakemake --workflow-profile profile/slurm \
+                    --configfile config/config.yaml
+```
+
+Snakemake submits `convert`, then `prepare`, then **one `segment` job per
+non-empty tile** (up to `jobs:` at once → that many GPUs in parallel), then
+`merge`. Raise `jobs:` to use more GPUs.
+
+!!! note "GPU request flag"
+    Clusters differ. `--gres=gpu:1` is common; some need `--gpus=1` or a
+    specific gres name (`--gres=gpu:a100:1`). Put whatever `sbatch` flag your
+    cluster needs in `slurm_extra`.
+
+## 6. Monitor
+
+- **Snakemake** prints each job as it submits/finishes and a `X of Y steps`
+  counter.
+- **SLURM**: `squeue --me` shows your queued/running jobs (`smk-segment`, …);
+  logs land where your profile/cluster sends them.
+- **patchworks** logs (`processing tile k/N`, ETA) are inside each job's stdout.
+
+## 7. Output
+
+Everything is under `work_dir`:
+
+```text
+results/
+  image.zarr/                 # converted, pyramidal OME-ZARR
+  image.zarr/labels/<name>/   # the segmentation (multi-scale, calibrated)
+```
+
+The labels live **inside** the image store. View image + labels together:
+
+```python
+from patchworks.plugins.napari import view_in_napari
+view_in_napari("/scratch/results/image.zarr")   # auto-loads the labels
+```
+
+## 8. Re-running and resuming
+
+Snakemake is resumable — if jobs fail or you cancel, just relaunch the same
+command and it picks up only the missing tiles. To force a clean rerun, delete
+`work_dir` (or the relevant outputs).
+
+## Conda (optional)
+
+To have each rule run in a named conda env instead of the active one, add
+`--use-conda` and point the rules at an env; or activate your env in a SLURM
+prologue. The simplest path is a single shared env that the compute nodes see.
+
+## Troubleshooting
+
+| Symptom | Fix |
+|---------|-----|
+| `snakemake: command not found` | use `python -m snakemake` |
+| Segment jobs pend forever | wrong `slurm_partition`/`slurm_extra` GPU flag for your cluster |
+| `cellpose is not installed` in a job | the job's env lacks `patchworks[cellpose]` |
+| Reading the input fails | install the matching reader (`patchworks[imaris]`/`[bioio]` + a `bioio-*`) |
+| Out of GPU memory | smaller `tile_shape`, or `do_3D: false` |
+| Very slow | confirm GPU is used (`nvidia-smi`); try 2-D or a lower `level` |
+
+## How it works (for the curious)
+
+The rule scripts are thin wrappers over patchworks' public API, so you can build
+the same per-tile distribution yourself:
+
+```python
+from patchworks import (
+    load_ome_zarr, spatial_tiles, create_stage, stage_tile, merge_tile_labels
+)
+from patchworks.plugins.ome_zarr import write_labels
+
+img = load_ome_zarr("image.zarr", channel=0)
+tiles = spatial_tiles(img.shape, tile_shape=(16, 1024, 1024))
+create_stage("stage.zarr", img.shape, (16, 1024, 1024))
+# (distribute these across jobs:)
+for i in range(len(tiles)):
+    stage_tile(img, my_fn, "stage.zarr", i, tile_shape=(16, 1024, 1024), overlap=30)
+merged = merge_tile_labels("stage.zarr", input_component="staged",
+                           write_to="merged.zarr", sequential_labels=True)
+write_labels("image.zarr", merged, name="cells")
+```

{patchworks-0.9.1 → patchworks-0.11.0}/mkdocs.yml

@@ -39,6 +39,7 @@ nav:
   - Empty tile skipping: guide/skip_empty.md
   - GPU & distributed: guide/gpu_distributed.md
   - Performance & memory: guide/performance.md
+  - Cluster workflow (Snakemake): guide/snakemake.md
   - OME-ZARR & napari: guide/ome_zarr_napari.md
   - Pitfalls: guide/pitfalls.md
 - Examples:

{patchworks-0.9.1 → patchworks-0.11.0}/pyproject.toml

@@ -58,6 +58,8 @@ bioio = [
 imaris = ["imaris-ims-file-reader"]
 # napari enables the interactive viewer plugin.
 napari = ["napari[all]"]
+# workflow runs the Snakemake pipeline (per-tile SLURM jobs across GPUs).
+workflow = ["snakemake>=8", "snakemake-executor-plugin-slurm"]
 dev = ["pytest", "pytest-cov", "scikit-image", "psutil", "tqdm"]
 docs = ["mkdocs-material>=9.0", "mkdocstrings[python]>=0.24"]
 all = [

{patchworks-0.9.1 → patchworks-0.11.0}/src/patchworks/__init__.py

@@ -32,6 +32,7 @@ from importlib.metadata import version as _pkg_version
 from ._chunks import auto_overlap, auto_tile_shape, auto_tile_shape_cellpose
 from ._cluster import make_local_cluster
 from ._core import tile_process
+from ._distributed import create_stage, spatial_tiles, stage_tile
 from ._io import estimate_empty_tiles, load_ome_zarr
 from ._merge import merge_tile_labels
 from ._relabel import relabel_sequential_array, relabel_sequential_zarr
@@ -51,4 +52,7 @@ __all__ = [
     "make_local_cluster",
     "relabel_sequential_array",
     "relabel_sequential_zarr",
+    "spatial_tiles",
+    "create_stage",
+    "stage_tile",
 ]

{patchworks-0.9.1 → patchworks-0.11.0}/src/patchworks/_core.py

@@ -20,6 +20,71 @@ from ._relabel import relabel_sequential_zarr
 logger = logging.getLogger(__name__)
 
 
+def _attach_log_file(path: str) -> None:
+    """Tee the ``patchworks`` INFO log to *path* (replacing a prior auto file).
+
+    A previous auto-attached handler is removed first so repeated calls do not
+    stack handlers. The package logger level is raised to INFO if needed so the
+    messages are actually emitted.
+
+    Parameters
+    ----------
+    path : str
+        Destination log-file path.
+
+    Returns
+    -------
+    None
+    """
+    pkg = logging.getLogger("patchworks")
+    for h in list(pkg.handlers):
+        if getattr(h, "_patchworks_auto", False):
+            pkg.removeHandler(h)
+            h.close()
+    handler = logging.FileHandler(path)
+    handler._patchworks_auto = True  # tag so we can find/replace it later
+    handler.setLevel(logging.INFO)
+    handler.setFormatter(
+        logging.Formatter("%(asctime)s %(levelname)s %(name)s: %(message)s")
+    )
+    pkg.addHandler(handler)
+    if pkg.level == logging.NOTSET or pkg.level > logging.INFO:
+        pkg.setLevel(logging.INFO)
+
+
+def _read_amplification(
+    native_chunks: tuple[int, ...], tile_shape: tuple[int, ...]
+) -> float:
+    """Estimate how much extra data each tile read pulls off disk.
+
+    When the store's on-disk chunks are larger than the tile, every tile read
+    decodes whole chunks and discards most of them. Returns the ratio of bytes
+    read to bytes used (1.0 = no waste).
+
+    Parameters
+    ----------
+    native_chunks : tuple of int
+        The store's on-disk chunk shape.
+    tile_shape : tuple of int
+        The processing tile shape.
+
+    Returns
+    -------
+    float
+        Read-amplification factor (``bytes_read / bytes_used``).
+    """
+    import math
+
+    read = used = 1.0
+    for n, t in zip(native_chunks, tile_shape):
+        if n <= 0 or t <= 0:
+            continue
+        touched = math.ceil(t / n)  # chunks a tile spans on this axis
+        read *= touched * n
+        used *= t
+    return read / used if used else 1.0
+
+
 def _stage_to_zarr(
     arr: da.Array, path: str, component: str, show_progress: bool
 ) -> None:
@@ -83,6 +148,7 @@ def tile_process(
     empty_threshold: float | None = None,
     stage_dir: Union[str, Path, None] = None,
     keep_stage: bool = False,
+    log_file: Union[str, Path, bool, None] = True,
     verbose: bool = False,
 ) -> da.Array:
     """Apply *fn* to every tile of *image* and merge labels globally.
@@ -180,6 +246,11 @@ def tile_process(
     keep_stage:
         Keep the temp stage store after merging (default: delete it). Useful
         for debugging or resuming an interrupted run.
+    log_file:
+        Where to tee the ``patchworks`` INFO log (including a per-tile
+        ``processing tile k/N`` counter). ``True`` (default) auto-writes
+        ``patchworks.log`` next to the output; a path writes there; ``False``/
+        ``None`` disables the file (logs still go to stderr).
     verbose:
         Log each tile's location and shape as it is processed.
 
@@ -250,10 +321,27 @@ def tile_process(
 
     # Load + tile
     image_source_path = None if isinstance(image, da.Array) else str(image)
+
+    # Auto log file (default): tee patchworks' INFO logs to a file next to the
+    # output, so a long run leaves a tailable record without notebook setup.
+    if log_file:
+        if log_file is True:
+            if write_to is not None:
+                _ldir = os.path.dirname(os.path.abspath(str(write_to)))
+            elif image_source_path is not None:
+                _ldir = os.path.dirname(os.path.abspath(image_source_path))
+            else:
+                _ldir = os.getcwd()
+            log_file = os.path.join(_ldir, "patchworks.log")
+        _attach_log_file(str(log_file))
+        logger.info("patchworks log → %s", log_file)
+
     _load_chunks: tuple[int, ...] | None = None
+    _native_chunks: tuple[int, ...] | None = None
 
     if not isinstance(image, da.Array):
         _peek = load_ome_zarr(image, channel=channel, level=level)
+        _native_chunks = _peek.chunksize  # on-disk zarr chunk shape
         if callable(tile_shape):
             _load_chunks = tuple(tile_shape(_peek.shape, _peek.dtype))
         elif isinstance(tile_shape, str):
@@ -291,13 +379,30 @@ def tile_process(
         logger.info("Rechunked to %s", tile_shape)
 
     n_tiles = int(np.prod([len(c) for c in image.chunks]))
+    _tile = tuple(c[0] for c in image.chunks)
     logger.info(
         "Processing %d tiles (per-axis %s, tile shape %s)",
         n_tiles,
         tuple(len(c) for c in image.chunks),
-        tuple(c[0] for c in image.chunks),
+        _tile,
     )
 
+    # Warn when the store's on-disk chunks are much larger than the tile: every
+    # tile read then decodes whole chunks and throws most away (slow I/O).
+    if _native_chunks is not None:
+        _amp = _read_amplification(_native_chunks, _tile)
+        if _amp >= 4:
+            logger.warning(
+                "Input chunks %s are much larger than the tile %s → ~%.0fx "
+                "read amplification (each tile decodes whole chunks and "
+                "discards most). Re-chunk the store near the tile size "
+                "(e.g. to_ome_zarr(..., chunks=...) without shard=) or read "
+                "the source file directly to avoid wasted I/O.",
+                _native_chunks,
+                _tile,
+                _amp,
+            )
+
     image_for_threshold = image
 
     # Overlap — build a per-axis depth dict (clips to fit each axis).
@@ -313,6 +418,23 @@ def tile_process(
     if skip_empty and _skip_thr is None:
         _skip_thr = _auto_empty_threshold(image_for_threshold, channel, level)
 
+    # Up-front heads-up for a big 3-D GPU job (z-stack tiles, many of them):
+    # an accurate ETA is logged after the first few tiles, but warn early that
+    # this is the expensive path and point at the faster alternatives.
+    if use_gpu and image.ndim >= 3 and _tile[0] > 4 and n_tiles >= 50:
+        logger.warning(
+            "Large 3-D GPU job: %d tiles of %s. Per-tile 3-D segmentation is "
+            "slow on a single device (a live ETA is logged after the first "
+            "tiles). If per-slice results are acceptable, 2-D (z=1 tiles) is "
+            "typically ~10x faster, or segment a lower pyramid level.",
+            n_tiles,
+            _tile,
+        )
+
+    # Tile counters + timing (GIL-safe enough for the threaded / in-process
+    # schedulers patchworks uses) so the log shows live "tile k/N + ETA".
+    _progress = {"done": 0, "seen": 0, "time": 0.0}
+
     def active_fn(block, block_info=None):
         """Run *fn* on one tile, or return zeros for an empty tile.
 
@@ -328,14 +450,36 @@ def tile_process(
         np.ndarray
             Integer labels, or an all-zero tile when skipped.
         """
+        import time
+
         loc = block_info[0].get("chunk-location") if block_info else "?"
+        _progress["seen"] += 1
         if skip_empty and block.size and block.max() <= _skip_thr:
             if verbose:
                 logger.debug("skip empty tile %s (max<=%s)", loc, _skip_thr)
             return np.zeros(block.shape, dtype=np.int32)
-        if verbose:
-            logger.debug("process tile %s shape=%s", loc, block.shape)
-        return fn(block)
+
+        t0 = time.perf_counter()
+        out = fn(block)
+        dt = time.perf_counter() - t0
+
+        _progress["done"] += 1
+        _progress["time"] += dt
+        done, seen = _progress["done"], _progress["seen"]
+        avg = _progress["time"] / done
+        # Extrapolate remaining non-empty tiles from the empty fraction seen.
+        remaining_nonempty = max(0, n_tiles - seen) * (done / seen)
+        eta_h = avg * remaining_nonempty / 3600
+        logger.info(
+            "tile %d done in %.1fs (avg %.1fs); %d/%d tiles seen; ETA ~%.1fh",
+            done,
+            dt,
+            avg,
+            seen,
+            n_tiles,
+            eta_h,
+        )
+        return out
 
     _meta = np.empty((0,) * image.ndim, dtype=np.int32)
     if overlap > 0:

patchworks-0.11.0/src/patchworks/_distributed.py

@@ -0,0 +1,140 @@
+"""Per-tile building blocks for distributed processing.
+
+``tile_process`` runs every tile and merges in one process. To spread tiles
+across separate jobs (e.g. one SLURM GPU job per tile) you need to process a
+*single* tile independently and merge later. These helpers expose exactly that:
+:func:`spatial_tiles` enumerates the tiles, :func:`create_stage` makes the
+shared output store, and :func:`stage_tile` runs ``fn`` on one tile and writes
+it into that store. Stitch the result with
+:func:`patchworks.merge_tile_labels` (or ``zarr_native_merge``).
+"""
+
+from __future__ import annotations
+
+import itertools
+from pathlib import Path
+from typing import Callable, Union
+
+import numpy as np
+import zarr
+
+
+def spatial_tiles(
+    shape: tuple[int, ...], tile_shape: tuple[int, ...]
+) -> list[tuple[slice, ...]]:
+    """Enumerate the tiles covering *shape*, in row-major order.
+
+    Parameters
+    ----------
+    shape : tuple of int
+        Spatial array shape.
+    tile_shape : tuple of int
+        Tile shape.
+
+    Returns
+    -------
+    list of tuple of slice
+        One slice tuple per tile (the same order ``estimate_empty_tiles``'s
+        ``occupancy`` grid uses when ravelled).
+    """
+    grids = [range(0, s, t) for s, t in zip(shape, tile_shape)]
+    return [
+        tuple(
+            slice(o, min(o + t, s))
+            for o, t, s in zip(starts, tile_shape, shape)
+        )
+        for starts in itertools.product(*grids)
+    ]
+
+
+def create_stage(
+    stage_path: Union[str, Path],
+    shape: tuple[int, ...],
+    tile_shape: tuple[int, ...],
+    *,
+    component: str = "staged",
+    dtype=np.int32,
+) -> str:
+    """Create the empty (zero-filled) shared stage store for tiled writes.
+
+    Parameters
+    ----------
+    stage_path : str or Path
+        Destination ``.zarr`` store.
+    shape : tuple of int
+        Full (spatial) array shape.
+    tile_shape : tuple of int
+        Chunk = tile shape (one chunk per tile, so jobs write disjoint files).
+    component : str, optional
+        Array name inside the store (default ``"staged"``).
+    dtype : data-type, optional
+        Label dtype (default ``int32``).
+
+    Returns
+    -------
+    str
+        The stage store path.
+    """
+    root = zarr.open_group(str(stage_path), mode="w")
+    root.create_array(
+        name=component, shape=shape, chunks=tile_shape, dtype=dtype
+    )
+    return str(stage_path)
+
+
+def stage_tile(
+    image,
+    fn: Callable[[np.ndarray], np.ndarray],
+    stage_path: Union[str, Path],
+    index: int,
+    *,
+    tile_shape: tuple[int, ...],
+    overlap: int = 0,
+    component: str = "staged",
+) -> int:
+    """Run *fn* on a single tile and write it into the shared stage store.
+
+    Reads the tile (expanded by *overlap* on every side for boundary context),
+    runs *fn*, trims the halo back off, and writes the result to the tile's
+    disjoint chunk of ``stage_path/component`` — so many of these can run
+    concurrently (one per job) without conflicts.
+
+    Parameters
+    ----------
+    image : array-like
+        The full image (dask/zarr/NumPy), indexable by slices.
+    fn : callable
+        ``(ndarray) -> ndarray`` returning integer labels of the same shape.
+    stage_path : str or Path
+        Stage store created by :func:`create_stage`.
+    index : int
+        Tile index into :func:`spatial_tiles`.
+    tile_shape : tuple of int
+        Tile shape (must match the stage store's chunks).
+    overlap : int, optional
+        Halo added on every side before calling *fn*.
+    component : str, optional
+        Array name inside the stage store.
+
+    Returns
+    -------
+    int
+        The processed tile *index*.
+    """
+    shape = image.shape
+    sl = spatial_tiles(shape, tile_shape)[index]
+    expanded, trims = [], []
+    for s, dim in zip(sl, shape):
+        lo = max(0, s.start - overlap)
+        hi = min(dim, s.stop + overlap)
+        expanded.append(slice(lo, hi))
+        trims.append((s.start - lo, hi - s.stop))
+    block = np.asarray(image[tuple(expanded)])
+    out = np.asarray(fn(block))
+    sel = tuple(
+        slice(left, out.shape[i] - right)
+        for i, (left, right) in enumerate(trims)
+    )
+    dst = zarr.open_group(str(stage_path), mode="r+")[component]
+    dst[sl] = out[sel].astype(dst.dtype)
+    return index

patchworks-0.11.0/tests/test_distributed.py

@@ -0,0 +1,45 @@
+"""Tests for the per-tile distributed building blocks."""
+
+import numpy as np
+
+from patchworks import (
+    create_stage,
+    merge_tile_labels,
+    spatial_tiles,
+    stage_tile,
+)
+
+
+def _fn(tile):
+    from skimage.measure import label
+
+    return label(tile > 0).astype("int32")
+
+
+def test_spatial_tiles_cover():
+    """Tiles tile the array exactly, in row-major order."""
+    tiles = spatial_tiles((4, 5), (2, 2))
+    assert len(tiles) == 2 * 3  # ceil(4/2) * ceil(5/2)
+    assert tiles[0] == (slice(0, 2), slice(0, 2))
+    assert tiles[-1] == (slice(2, 4), slice(4, 5))  # clipped last tile
+
+
+def test_stage_then_merge_stitches_boundary(tmp_path):
+    """Per-tile staging + merge reproduces a cross-boundary single object."""
+    img = np.zeros((16, 32), "uint16")
+    img[4:12, 8:24] = 500  # block straddling the x=16 tile boundary
+
+    stage = str(tmp_path / "stage.zarr")
+    tile = (16, 16)
+    create_stage(stage, img.shape, tile)
+    for i in range(len(spatial_tiles(img.shape, tile))):
+        stage_tile(img, _fn, stage, i, tile_shape=tile, overlap=4)
+
+    merged = merge_tile_labels(
+        stage,
+        write_to=str(tmp_path / "out.zarr"),
+        input_component="staged",
+        sequential_labels=True,
+    ).compute()
+    ids = np.unique(merged[merged > 0])
+    assert ids.size == 1, f"object split into {ids.size} labels"

patchworks-0.11.0/workflow/.snakemake/metadata/L3RtcC90b3kvb3V0L2ltYWdlLnphcnI=

@@ -0,0 +1 @@
+{"rule": "convert", "input": [], "log": [], "shellcmd": null, "params": [], "code": "        \"../scripts/convert.py\"\n", "record_format_version": 6, "conda_env": null, "container_img_url": null, "software_stack_hash": "d41d8cd98f00b204e9800998ecf8427e", "job_hash": 7968324357465, "starttime": 1782285191.3091571, "endtime": 1782285191.3090107, "incomplete": false, "external_jobid": null, "input_checksums": {}}

patchworks-0.11.0/workflow/.snakemake/metadata/L3RtcC90b3kvb3V0L2xhYmVscy5kb25l

@@ -0,0 +1 @@
+{"rule": "merge", "input": ["/tmp/toy/out/seg/0.done", "/tmp/toy/out/seg/1.done", "/tmp/toy/out/seg/3.done", "/tmp/toy/out/seg/4.done"], "log": [], "shellcmd": null, "params": [], "code": "        \"../scripts/merge.py\"\n", "record_format_version": 6, "conda_env": null, "container_img_url": null, "software_stack_hash": "d41d8cd98f00b204e9800998ecf8427e", "job_hash": 7968324177309, "starttime": 1782285198.9120235, "endtime": 1782285198.9118745, "incomplete": false, "external_jobid": null, "input_checksums": {"/tmp/toy/out/seg/0.done": "sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "/tmp/toy/out/seg/1.done": "sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "/tmp/toy/out/seg/3.done": "sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "/tmp/toy/out/seg/4.done": "sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"}}

patchworks-0.11.0/workflow/.snakemake/metadata/L3RtcC90b3kvb3V0L3N0YWdlLnphcnI=

@@ -0,0 +1 @@
+{"rule": "prepare", "input": ["/tmp/toy/out/image.zarr"], "log": [], "shellcmd": null, "params": [], "code": "        \"../scripts/prepare_tiles.py\"\n", "record_format_version": 6, "conda_env": null, "container_img_url": null, "software_stack_hash": "d41d8cd98f00b204e9800998ecf8427e", "job_hash": 7968324357329, "starttime": 1782285193.0925362, "endtime": 1782285193.0922585, "incomplete": false, "external_jobid": null, "input_checksums": {}}

patchworks-0.11.0/workflow/.snakemake/metadata/L3RtcC90b3kvb3V0L3NlZy80LmRvbmU=

@@ -0,0 +1 @@
+{"rule": "segment", "input": ["/tmp/toy/out/image.zarr", "/tmp/toy/out/stage.zarr", "/tmp/toy/out/tiles.json"], "log": [], "shellcmd": null, "params": [], "code": "        \"../scripts/segment_tile.py\"\n", "record_format_version": 6, "conda_env": null, "container_img_url": null, "software_stack_hash": "d41d8cd98f00b204e9800998ecf8427e", "job_hash": 7968316803128, "starttime": 1782285194.9512916, "endtime": 1782285194.9498596, "incomplete": false, "external_jobid": null, "input_checksums": {"/tmp/toy/out/tiles.json": "sha256:a7ba7de7a100b9eed2f69158d779580251e48da2c4bdb722e28c4d9a79abb411"}}

patchworks-0.11.0/workflow/.snakemake/metadata/L3RtcC90b3kvb3V0L3NlZy8wLmRvbmU=

@@ -0,0 +1 @@
+{"rule": "segment", "input": ["/tmp/toy/out/image.zarr", "/tmp/toy/out/stage.zarr", "/tmp/toy/out/tiles.json"], "log": [], "shellcmd": null, "params": [], "code": "        \"../scripts/segment_tile.py\"\n", "record_format_version": 6, "conda_env": null, "container_img_url": null, "software_stack_hash": "d41d8cd98f00b204e9800998ecf8427e", "job_hash": 7968316911209, "starttime": 1782285194.9791708, "endtime": 1782285194.9778593, "incomplete": false, "external_jobid": null, "input_checksums": {"/tmp/toy/out/tiles.json": "sha256:a7ba7de7a100b9eed2f69158d779580251e48da2c4bdb722e28c4d9a79abb411"}}