diff --git a/src/python/examples/segmentation_workbook/cpsam_segmentation.ipynb b/src/python/examples/segmentation_workbook/cpsam_segmentation.ipynb new file mode 100644 index 0000000..68b741d --- /dev/null +++ b/src/python/examples/segmentation_workbook/cpsam_segmentation.ipynb @@ -0,0 +1,315 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "07ed918f", + "metadata": {}, + "source": [ + "# CellposeSAM segmentation across an AVITI24 cytoprofiling run\n", + "\n", + "Run [CellposeSAM (CPSAM)](https://github.com/mouseland/cellpose) across every tile in a Teton or Teton Atlas run and write the segmentation masks Cells2Stats expects. CPSAM is a general-purpose model that integrates the [Segment Anything Model](https://segment-anything.com/) architecture; use it when your cell type is not represented in the Element Biosciences model library or when the General Element Biosciences model produces poor results even after diameter tuning.\n", + "\n", + "This notebook is the companion to the [Custom segmentation tutorial](https://docs.elembio.io/docs/tutorials/cytoprofiling/custom-segmentation/). Read the tutorial first for the full context: run-type identification, when to use CPSAM, and post-segmentation Cells2Stats re-run." + ] + }, + { + "cell_type": "markdown", + "id": "6fd24dd9", + "metadata": {}, + "source": [ + "## Prerequisites\n", + "\n", + "Confirm the following before running this notebook:\n", + "\n", + "- Your run is a **Teton** or **Teton Atlas** run. CPSAM requires the actin channel and fails on Cell Paint only runs because no actin `.tif` file exists. For Cell Paint only runs, use an Element Biosciences 2-channel model and follow [Run a tile evaluation](https://docs.elembio.io/docs/tutorials/cytoprofiling/custom-segmentation/#tile-evaluation) and [Run full segmentation](https://docs.elembio.io/docs/tutorials/cytoprofiling/custom-segmentation/#full-segmentation).\n", + "- You created the separate `cpsam` Python environment with Cellpose 4.x installed from the MouseLand GitHub HEAD. See [Set up the CPSAM environment](https://docs.elembio.io/docs/tutorials/cytoprofiling/custom-segmentation/#cpsam-setup-env). Do not install Cellpose 4.x into your `cytoprofiling-seg` environment.\n", + "- The `cpsam` environment is selected as this notebook's kernel (top menu: **Kernel → Change kernel → CellposeSAM**).\n", + "- A GPU is available. CPSAM on CPU is prohibitively slow for full-run processing.\n", + "\n", + "> **First run downloads ~1.15 GB.** The first time you initialize the CPSAM model, Cellpose automatically downloads the model weights (~1.15 GB) from HuggingFace to `~/.cellpose/models/`. Subsequent runs use the cached weights and do not require an internet connection." + ] + }, + { + "cell_type": "markdown", + "id": "06e16ef5", + "metadata": {}, + "source": [ + "## Step 1 — Import packages\n", + "\n", + "Load the imaging, numerics, and Cellpose packages used throughout the rest of the notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "48e24551", + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "import os\n", + "\n", + "import numpy as np\n", + "import skimage\n", + "from cellpose import core, models, transforms\n" + ] + }, + { + "cell_type": "markdown", + "id": "9ce6d73e", + "metadata": {}, + "source": [ + "## Step 2 — Provide Input and Output Paths\n", + "\n", + "Set the two required paths. Use a fresh `output_location` per re-segmentation pass so CPSAM masks do not overwrite Element Biosciences masks." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "24ab308f", + "metadata": {}, + "outputs": [], + "source": [ + "# Edit both paths before running the rest of the notebook.\n", + "\n", + "# Path to your AVITI24 run output folder\n", + "run_directory = r\"/path/to/your/Run/Output/Folder\"\n", + "\n", + "# Where to write the CPSAM segmentation mask outputs (must be a different folder)\n", + "output_location = r\"/path/to/your/Run/Output/Folder/Segmentation_Output\"" + ] + }, + { + "cell_type": "markdown", + "id": "65c4954e", + "metadata": {}, + "source": [ + "## Step 3 — Confirm GPU and load CPSAM\n", + "\n", + "Verify that a GPU is available, then load the CPSAM model. The first time this cell runs, Cellpose downloads ~1.15 GB of model weights from HuggingFace to `~/.cellpose/models/`. Subsequent runs use the cached weights." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b567dd74", + "metadata": {}, + "outputs": [], + "source": [ + "if not core.use_gpu():\n", + " print(\"WARNING: No GPU detected. Runtime will be very long (8+ hours for 12-well).\")\n", + " print(\"Consider running on a GPU-equipped machine for production use.\")\n", + "else:\n", + " print(\"GPU confirmed. Proceeding with CPSAM segmentation.\")\n", + "\n", + "# Load model. Downloads on first run (~1.15 GB).\n", + "model = models.CellposeModel(gpu=True)\n" + ] + }, + { + "cell_type": "markdown", + "id": "32c8be23", + "metadata": {}, + "source": [ + "## Step 4 — Define the normalization helper\n", + "\n", + "`normalize_image` applies Cellpose's per-region normalization across 1824-pixel sub-tiles, matching the preprocessing used by the Element Biosciences segmentation workflow." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "8b14c6cf", + "metadata": {}, + "outputs": [], + "source": [ + "def normalize_image(image, region_size=1824):\n", + " image_norm = np.zeros_like(image, np.single)\n", + "\n", + " for xi in range(int(image.shape[1] / region_size)):\n", + " for yi in range(int(image.shape[0] / region_size)):\n", + " cropped = image[\n", + " yi * region_size:(yi + 1) * region_size,\n", + " xi * region_size:(xi + 1) * region_size,\n", + " ]\n", + " cropped = transforms.normalize_img(\n", + " cropped.reshape(cropped.shape[0], cropped.shape[1], 1)\n", + " ).reshape(cropped.shape[0], cropped.shape[1])\n", + " image_norm[\n", + " yi * region_size:(yi + 1) * region_size,\n", + " xi * region_size:(xi + 1) * region_size,\n", + " ] = cropped\n", + "\n", + " return image_norm\n" + ] + }, + { + "cell_type": "markdown", + "id": "18fa08aa", + "metadata": {}, + "source": [ + "## Step 5 — Build the tile list from `RunParameters.json`\n", + "\n", + "Read `RunParameters.json` to enumerate every well and tile in the run and build the `tile2well` map used by the segmentation loop. The cell prints the total tile count so you can confirm the workload before committing to Step 6." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d4e628cb", + "metadata": {}, + "outputs": [], + "source": [ + "with open(os.path.join(run_directory, \"RunParameters.json\")) as f:\n", + " run_parameters = json.load(f)\n", + "\n", + "tile2well, tiles = {}, []\n", + "for well in run_parameters[\"Wells\"]:\n", + " for tile in well[\"Tiles\"]:\n", + " tile2well[tile[\"Name\"]] = well[\"WellLocation\"]\n", + " tiles.append(tile[\"Name\"])\n", + "\n", + "print(f\"Total tiles to process: {len(tiles)}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "39ec5de5", + "metadata": {}, + "source": [ + "## Step 6 — Segment every tile and write masks\n", + "\n", + "Run CPSAM on each tile and write the cell and nuclear masks to `output_location/Well{well}/`. Unlike the Element Biosciences workflow, CPSAM uses a single model for every well, so no per-well model lookup is needed.\n", + "\n", + "To monitor progress, watch for the rolling `Done: ...` lines. Each line corresponds to one tile fully processed and saved. See the **Runtime expectations** table at the bottom of the notebook for typical wall-clock times." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "733015fe", + "metadata": {}, + "outputs": [], + "source": [ + "flow_threshold = 0.4\n", + "cellprob_threshold = 0.0\n", + "tile_norm_blocksize = 0\n", + "\n", + "print(f\"Beginning segmentation across {len(tiles)} tiles\")\n", + "\n", + "for tile in tiles:\n", + " well = tile2well[tile]\n", + " os.makedirs(os.path.join(output_location, f\"Well{well}\"), exist_ok=True)\n", + "\n", + " cell_image = skimage.io.imread(\n", + " os.path.join(run_directory, \"Projection\", f\"Well{well}\", f\"CP01_{tile}_Cell-Membrane.tif\")\n", + " )\n", + " nuclear_image = skimage.io.imread(\n", + " os.path.join(run_directory, \"Projection\", f\"Well{well}\", f\"CP01_{tile}_Nucleus.tif\")\n", + " )\n", + " actin_image = skimage.io.imread(\n", + " os.path.join(run_directory, \"Projection\", f\"Well{well}\", f\"CP01_{tile}_Actin.tif\")\n", + " )\n", + "\n", + " cell_image = normalize_image(cell_image)\n", + " nuclear_image = normalize_image(nuclear_image)\n", + " actin_image = normalize_image(actin_image)\n", + "\n", + " composite = np.zeros((cell_image.shape[0], cell_image.shape[1], 3))\n", + " composite[:, :, 0] = cell_image\n", + " composite[:, :, 1] = nuclear_image\n", + " composite[:, :, 2] = actin_image\n", + "\n", + " print(f\"Segmenting cell membrane \\u2014 tile: {tile}\")\n", + " cell_mask, _, _ = model.eval(\n", + " composite,\n", + " batch_size=2,\n", + " flow_threshold=flow_threshold,\n", + " cellprob_threshold=cellprob_threshold,\n", + " normalize={\"tile_norm_blocksize\": tile_norm_blocksize},\n", + " resample=False,\n", + " )\n", + " cell_mask = cell_mask.astype(np.uint32)\n", + "\n", + " print(f\"Segmenting nuclei \\u2014 tile: {tile}\")\n", + " nuclear_mask, _, _ = model.eval(\n", + " nuclear_image,\n", + " batch_size=2,\n", + " flow_threshold=flow_threshold,\n", + " cellprob_threshold=cellprob_threshold,\n", + " normalize={\"tile_norm_blocksize\": tile_norm_blocksize},\n", + " resample=False,\n", + " )\n", + " binary_nuclei = nuclear_mask.copy()\n", + " binary_nuclei[nuclear_mask > 0] = 1\n", + "\n", + " skimage.io.imsave(\n", + " os.path.join(output_location, f\"Well{well}\", f\"{tile}_Cell.tif\"),\n", + " cell_mask.astype(np.uint16),\n", + " )\n", + " skimage.io.imsave(\n", + " os.path.join(output_location, f\"Well{well}\", f\"{tile}_Nuclear.tif\"),\n", + " binary_nuclei.astype(np.uint8),\n", + " )\n", + " print(f\"Done: {tile}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "8dba8d14", + "metadata": {}, + "source": [ + "## Reference\n", + "\n", + "### Runtime expectations\n", + "\n", + "CPSAM processes every tile in the run. CPU runtimes are prohibitive; the table below assumes a GPU.\n", + "\n", + "| Plate format | Approximate tiles | GPU estimate |\n", + "| ------------ | ----------------- | ------------ |\n", + "| 1-well | ~18 tiles | ~30 minutes |\n", + "| 12-well | ~216 tiles | ~6–10 hours |\n", + "| 48-well | ~864 tiles | ~24–36 hours |\n", + "\n", + "### Output files\n", + "\n", + "For each tile, the loop writes two files to your `output_location`:\n", + "\n", + "- `{tile}_Cell.tif`: a `uint16` label mask where each unique integer represents one segmented cell.\n", + "- `{tile}_Nuclear.tif`: a `uint8` binary mask where `0` indicates no nucleus and `1` indicates a nucleus is present.\n", + "\n", + "### Validation\n", + "\n", + "CPSAM does not produce a built-in quality metrics table. Verify outputs visually or by comparing cell and nucleus counts against the baseline you established in [Interpret results and choose a model](https://docs.elembio.io/docs/tutorials/cytoprofiling/custom-segmentation/#interpret-results).\n", + "\n", + "### Third-party tool disclaimer\n", + "\n", + "CellposeSAM is provided by the [MouseLand open-source project](https://github.com/mouseland/cellpose) and is not affiliated with or endorsed by Element Biosciences. CPSAM has not been formally validated against AVITI24 cytoprofiling runs and results may vary. For CPSAM-specific issues, installation support, or model updates, refer to the [official MouseLand repository](https://github.com/mouseland/cellpose).\n", + "\n", + "After all tiles finish, re-run Cells2Stats with `--segmentation` pointing at `output_location` to regenerate the cell table. See [Re-run Cells2Stats for cell assignment](https://docs.elembio.io/docs/tutorials/cytoprofiling/custom-segmentation/#cell-assignment)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "CellposeSAM", + "language": "python", + "name": "cpsam" + }, + "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.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/python/examples/segmentation_workbook/full_segmentation.ipynb b/src/python/examples/segmentation_workbook/full_segmentation.ipynb new file mode 100644 index 0000000..8cbb77c --- /dev/null +++ b/src/python/examples/segmentation_workbook/full_segmentation.ipynb @@ -0,0 +1,524 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d774738e", + "metadata": {}, + "source": [ + "# Full segmentation across an AVITI24 cytoprofiling run\n", + "\n", + "After you select a model with the tile evaluation notebook, run this notebook to apply your selected model to every tile in the run and write the segmentation masks Cells2Stats expects.\n", + "\n", + "This notebook is the companion to the [Custom segmentation tutorial](https://docs.elembio.io/docs/tutorials/cytoprofiling/custom-segmentation/). Read the tutorial first for the full context: run-type identification, tile evaluation, and post-segmentation Cells2Stats re-run.\n" + ] + }, + { + "cell_type": "markdown", + "id": "d9058e94", + "metadata": {}, + "source": [ + "## Prerequisites\n", + "\n", + "Confirm the following before running this notebook:\n", + "\n", + "- You identified your run type. See [Identify run type](https://docs.elembio.io/docs/tutorials/cytoprofiling/custom-segmentation/#identify-run-type).\n", + "- You recorded the best model name from the tile evaluation. See [Interpret results and choose a model](https://docs.elembio.io/docs/tutorials/cytoprofiling/custom-segmentation/#interpret-results).\n", + "- You installed the cytoprofiling package and know your `segmentationModels/` directory path.\n", + "- Your `cytoprofiling-seg` environment is active and selected as this notebook's kernel (top menu: **Kernel → Change kernel → Cytoprofiling Segmentation**).\n" + ] + }, + { + "cell_type": "markdown", + "id": "1fa3b3ad", + "metadata": {}, + "source": [ + "## Step 1 — Import packages\n", + "\n", + "Cellpose loads the segmentation models, scikit-image reads and writes the tile TIFFs, and the warning filters silence two benign messages from PyTorch and scikit-image during inference.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "76bc1c07", + "metadata": {}, + "outputs": [], + "source": [ + "from cellpose import models, transforms\n", + "import skimage\n", + "import os\n", + "import numpy as np\n", + "import json\n", + "\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\", message=\".*weights_only=False.*\")\n", + "warnings.filterwarnings(\"ignore\", message=\".*low contrast image.*\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "cc95acc3", + "metadata": {}, + "source": [ + "## Step 2 — Provide Input and Output Paths\n", + "\n", + "- `run_directory` should point to a Teton run folder with `Projection/` images (Cell-Membrane, Nucleus, Actin) and `RunParameters.json`. These files determine well layout, kit type, and available tiles.\n", + "- `output_location` is the root folder for segmentation outputs. The notebook writes each well's masks under `output_location/Well{well}/` so the directory can be consumed directly by Cells2Stats (the downstream analysis pipeline).\n", + "- `model_dir` should point to the `segmentationModels/` folder inside your local clone of the cytoprofiling package (for example, `cytoprofiling/src/segmentationModels`). The notebook resolves every model name in STEP C of the next cell against this directory.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f3bb14a9", + "metadata": {}, + "outputs": [], + "source": [ + "# Edit all three paths before running the rest of the notebook.\n", + "\n", + "# Path to your AVITI24 run output folder\n", + "run_directory = r\"/path/to/your/Run/Output/Folder\"\n", + "\n", + "# Where to write the segmentation mask outputs (must be a different folder)\n", + "output_location = r\"/path/to/your/Run/Output/Folder/Segmentation_Output\"\n", + "\n", + "# Path to segmentation models\n", + "model_dir = r\"/path/to/cytoprofiling/src/segmentationModels\"" + ] + }, + { + "cell_type": "markdown", + "id": "81bf93e7", + "metadata": {}, + "source": [ + "## Step 3 — Configure cell types and models\n", + "\n", + "The notebook auto-initializes well-level cell type and diameter assignments from `RunManifest.csv` in `run_directory`. Review the loaded values printed below the cell and make adjustments in the override block before running Step 3.\n", + "\n", + "- **STEP A**: load `cell_types` and `cell_diameters` from the run manifest, with optional per-well overrides.\n", + "- **STEP B**: select the segmentation model file used for each cell type. Use `_3ch` for Teton/Teton Atlas runs and `_2ch` for Cell Paint only runs.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a6c24fb8", + "metadata": {}, + "outputs": [], + "source": [ + "# ───────────────────────────────────────────────────────────────────────\n", + "# STEP A — Load cell_types and cell_diameters from RunManifest.csv\n", + "# ───────────────────────────────────────────────────────────────────────\n", + "# Source of truth is the [Wells] section of RunManifest.csv at run_directory.\n", + "# Manifest CellType values are agnostic to spaces, hyphens, and case\n", + "# (see https://docs.elembio.io/docs/run-manifest/wells-section/).\n", + "# If RunManifest.csv is missing, the well list is read from\n", + "# RunParameters.json and every well defaults to OTHER.\n", + "import csv\n", + "import re\n", + "\n", + "# Map each normalized manifest CellType to the matching STEP B key.\n", + "# Update this dict if you add a new model to STEP B with a name that\n", + "# does not normalize directly to its key (for example, SH-SY5Y).\n", + "MANIFEST_TO_MODEL_KEY = {\n", + " \"HELA\": \"HELA\",\n", + " \"HUVEC\": \"HUVEC\",\n", + " \"MCF7\": \"MCF7\",\n", + " \"PC3\": \"PC3\",\n", + " \"HEK293\": \"HEK293\",\n", + " \"JURKAT\": \"JURKAT\",\n", + " \"HEPG2\": \"HEPG2\",\n", + " \"HCT116\": \"HCT116\",\n", + " \"PBMC\": \"PBMC\",\n", + " \"SHSY5Y\": \"SH-SY5Y\",\n", + " \"FIBROBLAST\": \"FIBROBLAST\",\n", + " \"IPSC\": \"IPSC\",\n", + "}\n", + "\n", + "\n", + "def _norm(value: str) -> str:\n", + " return re.sub(r\"[\\s-]\", \"\", value).upper().strip()\n", + "\n", + "\n", + "def _iter_manifest_wells(path: str):\n", + " \"\"\"Yield dicts of {WellLocation, CellType, CellDiameter, ...} from\n", + " the [Wells] section of an Element Biosciences run manifest CSV.\"\"\"\n", + " in_wells = False\n", + " header = None\n", + " with open(path, newline=\"\") as f:\n", + " for raw in f:\n", + " line = raw.rstrip(\"\\r\\n\")\n", + " stripped = line.strip()\n", + " if stripped.startswith(\"[\") and stripped.endswith(\"]\"):\n", + " in_wells = (stripped == \"[Wells]\")\n", + " header = None\n", + " continue\n", + " if not in_wells or not stripped:\n", + " continue\n", + " row = next(csv.reader([line]))\n", + " row = [c.strip() for c in row]\n", + " if header is None:\n", + " header = [c for c in row if c]\n", + " continue\n", + " padded = row + [\"\"] * (len(header) - len(row))\n", + " yield dict(zip(header, padded))\n", + "\n", + "\n", + "cell_types = {}\n", + "cell_diameters = {}\n", + "\n", + "manifest_path = os.path.join(run_directory, \"RunManifest.csv\")\n", + "if os.path.exists(manifest_path):\n", + " for record in _iter_manifest_wells(manifest_path):\n", + " well = record.get(\"WellLocation\", \"\").strip()\n", + " if not well:\n", + " continue\n", + " manifest_type = record.get(\"CellType\", \"\").strip()\n", + " ctype = MANIFEST_TO_MODEL_KEY.get(_norm(manifest_type), \"OTHER\")\n", + " cell_types[well] = ctype\n", + " diameter_raw = record.get(\"CellDiameter\", \"\").strip()\n", + " if ctype == \"OTHER\" and diameter_raw:\n", + " try:\n", + " cell_diameters[well] = int(float(diameter_raw))\n", + " except ValueError:\n", + " pass\n", + " print(f\"Loaded {len(cell_types)} wells from RunManifest.csv\")\n", + "else:\n", + " with open(os.path.join(run_directory, \"RunParameters.json\")) as f:\n", + " rp = json.load(f)\n", + " for w in rp.get(\"Wells\", []):\n", + " cell_types[w[\"WellLocation\"]] = \"OTHER\"\n", + " print(\n", + " f\"RunManifest.csv not found. Loaded {len(cell_types)} wells from \"\n", + " \"RunParameters.json (all set to OTHER).\"\n", + " )\n", + "\n", + "# ───────────────────────────────────────────────────────────────────────\n", + "# STEP B — OVERRIDE RUN MANIFEST LOADED MODELS\n", + "# ───────────────────────────────────────────────────────────────────────\n", + "# Uncomment and edit the entries below if a well's manifest entry is\n", + "# wrong or you want to use a different model for a specific well.\n", + "# Values set here win over anything loaded from the manifest in STEP A.\n", + "# Diameters are only consulted for wells whose cell type is OTHER.\n", + "cell_types.update({\n", + " \"A1\": \"HELA\",\n", + " # \"A2\": \"HELA\",\n", + " # \"B1\": \"HELA\",\n", + " # \"B2\": \"HELA\",\n", + " \"C1\": \"HELA\",\n", + " # \"C2\": \"HELA\",\n", + " # \"D1\": \"HELA\",\n", + " # \"D2\": \"HELA\",\n", + " # \"E1\": \"HELA\",\n", + " # \"E2\": \"HELA\",\n", + " # \"F1\": \"HELA\",\n", + " # \"F2\": \"HELA\",\n", + "})\n", + "cell_diameters.update({\n", + " # \"A1\": 40,\n", + " # \"A2\": 40,\n", + " # \"B1\": 40,\n", + " # \"B2\": 40,\n", + " # \"C1\": 40,\n", + " # \"C2\": 40,\n", + " # \"D1\": 40,\n", + " # \"D2\": 40,\n", + " # \"E1\": 40,\n", + " # \"E2\": 40,\n", + " # \"F1\": 40,\n", + " # \"F2\": 40,\n", + "})\n", + "\n", + "print(\"cell_types :\", json.dumps(cell_types, indent=2))\n", + "print(\"cell_diameters :\", json.dumps(cell_diameters, indent=2))\n", + "\n", + "\n", + "# ───────────────────────────────────────────────────────────────────────\n", + "# STEP C — Select your segmentation models\n", + "# ───────────────────────────────────────────────────────────────────────\n", + "# Each key must match a value in cell_types from STEP A.\n", + "# Model suffix must match your run type:\n", + "# _3ch → Teton or Teton Atlas runs (Cell-Membrane + Nucleus + Actin)\n", + "# _2ch → Cell Paint only runs (Cell-Membrane + Nucleus only)\n", + "element_models = {\n", + " \"OTHER\": \"20240905_general_15diam_3ch\", # fallback for unlisted cell types\n", + " \"HELA\": \"20240905_hela_15diam_3ch\",\n", + " \"HUVEC\": \"20240905_huvec_15diam_3ch\",\n", + " \"MCF7\": \"20240924_mcf7_15diam_3ch\",\n", + " \"PC3\": \"20240924_pc3_15diam_3ch\",\n", + " \"HEK293\": \"20240924_hek293_15diam_3ch\",\n", + " \"JURKAT\": \"20240924_jurkat_15diam_3ch\",\n", + " \"HEPG2\": \"20240924_hepg2_15diam_3ch\",\n", + " \"HCT116\": \"20240924_hct116_15diam_3ch\",\n", + " \"PBMC\": \"20250127_pbmc_15diam_3ch\",\n", + " \"SH-SY5Y\": \"20250127_sh-sy5y_15diam_3ch\",\n", + " \"FIBROBLAST\": \"20260403_fibroblast_15diam_3ch\",\n", + " \"IPSC\": \"20260402_ipsc_15diam_3ch\",\n", + "}\n", + "\n", + "# Nuclear model — same for all runs and cell types\n", + "nuclear_model = \"20250212_cellpose_nuc_8diam\"\n" + ] + }, + { + "cell_type": "markdown", + "id": "097ec1c1", + "metadata": {}, + "source": [ + "## Step 4 — Define normalization and segmentation helpers\n", + "\n", + "`normalize_image` performs per-region intensity normalization before the model runs, so Cellpose's built-in normalization can be disabled for deterministic behavior. `segment_cells` builds the 3-channel composite Cellpose expects and runs both the cell and nuclear models on a single tile.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "61b97bf6", + "metadata": {}, + "outputs": [], + "source": [ + "def normalize_image(image, region_size=1824):\n", + " \"\"\"\n", + " Normalize each tile region independently before passing the image\n", + " to the segmentation model. Performed manually so that Cellpose\n", + " normalization is disabled during model inference.\n", + " \"\"\"\n", + " image_norm = np.zeros_like(image, np.single)\n", + "\n", + " for xi in range(int(image.shape[1] / region_size)):\n", + " for yi in range(int(image.shape[0] / region_size)):\n", + " cropped = image[\n", + " yi * region_size:(yi + 1) * region_size,\n", + " xi * region_size:(xi + 1) * region_size\n", + " ]\n", + " cropped = transforms.normalize_img(\n", + " cropped.reshape(cropped.shape[0], cropped.shape[1], 1)\n", + " ).reshape(cropped.shape[0], cropped.shape[1])\n", + " image_norm[\n", + " yi * region_size:(yi + 1) * region_size,\n", + " xi * region_size:(xi + 1) * region_size\n", + " ] = cropped\n", + "\n", + " return image_norm\n", + "\n", + "\n", + "def segment_cells(cell_image, nuclear_image, actin_image,\n", + " cell_model_path, nuclear_model_path,\n", + " cell_diameter, use_gpu=False):\n", + " \"\"\"\n", + " Run cell and nuclear segmentation for a single tile.\n", + "\n", + " Parameters\n", + " ----------\n", + " cell_image : Cell-membrane channel image array\n", + " nuclear_image : Nucleus channel image array\n", + " actin_image : Actin channel image array. Pass None for\n", + " Cell Paint only (2-channel) runs.\n", + " cell_model_path : Full path to the cell segmentation model file\n", + " nuclear_model_path : Full path to the nuclear segmentation model file\n", + " cell_diameter : Diameter in pixels. Used only for the General\n", + " model. Pass 0 to use the model's internal\n", + " training diameter.\n", + " use_gpu : Set to True if a GPU is available\n", + " \"\"\"\n", + " cell_image = normalize_image(cell_image)\n", + " nuclear_image = normalize_image(nuclear_image)\n", + "\n", + " # Build a 3-channel composite: [cell-membrane, nucleus, actin].\n", + " # For Cell Paint only runs, actin_image is None and channel 2\n", + " # remains zeros. Use a _2ch model in that case.\n", + " composite = np.zeros((cell_image.shape[0], cell_image.shape[1], 3))\n", + " composite[:, :, 0] = cell_image\n", + " composite[:, :, 1] = nuclear_image\n", + "\n", + " if actin_image is not None:\n", + " actin_image = normalize_image(actin_image)\n", + " composite[:, :, 2] = actin_image\n", + "\n", + " print(f\"Using {cell_model_path} for cell segmentation\")\n", + "\n", + " # Use pretrained_model for Element models. model_type is reserved\n", + " # for built-in Cellpose models such as cyto3 and does not load\n", + " # local files correctly.\n", + " model = models.CellposeModel(\n", + " gpu=use_gpu,\n", + " pretrained_model=cell_model_path,\n", + " nchan=3,\n", + " )\n", + "\n", + " cell_mask, _, _ = model.eval(\n", + " composite,\n", + " diameter=cell_diameter if cell_diameter > 0 else None,\n", + " channels=None,\n", + " normalize=False, # normalization handled manually above\n", + " resample=False,\n", + " )\n", + " cell_mask = cell_mask.astype(np.uint32)\n", + "\n", + " print(f\"Using {nuclear_model_path} for nuclear segmentation\")\n", + "\n", + " nuclear_model_obj = models.CellposeModel(\n", + " gpu=use_gpu,\n", + " pretrained_model=nuclear_model_path,\n", + " )\n", + "\n", + " nuclear_mask, _, _ = nuclear_model_obj.eval(\n", + " nuclear_image,\n", + " normalize=False,\n", + " resample=False,\n", + " )\n", + "\n", + " binary_nuclei = nuclear_mask.copy()\n", + " binary_nuclei[nuclear_mask > 0] = 1\n", + "\n", + " return cell_mask, binary_nuclei\n" + ] + }, + { + "cell_type": "markdown", + "id": "aa94d872", + "metadata": {}, + "source": [ + "## Step 5 — Build the tile list from `RunParameters.json`\n", + "\n", + "`RunParameters.json` enumerates every tile imaged on the run and the well each tile belongs to. This cell flattens that into a `tiles` list and a `tile2well` lookup the segmentation loop uses next.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1b8cd28b", + "metadata": {}, + "outputs": [], + "source": [ + "# Read RunParameters.json to build the full list of tiles and map\n", + "# each tile back to its well location.\n", + "with open(os.path.join(run_directory, \"RunParameters.json\")) as f:\n", + " run_parameters = json.load(f)\n", + "\n", + "tile2well = {}\n", + "tiles = []\n", + "\n", + "for well in run_parameters[\"Wells\"]:\n", + " for tile in well[\"Tiles\"]:\n", + " tile2well[tile[\"Name\"]] = well[\"WellLocation\"]\n", + " tiles.append(tile[\"Name\"])\n", + "\n", + "print(f\"Total tiles to process: {len(tiles)}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "22cf36f3", + "metadata": {}, + "source": [ + "## Step 6 — Segment every tile and write masks\n", + "\n", + "For each tile, the loop loads the channel TIFFs, runs `segment_cells`, and writes a `{tile}_Cell.tif` and `{tile}_Nuclear.tif` to the well's output directory. The actin channel is loaded only when present, so the same code path handles Cell Paint only and Teton runs.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "053cf415", + "metadata": {}, + "outputs": [], + "source": [ + "print(f\"Beginning segmentation across {len(tiles)} tiles\")\n", + "\n", + "for tile in tiles:\n", + " well = tile2well[tile]\n", + " cell_type = cell_types.get(well, \"OTHER\")\n", + " cell_diameter = cell_diameters.get(well, 0)\n", + "\n", + " cell_model_path = os.path.join(\n", + " model_dir,\n", + " element_models.get(cell_type.upper(), element_models[\"OTHER\"]),\n", + " )\n", + " nuclear_model_path = os.path.join(model_dir, nuclear_model)\n", + "\n", + " os.makedirs(\n", + " os.path.join(output_location, f\"Well{well}\"), exist_ok=True\n", + " )\n", + "\n", + " cell_image = skimage.io.imread(\n", + " os.path.join(run_directory, \"Projection\", f\"Well{well}\", f\"CP01_{tile}_Cell-Membrane.tif\")\n", + " )\n", + " nuclear_image = skimage.io.imread(\n", + " os.path.join(run_directory, \"Projection\", f\"Well{well}\", f\"CP01_{tile}_Nucleus.tif\")\n", + " )\n", + "\n", + " # Load the actin channel only for Teton and Teton Atlas runs.\n", + " actin_path = os.path.join(\n", + " run_directory, \"Projection\", f\"Well{well}\", f\"CP01_{tile}_Actin.tif\"\n", + " )\n", + " actin_image = skimage.io.imread(actin_path) if os.path.exists(actin_path) else None\n", + "\n", + " cell_mask, binary_nuclei = segment_cells(\n", + " cell_image, nuclear_image, actin_image,\n", + " cell_model_path, nuclear_model_path,\n", + " cell_diameter,\n", + " )\n", + "\n", + " skimage.io.imsave(\n", + " os.path.join(output_location, f\"Well{well}\", f\"{tile}_Cell.tif\"),\n", + " cell_mask.astype(np.uint16),\n", + " )\n", + " skimage.io.imsave(\n", + " os.path.join(output_location, f\"Well{well}\", f\"{tile}_Nuclear.tif\"),\n", + " binary_nuclei.astype(np.uint8),\n", + " )\n", + "\n", + " print(f\"Finished segmenting {tile}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "6d9672c1", + "metadata": {}, + "source": [ + "## Reference\n", + "\n", + "### Runtime expectations\n", + "\n", + "Full segmentation processes every tile in the run. Approximate run times are as follows:\n", + "\n", + "| Plate format | Approximate tiles | CPU estimate | GPU estimate |\n", + "| ------------ | ----------------- | ------------ | ------------ |\n", + "| 1-well | ~18 tiles | ~3 hours | ~20 minutes |\n", + "| 12-well | ~216 tiles | ~36 hours | ~4–8 hours |\n", + "| 48-well | ~864 tiles | ~48 hours | ~16–24 hours |\n", + "\n", + "### Output files\n", + "\n", + "For each tile, the loop writes two files to your `output_location`:\n", + "\n", + "- `{tile}_Cell.tif`: a `uint16` label mask where each unique integer represents one segmented cell.\n", + "- `{tile}_Nuclear.tif`: a `uint8` binary mask where `0` indicates no nucleus and `1` indicates a nucleus is present.\n", + "\n", + "After all tiles finish, re-run Cells2Stats with `--segmentation` pointing at `output_location` to regenerate the cell table. See [Re-run Cells2Stats for cell assignment](https://docs.elembio.io/docs/tutorials/cytoprofiling/custom-segmentation/#cell-assignment).\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Cytoprofiling Segmentation", + "language": "python", + "name": "cytoprofiling-seg" + }, + "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.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/python/examples/segmentation_workbook/segmentation.ipynb b/src/python/examples/segmentation_workbook/segmentation.ipynb index b0d15a3..d261968 100644 --- a/src/python/examples/segmentation_workbook/segmentation.ipynb +++ b/src/python/examples/segmentation_workbook/segmentation.ipynb @@ -42,19 +42,15 @@ "metadata": {}, "outputs": [], "source": [ - "import json\n", - "import os\n", - "import sys\n", - "from pathlib import Path\n", - "\n", - "\n", - "import segmentation as segmentation_module\n", - "from segmentation import (\n", - " run_segmentation,\n", - " TILE_MAPS,\n", - " WELL_LAYOUT_MAP,\n", - " is_two_channel_model,\n", - ")" + " from cellpose import models, transforms\n", + " import skimage\n", + " import os\n", + " import numpy as np\n", + " import json\n", + "\n", + " import warnings\n", + " warnings.filterwarnings(\"ignore\", message=\".*weights_only=False.*\")\n", + " warnings.filterwarnings(\"ignore\", message=\".*low contrast image.*\")" ] }, { @@ -316,20 +312,24 @@ "metadata": {}, "source": [ "## Provide Input and Output Paths\n", - "- `Run_directory` should point to a Teton run folder with `Projection/` images (Cell-Membrane, Nucleus, Actin) and `RunParameters.json`. These files determine well layout, kit type, and available tiles.\n", + "- `run_directory` should point to a Teton run folder with `Projection/` images (Cell-Membrane, Nucleus, Actin) and `RunParameters.json`. These files determine well layout, kit type, and available tiles.\n", "- `output_location` is the root folder for segmentation outputs. If you pick multiple cell models, the notebook writes each model's masks to separate subdirectories so they can be consumed directly by Cells2Stats (the downstream analysis pipeline)." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "43c83155", "metadata": {}, "outputs": [], "source": [ - "# Input Run Directory\n", - "Run_directory = r\"C:\\Users\\lab\\Desktop\\AVXXXXX\\202XXXXX_Teton_Training\"\n", - "output_location = r\"C:\\Users\\lab\\Desktop\\AVXXXXX\"" + "# Edit both paths before running the rest of the notebook.\n", + "\n", + "# Path to your AVITI24 run output folder\n", + "run_directory = r\"/path/to/your/Run/Output/Folder\"\n", + "\n", + "# Where to write the segmentation mask outputs (must be a different folder)\n", + "output_location = r\"/path/to/your/Run/Output/Folder/Segmentation_Output\"" ] }, { @@ -348,88 +348,10 @@ "execution_count": null, "id": "295838bc", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Detected layout: TwelveWellStandard | Kit type: KitTypeAntibodyScreening\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "a2d9b48b13634d2b813dad3995451d99", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(Image(value=b'\\x89PNG\\r\\n\\x1a\\n\\x00\\x00\\x00\\rIHDR\\x00\\x00\\x05\\x1d\\x00\\x00\\x02\\xfe\\x08\\x06\\x00\\x…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "e6b5d457010b498a9e1d7be00c0e6088", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "VBox(children=(HBox(children=(SelectMultiple(description='Select wells', layout=Layout(width='40%'), options=(…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "0c8c020cdf584f1c99de2e5a4ea71be7", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Output()" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "5e4ddb3f19864519a81f31f2b12a100a", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Button(button_style='success', description='Confirm selection', style=ButtonStyle())" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "de842b848f244bdbaf372ecfa19d4c67", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Output()" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Select wells and tiles for this run based on the detected well layout\n", - "selection_well_tiles, well_select, tile_select, confirm_btn, selection_out = interactive_well_tile_selector(Run_directory)" + "selection_well_tiles, well_select, tile_select, confirm_btn, selection_out = interactive_well_tile_selector(run_directory)" ] }, { @@ -449,53 +371,10 @@ "execution_count": null, "id": "115079d3", "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "e39d81fd5e3c48d998d3dceed499e4d2", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(SelectMultiple(description='Cell models', layout=Layout(width='50%'), options=('20240905_genera…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "f620af129f58401ba93d6d32c240b00e", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(Button(button_style='success', description='Confirm models', style=ButtonStyle()),))" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "9e5a07d22dea4afe81cd8bd69fd57a15", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Output()" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Choose segmentation models (cell membrane + nuclear)\n", - "model_dir = r\"C:\\Users\\lab\\cytoprofiling\\src\\segmentationModels\"\n", + "model_dir = r\"/path/to/cytoprofiling/src/segmentationModels\"\n", "selected_models = model_selection_widget(model_dir, kit_type=selection_well_tiles.get(\"kit_type\"))" ] }, @@ -514,138 +393,10 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "66f94c91", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Running segmentation for D1 - L2R11C01S1 using 20240905_general_15diam_2ch / 20250212_cellpose_nuc_8diam\n", - "Running segmentation for D1 - L2R11C01S1 using 20240905_hela_15diam_2ch / 20250212_cellpose_nuc_8diam\n", - "Running segmentation for D1 - L2R11C01S1 using 20240905_huvec_15diam_2ch / 20250212_cellpose_nuc_8diam\n", - "Running segmentation for D1 - L2R11C02S1 using 20240905_general_15diam_2ch / 20250212_cellpose_nuc_8diam\n", - "Running segmentation for D1 - L2R11C02S1 using 20240905_hela_15diam_2ch / 20250212_cellpose_nuc_8diam\n", - "Running segmentation for D1 - L2R11C02S1 using 20240905_huvec_15diam_2ch / 20250212_cellpose_nuc_8diam\n" - ] - }, - { - "data": { - "text/html": [ - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Cell Membrane ModelNuclear ModelWellTileDiameter (px)Number of CellsNumber of NucleiMean Cell AreaPercent Cells without NucleusPercent Nuclei outside cellsOverlay
020240905_general_15diam_2ch20250212_cellpose_nuc_8diamD1L2R11C01S130.002292262459.002.626.19
120240905_hela_15diam_2ch20250212_cellpose_nuc_8diamD1L2R11C01S11872267052.820.536.19
220240905_huvec_15diam_2ch20250212_cellpose_nuc_8diamD1L2R11C01S11922267119.521.043.98
320240905_general_15diam_2ch20250212_cellpose_nuc_8diamD1L2R11C02S130.002922601992.4110.274.62
420240905_hela_15diam_2ch20250212_cellpose_nuc_8diamD1L2R11C02S12432606016.1613.9911.54
520240905_huvec_15diam_2ch20250212_cellpose_nuc_8diamD1L2R11C02S12372606539.0012.246.92
" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "cell_diameters = selection_well_tiles.get(\"cell_diameters\", [])\n", "\n", @@ -653,7 +404,7 @@ " selection_well_tiles,\n", " selected_models,\n", " model_dir,\n", - " Run_directory,\n", + " run_directory,\n", " output_location,\n", " cell_diameters=cell_diameters,\n", ")\n", @@ -673,33 +424,10 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "6cfa7bea", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\rushikesh.dhonde\\AppData\\Local\\Temp\\ipykernel_71748\\1294701084.py:21: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", - " axes[0].legend().remove() # remove duplicate legends\n", - "C:\\Users\\rushikesh.dhonde\\AppData\\Local\\Temp\\ipykernel_71748\\1294701084.py:33: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", - " axes[1].legend().remove()\n", - "C:\\Users\\rushikesh.dhonde\\AppData\\Local\\Temp\\ipykernel_71748\\1294701084.py:45: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", - " axes[2].legend().remove()\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", @@ -754,9 +482,9 @@ ], "metadata": { "kernelspec": { - "display_name": "resegmentation", + "display_name": "Cytoprofiling Segmentation", "language": "python", - "name": "python3" + "name": "cytoprofiling-seg" }, "language_info": { "codemirror_mode": { @@ -768,7 +496,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.18" + "version": "3.12.2" } }, "nbformat": 4,