Add ovarian CT progression viewer

RL0910/demo_imaging_cases/cases/TCGA-25-1328/manifest.json

@@ -0,0 +1,75 @@
+{
+  "format": "rldt_ov_imaging_package",
+  "version": 1,
+  "case_id": "TCGA-25-1328",
+  "patient_id": "TCGA-25-1328",
+  "display_name": "TCGA-OV TCGA-25-1328",
+  "modality": "CT",
+  "summary_note": "Existing progression visualization built from preprocessed TCGA-OV CT series. Lesion highlighting is heuristic when no label is available.",
+  "timepoints": [
+    {
+      "timepoint_id": "t01",
+      "label": "01-16-1986-CT ChestAbdomenPelv-10718",
+      "relative_time": 1.0,
+      "asset_path": "tp_01.json",
+      "series_description": "AXIAL",
+      "num_slices_original": 144,
+      "spacing_zyx_mm": [
+        4.468531440559441,
+        0.703125,
+        0.703125
+      ],
+      "lesion_confidence": 0.42,
+      "lesion_source": "heuristic_component",
+      "lesion_voxel_count": 1015
+    },
+    {
+      "timepoint_id": "t02",
+      "label": "04-12-1985-Abdomen1 AP ROUTINE-14165",
+      "relative_time": 4.0,
+      "asset_path": "tp_02.json",
+      "series_description": "AP Routine  5.0  B40f",
+      "num_slices_original": 90,
+      "spacing_zyx_mm": [
+        5.0,
+        0.703125,
+        0.703125
+      ],
+      "lesion_confidence": 0.42,
+      "lesion_source": "heuristic_component",
+      "lesion_voxel_count": 4034
+    },
+    {
+      "timepoint_id": "t03",
+      "label": "08-23-1986-Abdomen01APRoutine Adult-21186",
+      "relative_time": 8.0,
+      "asset_path": "tp_03.json",
+      "series_description": "AP Routine  5.0  B40f",
+      "num_slices_original": 96,
+      "spacing_zyx_mm": [
+        5.0,
+        0.78125,
+        0.78125
+      ],
+      "lesion_confidence": 0.42,
+      "lesion_source": "heuristic_component",
+      "lesion_voxel_count": 3512
+    },
+    {
+      "timepoint_id": "t04",
+      "label": "12-26-1986-CT ABDOMEN PELVIS-83459",
+      "relative_time": 12.0,
+      "asset_path": "tp_04.json",
+      "series_description": "AXIAL",
+      "num_slices_original": 67,
+      "spacing_zyx_mm": [
+        6.893939560606061,
+        0.78125,
+        0.78125
+      ],
+      "lesion_confidence": 0.42,
+      "lesion_source": "heuristic_component",
+      "lesion_voxel_count": 683
+    }
+  ]
+}

RL0910/demo_imaging_cases/cases/TCGA-25-1633/manifest.json

@@ -0,0 +1,75 @@
+{
+  "format": "rldt_ov_imaging_package",
+  "version": 1,
+  "case_id": "TCGA-25-1633",
+  "patient_id": "TCGA-25-1633",
+  "display_name": "TCGA-OV TCGA-25-1633",
+  "modality": "CT",
+  "summary_note": "Existing progression visualization built from preprocessed TCGA-OV CT series. Lesion highlighting is heuristic when no label is available.",
+  "timepoints": [
+    {
+      "timepoint_id": "t01",
+      "label": "02-21-1987-Abdomen020APRoutine Adult-53316",
+      "relative_time": 2.0,
+      "asset_path": "tp_01.json",
+      "series_description": "AP Routine  3.0  SPO  cor",
+      "num_slices_original": 97,
+      "spacing_zyx_mm": [
+        2.5,
+        0.732421875,
+        0.732421875
+      ],
+      "lesion_confidence": 0.42,
+      "lesion_source": "heuristic_component",
+      "lesion_voxel_count": 1050
+    },
+    {
+      "timepoint_id": "t02",
+      "label": "04-28-1988-Abdomen020APRoutine Adult-77184",
+      "relative_time": 4.0,
+      "asset_path": "tp_02.json",
+      "series_description": "AP Routine  5.0  B40f",
+      "num_slices_original": 82,
+      "spacing_zyx_mm": [
+        5.0,
+        0.703125,
+        0.703125
+      ],
+      "lesion_confidence": 0.42,
+      "lesion_source": "heuristic_component",
+      "lesion_voxel_count": 1385
+    },
+    {
+      "timepoint_id": "t03",
+      "label": "08-02-1987-Abdomen020APRoutine Adult-13930",
+      "relative_time": 8.0,
+      "asset_path": "tp_03.json",
+      "series_description": "AP routine  5.0  B40f",
+      "num_slices_original": 86,
+      "spacing_zyx_mm": [
+        5.0,
+        0.6640625,
+        0.6640625
+      ],
+      "lesion_confidence": 0.42,
+      "lesion_source": "heuristic_component",
+      "lesion_voxel_count": 2379
+    },
+    {
+      "timepoint_id": "t04",
+      "label": "12-27-1986-CT ABDOMEN PELVIS-23762",
+      "relative_time": 12.0,
+      "asset_path": "tp_04.json",
+      "series_description": "AXIAL",
+      "num_slices_original": 82,
+      "spacing_zyx_mm": [
+        5.000000024691358,
+        0.742188,
+        0.742188
+      ],
+      "lesion_confidence": 0.42,
+      "lesion_source": "heuristic_component",
+      "lesion_voxel_count": 19345
+    }
+  ]
+}

RL0910/demo_imaging_cases/cases/TCGA-25-2393/manifest.json

@@ -0,0 +1,75 @@
+{
+  "format": "rldt_ov_imaging_package",
+  "version": 1,
+  "case_id": "TCGA-25-2393",
+  "patient_id": "TCGA-25-2393",
+  "display_name": "TCGA-OV TCGA-25-2393",
+  "modality": "CT",
+  "summary_note": "Existing progression visualization built from preprocessed TCGA-OV CT series. Lesion highlighting is heuristic when no label is available.",
+  "timepoints": [
+    {
+      "timepoint_id": "t01",
+      "label": "01-17-1987-Abdomen020APRoutine Adult-74338",
+      "relative_time": 1.0,
+      "asset_path": "tp_01.json",
+      "series_description": "AP Routine  3.0  SPO  cor",
+      "num_slices_original": 128,
+      "spacing_zyx_mm": [
+        2.5,
+        0.890625,
+        0.890625
+      ],
+      "lesion_confidence": 0.22,
+      "lesion_source": "heuristic_ellipsoid",
+      "lesion_voxel_count": 2353
+    },
+    {
+      "timepoint_id": "t02",
+      "label": "04-27-1988-Abdomen020APRoutine Adult-64382",
+      "relative_time": 4.0,
+      "asset_path": "tp_02.json",
+      "series_description": "AP routine  5.0  B40f",
+      "num_slices_original": 80,
+      "spacing_zyx_mm": [
+        5.0,
+        0.859375,
+        0.859375
+      ],
+      "lesion_confidence": 0.42,
+      "lesion_source": "heuristic_component",
+      "lesion_voxel_count": 310
+    },
+    {
+      "timepoint_id": "t03",
+      "label": "08-15-1985-CT ABDOMEN PELVIS-61715",
+      "relative_time": 8.0,
+      "asset_path": "tp_03.json",
+      "series_description": "AXIAL",
+      "num_slices_original": 18,
+      "spacing_zyx_mm": [
+        5.764705882352941,
+        0.859375,
+        0.859375
+      ],
+      "lesion_confidence": 0.42,
+      "lesion_source": "heuristic_component",
+      "lesion_voxel_count": 429
+    },
+    {
+      "timepoint_id": "t04",
+      "label": "12-02-1986-CT ABDOMEN PELVIS-18560",
+      "relative_time": 12.0,
+      "asset_path": "tp_04.json",
+      "series_description": "AXIAL",
+      "num_slices_original": 97,
+      "spacing_zyx_mm": [
+        5.000000114583333,
+        0.859375,
+        0.859375
+      ],
+      "lesion_confidence": 0.42,
+      "lesion_source": "heuristic_component",
+      "lesion_voxel_count": 3104
+    }
+  ]
+}

RL0910/demo_imaging_cases/manifest.json

@@ -0,0 +1,21 @@
+{
+  "format": "rldt_ov_imaging_package",
+  "version": 1,
+  "cases": [
+    {
+      "case_id": "TCGA-25-1633",
+      "display_name": "TCGA-OV TCGA-25-1633",
+      "timepoint_count": 4
+    },
+    {
+      "case_id": "TCGA-25-1328",
+      "display_name": "TCGA-OV TCGA-25-1328",
+      "timepoint_count": 4
+    },
+    {
+      "case_id": "TCGA-25-2393",
+      "display_name": "TCGA-OV TCGA-25-2393",
+      "timepoint_count": 4
+    }
+  ]
+}

RL0910/enhanced_chat_ui.py

@@ -57,6 +57,13 @@ from online_monitor import OnlineSystemMonitor
 from system_health_check import SystemHealthChecker
 
 from drive_tools import load_data_source, generate_patient_report, generate_patient_report_ui
+from imaging_viewer import (
+    imaging_upload_requirements_md,
+    initialize_demo_view,
+    load_imaging_case,
+    select_gallery_slice,
+    update_imaging_timepoint,
+)
 
 # ---- Optional BCQ loader ----
 def _load_bcq_policy(path: str):
@@ -788,6 +795,16 @@ def create_gradio_interface():
         - 🤖 LLM Co-Pilot: Context-aware help available on every page
         """)
 
+        with gr.Row():
+            with gr.Column(scale=4):
+                gr.Markdown("")
+            with gr.Column(scale=1, min_width=240):
+                open_imaging_workspace_btn = _register_button_with_help(
+                    "🩻 Open Ovarian Imaging Viewer",
+                    "Jump to the CT progression viewer for preloaded TCGA-OV imaging cases or uploaded imaging packages.",
+                    variant="primary",
+                )
+
         with gr.Row():
             with gr.Column(scale=4, min_width=720):
                 with gr.Tabs():
@@ -1001,7 +1018,69 @@ def create_gradio_interface():
 
                         export_output = gr.File(label="Exported Data", visible=False)
 
-                    # Tab 2: Parameter Control
+                    # Tab 2: Ovarian Imaging Viewer
+                    with gr.Tab("🩻 Ovarian Imaging Viewer") as imaging_tab:
+                        gr.Markdown("### Ovarian Cancer Existing Progression Viewer")
+                        gr.Markdown(
+                            "> Existing progression visualization only. This workspace shows preloaded TCGA-OV CT time series or uploaded RLDT imaging packages, with heuristic lesion highlighting when no mask is available."
+                        )
+
+                        with gr.Row():
+                            imaging_source_mode = gr.Radio(
+                                choices=["Demo Cases", "Upload Package"],
+                                value="Demo Cases",
+                                label="Imaging source",
+                                info="Use the preloaded TCGA-OV cases or upload one packaged case for visualization."
+                            )
+                            imaging_case_dropdown = gr.Dropdown(
+                                choices=[],
+                                value=None,
+                                label="Demo case",
+                                info="Select one of the preloaded TCGA-OV longitudinal imaging cases.",
+                            )
+                            imaging_timepoint_dropdown = gr.Dropdown(
+                                choices=[],
+                                value=None,
+                                label="Timepoint",
+                                info="Switch between available visits for the active case.",
+                            )
+
+                        with gr.Row():
+                            with gr.Column(scale=2):
+                                imaging_upload = gr.File(
+                                    label="Upload Imaging Package (.zip)",
+                                    file_types=[".zip"],
+                                    visible=False,
+                                )
+                            with gr.Column(scale=1):
+                                imaging_load_btn = _register_button_with_help(
+                                    "Load Imaging Case",
+                                    "Load the selected demo case or uploaded imaging package into the progression viewer.",
+                                    variant="primary",
+                                )
+
+                        imaging_requirements = gr.Markdown(imaging_upload_requirements_md())
+                        imaging_case_info = gr.Markdown("No imaging case loaded yet.")
+
+                        with gr.Row():
+                            with gr.Column(scale=3, min_width=640):
+                                imaging_plot = gr.Plot(label="3D Existing Progression View")
+                            with gr.Column(scale=2, min_width=360):
+                                imaging_timeline_plot = gr.Plot(label="Progression Timeline")
+                                imaging_slice_detail = gr.Image(label="Selected Slice", visible=False)
+                                imaging_slice_markdown = gr.Markdown("Load a case to inspect slices.")
+
+                        imaging_gallery = gr.Gallery(
+                            label="Representative Axial Slices",
+                            columns=4,
+                            rows=2,
+                            height=320,
+                            preview=False,
+                        )
+                        imaging_state = gr.State({})
+                        imaging_slice_indices = gr.State([])
+
+                    # Tab 3: Parameter Control
                     with gr.Tab("⚙️ Parameter Control"):
                         gr.Markdown("### Model Parameter Configuration")
 
@@ -2785,6 +2864,69 @@ def create_gradio_interface():
             inputs=[patient_dropdown],
             outputs=[export_output]
         )
+
+        def _toggle_imaging_source(mode):
+            use_upload = mode == "Upload Package"
+            return (
+                gr.update(visible=use_upload),
+                gr.update(visible=not use_upload),
+            )
+
+        imaging_source_mode.change(
+            _toggle_imaging_source,
+            inputs=[imaging_source_mode],
+            outputs=[imaging_upload, imaging_case_dropdown],
+        )
+
+        imaging_load_btn.click(
+            load_imaging_case,
+            inputs=[imaging_source_mode, imaging_upload, imaging_case_dropdown, imaging_timepoint_dropdown],
+            outputs=[
+                imaging_case_dropdown,
+                imaging_timepoint_dropdown,
+                imaging_case_info,
+                imaging_plot,
+                imaging_gallery,
+                imaging_timeline_plot,
+                imaging_slice_markdown,
+                imaging_slice_detail,
+                imaging_state,
+                imaging_slice_indices,
+            ],
+        )
+
+        imaging_timepoint_dropdown.change(
+            update_imaging_timepoint,
+            inputs=[imaging_state, imaging_timepoint_dropdown],
+            outputs=[
+                imaging_case_info,
+                imaging_plot,
+                imaging_gallery,
+                imaging_timeline_plot,
+                imaging_slice_markdown,
+                imaging_slice_detail,
+                imaging_state,
+                imaging_slice_indices,
+            ],
+        )
+
+        imaging_gallery.select(
+            select_gallery_slice,
+            inputs=[imaging_state, imaging_slice_indices],
+            outputs=[imaging_slice_detail, imaging_slice_markdown],
+        )
+
+        open_imaging_workspace_btn.click(
+            lambda: None,
+            outputs=[],
+            queue=False,
+            js="""() => {
+                const buttons = Array.from(document.querySelectorAll('button'));
+                const target = buttons.find((el) => el.innerText && el.innerText.trim() === '🩻 Ovarian Imaging Viewer');
+                if (target) { target.click(); }
+                return [];
+            }""",
+        )
         
         # Chat events with patient context
         msg.submit(
@@ -3296,6 +3438,22 @@ def create_gradio_interface():
             """
         )
 
+        demo.load(
+            initialize_demo_view,
+            outputs=[
+                imaging_case_dropdown,
+                imaging_timepoint_dropdown,
+                imaging_case_info,
+                imaging_plot,
+                imaging_gallery,
+                imaging_timeline_plot,
+                imaging_slice_markdown,
+                imaging_slice_detail,
+                imaging_state,
+                imaging_slice_indices,
+            ],
+        )
+
     return demo
 
 

RL0910/imaging_viewer.py

@@ -0,0 +1,403 @@
+from __future__ import annotations
+
+import base64
+import io
+import json
+import math
+import tempfile
+import zipfile
+import zlib
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+
+import gradio as gr
+import numpy as np
+import plotly.graph_objects as go
+from PIL import Image, ImageDraw
+from scipy import ndimage as ndi
+
+
+MODULE_DIR = Path(__file__).resolve().parent
+DEMO_ROOT = MODULE_DIR / "demo_imaging_cases"
+UPLOAD_CACHE_ROOT = Path(tempfile.gettempdir()) / "rldt_ov_imaging_uploads"
+PACKAGE_MAGIC = "rldt_ov_imaging_package"
+
+
+def _json_load(path: Path) -> dict[str, Any]:
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+@lru_cache(maxsize=32)
+def _load_asset(asset_path: str) -> dict[str, Any]:
+    path = Path(asset_path)
+    if path.suffix == ".npz":
+        data = np.load(path, allow_pickle=False)
+        return {key: data[key] for key in data.files}
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    shape = tuple(payload["shape"])
+    volume_bytes = zlib.decompress(base64.b85decode(payload["volume_u8_b85"].encode("ascii")))
+    lesion_bytes = zlib.decompress(base64.b85decode(payload["lesion_mask_b85"].encode("ascii")))
+    return {
+        "volume_u8": np.frombuffer(volume_bytes, dtype=np.uint8).reshape(shape),
+        "lesion_mask": np.frombuffer(lesion_bytes, dtype=np.uint8).reshape(shape),
+        "roi_center_zyx": np.array(payload.get("roi_center_zyx", [shape[0] // 2, shape[1] // 2, shape[2] // 2]), dtype=np.int16),
+    }
+
+
+def list_demo_cases() -> list[dict[str, Any]]:
+    manifest_path = DEMO_ROOT / "manifest.json"
+    if not manifest_path.exists():
+        return []
+    manifest = _json_load(manifest_path)
+    return manifest.get("cases", [])
+
+
+def _load_case_manifest(case_root: Path) -> dict[str, Any]:
+    return _json_load(case_root / "manifest.json")
+
+
+def _body_mask_from_volume(volume_u8: np.ndarray) -> np.ndarray:
+    body = volume_u8 > 12
+    if not body.any():
+        return body
+    labels, n = ndi.label(body)
+    if n <= 0:
+        return body
+    sizes = np.bincount(labels.ravel())
+    sizes[0] = 0
+    return labels == int(sizes.argmax())
+
+
+def _sample_points(mask: np.ndarray, max_points: int) -> np.ndarray:
+    coords = np.argwhere(mask)
+    if len(coords) == 0:
+        return np.zeros((0, 3), dtype=np.int16)
+    if len(coords) <= max_points:
+        return coords.astype(np.int16)
+    step = max(1, len(coords) // max_points)
+    return coords[::step][:max_points].astype(np.int16)
+
+
+def _surface_points(body_mask: np.ndarray, max_points: int = 4500) -> np.ndarray:
+    eroded = ndi.binary_erosion(body_mask, iterations=1)
+    surface = body_mask & (~eroded)
+    return _sample_points(surface, max_points=max_points)
+
+
+def _lesion_points(lesion_mask: np.ndarray, max_points: int = 2200) -> np.ndarray:
+    return _sample_points(lesion_mask > 0, max_points=max_points)
+
+
+def _region_name(z: int, y: int, x: int, shape: tuple[int, int, int]) -> tuple[str, str]:
+    d, h, w = shape
+    zf = z / max(d - 1, 1)
+    xf = x / max(w - 1, 1)
+    if zf < 0.35:
+        cranio = "upper abdomen"
+        note = "Liver, stomach, and upper peritoneal cavity are more likely in this level."
+    elif zf < 0.68:
+        cranio = "mid abdomen"
+        note = "Bowel loops, mesentery, and central peritoneal cavity are more likely in this level."
+    else:
+        cranio = "pelvis"
+        note = "Adnexal, uterine, bladder, and pelvic peritoneal structures are more likely in this level."
+    if xf < 0.4:
+        side = "left"
+    elif xf > 0.6:
+        side = "right"
+    else:
+        side = "midline"
+    return f"{side} {cranio}", note
+
+
+def _volume_to_rgb(slice_img: np.ndarray, lesion_slice: np.ndarray | None = None) -> Image.Image:
+    base = np.stack([slice_img] * 3, axis=-1).astype(np.uint8)
+    if lesion_slice is not None and lesion_slice.any():
+        overlay = base.copy()
+        overlay[..., 0] = np.maximum(overlay[..., 0], lesion_slice.astype(np.uint8) * 255)
+        overlay[..., 1] = np.where(lesion_slice > 0, overlay[..., 1] // 3, overlay[..., 1])
+        overlay[..., 2] = np.where(lesion_slice > 0, overlay[..., 2] // 3, overlay[..., 2])
+        base = (0.5 * base + 0.5 * overlay).astype(np.uint8)
+    return Image.fromarray(base)
+
+
+def _annotate_slice(img: Image.Image, label: str) -> Image.Image:
+    canvas = img.convert("RGB")
+    draw = ImageDraw.Draw(canvas)
+    draw.rounded_rectangle((10, 10, 250, 42), radius=8, fill=(20, 26, 42))
+    draw.text((18, 18), label, fill=(255, 255, 255))
+    return canvas
+
+
+def _build_gallery_items(volume_u8: np.ndarray, lesion_mask: np.ndarray, center_z: int) -> tuple[list[tuple[Image.Image, str]], list[int]]:
+    d = volume_u8.shape[0]
+    indices = sorted({int(np.clip(center_z + delta, 0, d - 1)) for delta in (-12, -8, -4, 0, 4, 8, 12)})
+    gallery: list[tuple[Image.Image, str]] = []
+    for z in indices:
+        lesion_slice = lesion_mask[z] if lesion_mask is not None else None
+        img = _volume_to_rgb(volume_u8[z], lesion_slice)
+        img = _annotate_slice(img.resize((288, 288)), f"Axial slice {z}")
+        gallery.append((img, f"Slice {z}"))
+    return gallery, indices
+
+
+def _slice_detail(volume_u8: np.ndarray, lesion_mask: np.ndarray, z_index: int) -> tuple[Image.Image, str]:
+    lesion_slice = lesion_mask[z_index] if lesion_mask is not None else None
+    img = _volume_to_rgb(volume_u8[z_index], lesion_slice)
+    img = _annotate_slice(img.resize((640, 640)), f"Axial slice {z_index}")
+    lesion_area = int(lesion_slice.sum()) if lesion_slice is not None else 0
+    desc = (
+        f"### Slice {z_index}\n"
+        f"- Overlay mode: heuristic lesion candidate\n"
+        f"- Highlighted pixels: {lesion_area}\n"
+        f"- View: axial CT slice enlarged from the progression viewer"
+    )
+    return img, desc
+
+
+def _timeline_figure(case_manifest: dict[str, Any]) -> go.Figure:
+    xs = []
+    ys = []
+    labels = []
+    for tp in case_manifest.get("timepoints", []):
+        xs.append(tp.get("relative_time", len(xs) + 1))
+        ys.append(tp.get("lesion_voxel_count", 0))
+        labels.append(tp.get("label", tp.get("timepoint_id", "t")))
+    fig = go.Figure()
+    fig.add_trace(
+        go.Scatter(
+            x=xs,
+            y=ys,
+            mode="lines+markers",
+            line=dict(color="#6366f1", width=3),
+            marker=dict(size=9, color="#ef4444"),
+            text=labels,
+            hovertemplate="Timepoint %{text}<br>Relative time %{x}<br>Candidate lesion voxels %{y}<extra></extra>",
+        )
+    )
+    fig.update_layout(
+        title="Existing Progression Timeline",
+        margin=dict(l=20, r=20, t=48, b=20),
+        height=280,
+        xaxis_title="Relative time",
+        yaxis_title="Candidate lesion volume proxy",
+        template="plotly_white",
+    )
+    return fig
+
+
+def _viewer_plot(volume_u8: np.ndarray, lesion_mask: np.ndarray, timepoint_meta: dict[str, Any]) -> go.Figure:
+    body = _body_mask_from_volume(volume_u8)
+    body_pts = _surface_points(body)
+    lesion_pts = _lesion_points(lesion_mask)
+    d, h, w = volume_u8.shape
+    fig = go.Figure()
+
+    if len(body_pts) > 0:
+        texts = []
+        colors = []
+        for z, y, x in body_pts:
+            region, note = _region_name(int(z), int(y), int(x), volume_u8.shape)
+            intensity = int(volume_u8[int(z), int(y), int(x)])
+            texts.append(
+                f"<b>Body surface sample</b><br>Region: {region}<br>Display intensity: {intensity}<br>{note}"
+            )
+            colors.append(z)
+        fig.add_trace(
+            go.Scatter3d(
+                x=body_pts[:, 2],
+                y=body_pts[:, 1],
+                z=body_pts[:, 0],
+                mode="markers",
+                name="Body envelope",
+                marker=dict(size=2.2, color=colors, colorscale="Blues", opacity=0.15, showscale=False),
+                text=texts,
+                hovertemplate="%{text}<extra></extra>",
+            )
+        )
+
+    if len(lesion_pts) > 0:
+        lesion_text = []
+        confidence = timepoint_meta.get("lesion_confidence", 0.35)
+        for z, y, x in lesion_pts:
+            region, note = _region_name(int(z), int(y), int(x), volume_u8.shape)
+            lesion_text.append(
+                f"<b>Candidate lesion ROI</b><br>Region: {region}<br>Confidence: {confidence:.2f}<br>{note}<br>Source: {timepoint_meta.get('lesion_source', 'heuristic') }"
+            )
+        fig.add_trace(
+            go.Scatter3d(
+                x=lesion_pts[:, 2],
+                y=lesion_pts[:, 1],
+                z=lesion_pts[:, 0],
+                mode="markers",
+                name="Candidate lesion",
+                marker=dict(size=3.8, color="#ef4444", opacity=0.78),
+                text=lesion_text,
+                hovertemplate="%{text}<extra></extra>",
+            )
+        )
+
+    fig.update_layout(
+        title=f"{timepoint_meta.get('label', 'Timepoint')} | 3D existing progression view",
+        template="plotly_white",
+        height=560,
+        margin=dict(l=0, r=0, t=48, b=0),
+        legend=dict(orientation="h", yanchor="bottom", y=1.02, x=0.0),
+        scene=dict(
+            xaxis=dict(title="Left ↔ Right"),
+            yaxis=dict(title="Posterior ↔ Anterior"),
+            zaxis=dict(title="Superior ↔ Inferior"),
+            aspectmode="data",
+            camera=dict(eye=dict(x=1.5, y=1.5, z=0.8)),
+        ),
+    )
+    return fig
+
+
+def _case_markdown(case_manifest: dict[str, Any], package_mode: str) -> str:
+    source_text = "Preloaded TCGA-OV demo case" if package_mode == "demo" else "Uploaded imaging package"
+    return (
+        f"### {case_manifest.get('display_name', case_manifest.get('case_id', 'Case'))}\n"
+        f"- Source: {source_text}\n"
+        f"- Patient ID: `{case_manifest.get('patient_id', case_manifest.get('case_id', 'unknown'))}`\n"
+        f"- Timepoints loaded: {len(case_manifest.get('timepoints', []))}\n"
+        f"- Modality: {case_manifest.get('modality', 'CT')}\n"
+        f"- Note: `{case_manifest.get('summary_note', 'Existing progression viewer only; no predictive inference in this workspace.')}`"
+    )
+
+
+def _package_root_from_upload(upload_path: str) -> Path:
+    upload_path = str(upload_path or "")
+    if not upload_path:
+        raise ValueError("No imaging package uploaded.")
+    src = Path(upload_path)
+    if not src.exists():
+        raise FileNotFoundError(f"Missing uploaded file: {src}")
+    target_dir = UPLOAD_CACHE_ROOT / src.stem
+    if target_dir.exists() and (target_dir / "manifest.json").exists():
+        return target_dir
+    target_dir.mkdir(parents=True, exist_ok=True)
+    with zipfile.ZipFile(src, "r") as zf:
+        zf.extractall(target_dir)
+    manifest_path = target_dir / "manifest.json"
+    if not manifest_path.exists():
+        raise ValueError("Uploaded package is missing manifest.json.")
+    manifest = _json_load(manifest_path)
+    if manifest.get("format") != PACKAGE_MAGIC:
+        raise ValueError("Uploaded package is not a supported RLDT ovarian imaging package.")
+    return target_dir
+
+
+def available_demo_case_choices() -> list[tuple[str, str]]:
+    return [(case.get("display_name", case.get("case_id", "Case")), case.get("case_id", "")) for case in list_demo_cases()]
+
+
+def initialize_demo_view() -> tuple[Any, ...]:
+    cases = list_demo_cases()
+    if not cases:
+        return (
+            gr.update(choices=[], value=None),
+            gr.update(choices=[], value=None),
+            "No demo imaging package found.",
+            None,
+            [],
+            None,
+            "No imaging asset loaded.",
+            gr.update(value=None, visible=False),
+            {},
+            [],
+        )
+    first_case = cases[0]["case_id"]
+    return load_imaging_case("demo", None, first_case, None)
+
+
+def load_imaging_case(source_mode: str, upload_file: Any, selected_case_id: str | None, selected_timepoint_id: str | None):
+    if source_mode == "upload":
+        package_root = _package_root_from_upload(getattr(upload_file, "name", upload_file))
+        case_manifest = _json_load(package_root / "manifest.json")
+        package_mode = "upload"
+    else:
+        package_root = DEMO_ROOT / "cases" / (selected_case_id or "")
+        if not package_root.exists():
+            demo_cases = list_demo_cases()
+            if not demo_cases:
+                raise ValueError("No demo imaging cases are available.")
+            package_root = DEMO_ROOT / "cases" / demo_cases[0]["case_id"]
+        case_manifest = _load_case_manifest(package_root)
+        package_mode = "demo"
+
+    timepoints = case_manifest.get("timepoints", [])
+    if not timepoints:
+        raise ValueError("Imaging package contains no timepoints.")
+    timepoint_map = {tp["timepoint_id"]: tp for tp in timepoints}
+    if selected_timepoint_id not in timepoint_map:
+        selected_timepoint_id = timepoints[0]["timepoint_id"]
+    tp_meta = timepoint_map[selected_timepoint_id]
+    asset_path = package_root / tp_meta["asset_path"]
+    data = _load_asset(str(asset_path))
+    volume_u8 = data["volume_u8"]
+    lesion_mask = data.get("lesion_mask", np.zeros_like(volume_u8, dtype=np.uint8))
+    roi_center = data.get("roi_center_zyx", np.array([volume_u8.shape[0] // 2, volume_u8.shape[1] // 2, volume_u8.shape[2] // 2]))
+    center_z = int(roi_center[0])
+
+    fig = _viewer_plot(volume_u8, lesion_mask, tp_meta)
+    gallery_items, slice_indices = _build_gallery_items(volume_u8, lesion_mask, center_z)
+    detail_img, detail_md = _slice_detail(volume_u8, lesion_mask, slice_indices[len(slice_indices) // 2])
+    timeline = _timeline_figure(case_manifest)
+    state = {
+        "package_root": str(package_root),
+        "package_mode": package_mode,
+        "case_id": case_manifest.get("case_id"),
+        "timepoint_id": selected_timepoint_id,
+    }
+    case_choices = [(case_manifest.get("display_name", case_manifest.get("case_id", "Case")), case_manifest.get("case_id"))]
+    if package_mode == "demo":
+        case_choices = available_demo_case_choices()
+    tp_choices = [(tp.get("label", tp["timepoint_id"]), tp["timepoint_id"]) for tp in timepoints]
+    info_md = _case_markdown(case_manifest, package_mode)
+    return (
+        gr.update(choices=case_choices, value=case_manifest.get("case_id")),
+        gr.update(choices=tp_choices, value=selected_timepoint_id),
+        info_md,
+        fig,
+        gallery_items,
+        timeline,
+        detail_md,
+        gr.update(value=detail_img, visible=True),
+        state,
+        slice_indices,
+    )
+
+
+def update_imaging_timepoint(state: dict[str, Any], selected_timepoint_id: str):
+    if not state:
+        raise ValueError("Load an imaging case before changing timepoints.")
+    package_root = Path(state["package_root"])
+    case_manifest = _load_case_manifest(package_root)
+    return load_imaging_case(state.get("package_mode", "demo"), None, case_manifest.get("case_id"), selected_timepoint_id)[2:]
+
+
+def select_gallery_slice(evt: gr.SelectData, state: dict[str, Any], slice_indices: list[int]):
+    if not state or not slice_indices:
+        return None, "Load an imaging case first."
+    package_root = Path(state["package_root"])
+    case_manifest = _load_case_manifest(package_root)
+    tp_id = state["timepoint_id"]
+    tp_meta = next(tp for tp in case_manifest["timepoints"] if tp["timepoint_id"] == tp_id)
+    data = _load_asset(str(package_root / tp_meta["asset_path"]))
+    volume_u8 = data["volume_u8"]
+    lesion_mask = data.get("lesion_mask", np.zeros_like(volume_u8, dtype=np.uint8))
+    index = int(evt.index) if evt is not None else 0
+    index = max(0, min(index, len(slice_indices) - 1))
+    return _slice_detail(volume_u8, lesion_mask, slice_indices[index])
+
+
+def imaging_upload_requirements_md() -> str:
+    return (
+        "#### Imaging package format\n"
+        "- Upload a `.zip` package generated by the RLDT ovarian imaging exporter.\n"
+        "- Each package contains one case, multiple timepoints, and preprocessed `.npz` imaging assets.\n"
+        "- Optional lesion masks are supported. If missing, the viewer falls back to a heuristic pelvic lesion candidate.\n"
+        "- This workspace is for **existing progression visualization only**; it does not run predictive modeling."
+    )

tools/build_tcga_ov_imaging_demo.py

@@ -0,0 +1,200 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import base64
+import json
+import shutil
+import zlib
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import SimpleITK as sitk
+from PIL import Image, ImageDraw
+from scipy import ndimage as ndi
+
+RAW_SEL = Path('/home/xqin5/3DTreatment/data/processed/tcga_ov/tcga_ov_series_selection.csv')
+OUT_ROOT = Path('/home/xqin5/RLDTALL/online/DT_hf_space/RL0910/demo_imaging_cases')
+PARTNER_OUT = Path('/home/xqin5/RLDTALL/online/ovarian_imaging_partner_test_data')
+PACKAGE_MAGIC = 'rldt_ov_imaging_package'
+DEMO_PATIENTS = ['TCGA-25-1633', 'TCGA-25-1328', 'TCGA-25-2393']
+MAX_TIMEPOINTS = 4
+TARGET_SHAPE = (80, 160, 160)  # z, y, x
+
+
+def read_series(series_dir: Path) -> tuple[np.ndarray, tuple[float, float, float]]:
+    reader = sitk.ImageSeriesReader()
+    ids = reader.GetGDCMSeriesIDs(str(series_dir))
+    if not ids:
+        raise FileNotFoundError(f'No DICOM series in {series_dir}')
+    files = reader.GetGDCMSeriesFileNames(str(series_dir), ids[0])
+    reader.SetFileNames(files)
+    image = reader.Execute()
+    arr = sitk.GetArrayFromImage(image).astype(np.int16)
+    spacing = image.GetSpacing()  # x, y, z
+    return arr, (float(spacing[2]), float(spacing[1]), float(spacing[0]))
+
+
+def resample_nn(arr: np.ndarray, out_shape: tuple[int, int, int], order: int) -> np.ndarray:
+    zoom = [o / i for o, i in zip(out_shape, arr.shape)]
+    return ndi.zoom(arr, zoom=zoom, order=order)
+
+
+def build_body_mask(volume_hu: np.ndarray) -> np.ndarray:
+    body = volume_hu > -350
+    labels, n = ndi.label(body)
+    if n <= 0:
+        return body
+    sizes = np.bincount(labels.ravel())
+    sizes[0] = 0
+    return labels == int(sizes.argmax())
+
+
+def heuristic_lesion_mask(volume_hu: np.ndarray, body_mask: np.ndarray) -> tuple[np.ndarray, np.ndarray, float, str]:
+    z_idx = np.where(body_mask.any(axis=(1, 2)))[0]
+    if len(z_idx) == 0:
+        center = np.array([volume_hu.shape[0] // 2, volume_hu.shape[1] // 2, volume_hu.shape[2] // 2], dtype=np.int16)
+        lesion = np.zeros_like(body_mask, dtype=np.uint8)
+        lesion[max(center[0]-3,0):center[0]+4, max(center[1]-10,0):center[1]+11, max(center[2]-10,0):center[2]+11] = 1
+        return lesion, center, 0.1, 'fallback_box'
+    z0 = int(np.percentile(z_idx, 60))
+    z1 = int(np.percentile(z_idx, 90))
+    proj = body_mask[z0:z1].max(axis=0)
+    yy, xx = np.where(proj)
+    cy = float(np.mean(yy)) if len(yy) else volume_hu.shape[1] / 2
+    cx = float(np.mean(xx)) if len(xx) else volume_hu.shape[2] / 2
+    H, W = volume_hu.shape[1:]
+    Y, X = np.ogrid[:H, :W]
+    central = ((Y - cy) ** 2 / (0.18 * H) ** 2 + (X - cx) ** 2 / (0.16 * W) ** 2) <= 1.0
+    roi = np.zeros_like(body_mask, dtype=bool)
+    roi[z0:z1] = central
+    candidate = (volume_hu > 145) & (volume_hu < 280) & body_mask & roi
+    candidate = ndi.binary_opening(candidate, structure=np.ones((1, 3, 3)))
+    candidate = ndi.binary_closing(candidate, structure=np.ones((1, 5, 5)))
+    labels, n = ndi.label(candidate)
+    best_mask = None
+    best_score = -1.0
+    center = np.array([int((z0 + z1) / 2), int(cy), int(cx)], dtype=np.int16)
+    if n > 0:
+        coords_center = center.astype(float)
+        for idx in range(1, n + 1):
+            comp = labels == idx
+            vox = int(comp.sum())
+            if vox < 200:
+                continue
+            pts = np.argwhere(comp)
+            centroid = pts.mean(axis=0)
+            dist = float(np.linalg.norm((centroid - coords_center) / np.array([8.0, 18.0, 18.0])))
+            score = vox / (1.0 + dist * 10.0)
+            if score > best_score:
+                best_score = score
+                best_mask = comp
+                center = centroid.astype(np.int16)
+    if best_mask is None:
+        best_mask = np.zeros_like(body_mask, dtype=bool)
+        cz, cyi, cxi = [int(v) for v in center]
+        rz, ry, rx = 4, 12, 12
+        Z, Yg, Xg = np.ogrid[:volume_hu.shape[0], :volume_hu.shape[1], :volume_hu.shape[2]]
+        ell = ((Z-cz)**2/rz**2 + (Yg-cyi)**2/ry**2 + (Xg-cxi)**2/rx**2) <= 1.0
+        best_mask = ell & body_mask
+        confidence = 0.22
+        source = 'heuristic_ellipsoid'
+    else:
+        confidence = 0.42
+        source = 'heuristic_component'
+    return best_mask.astype(np.uint8), center.astype(np.int16), confidence, source
+
+
+def normalize_to_u8(volume_hu: np.ndarray) -> np.ndarray:
+    windowed = np.clip(volume_hu, -150, 250)
+    scaled = ((windowed + 150.0) / 400.0) * 255.0
+    return scaled.astype(np.uint8)
+
+
+def sample_timepoints(df: pd.DataFrame) -> pd.DataFrame:
+    df = df.sort_values(['relative_time', 'Number of Images'], ascending=[True, False]).drop_duplicates('timepoint')
+    if len(df) <= MAX_TIMEPOINTS:
+        return df
+    idxs = np.linspace(0, len(df) - 1, MAX_TIMEPOINTS, dtype=int)
+    return df.iloc[idxs]
+
+
+def build_case(case_df: pd.DataFrame, case_root: Path) -> dict:
+    case_root.mkdir(parents=True, exist_ok=True)
+    manifest = {
+        'format': PACKAGE_MAGIC,
+        'version': 1,
+        'case_id': case_df.iloc[0]['patient_id'],
+        'patient_id': case_df.iloc[0]['patient_id'],
+        'display_name': f"TCGA-OV {case_df.iloc[0]['patient_id']}",
+        'modality': 'CT',
+        'summary_note': 'Existing progression visualization built from preprocessed TCGA-OV CT series. Lesion highlighting is heuristic when no label is available.',
+        'timepoints': [],
+    }
+    for tp_idx, (_, row) in enumerate(case_df.iterrows(), start=1):
+        volume_hu, spacing_zyx = read_series(Path(row['image_path']))
+        body = build_body_mask(volume_hu)
+        volume_hu_small = resample_nn(volume_hu, TARGET_SHAPE, order=1).astype(np.int16)
+        body_small = resample_nn(body.astype(np.uint8), TARGET_SHAPE, order=0) > 0
+        lesion_mask, roi_center, confidence, source = heuristic_lesion_mask(volume_hu_small, body_small)
+        volume_u8 = normalize_to_u8(volume_hu_small)
+        asset_name = f'tp_{tp_idx:02d}.json'
+        payload = {
+            'shape': list(volume_u8.shape),
+            'roi_center_zyx': [int(v) for v in roi_center.tolist()],
+            'volume_u8_b85': base64.b85encode(zlib.compress(volume_u8.tobytes(), level=9)).decode('ascii'),
+            'lesion_mask_b85': base64.b85encode(zlib.compress(lesion_mask.astype(np.uint8).tobytes(), level=9)).decode('ascii'),
+        }
+        (case_root / asset_name).write_text(json.dumps(payload), encoding='utf-8')
+        manifest['timepoints'].append({
+            'timepoint_id': f't{tp_idx:02d}',
+            'label': str(row['timepoint']),
+            'relative_time': float(row['relative_time']),
+            'asset_path': asset_name,
+            'series_description': str(row['Series Description']),
+            'num_slices_original': int(row['Number of Images']),
+            'spacing_zyx_mm': [float(v) for v in spacing_zyx],
+            'lesion_confidence': float(confidence),
+            'lesion_source': source,
+            'lesion_voxel_count': int(lesion_mask.sum()),
+        })
+    (case_root / 'manifest.json').write_text(json.dumps(manifest, indent=2), encoding='utf-8')
+    return manifest
+
+
+def main() -> None:
+    OUT_ROOT.mkdir(parents=True, exist_ok=True)
+    (OUT_ROOT / 'cases').mkdir(parents=True, exist_ok=True)
+    PARTNER_OUT.mkdir(parents=True, exist_ok=True)
+    sel = pd.read_csv(RAW_SEL)
+    root_manifest = {'format': PACKAGE_MAGIC, 'version': 1, 'cases': []}
+    built_case_dirs = []
+    for pid in DEMO_PATIENTS:
+        case_df = sample_timepoints(sel[sel['patient_id'] == pid])
+        case_root = OUT_ROOT / 'cases' / pid
+        if case_root.exists():
+            shutil.rmtree(case_root)
+        case_manifest = build_case(case_df, case_root)
+        built_case_dirs.append(case_root)
+        root_manifest['cases'].append({
+            'case_id': pid,
+            'display_name': case_manifest['display_name'],
+            'timepoint_count': len(case_manifest['timepoints']),
+        })
+        partner_zip = PARTNER_OUT / f'{pid}_ovarian_imaging_package.zip'
+        if partner_zip.exists():
+            partner_zip.unlink()
+        shutil.make_archive(str(partner_zip.with_suffix('')), 'zip', root_dir=case_root)
+    (OUT_ROOT / 'manifest.json').write_text(json.dumps(root_manifest, indent=2), encoding='utf-8')
+    readme = PARTNER_OUT / 'README.txt'
+    readme.write_text(
+        'RLDT ovarian imaging upload package\n\n'
+        '- Upload one .zip package at a time in the Space imaging viewer.\n'
+        '- Package format is preprocessed multi-timepoint CT for visualization only.\n'
+        '- If no lesion mask exists, the viewer uses a heuristic pelvic lesion candidate overlay.\n',
+        encoding='utf-8',
+    )
+
+
+if __name__ == '__main__':
+    main()