diff --git a/README.md b/README.md index 48ebb87e9..8aa1d61ab 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,3 @@ 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°¡ ¼³Á¤µÇ¾î ÀÖ½À´Ï´Ù. diff --git a/modules/idc_dataset.ipynb b/modules/idc_dataset.ipynb new file mode 100644 index 000000000..d5e7bb8f8 --- /dev/null +++ b/modules/idc_dataset.ipynb @@ -0,0 +1,911 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "eFLP44iEFCpB" + }, + "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 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", + "execution_count": null, + "metadata": { + "id": "T4ujv4U7FCpC" + }, + "outputs": [], + "source": "!pip install -q monai idc-index itk itkwasm-dicom" + }, + { + "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\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", + "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", + " \"\"\"\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", + "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(\"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", + " \"\"\"\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", + ")\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", + " \"\"\"\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", + "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(seriesInstanceUID=series_uids, downloadDir=data_dir, dirTemplate=\"%SeriesInstanceUID\")\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", + " [\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", + "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": [ + "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()" + ] + }, + { + "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", + " \"\"\"\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", + ")\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": "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", + "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", + " {\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", + "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]) 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", + "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(\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", + "seg_slice = seg_np[:, :, seg_mid_z]\n", + "mask = np.ma.masked_where(seg_slice == 0, seg_slice)\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.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(\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", + "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 +} 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*)