From 4523d5759f466255cfb108cbddae0da74b395d5e Mon Sep 17 00:00:00 2001 From: Rushin Gindra Date: Mon, 31 Aug 2026 20:42:19 +0200 Subject: [PATCH 1/2] Document the segmentation pipeline Add a tutorial notebook that carries an OME-TIFF through InstanSeg nucleus segmentation to a SpatialData zarr, and register it in the docs. Name the zarr store for the slide's stem (`slide.ome.tif` -> `slide.zarr`) instead of the full filename, via a new `slide_stem` helper. Untrack the SLURM scripts; they are cluster-specific scratch. --- .gitignore | 16 +- docs/api.md | 35 +- docs/index.md | 3 + docs/installation.md | 13 + docs/notebooks/convert_to_ometiff.ipynb | 3 +- docs/notebooks/segment_nuclei.ipynb | 601 ++++++++++++++++++ docs/tutorials.md | 3 + scripts/geojson_to_spatialdata.py | 24 +- slurm/SEGMENTATION_PLAN.md | 178 ------ slurm/segment_node_worker.sh | 141 ---- slurm/segment_slurm.sh | 202 ------ src/spatialrefinery/core/utils.py | 29 + src/spatialrefinery/segmentation/instanseg.py | 4 +- .../segmentation/to_spatialdata.py | 13 + tests/test_segmentation.py | 20 +- tests/test_utils.py | 25 + 16 files changed, 766 insertions(+), 544 deletions(-) create mode 100644 docs/notebooks/segment_nuclei.ipynb delete mode 100644 slurm/SEGMENTATION_PLAN.md delete mode 100755 slurm/segment_node_worker.sh delete mode 100755 slurm/segment_slurm.sh diff --git a/.gitignore b/.gitignore index 313da81..c1ddb00 100644 --- a/.gitignore +++ b/.gitignore @@ -27,19 +27,11 @@ xenium_example/ # Local scratch work: new notebooks and scripts stay untracked by default # (already-tracked files are unaffected; use `git add -f` to version a new one) -/docs/notebooks/*.ipynb -/scripts/*.py +/scripts/convert_panel_sample.py /graphify-out/ /slurm/ /slurm-logs/ -# ...except the segmentation pipeline, which is part of the package's public -# surface rather than scratch: the CLI wrappers are documented entry points and -# the SLURM scripts are the supported way to run them on a cluster. -!/scripts/instanseg_segment.py -!/scripts/geojson_to_spatialdata.py -!/slurm/ -/slurm/* -!/slurm/segment_node_worker.sh -!/slurm/segment_slurm.sh -!/slurm/SEGMENTATION_PLAN.md +# ...except the segmentation pipeline's documented entry points: the tutorial +# notebook and the two CLI wrappers. The SLURM scripts stay untracked -- they +# are cluster-specific scratch. \ No newline at end of file diff --git a/docs/api.md b/docs/api.md index 1876b24..ccf7a50 100644 --- a/docs/api.md +++ b/docs/api.md @@ -1,8 +1,10 @@ # API reference This page documents the functions used in the [tutorial notebooks](tutorials.md): the two entry points for pulling raw -Xenium data and converting it to a [SpatialData](https://spatialdata.scverse.org/en/stable/) zarr store, and the one entry -point for converting whole-slide images to pyramidal OME-TIFF. All four are importable directly off the top-level package. +Xenium data and converting it to a [SpatialData](https://spatialdata.scverse.org/en/stable/) zarr store, the one entry +point for converting whole-slide images to pyramidal OME-TIFF, and the two that carry an H&E slide through nucleus +segmentation. The first four are importable directly off the top-level package; the segmentation pair is reached through +`spatialrefinery.segmentation`, since it needs the optional `segmentation` extra. ## Downloading @@ -35,9 +37,36 @@ Convert raw vendor bundles and whole-slide images into analysis-ready formats: a convert_to_ometiff ``` +## Segmenting + +Segment nuclei in an H&E whole-slide image with [InstanSeg](https://github.com/instanseg/instanseg), then package the +boundaries as a [SpatialData](https://spatialdata.scverse.org/en/stable/) zarr store. Needs the optional `segmentation` +extra -- see [Installation](installation.md). + +```{eval-rst} +.. currentmodule:: spatialrefinery.segmentation.instanseg + +.. autosummary:: + :toctree: generated + :nosignatures: + + segment_wsi +``` + +```{eval-rst} +.. currentmodule:: spatialrefinery.segmentation.to_spatialdata + +.. autosummary:: + :toctree: generated + :nosignatures: + + geojson_to_spatialdata + default_zarr_path +``` + :::{note} This reference is deliberately narrow. `spatialrefinery.core` and `spatialrefinery.io` contain additional lower-level machinery -- the technology/converter registry, `BaseDownloader`, `XeniumConverter`, and the pseudo-spot helpers in `core.utils` -- that other modules build on but that isn't part of the documented, stable surface yet. Expect it to change -without notice; the four functions above are the supported way to use `spatialrefinery`. +without notice; the functions above are the supported way to use `spatialrefinery`. ::: diff --git a/docs/index.md b/docs/index.md index f831724..81caa0d 100644 --- a/docs/index.md +++ b/docs/index.md @@ -79,6 +79,9 @@ any zoom level. * - Convert a whole-slide image to pyramidal OME-TIFF - {py:obj}`~spatialrefinery.convert_to_ometiff` - [Converting images to OME-TIFF](notebooks/convert_to_ometiff) +* - Segment nuclei in an H&E slide and store them as SpatialData + - {py:obj}`~spatialrefinery.segmentation.instanseg.segment_wsi` + - [Nucleus segmentation to SpatialData zarr](notebooks/segment_nuclei) ``` ```{toctree} diff --git a/docs/installation.md b/docs/installation.md index ac60e2f..5ec97d3 100644 --- a/docs/installation.md +++ b/docs/installation.md @@ -38,6 +38,19 @@ pip install "spatialrefinery[czi] @ git+https://github.com/peng-lab/spatialrefin Without the `czi` extra, {py:obj}`~spatialrefinery.convert_to_ometiff` still handles every other registered format (`.svs`, `.ndpi`, `.tif`, `.tiff`, `.mrxs`, `.scn`, `.bif`, `.vms`, `.svslide`) -- only `.czi` requires it. +## Optional: nucleus segmentation + +Nucleus segmentation on H&E whole-slide images needs the `segmentation` extra, which pulls +[InstanSeg](https://github.com/instanseg/instanseg) (`instanseg-torch`) plus `rasterio`, `geojson` and `tiffslide`: + +```bash +pip install "spatialrefinery[segmentation] @ git+https://github.com/peng-lab/spatialrefinery.git" +``` + +It is kept optional because `instanseg-torch` brings torch and therefore multi-GB CUDA wheels, which most +`spatialrefinery` uses do not need. A CUDA GPU is strongly recommended -- see +[Nucleus segmentation to SpatialData zarr](notebooks/segment_nuclei). + ## Verifying the install ```python diff --git a/docs/notebooks/convert_to_ometiff.ipynb b/docs/notebooks/convert_to_ometiff.ipynb index 7d1e17a..2c92d7b 100644 --- a/docs/notebooks/convert_to_ometiff.ipynb +++ b/docs/notebooks/convert_to_ometiff.ipynb @@ -303,7 +303,8 @@ "source": [ "## What's next\n", "\n", - "That's the full pipeline -- see the [API reference](../api.md) for the complete parameter list of each function used across these tutorials." + "Continue to [Nucleus segmentation to SpatialData zarr](segment_nuclei) to segment nuclei in the OME-TIFF you just\n", + "wrote and package them as a SpatialData zarr store." ] } ], diff --git a/docs/notebooks/segment_nuclei.ipynb b/docs/notebooks/segment_nuclei.ipynb new file mode 100644 index 0000000..782cd06 --- /dev/null +++ b/docs/notebooks/segment_nuclei.ipynb @@ -0,0 +1,601 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "cell-0", + "metadata": {}, + "source": [ + "# Nucleus segmentation to SpatialData zarr\n", + "\n", + "`spatialrefinery.segmentation` segments nuclei in an H&E whole-slide image and packages the result as a [SpatialData](https://spatialdata.scverse.org/en/stable/) zarr store. It is two functions and a `cells.geojson` between them: `segment_wsi` runs [InstanSeg](https://github.com/instanseg/instanseg) over the slide, and `geojson_to_spatialdata` turns its polygons into a zarr carrying the slide image, the nucleus boundaries, and a table annotating them.\n", + "\n", + "InstanSeg owns the whole-slide layer this needs -- tiling, cross-tile label matching, an Otsu tissue prefilter so background is never segmented, and GeoJSON export. The GeoJSON in between is a resume boundary: a failed conversion does not force re-segmentation.\n", + "\n", + "The table the conversion writes is all-zero counts over a template's `var`. Nucleus segmentation produces no expression data, so the table exists to give the shapes element a SpatialData-valid annotation -- and to fix the gene axis that inferred expression will later be written into.\n", + "\n", + "This picks up where {doc}`Converting images to OME-TIFF ` leaves off: the `.ome.tif` written there is exactly what `segment_wsi` reads. Segmentation needs the optional `segmentation` extra, which pulls `instanseg-torch` and therefore torch's multi-GB CUDA wheels:\n", + "\n", + "```bash\n", + "pip install \"spatialrefinery[segmentation] @ git+https://github.com/peng-lab/spatialrefinery.git\"\n", + "```\n", + "\n", + "**What you need:** one TIFF-backed slide (`.ome.tif`, `.svs`, `.ndpi`, ...), a template `.h5ad` whose `var` defines the gene axis, and a CUDA GPU. **Runtime:** on the 867 MB kidney H&E below, 8 minutes for segmentation (1239 tiles) and about a minute to write the zarr; CPU-only is possible but far slower." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "cell-1", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-31T18:12:39.083710Z", + "iopub.status.busy": "2026-08-31T18:12:39.083483Z", + "iopub.status.idle": "2026-08-31T18:12:43.491332Z", + "shell.execute_reply": "2026-08-31T18:12:43.490033Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/p/project1/hai_1240/spatialrefinery/.venv/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "from pathlib import Path\n", + "\n", + "import spatialdata as sd\n", + "import spatialdata_plot # noqa: F401 - registers the `.pl` accessor on SpatialData\n", + "\n", + "from spatialrefinery.segmentation.instanseg import segment_wsi\n", + "from spatialrefinery.segmentation.to_spatialdata import default_zarr_path, geojson_to_spatialdata" + ] + }, + { + "cell_type": "markdown", + "id": "cell-2", + "metadata": {}, + "source": [ + "## Parameters\n", + "\n", + "`SEG_OUTDIR` holds the per-slide segmentation results and `ZARR_OUTDIR` the SpatialData stores. They are kept apart deliberately: the GeoJSON stage is the expensive one, so it is worth preserving independently of any zarr you rebuild from it.\n", + "\n", + "`TEMPLATE_ADATA` is an AnnData whose `var` is the gene panel you intend to infer expression for. Only `var` is read -- `X`, `obs` and everything else are ignored -- so a panel definition saved from any matching study works." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "cell-3", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-31T18:12:43.495517Z", + "iopub.status.busy": "2026-08-31T18:12:43.494834Z", + "iopub.status.idle": "2026-08-31T18:12:43.499897Z", + "shell.execute_reply": "2026-08-31T18:12:43.498986Z" + } + }, + "outputs": [], + "source": [ + "WSI_PATH = Path(\n", + " \"/p/project1/hai_spatial_clip/data/phoenix_datasets/panels/multi_tissue/TENX/\"\n", + " \"Xenium_V1_hKidney_nondiseased_section/Xenium_V1_hKidney_nondiseased_section_he_image.ome.tif\"\n", + ")\n", + "SEG_OUTDIR = Path(\"/p/scratch/hai_1240/segmentation_files/segmentation_docs\")\n", + "ZARR_OUTDIR = Path(\"/p/scratch/hai_1240/segmentation_files\")\n", + "TEMPLATE_ADATA = Path(\"/p/scratch/hai_1240/segmentation_files/template_kidney_panel.h5ad\")\n", + "\n", + "SEG_OUTDIR.mkdir(parents=True, exist_ok=True)\n", + "ZARR_OUTDIR.mkdir(parents=True, exist_ok=True)" + ] + }, + { + "cell_type": "markdown", + "id": "cell-4", + "metadata": {}, + "source": [ + "## Step 1 -- segment nuclei\n", + "\n", + "`segment_wsi` writes `//cells.geojson`. The directory keeps the *full* filename, extension included, so that `a.svs` and `a.ndpi` cannot land on top of each other. `skip_existing=True` (the default) returns immediately when that file is already there, which makes an interrupted batch resumable.\n", + "\n", + "Two parameters are worth knowing before a first run:\n", + "\n", + "- **`pixel_size`** -- microns per pixel, read from the slide metadata when omitted. InstanSeg rejects anything outside [0.1, 1] micron, so pass it explicitly for slides whose resolution tags are missing or nonsensical. The slide here reports 0.2738, so it is left out.\n", + "- **`clahe_clip` / `seed_threshold`** -- InstanSeg normalises each tile by percentiles, so on weakly haematoxylin-stained slides pale nuclei fall below the seed threshold and are missed. Running CLAHE over each tile lifts local contrast (applied to L in LAB, so the H&E hue balance the model was trained on is preserved), and a lower seed threshold detects fainter nuclei. On this pale kidney section the two together found 83,554 nuclei against 67,168 at the defaults, +24.4%, with boundaries that hold up on visual inspection. Both are off by default; the values below are a reasonable start.\n", + "\n", + "`gpu_id` is the CUDA device index, or `None` to force CPU." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "cell-5", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-31T18:12:43.501984Z", + "iopub.status.busy": "2026-08-31T18:12:43.501842Z", + "iopub.status.idle": "2026-08-31T18:20:36.874251Z", + "shell.execute_reply": "2026-08-31T18:20:36.872895Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[34mINFO \u001b[0m Segmenting Xenium_V1_hKidney_nondiseased_section_he_image.ome.tif with \u001b[1;35mInstanSeg\u001b[0m\u001b[1m(\u001b[0mbrightfield_nuclei\u001b[1m)\u001b[0m on \n", + " cu\u001b[1;92mda:0\u001b[0m \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model brightfield_nuclei version 0.1.1 already downloaded in /p/project1/hai_1240/spatialrefinery/.venv/lib/python3.12/site-packages/instanseg/utils/../bioimageio_models/, loading\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[34mINFO \u001b[0m Applying CLAHE \u001b[1m(\u001b[0m\u001b[33mclip\u001b[0m=\u001b[1;36m2\u001b[0m\u001b[1;36m.0\u001b[0m\u001b[1m)\u001b[0m to each tile before inference \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + "Slide progress: 100%|\u001b[32m\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u001b[0m| 1239/1239 [07:07<00:00, 2.90it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Exporting to geojson\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\r", + "100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 38/38 [00:42<00:00, 1.11s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[34mINFO \u001b[0m Wrote \n", + " \u001b[35m/p/scratch/hai_1240/segmentation_files/segmentation_docs/Xenium_V1_hKidney_nondiseased_section_he_image.om\u001b[0m\n", + " \u001b[35me.tif/\u001b[0m\u001b[95mcells.geojson\u001b[0m \n" + ] + }, + { + "data": { + "text/plain": [ + "PosixPath('/p/scratch/hai_1240/segmentation_files/segmentation_docs/Xenium_V1_hKidney_nondiseased_section_he_image.ome.tif/cells.geojson')" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "geojson_path = segment_wsi(\n", + " WSI_PATH,\n", + " SEG_OUTDIR,\n", + " gpu_id=0,\n", + " clahe_clip=2.0,\n", + " seed_threshold=0.4,\n", + ")\n", + "geojson_path" + ] + }, + { + "cell_type": "markdown", + "id": "cell-6", + "metadata": {}, + "source": [ + "## Step 2 -- build the SpatialData zarr\n", + "\n", + "`geojson_to_spatialdata` assembles three elements:\n", + "\n", + "- `images[\"he_image\"]` -- a lazy multiscale image built straight from the slide's own pyramid through `tifffile`'s zarr interface, so dask reads only the blocks a write touches. A level-0 plane on this slide is 33427 x 11949 x 3, about 1.1 GiB if it were materialised.\n", + "- `shapes[\"nucleus_boundaries\"]` -- one polygon per nucleus, in pixel coordinates.\n", + "- `tables[\"table\"]` -- all-zero counts over `TEMPLATE_ADATA`'s `var`, annotating the shapes, with nucleus centroids in `obsm[\"spatial\"]`.\n", + "\n", + "`default_zarr_path` gives the store its conventional name: the slide's stem plus `.zarr`, so `Xenium_..._he_image.ome.tif` becomes `Xenium_..._he_image.zarr`. The whole extension goes, which `Path.stem` alone would not do -- it strips only the last suffix and would leave `...he_image.ome`. Note this differs from step 1, whose directory keeps the full filename.\n", + "\n", + "`write_zip=True` (the default) also writes an uncompressed `.zarr.zip` beside the store. A zarr is tens of thousands of small files; the archive is what you actually move between filesystems.\n", + "\n", + "The function also returns the object it just wrote, but its image element is still backed by the slide's own TIFF rather than by the zarr. Read the store back from disk instead, as the next cell does -- that is what any downstream consumer sees." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "cell-7", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-31T18:20:36.877581Z", + "iopub.status.busy": "2026-08-31T18:20:36.877133Z", + "iopub.status.idle": "2026-08-31T18:21:49.441484Z", + "shell.execute_reply": "2026-08-31T18:21:49.439798Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/p/scratch/hai_1240/segmentation_files/Xenium_V1_hKidney_nondiseased_section_he_image.zarr\n", + "\u001b[34mINFO \u001b[0m Exploding multi-polygons from \n", + " \u001b[35m/p/scratch/hai_1240/segmentation_files/segmentation_docs/Xenium_V1_hKidney_nondiseased_section_he_image.om\u001b[0m\n", + " \u001b[35me.tif/\u001b[0m\u001b[95mcells.geojson\u001b[0m \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/p/project1/hai_1240/spatialrefinery/.venv/lib/python3.12/site-packages/pyogrio/geopandas.py:948: UserWarning: 'crs' was not provided. The output dataset will not have projection information defined and may not be usable in other systems.\n", + " write(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[34mINFO \u001b[0m Reading exploded GeoJSON \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[34mINFO \u001b[0m Loading template AnnData: \u001b[35m/p/scratch/hai_1240/segmentation_files/\u001b[0m\u001b[95mtemplate_kidney_panel.h5ad\u001b[0m \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[34mINFO \u001b[0m Building SpatialData object \u001b[1m(\u001b[0m\u001b[1;36m83554\u001b[0m nuclei\u001b[1m)\u001b[0m \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[34mINFO \u001b[0m Writing SpatialData zarr to \n", + " \u001b[35m/p/scratch/hai_1240/segmentation_files/\u001b[0m\u001b[95mXenium_V1_hKidney_nondiseased_section_he_image.zarr\u001b[0m \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/p/project1/hai_1240/spatialrefinery/.venv/lib/python3.12/site-packages/spatialdata/_core/spatialdata.py:477: UserWarning: Converting `region_key: region` to categorical dtype.\n", + " convert_region_column_to_categorical(table)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[34mINFO \u001b[0m Creating uncompressed zip archive \n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wrote Xenium_V1_hKidney_nondiseased_section_he_image.zarr and Xenium_V1_hKidney_nondiseased_section_he_image.zarr.zip\n" + ] + } + ], + "source": [ + "zarr_path = default_zarr_path(WSI_PATH, ZARR_OUTDIR)\n", + "print(zarr_path)\n", + "\n", + "geojson_to_spatialdata(\n", + " geojson_path=geojson_path,\n", + " zarr_path=zarr_path,\n", + " image_path=WSI_PATH,\n", + " template_adata_path=TEMPLATE_ADATA,\n", + ")\n", + "print(f\"wrote {zarr_path.name} and {zarr_path.name}.zip\")" + ] + }, + { + "cell_type": "markdown", + "id": "cell-8", + "metadata": {}, + "source": [ + "## Inspect the result\n", + "\n", + "Read the store back from disk -- the same thing any downstream consumer sees." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "cell-9", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-31T18:21:49.446284Z", + "iopub.status.busy": "2026-08-31T18:21:49.445840Z", + "iopub.status.idle": "2026-08-31T18:21:50.128121Z", + "shell.execute_reply": "2026-08-31T18:21:50.126635Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "83,554 nuclei over a 377-gene panel\n" + ] + }, + { + "data": { + "text/plain": [ + "SpatialData object, with associated Zarr store: /p/scratch/hai_1240/segmentation_files/Xenium_V1_hKidney_nondiseased_section_he_image.zarr\n", + "\u251c\u2500\u2500 Images\n", + "\u2502 \u2514\u2500\u2500 'he_image': DataTree[cyx] (3, 33427, 11949), (3, 16713, 5974), (3, 8356, 2987), (3, 4178, 1493), (3, 2089, 746)\n", + "\u251c\u2500\u2500 Shapes\n", + "\u2502 \u2514\u2500\u2500 'nucleus_boundaries': GeoDataFrame shape: (83554, 1) (2D shapes)\n", + "\u2514\u2500\u2500 Tables\n", + " \u2514\u2500\u2500 'table': AnnData (83554, 377)\n", + "with coordinate systems:\n", + " \u25b8 'global', with elements:\n", + " he_image (Images), nucleus_boundaries (Shapes)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sdata = sd.read_zarr(zarr_path)\n", + "print(f\"{len(sdata['nucleus_boundaries']):,} nuclei over a {sdata['table'].shape[1]}-gene panel\")\n", + "sdata" + ] + }, + { + "cell_type": "markdown", + "id": "cell-10", + "metadata": {}, + "source": [ + "At full-slide zoom the nuclei are subpixel, so the overlay reads as tissue-shaped coverage: useful for checking that the Otsu prefilter kept to the tissue and did not wander into background." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "cell-11", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-31T18:21:50.130603Z", + "iopub.status.busy": "2026-08-31T18:21:50.130412Z", + "iopub.status.idle": "2026-08-31T18:22:00.120016Z", + "shell.execute_reply": "2026-08-31T18:22:00.118220Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sdata.pl.render_images(\"he_image\").pl.render_shapes(\n", + " \"nucleus_boundaries\",\n", + " color=\"yellow\",\n", + " fill_alpha=0.7,\n", + " outline_width=1.0,\n", + " outline_alpha=1.0,\n", + " outline_color=\"red\",\n", + ").pl.show()" + ] + }, + { + "cell_type": "markdown", + "id": "cell-12", + "metadata": {}, + "source": [ + "Individual boundaries only become visible on a crop. `query.bounding_box` subsets every element at once, in pixel coordinates on the `\"global\"` system." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "cell-13", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-31T18:22:00.123803Z", + "iopub.status.busy": "2026-08-31T18:22:00.123626Z", + "iopub.status.idle": "2026-08-31T18:22:01.925801Z", + "shell.execute_reply": "2026-08-31T18:22:01.924215Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cropped = sdata.query.bounding_box(\n", + " axes=[\"x\", \"y\"],\n", + " min_coordinate=[5000, 15000],\n", + " max_coordinate=[6000, 16000],\n", + " target_coordinate_system=\"global\",\n", + ")\n", + "\n", + "cropped.pl.render_images(\"he_image\").pl.render_shapes(\n", + " \"nucleus_boundaries\",\n", + " fill_alpha=0.0,\n", + " outline_width=1.0,\n", + " outline_alpha=1.0,\n", + " outline_color=\"red\",\n", + ").pl.show()" + ] + }, + { + "cell_type": "markdown", + "id": "cell-14", + "metadata": {}, + "source": [ + "## Expected output structure\n", + "\n", + "```text\n", + "segmentation_docs/\n", + "\u2514\u2500\u2500 Xenium_V1_hKidney_nondiseased_section_he_image.ome.tif/ # full filename\n", + " \u2514\u2500\u2500 cells.geojson\n", + "\n", + "Xenium_V1_hKidney_nondiseased_section_he_image.zarr/ # stem only\n", + "\u251c\u2500\u2500 images/he_image/ # multiscale, 5 pyramid levels\n", + "\u251c\u2500\u2500 shapes/nucleus_boundaries/\n", + "\u251c\u2500\u2500 tables/table/\n", + "\u2514\u2500\u2500 zmetadata\n", + "Xenium_V1_hKidney_nondiseased_section_he_image.zarr.zip\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "cell-15", + "metadata": {}, + "source": [ + "## Batch processing multiple slides\n", + "\n", + "Both stages skip work that is already on disk, so the loop below is safe to re-run over a directory: it picks up where an interrupted batch stopped rather than re-segmenting everything." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "cell-16", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-31T18:22:01.931751Z", + "iopub.status.busy": "2026-08-31T18:22:01.931471Z", + "iopub.status.idle": "2026-08-31T18:22:01.939887Z", + "shell.execute_reply": "2026-08-31T18:22:01.938651Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Wrote 0 SpatialData store(s)\n" + ] + } + ], + "source": [ + "WSI_DIR = Path(\"ometiff_output\")\n", + "written: list[Path] = []\n", + "\n", + "for wsi in sorted(WSI_DIR.glob(\"*.ome.tif\")):\n", + " zarr_out = default_zarr_path(wsi, ZARR_OUTDIR)\n", + " if zarr_out.exists():\n", + " print(f\"Skipping {wsi.name}: {zarr_out.name} already exists\")\n", + " continue\n", + "\n", + " try:\n", + " cells = segment_wsi(wsi, SEG_OUTDIR, gpu_id=0, clahe_clip=2.0, seed_threshold=0.4)\n", + " geojson_to_spatialdata(\n", + " geojson_path=cells,\n", + " zarr_path=zarr_out,\n", + " image_path=wsi,\n", + " template_adata_path=TEMPLATE_ADATA,\n", + " )\n", + " except Exception as e: # noqa: BLE001 - one slide's failure must not abort the batch\n", + " print(f\"Failed on {wsi.name}: {e}\")\n", + " continue\n", + "\n", + " written.append(zarr_out)\n", + "\n", + "print(f\"Wrote {len(written)} SpatialData store(s)\")" + ] + }, + { + "cell_type": "markdown", + "id": "cell-17", + "metadata": {}, + "source": [ + "## Running this as a script\n", + "\n", + "The two stages have one CLI wrapper each, split on the same `cells.geojson` boundary. `instanseg_segment.py` prints `GEOJSON_PATH=` and `geojson_to_spatialdata.py` prints `ZARR_PATH=`, so they chain in a shell:\n", + "\n", + "```bash\n", + "python scripts/instanseg_segment.py \\\n", + " --wsi-path slide.ome.tif \\\n", + " --outdir segmentation/ \\\n", + " --gpu-id 0 \\\n", + " --clahe 2.0 \\\n", + " --seed-threshold 0.4\n", + "\n", + "python scripts/geojson_to_spatialdata.py \\\n", + " --geojson-path segmentation/slide.ome.tif/cells.geojson \\\n", + " --zarr-outdir zarrs/ \\\n", + " --wsi-path slide.ome.tif \\\n", + " --template-adata template.h5ad\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "cell-18", + "metadata": {}, + "source": [ + "## What's next\n", + "\n", + "That's the full pipeline -- see the [API reference](../api.md) for the complete parameter list of each function used across these tutorials." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "spatialrefinery (3.12.0)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/tutorials.md b/docs/tutorials.md index 2e403ea..1b13f1d 100644 --- a/docs/tutorials.md +++ b/docs/tutorials.md @@ -10,6 +10,8 @@ with the plain command-line invocation if you'd rather run it as a batch job. store, with aligned H&E images and Visium-like pseudo-spots. 3. **[Converting images to OME-TIFF](notebooks/convert_to_ometiff)** -- convert whole-slide/microscopy images to pyramidal OME-TIFF for fast, multi-resolution viewing. +4. **[Nucleus segmentation to SpatialData zarr](notebooks/segment_nuclei)** -- segment nuclei in an H&E whole-slide image + with InstanSeg and package the boundaries as a SpatialData zarr store. ```{toctree} :hidden: true @@ -18,4 +20,5 @@ with the plain command-line invocation if you'd rather run it as a batch job. notebooks/xenium_download notebooks/xenium_to_zarr notebooks/convert_to_ometiff +notebooks/segment_nuclei ``` diff --git a/scripts/geojson_to_spatialdata.py b/scripts/geojson_to_spatialdata.py index 68f3fcb..61102f7 100755 --- a/scripts/geojson_to_spatialdata.py +++ b/scripts/geojson_to_spatialdata.py @@ -8,8 +8,21 @@ Usage ----- python geojson_to_spatialdata.py \\ - --geojson-path results/slide.svs/cells.geojson \\ - --zarr-outdir zarrs/ --wsi-path slide.svs --template-adata template.h5ad + --geojson-path results/slide.ome.tif/cells.geojson \\ + --zarr-outdir zarrs/ --wsi-path slide.ome.tif --template-adata template.h5ad + +The store is named for the slide's stem, so the example above writes +`zarrs/slide.zarr` (plus `zarrs/slide.zarr.zip`). + +Stores written before this convention are named for the full filename +(`slide.ome.tif.zarr`). The skip-existing check only looks for the new name, so +re-running rebuilds them rather than skipping; rename them instead: + + for z in "$ZARR_OUTDIR"/*.ome.tif.zarr; do echo "$z -> ${z%.ome.tif.zarr}.zarr"; done # dry run + for z in "$ZARR_OUTDIR"/*.ome.tif.zarr; do mv "$z" "${z%.ome.tif.zarr}.zarr"; done + for z in "$ZARR_OUTDIR"/*.ome.tif.zarr.zip; do mv "$z" "${z%.ome.tif.zarr.zip}.zarr.zip"; done + +A zarr store records no path of its own, so a rename is all that is needed. """ import argparse @@ -17,7 +30,7 @@ import sys from pathlib import Path -from spatialrefinery.segmentation.to_spatialdata import geojson_to_spatialdata +from spatialrefinery.segmentation.to_spatialdata import default_zarr_path, geojson_to_spatialdata logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s") logger = logging.getLogger(__name__) @@ -51,8 +64,9 @@ def main() -> None: logger.error("%s file not found: %s", label, path) sys.exit(1) - # Named with the full filename, matching the segmentation stage's layout. - zarr_path = Path(args.zarr_outdir) / f"{wsi_path.name}.zarr" + # Named for the stem, so `slide.ome.tif` gives `slide.zarr`. Unlike the + # segmentation stage's per-slide directory, which keeps the full filename. + zarr_path = default_zarr_path(wsi_path, args.zarr_outdir) if zarr_path.exists() and not args.no_skip_existing: logger.info("Skipping %s: %s already exists", wsi_path.name, zarr_path) sys.exit(0) diff --git a/slurm/SEGMENTATION_PLAN.md b/slurm/SEGMENTATION_PLAN.md deleted file mode 100644 index 90c8c9a..0000000 --- a/slurm/SEGMENTATION_PLAN.md +++ /dev/null @@ -1,178 +0,0 @@ -# Nucleus segmentation on H&E whole-slide images - -Status: **implemented** on branch `worktree-instanseg-segmentation`, 2026-08-31. - -Design notes for the segmentation pipeline: `spatialrefinery.segmentation`, -its CLI wrappers in `scripts/`, and the SLURM launchers here. - -## Approach - -Segmentation uses [InstanSeg](https://github.com/instanseg/instanseg) -(`instanseg-torch`), whose `brightfield_nuclei` model is the default and is -trained for H&E. - -The decisive property for this pipeline is that InstanSeg owns the -**whole-slide layer**: `eval_whole_slide_image` handles tiling, cross-tile -label matching (`match_labels`), an Otsu tissue prefilter, and GeoJSON export. -Writing that layer by hand is the expensive part of whole-slide segmentation — -cross-tile instance deduplication in particular — so a model that ships it is -worth considerably more than one that does not. - -Its runtime requirements are also undemanding: `numpy>=1.24` and `torch>=2.0` -with no upper bounds, so it installs additively into this project's existing -environment. Verified: 31 packages added, **zero removed**; `numpy`, -`pydantic`, `zarr` and `spatialdata` all untouched. - -```python -model = InstanSeg("brightfield_nuclei", image_reader="tiffslide") -model.eval_whole_slide_image( - image=str(wsi_path), - pixel_size=wsi_mpp, # else read from slide metadata - tile_size=512, overlap=80, - use_otsu_threshold=True, # skip background tiles - save_geojson=True, -) -``` - -## Three upstream defects had to be bridged - -All three are in `instanseg` 0.1.1 and unchanged on `main`. They are patched at -call time in `segmentation/_compat.py`, never vendored, so deleting that module -is all it will take once upstream fixes them. Each is pinned by a test. - -1. **zarr 3.** `eval_whole_slide_image` builds its canvas with - `zarr.DirectoryStore`, which zarr 3 renamed to `zarr.storage.LocalStore`. - InstanSeg pins `zarr>=2.0.0,<3` in its `io` extra as a result — and that cap - collides with `spatialdata` (`zarr>=3.0.0`) and `anndata` (`zarr>=3.1`). - **Installing `instanseg-torch[io]` silently downgrades zarr, numcodecs and - tiffslide and breaks spatialdata.** The `segmentation` extra therefore names - `rasterio` and `geojson` directly. The pin's stated reason ("tiffslide - doesn't support zarr v3 yet") is stale as of tiffslide 4.0 - (Bayer-Group/tiffslide#97); only the *name* is missing, and `LocalStore` is - a drop-in for all four operations InstanSeg performs on the store. -2. **`TiffSlide` is never imported.** `read_slide` calls `TiffSlide(...)` at - `inference_class.py:236`, but every import of that name in the module is - function-local, so the global is unbound and any whole-slide call raises - `NameError` before reading a single tile. -3. **The GeoJSON it writes is invalid.** The exporter emits a comma after every - feature and then closes the array, so output ends `...}},\n]`. `json.load` - rejects it, and so does QuPath. Repaired in the artefact rather than worked - around at read time, so the published file is valid for any consumer. - -Defects 2 and 3 together mean InstanSeg's whole-slide path cannot have been run -end to end upstream. All three are worth reporting. - -## Layout - -Logic lives in the package; `scripts/` holds thin wrappers, matching -`scripts/convert_to_ometiff.py`. - -| File | Purpose | -|---|---| -| `src/spatialrefinery/segmentation/_compat.py` | the three bridges above | -| `src/spatialrefinery/segmentation/instanseg.py` | `segment_wsi()` — slide → `cells.geojson` | -| `src/spatialrefinery/segmentation/to_spatialdata.py` | `geojson_to_spatialdata()` | -| `scripts/instanseg_segment.py` | CLI; emits the `GEOJSON_PATH=` contract | -| `scripts/geojson_to_spatialdata.py` | CLI | -| `slurm/segment_node_worker.sh` | per-node worker, round-robin across GPUs | -| `slurm/segment_slurm.sh` | manifest + sbatch launcher | -| `tests/test_compat.py`, `tests/test_segmentation.py` | 24 tests | - -The two stages exchange a `cells.geojson` rather than being merged: it is a -resume boundary, so a conversion failure does not force re-segmentation. - -Implementation details worth knowing: - -- **Outputs are redirected.** InstanSeg writes its `.zarr` and `.geojson` next - to the *input* file; slides usually sit on read-only dataset mounts, so - `segment_wsi` runs the model against a symlink inside the output directory. -- **The image element is built lazily** from the slide's own pyramid via - `tifffile`'s zarr interface — a level-0 plane on the test slide is - 33427 × 11949 × 3, about 1.1 GiB if materialised. -- **CRS is cleared before centroids are taken.** `gpd.read_file` tags GeoJSON - as EPSG:4326, but these are pixel coordinates; left in place, `.centroid` is - computed against a spherical datum and every centroid drifts. -- **`.gitignore`** ignores `/scripts/*.py` and `/slurm/` as scratch; explicit - negations track this pipeline. - -## Sensitivity on pale slides - -On weakly haematoxylin-stained slides InstanSeg misses pale nuclei. The cause -is staining, not the model: the crop measured has **median lightness 205/255** -(1st percentile 119), and the nuclei found were the darker ones. InstanSeg -normalises each tile with `percentile_normalize`, a *global* stretch over the -tile; where bright cytoplasm dominates the histogram it does not lift pale -nuclei above the seed threshold (default 0.7). - -Measured on one 1000 × 1000 crop: - -| variant | nuclei | vs default | -|---|---|---| -| default | 209 | — | -| `seed_threshold=0.3` | 222 | +6% | -| percentile stretch 1–99 | 219 | +5% | -| **CLAHE clip=2** | **254** | **+22%** | -| **CLAHE clip=2 + `seed_threshold=0.4`** | **266** | **+27%** | -| haematoxylin colour deconvolution | 97 | −54% | - -Overlays confirmed the extra detections are real nuclei with tight boundaries. -Two things were ruled out: **resolution is not the bottleneck** (InstanSeg -downsamples 1.83× from 0.2738 to its native 0.5 µm; suppressing that gained -+2%), and **colour deconvolution actively hurts** — the brightfield model wants -true H&E appearance. - -Confirmed on the **whole slide** (8m52s end to end, versus 8m40s without — -CLAHE costs nothing measurable): - -| | default | `--clahe 2.0 --seed-threshold 0.4` | -|---|---|---| -| nuclei | 67,168 | **83,554 (+24.4%)** | -| median area | 318 px² | 339 px² | -| objects < 20 px² | 54 | 106 (0.13% of total) | - -The area distribution shifted **up** at every percentile from 1 to 99, which is -the reassuring direction: a flood of spurious fragments would have pulled the -median down. External sanity check: Xenium's own DAPI-based segmentation of -this sample has 97,560 cells, so the default recovered 69% of that from H&E and -CLAHE 86% — different images, so exact agreement is not expected. - -Both controls are **opt-in and off by default**, so runs stay reproducible: -`--clahe 2.0 --seed-threshold 0.4` on the CLI, `CLAHE` and `SEED_THRESHOLD` on -`segment_slurm.sh`. CLAHE is applied to L in LAB (hue preserved) by wrapping -`model._to_tensor`, the single point every tile passes through in the -whole-slide loop — no fork required. Per-tile is the right granularity for an -adaptive method; the 80 px overlap and cross-tile label matching absorb seam -discontinuities. - -## Verification - -1. Driver check — CUDA 13 wheels were the main rollout risk: - `nvidia-smi --query-gpu=driver_version --format=csv` → **595.71.05**, fine, - Turing sm_75 included. -2. Environment coherence after install — `numpy 2.4.6`, `pydantic 2.12.5`, - `zarr 3.3.0`, `spatialdata 0.8.0`, `anndata 0.13.2` all unchanged. -3. `pytest tests/` → 86 passed locally; 84 passed + 2 skipped in the CI hatch - environments on both py3.12 and py3.14 (the skips are the tests needing the - optional `segmentation` extra). `prek run --all-files` clean. -4. End to end on `Xenium_V1_hKidney_nondiseased_section_he_image.ome.tif` - (867 MB, 33427 × 11949, mpp 0.2738 read from metadata): - - | stage | result | - |---|---| - | segmentation | 7m49s, 1239 tiles, 51 MB `cells.geojson`, 83,554 nuclei | - | conversion | 67s, SpatialData zarr | - - Read back: image `DataTree[cyx] (3, 33427, 11949)` with 5 pyramid levels; - `nucleus_boundaries` 83,554 Polygons, geometry column only; table - `(83554, 377)` over the Xenium panel; `obs` = `region`, `instance_id`; - centroids within slide bounds. - -## Risks - -- **InstanSeg's WSI support is documented as "limited."** It held on a 400 Mpx - slide; validate on the largest slide in a cohort before batch rollout. -- **The `[io]` extra must never be installed** — see defect 1. -- **The +24.4% is one slide from one tissue.** If staining varies across a - cohort, `--clahe 2.0` may want tuning per batch before becoming a default. -- **GPU memory** ran ~35 GB with CLAHE versus ~12 GB without. Fine on a 46 GB - card, but lower `--tile-size` if fanning out 4 GPUs per node hits OOM. diff --git a/slurm/segment_node_worker.sh b/slurm/segment_node_worker.sh deleted file mode 100755 index ebc5985..0000000 --- a/slurm/segment_node_worker.sh +++ /dev/null @@ -1,141 +0,0 @@ -#!/bin/bash - -# ============================================================================== -# InstanSeg + SpatialData: per-node worker -# ============================================================================== -# Called by srun on each allocated node. Reads a manifest chunk (one WSI path -# per line) and processes the slides in parallel across the node's GPUs, using -# round-robin assignment. -# -# Both stages run in the same interpreter, from the project venv. -# -# They exchange a cells.geojson rather than being merged: it is a resume -# boundary, so a conversion failure does not force re-segmentation. -# -# Usage: invoked by slurm/segment_slurm.sh, not directly. -# bash segment_node_worker.sh \ -# [wsi_mpp] [tile_size] [overlap] \ -# [clahe_clip] [seed_threshold] -# ============================================================================== - -set -euo pipefail - -MANIFEST_CHUNK="$1" -SEG_OUTDIR="$2" -ZARR_OUTDIR="$3" -TEMPLATE_ADATA="$4" -GPUS_PER_NODE="${5:-4}" -WSI_MPP="${6:-}" -TILE_SIZE="${7:-512}" -OVERLAP="${8:-80}" -CLAHE="${9:-}" # empty = off -SEED_THRESHOLD="${10:-}" # empty = model default (0.7) - -REPO_ROOT="${REPO_ROOT:-/p/project1/hai_1240/spatialrefinery}" -PY="${PY:-${REPO_ROOT}/.venv/bin/python}" - -SEGMENT_SCRIPT="${REPO_ROOT}/scripts/instanseg_segment.py" -CONVERT_SCRIPT="${REPO_ROOT}/scripts/geojson_to_spatialdata.py" - -LOG_DIR="${LOG_DIR:-$(dirname "$ZARR_OUTDIR")/slurm_logs}" -mkdir -p "$LOG_DIR" - -if [ ! -x "$PY" ]; then - echo "ERROR: interpreter not found: $PY" >&2 - echo " Create it with: uv sync --extra segmentation" >&2 - exit 2 -fi - -echo "=======================================================" -echo "NODE WORKER: $(hostname)" -echo " Manifest chunk: $MANIFEST_CHUNK" -echo " GPUs per node: $GPUS_PER_NODE" -echo " Interpreter: $PY" -echo " Started at: $(date -Is)" -echo "=======================================================" - -mapfile -t WSI_LIST < "$MANIFEST_CHUNK" -TOTAL_WSIS=${#WSI_LIST[@]} - -if [ "$TOTAL_WSIS" -eq 0 ]; then - echo "No WSIs in manifest chunk. Nothing to do." - exit 0 -fi - -echo "Processing $TOTAL_WSIS WSIs across $GPUS_PER_NODE GPUs..." - -OPTIONAL_ARGS=() -if [ -n "$WSI_MPP" ]; then - OPTIONAL_ARGS+=(--wsi-mpp "$WSI_MPP") -fi -if [ -n "$CLAHE" ]; then - OPTIONAL_ARGS+=(--clahe "$CLAHE") -fi -if [ -n "$SEED_THRESHOLD" ]; then - OPTIONAL_ARGS+=(--seed-threshold "$SEED_THRESHOLD") -fi - -process_wsi() { - local WSI_PATH="$1" - local GPU_ID="$2" - local SAMPLE_NAME - SAMPLE_NAME=$(basename "$WSI_PATH") - local LOG_FILE="${LOG_DIR}/${SAMPLE_NAME}_gpu${GPU_ID}.log" - - { - echo "### [$SAMPLE_NAME] GPU $GPU_ID -- $(date -Is)" - - echo "--- Stage 1: InstanSeg segmentation ---" - # The process sees one GPU, so --gpu-id stays 0. - local SEGMENT_OUT - SEGMENT_OUT=$(CUDA_VISIBLE_DEVICES="$GPU_ID" "$PY" "$SEGMENT_SCRIPT" \ - --wsi-path "$WSI_PATH" \ - --outdir "$SEG_OUTDIR" \ - --gpu-id 0 \ - --tile-size "$TILE_SIZE" \ - --overlap "$OVERLAP" \ - "${OPTIONAL_ARGS[@]}" 2>&1) - echo "$SEGMENT_OUT" - - local GEOJSON_PATH - GEOJSON_PATH=$(echo "$SEGMENT_OUT" | grep '^GEOJSON_PATH=' | tail -1 | cut -d= -f2-) - if [ -z "$GEOJSON_PATH" ]; then - GEOJSON_PATH="$SEG_OUTDIR/$SAMPLE_NAME/cells.geojson" - fi - if [ ! -f "$GEOJSON_PATH" ]; then - echo "FAILED: stage 1 produced no cells.geojson at $GEOJSON_PATH" - exit 1 - fi - echo "Stage 1 complete: $GEOJSON_PATH" - - echo "--- Stage 2: SpatialData conversion ---" - "$PY" "$CONVERT_SCRIPT" \ - --geojson-path "$GEOJSON_PATH" \ - --zarr-outdir "$ZARR_OUTDIR" \ - --wsi-path "$WSI_PATH" \ - --template-adata "$TEMPLATE_ADATA" - - echo "[$SAMPLE_NAME] done at $(date -Is)" - } > "$LOG_FILE" 2>&1 -} - -for i in "${!WSI_LIST[@]}"; do - WSI_PATH="${WSI_LIST[$i]}" - GPU_ID=$((i % GPUS_PER_NODE)) - echo "---> [$((i + 1))/$TOTAL_WSIS] $(basename "$WSI_PATH") -> GPU $GPU_ID" - - process_wsi "$WSI_PATH" "$GPU_ID" & - - if (( $(jobs -rp | wc -l) >= GPUS_PER_NODE )); then - wait -n || echo "A worker exited non-zero (continuing with remaining WSIs)" - fi -done - -echo "Waiting for remaining workers..." -wait - -echo "=======================================================" -echo "NODE WORKER: $(hostname) - COMPLETE" -echo " Processed: $TOTAL_WSIS WSIs" -echo " Finished at: $(date -Is)" -echo "=======================================================" diff --git a/slurm/segment_slurm.sh b/slurm/segment_slurm.sh deleted file mode 100755 index 7d1ccee..0000000 --- a/slurm/segment_slurm.sh +++ /dev/null @@ -1,202 +0,0 @@ -#!/bin/bash - -# ============================================================================== -# SLURM launcher: InstanSeg segmentation + SpatialData conversion -# ============================================================================== -# Discovers WSI files, writes a manifest, and submits a job that spreads the -# slides across nodes (each with several GPUs). -# -# Usage: -# ./segment_slurm.sh [sample_subset] -# -# Examples: -# ./slurm/segment_slurm.sh /data/wsis /data/seg /data/zarr /data/template.h5ad -# NODES=4 ./slurm/segment_slurm.sh /data/wsis /data/seg /data/zarr /data/template.h5ad s1,s2 -# ============================================================================== - -set -euo pipefail - -ACCOUNT="${ACCOUNT:-hai_1240}" -PARTITION="${PARTITION:-dc-hwai}" -NODES="${NODES:-1}" -GPUS_PER_NODE="${GPUS_PER_NODE:-4}" -TIME="${TIME:-24:00:00}" -MEMORY="${MEMORY:-500G}" -CPUS_PER_NODE="${CPUS_PER_NODE:-64}" - -# Segmentation settings. InstanSeg tiles internally, so there is no batch size -# or worker pool to size here. -WSI_MPP="${WSI_MPP:-}" # empty = read from slide metadata -TILE_SIZE="${TILE_SIZE:-512}" -OVERLAP="${OVERLAP:-80}" -# Sensitivity, both off by default. Worth setting on weakly stained cohorts: -# CLAHE=2.0 with SEED_THRESHOLD=0.4 recovered 27% more nuclei on a pale kidney H&E. -CLAHE="${CLAHE:-}" -SEED_THRESHOLD="${SEED_THRESHOLD:-}" - -WSI_EXTENSIONS=("svs" "ndpi" "ome.tif" "ome.tiff" "tif" "tiff" "mrxs") - -REPO_ROOT="${REPO_ROOT:-/p/project1/hai_1240/spatialrefinery}" -PY="${PY:-${REPO_ROOT}/.venv/bin/python}" -NODE_WORKER_SCRIPT="${REPO_ROOT}/slurm/segment_node_worker.sh" - -if [ "$#" -lt 4 ] || [ "$#" -gt 5 ]; then - cat < [comma_separated_sample_ids] - -Environment variables: - NODES=4 Number of nodes (default: 1) - GPUS_PER_NODE=4 GPUs per node (default: 4) - WSI_MPP=0.2738 Microns per pixel (default: read from slide metadata) - TILE_SIZE=512 InstanSeg tile size (default: 512) - OVERLAP=80 Tile overlap in pixels (default: 80) - CLAHE=2.0 CLAHE clip limit for pale slides (default: off) - SEED_THRESHOLD=0.4 Model seed threshold (default: off, model uses 0.7) - TIME=24:00:00 Max runtime - MEMORY=500G Memory per node - REPO_ROOT=... Repo checkout (default: $REPO_ROOT) -USAGE - exit 1 -fi - -WSI_DIR="$1" -SEG_OUTDIR="$2" -ZARR_OUTDIR="$3" -TEMPLATE_ADATA="$4" -SAMPLE_SUBSET="${5:-}" - -BASE_PATH="$(dirname "$ZARR_OUTDIR")" -LOG_DIR="${BASE_PATH}/slurm_logs" -MANIFEST_DIR="${BASE_PATH}/manifests" - -mkdir -p "$SEG_OUTDIR" "$ZARR_OUTDIR" "$LOG_DIR" "$MANIFEST_DIR" - -if [ ! -d "$WSI_DIR" ]; then - echo "ERROR: WSI directory not found: $WSI_DIR" >&2 - exit 1 -fi -if [ ! -f "$TEMPLATE_ADATA" ]; then - echo "ERROR: template AnnData not found: $TEMPLATE_ADATA" >&2 - exit 1 -fi -if [ ! -f "$NODE_WORKER_SCRIPT" ]; then - echo "ERROR: node worker not found: $NODE_WORKER_SCRIPT" >&2 - exit 1 -fi -if [ ! -x "$PY" ]; then - echo "ERROR: interpreter not found: $PY" >&2 - echo " Create it with: uv sync --extra segmentation" >&2 - exit 1 -fi - -echo "Scanning for WSI files in: $WSI_DIR" -MANIFEST="${MANIFEST_DIR}/manifest_$(date +%Y%m%d_%H%M%S).txt" -: > "$MANIFEST" - -if [ -n "$SAMPLE_SUBSET" ]; then - echo " Filtering to: $SAMPLE_SUBSET" - IFS=',' read -r -a SAMPLE_IDS <<< "$SAMPLE_SUBSET" - for sample_id in "${SAMPLE_IDS[@]}"; do - for ext in "${WSI_EXTENSIONS[@]}"; do - [ -f "$WSI_DIR/${sample_id}.${ext}" ] && echo "$WSI_DIR/${sample_id}.${ext}" >> "$MANIFEST" - done - done -else - for ext in "${WSI_EXTENSIONS[@]}"; do - find "$WSI_DIR" -maxdepth 1 -name "*.${ext}" -type f >> "$MANIFEST" 2>/dev/null || true - done -fi - -sort -u -o "$MANIFEST" "$MANIFEST" -TOTAL_WSIS=$(wc -l < "$MANIFEST") - -if [ "$TOTAL_WSIS" -eq 0 ]; then - echo "No WSI files found. Exiting." - rm -f "$MANIFEST" - exit 0 -fi - -cat < Node \$i (\$TARGET_NODE): \$(wc -l < "\$CHUNK_FILE") WSIs" - - srun --nodes=1 --ntasks=1 --exclusive \\ - --nodelist="\$TARGET_NODE" \\ - bash ${NODE_WORKER_SCRIPT} \\ - "\$CHUNK_FILE" \\ - "${SEG_OUTDIR}" \\ - "${ZARR_OUTDIR}" \\ - "${TEMPLATE_ADATA}" \\ - "${GPUS_PER_NODE}" \\ - "${WSI_MPP}" \\ - "${TILE_SIZE}" \\ - "${OVERLAP}" \\ - "${CLAHE}" \\ - "${SEED_THRESHOLD}" & -done - -wait - -echo "=======================================================" -echo "JOB COMPLETE \$(date -Is)" -echo "=======================================================" - -rm -f \${CHUNK_PREFIX}* -EOF - -echo -echo "Submitted. Monitor with: squeue -u \$USER" -echo " Logs: $LOG_DIR" -echo " Manifest: $MANIFEST" diff --git a/src/spatialrefinery/core/utils.py b/src/spatialrefinery/core/utils.py index 9ab0655..ee976cf 100644 --- a/src/spatialrefinery/core/utils.py +++ b/src/spatialrefinery/core/utils.py @@ -52,6 +52,35 @@ def transform_name(old_name: str) -> str: return re.sub(r"[^\w\._-]", "_", old_name) +#: Multi-part suffixes that `Path.stem` would only half-strip: `a.ome.tif` -> `a.ome`. +COMPOUND_SUFFIXES = (".ome.tif", ".ome.tiff", ".ome.zarr") + + +def slide_stem(path: str | Path) -> str: + """Return a slide's filename with its extension removed, `.ome.tif` included. + + `Path.stem` strips only the final suffix, so `slide.ome.tif` yields + `slide.ome`. Derived outputs are keyed on this instead: the SpatialData + store one slide converts to is named `.zarr`. + + Parameters + ---------- + path : str | Path + A slide path or bare filename. + + Returns + ------- + str + The filename up to (but excluding) the first suffix of its extension. + """ + name = Path(path).name + lowered = name.lower() + for suffix in COMPOUND_SUFFIXES: + if lowered.endswith(suffix): + return name[: -len(suffix)] + return Path(name).stem + + def iter_curl_urls(lines: Iterable[str]) -> Iterator[str]: """Yield URLs from `curl -O ` lines, ignoring comments/blanks/other commands.""" for line in lines: diff --git a/src/spatialrefinery/segmentation/instanseg.py b/src/spatialrefinery/segmentation/instanseg.py index c00b079..09eb46b 100644 --- a/src/spatialrefinery/segmentation/instanseg.py +++ b/src/spatialrefinery/segmentation/instanseg.py @@ -113,7 +113,9 @@ def segment_wsi( outdir Parent directory. Results go to `//cells.geojson`; the directory is named with the full filename (extension included) so - that `a.svs` and `a.ndpi` cannot collide. + that `a.svs` and `a.ndpi` cannot collide. The zarr stage names its store + for the stem instead (`a.ome.tif` -> `a.zarr`); see + `to_spatialdata.default_zarr_path`. pixel_size Microns per pixel. Read from the slide metadata when omitted. InstanSeg rejects a value outside [0.1, 1] micron, so pass this explicitly for diff --git a/src/spatialrefinery/segmentation/to_spatialdata.py b/src/spatialrefinery/segmentation/to_spatialdata.py index 66c2588..afe899c 100644 --- a/src/spatialrefinery/segmentation/to_spatialdata.py +++ b/src/spatialrefinery/segmentation/to_spatialdata.py @@ -105,6 +105,19 @@ def wsi_image_element(image_path: str | Path, *, scale_factors=DEFAULT_SCALE_FAC ) +def default_zarr_path(wsi_path: str | Path, zarr_outdir: str | Path) -> Path: + """Return `/.zarr`, the store name one slide converts to. + + The stem is the prefix before the slide's extension, so `slide.ome.tif` + gives `slide.zarr` rather than `slide.ome.tif.zarr` or `slide.ome.zarr`. + Note this differs from the segmentation stage, whose per-slide directory + keeps the full filename (see `segmentation.instanseg.segment_wsi`). + """ + from spatialrefinery.core.utils import slide_stem + + return Path(zarr_outdir) / f"{slide_stem(wsi_path)}.zarr" + + def geojson_to_spatialdata( geojson_path: str | Path, zarr_path: str | Path, diff --git a/tests/test_segmentation.py b/tests/test_segmentation.py index d227b81..b2d3b9e 100644 --- a/tests/test_segmentation.py +++ b/tests/test_segmentation.py @@ -24,6 +24,7 @@ segment_wsi, ) from spatialrefinery.segmentation.to_spatialdata import ( + default_zarr_path, explode_multipolygons, geojson_to_spatialdata, wsi_image_element, @@ -196,6 +197,22 @@ def test_wsi_image_element_rejects_non_tiff(tmp_path): # --------------------------------------------------------------------- # +@pytest.mark.parametrize( + ("filename", "expected"), + [ + # The regression: the full filename used to become the store name, + # giving `slide.ome.tif.zarr`. + ("slide.ome.tif", "slide.zarr"), + ("slide.ome.tiff", "slide.zarr"), + ("slide.svs", "slide.zarr"), + ("slide.tif", "slide.zarr"), + ], +) +def test_default_zarr_path_names_store_for_the_slide_stem(tmp_path, filename: str, expected: str): + """The store is `.zarr`, with the whole extension stripped.""" + assert default_zarr_path(Path("/slides") / filename, tmp_path) == tmp_path / expected + + def test_geojson_to_spatialdata_writes_expected_elements(tmp_path): """The written zarr must carry the image, the shapes, and a table annotating them.""" import spatialdata @@ -207,7 +224,8 @@ def test_geojson_to_spatialdata_writes_expected_elements(tmp_path): template = tmp_path / "template.h5ad" make_template(template, n_vars=5) - zarr_path = tmp_path / "slide.tif.zarr" + zarr_path = default_zarr_path(wsi, tmp_path) + assert zarr_path == tmp_path / "slide.zarr" geojson_to_spatialdata( geojson_path=geojson, zarr_path=zarr_path, diff --git a/tests/test_utils.py b/tests/test_utils.py index f0e6479..821f0cd 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -8,6 +8,8 @@ from __future__ import annotations +from pathlib import Path + import numpy as np import pytest @@ -24,6 +26,7 @@ human_bytes, parse_curl_manifest, safe_extract_zip, + slide_stem, split_study_filename, transform_name, ) @@ -46,6 +49,28 @@ def test_transform_name(old_name: str, expected: str) -> None: assert transform_name(old_name) == expected +@pytest.mark.parametrize( + ("filename", "expected"), + [ + # The case this helper exists for: `Path.stem` would leave "slide.ome". + ("slide.ome.tif", "slide"), + ("slide.ome.tiff", "slide"), + ("slide.OME.TIF", "slide"), + ("slide.ome.zarr", "slide"), + ("slide.svs", "slide"), + ("slide.tif", "slide"), + ("slide.NDPI", "slide"), + # Only the extension goes; dots inside the name are part of it. + ("Xenium_V1.2_section.ome.tif", "Xenium_V1.2_section"), + ("a.b.svs", "a.b"), + ("no_extension", "no_extension"), + ], +) +def test_slide_stem(filename: str, expected: str) -> None: + assert slide_stem(filename) == expected + assert slide_stem(Path("/some/dir") / filename) == expected + + def test_parse_curl_manifest_ignores_non_curl_lines(tmp_path) -> None: manifest = tmp_path / "manifest.txt" manifest.write_text( From 1927779c5956604dbd1f068aef016838f539de3e Mon Sep 17 00:00:00 2001 From: Rushin Gindra Date: Mon, 31 Aug 2026 20:49:45 +0200 Subject: [PATCH 2/2] Cover segmentation in the README, and fix a missing newline Add the segmentation steps to Getting started and both optional extras to Installation. Restore the trailing newline in .gitignore, which end-of-file-fixer rejected in CI. --- .gitignore | 2 +- README.md | 42 ++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 41 insertions(+), 3 deletions(-) diff --git a/.gitignore b/.gitignore index c1ddb00..59d2f07 100644 --- a/.gitignore +++ b/.gitignore @@ -34,4 +34,4 @@ xenium_example/ # ...except the segmentation pipeline's documented entry points: the tutorial # notebook and the two CLI wrappers. The SLURM scripts stay untracked -- they -# are cluster-specific scratch. \ No newline at end of file +# are cluster-specific scratch. diff --git a/README.md b/README.md index 53e326f..6c526c4 100644 --- a/README.md +++ b/README.md @@ -9,7 +9,8 @@ [badge-coverage]: https://codecov.io/github/peng-lab/spatialrefinery/branch/main/graph/badge.svg A toolkit for turning raw spatial-omics vendor outputs into analysis-ready data: 10x Genomics Xenium bundles become -[SpatialData][] zarr stores, and whole-slide/microscopy images become pyramidal OME-TIFF. +[SpatialData][] zarr stores, whole-slide/microscopy images become pyramidal OME-TIFF, and H&E slides can be segmented +into nucleus boundaries packaged as a SpatialData store of their own. ## Why spatialrefinery @@ -21,6 +22,9 @@ zarr store with pseudo-spots binned at whatever sizes a given resolution needs ( paired whole-slide image to a pyramidal OME-TIFF for fast viewing. Run it over a batch of raw bundles and you get one common, multi-resolution dataset to train Phoenix on. +The same pipeline also runs on histology that has no paired Xenium run: nucleus segmentation turns an H&E slide into a +SpatialData store of nucleus boundaries with an empty table over a gene panel -- the shape Phoenix predicts into. + ## Getting started Please refer to the [documentation][], in particular the [installation guide][], [tutorials][], and @@ -44,6 +48,27 @@ xenium_to_spatialdata( convert_to_ometiff(source="raw_files/my_study/slide.svs", output_dir="processed") ``` +Nucleus segmentation needs the optional `segmentation` extra, and is reached through `spatialrefinery.segmentation` +rather than the top-level package: + +```python +from spatialrefinery.segmentation.instanseg import segment_wsi +from spatialrefinery.segmentation.to_spatialdata import default_zarr_path, geojson_to_spatialdata + +slide = "processed/slide.ome.tif" + +# 4. Segment nuclei with InstanSeg -> segmentation/slide.ome.tif/cells.geojson +cells = segment_wsi(slide, outdir="segmentation") + +# 5. Package the boundaries with the slide -> processed/slide.zarr (+ .zarr.zip) +geojson_to_spatialdata( + geojson_path=cells, + zarr_path=default_zarr_path(slide, "processed"), + image_path=slide, + template_adata_path="panel_template.h5ad", +) +``` + ## Installation You need to have Python 3.12 or newer installed on your system. @@ -75,7 +100,20 @@ Choose from the options below to install spatialrefinery: pip install git+https://github.com/peng-lab/spatialrefinery.git # (or `uv add`) ``` -See the [installation guide][] for the optional `czi` extra and a verification snippet. +### Optional extras + +```bash +# Zeiss CZI images, via bioio +pip install "spatialrefinery[czi] @ git+https://github.com/peng-lab/spatialrefinery.git" + +# H&E nucleus segmentation, via InstanSeg +pip install "spatialrefinery[segmentation] @ git+https://github.com/peng-lab/spatialrefinery.git" +``` + +`segmentation` is kept out of the base install because it pulls `instanseg-torch`, and therefore torch's multi-GB CUDA +wheels, which most uses do not need. A CUDA GPU is strongly recommended for it. + +See the [installation guide][] for details and a verification snippet. ## Release notes