patchworks 1.3.2__tar.gz → 1.3.4__tar.gz

{patchworks-1.3.2 → patchworks-1.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: patchworks
-Version: 1.3.2
+Version: 1.3.4
 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
@@ -130,6 +130,7 @@ pip install "patchworks[gpu]"       # GPU VRAM querying (nvidia-ml-py)
 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[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
@@ -142,6 +143,14 @@ pip install "patchworks[all]"       # Everything, incl. the napari viewer
 > `[imaris]` adds native `.ims` support (HDF5, no JVM). Physical pixel
 > calibration is read from the input and written into the OME-ZARR.
 
+> **`cupy` is never installed automatically**, unlike Cellpose's GPU support
+> (which comes for free via PyTorch's self-contained CUDA wheels). Any
+> `use_gpu=True`/`dilate_gpu: true` option (the `dog` plugin, `dilate_labels`)
+> needs `cupy` installed separately, matching your CUDA version — e.g.
+> `pip install cupy-cuda12x`. Not bundled because cupy ships one wheel per
+> CUDA major version; a generic pin would resolve to the wrong build (or fail
+> to resolve) depending on the machine.
+
 ---
 
 ## Quick start — 5 lines
@@ -397,10 +406,14 @@ Optional:
 - `tqdm` — progress bars
 - `cellpose` — Cellpose plugin, v3 or v4 (`patchworks[cellpose]`);
   pin with `[cellpose3]` or `[cellpose4]`
+- `pycudadecon` — deconvolution step of the `dog` plugin (`patchworks[dog]`)
 - `bioio` + readers — convert CZI/LIF/ND2/OME-TIFF/… to OME-ZARR
   (`patchworks[bioio]`)
 - `imaris-ims-file-reader` — convert Imaris `.ims` (`patchworks[imaris]`)
 - `napari` — interactive viewer plugin (`patchworks[napari]`)
+- `cupy` — **install manually**, matching your CUDA version (e.g.
+  `pip install cupy-cuda12x`); not offered as an extra since it isn't one
+  generic pin. Needed for `use_gpu=True`/`dilate_gpu: true`.
 
 ---
 

{patchworks-1.3.2 → patchworks-1.3.4}/README.md

@@ -40,6 +40,7 @@ pip install "patchworks[gpu]"       # GPU VRAM querying (nvidia-ml-py)
 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[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
@@ -52,6 +53,14 @@ pip install "patchworks[all]"       # Everything, incl. the napari viewer
 > `[imaris]` adds native `.ims` support (HDF5, no JVM). Physical pixel
 > calibration is read from the input and written into the OME-ZARR.
 
+> **`cupy` is never installed automatically**, unlike Cellpose's GPU support
+> (which comes for free via PyTorch's self-contained CUDA wheels). Any
+> `use_gpu=True`/`dilate_gpu: true` option (the `dog` plugin, `dilate_labels`)
+> needs `cupy` installed separately, matching your CUDA version — e.g.
+> `pip install cupy-cuda12x`. Not bundled because cupy ships one wheel per
+> CUDA major version; a generic pin would resolve to the wrong build (or fail
+> to resolve) depending on the machine.
+
 ---
 
 ## Quick start — 5 lines
@@ -307,10 +316,14 @@ Optional:
 - `tqdm` — progress bars
 - `cellpose` — Cellpose plugin, v3 or v4 (`patchworks[cellpose]`);
   pin with `[cellpose3]` or `[cellpose4]`
+- `pycudadecon` — deconvolution step of the `dog` plugin (`patchworks[dog]`)
 - `bioio` + readers — convert CZI/LIF/ND2/OME-TIFF/… to OME-ZARR
   (`patchworks[bioio]`)
 - `imaris-ims-file-reader` — convert Imaris `.ims` (`patchworks[imaris]`)
 - `napari` — interactive viewer plugin (`patchworks[napari]`)
+- `cupy` — **install manually**, matching your CUDA version (e.g.
+  `pip install cupy-cuda12x`); not offered as an extra since it isn't one
+  generic pin. Needed for `use_gpu=True`/`dilate_gpu: true`.
 
 ---
 

{patchworks-1.3.2 → patchworks-1.3.4}/docs/getting_started.md

@@ -36,12 +36,25 @@ patchworks can be installed from PyPI on all operating systems, for Python ≥ 3
     pip install "patchworks[cellpose]"
     ```
 
+=== "With deconvolution + DoG plugin"
+
+    ```bash
+    pip install "patchworks[dog]"
+    ```
+
 === "Everything"
 
     ```bash
     pip install "patchworks[all]"
     ```
 
+!!! note "cupy is always a manual install"
+    `use_gpu=True` (the `dog` plugin, `dilate_labels`) needs `cupy`, but it's
+    never pulled in automatically — unlike Cellpose, which gets GPU support
+    for free via PyTorch's self-contained CUDA wheels, `cupy` ships one wheel
+    per CUDA major version. Install the one matching your CUDA version
+    yourself, e.g. `pip install cupy-cuda12x`.
+
 ---
 
 ## The one function you need

{patchworks-1.3.2 → patchworks-1.3.4}/docs/guide/custom_segmentation.md

@@ -74,6 +74,20 @@ tiles are merged, so `overlap` must still cover the dilation amount. On the
 cluster, set `dilate: N` in the config instead — see [Configure the
 run](snakemake.md#3-configure-the-run).
 
+By default the dilation itself runs on CPU (scipy), independent of whatever
+backend `fn` used — pass `use_gpu=True` to dilate via cupy instead:
+
+```python
+fn = dilate_labels(fn, iterations=2, use_gpu=True)
+```
+
+Needs `cupy` installed **manually**, matching your CUDA version (e.g.
+`pip install cupy-cuda12x`) — it's never installed automatically by
+patchworks, unlike Cellpose's GPU support (which comes for free via
+PyTorch's self-contained CUDA wheels); cupy ships one wheel per CUDA major
+version, so there's no single generic pin that works everywhere. On the
+cluster, this is the `dilate_gpu: true` config key.
+
 ## Real example: StarDist 3-D, with model caching
 
 Heavy models must be loaded **once**, not per tile. On SLURM each tile is its

{patchworks-1.3.2 → patchworks-1.3.4}/docs/guide/snakemake.md

@@ -65,6 +65,7 @@ empty_threshold: null          # null → Otsu
 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)
 cellpose:
   model: "cyto3"
   diameter: 30
@@ -80,8 +81,15 @@ 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`. `0` (default) disables it. See [Growing labels
-    afterwards](custom_segmentation.md#growing-labels-afterwards-dilation)
+    regardless of `method`. `0` (default) disables it. Runs on CPU (scipy)
+    by default; set `dilate_gpu: true` to dilate via cupy instead — that
+    needs `cupy` installed in the segment job's environment (matching your
+    CUDA version, e.g. `pip install cupy-cuda12x`) and a GPU allocated for
+    that job (`set-resources: segment:` in `profile/slurm/config.yaml`,
+    same as for a GPU `method`). It's independent of whatever `method`
+    itself runs on — you can dilate on GPU even with `method: "threshold"`
+    (CPU), or on CPU even with `method: "cellpose"` (GPU). See [Growing
+    labels afterwards](custom_segmentation.md#growing-labels-afterwards-dilation)
     for how it works and the equivalent direct-API call.
 
 !!! tip "Tile size vs runtime"

{patchworks-1.3.2 → patchworks-1.3.4}/workflow/config/config.yaml

@@ -30,7 +30,8 @@ empty_threshold: null # null → Otsu; or a number
 
 # ---- segmentation -----------------------------------------------------------
 method: "cellpose" # "cellpose" (GPU), "threshold" (no GPU; testing), "custom"
-# dilate: 2 # optional: pixels to grow labels by after segmentation, any method
+# dilate: 2       # optional: pixels to grow labels by after segmentation, any method
+# dilate_gpu: true # optional: dilate via cupy instead of scipy, needs a GPU
 # Also namespaces this run's intermediate files under work_dir/<label_name>/,
 # so a second segmentation (different label_name, e.g. nuclei vs cytoplasm)
 # can safely target the same work_dir — see docs/guide/snakemake.md

{patchworks-1.3.2 → patchworks-1.3.4}/workflow/config/config_cilia.yaml

@@ -25,7 +25,8 @@ skip_empty: true
 empty_threshold: null
 
 method: "custom"
-# dilate: 2 # optional: pixels to grow labels by after segmentation
+# dilate: 2       # optional: pixels to grow labels by after segmentation
+# dilate_gpu: true # optional: dilate via cupy instead of scipy, needs a GPU
 label_name: "cilia_labels"
 custom:
   module: "patchworks.plugins.dog"

{patchworks-1.3.2 → patchworks-1.3.4}/workflow/scripts/_pw.py

@@ -136,7 +136,10 @@ def build_fn(cfg):
         function (``cfg["custom"] = {module, function, kwargs}``). Optional
         ``cfg["dilate"]``: int, pixels to grow labels by after segmentation
         (via ``patchworks.dilate_labels``), applied regardless of ``method``.
-        Omitted/0 disables dilation.
+        Omitted/0 disables dilation. ``cfg["dilate_gpu"]``: bool, dilate via
+        cupyx instead of scipy (default ``False``); only takes effect when
+        ``dilate`` is set, and needs a GPU allocated for the segment job
+        (independent of whether ``method`` itself uses one).
 
     Returns
     -------
@@ -149,7 +152,7 @@ def build_fn(cfg):
     if dilate:
         from patchworks import dilate_labels
 
-        fn = dilate_labels(fn, iterations=dilate)
+        fn = dilate_labels(fn, iterations=dilate, use_gpu=cfg.get("dilate_gpu", False))
 
     return fn