diff --git a/panoptica/brats_mets_data/prediction.nii.gz b/panoptica/brats_mets_data/prediction.nii.gz new file mode 100644 index 0000000..246705a Binary files /dev/null and b/panoptica/brats_mets_data/prediction.nii.gz differ diff --git a/panoptica/brats_mets_data/reference.nii.gz b/panoptica/brats_mets_data/reference.nii.gz new file mode 100644 index 0000000..9eef997 Binary files /dev/null and b/panoptica/brats_mets_data/reference.nii.gz differ diff --git a/panoptica/example_brats_mets.ipynb b/panoptica/example_brats_mets.ipynb new file mode 100644 index 0000000..6afbe94 --- /dev/null +++ b/panoptica/example_brats_mets.ipynb @@ -0,0 +1,767 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "352f748f", + "metadata": {}, + "source": [ + "# Panoptica Tutorial: BraTS Metastasis Segmentation — Standard PQ & Part PQ\n", + "\n", + "This tutorial demonstrates how to use **Panoptica** to evaluate brain metastasis segmentation using data from the BraTS-Mets 2025 challenge.\n", + "\n", + "You will learn how to:\n", + "1. Perform per-region **Standard Panoptic Quality (PQ)** evaluation on the three BraTS sub-regions.\n", + "2. Use **Part Panoptic Quality** to evaluate hierarchical tumor structure (thing + parts).\n", + "3. Compare both approaches and interpret the results." + ] + }, + { + "cell_type": "markdown", + "id": "c21c7912", + "metadata": {}, + "source": [ + "## 1. Setup & Installation" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "3efa3456", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-04T11:18:53.808634Z", + "iopub.status.busy": "2026-05-04T11:18:53.808546Z", + "iopub.status.idle": "2026-05-04T11:18:54.774960Z", + "shell.execute_reply": "2026-05-04T11:18:54.774339Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33mWARNING: Ignoring invalid distribution -nknown (/home/localssk23/.local/lib/python3.10/site-packages)\u001b[0m\u001b[33m\r\n", + "\u001b[0m" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33mWARNING: Ignoring invalid distribution -nknown (/home/localssk23/.local/lib/python3.10/site-packages)\u001b[0m\u001b[33m\r\n", + "\u001b[0m" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33mWARNING: Ignoring invalid distribution -nknown (/home/localssk23/.local/lib/python3.10/site-packages)\u001b[0m\u001b[33m\r\n", + "\u001b[0m\u001b[33mWARNING: Ignoring invalid distribution -nknown (/home/localssk23/.local/lib/python3.10/site-packages)\u001b[0m\u001b[33m\r\n", + "\u001b[0m\r\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m26.0.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m26.1\u001b[0m\r\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpython3 -m pip install --upgrade pip\u001b[0m\r\n" + ] + } + ], + "source": [ + "!pip install panoptica auxiliary nibabel matplotlib numpy rich > /dev/null" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e4f80c32", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-04T11:18:54.776617Z", + "iopub.status.busy": "2026-05-04T11:18:54.776462Z", + "iopub.status.idle": "2026-05-04T11:18:54.779888Z", + "shell.execute_reply": "2026-05-04T11:18:54.779349Z" + } + }, + "outputs": [], + "source": [ + "import sys\n", + "\n", + "try:\n", + " import google.colab\n", + "\n", + " colabFlag = True\n", + "except ImportError:\n", + " colabFlag = False\n", + "\n", + "if colabFlag:\n", + " from google.colab import drive\n", + "\n", + " drive.mount(\"/content/drive\")\n", + " !git clone https://github.com/BrainLesion/tutorials.git /content/drive/MyDrive/tutorials\n", + " BASE_PATH = \"/content/drive/MyDrive/tutorials/panoptica\"\n", + " sys.path.insert(0, BASE_PATH)\n", + "else:\n", + " BASE_PATH = \".\"" + ] + }, + { + "cell_type": "markdown", + "id": "6c432595", + "metadata": {}, + "source": [ + "## 2. Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8b979060", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-04T11:18:54.780975Z", + "iopub.status.busy": "2026-05-04T11:18:54.780890Z", + "iopub.status.idle": "2026-05-04T11:18:56.446331Z", + "shell.execute_reply": "2026-05-04T11:18:56.445699Z" + } + }, + "outputs": [], + "source": [ + "import os\n", + "import numpy as np\n", + "import nibabel as nib\n", + "import matplotlib.pyplot as plt\n", + "from rich import print as rprint\n", + "\n", + "from panoptica import (\n", + " InputType,\n", + " Panoptica_Evaluator,\n", + " ConnectedComponentsInstanceApproximator,\n", + " NaiveThresholdMatching,\n", + " Metric,\n", + ")\n", + "from panoptica.utils.segmentation_class import SegmentationClassGroups\n", + "from panoptica.utils.label_group import LabelGroup, LabelPartGroup" + ] + }, + { + "cell_type": "markdown", + "id": "9437ba3c", + "metadata": {}, + "source": [ + "## 3. BraTS Metastasis Sub-regions\n", + "\n", + "The BraTS-Mets 2025 segmentation masks contain three sub-region labels:\n", + "\n", + "| Label | Region | Description |\n", + "|-------|--------|-------------|\n", + "| 1 | Necrotic Core (NCR) | Non-enhancing, necrotic tumor core |\n", + "| 2 | Peritumoral Edema (ED) | Surrounding edematous/invaded tissue |\n", + "| 3 | Enhancing Tumor (ET) | Actively enhancing tumor |\n", + "\n", + "**Dataset:** BraTS-Path 2024 / BraTS-Mets 2025 challenge data.\n", + "\n", + "In **Standard PQ**, each sub-region is evaluated independently as a separate class.\n", + "\n", + "In **Part PQ**, the enhancing tumor and edema form the *thing* (the tumor instance), while the necrotic core is a *part* nested inside it — reflecting the biological hierarchy." + ] + }, + { + "cell_type": "markdown", + "id": "4400ace7", + "metadata": {}, + "source": [ + "## 4. Load Data" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c4071d8f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-04T11:18:56.447951Z", + "iopub.status.busy": "2026-05-04T11:18:56.447771Z", + "iopub.status.idle": "2026-05-04T11:18:56.805069Z", + "shell.execute_reply": "2026-05-04T11:18:56.804354Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reference shape: (240, 240, 155), labels: [0 1 2 3]\n", + "Prediction shape: (240, 240, 155), labels: [0 1 2 3]\n", + "Voxel spacing: (np.float32(1.0), np.float32(1.0), np.float32(1.0))\n" + ] + } + ], + "source": [ + "data_dir = os.path.join(BASE_PATH, \"brats_mets_data\")\n", + "\n", + "ref_nii = nib.load(os.path.join(data_dir, \"reference.nii.gz\"))\n", + "pred_nii = nib.load(os.path.join(data_dir, \"prediction.nii.gz\"))\n", + "\n", + "ref_mask = ref_nii.get_fdata().astype(np.uint8)\n", + "pred_mask = pred_nii.get_fdata().astype(np.uint8)\n", + "voxelspacing = ref_nii.header.get_zooms()\n", + "\n", + "print(f\"Reference shape: {ref_mask.shape}, labels: {np.unique(ref_mask)}\")\n", + "print(f\"Prediction shape: {pred_mask.shape}, labels: {np.unique(pred_mask)}\")\n", + "print(f\"Voxel spacing: {voxelspacing}\")" + ] + }, + { + "cell_type": "markdown", + "id": "4ab2ca3b", + "metadata": {}, + "source": [ + "## 5. Standard PQ — Per Sub-region Evaluation\n", + "\n", + "We evaluate each BraTS sub-region independently by defining a `SegmentationClassGroups` with one `LabelGroup` per label.\n", + "Each group is treated as a separate class: instances are extracted with Connected Components, then matched using NaiveThresholdMatching (IoU ≥ 0.5)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "8a01977b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-04T11:18:56.806707Z", + "iopub.status.busy": "2026-05-04T11:18:56.806609Z", + "iopub.status.idle": "2026-05-04T11:18:57.672234Z", + "shell.execute_reply": "2026-05-04T11:18:57.671760Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
────────────────────────────────────────── Thank you for using panoptica ──────────────────────────────────────────\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[92m────────────────────────────────────────── \u001b[0mThank you for using \u001b[1mpanoptica\u001b[0m\u001b[92m ──────────────────────────────────────────\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
                                     Please support our development by citing                                      \n",
+       "
\n" + ], + "text/plain": [ + " Please support our development by citing \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
                          https://github.com/BrainLesion/panoptica#citation -- Thank you!                          \n",
+       "
\n" + ], + "text/plain": [ + " \u001b[4;94mhttps://github.com/BrainLesion/panoptica#citation\u001b[0m -- Thank you! \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[92m───────────────────────────────────────────────────────────────────────────────────────────────────────────────────\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n",
+       "
\n" + ], + "text/plain": [ + "\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Region | PQ | SQ | RQ | TP | FP | FN \n", + "-------------------------------------------------------\n", + "necrotic | 0.0093 | 0.5142 | 0.0180 | 1 | 98 | 11 \n", + "edema | 0.0533 | 0.7198 | 0.0741 | 1 | 24 | 1 \n", + "enhancing | 0.2817 | 0.5634 | 0.5000 | 4 | 4 | 4 \n" + ] + } + ], + "source": [ + "standard_groups = SegmentationClassGroups(\n", + " {\n", + " \"Necrotic\": LabelGroup(1),\n", + " \"Edema\": LabelGroup(2),\n", + " \"Enhancing\": LabelGroup(3),\n", + " }\n", + ")\n", + "\n", + "evaluator_standard = Panoptica_Evaluator(\n", + " expected_input=InputType.SEMANTIC,\n", + " instance_approximator=ConnectedComponentsInstanceApproximator(),\n", + " instance_matcher=NaiveThresholdMatching(),\n", + " segmentation_class_groups=standard_groups,\n", + ")\n", + "\n", + "results_standard = evaluator_standard.evaluate(\n", + " pred_mask, ref_mask, voxelspacing=voxelspacing, verbose=False\n", + ")\n", + "\n", + "print(\n", + " f\"{'Region':<12} | {'PQ':<6} | {'SQ':<6} | {'RQ':<6} | {'TP':<4} | {'FP':<4} | {'FN':<4}\"\n", + ")\n", + "print(\"-\" * 55)\n", + "for name, res in results_standard.items():\n", + " print(\n", + " f\"{name:<12} | {res.pq:.4f} | {res.sq:.4f} | {res.rq:.4f} | {res.tp:<4} | {res.fp:<4} | {res.fn:<4}\"\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "04eef78a", + "metadata": {}, + "source": [ + "## 6. Part PQ — Hierarchical Tumor Evaluation\n", + "\n", + "Part PQ extends the standard panoptic quality to handle **hierarchical structures**: a *thing* object (the tumor instance) contains *part* objects (sub-regions).\n", + "\n", + "Here we define:\n", + "- **Thing label**: Enhancing Tumor (3) — the primary active tumor instance\n", + "- **Part label**: Necrotic Core (1) — physically nested inside the enhancing rim\n", + "- **Standard group**: Peritumoral Edema (2) — evaluated independently as a regular class\n", + "\n", + "Panoptica will:\n", + "1. Match enhancing tumor instances between prediction and reference (thing-level matching)\n", + "2. For each matched pair, score how well the necrotic core aligns (part-level scoring)\n", + "3. Evaluate edema separately as a standard LabelGroup\n", + "\n", + "Isolated necrotic voxels with no enclosing enhancing tumor are automatically discarded." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "d3fff704", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-04T11:18:57.673860Z", + "iopub.status.busy": "2026-05-04T11:18:57.673625Z", + "iopub.status.idle": "2026-05-04T11:18:59.447977Z", + "shell.execute_reply": "2026-05-04T11:18:59.447310Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- Part PQ: Tumor-level matching ---\n", + " PQ: 0.2859\n", + " SQ: 0.5719\n", + " RQ: 0.5000\n", + " TP: 4 | FP: 4 | FN: 4\n", + "\n", + "--- Part DSC per channel (part-level alignment) ---\n", + " Necrotic (part): DSC = 0.8544\n", + " Enhancing (thing): DSC = 0.8060\n", + "\n", + "--- Edema (standard LabelGroup) ---\n", + " PQ: 0.0533 SQ: 0.7198 RQ: 0.0741\n", + " TP: 1 | FP: 24 | FN: 1\n" + ] + } + ], + "source": [ + "part_groups = SegmentationClassGroups(\n", + " {\n", + " \"tumor\": LabelPartGroup(thing_labels=[3], part_labels=[1]),\n", + " \"edema\": LabelGroup(2),\n", + " }\n", + ")\n", + "\n", + "evaluator_part = Panoptica_Evaluator(\n", + " expected_input=InputType.SEMANTIC,\n", + " instance_approximator=ConnectedComponentsInstanceApproximator(),\n", + " instance_matcher=NaiveThresholdMatching(),\n", + " segmentation_class_groups=part_groups,\n", + ")\n", + "\n", + "results_part = evaluator_part.evaluate(\n", + " pred_mask, ref_mask, voxelspacing=voxelspacing, verbose=False\n", + ")\n", + "res_part = results_part[\"tumor\"]\n", + "\n", + "print(\"--- Part PQ: Tumor-level matching ---\")\n", + "print(f\" PQ: {res_part.pq:.4f}\")\n", + "print(f\" SQ: {res_part.sq:.4f}\")\n", + "print(f\" RQ: {res_part.rq:.4f}\")\n", + "print(f\" TP: {res_part.tp} | FP: {res_part.fp} | FN: {res_part.fn}\")\n", + "\n", + "print(\"\\n--- Part DSC per channel (part-level alignment) ---\")\n", + "channel_dsc = res_part.get_channel_metrics(\"dsc\")\n", + "channel_names = {0: \"Necrotic (part)\", 3: \"Enhancing (thing)\"}\n", + "if channel_dsc:\n", + " for ch_label, dsc_val in channel_dsc.items():\n", + " print(\n", + " f\" {channel_names.get(ch_label, f'label {ch_label}')}: DSC = {dsc_val:.4f}\"\n", + " )\n", + "\n", + "print(\"\\n--- Edema (standard LabelGroup) ---\")\n", + "res_edema = results_part[\"edema\"]\n", + "print(f\" PQ: {res_edema.pq:.4f} SQ: {res_edema.sq:.4f} RQ: {res_edema.rq:.4f}\")\n", + "print(f\" TP: {res_edema.tp} | FP: {res_edema.fp} | FN: {res_edema.fn}\")" + ] + }, + { + "cell_type": "markdown", + "id": "e5bff1fb", + "metadata": {}, + "source": [ + "## 7. Comparison: Standard PQ vs Part PQ\n", + "\n", + "Standard PQ treats each sub-region independently — a necrotic lesion that is correctly located but inside a mis-matched edema region still counts as a TP.\n", + "\n", + "Part PQ enforces the hierarchy: the necrotic core only scores well if its parent tumor instance was also correctly matched." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "3afcad68", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-04T11:18:59.449654Z", + "iopub.status.busy": "2026-05-04T11:18:59.449524Z", + "iopub.status.idle": "2026-05-04T11:18:59.452365Z", + "shell.execute_reply": "2026-05-04T11:18:59.451910Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Method | PQ | SQ | RQ | TP | FP | FN \n", + "-------------------------------------------------------------------\n", + "Standard [necrotic ] | 0.0093 | 0.5142 | 0.0180 | 1 | 98 | 11 \n", + "Standard [edema ] | 0.0533 | 0.7198 | 0.0741 | 1 | 24 | 1 \n", + "Standard [enhancing ] | 0.2817 | 0.5634 | 0.5000 | 4 | 4 | 4 \n", + "Part PQ [tumor ] | 0.2859 | 0.5719 | 0.5000 | 4 | 4 | 4 \n", + "Part PQ [edema ] | 0.0533 | 0.7198 | 0.0741 | 1 | 24 | 1 \n" + ] + } + ], + "source": [ + "print(\n", + " f\"{'Method':<22} | {'PQ':<6} | {'SQ':<6} | {'RQ':<6} | {'TP':<4} | {'FP':<4} | {'FN':<4}\"\n", + ")\n", + "print(\"-\" * 67)\n", + "\n", + "for name, res in results_standard.items():\n", + " print(\n", + " f\"Standard [{name:<10}] | {res.pq:.4f} | {res.sq:.4f} | {res.rq:.4f} | {res.tp:<4} | {res.fp:<4} | {res.fn:<4}\"\n", + " )\n", + "\n", + "print(\n", + " f\"Part PQ [tumor ] | {res_part.pq:.4f} | {res_part.sq:.4f} | {res_part.rq:.4f} | {res_part.tp:<4} | {res_part.fp:<4} | {res_part.fn:<4}\"\n", + ")\n", + "print(\n", + " f\"Part PQ [edema ] | {res_edema.pq:.4f} | {res_edema.sq:.4f} | {res_edema.rq:.4f} | {res_edema.tp:<4} | {res_edema.fp:<4} | {res_edema.fn:<4}\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "af395156", + "metadata": {}, + "source": [ + "## 8. Threshold Analysis\n", + "\n", + "The IoU matching threshold controls how much overlap is required to count a prediction as a True Positive.\n", + "Here we sweep from 0.05 to 0.95 using the Standard PQ (Enhancing Tumor class) and Part PQ to see how each degrades." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "b6c4cca7", + "metadata": { + "execution": { + "iopub.execute_input": "2026-05-04T11:18:59.453480Z", + "iopub.status.busy": "2026-05-04T11:18:59.453383Z", + "iopub.status.idle": "2026-05-04T11:19:50.772758Z", + "shell.execute_reply": "2026-05-04T11:19:50.771979Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sweeping thresholds...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [thresh=0.05] Standard ET PQ=0.4814 | Part PQ=0.3703\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [thresh=0.10] Standard ET PQ=0.4814 | Part PQ=0.3703\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [thresh=0.15] Standard ET PQ=0.4814 | Part PQ=0.3703\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [thresh=0.20] Standard ET PQ=0.4814 | Part PQ=0.3703\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [thresh=0.25] Standard ET PQ=0.4814 | Part PQ=0.3703\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [thresh=0.30] Standard ET PQ=0.4814 | Part PQ=0.3703\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [thresh=0.35] Standard ET PQ=0.4393 | Part PQ=0.3361\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [thresh=0.40] Standard ET PQ=0.4393 | Part PQ=0.3361\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [thresh=0.45] Standard ET PQ=0.2817 | Part PQ=0.2859\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [thresh=0.50] Standard ET PQ=0.2817 | Part PQ=0.2859\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [thresh=0.55] Standard ET PQ=0.1555 | Part PQ=0.2256\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [thresh=0.60] Standard ET PQ=0.0862 | Part PQ=0.0904\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [thresh=0.65] Standard ET PQ=0.0862 | Part PQ=0.0904\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [thresh=0.70] Standard ET PQ=0.0000 | Part PQ=0.0904\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [thresh=0.75] Standard ET PQ=0.0000 | Part PQ=0.0000\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [thresh=0.80] Standard ET PQ=0.0000 | Part PQ=0.0000\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [thresh=0.85] Standard ET PQ=0.0000 | Part PQ=0.0000\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [thresh=0.90] Standard ET PQ=0.0000 | Part PQ=0.0000\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [thresh=0.95] Standard ET PQ=0.0000 | Part PQ=0.0000\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from panoptica.instance_matcher import NaiveThresholdMatching as NTM\n", + "\n", + "thresholds = np.arange(0.05, 1.0, 0.05)\n", + "pq_enhancing = []\n", + "pq_part = []\n", + "\n", + "print(\"Sweeping thresholds...\")\n", + "for thresh in thresholds:\n", + " matcher = NTM(matching_metric=Metric.IOU, matching_threshold=float(thresh))\n", + "\n", + " # Standard PQ — all sub-regions, extract Enhancing result\n", + " ev_s = Panoptica_Evaluator(\n", + " expected_input=InputType.SEMANTIC,\n", + " instance_approximator=ConnectedComponentsInstanceApproximator(),\n", + " instance_matcher=matcher,\n", + " segmentation_class_groups=SegmentationClassGroups(\n", + " {\n", + " \"Necrotic\": LabelGroup(1),\n", + " \"Edema\": LabelGroup(2),\n", + " \"Enhancing\": LabelGroup(3),\n", + " }\n", + " ),\n", + " )\n", + " r_s = ev_s.evaluate(pred_mask, ref_mask, voxelspacing=voxelspacing, verbose=False)[\n", + " \"enhancing\"\n", + " ]\n", + " pq_enhancing.append(r_s.pq)\n", + "\n", + " # Part PQ — Enhancing as thing, Necrotic as part\n", + " ev_p = Panoptica_Evaluator(\n", + " expected_input=InputType.SEMANTIC,\n", + " instance_approximator=ConnectedComponentsInstanceApproximator(),\n", + " instance_matcher=matcher,\n", + " segmentation_class_groups=SegmentationClassGroups(\n", + " {\n", + " \"tumor\": LabelPartGroup(thing_labels=[3], part_labels=[1]),\n", + " \"edema\": LabelGroup(2),\n", + " }\n", + " ),\n", + " )\n", + " r_p = ev_p.evaluate(pred_mask, ref_mask, voxelspacing=voxelspacing, verbose=False)[\n", + " \"tumor\"\n", + " ]\n", + " pq_part.append(r_p.pq)\n", + "\n", + " print(f\" [thresh={thresh:.2f}] Standard ET PQ={r_s.pq:.4f} | Part PQ={r_p.pq:.4f}\")\n", + "\n", + "fig, ax = plt.subplots(figsize=(10, 5))\n", + "ax.plot(\n", + " thresholds,\n", + " pq_enhancing,\n", + " marker=\"o\",\n", + " linewidth=2,\n", + " label=\"Standard PQ (Enhancing Tumor)\",\n", + ")\n", + "ax.plot(\n", + " thresholds,\n", + " pq_part,\n", + " marker=\"s\",\n", + " linestyle=\"--\",\n", + " linewidth=2,\n", + " label=\"Part PQ (Enhancing + Necrotic)\",\n", + ")\n", + "ax.set_xlabel(\"IoU Matching Threshold\", fontsize=12)\n", + "ax.set_ylabel(\"Panoptic Quality (PQ)\", fontsize=12)\n", + "ax.set_title(\"Impact of Matching Threshold: Standard PQ vs Part PQ\", fontsize=13)\n", + "ax.legend(fontsize=11)\n", + "ax.grid(True, linestyle=\"--\", alpha=0.6)\n", + "fig.tight_layout()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}