From 7cbb4d82bb3df5f751edd92078ef38bb5991c75d Mon Sep 17 00:00:00 2001 From: Andrey Fedorov Date: Fri, 1 May 2026 17:33:24 -0400 Subject: [PATCH 1/8] enh: add notebook demonstrating access to data from Imaging Data Commons Signed-off-by: Andrey Fedorov --- modules/idc_dataset.ipynb | 1094 +++++++++++++++++++++++++++++++++++++ 1 file changed, 1094 insertions(+) create mode 100644 modules/idc_dataset.ipynb diff --git a/modules/idc_dataset.ipynb b/modules/idc_dataset.ipynb new file mode 100644 index 000000000..c0f15adb9 --- /dev/null +++ b/modules/idc_dataset.ipynb @@ -0,0 +1,1094 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "eFLP44iEFCpB" + }, + "source": [ + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/ImagingDataCommons/idc-monai/blob/main/monai_contribution/idc_dataset.ipynb)\n", + "\n", + "# Using NCI Imaging Data Commons with MONAI\n", + "\n", + "Copyright 2026 Imaging Data Commons\n", + "\n", + "Licensed under the Apache License, Version 2.0 (the \"License\");\n", + "you may not use this file except in compliance with the License.\n", + "You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0\n", + "\n", + "---\n", + "\n", + "## What is IDC?\n", + "\n", + "[NCI Imaging Data Commons (IDC)](https://portal.imaging.datacommons.cancer.gov/) is a free, cloud-hosted repository of publicly available cancer imaging data maintained by the National Cancer Institute (NCI). It provides:\n", + "\n", + "- **~100 TB** of radiology (CT, MR, PET) and pathology images across 160+ cancer collections\n", + "- **No sign-up or authentication required** — data is openly accessible\n", + "- **Expert and AI-generated annotations** (e.g., organ segmentations) paired with images\n", + "- **Standardized format** — all data uses DICOM, the medical imaging industry standard\n", + "- **Cloud-native storage** — data lives in Google Cloud Storage (GCS) buckets, so downloads are fast\n", + "- **Accompanying tools** - you can search, visualize, and subset the data\n", + "\n", + "## What is `idc-index`?\n", + "\n", + "[`idc-index`](https://github.com/ImagingDataCommons/idc-index) is a lightweight Python package that lets you search and download IDC data without any cloud account or special credentials. It ships with a local metadata index — a set of DuckDB tables describing every image series in IDC — so you can run SQL queries locally to find exactly the data you need before downloading anything.\n", + "\n", + "## What this tutorial covers\n", + "\n", + "This tutorial shows how to:\n", + "1. Query IDC metadata with SQL to find cancer imaging data\n", + "2. Download DICOM images and segmentations with one function call\n", + "3. Load the data into MONAI for AI/ML preprocessing\n", + "4. Work with DICOM Segmentation (DICOM-SEG) objects and their rich metadata\n", + "\n", + "> **Tip**: This tutorial was created using [idc-claude-skill](https://github.com/ImagingDataCommons/idc-claude-skill) — an AI assistant skill for navigating IDC data and the `idc-index` API." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "iudwt5GoFCpC" + }, + "source": [ + "## Setup\n", + "\n", + "Install required packages:\n", + "- `monai` — Medical Open Network for AI, the ML framework used here\n", + "- `idc-index` — Query and download IDC data (includes local metadata index)\n", + "- `itk` / `itkwasm-dicom` — ITK-based DICOM readers used by MONAI's `ITKReader` and our custom DICOM-SEG loader" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "T4ujv4U7FCpC" + }, + "outputs": [], + "source": [ + "!pip install -q monai idc-index itk itkwasm-dicom\n", + "\n", + "# Restart runtime after installing ITK (required for ITK to load properly)\n", + "import sys\n", + "if \"google.colab\" in sys.modules:\n", + " try:\n", + " import itk # noqa: F401\n", + " except ImportError:\n", + " print(\"Restarting runtime to load ITK...\")\n", + " import os\n", + " os.kill(os.getpid(), 9)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hKiJz5u0FCpD" + }, + "source": [ + "## Setup imports" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "jfwDjSFfFCpD", + "outputId": "f63082ca-81d8-4b02-8de0-662710f6e508" + }, + "outputs": [], + "source": [ + "import os\n", + "import tempfile\n", + "from pathlib import Path\n", + "from typing import Hashable, Mapping\n", + "\n", + "import torch\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.colors import ListedColormap\n", + "from idc_index import IDCClient\n", + "\n", + "from monai.config import KeysCollection\n", + "from monai.transforms import (\n", + " Compose,\n", + " LoadImaged,\n", + " EnsureChannelFirstd,\n", + " Orientationd,\n", + " Spacingd,\n", + " ScaleIntensityRanged,\n", + " MapTransform,\n", + ")\n", + "from monai.data import Dataset, MetaTensor\n", + "from monai.data.image_reader import ITKReader\n", + "import monai\n", + "\n", + "monai.config.print_config()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rl7yWrklFCpD" + }, + "source": [ + "## 1. Discover Data with `idc-index`\n", + "\n", + "`idc-index` ships with a built-in local metadata index — a DuckDB database containing one row per DICOM series in IDC. You query it using standard SQL via `client.sql_query()`. **No internet connection is needed for queries** — only for downloading actual image files, or for installing optional components of `idc-index`.\n", + "\n", + "The primary table is `index`, which has one row per DICOM series and includes columns like:\n", + "- `SeriesInstanceUID` — unique identifier for a series (used for downloading)\n", + "- `collection_id` — which dataset the series belongs to (e.g., `lidc_idri`, `nlst`)\n", + "- `PatientID`, `StudyInstanceUID` — standard DICOM identifiers\n", + "- `Modality` — imaging type (`CT`, `MR`, `SEG`, `RTSTRUCT`, etc.)\n", + "- `series_size_MB` — download size in megabytes\n", + "- `license_short_name` — data license (important before use in a project)\n", + "\n", + "Additional index tables (loaded on demand with `fetch_index()`) extend this with collection-level info, segmentation metadata, volume geometry, metadata specific to pathology images, etc (see [this documentation page](https://idc-index.readthedocs.io/en/latest/indices_reference.html) for details)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "3qV-kCTbFCpD", + "outputId": "bc81ea35-a345-4b1b-f4ba-bc9201f85d22" + }, + "outputs": [], + "source": [ + "# IDCClient is the main entry point for idc-index.\n", + "client = IDCClient()\n", + "\n", + "# IDC releases versioned snapshots of the metadata.\n", + "# The version number tells you which data release the local index reflects.\n", + "print(f\"IDC version: {client.get_idc_version()}\")\n", + "\n", + "# Query the primary 'index' table to see the overall scale of IDC.\n", + "# 'collection_id' groups series by dataset; 'PatientID' is the DICOM patient identifier.\n", + "stats = client.sql_query(\"\"\"\n", + " SELECT COUNT(DISTINCT collection_id) as collections,\n", + " COUNT(DISTINCT PatientID) as patients,\n", + " COUNT(DISTINCT SeriesInstanceUID) as series,\n", + " SUM(series_size_MB) as size_mb,\n", + " ROUND(SUM(series_size_MB) / 1e6, 2) as size_tb\n", + " FROM index\n", + "\"\"\")\n", + "row = stats.iloc[0]\n", + "print(f\"Collections: {row['collections']}, Patients: {row['patients']}, Total size: {row['size_tb']}TB\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "O5p6zyhDFCpD", + "outputId": "09d16b16-fbf6-4438-974b-68080b0a49e4" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Lung CT collections:\n", + " collection_id Subjects CancerTypes ct_series\n", + " nlst 26410 Lung Cancer, Non-Cancer 203087\n", + " lidc_idri 1010 Lung Cancer, Non-Cancer, Metastatic disease 1018\n", + " tcga_luad 560 Lung Adenocarcinoma 551\n", + "mediastinal_lymph_node_seg 513 Breast Cancer, Non-small Cell Lung Cancer, Hodgkin Lymphoma, Small Cell Lung Cancer, Thyroid Cancer, Adenocarcinoma, Melanoma, Head and Neck Cancer, Prostate Cancer, Mesothelioma, Ovarian Cancer, Colon Cancer 513\n", + " tcga_lusc 504 Lung Squamous Cell Carcinoma 235\n" + ] + } + ], + "source": [ + "# 'collections_index' is an optional table with one row per IDC collection.\n", + "# It adds collection-level metadata not in the per-series 'index' t able,\n", + "# such as CancerTypes, Subjects count, and collection descriptions.\n", + "client.fetch_index_table(\"collections_index\")\n", + "\n", + "# Join collections_index with the per-series index to filter by both cancer type and modality.\n", + "# The 'index' table has Modality per series; collections_index has CancerTypes per collection.\n", + "lung_collections = client.sql_query(\"\"\"\n", + " SELECT c.collection_id, c.Subjects, c.CancerTypes,\n", + " COUNT(DISTINCT CASE WHEN i.Modality = 'CT' THEN i.SeriesInstanceUID END) as ct_series\n", + " FROM collections_index c\n", + " JOIN index i ON c.collection_id = i.collection_id\n", + " WHERE c.CancerTypes LIKE '%Lung%'\n", + " GROUP BY c.collection_id, c.Subjects, c.CancerTypes\n", + " HAVING ct_series > 0\n", + " ORDER BY c.Subjects DESC\n", + " LIMIT 5\n", + "\"\"\")\n", + "print(\"Lung CT collections:\")\n", + "print(lung_collections.to_string(index=False))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Wfr7bRSDFCpD", + "outputId": "e96d6e05-a16e-40c3-c7c2-5d13e5042147" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 3 CT series\n" + ] + } + ], + "source": [ + "# 'volume_geometry_index' is a supplemental table that adds pre-computed\n", + "# geometric quality flags for each CT/MR series — for example:\n", + "# regularly_spaced_3d_volume = TRUE means the slices form a clean 3D volume\n", + "# (uniform spacing, no gaps, no duplicate positions).\n", + "# Filtering on this flag avoids downloading series that won't load cleanly into MONAI.\n", + "client.fetch_index(\"volume_geometry_index\")\n", + "\n", + "# Select a few small CT series that form well-formed 3D volumes.\n", + "# We join 'index' (series metadata) with 'volume_geometry_index' (geometry flags).\n", + "# ORDER BY series_size_MB is not here, but LIMIT 3 keeps the demo download small.\n", + "series_df = client.sql_query(\"\"\"\n", + " SELECT index.SeriesInstanceUID, PatientID, Modality,\n", + " ROUND(series_size_MB, 2) as size_mb\n", + " FROM index\n", + " JOIN volume_geometry_index USING (SeriesInstanceUID)\n", + " WHERE regularly_spaced_3d_volume = TRUE AND Modality = 'CT'\n", + " LIMIT 3\n", + "\"\"\")\n", + "print(f\"Found {len(series_df)} CT series\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qY5J-bmxFCpD" + }, + "source": [ + "## 2. Download DICOM Data\n", + "\n", + "`download_from_selection()` fetches DICOM files directly from IDC's Google Cloud Storage buckets. No account or credentials are needed — all IDC data is publicly accessible.\n", + "\n", + "Files are organized on disk according to the `dirTemplate` pattern. Using `%SeriesInstanceUID` creates one subdirectory per series, which is what MONAI's `ITKReader` expects when loading a DICOM series." + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "0NeNmIQ1FCpD", + "outputId": "8202baa5-c338-4a55-ab3a-4ab1b5127333" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading 3 series...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Downloading data: 100%|█████████▉| 329M/329M [00:07<00:00, 46.0MB/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Done!\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# Create a temporary directory to hold downloaded DICOM files.\n", + "data_dir = tempfile.mkdtemp(prefix=\"idc_monai_\")\n", + "series_uids = list(series_df['SeriesInstanceUID'])\n", + "\n", + "print(f\"Downloading {len(series_uids)} series...\")\n", + "# download_from_selection() accepts a list of SeriesInstanceUIDs and fetches\n", + "# all DICOM files for those series from IDC's GCS buckets.\n", + "# dirTemplate=\"%SeriesInstanceUID\" puts each series in its own subdirectory —\n", + "# required because MONAI's ITKReader reads a directory to reconstruct a 3D volume.\n", + "client.download_from_selection(\n", + " seriesInstanceUID=series_uids,\n", + " downloadDir=data_dir,\n", + " dirTemplate=\"%SeriesInstanceUID\"\n", + ")\n", + "print(\"Done!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ZI2ffIdmFCpE" + }, + "source": [ + "## 3. Load with MONAI Transforms\n", + "\n", + "MONAI's `LoadImaged` with `ITKReader` directly loads DICOM series from directories." + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "tCoXJmSlFCpE", + "outputId": "b07ea514-36be-4800-c854-fc2f6e1efb94" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "monai.transforms.spatial.dictionary Orientationd.__init__:labels: Current default value of argument `labels=(('L', 'R'), ('P', 'A'), ('I', 'S'))` was changed in version None from `labels=(('L', 'R'), ('P', 'A'), ('I', 'S'))` to `labels=None`. Default value changed to None meaning that the transform now uses the 'space' of a meta-tensor, if applicable, to determine appropriate axis labels.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Image shape: torch.Size([1, 280, 280, 171])\n", + "Value range: [0.00, 1.00]\n" + ] + } + ], + "source": [ + "# Define transforms for CT preprocessing\n", + "# Use ITKReader explicitly to load DICOM series from directories\n", + "transforms = Compose([\n", + " LoadImaged(keys=[\"image\"], reader=ITKReader()),\n", + " EnsureChannelFirstd(keys=[\"image\"]),\n", + " Orientationd(keys=[\"image\"], axcodes=\"RAS\"),\n", + " Spacingd(keys=[\"image\"], pixdim=(1.5, 1.5, 2.0)),\n", + " ScaleIntensityRanged(keys=[\"image\"], a_min=-175, a_max=250,\n", + " b_min=0.0, b_max=1.0, clip=True),\n", + "])\n", + "\n", + "# Create dataset\n", + "data_dicts = [{\"image\": os.path.join(data_dir, uid)} for uid in series_uids]\n", + "dataset = Dataset(data=data_dicts, transform=transforms)\n", + "\n", + "# Load sample\n", + "sample = dataset[0]\n", + "print(f\"Image shape: {sample['image'].shape}\")\n", + "print(f\"Value range: [{sample['image'].min():.2f}, {sample['image'].max():.2f}]\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7AFaXdBXFCpE" + }, + "source": [ + "## 4. Visualize" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 521 + }, + "id": "3cz897-RFCpE", + "outputId": "bf4729c9-a2d1-4919-fe3f-65697b0ba56b" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "image = sample['image'][0]\n", + "z = image.shape[2] // 2\n", + "\n", + "plt.figure(figsize=(6, 6))\n", + "plt.imshow(image[:, :, z].T, cmap='gray', origin='lower')\n", + "plt.title(f'CT from IDC (slice {z})')\n", + "plt.axis('off')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GXWVYLRAFCpE" + }, + "source": [ + "## 5. Loading DICOM Segmentations\n", + "\n", + "IDC contains DICOM Segmentation (DICOM-SEG) objects. These are different from regular DICOM series:\n", + "- **Enhanced multiframe**: All slices in a single file\n", + "- **Cannot use ITKReader**: Standard readers don't support this format\n", + "- **Segment metadata**: Each segment has label, description, and recommended display color\n", + "\n", + "We define a custom `LoadDicomSegd` transform that:\n", + "1. Uses `itkwasm-dicom` (wraps dcmqi) for robust DICOM-SEG reading\n", + "2. Derives the affine matrix directly from DICOM metadata (direction cosines, spacing, origin) — no axis flipping\n", + "3. Orientation is fully encoded in the affine via the direction cosine matrix\n", + "4. Extracts segment colors from DICOM metadata for visualization\n", + "\n", + "> **Note**: CT and SEG may have different affines when acquired with different orientations (common with AI-generated segmentations like TotalSegmentator). Apply `Orientationd` to normalize both to a common orientation before voxel-level overlay." + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "zYsf2TZxFCpE", + "outputId": "c52d34fc-746d-4035-8444-778ded4ef6de" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CT with TotalSegmentator segmentations:\n", + " image_uid seg_uid collection_id total_segments image_mb\n", + " 1.2.840.113654.2.55.39501032054040159252741883490811009228 1.2.276.0.7230010.3.1.3.313263360.23926.1706319815.161829 nlst 47 26.32\n", + "1.2.840.113654.2.55.134877680474542655199243531560181528016 1.2.276.0.7230010.3.1.3.313263360.31910.1706312185.595733 nlst 73 26.32\n", + "1.2.840.113654.2.55.296129646159215067393462057349853219678 1.2.276.0.7230010.3.1.3.313263360.35421.1706312631.378111 nlst 62 26.32\n" + ] + } + ], + "source": [ + "# 'seg_index' is a supplemental index table with one row per DICOM Segmentation series in IDC.\n", + "# It adds metadata specific to segmentations that isn't in the primary 'index' table:\n", + "# segmented_SeriesInstanceUID — the SeriesInstanceUID of the CT/MR image that was segmented\n", + "# AlgorithmName — the tool that created the segmentation (e.g., TotalSegmentator)\n", + "# total_segments — how many anatomical structures are labeled in the file\n", + "# fetch_index() downloads and caches it locally; once cached it won't re-download.\n", + "client.fetch_index(\"seg_index\")\n", + "\n", + "# Find CT series that have TotalSegmentator segmentations.\n", + "# TotalSegmentator is an AI model that auto-segments 100+ anatomical structures.\n", + "# The JOIN links each segmentation back to its source CT via segmented_SeriesInstanceUID.\n", + "# We sort by image size (ASC) so the demo downloads the smallest available pair.\n", + "paired = client.sql_query(\"\"\"\n", + " SELECT src.SeriesInstanceUID as image_uid,\n", + " seg.SeriesInstanceUID as seg_uid,\n", + " src.collection_id, seg.total_segments,\n", + " ROUND(src.series_size_MB, 2) as image_mb\n", + " FROM seg_index seg\n", + " JOIN index src ON seg.segmented_SeriesInstanceUID = src.SeriesInstanceUID\n", + " WHERE src.Modality = 'CT'\n", + " AND seg.AlgorithmName LIKE '%TotalSegmentator%'\n", + " ORDER BY src.series_size_MB ASC\n", + " LIMIT 3\n", + "\"\"\")\n", + "print(\"CT with TotalSegmentator segmentations:\")\n", + "print(paired.to_string(index=False))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "vU6WkmrNFCpE", + "outputId": "fb6b6730-882c-4dbe-e37e-d09e3beeea86" + }, + "outputs": [], + "source": [ + "# Download one image-segmentation pair\n", + "demo_pair = paired.iloc[0]\n", + "seg_dir = tempfile.mkdtemp(prefix=\"idc_seg_\")\n", + "\n", + "print(\"Downloading image and segmentation pair...\")\n", + "client.download_from_selection(\n", + " seriesInstanceUID=[demo_pair['image_uid'], demo_pair['seg_uid']],\n", + " downloadDir=seg_dir,\n", + " dirTemplate=\"%SeriesInstanceUID\"\n", + ")\n", + "print(\"Done!\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "o4dsoW59FCpE", + "outputId": "386c615d-5349-49fb-f412-7a92cfc421d9" + }, + "outputs": [], + "source": [ + "import itkwasm_dicom # noqa: E402\n", + "\n", + "\n", + "class LoadDicomSegd(MapTransform):\n", + " \"\"\"Load DICOM Segmentation (DICOM-SEG) files using ITKWasm.\n", + "\n", + " DICOM-SEG is an enhanced multiframe DICOM format that stores segmentation\n", + " masks with segment metadata including recommended display colors.\n", + "\n", + " The affine matrix is derived directly from DICOM metadata (direction cosines,\n", + " spacing, origin) with LPS→RAS conversion applied to match MONAI's ITKReader\n", + " convention. No axis flipping is performed — orientation is fully encoded in\n", + " the affine via the direction cosine matrix.\n", + " \"\"\"\n", + "\n", + " def __init__(self, keys: KeysCollection, allow_missing_keys: bool = False):\n", + " super().__init__(keys, allow_missing_keys)\n", + "\n", + " def _find_dcm_file(self, path: Path) -> Path:\n", + " \"\"\"Find .dcm file in directory or return path if already a file.\"\"\"\n", + " if path.is_file():\n", + " return path\n", + " dcm_files = list(path.glob(\"*.dcm\"))\n", + " if not dcm_files:\n", + " raise FileNotFoundError(f\"No .dcm files found in {path}\")\n", + " return dcm_files[0]\n", + "\n", + " def _build_affine(self, spacing, origin, direction) -> np.ndarray:\n", + " \"\"\"Build 4x4 affine matrix from DICOM spatial metadata.\n", + "\n", + " Converts from ITK/DICOM LPS convention to MONAI's RAS-like convention\n", + " by negating X and Y world coordinates (LPS→RAS). No axis flips are\n", + " applied — orientation is fully encoded in the affine via the direction\n", + " cosine matrix.\n", + "\n", + " Args:\n", + " spacing: Voxel spacing (X, Y, Z) as returned by itkwasm\n", + " origin: Physical coordinates of voxel [0,0,0] in LPS\n", + " direction: 3x3 direction cosine matrix D where D[i,j] is the\n", + " component of voxel-axis-j's unit vector along LPS\n", + " physical axis i. ITK affine formula:\n", + " world_lps = D @ diag(spacing) @ voxel + origin\n", + " \"\"\"\n", + " lps_to_ras = np.diag([-1., -1., 1.])\n", + " affine = np.eye(4)\n", + " affine[:3, :3] = lps_to_ras @ direction @ np.diag(spacing)\n", + " affine[:3, 3] = lps_to_ras @ origin\n", + " return affine\n", + "\n", + " def __call__(self, data: Mapping[Hashable, any]) -> dict[Hashable, any]:\n", + " d = dict(data)\n", + " for key in self.key_iterator(d):\n", + " path = Path(d[key])\n", + " dcm_file = self._find_dcm_file(path)\n", + "\n", + " # Read using ITKWasm\n", + " seg_image, overlay_info = itkwasm_dicom.read_segmentation(dcm_file)\n", + "\n", + " # ITKWasm returns array in (Z, Y, X) order but metadata in (X, Y, Z) order.\n", + " # Transpose to (X, Y, Z) to match metadata — this is a layout convention,\n", + " # not an orientation flip.\n", + " seg_array = np.asarray(seg_image.data).copy()\n", + " seg_array = np.transpose(seg_array, (2, 1, 0))\n", + "\n", + " # Build affine from spatial metadata\n", + " spacing = np.array(seg_image.spacing)\n", + " origin = np.array(seg_image.origin)\n", + " direction = np.array(seg_image.direction).reshape(3, 3)\n", + "\n", + " affine = self._build_affine(spacing, origin, direction)\n", + "\n", + " # Make contiguous (array may be non-contiguous after transpose)\n", + " seg_array = np.ascontiguousarray(seg_array)\n", + "\n", + " # Create MONAI MetaTensor with metadata\n", + " meta_tensor = MetaTensor(seg_array)\n", + " meta_tensor.affine = affine\n", + " meta_tensor.meta[\"filename_or_obj\"] = str(dcm_file)\n", + " meta_tensor.meta[\"overlay_info\"] = overlay_info\n", + " meta_tensor.meta[\"original_channel_dim\"] = \"no_channel\"\n", + "\n", + " d[key] = meta_tensor\n", + " d[f\"{key}_meta_dict\"] = dict(meta_tensor.meta)\n", + "\n", + " return d\n", + "\n", + "\n", + "# Load CT with MONAI's ITKReader\n", + "ct_transforms = Compose([\n", + " LoadImaged(keys=[\"image\"], reader=ITKReader()),\n", + " EnsureChannelFirstd(keys=[\"image\"]),\n", + "])\n", + "\n", + "# Load SEG with our custom LoadDicomSegd\n", + "seg_transforms = Compose([\n", + " LoadDicomSegd(keys=[\"label\"]),\n", + " EnsureChannelFirstd(keys=[\"label\"]),\n", + "])\n", + "\n", + "# Load both\n", + "image_path = os.path.join(seg_dir, demo_pair['image_uid'])\n", + "seg_path = os.path.join(seg_dir, demo_pair['seg_uid'])\n", + "\n", + "ct_data = ct_transforms({\"image\": image_path})\n", + "seg_data = seg_transforms({\"label\": seg_path})\n", + "\n", + "ct_image = ct_data[\"image\"]\n", + "seg_label = seg_data[\"label\"]\n", + "\n", + "print(f\"CT image shape: {ct_image.shape}\")\n", + "print(f\"Segmentation shape: {seg_label.shape}\")\n", + "print(f\"Unique labels: {torch.unique(seg_label)[:10].tolist()}...\") # First 10 labels" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "2LadU47uFCpF", + "outputId": "919b55b1-7240-4118-d67d-d466af47ad57" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CT affine:\n", + "tensor([[-7.4700e-01, 0.0000e+00, 0.0000e+00, 1.9688e+02],\n", + " [ 0.0000e+00, -7.4700e-01, 0.0000e+00, 1.9922e+02],\n", + " [ 0.0000e+00, 0.0000e+00, 2.0000e+00, 1.3415e+03],\n", + " [ 0.0000e+00, 0.0000e+00, 0.0000e+00, 1.0000e+00]],\n", + " dtype=torch.float64)\n", + "\n", + "SEG affine:\n", + "tensor([[-7.4700e-01, 0.0000e+00, 0.0000e+00, 1.9688e+02],\n", + " [ 0.0000e+00, 7.4700e-01, 0.0000e+00, -1.8250e+02],\n", + " [ 0.0000e+00, 0.0000e+00, -2.0000e+00, 1.4395e+03],\n", + " [ 0.0000e+00, 0.0000e+00, 0.0000e+00, 1.0000e+00]],\n", + " dtype=torch.float64)\n", + "\n", + "Affines differ — CT and SEG have different acquisition orientations.\n", + "Apply Orientationd(axcodes='RAS') to both before voxel-level overlay.\n" + ] + } + ], + "source": [ + "# Print affines — they may differ when CT and SEG have different direction matrices.\n", + "# Both are correct: each faithfully encodes the spatial metadata from its DICOM file.\n", + "# Use Orientationd to normalize to a common orientation before voxel-level overlay.\n", + "print(\"CT affine:\")\n", + "print(ct_image.affine)\n", + "print(\"\\nSEG affine:\")\n", + "print(seg_label.affine)\n", + "\n", + "affines_match = torch.allclose(ct_image.affine, seg_label.affine, atol=1e-4)\n", + "if affines_match:\n", + " print(\"\\nAffines match — CT and SEG share the same acquisition orientation.\")\n", + "else:\n", + " print(\"\\nAffines differ — CT and SEG have different acquisition orientations.\")\n", + " print(\"Apply Orientationd(axcodes='RAS') to both before voxel-level overlay.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ZgzJ9CFAFCpF" + }, + "source": [ + "## 5.1 Exploring Segment Metadata\n", + "\n", + "DICOM SEG files contain rich metadata about each segment, including:\n", + "- **SegmentLabel**: Human-readable name (e.g., \"Liver\", \"Spleen\")\n", + "- **SegmentedPropertyCategoryCodeSequence**: Category (e.g., \"Anatomical Structure\", \"Tumor\")\n", + "- **SegmentedPropertyTypeCodeSequence**: Specific type using standardized codes (e.g., SNOMED-CT)\n", + "- **recommendedDisplayRGBValue**: Display color for visualization\n", + "- **labelID**: Integer label value in the segmentation array" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "TL8R1jyNFCpF", + "outputId": "50ca6e7e-685e-4b05-ca3e-b52ae2639a6e" + }, + "outputs": [], + "source": [ + "def get_segment_info(overlay_info):\n", + " \"\"\"Extract segment information from DICOM SEG overlay_info.\n", + "\n", + " Args:\n", + " overlay_info: Dictionary from LoadDicomSegd containing segmentAttributes\n", + "\n", + " Returns:\n", + " List of dicts with segment details (label_id, name, category, type, color)\n", + " \"\"\"\n", + " segment_attrs = overlay_info.get(\"segmentAttributes\", [[]])\n", + "\n", + " # Flatten segment attributes (may be nested in groups)\n", + " all_segments = []\n", + " for group in segment_attrs:\n", + " all_segments.extend(group)\n", + "\n", + " segments = []\n", + " for seg in all_segments:\n", + " # Extract category (e.g., \"Anatomical Structure\", \"Morphologically Altered Structure\")\n", + " category_seq = seg.get(\"SegmentedPropertyCategoryCodeSequence\", {})\n", + " category = category_seq.get(\"CodeMeaning\", \"Unknown\")\n", + "\n", + " # Extract type (e.g., \"Liver\", \"Spleen\") with coding scheme\n", + " type_seq = seg.get(\"SegmentedPropertyTypeCodeSequence\", {})\n", + " seg_type = type_seq.get(\"CodeMeaning\", \"Unknown\")\n", + " type_code = type_seq.get(\"CodeValue\", \"\")\n", + " coding_scheme = type_seq.get(\"CodingSchemeDesignator\", \"\")\n", + "\n", + " # Extract modifier if present (e.g., \"Left\", \"Right\")\n", + " modifier_seq = seg.get(\"SegmentedPropertyTypeModifierCodeSequence\", {})\n", + " modifier = modifier_seq.get(\"CodeMeaning\", \"\") if modifier_seq else \"\"\n", + "\n", + " segments.append({\n", + " \"label_id\": seg.get(\"labelID\", 0),\n", + " \"name\": seg.get(\"SegmentLabel\", \"Unknown\"),\n", + " \"category\": category,\n", + " \"type\": seg_type,\n", + " \"type_code\": f\"{coding_scheme}:{type_code}\" if type_code else \"\",\n", + " \"modifier\": modifier,\n", + " \"color_rgb\": seg.get(\"recommendedDisplayRGBValue\", [128, 128, 128]),\n", + " \"algorithm\": seg.get(\"SegmentAlgorithmName\", \"\"),\n", + " })\n", + "\n", + " return sorted(segments, key=lambda x: x[\"label_id\"])\n", + "\n", + "\n", + "# Extract segment information\n", + "overlay_info = seg_data.get('label_meta_dict', {}).get('overlay_info', {})\n", + "segments = get_segment_info(overlay_info)\n", + "\n", + "print(f\"Found {len(segments)} segments in DICOM SEG:\\n\")\n", + "print(f\"{'ID':<4} {'Name':<25} {'Category':<25} {'Type':<20} {'Code'}\")\n", + "print(\"-\" * 100)\n", + "for seg in segments[:15]: # Show first 15\n", + " print(f\"{seg['label_id']:<4} {seg['name']:<25} {seg['category']:<25} {seg['type']:<20} {seg['type_code']}\")\n", + "\n", + "if len(segments) > 15:\n", + " print(f\"... and {len(segments) - 15} more segments\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "nOsP3Jd3FCpF", + "outputId": "313c7848-24d8-4c1f-d85e-342b94258d12" + }, + "outputs": [], + "source": [ + "# Create a lookup dictionary: label_id -> segment name\n", + "# Useful for interpreting model predictions or filtering specific structures\n", + "label_to_name = {seg[\"label_id\"]: seg[\"name\"] for seg in segments}\n", + "\n", + "# Normalize both CT and SEG to RAS orientation before visualization.\n", + "# CT and SEG may have different direction matrices (different acquisition orientations),\n", + "# so the same voxel index maps to different world positions without reorientation.\n", + "ct_ras = Orientationd(keys=[\"image\"], axcodes=\"RAS\")(ct_data)[\"image\"]\n", + "seg_ras = Orientationd(keys=[\"label\"], axcodes=\"RAS\")(seg_data)[\"label\"]\n", + "\n", + "ct_np = ct_ras[0].numpy()\n", + "seg_np = seg_ras[0].numpy()\n", + "\n", + "\n", + "# Find matching z-slices via world coordinates so the overlay is anatomically correct.\n", + "# The SEG and CT z-axes may still have different extents after RAS reorientation.\n", + "def voxel_to_world(affine, voxel):\n", + " return (np.array(affine) @ np.append(voxel, 1))[:3]\n", + "\n", + "\n", + "def world_to_voxel(affine, world):\n", + " return (np.linalg.inv(np.array(affine)) @ np.append(world, 1))[:3]\n", + "\n", + "\n", + "# Find SEG z-slice at the midpoint of the labeled region\n", + "z_slices_with_labels = np.where(seg_np.sum(axis=(0, 1)) > 0)[0]\n", + "seg_mid_z = (\n", + " int(z_slices_with_labels[len(z_slices_with_labels) // 2])\n", + " if len(z_slices_with_labels) > 0\n", + " else seg_np.shape[2] // 2\n", + ")\n", + "\n", + "# Map SEG midpoint z to CT z via world coordinates\n", + "seg_mid_world = voxel_to_world(seg_ras.affine, [0, 0, seg_mid_z])\n", + "ct_mid_voxel = world_to_voxel(ct_ras.affine, seg_mid_world)\n", + "z_mid = int(np.clip(np.round(ct_mid_voxel[2]), 0, ct_np.shape[2] - 1))\n", + "\n", + "# Show which segments are present in the matched slice\n", + "seg_slice_check = seg_np[:, :, seg_mid_z]\n", + "labels_in_slice = [int(lbl) for lbl in np.unique(seg_slice_check) if lbl > 0]\n", + "\n", + "print(f\"Segments visible in SEG slice {seg_mid_z} (mapped to CT slice {z_mid}):\")\n", + "for label_id in labels_in_slice[:10]:\n", + " seg_info = next((s for s in segments if s[\"label_id\"] == label_id), None)\n", + " if seg_info:\n", + " color = seg_info[\"color_rgb\"]\n", + " print(f\" Label {label_id}: {seg_info['name']:<20} (RGB: {color})\")\n", + "\n", + "if len(labels_in_slice) > 10:\n", + " print(f\" ... and {len(labels_in_slice) - 10} more\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 547 + }, + "id": "t-TdONZ3FCpF", + "outputId": "8524cdfd-f75e-4738-acbf-babd4a580256" + }, + "outputs": [], + "source": [ + "def build_seg_colormap(overlay_info):\n", + " \"\"\"Build a matplotlib colormap from DICOM SEG segment colors.\n", + "\n", + " Args:\n", + " overlay_info: Dictionary from LoadDicomSegd containing segmentAttributes\n", + "\n", + " Returns:\n", + " ListedColormap with colors for each segment label\n", + " \"\"\"\n", + " segment_attrs = overlay_info.get(\"segmentAttributes\", [[]])\n", + "\n", + " # Flatten segment attributes (may be nested in groups)\n", + " all_segments = []\n", + " for group in segment_attrs:\n", + " all_segments.extend(group)\n", + "\n", + " if not all_segments:\n", + " return plt.cm.nipy_spectral\n", + "\n", + " max_label = max(seg.get(\"labelID\", 0) for seg in all_segments)\n", + "\n", + " # Build RGBA color array: index 0 = background (transparent)\n", + " colors = np.zeros((max_label + 1, 4))\n", + " colors[0] = [0, 0, 0, 0] # Background transparent\n", + "\n", + " for seg in all_segments:\n", + " label_id = seg.get(\"labelID\", 0)\n", + " rgb = seg.get(\"recommendedDisplayRGBValue\", [128, 128, 128])\n", + " colors[label_id] = [rgb[0]/255, rgb[1]/255, rgb[2]/255, 1.0]\n", + "\n", + " return ListedColormap(colors)\n", + "\n", + "\n", + "# Build colormap from DICOM SEG metadata\n", + "seg_cmap = build_seg_colormap(overlay_info)\n", + "\n", + "# Visualize using RAS-normalized arrays (reoriented in cell above).\n", + "# Slices are matched via world coordinates, not raw array indices.\n", + "fig, axes = plt.subplots(1, 3, figsize=(15, 5))\n", + "\n", + "# CT image only\n", + "axes[0].imshow(ct_np[:, :, z_mid].T, cmap='gray', origin='lower', vmin=-1000, vmax=500)\n", + "axes[0].set_title(f'CT Image (RAS, z={z_mid})')\n", + "axes[0].axis('off')\n", + "\n", + "# Segmentation only (using DICOM SEG colors)\n", + "axes[1].imshow(seg_np[:, :, seg_mid_z].T, cmap=seg_cmap, origin='lower',\n", + " vmin=0, vmax=len(seg_cmap.colors)-1, interpolation='nearest')\n", + "axes[1].set_title(f'Segmentation (RAS, z={seg_mid_z})\\n({int(seg_np.max())} labels, DICOM SEG colors)')\n", + "axes[1].axis('off')\n", + "\n", + "# Overlay — both arrays are in RAS, z-slices matched via world coordinates\n", + "axes[2].imshow(ct_np[:, :, z_mid].T, cmap='gray', origin='lower', vmin=-1000, vmax=500)\n", + "seg_slice = seg_np[:, :, seg_mid_z]\n", + "mask = np.ma.masked_where(seg_slice == 0, seg_slice)\n", + "axes[2].imshow(mask.T, cmap=seg_cmap, alpha=0.6, origin='lower',\n", + " vmin=0, vmax=len(seg_cmap.colors)-1, interpolation='nearest')\n", + "axes[2].set_title('Overlay (RAS)\\n(DICOM SEG colors)')\n", + "axes[2].axis('off')\n", + "\n", + "plt.suptitle('CT + TotalSegmentator Segmentation', fontsize=14)\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "print(\"\\n✓ Segmentation loaded with LoadDicomSegd and overlaid after RAS reorientation!\")\n", + "print(\" Colors extracted from DICOM SEG recommendedDisplayRGBValue.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "nFG58GjfFCpF" + }, + "source": [ + "## 6. Check Licenses Before Using Data\n", + "\n", + "IDC collections use a variety of open licenses, although >95% of data is covered by CC-BY licenses. The license governs what you can do with the data — for example:\n", + "- **CC BY** — freely use, modify, and redistribute with attribution (most permissive)\n", + "- **CC BY-NC** — non-commercial use only with attribution\n", + "\n", + "Always check the license before training models or publishing results. The `license_short_name` column in the `index` table makes this a simple SQL query." + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "pbLa41sgFCpF", + "outputId": "61ea7153-0130-44a9-b433-467465499379" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Licenses:\n", + "license_short_name count\n", + " CC BY 4.0 3\n" + ] + } + ], + "source": [ + "# Always check licenses before use\n", + "uid_list = \", \".join(f\"'{uid}'\" for uid in series_uids)\n", + "licenses = client.sql_query(f\"\"\"\n", + " SELECT license_short_name, COUNT(*) as count\n", + " FROM index WHERE SeriesInstanceUID IN ({uid_list})\n", + " GROUP BY license_short_name\n", + "\"\"\")\n", + "print(\"Licenses:\")\n", + "print(licenses.to_string(index=False))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "oRVp9eTeFCpF" + }, + "source": [ + "## 7. Cleanup" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "sKTSD2UKFCpG", + "outputId": "877e2079-683b-40f2-b095-8fd55324c173" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Data at: /tmp/idc_monai_saoiqlhn\n" + ] + } + ], + "source": [ + "# import shutil; shutil.rmtree(data_dir) # Uncomment to delete\n", + "print(f\"Data at: {data_dir}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xave1m8xFCpG" + }, + "source": [ + "## Summary\n", + "\n", + "This tutorial demonstrated:\n", + "1. Querying IDC with `idc-index` SQL — no cloud account needed, queries run locally\n", + "2. Downloading DICOM images and segmentations with `download_from_selection()`\n", + "3. Loading CT images into MONAI with `LoadImaged` and `ITKReader`\n", + "4. Finding image–segmentation pairs via `seg_index`\n", + "5. Loading DICOM-SEG files with a custom `LoadDicomSegd` transform\n", + "6. Extracting per-segment metadata (names, categories, standardized codes)\n", + "7. Using DICOM SEG recommended colors for anatomically meaningful visualization\n", + "\n", + "**Key IDC Concepts:**\n", + "- **`index` table** — one row per DICOM series; the starting point for all queries\n", + "- **Supplemental indexes** (`collections_index`, `seg_index`, `volume_geometry_index`) — loaded on demand via `fetch_index()` for specialized metadata\n", + "- **No auth required** — all IDC data is publicly accessible; just install `idc-index` and query\n", + "\n", + "**Key DICOM-SEG Concepts:** Each segment in a DICOM-SEG file carries:\n", + "- `SegmentLabel` — Human-readable name (e.g., \"Liver\")\n", + "- `SegmentedPropertyCategoryCodeSequence` — Category (e.g., \"Anatomical Structure\")\n", + "- `SegmentedPropertyTypeCodeSequence` — Type with standardized codes (SNOMED-CT, RadLex, etc.)\n", + "- `recommendedDisplayRGBValue` — Suggested display color baked into the DICOM file\n", + "\n", + "**Resources:**\n", + "- [IDC Tutorials](https://github.com/ImagingDataCommons/IDC-Tutorials) - Self-guided Google Colab notebooks\n", + "- [IDC Portal](https://portal.imaging.datacommons.cancer.gov/) — Interactive browser for exploring collections\n", + "- [IDC Documentation](https://learn.canceridc.dev/) — Full documentation and tutorials\n", + "- [IDC User Forum](https://discourse.canceridc.dev/) — Community support from IDC maintainers\n", + "- [idc-index on GitHub](https://github.com/ImagingDataCommons/idc-index) — Package source and issue tracker\n", + "- [ITKWasm DICOM](https://wasm.itk.org/en/latest/introduction/file_formats/dicom.html)\n", + "- [idc-claude-skill](https://github.com/ImagingDataCommons/idc-claude-skill) — an AI assistant skill for navigating IDC data and the `idc-index` API." + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.9" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} From e29e86147b9e6fd1bf0c74a7f59ee55102a601b3 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 1 May 2026 22:29:46 +0000 Subject: [PATCH 2/8] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- modules/idc_dataset.ipynb | 161 +++++++++++++++++++++----------------- 1 file changed, 90 insertions(+), 71 deletions(-) diff --git a/modules/idc_dataset.ipynb b/modules/idc_dataset.ipynb index c0f15adb9..88144ad77 100644 --- a/modules/idc_dataset.ipynb +++ b/modules/idc_dataset.ipynb @@ -70,12 +70,14 @@ "\n", "# Restart runtime after installing ITK (required for ITK to load properly)\n", "import sys\n", + "\n", "if \"google.colab\" in sys.modules:\n", " try:\n", " import itk # noqa: F401\n", " except ImportError:\n", " print(\"Restarting runtime to load ITK...\")\n", " import os\n", + "\n", " os.kill(os.getpid(), 9)" ] }, @@ -170,14 +172,16 @@ "\n", "# Query the primary 'index' table to see the overall scale of IDC.\n", "# 'collection_id' groups series by dataset; 'PatientID' is the DICOM patient identifier.\n", - "stats = client.sql_query(\"\"\"\n", + "stats = client.sql_query(\n", + " \"\"\"\n", " SELECT COUNT(DISTINCT collection_id) as collections,\n", " COUNT(DISTINCT PatientID) as patients,\n", " COUNT(DISTINCT SeriesInstanceUID) as series,\n", " SUM(series_size_MB) as size_mb,\n", " ROUND(SUM(series_size_MB) / 1e6, 2) as size_tb\n", " FROM index\n", - "\"\"\")\n", + "\"\"\"\n", + ")\n", "row = stats.iloc[0]\n", "print(f\"Collections: {row['collections']}, Patients: {row['patients']}, Total size: {row['size_tb']}TB\")" ] @@ -215,7 +219,8 @@ "\n", "# Join collections_index with the per-series index to filter by both cancer type and modality.\n", "# The 'index' table has Modality per series; collections_index has CancerTypes per collection.\n", - "lung_collections = client.sql_query(\"\"\"\n", + "lung_collections = client.sql_query(\n", + " \"\"\"\n", " SELECT c.collection_id, c.Subjects, c.CancerTypes,\n", " COUNT(DISTINCT CASE WHEN i.Modality = 'CT' THEN i.SeriesInstanceUID END) as ct_series\n", " FROM collections_index c\n", @@ -225,7 +230,8 @@ " HAVING ct_series > 0\n", " ORDER BY c.Subjects DESC\n", " LIMIT 5\n", - "\"\"\")\n", + "\"\"\"\n", + ")\n", "print(\"Lung CT collections:\")\n", "print(lung_collections.to_string(index=False))" ] @@ -260,14 +266,16 @@ "# Select a few small CT series that form well-formed 3D volumes.\n", "# We join 'index' (series metadata) with 'volume_geometry_index' (geometry flags).\n", "# ORDER BY series_size_MB is not here, but LIMIT 3 keeps the demo download small.\n", - "series_df = client.sql_query(\"\"\"\n", + "series_df = client.sql_query(\n", + " \"\"\"\n", " SELECT index.SeriesInstanceUID, PatientID, Modality,\n", " ROUND(series_size_MB, 2) as size_mb\n", " FROM index\n", " JOIN volume_geometry_index USING (SeriesInstanceUID)\n", " WHERE regularly_spaced_3d_volume = TRUE AND Modality = 'CT'\n", " LIMIT 3\n", - "\"\"\")\n", + "\"\"\"\n", + ")\n", "print(f\"Found {len(series_df)} CT series\")" ] }, @@ -327,18 +335,14 @@ "source": [ "# Create a temporary directory to hold downloaded DICOM files.\n", "data_dir = tempfile.mkdtemp(prefix=\"idc_monai_\")\n", - "series_uids = list(series_df['SeriesInstanceUID'])\n", + "series_uids = list(series_df[\"SeriesInstanceUID\"])\n", "\n", "print(f\"Downloading {len(series_uids)} series...\")\n", "# download_from_selection() accepts a list of SeriesInstanceUIDs and fetches\n", "# all DICOM files for those series from IDC's GCS buckets.\n", "# dirTemplate=\"%SeriesInstanceUID\" puts each series in its own subdirectory —\n", "# required because MONAI's ITKReader reads a directory to reconstruct a 3D volume.\n", - "client.download_from_selection(\n", - " seriesInstanceUID=series_uids,\n", - " downloadDir=data_dir,\n", - " dirTemplate=\"%SeriesInstanceUID\"\n", - ")\n", + "client.download_from_selection(seriesInstanceUID=series_uids, downloadDir=data_dir, dirTemplate=\"%SeriesInstanceUID\")\n", "print(\"Done!\")" ] }, @@ -383,14 +387,15 @@ "source": [ "# Define transforms for CT preprocessing\n", "# Use ITKReader explicitly to load DICOM series from directories\n", - "transforms = Compose([\n", - " LoadImaged(keys=[\"image\"], reader=ITKReader()),\n", - " EnsureChannelFirstd(keys=[\"image\"]),\n", - " Orientationd(keys=[\"image\"], axcodes=\"RAS\"),\n", - " Spacingd(keys=[\"image\"], pixdim=(1.5, 1.5, 2.0)),\n", - " ScaleIntensityRanged(keys=[\"image\"], a_min=-175, a_max=250,\n", - " b_min=0.0, b_max=1.0, clip=True),\n", - "])\n", + "transforms = Compose(\n", + " [\n", + " LoadImaged(keys=[\"image\"], reader=ITKReader()),\n", + " EnsureChannelFirstd(keys=[\"image\"]),\n", + " Orientationd(keys=[\"image\"], axcodes=\"RAS\"),\n", + " Spacingd(keys=[\"image\"], pixdim=(1.5, 1.5, 2.0)),\n", + " ScaleIntensityRanged(keys=[\"image\"], a_min=-175, a_max=250, b_min=0.0, b_max=1.0, clip=True),\n", + " ]\n", + ")\n", "\n", "# Create dataset\n", "data_dicts = [{\"image\": os.path.join(data_dir, uid)} for uid in series_uids]\n", @@ -435,15 +440,14 @@ } ], "source": [ - "\n", - "image = sample['image'][0]\n", + "image = sample[\"image\"][0]\n", "z = image.shape[2] // 2\n", "\n", "plt.figure(figsize=(6, 6))\n", - "plt.imshow(image[:, :, z].T, cmap='gray', origin='lower')\n", - "plt.title(f'CT from IDC (slice {z})')\n", - "plt.axis('off')\n", - "plt.show()\n" + "plt.imshow(image[:, :, z].T, cmap=\"gray\", origin=\"lower\")\n", + "plt.title(f\"CT from IDC (slice {z})\")\n", + "plt.axis(\"off\")\n", + "plt.show()" ] }, { @@ -504,7 +508,8 @@ "# TotalSegmentator is an AI model that auto-segments 100+ anatomical structures.\n", "# The JOIN links each segmentation back to its source CT via segmented_SeriesInstanceUID.\n", "# We sort by image size (ASC) so the demo downloads the smallest available pair.\n", - "paired = client.sql_query(\"\"\"\n", + "paired = client.sql_query(\n", + " \"\"\"\n", " SELECT src.SeriesInstanceUID as image_uid,\n", " seg.SeriesInstanceUID as seg_uid,\n", " src.collection_id, seg.total_segments,\n", @@ -515,7 +520,8 @@ " AND seg.AlgorithmName LIKE '%TotalSegmentator%'\n", " ORDER BY src.series_size_MB ASC\n", " LIMIT 3\n", - "\"\"\")\n", + "\"\"\"\n", + ")\n", "print(\"CT with TotalSegmentator segmentations:\")\n", "print(paired.to_string(index=False))" ] @@ -538,9 +544,9 @@ "\n", "print(\"Downloading image and segmentation pair...\")\n", "client.download_from_selection(\n", - " seriesInstanceUID=[demo_pair['image_uid'], demo_pair['seg_uid']],\n", + " seriesInstanceUID=[demo_pair[\"image_uid\"], demo_pair[\"seg_uid\"]],\n", " downloadDir=seg_dir,\n", - " dirTemplate=\"%SeriesInstanceUID\"\n", + " dirTemplate=\"%SeriesInstanceUID\",\n", ")\n", "print(\"Done!\")" ] @@ -600,7 +606,7 @@ " physical axis i. ITK affine formula:\n", " world_lps = D @ diag(spacing) @ voxel + origin\n", " \"\"\"\n", - " lps_to_ras = np.diag([-1., -1., 1.])\n", + " lps_to_ras = np.diag([-1.0, -1.0, 1.0])\n", " affine = np.eye(4)\n", " affine[:3, :3] = lps_to_ras @ direction @ np.diag(spacing)\n", " affine[:3, 3] = lps_to_ras @ origin\n", @@ -645,20 +651,24 @@ "\n", "\n", "# Load CT with MONAI's ITKReader\n", - "ct_transforms = Compose([\n", - " LoadImaged(keys=[\"image\"], reader=ITKReader()),\n", - " EnsureChannelFirstd(keys=[\"image\"]),\n", - "])\n", + "ct_transforms = Compose(\n", + " [\n", + " LoadImaged(keys=[\"image\"], reader=ITKReader()),\n", + " EnsureChannelFirstd(keys=[\"image\"]),\n", + " ]\n", + ")\n", "\n", "# Load SEG with our custom LoadDicomSegd\n", - "seg_transforms = Compose([\n", - " LoadDicomSegd(keys=[\"label\"]),\n", - " EnsureChannelFirstd(keys=[\"label\"]),\n", - "])\n", + "seg_transforms = Compose(\n", + " [\n", + " LoadDicomSegd(keys=[\"label\"]),\n", + " EnsureChannelFirstd(keys=[\"label\"]),\n", + " ]\n", + ")\n", "\n", "# Load both\n", - "image_path = os.path.join(seg_dir, demo_pair['image_uid'])\n", - "seg_path = os.path.join(seg_dir, demo_pair['seg_uid'])\n", + "image_path = os.path.join(seg_dir, demo_pair[\"image_uid\"])\n", + "seg_path = os.path.join(seg_dir, demo_pair[\"seg_uid\"])\n", "\n", "ct_data = ct_transforms({\"image\": image_path})\n", "seg_data = seg_transforms({\"label\": seg_path})\n", @@ -782,22 +792,24 @@ " modifier_seq = seg.get(\"SegmentedPropertyTypeModifierCodeSequence\", {})\n", " modifier = modifier_seq.get(\"CodeMeaning\", \"\") if modifier_seq else \"\"\n", "\n", - " segments.append({\n", - " \"label_id\": seg.get(\"labelID\", 0),\n", - " \"name\": seg.get(\"SegmentLabel\", \"Unknown\"),\n", - " \"category\": category,\n", - " \"type\": seg_type,\n", - " \"type_code\": f\"{coding_scheme}:{type_code}\" if type_code else \"\",\n", - " \"modifier\": modifier,\n", - " \"color_rgb\": seg.get(\"recommendedDisplayRGBValue\", [128, 128, 128]),\n", - " \"algorithm\": seg.get(\"SegmentAlgorithmName\", \"\"),\n", - " })\n", + " segments.append(\n", + " {\n", + " \"label_id\": seg.get(\"labelID\", 0),\n", + " \"name\": seg.get(\"SegmentLabel\", \"Unknown\"),\n", + " \"category\": category,\n", + " \"type\": seg_type,\n", + " \"type_code\": f\"{coding_scheme}:{type_code}\" if type_code else \"\",\n", + " \"modifier\": modifier,\n", + " \"color_rgb\": seg.get(\"recommendedDisplayRGBValue\", [128, 128, 128]),\n", + " \"algorithm\": seg.get(\"SegmentAlgorithmName\", \"\"),\n", + " }\n", + " )\n", "\n", " return sorted(segments, key=lambda x: x[\"label_id\"])\n", "\n", "\n", "# Extract segment information\n", - "overlay_info = seg_data.get('label_meta_dict', {}).get('overlay_info', {})\n", + "overlay_info = seg_data.get(\"label_meta_dict\", {}).get(\"overlay_info\", {})\n", "segments = get_segment_info(overlay_info)\n", "\n", "print(f\"Found {len(segments)} segments in DICOM SEG:\\n\")\n", @@ -849,9 +861,7 @@ "# Find SEG z-slice at the midpoint of the labeled region\n", "z_slices_with_labels = np.where(seg_np.sum(axis=(0, 1)) > 0)[0]\n", "seg_mid_z = (\n", - " int(z_slices_with_labels[len(z_slices_with_labels) // 2])\n", - " if len(z_slices_with_labels) > 0\n", - " else seg_np.shape[2] // 2\n", + " int(z_slices_with_labels[len(z_slices_with_labels) // 2]) if len(z_slices_with_labels) > 0 else seg_np.shape[2] // 2\n", ")\n", "\n", "# Map SEG midpoint z to CT z via world coordinates\n", @@ -915,7 +925,7 @@ " for seg in all_segments:\n", " label_id = seg.get(\"labelID\", 0)\n", " rgb = seg.get(\"recommendedDisplayRGBValue\", [128, 128, 128])\n", - " colors[label_id] = [rgb[0]/255, rgb[1]/255, rgb[2]/255, 1.0]\n", + " colors[label_id] = [rgb[0] / 255, rgb[1] / 255, rgb[2] / 255, 1.0]\n", "\n", " return ListedColormap(colors)\n", "\n", @@ -928,26 +938,33 @@ "fig, axes = plt.subplots(1, 3, figsize=(15, 5))\n", "\n", "# CT image only\n", - "axes[0].imshow(ct_np[:, :, z_mid].T, cmap='gray', origin='lower', vmin=-1000, vmax=500)\n", - "axes[0].set_title(f'CT Image (RAS, z={z_mid})')\n", - "axes[0].axis('off')\n", + "axes[0].imshow(ct_np[:, :, z_mid].T, cmap=\"gray\", origin=\"lower\", vmin=-1000, vmax=500)\n", + "axes[0].set_title(f\"CT Image (RAS, z={z_mid})\")\n", + "axes[0].axis(\"off\")\n", "\n", "# Segmentation only (using DICOM SEG colors)\n", - "axes[1].imshow(seg_np[:, :, seg_mid_z].T, cmap=seg_cmap, origin='lower',\n", - " vmin=0, vmax=len(seg_cmap.colors)-1, interpolation='nearest')\n", - "axes[1].set_title(f'Segmentation (RAS, z={seg_mid_z})\\n({int(seg_np.max())} labels, DICOM SEG colors)')\n", - "axes[1].axis('off')\n", + "axes[1].imshow(\n", + " seg_np[:, :, seg_mid_z].T,\n", + " cmap=seg_cmap,\n", + " origin=\"lower\",\n", + " vmin=0,\n", + " vmax=len(seg_cmap.colors) - 1,\n", + " interpolation=\"nearest\",\n", + ")\n", + "axes[1].set_title(f\"Segmentation (RAS, z={seg_mid_z})\\n({int(seg_np.max())} labels, DICOM SEG colors)\")\n", + "axes[1].axis(\"off\")\n", "\n", "# Overlay — both arrays are in RAS, z-slices matched via world coordinates\n", - "axes[2].imshow(ct_np[:, :, z_mid].T, cmap='gray', origin='lower', vmin=-1000, vmax=500)\n", + "axes[2].imshow(ct_np[:, :, z_mid].T, cmap=\"gray\", origin=\"lower\", vmin=-1000, vmax=500)\n", "seg_slice = seg_np[:, :, seg_mid_z]\n", "mask = np.ma.masked_where(seg_slice == 0, seg_slice)\n", - "axes[2].imshow(mask.T, cmap=seg_cmap, alpha=0.6, origin='lower',\n", - " vmin=0, vmax=len(seg_cmap.colors)-1, interpolation='nearest')\n", - "axes[2].set_title('Overlay (RAS)\\n(DICOM SEG colors)')\n", - "axes[2].axis('off')\n", + "axes[2].imshow(\n", + " mask.T, cmap=seg_cmap, alpha=0.6, origin=\"lower\", vmin=0, vmax=len(seg_cmap.colors) - 1, interpolation=\"nearest\"\n", + ")\n", + "axes[2].set_title(\"Overlay (RAS)\\n(DICOM SEG colors)\")\n", + "axes[2].axis(\"off\")\n", "\n", - "plt.suptitle('CT + TotalSegmentator Segmentation', fontsize=14)\n", + "plt.suptitle(\"CT + TotalSegmentator Segmentation\", fontsize=14)\n", "plt.tight_layout()\n", "plt.show()\n", "\n", @@ -994,11 +1011,13 @@ "source": [ "# Always check licenses before use\n", "uid_list = \", \".join(f\"'{uid}'\" for uid in series_uids)\n", - "licenses = client.sql_query(f\"\"\"\n", + "licenses = client.sql_query(\n", + " f\"\"\"\n", " SELECT license_short_name, COUNT(*) as count\n", " FROM index WHERE SeriesInstanceUID IN ({uid_list})\n", " GROUP BY license_short_name\n", - "\"\"\")\n", + "\"\"\"\n", + ")\n", "print(\"Licenses:\")\n", "print(licenses.to_string(index=False))" ] From 4b01df9e5ddec509cfaba5f7eecfab063971e583 Mon Sep 17 00:00:00 2001 From: Andrey Fedorov Date: Fri, 1 May 2026 18:34:56 -0400 Subject: [PATCH 3/8] bug: fix function name Signed-off-by: Andrey Fedorov --- modules/idc_dataset.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/idc_dataset.ipynb b/modules/idc_dataset.ipynb index 88144ad77..4782d0692 100644 --- a/modules/idc_dataset.ipynb +++ b/modules/idc_dataset.ipynb @@ -215,7 +215,7 @@ "# 'collections_index' is an optional table with one row per IDC collection.\n", "# It adds collection-level metadata not in the per-series 'index' t able,\n", "# such as CancerTypes, Subjects count, and collection descriptions.\n", - "client.fetch_index_table(\"collections_index\")\n", + "client.fetch_index(\"collections_index\")\n", "\n", "# Join collections_index with the per-series index to filter by both cancer type and modality.\n", "# The 'index' table has Modality per series; collections_index has CancerTypes per collection.\n", From c5d0658b1ec882190744e903bd3da99787fe9326 Mon Sep 17 00:00:00 2001 From: Andrey Fedorov Date: Fri, 1 May 2026 18:52:27 -0400 Subject: [PATCH 4/8] fix: bring idc_dataset notebook into compliance with contribution guidelines - Fix license header: use MONAI Consortium copyright, correct format with trailing double spaces and   indentation, moved to top of first cell - Move all imports (os, sys, itkwasm_dicom) into Setup imports cell; simplify Setup environment cell to pip install only - Add README.md entry for idc_dataset under Modules section - Add idc_dataset to doesnt_contain_max_epochs and skip_run_papermill in runner.sh Co-Authored-By: Claude Sonnet 4.6 Signed-off-by: Andrey Fedorov --- README.md | 4 +- modules/idc_dataset.ipynb | 214 ++------------------------------------ runner.sh | 2 + 3 files changed, 11 insertions(+), 209 deletions(-) diff --git a/README.md b/README.md index 48ebb87e9..ff7a0e881 100644 --- a/README.md +++ b/README.md @@ -331,6 +331,8 @@ Illustrate reading NIfTI files and iterating over image patches of the volumes l This tutorial illustrates the flexible network APIs and utilities. ##### [postprocessing_transforms](./modules/postprocessing_transforms.ipynb) This notebook shows the usage of several postprocessing transforms based on the model output of spleen segmentation task. +##### [idc_dataset](./modules/idc_dataset.ipynb) +This notebook shows how to query and download public cancer imaging data from NCI Imaging Data Commons (IDC) using `idc-index`, and how to load DICOM images and DICOM-SEG segmentations into MONAI for AI/ML preprocessing. ##### [public_datasets](./modules/public_datasets.ipynb) This notebook shows how to quickly set up training workflow based on `MedNISTDataset` and `DecathlonDataset`, and how to create a new dataset. ##### [tcia_csv_processing](./modules/tcia_csv_processing.ipynb) @@ -386,4 +388,4 @@ Example shows the use cases of using MONAI to evaluate the performance of a gene #### [VISTA2D](./vista_2d) This tutorial demonstrates how to train a cell segmentation model using the [MONAI](https://monai.io/) framework and the [Segment Anything Model (SAM)](https://github.com/facebookresearch/segment-anything) on the [Cellpose dataset](https://www.cellpose.org/). -ECHO°¡ ¼³Á¤µÇ¾î ÀÖ½À´Ï´Ù. +ECHO�� �����Ǿ� �ֽ��ϴ�. diff --git a/modules/idc_dataset.ipynb b/modules/idc_dataset.ipynb index 4782d0692..da84fdcbb 100644 --- a/modules/idc_dataset.ipynb +++ b/modules/idc_dataset.ipynb @@ -5,58 +5,14 @@ "metadata": { "id": "eFLP44iEFCpB" }, - "source": [ - "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/ImagingDataCommons/idc-monai/blob/main/monai_contribution/idc_dataset.ipynb)\n", - "\n", - "# Using NCI Imaging Data Commons with MONAI\n", - "\n", - "Copyright 2026 Imaging Data Commons\n", - "\n", - "Licensed under the Apache License, Version 2.0 (the \"License\");\n", - "you may not use this file except in compliance with the License.\n", - "You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0\n", - "\n", - "---\n", - "\n", - "## What is IDC?\n", - "\n", - "[NCI Imaging Data Commons (IDC)](https://portal.imaging.datacommons.cancer.gov/) is a free, cloud-hosted repository of publicly available cancer imaging data maintained by the National Cancer Institute (NCI). It provides:\n", - "\n", - "- **~100 TB** of radiology (CT, MR, PET) and pathology images across 160+ cancer collections\n", - "- **No sign-up or authentication required** — data is openly accessible\n", - "- **Expert and AI-generated annotations** (e.g., organ segmentations) paired with images\n", - "- **Standardized format** — all data uses DICOM, the medical imaging industry standard\n", - "- **Cloud-native storage** — data lives in Google Cloud Storage (GCS) buckets, so downloads are fast\n", - "- **Accompanying tools** - you can search, visualize, and subset the data\n", - "\n", - "## What is `idc-index`?\n", - "\n", - "[`idc-index`](https://github.com/ImagingDataCommons/idc-index) is a lightweight Python package that lets you search and download IDC data without any cloud account or special credentials. It ships with a local metadata index — a set of DuckDB tables describing every image series in IDC — so you can run SQL queries locally to find exactly the data you need before downloading anything.\n", - "\n", - "## What this tutorial covers\n", - "\n", - "This tutorial shows how to:\n", - "1. Query IDC metadata with SQL to find cancer imaging data\n", - "2. Download DICOM images and segmentations with one function call\n", - "3. Load the data into MONAI for AI/ML preprocessing\n", - "4. Work with DICOM Segmentation (DICOM-SEG) objects and their rich metadata\n", - "\n", - "> **Tip**: This tutorial was created using [idc-claude-skill](https://github.com/ImagingDataCommons/idc-claude-skill) — an AI assistant skill for navigating IDC data and the `idc-index` API." - ] + "source": "Copyright (c) MONAI Consortium \nLicensed under the Apache License, Version 2.0 (the \"License\"); \nyou may not use this file except in compliance with the License. \nYou may obtain a copy of the License at \n    http://www.apache.org/licenses/LICENSE-2.0 \nUnless required by applicable law or agreed to in writing, software \ndistributed under the License is distributed on an \"AS IS\" BASIS, \nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. \nSee the License for the specific language governing permissions and \nlimitations under the License.\n\n[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/ImagingDataCommons/idc-monai/blob/main/monai_contribution/idc_dataset.ipynb)\n\n# Using NCI Imaging Data Commons with MONAI\n\n## What is IDC?\n\n[NCI Imaging Data Commons (IDC)](https://portal.imaging.datacommons.cancer.gov/) is a free, cloud-hosted repository of publicly available cancer imaging data maintained by the National Cancer Institute (NCI). It provides:\n\n- **~100 TB** of radiology (CT, MR, PET) and pathology images across 160+ cancer collections\n- **No sign-up or authentication required** — data is openly accessible\n- **Expert and AI-generated annotations** (e.g., organ segmentations) paired with images\n- **Standardized format** — all data uses DICOM, the medical imaging industry standard\n- **Cloud-native storage** — data lives in Google Cloud Storage (GCS) buckets, so downloads are fast\n- **Accompanying tools** - you can search, visualize, and subset the data\n\n## What is `idc-index`?\n\n[`idc-index`](https://github.com/ImagingDataCommons/idc-index) is a lightweight Python package that lets you search and download IDC data without any cloud account or special credentials. It ships with a local metadata index — a set of DuckDB tables describing every image series in IDC — so you can run SQL queries locally to find exactly the data you need before downloading anything.\n\n## What this tutorial covers\n\nThis tutorial shows how to:\n1. Query IDC metadata with SQL to find cancer imaging data\n2. Download DICOM images and segmentations with one function call\n3. Load the data into MONAI for AI/ML preprocessing\n4. Work with DICOM Segmentation (DICOM-SEG) objects and their rich metadata\n\n> **Tip**: This tutorial was created using [idc-claude-skill](https://github.com/ImagingDataCommons/idc-claude-skill) — an AI assistant skill for navigating IDC data and the `idc-index` API." }, { "cell_type": "markdown", "metadata": { "id": "iudwt5GoFCpC" }, - "source": [ - "## Setup\n", - "\n", - "Install required packages:\n", - "- `monai` — Medical Open Network for AI, the ML framework used here\n", - "- `idc-index` — Query and download IDC data (includes local metadata index)\n", - "- `itk` / `itkwasm-dicom` — ITK-based DICOM readers used by MONAI's `ITKReader` and our custom DICOM-SEG loader" - ] + "source": "## Setup environment\n\nInstall required packages:\n- `monai` — Medical Open Network for AI, the ML framework used here\n- `idc-index` — Query and download IDC data (includes local metadata index)\n- `itk` / `itkwasm-dicom` — ITK-based DICOM readers used by MONAI's `ITKReader` and our custom DICOM-SEG loader\n\n> **Colab users**: After running the cell below, restart the runtime before continuing (Runtime → Restart runtime). ITK requires a fresh runtime to load correctly after installation." }, { "cell_type": "code", @@ -65,21 +21,7 @@ "id": "T4ujv4U7FCpC" }, "outputs": [], - "source": [ - "!pip install -q monai idc-index itk itkwasm-dicom\n", - "\n", - "# Restart runtime after installing ITK (required for ITK to load properly)\n", - "import sys\n", - "\n", - "if \"google.colab\" in sys.modules:\n", - " try:\n", - " import itk # noqa: F401\n", - " except ImportError:\n", - " print(\"Restarting runtime to load ITK...\")\n", - " import os\n", - "\n", - " os.kill(os.getpid(), 9)" - ] + "source": "!pip install -q monai idc-index itk itkwasm-dicom" }, { "cell_type": "markdown", @@ -101,34 +43,7 @@ "outputId": "f63082ca-81d8-4b02-8de0-662710f6e508" }, "outputs": [], - "source": [ - "import os\n", - "import tempfile\n", - "from pathlib import Path\n", - "from typing import Hashable, Mapping\n", - "\n", - "import torch\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "from matplotlib.colors import ListedColormap\n", - "from idc_index import IDCClient\n", - "\n", - "from monai.config import KeysCollection\n", - "from monai.transforms import (\n", - " Compose,\n", - " LoadImaged,\n", - " EnsureChannelFirstd,\n", - " Orientationd,\n", - " Spacingd,\n", - " ScaleIntensityRanged,\n", - " MapTransform,\n", - ")\n", - "from monai.data import Dataset, MetaTensor\n", - "from monai.data.image_reader import ITKReader\n", - "import monai\n", - "\n", - "monai.config.print_config()" - ] + "source": "import os\nimport sys\nimport tempfile\nfrom pathlib import Path\nfrom typing import Hashable, Mapping\n\nimport itkwasm_dicom\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport torch\nfrom idc_index import IDCClient\nfrom matplotlib.colors import ListedColormap\n\nimport monai\nfrom monai.config import KeysCollection\nfrom monai.data import Dataset, MetaTensor\nfrom monai.data.image_reader import ITKReader\nfrom monai.transforms import (\n Compose,\n EnsureChannelFirstd,\n LoadImaged,\n MapTransform,\n Orientationd,\n ScaleIntensityRanged,\n Spacingd,\n)\n\nmonai.config.print_config()" }, { "cell_type": "markdown", @@ -562,124 +477,7 @@ "outputId": "386c615d-5349-49fb-f412-7a92cfc421d9" }, "outputs": [], - "source": [ - "import itkwasm_dicom # noqa: E402\n", - "\n", - "\n", - "class LoadDicomSegd(MapTransform):\n", - " \"\"\"Load DICOM Segmentation (DICOM-SEG) files using ITKWasm.\n", - "\n", - " DICOM-SEG is an enhanced multiframe DICOM format that stores segmentation\n", - " masks with segment metadata including recommended display colors.\n", - "\n", - " The affine matrix is derived directly from DICOM metadata (direction cosines,\n", - " spacing, origin) with LPS→RAS conversion applied to match MONAI's ITKReader\n", - " convention. No axis flipping is performed — orientation is fully encoded in\n", - " the affine via the direction cosine matrix.\n", - " \"\"\"\n", - "\n", - " def __init__(self, keys: KeysCollection, allow_missing_keys: bool = False):\n", - " super().__init__(keys, allow_missing_keys)\n", - "\n", - " def _find_dcm_file(self, path: Path) -> Path:\n", - " \"\"\"Find .dcm file in directory or return path if already a file.\"\"\"\n", - " if path.is_file():\n", - " return path\n", - " dcm_files = list(path.glob(\"*.dcm\"))\n", - " if not dcm_files:\n", - " raise FileNotFoundError(f\"No .dcm files found in {path}\")\n", - " return dcm_files[0]\n", - "\n", - " def _build_affine(self, spacing, origin, direction) -> np.ndarray:\n", - " \"\"\"Build 4x4 affine matrix from DICOM spatial metadata.\n", - "\n", - " Converts from ITK/DICOM LPS convention to MONAI's RAS-like convention\n", - " by negating X and Y world coordinates (LPS→RAS). No axis flips are\n", - " applied — orientation is fully encoded in the affine via the direction\n", - " cosine matrix.\n", - "\n", - " Args:\n", - " spacing: Voxel spacing (X, Y, Z) as returned by itkwasm\n", - " origin: Physical coordinates of voxel [0,0,0] in LPS\n", - " direction: 3x3 direction cosine matrix D where D[i,j] is the\n", - " component of voxel-axis-j's unit vector along LPS\n", - " physical axis i. ITK affine formula:\n", - " world_lps = D @ diag(spacing) @ voxel + origin\n", - " \"\"\"\n", - " lps_to_ras = np.diag([-1.0, -1.0, 1.0])\n", - " affine = np.eye(4)\n", - " affine[:3, :3] = lps_to_ras @ direction @ np.diag(spacing)\n", - " affine[:3, 3] = lps_to_ras @ origin\n", - " return affine\n", - "\n", - " def __call__(self, data: Mapping[Hashable, any]) -> dict[Hashable, any]:\n", - " d = dict(data)\n", - " for key in self.key_iterator(d):\n", - " path = Path(d[key])\n", - " dcm_file = self._find_dcm_file(path)\n", - "\n", - " # Read using ITKWasm\n", - " seg_image, overlay_info = itkwasm_dicom.read_segmentation(dcm_file)\n", - "\n", - " # ITKWasm returns array in (Z, Y, X) order but metadata in (X, Y, Z) order.\n", - " # Transpose to (X, Y, Z) to match metadata — this is a layout convention,\n", - " # not an orientation flip.\n", - " seg_array = np.asarray(seg_image.data).copy()\n", - " seg_array = np.transpose(seg_array, (2, 1, 0))\n", - "\n", - " # Build affine from spatial metadata\n", - " spacing = np.array(seg_image.spacing)\n", - " origin = np.array(seg_image.origin)\n", - " direction = np.array(seg_image.direction).reshape(3, 3)\n", - "\n", - " affine = self._build_affine(spacing, origin, direction)\n", - "\n", - " # Make contiguous (array may be non-contiguous after transpose)\n", - " seg_array = np.ascontiguousarray(seg_array)\n", - "\n", - " # Create MONAI MetaTensor with metadata\n", - " meta_tensor = MetaTensor(seg_array)\n", - " meta_tensor.affine = affine\n", - " meta_tensor.meta[\"filename_or_obj\"] = str(dcm_file)\n", - " meta_tensor.meta[\"overlay_info\"] = overlay_info\n", - " meta_tensor.meta[\"original_channel_dim\"] = \"no_channel\"\n", - "\n", - " d[key] = meta_tensor\n", - " d[f\"{key}_meta_dict\"] = dict(meta_tensor.meta)\n", - "\n", - " return d\n", - "\n", - "\n", - "# Load CT with MONAI's ITKReader\n", - "ct_transforms = Compose(\n", - " [\n", - " LoadImaged(keys=[\"image\"], reader=ITKReader()),\n", - " EnsureChannelFirstd(keys=[\"image\"]),\n", - " ]\n", - ")\n", - "\n", - "# Load SEG with our custom LoadDicomSegd\n", - "seg_transforms = Compose(\n", - " [\n", - " LoadDicomSegd(keys=[\"label\"]),\n", - " EnsureChannelFirstd(keys=[\"label\"]),\n", - " ]\n", - ")\n", - "\n", - "# Load both\n", - "image_path = os.path.join(seg_dir, demo_pair[\"image_uid\"])\n", - "seg_path = os.path.join(seg_dir, demo_pair[\"seg_uid\"])\n", - "\n", - "ct_data = ct_transforms({\"image\": image_path})\n", - "seg_data = seg_transforms({\"label\": seg_path})\n", - "\n", - "ct_image = ct_data[\"image\"]\n", - "seg_label = seg_data[\"label\"]\n", - "\n", - "print(f\"CT image shape: {ct_image.shape}\")\n", - "print(f\"Segmentation shape: {seg_label.shape}\")\n", - "print(f\"Unique labels: {torch.unique(seg_label)[:10].tolist()}...\") # First 10 labels" - ] + "source": "class LoadDicomSegd(MapTransform):\n \"\"\"Load DICOM Segmentation (DICOM-SEG) files using ITKWasm.\n\n DICOM-SEG is an enhanced multiframe DICOM format that stores segmentation\n masks with segment metadata including recommended display colors.\n\n The affine matrix is derived directly from DICOM metadata (direction cosines,\n spacing, origin) with LPS→RAS conversion applied to match MONAI's ITKReader\n convention. No axis flipping is performed — orientation is fully encoded in\n the affine via the direction cosine matrix.\n \"\"\"\n\n def __init__(self, keys: KeysCollection, allow_missing_keys: bool = False):\n super().__init__(keys, allow_missing_keys)\n\n def _find_dcm_file(self, path: Path) -> Path:\n \"\"\"Find .dcm file in directory or return path if already a file.\"\"\"\n if path.is_file():\n return path\n dcm_files = list(path.glob(\"*.dcm\"))\n if not dcm_files:\n raise FileNotFoundError(f\"No .dcm files found in {path}\")\n return dcm_files[0]\n\n def _build_affine(self, spacing, origin, direction) -> np.ndarray:\n \"\"\"Build 4x4 affine matrix from DICOM spatial metadata.\n\n Converts from ITK/DICOM LPS convention to MONAI's RAS-like convention\n by negating X and Y world coordinates (LPS→RAS). No axis flips are\n applied — orientation is fully encoded in the affine via the direction\n cosine matrix.\n\n Args:\n spacing: Voxel spacing (X, Y, Z) as returned by itkwasm\n origin: Physical coordinates of voxel [0,0,0] in LPS\n direction: 3x3 direction cosine matrix D where D[i,j] is the\n component of voxel-axis-j's unit vector along LPS\n physical axis i. ITK affine formula:\n world_lps = D @ diag(spacing) @ voxel + origin\n \"\"\"\n lps_to_ras = np.diag([-1.0, -1.0, 1.0])\n affine = np.eye(4)\n affine[:3, :3] = lps_to_ras @ direction @ np.diag(spacing)\n affine[:3, 3] = lps_to_ras @ origin\n return affine\n\n def __call__(self, data: Mapping[Hashable, any]) -> dict[Hashable, any]:\n d = dict(data)\n for key in self.key_iterator(d):\n path = Path(d[key])\n dcm_file = self._find_dcm_file(path)\n\n # Read using ITKWasm\n seg_image, overlay_info = itkwasm_dicom.read_segmentation(dcm_file)\n\n # ITKWasm returns array in (Z, Y, X) order but metadata in (X, Y, Z) order.\n # Transpose to (X, Y, Z) to match metadata — this is a layout convention,\n # not an orientation flip.\n seg_array = np.asarray(seg_image.data).copy()\n seg_array = np.transpose(seg_array, (2, 1, 0))\n\n # Build affine from spatial metadata\n spacing = np.array(seg_image.spacing)\n origin = np.array(seg_image.origin)\n direction = np.array(seg_image.direction).reshape(3, 3)\n\n affine = self._build_affine(spacing, origin, direction)\n\n # Make contiguous (array may be non-contiguous after transpose)\n seg_array = np.ascontiguousarray(seg_array)\n\n # Create MONAI MetaTensor with metadata\n meta_tensor = MetaTensor(seg_array)\n meta_tensor.affine = affine\n meta_tensor.meta[\"filename_or_obj\"] = str(dcm_file)\n meta_tensor.meta[\"overlay_info\"] = overlay_info\n meta_tensor.meta[\"original_channel_dim\"] = \"no_channel\"\n\n d[key] = meta_tensor\n d[f\"{key}_meta_dict\"] = dict(meta_tensor.meta)\n\n return d\n\n\n# Load CT with MONAI's ITKReader\nct_transforms = Compose(\n [\n LoadImaged(keys=[\"image\"], reader=ITKReader()),\n EnsureChannelFirstd(keys=[\"image\"]),\n ]\n)\n\n# Load SEG with our custom LoadDicomSegd\nseg_transforms = Compose(\n [\n LoadDicomSegd(keys=[\"label\"]),\n EnsureChannelFirstd(keys=[\"label\"]),\n ]\n)\n\n# Load both\nimage_path = os.path.join(seg_dir, demo_pair[\"image_uid\"])\nseg_path = os.path.join(seg_dir, demo_pair[\"seg_uid\"])\n\nct_data = ct_transforms({\"image\": image_path})\nseg_data = seg_transforms({\"label\": seg_path})\n\nct_image = ct_data[\"image\"]\nseg_label = seg_data[\"label\"]\n\nprint(f\"CT image shape: {ct_image.shape}\")\nprint(f\"Segmentation shape: {seg_label.shape}\")\nprint(f\"Unique labels: {torch.unique(seg_label)[:10].tolist()}...\") # First 10 labels" }, { "cell_type": "code", @@ -1110,4 +908,4 @@ }, "nbformat": 4, "nbformat_minor": 0 -} +} \ No newline at end of file diff --git a/runner.sh b/runner.sh index 3f5473f03..3296299fd 100755 --- a/runner.sh +++ b/runner.sh @@ -50,6 +50,7 @@ doesnt_contain_max_epochs=("${doesnt_contain_max_epochs[@]}" 2d_slices_from_3d_t doesnt_contain_max_epochs=("${doesnt_contain_max_epochs[@]}" preprocess_to_build_detection_dataset.ipynb) doesnt_contain_max_epochs=("${doesnt_contain_max_epochs[@]}" preprocess_detect_scene_and_split_fold.ipynb) doesnt_contain_max_epochs=("${doesnt_contain_max_epochs[@]}" preprocess_extract_images_from_video.ipynb) +doesnt_contain_max_epochs=("${doesnt_contain_max_epochs[@]}" idc_dataset.ipynb) doesnt_contain_max_epochs=("${doesnt_contain_max_epochs[@]}" profiling_camelyon_pipeline.ipynb) doesnt_contain_max_epochs=("${doesnt_contain_max_epochs[@]}" monailabel_HelloWorld_radiology_3dslicer.ipynb) doesnt_contain_max_epochs=("${doesnt_contain_max_epochs[@]}" monailabel_monaibundle_3dslicer_multiorgan_seg.ipynb) @@ -97,6 +98,7 @@ skip_run_papermill=("${skip_run_papermill[@]}" .*generate_random_permutations*) skip_run_papermill=("${skip_run_papermill[@]}" .*transforms_update_meta_data*) skip_run_papermill=("${skip_run_papermill[@]}" .*video_seg*) skip_run_papermill=("${skip_run_papermill[@]}" .*tcia_dataset*) +skip_run_papermill=("${skip_run_papermill[@]}" .*idc_dataset*) skip_run_papermill=("${skip_run_papermill[@]}" .*hovernet_torch*) skip_run_papermill=("${skip_run_papermill[@]}" .*preprocess_detect_scene_and_split_fold*) skip_run_papermill=("${skip_run_papermill[@]}" .*preprocess_to_build_detection_dataset*) From 787ea3e9b7b28bd47e27fce6bb6dac094cd38e10 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 1 May 2026 22:53:23 +0000 Subject: [PATCH 5/8] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- modules/idc_dataset.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/idc_dataset.ipynb b/modules/idc_dataset.ipynb index da84fdcbb..233b92e14 100644 --- a/modules/idc_dataset.ipynb +++ b/modules/idc_dataset.ipynb @@ -908,4 +908,4 @@ }, "nbformat": 4, "nbformat_minor": 0 -} \ No newline at end of file +} From bd4b8b7da04e10e7228b992c960e9b9f6dea676c Mon Sep 17 00:00:00 2001 From: Andrey Fedorov Date: Sat, 2 May 2026 13:35:16 -0400 Subject: [PATCH 6/8] bug: remove unused sys import Signed-off-by: Andrey Fedorov --- modules/idc_dataset.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/idc_dataset.ipynb b/modules/idc_dataset.ipynb index 233b92e14..d5e7bb8f8 100644 --- a/modules/idc_dataset.ipynb +++ b/modules/idc_dataset.ipynb @@ -43,7 +43,7 @@ "outputId": "f63082ca-81d8-4b02-8de0-662710f6e508" }, "outputs": [], - "source": "import os\nimport sys\nimport tempfile\nfrom pathlib import Path\nfrom typing import Hashable, Mapping\n\nimport itkwasm_dicom\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport torch\nfrom idc_index import IDCClient\nfrom matplotlib.colors import ListedColormap\n\nimport monai\nfrom monai.config import KeysCollection\nfrom monai.data import Dataset, MetaTensor\nfrom monai.data.image_reader import ITKReader\nfrom monai.transforms import (\n Compose,\n EnsureChannelFirstd,\n LoadImaged,\n MapTransform,\n Orientationd,\n ScaleIntensityRanged,\n Spacingd,\n)\n\nmonai.config.print_config()" + "source": "import os\nimport tempfile\nfrom pathlib import Path\nfrom typing import Hashable, Mapping\n\nimport itkwasm_dicom\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport torch\nfrom idc_index import IDCClient\nfrom matplotlib.colors import ListedColormap\n\nimport monai\nfrom monai.config import KeysCollection\nfrom monai.data import Dataset, MetaTensor\nfrom monai.data.image_reader import ITKReader\nfrom monai.transforms import (\n Compose,\n EnsureChannelFirstd,\n LoadImaged,\n MapTransform,\n Orientationd,\n ScaleIntensityRanged,\n Spacingd,\n)\n\nmonai.config.print_config()" }, { "cell_type": "markdown", From 92cf83dbe20f6bd06a086cd7996973dab64921e5 Mon Sep 17 00:00:00 2001 From: Andrey Fedorov Date: Sat, 2 May 2026 13:39:06 -0400 Subject: [PATCH 7/8] bug: remove garbled text Signed-off-by: Andrey Fedorov --- README.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/README.md b/README.md index ff7a0e881..3d296df00 100644 --- a/README.md +++ b/README.md @@ -387,5 +387,4 @@ Example shows the use cases of how to use MONAI for 2D segmentation of images us Example shows the use cases of using MONAI to evaluate the performance of a generative model by computing metrics such as Frechet Inception Distance (FID) and Maximum Mean Discrepancy (MMD) for assessing realism, as well as MS-SSIM and SSIM for evaluating image diversity. #### [VISTA2D](./vista_2d) -This tutorial demonstrates how to train a cell segmentation model using the [MONAI](https://monai.io/) framework and the [Segment Anything Model (SAM)](https://github.com/facebookresearch/segment-anything) on the [Cellpose dataset](https://www.cellpose.org/). -ECHO�� �����Ǿ� �ֽ��ϴ�. +This tutorial demonstrates how to train a cell segmentation model using the [MONAI](https://monai.io/) framework and the [Segment Anything Model (SAM)](https://github.com/facebookresearch/segment-anything) on the [Cellpose dataset](https://www.cellpose.org/). \ No newline at end of file From 9113b0148e73b67650ce54813f417d2c410abd63 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Sat, 2 May 2026 17:40:18 +0000 Subject: [PATCH 8/8] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 3d296df00..8aa1d61ab 100644 --- a/README.md +++ b/README.md @@ -387,4 +387,4 @@ Example shows the use cases of how to use MONAI for 2D segmentation of images us Example shows the use cases of using MONAI to evaluate the performance of a generative model by computing metrics such as Frechet Inception Distance (FID) and Maximum Mean Discrepancy (MMD) for assessing realism, as well as MS-SSIM and SSIM for evaluating image diversity. #### [VISTA2D](./vista_2d) -This tutorial demonstrates how to train a cell segmentation model using the [MONAI](https://monai.io/) framework and the [Segment Anything Model (SAM)](https://github.com/facebookresearch/segment-anything) on the [Cellpose dataset](https://www.cellpose.org/). \ No newline at end of file +This tutorial demonstrates how to train a cell segmentation model using the [MONAI](https://monai.io/) framework and the [Segment Anything Model (SAM)](https://github.com/facebookresearch/segment-anything) on the [Cellpose dataset](https://www.cellpose.org/).