Initial commit: MONAI WholeBody CT Segmentation Space

.gitattributes

@@ -0,0 +1 @@
+*.nii.gz filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,80 @@
+---
+title: MONAI WholeBody CT Segmentation
+emoji: 🏥
+colorFrom: blue
+colorTo: green
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
+pinned: false
+license: apache-2.0
+tags:
+  - medical-imaging
+  - segmentation
+  - ct-scan
+  - monai
+  - 3d-segmentation
+---
+
+# 🏥 MONAI WholeBody CT Segmentation
+
+**Automatic 3D segmentation of 104 anatomical structures from CT scans**
+
+## Overview
+
+This application uses MONAI's pre-trained **SegResNet** model trained on the [TotalSegmentator](https://github.com/wasserth/TotalSegmentator) dataset to automatically segment 104 different anatomical structures from whole-body CT scans.
+
+## Features
+
+- 🔬 **104 Anatomical Structures**: Segments organs, bones, muscles, and vessels
+- 📊 **Interactive Visualization**: Navigate through axial, coronal, and sagittal views
+- 🎨 **Color-coded Overlay**: Each structure has a distinct color for easy identification
+- ⚡ **GPU Accelerated**: Uses CUDA when available for faster inference
+
+## Supported Structures
+
+| Category | Structures |
+|----------|------------|
+| **Major Organs** | Liver, Spleen, Kidneys, Pancreas, Gallbladder, Stomach, Bladder |
+| **Cardiovascular** | Heart (4 chambers), Aorta, Vena Cava, Portal Vein, Iliac vessels |
+| **Respiratory** | Lung lobes (5), Trachea, Esophagus |
+| **Skeletal** | Vertebrae (C1-L5), 24 Ribs, Hip bones, Femur, Humerus, Scapula, Clavicle |
+| **Muscles** | Gluteal muscles, Iliopsoas, Autochthon |
+| **Other** | Brain, Face, Adrenal glands, Small/Large bowel |
+
+## Usage
+
+1. **Upload** a CT scan in NIfTI format (`.nii` or `.nii.gz`)
+2. Click **Run Segmentation** and wait for processing (1-5 minutes)
+3. **Explore** the results using the slice sliders and view controls
+4. Check the **Detected Structures** panel to see all identified anatomy
+
+## Model Details
+
+- **Architecture**: SegResNet (MONAI)
+- **Resolution**: 3.0mm isotropic (low-resolution model)
+- **Training Data**: TotalSegmentator dataset
+- **Output**: 105 channels (background + 104 structures)
+
+## References
+
+- [MONAI Model Zoo](https://monai.io/model-zoo.html)
+- [TotalSegmentator Paper](https://pubs.rsna.org/doi/10.1148/ryai.230024)
+- [TotalSegmentator GitHub](https://github.com/wasserth/TotalSegmentator)
+
+## License
+
+This model is released under the Apache 2.0 License. The TotalSegmentator dataset is released under CC BY 4.0.
+
+## Citation
+
+If you use this model, please cite:
+
+```bibtex
+@article{wasserthal2023totalsegmentator,
+  title={TotalSegmentator: robust segmentation of 104 anatomical structures in CT images},
+  author={Wasserthal, Jakob and others},
+  journal={Radiology: Artificial Intelligence},
+  year={2023}
+}
+```

app.py

@@ -0,0 +1,412 @@
+"""
+MONAI WholeBody CT Segmentation - Hugging Face Space
+Segments 104 anatomical structures from CT scans using MONAI's SegResNet model
+"""
+
+import os
+import tempfile
+import numpy as np
+import gradio as gr
+import torch
+import nibabel as nib
+import matplotlib.pyplot as plt
+from matplotlib.colors import ListedColormap
+from huggingface_hub import hf_hub_download
+from monai.networks.nets import SegResNet
+from monai.transforms import (
+    Compose,
+    LoadImage,
+    EnsureChannelFirst,
+    Orientation,
+    Spacing,
+    ScaleIntensityRange,
+    CropForeground,
+    Activations,
+    AsDiscrete,
+)
+from monai.inferers import sliding_window_inference
+from labels import LABEL_NAMES, get_color_map, get_label_name, get_organ_categories
+
+# Constants
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+MODEL_REPO = "MONAI/wholeBody_ct_segmentation"
+SPATIAL_SIZE = (96, 96, 96)
+PIXDIM = (3.0, 3.0, 3.0)  # Low-res model spacing
+
+# Global model variable
+model = None
+
+
+def load_model():
+    """Download and load the MONAI SegResNet model"""
+    global model
+    if model is not None:
+        return model
+    
+    print("Downloading model weights...")
+    try:
+        model_path = hf_hub_download(
+            repo_id=MODEL_REPO,
+            filename="models/model_lowres.pt",
+        )
+    except Exception as e:
+        print(f"Failed to download from HF, trying alternative: {e}")
+        # Fallback: try to download from MONAI model zoo
+        model_path = hf_hub_download(
+            repo_id=MODEL_REPO,
+            filename="models/model.pt",
+        )
+    
+    print(f"Loading model from {model_path}...")
+    
+    # Initialize SegResNet with 105 output channels (background + 104 classes)
+    model = SegResNet(
+        blocks_down=[1, 2, 2, 4],
+        blocks_up=[1, 1, 1],
+        init_filters=16,
+        in_channels=1,
+        out_channels=105,
+        dropout_prob=0.2,
+    )
+    
+    # Load weights
+    checkpoint = torch.load(model_path, map_location=DEVICE)
+    if isinstance(checkpoint, dict) and "state_dict" in checkpoint:
+        model.load_state_dict(checkpoint["state_dict"])
+    else:
+        model.load_state_dict(checkpoint)
+    
+    model.to(DEVICE)
+    model.eval()
+    print(f"Model loaded successfully on {DEVICE}")
+    
+    return model
+
+
+def get_preprocessing_transforms():
+    """Get MONAI preprocessing transforms"""
+    return Compose([
+        LoadImage(image_only=True),
+        EnsureChannelFirst(),
+        Orientation(axcodes="RAS"),
+        Spacing(pixdim=PIXDIM, mode="bilinear"),
+        ScaleIntensityRange(
+            a_min=-1024, a_max=1024,
+            b_min=0.0, b_max=1.0,
+            clip=True
+        ),
+    ])
+
+
+def get_postprocessing_transforms():
+    """Get MONAI postprocessing transforms"""
+    return Compose([
+        Activations(softmax=True),
+        AsDiscrete(argmax=True),
+    ])
+
+
+def run_inference(image_path: str, progress=gr.Progress()):
+    """Run segmentation inference on a CT image"""
+    progress(0.1, desc="Loading model...")
+    model = load_model()
+    
+    progress(0.2, desc="Preprocessing image...")
+    preprocess = get_preprocessing_transforms()
+    postprocess = get_postprocessing_transforms()
+    
+    # Load and preprocess
+    image = preprocess(image_path)
+    image = image.unsqueeze(0).to(DEVICE)  # Add batch dimension
+    
+    progress(0.4, desc="Running segmentation (this may take a few minutes)...")
+    
+    with torch.no_grad():
+        # Use sliding window inference for large volumes
+        outputs = sliding_window_inference(
+            image,
+            roi_size=SPATIAL_SIZE,
+            sw_batch_size=4,
+            predictor=model,
+            overlap=0.5,
+        )
+    
+    progress(0.8, desc="Post-processing...")
+    
+    # Post-process
+    outputs = postprocess(outputs)
+    segmentation = outputs.squeeze().cpu().numpy().astype(np.uint8)
+    
+    # Load original image for visualization
+    original_nib = nib.load(image_path)
+    original_data = original_nib.get_fdata()
+    
+    progress(1.0, desc="Complete!")
+    
+    return original_data, segmentation
+
+
+def create_slice_visualization(ct_data, seg_data, axis, slice_idx, alpha=0.5, show_overlay=True):
+    """Create a visualization of a CT slice with segmentation overlay"""
+    
+    # Get the slice based on axis
+    if axis == "Axial":
+        ct_slice = ct_data[:, :, slice_idx]
+        seg_slice = seg_data[:, :, slice_idx] if seg_data is not None else None
+    elif axis == "Coronal":
+        ct_slice = ct_data[:, slice_idx, :]
+        seg_slice = seg_data[:, slice_idx, :] if seg_data is not None else None
+    else:  # Sagittal
+        ct_slice = ct_data[slice_idx, :, :]
+        seg_slice = seg_data[slice_idx, :, :] if seg_data is not None else None
+    
+    # Create figure
+    fig, ax = plt.subplots(1, 1, figsize=(8, 8))
+    
+    # Normalize CT for display
+    ct_normalized = np.clip(ct_slice, -1024, 1024)
+    ct_normalized = (ct_normalized - ct_normalized.min()) / (ct_normalized.max() - ct_normalized.min() + 1e-8)
+    
+    # Display CT
+    ax.imshow(ct_normalized.T, cmap='gray', origin='lower')
+    
+    # Overlay segmentation
+    if show_overlay and seg_slice is not None and np.any(seg_slice > 0):
+        colors = get_color_map() / 255.0
+        colors[0] = [0, 0, 0, 0]  # Make background transparent
+        
+        # Create RGBA overlay
+        seg_rgba = colors[seg_slice.astype(int)]
+        seg_rgba = np.concatenate([seg_rgba, np.ones((*seg_slice.shape, 1)) * alpha], axis=-1)
+        seg_rgba[seg_slice == 0, 3] = 0  # Transparent background
+        
+        ax.imshow(seg_rgba.transpose(1, 0, 2), origin='lower')
+    
+    ax.axis('off')
+    ax.set_title(f"{axis} View - Slice {slice_idx}")
+    
+    plt.tight_layout()
+    return fig
+
+
+def get_detected_structures(seg_data):
+    """Get list of detected anatomical structures"""
+    unique_labels = np.unique(seg_data)
+    unique_labels = unique_labels[unique_labels > 0]  # Exclude background
+    
+    structures = []
+    for label in unique_labels:
+        name = get_label_name(label)
+        count = np.sum(seg_data == label)
+        structures.append(f"• {name} (Label {label})")
+    
+    return "\n".join(structures) if structures else "No structures detected"
+
+
+# Global state for current visualization
+current_ct_data = None
+current_seg_data = None
+
+
+def process_upload(file_path, progress=gr.Progress()):
+    """Process uploaded CT file and run segmentation"""
+    global current_ct_data, current_seg_data
+    
+    if file_path is None:
+        return None, "Please upload a NIfTI file", gr.update(maximum=1), gr.update(maximum=1), gr.update(maximum=1)
+    
+    try:
+        ct_data, seg_data = run_inference(file_path, progress)
+        current_ct_data = ct_data
+        current_seg_data = seg_data
+        
+        # Get initial visualization
+        mid_axial = ct_data.shape[2] // 2
+        mid_coronal = ct_data.shape[1] // 2
+        mid_sagittal = ct_data.shape[0] // 2
+        
+        fig = create_slice_visualization(ct_data, seg_data, "Axial", mid_axial)
+        structures = get_detected_structures(seg_data)
+        
+        return (
+            fig,
+            structures,
+            gr.update(maximum=ct_data.shape[2] - 1, value=mid_axial),
+            gr.update(maximum=ct_data.shape[1] - 1, value=mid_coronal),
+            gr.update(maximum=ct_data.shape[0] - 1, value=mid_sagittal),
+        )
+    except Exception as e:
+        return None, f"Error processing file: {str(e)}", gr.update(), gr.update(), gr.update()
+
+
+def update_visualization(axis, slice_idx, alpha, show_overlay):
+    """Update the visualization based on slider changes"""
+    global current_ct_data, current_seg_data
+    
+    if current_ct_data is None:
+        return None
+    
+    fig = create_slice_visualization(
+        current_ct_data,
+        current_seg_data,
+        axis,
+        int(slice_idx),
+        alpha,
+        show_overlay
+    )
+    return fig
+
+
+def load_example(example_name):
+    """Load a bundled example CT scan"""
+    example_dir = os.path.join(os.path.dirname(__file__), "examples")
+    example_path = os.path.join(example_dir, example_name)
+    
+    if os.path.exists(example_path):
+        return example_path
+    return None
+
+
+# Create Gradio interface
+with gr.Blocks(
+    title="MONAI WholeBody CT Segmentation",
+    theme=gr.themes.Soft(),
+    css="""
+    .gradio-container {max-width: 1200px !important}
+    .output-image {min-height: 500px}
+    """
+) as demo:
+    gr.Markdown("""
+    # 🏥 MONAI WholeBody CT Segmentation
+    
+    **Automatic segmentation of 104 anatomical structures from CT scans**
+    
+    This application uses MONAI's pre-trained SegResNet model trained on the TotalSegmentator dataset.
+    Upload a CT scan in NIfTI format (.nii or .nii.gz) to get started.
+    
+    > ⚡ **Note**: Processing may take 1-5 minutes depending on the CT volume size.
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            # Input section
+            gr.Markdown("### 📤 Upload CT Scan")
+            file_input = gr.File(
+                label="Upload NIfTI file (.nii, .nii.gz)",
+                file_types=[".nii", ".nii.gz", ".gz"],
+                type="filepath"
+            )
+            
+            # Example files
+            gr.Markdown("### 📁 Example Files")
+            example_gallery = gr.Examples(
+                examples=[
+                    ["examples/sample_ct_chest.nii.gz"],
+                    ["examples/sample_ct_abdomen.nii.gz"],
+                ],
+                inputs=[file_input],
+                label="Click to load example"
+            )
+            
+            process_btn = gr.Button("🔬 Run Segmentation", variant="primary", size="lg")
+            
+            # Visualization controls
+            gr.Markdown("### 🎛️ Visualization Controls")
+            
+            view_axis = gr.Radio(
+                choices=["Axial", "Coronal", "Sagittal"],
+                value="Axial",
+                label="View Axis"
+            )
+            
+            with gr.Row():
+                axial_slider = gr.Slider(0, 100, value=50, step=1, label="Axial Slice")
+                coronal_slider = gr.Slider(0, 100, value=50, step=1, label="Coronal Slice")
+                sagittal_slider = gr.Slider(0, 100, value=50, step=1, label="Sagittal Slice")
+            
+            alpha_slider = gr.Slider(0, 1, value=0.5, step=0.1, label="Overlay Opacity")
+            show_overlay = gr.Checkbox(value=True, label="Show Segmentation Overlay")
+            
+        with gr.Column(scale=2):
+            # Output section
+            gr.Markdown("### 🖼️ Segmentation Result")
+            output_image = gr.Plot(label="CT with Segmentation Overlay")
+            
+            gr.Markdown("### 📋 Detected Structures")
+            structures_output = gr.Textbox(
+                label="Anatomical Structures Found",
+                lines=10,
+                max_lines=20
+            )
+    
+    # Model info section
+    with gr.Accordion("ℹ️ Model Information", open=False):
+        gr.Markdown("""
+        ### About the Model
+        
+        This model is based on **SegResNet** architecture from MONAI, trained on the **TotalSegmentator** dataset.
+        
+        **Capabilities:**
+        - Segments 104 distinct anatomical structures
+        - Works on whole-body CT scans
+        - Uses 3.0mm isotropic spacing (low-resolution model for faster inference)
+        
+        **Segmented Structures include:**
+        - **Major Organs**: Liver, Spleen, Kidneys, Pancreas, Gallbladder, Stomach, Bladder
+        - **Cardiovascular**: Heart chambers, Aorta, Vena Cava, Portal Vein
+        - **Respiratory**: Lung lobes, Trachea
+        - **Skeletal**: Vertebrae (C1-L5), Ribs, Hip bones, Femur, Humerus, Scapula
+        - **Muscles**: Gluteal muscles, Iliopsoas
+        - And many more...
+        
+        **References:**
+        - [MONAI Model Zoo](https://monai.io/model-zoo.html)
+        - [TotalSegmentator Paper](https://pubs.rsna.org/doi/10.1148/ryai.230024)
+        """)
+    
+    # Event handlers
+    process_btn.click(
+        fn=process_upload,
+        inputs=[file_input],
+        outputs=[output_image, structures_output, axial_slider, coronal_slider, sagittal_slider]
+    )
+    
+    # Update visualization when controls change
+    for control in [view_axis, alpha_slider, show_overlay]:
+        control.change(
+            fn=lambda axis, alpha, overlay, ax_s, cor_s, sag_s: update_visualization(
+                axis,
+                ax_s if axis == "Axial" else (cor_s if axis == "Coronal" else sag_s),
+                alpha,
+                overlay
+            ),
+            inputs=[view_axis, alpha_slider, show_overlay, axial_slider, coronal_slider, sagittal_slider],
+            outputs=[output_image]
+        )
+    
+    # Update when sliders change
+    axial_slider.change(
+        fn=lambda s, alpha, overlay: update_visualization("Axial", s, alpha, overlay),
+        inputs=[axial_slider, alpha_slider, show_overlay],
+        outputs=[output_image]
+    )
+    
+    coronal_slider.change(
+        fn=lambda s, alpha, overlay: update_visualization("Coronal", s, alpha, overlay),
+        inputs=[coronal_slider, alpha_slider, show_overlay],
+        outputs=[output_image]
+    )
+    
+    sagittal_slider.change(
+        fn=lambda s, alpha, overlay: update_visualization("Sagittal", s, alpha, overlay),
+        inputs=[sagittal_slider, alpha_slider, show_overlay],
+        outputs=[output_image]
+    )
+
+
+if __name__ == "__main__":
+    # Ensure examples directory exists
+    os.makedirs("examples", exist_ok=True)
+    
+    # Launch the app
+    demo.launch()

create_samples.py

@@ -0,0 +1,124 @@
+"""
+Create synthetic CT phantom samples for HuggingFace Space demo
+"""
+import numpy as np
+import nibabel as nib
+import os
+
+def create_synthetic_samples():
+    examples_dir = 'examples'
+    os.makedirs(examples_dir, exist_ok=True)
+    
+    np.random.seed(42)
+    
+    # Sample 1: Chest phantom
+    print('Creating sample_ct_chest.nii.gz...')
+    shape = (192, 192, 128)
+    data = np.ones(shape, dtype=np.float32) * -1000  # Air background
+    
+    cx, cy, cz = shape[0]//2, shape[1]//2, shape[2]//2
+    
+    # Create coordinate grids
+    X, Y, Z = np.meshgrid(
+        np.arange(shape[0]) - cx,
+        np.arange(shape[1]) - cy,
+        np.arange(shape[2]) - cz,
+        indexing='ij'
+    )
+    
+    # Body contour (ellipsoid)
+    body = (X**2 / 70**2 + Y**2 / 50**2 + Z**2 / 55**2) < 1
+    data[body] = 40 + np.random.randn(*shape)[body] * 30
+    
+    # Spine
+    spine = (X**2 + (Y + 35)**2) < 100
+    data[spine] = 400 + np.random.randn(*shape)[spine] * 50
+    
+    # Liver
+    liver = ((X - 30)**2 / 25**2 + (Y + 10)**2 / 30**2 + (Z + 20)**2 / 35**2) < 1
+    data[liver] = 60 + np.random.randn(*shape)[liver] * 15
+    
+    # Lungs
+    lung_l = ((X + 25)**2 / 20**2 + (Y - 20)**2 / 25**2 + Z**2 / 40**2) < 1
+    lung_r = ((X - 25)**2 / 20**2 + (Y - 20)**2 / 25**2 + Z**2 / 40**2) < 1
+    data[lung_l | lung_r] = -700 + np.random.randn(*shape)[lung_l | lung_r] * 100
+    
+    # Heart
+    heart = (X**2 / 20**2 + (Y - 10)**2 / 18**2 + (Z + 10)**2 / 25**2) < 1
+    data[heart] = 50 + np.random.randn(*shape)[heart] * 20
+    
+    # Kidneys
+    kidney_l = ((X + 35)**2 / 8**2 + (Y + 15)**2 / 12**2 + (Z + 10)**2 / 18**2) < 1
+    kidney_r = ((X - 35)**2 / 8**2 + (Y + 15)**2 / 12**2 + (Z + 10)**2 / 18**2) < 1
+    data[kidney_l | kidney_r] = 30 + np.random.randn(*shape)[kidney_l | kidney_r] * 10
+    
+    # Ribs
+    for i in range(-5, 6):
+        rib_z = i * 10
+        rib_mask = ((X - 45)**2 + (Y - 15)**2 < 20) & (np.abs(Z - rib_z) < 3)
+        data[rib_mask] = 350 + np.random.randn(*shape)[rib_mask] * 40
+        rib_mask = ((X + 45)**2 + (Y - 15)**2 < 20) & (np.abs(Z - rib_z) < 3)
+        data[rib_mask] = 350 + np.random.randn(*shape)[rib_mask] * 40
+    
+    affine = np.diag([1.5, 1.5, 1.5, 1.0])
+    img = nib.Nifti1Image(data.astype(np.int16), affine)
+    nib.save(img, os.path.join(examples_dir, 'sample_ct_chest.nii.gz'))
+    print('  ✓ Created sample_ct_chest.nii.gz')
+    
+    # Sample 2: Abdomen phantom
+    print('Creating sample_ct_abdomen.nii.gz...')
+    shape2 = (160, 160, 96)
+    data2 = np.ones(shape2, dtype=np.float32) * -1000
+    
+    cx2, cy2, cz2 = shape2[0]//2, shape2[1]//2, shape2[2]//2
+    
+    X2, Y2, Z2 = np.meshgrid(
+        np.arange(shape2[0]) - cx2,
+        np.arange(shape2[1]) - cy2,
+        np.arange(shape2[2]) - cz2,
+        indexing='ij'
+    )
+    
+    # Body
+    body2 = (X2**2 / 60**2 + Y2**2 / 45**2) < 1
+    data2[body2] = 35 + np.random.randn(*shape2)[body2] * 25
+    
+    # Spine
+    spine2 = (X2**2 + (Y2 + 30)**2) < 80
+    data2[spine2] = 380 + np.random.randn(*shape2)[spine2] * 45
+    
+    # Liver
+    liver2 = ((X2 - 25)**2 / 30**2 + (Y2 + 5)**2 / 28**2 + (Z2 + 15)**2 / 30**2) < 1
+    data2[liver2] = 55 + np.random.randn(*shape2)[liver2] * 12
+    
+    # Spleen
+    spleen = ((X2 + 35)**2 / 15**2 + (Y2 + 10)**2 / 18**2 + (Z2 + 5)**2 / 20**2) < 1
+    data2[spleen] = 45 + np.random.randn(*shape2)[spleen] * 10
+    
+    # Kidneys
+    kidney_l2 = ((X2 + 28)**2 / 10**2 + (Y2 + 12)**2 / 14**2 + Z2**2 / 18**2) < 1
+    kidney_r2 = ((X2 - 28)**2 / 10**2 + (Y2 + 12)**2 / 14**2 + Z2**2 / 18**2) < 1
+    data2[kidney_l2 | kidney_r2] = 32 + np.random.randn(*shape2)[kidney_l2 | kidney_r2] * 8
+    
+    # Pancreas
+    pancreas = (X2**2 / 25**2 + (Y2 + 8)**2 / 6**2 + (Z2 - 5)**2 / 10**2) < 1
+    data2[pancreas] = 40 + np.random.randn(*shape2)[pancreas] * 10
+    
+    # Aorta
+    aorta = (X2**2 + (Y2 + 20)**2) < 36
+    data2[aorta] = 120 + np.random.randn(*shape2)[aorta] * 25
+    
+    # Stomach
+    stomach = ((X2 + 10)**2 / 20**2 + (Y2 - 5)**2 / 15**2 + (Z2 + 25)**2 / 18**2) < 1
+    data2[stomach] = -50 + np.random.randn(*shape2)[stomach] * 30
+    
+    affine2 = np.diag([2.0, 2.0, 2.0, 1.0])
+    img2 = nib.Nifti1Image(data2.astype(np.int16), affine2)
+    nib.save(img2, os.path.join(examples_dir, 'sample_ct_abdomen.nii.gz'))
+    print('  ✓ Created sample_ct_abdomen.nii.gz')
+    
+    print('\nDone! Synthetic CT samples created.')
+    return ['sample_ct_chest.nii.gz', 'sample_ct_abdomen.nii.gz']
+
+if __name__ == '__main__':
+    create_synthetic_samples()

download_samples.py

@@ -0,0 +1,167 @@
+"""
+Download sample CT scans for the Hugging Face Space demo.
+Uses publicly available data from Zenodo (TotalSegmentator sample subset).
+"""
+
+import os
+import urllib.request
+import zipfile
+import shutil
+import gzip
+
+# Sample CT scans from public sources
+SAMPLE_URLS = [
+    # TotalSegmentator sample from Zenodo (small sample subset)
+    {
+        "url": "https://zenodo.org/records/10047292/files/Totalsegmentator_dataset_small_v201.zip?download=1",
+        "filename": "ts_sample.zip",
+        "type": "zip",
+        "description": "TotalSegmentator sample dataset (102 subjects)"
+    }
+]
+
+# Alternative: Direct links to individual sample scans from open datasets
+DIRECT_SAMPLES = [
+    # These would be actual CT scan URLs if available
+    # For now, we'll create a placeholder that downloads on first run
+]
+
+
+def download_file(url: str, dest_path: str, description: str = ""):
+    """Download a file with progress indication"""
+    print(f"Downloading {description}...")
+    print(f"  URL: {url}")
+    print(f"  Destination: {dest_path}")
+    
+    try:
+        urllib.request.urlretrieve(url, dest_path)
+        print(f"  ✓ Downloaded successfully")
+        return True
+    except Exception as e:
+        print(f"  ✗ Failed: {e}")
+        return False
+
+
+def extract_sample_from_zip(zip_path: str, examples_dir: str, max_samples: int = 2):
+    """Extract a few sample CT scans from the dataset zip"""
+    print(f"Extracting samples from {zip_path}...")
+    
+    with zipfile.ZipFile(zip_path, 'r') as zf:
+        # List all files to find CT scans
+        all_files = zf.namelist()
+        
+        # Find .nii.gz files (CT images)
+        ct_files = [f for f in all_files if f.endswith('.nii.gz') and 'ct.' in f.lower()]
+        
+        if not ct_files:
+            # Try alternative patterns
+            ct_files = [f for f in all_files if f.endswith('.nii.gz') and 'image' in f.lower()]
+        
+        if not ct_files:
+            # Just get any .nii.gz files
+            ct_files = [f for f in all_files if f.endswith('.nii.gz')][:max_samples * 2]
+        
+        # Extract a few samples
+        extracted = 0
+        for ct_file in ct_files[:max_samples]:
+            try:
+                # Extract to examples directory
+                output_name = f"sample_ct_{extracted + 1}.nii.gz"
+                output_path = os.path.join(examples_dir, output_name)
+                
+                # Extract the file
+                with zf.open(ct_file) as source:
+                    with open(output_path, 'wb') as target:
+                        target.write(source.read())
+                
+                print(f"  ✓ Extracted: {output_name}")
+                extracted += 1
+                
+                if extracted >= max_samples:
+                    break
+            except Exception as e:
+                print(f"  ✗ Failed to extract {ct_file}: {e}")
+    
+    return extracted
+
+
+def create_synthetic_sample(examples_dir: str):
+    """Create a small synthetic NIfTI file for testing"""
+    import numpy as np
+    import nibabel as nib
+    
+    print("Creating synthetic sample CT for testing...")
+    
+    # Create a simple 3D volume (small for demo)
+    shape = (128, 128, 64)
+    data = np.random.randn(*shape).astype(np.float32) * 100 - 500
+    
+    # Add some structure (spheres to simulate organs)
+    center = np.array(shape) // 2
+    
+    for i in range(3):
+        offset = np.array([20 * (i - 1), 0, 0])
+        pos = center + offset
+        x, y, z = np.ogrid[:shape[0], :shape[1], :shape[2]]
+        mask = ((x - pos[0])**2 + (y - pos[1])**2 + (z - pos[2])**2) < 400
+        data[mask] = 50 + i * 30  # Different intensities
+    
+    # Create NIfTI
+    affine = np.diag([3.0, 3.0, 3.0, 1.0])  # 3mm spacing
+    img = nib.Nifti1Image(data, affine)
+    
+    output_path = os.path.join(examples_dir, "sample_synthetic.nii.gz")
+    nib.save(img, output_path)
+    print(f"  ✓ Created: {output_path}")
+    
+    return output_path
+
+
+def setup_examples():
+    """Download and set up example CT scans"""
+    examples_dir = os.path.join(os.path.dirname(__file__), "examples")
+    os.makedirs(examples_dir, exist_ok=True)
+    
+    # Check if examples already exist
+    existing = [f for f in os.listdir(examples_dir) if f.endswith('.nii.gz')]
+    if len(existing) >= 2:
+        print(f"Examples already exist: {existing}")
+        return existing
+    
+    print("Setting up example CT scans...")
+    print("=" * 50)
+    
+    # Try to download from Zenodo
+    temp_dir = os.path.join(examples_dir, "temp")
+    os.makedirs(temp_dir, exist_ok=True)
+    
+    downloaded = False
+    for sample in SAMPLE_URLS:
+        zip_path = os.path.join(temp_dir, sample["filename"])
+        if download_file(sample["url"], zip_path, sample["description"]):
+            if sample["type"] == "zip":
+                extracted = extract_sample_from_zip(zip_path, examples_dir)
+                if extracted > 0:
+                    downloaded = True
+                    break
+    
+    # Clean up temp files
+    if os.path.exists(temp_dir):
+        shutil.rmtree(temp_dir)
+    
+    # If download failed, create synthetic sample
+    if not downloaded:
+        print("\nDownload failed, creating synthetic sample for testing...")
+        try:
+            create_synthetic_sample(examples_dir)
+        except ImportError:
+            print("  nibabel not available, skipping synthetic sample creation")
+    
+    # List final examples
+    final_examples = [f for f in os.listdir(examples_dir) if f.endswith('.nii.gz')]
+    print(f"\nFinal examples: {final_examples}")
+    return final_examples
+
+
+if __name__ == "__main__":
+    setup_examples()

examples/sample_ct_abdomen.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:529f536c2c150332ac1a6a190d155cf193ff7f7d14d5980879a27fc0a30a6ac1
+size 1078619

examples/sample_ct_chest.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e865ff9bc7929dfca1d81dc1c19ff3cadbb725740321e84fd3ad616951a1a3c5
+size 1237226

labels.py

@@ -0,0 +1,193 @@
+# 104 Anatomical Structure Labels for TotalSegmentator / MONAI wholeBody_ct_segmentation
+# Based on TotalSegmentator v1 class definitions
+
+LABEL_NAMES = {
+    0: "background",
+    1: "spleen",
+    2: "kidney_right",
+    3: "kidney_left",
+    4: "gallbladder",
+    5: "liver",
+    6: "stomach",
+    7: "aorta",
+    8: "inferior_vena_cava",
+    9: "portal_vein_and_splenic_vein",
+    10: "pancreas",
+    11: "adrenal_gland_right",
+    12: "adrenal_gland_left",
+    13: "lung_upper_lobe_left",
+    14: "lung_lower_lobe_left",
+    15: "lung_upper_lobe_right",
+    16: "lung_middle_lobe_right",
+    17: "lung_lower_lobe_right",
+    18: "vertebrae_L5",
+    19: "vertebrae_L4",
+    20: "vertebrae_L3",
+    21: "vertebrae_L2",
+    22: "vertebrae_L1",
+    23: "vertebrae_T12",
+    24: "vertebrae_T11",
+    25: "vertebrae_T10",
+    26: "vertebrae_T9",
+    27: "vertebrae_T8",
+    28: "vertebrae_T7",
+    29: "vertebrae_T6",
+    30: "vertebrae_T5",
+    31: "vertebrae_T4",
+    32: "vertebrae_T3",
+    33: "vertebrae_T2",
+    34: "vertebrae_T1",
+    35: "vertebrae_C7",
+    36: "vertebrae_C6",
+    37: "vertebrae_C5",
+    38: "vertebrae_C4",
+    39: "vertebrae_C3",
+    40: "vertebrae_C2",
+    41: "vertebrae_C1",
+    42: "esophagus",
+    43: "trachea",
+    44: "heart_myocardium",
+    45: "heart_atrium_left",
+    46: "heart_ventricle_left",
+    47: "heart_atrium_right",
+    48: "heart_ventricle_right",
+    49: "pulmonary_artery",
+    50: "brain",
+    51: "iliac_artery_left",
+    52: "iliac_artery_right",
+    53: "iliac_vena_left",
+    54: "iliac_vena_right",
+    55: "small_bowel",
+    56: "duodenum",
+    57: "colon",
+    58: "rib_left_1",
+    59: "rib_left_2",
+    60: "rib_left_3",
+    61: "rib_left_4",
+    62: "rib_left_5",
+    63: "rib_left_6",
+    64: "rib_left_7",
+    65: "rib_left_8",
+    66: "rib_left_9",
+    67: "rib_left_10",
+    68: "rib_left_11",
+    69: "rib_left_12",
+    70: "rib_right_1",
+    71: "rib_right_2",
+    72: "rib_right_3",
+    73: "rib_right_4",
+    74: "rib_right_5",
+    75: "rib_right_6",
+    76: "rib_right_7",
+    77: "rib_right_8",
+    78: "rib_right_9",
+    79: "rib_right_10",
+    80: "rib_right_11",
+    81: "rib_right_12",
+    82: "humerus_left",
+    83: "humerus_right",
+    84: "scapula_left",
+    85: "scapula_right",
+    86: "clavicula_left",
+    87: "clavicula_right",
+    88: "femur_left",
+    89: "femur_right",
+    90: "hip_left",
+    91: "hip_right",
+    92: "sacrum",
+    93: "face",
+    94: "gluteus_maximus_left",
+    95: "gluteus_maximus_right",
+    96: "gluteus_medius_left",
+    97: "gluteus_medius_right",
+    98: "gluteus_minimus_left",
+    99: "gluteus_minimus_right",
+    100: "autochthon_left",
+    101: "autochthon_right",
+    102: "iliopsoas_left",
+    103: "iliopsoas_right",
+    104: "urinary_bladder",
+}
+
+# Color map for visualization (RGB values)
+# Using a custom colormap for better visualization
+import numpy as np
+
+def get_color_map():
+    """Generate a color map for 105 classes (background + 104 structures)"""
+    np.random.seed(42)  # For reproducibility
+    colors = np.zeros((105, 3), dtype=np.uint8)
+    
+    # Background is black
+    colors[0] = [0, 0, 0]
+    
+    # Assign distinct colors to different organ categories
+    # Organs (1-12): Warm colors
+    organ_colors = [
+        [255, 99, 71],   # spleen - tomato
+        [255, 165, 0],   # kidney_right - orange
+        [255, 140, 0],   # kidney_left - dark orange
+        [50, 205, 50],   # gallbladder - lime green
+        [139, 69, 19],   # liver - saddle brown
+        [255, 192, 203], # stomach - pink
+        [220, 20, 60],   # aorta - crimson
+        [0, 0, 139],     # inferior_vena_cava - dark blue
+        [138, 43, 226],  # portal_vein_and_splenic_vein - blue violet
+        [255, 215, 0],   # pancreas - gold
+        [255, 255, 0],   # adrenal_gland_right - yellow
+        [255, 255, 0],   # adrenal_gland_left - yellow
+    ]
+    colors[1:13] = organ_colors
+    
+    # Lungs (13-17): Light blue shades
+    colors[13:18] = [[135, 206, 235], [100, 149, 237], [30, 144, 255], [0, 191, 255], [70, 130, 180]]
+    
+    # Vertebrae (18-41): Gradient from red to purple
+    for i in range(18, 42):
+        colors[i] = [200 - (i-18)*5, 100, 150 + (i-18)*3]
+    
+    # Other structures (42-57): Various colors
+    colors[42] = [255, 182, 193]  # esophagus
+    colors[43] = [176, 224, 230]  # trachea
+    colors[44:49] = [[220, 20, 60], [255, 105, 180], [255, 20, 147], [255, 182, 193], [199, 21, 133]]  # heart
+    colors[49] = [148, 0, 211]    # pulmonary_artery
+    colors[50] = [255, 218, 185]  # brain
+    colors[51:55] = [[178, 34, 34], [178, 34, 34], [70, 130, 180], [70, 130, 180]]  # iliac vessels
+    colors[55:58] = [[222, 184, 135], [210, 180, 140], [188, 143, 143]]  # bowels
+    
+    # Ribs (58-81): Bone color variations
+    for i in range(58, 82):
+        colors[i] = [255, 250, 205 + (i-58) % 50]
+    
+    # Bones (82-92): Gray/white shades
+    for i in range(82, 93):
+        colors[i] = [220 + (i-82)*2, 220 + (i-82)*2, 220]
+    
+    # Face and muscles (93-103): Skin and muscle tones
+    colors[93] = [255, 228, 196]  # face
+    for i in range(94, 104):
+        colors[i] = [205, 92, 92 + (i-94)*5]  # muscles - indian red variations
+    
+    # Bladder
+    colors[104] = [255, 255, 0]  # urinary_bladder - yellow
+    
+    return colors
+
+def get_label_name(label_id: int) -> str:
+    """Get human-readable name for a label ID"""
+    return LABEL_NAMES.get(label_id, f"unknown_{label_id}").replace("_", " ").title()
+
+def get_organ_categories():
+    """Group organs by category for UI display"""
+    return {
+        "Major Organs": [1, 2, 3, 4, 5, 6, 10, 104],
+        "Cardiovascular": [7, 8, 9, 44, 45, 46, 47, 48, 49, 51, 52, 53, 54],
+        "Respiratory": [13, 14, 15, 16, 17, 43],
+        "Digestive": [42, 55, 56, 57],
+        "Vertebrae": list(range(18, 42)),
+        "Ribs": list(range(58, 82)),
+        "Upper Body Bones": [82, 83, 84, 85, 86, 87],
+        "Lower Body Bones": [88, 89, 90, 91, 92],
+        "Muscles": list(range(94, 104)),
+        "Other": [11, 12, 50, 93],
+    }

requirements.txt

@@ -0,0 +1,9 @@
+monai[nibabel]>=1.3.0
+torch>=2.0.0
+gradio>=4.0.0
+nibabel>=5.0.0
+numpy
+matplotlib
+huggingface_hub
+scikit-image
+gdown