Complete NeuroSAM 3 app - use HF_TOKEN environment variable

README.md

@@ -1,7 +1,56 @@
 ---
-title: NeuroSAM3
-app_file: app.py
+title: NeuroSAM 3
+emoji: 🏥
+colorFrom: blue
+colorTo: purple
 sdk: gradio
-sdk_version: 6.0.2
-pinned: true
----
+sdk_version: 4.0.0
+app_file: app.py
+pinned: false
+license: apache-2.0
+---
+
+# NeuroSAM 3: Medical Image Segmentation
+
+A medical image segmentation application using SAM 3 (Segment Anything Model 3) for DICOM file analysis.
+
+## Features
+
+- 🧠 **SAM 3 Integration**: Uses the latest Segment Anything Model 3 for medical image segmentation
+- 📁 **DICOM Support**: Process CT and MRI DICOM files
+- 🎯 **Text Prompts**: Describe what you want to segment (e.g., "brain", "tumor", "skull")
+- ⚙️ **Windowing Strategies**: Optimized windowing presets for CT images
+- 🎨 **Visualization**: Overlay segmentation masks on medical images
+
+## Usage
+
+1. Upload a DICOM (.dcm) file
+2. Enter a text prompt describing what to segment
+3. Select the imaging modality (CT or MRI)
+4. Choose the windowing strategy (for CT images)
+5. Click "Segment Structure" to process
+
+## Requirements
+
+- Python 3.8+
+- PyTorch
+- Gradio
+- PyDICOM
+- Transformers (with SAM 3 support)
+
+## Model
+
+This app uses the SAM 3 model from Facebook/Meta. You need:
+- A Hugging Face account
+- Access token with read permissions for the SAM 3 model
+- Set `HF_TOKEN` environment variable in Space settings
+
+## Public Datasets
+
+- UniqueData/dicom-brain-dataset (Hugging Face) - MRI Brain scans
+- The Cancer Imaging Archive (TCIA) - Various medical imaging
+- Imaging Data Commons (IDC) - Large collection of DICOM files
+
+## License
+
+Apache 2.0

app.py

@@ -1,3 +1,8 @@
+"""
+NeuroSAM 3: Medical Image Segmentation App
+A Gradio app for segmenting medical images (CT/MRI) using SAM 3
+"""
+
 import os
 import tempfile
 import gradio as gr
@@ -8,97 +13,152 @@ from PIL import Image
 from transformers import Sam3Processor, Sam3Model
 import matplotlib.pyplot as plt
 
-def process_medical_image(dicom_file, prompt_text, modality, window_type, model, processor, device):
-    """
-    Process a DICOM medical image and perform segmentation using SAM 3.
-
-    Args:
-        dicom_file: Path to DICOM file (from Gradio File component)
-        prompt_text: Text prompt describing what to segment
-        modality: "CT" or "MRI"
-        window_type: Windowing strategy for CT images
-        model: The loaded SAM 3 model
-        processor: The loaded SAM 3 processor
-        device: The device (cpu/cuda) the model is on
+# Hugging Face Token (must be set as HF_TOKEN environment variable in Space settings)
+hf_token = os.getenv("HF_TOKEN")
+if not hf_token:
+    raise ValueError("HF_TOKEN environment variable is required. Please set it in Space settings.")
+
+# Login to Hugging Face Hub
+try:
+    from huggingface_hub import login
+    login(token=hf_token, add_to_git_credential=False)
+except Exception as e:
+    print(f"⚠️ Could not login to HF Hub (non-critical): {e}")
+
+# Load SAM 3 Model
+print("🧠 Loading SAM 3 Model...")
+device = "cuda" if torch.cuda.is_available() else "cpu"
+model = None
+processor = None
+
+try:
+    model = Sam3Model.from_pretrained("facebook/sam3", token=hf_token).to(device)
+    processor = Sam3Processor.from_pretrained("facebook/sam3", token=hf_token)
+    model.eval()
+    print("✅ Model Loaded Successfully!")
+except Exception as e:
+    print(f"⚠️ Model Load Warning: {e}")
+    print("Ensure you have the correct HuggingFace model name/identifier and access permissions.")
+
+# Create Sample DICOM File for Demo
+demo_dicom_path = "demo_brain_mri.dcm"
+demo_file_available = False
+
+try:
+    from pydicom.data import get_testdata_file
+    test_file = get_testdata_file("MR_small.dcm")
+    if test_file and os.path.exists(test_file):
+        import shutil
+        shutil.copy(test_file, demo_dicom_path)
+        demo_file_available = True
+        print(f"✅ Demo file ready: {demo_dicom_path}")
+except:
+    try:
+        # Create synthetic DICOM file
+        from pydicom.dataset import FileDataset, FileMetaDataset
+        from pydicom.uid import generate_uid
+        from datetime import datetime
+        
+        synthetic_image = np.random.randint(0, 255, (256, 256), dtype=np.uint16)
+        center_x, center_y = 128, 128
+        y, x = np.ogrid[:256, :256]
+        mask = (x - center_x)**2 + (y - center_y)**2 <= 100**2
+        synthetic_image[mask] = np.clip(synthetic_image[mask] + 50, 0, 255)
+        
+        file_meta = FileMetaDataset()
+        file_meta.MediaStorageSOPClassUID = '1.2.840.10008.5.1.4.1.1.4'
+        file_meta.MediaStorageSOPInstanceUID = generate_uid()
+        file_meta.TransferSyntaxUID = '1.2.840.10008.1.2.1'
+        
+        ds = FileDataset(demo_dicom_path, {}, file_meta=file_meta, preamble=b"\x00" * 128)
+        ds.PatientName = "Demo^Patient"
+        ds.PatientID = "DEMO001"
+        ds.Modality = "MR"
+        ds.Rows = 256
+        ds.Columns = 256
+        ds.BitsAllocated = 16
+        ds.BitsStored = 16
+        ds.HighBit = 15
+        ds.SamplesPerPixel = 1
+        ds.PixelRepresentation = 0
+        ds.PhotometricInterpretation = "MONOCHROME2"
+        ds.PixelSpacing = [1.0, 1.0]
+        ds.RescaleIntercept = "0"
+        ds.RescaleSlope = "1"
+        ds.PixelData = synthetic_image.tobytes()
+        
+        ds.save_as(demo_dicom_path, write_like_original=False)
+        demo_file_available = True
+        print(f"✅ Synthetic demo file created: {demo_dicom_path}")
+    except Exception as e:
+        print(f"⚠️ Could not create demo file: {e}")
 
-    Returns:
-        Path to output image with segmentation overlay, or None on error
-    """
-    # Check if model is loaded
+def process_medical_image(dicom_file, prompt_text, modality, window_type):
+    """Process a DICOM medical image and perform segmentation using SAM 3."""
     if model is None or processor is None:
-        print("❌ Error: Model not loaded. Please check the model loading section.")
+        print("❌ Error: Model not loaded.")
         return None
-
-    # Validate inputs
+    
     if dicom_file is None:
         return None
-
+    
     if not prompt_text or not prompt_text.strip():
-        print("⚠️ Warning: Empty prompt text. Using default 'brain'.")
         prompt_text = "brain"
-
+    
     try:
-        # --- A. Read DICOM ---
-        # Gradio File component returns a file path string
         dicom_path = dicom_file if isinstance(dicom_file, str) else str(dicom_file)
-
+        
         if not os.path.exists(dicom_path):
             print(f"❌ Error: DICOM file not found at {dicom_path}")
             return None
-
+        
         ds = pydicom.dcmread(dicom_path)
-
-        # Check if pixel data exists
+        
         if not hasattr(ds, 'pixel_array'):
             print("❌ Error: DICOM file does not contain pixel data.")
             return None
-
+        
         raw = ds.pixel_array.astype(np.float32)
         slope = getattr(ds, 'RescaleSlope', 1)
         intercept = getattr(ds, 'RescaleIntercept', 0)
         img_hu = raw * slope + intercept
 
-        # --- B. Apply Windowing ---
+        # Apply Windowing
         if modality == "CT":
             if window_type == "Brain (Grey Matter)":
                 level, width = 40, 80
             elif window_type == "Bone (Skull)":
                 level, width = 500, 2000
-            else:  # Soft Tissue / Face
+            else:
                 level, width = 40, 400
             img_min = level - (width / 2)
             img_max = level + (width / 2)
-        else:  # MRI (Percentile based)
+        else:  # MRI
             img_min = np.percentile(img_hu, 1)
             img_max = np.percentile(img_hu, 99)
 
-        # Handle division by zero
         img_range = img_max - img_min
         if img_range <= 0:
-            print("⚠️ Warning: Invalid image range. Using full range.")
             img_min = np.min(img_hu)
             img_max = np.max(img_hu)
             img_range = img_max - img_min
             if img_range <= 0:
-                print("❌ Error: Cannot process image with zero range.")
                 return None
 
         img_windowed = (img_hu - img_min) / img_range
         img_windowed = np.clip(img_windowed, 0, 1)
-
-        # Convert to RGB for SAM 3
+        
         img_uint8 = (img_windowed * 255).astype(np.uint8)
-
-        # Handle grayscale to RGB conversion
+        
         if len(img_uint8.shape) == 2:
             pil_image = Image.fromarray(img_uint8).convert('RGB')
         else:
             pil_image = Image.fromarray(img_uint8)
 
-        # --- C. Run SAM 3 Inference ---
+        # Run SAM 3 Inference
         try:
             inputs = processor(images=pil_image, text=prompt_text, return_tensors="pt").to(device)
-
+            
             with torch.no_grad():
                 outputs = model(**inputs)
 
@@ -108,159 +168,146 @@ def process_medical_image(dicom_file, prompt_text, modality, window_type, model,
         except Exception as e:
             print(f"❌ Error during model inference: {e}")
             return None
-
-        # --- D. Draw Masks on Image ---
-        # Create a figure to plot the result
+        
+        # Draw Masks on Image
         plt.figure(figsize=(10, 10))
         plt.imshow(pil_image)
-
-        # Check if masks exist in results
+        
         if 'masks' in results and results['masks'] is not None:
             masks = results['masks'].cpu().numpy()
             if len(masks) > 0:
                 final_mask = np.any(masks, axis=0)
-                plt.imshow(final_mask, alpha=0.5, cmap='spring')  # Overlay mask
+                plt.imshow(final_mask, alpha=0.5, cmap='spring')
             else:
                 print("⚠️ Warning: No masks found in segmentation results.")
         else:
-            print("⚠️ Warning: No masks in results. Showing original image.")
-
+            print("⚠️ Warning: No masks in results.")
+        
         plt.axis('off')
         plt.title(f"Segmentation: {prompt_text}", fontsize=12, pad=10)
-
-        # Save plot to a temporary file with unique name
+        
         output_file = tempfile.NamedTemporaryFile(delete=False, suffix='.png')
         output_path = output_file.name
         output_file.close()
-
+        
         plt.savefig(output_path, bbox_inches='tight', pad_inches=0, dpi=100)
         plt.close()
-
+        
         return output_path
-
-    except pydicom.errors.InvalidDicomError as e:
-        print(f"❌ Error: Invalid DICOM file format. {e}")
-        return None
+        
     except Exception as e:
         print(f"❌ Error processing image: {e}")
         import traceback
         traceback.print_exc()
         return None
 
-def create_gradio_interface(model_instance, processor_instance, device_instance, demo_file_path=None):
-    demo_file_available = False
-    if demo_file_path and os.path.exists(demo_file_path):
-        demo_file_available = True
+# Create Gradio Interface
+demo_file_path = demo_dicom_path if demo_file_available and os.path.exists(demo_dicom_path) else None
 
-    with gr.Blocks(theme=gr.themes.Soft()) as demo:
-        gr.Markdown("# 🏥 NeuroSAM 3: Medical Image Segmentation")
-
-        demo_info = ""
-        if demo_file_available and demo_file_path:
-            demo_info = f"\n\n**📁 Demo File Available:** A sample DICOM file is ready: `{demo_file_path}`\nClick 'Load Demo File' button below to use it!"
-
-        gr.Markdown(f"""
-        Upload a DICOM file (CT or MRI) and type what you want to find (e.g., 'brain', 'skull', 'eyes').
-        {demo_info}
-
-        **Instructions:**
-        1. Upload a DICOM (.dcm) file (or click 'Load Demo File' if available)
-        2. Enter a text prompt describing what to segment
-        3. Select the imaging modality (CT or MRI)
-        4. Choose the windowing strategy (for CT images)
-        5. Click "Segment Structure" to process
-
-        **Note:** Make sure GPU is enabled in Colab (Runtime → Change runtime type → GPU) for best performance.
-
-        **Public Datasets:**
-        - UniqueData/dicom-brain-dataset (Hugging Face) - MRI Brain scans
-        - The Cancer Imaging Archive (TCIA) - Various medical imaging
-        - Imaging Data Commons (IDC) - Large collection of DICOM files
-        """)
-
-        with gr.Row():
-            with gr.Column():
-                file_input = gr.File(
-                    label="Upload DICOM (.dcm)",
-                    file_types=[".dcm"],
-                    type="filepath",
-                    value=demo_file_path if demo_file_available else None
-                )
-
-                load_demo_btn = gr.Button(
-                    "📁 Load Demo File",
-                    variant="secondary",
-                    size="sm",
-                    visible=demo_file_available
-                )
-
-                text_input = gr.Textbox(
-                    label="Text Prompt",
-                    value="brain",
-                    placeholder="e.g. brain, tumor, skull, eyes",
-                    info="Describe what anatomical structure or region you want to segment"
-                )
-
-                with gr.Row():
-                    modality_dropdown = gr.Dropdown(
-                        ["CT", "MRI"],
-                        label="Modality",
-                        value="MRI",
-                        info="Select the imaging modality"
-                    )
-                    window_dropdown = gr.Dropdown(
-                        ["Brain (Grey Matter)", "Bone (Skull)", "Soft Tissue (Face)"],
-                        label="Windowing Strategy (CT only)",
-                        value="Brain (Grey Matter)",
-                        info="CT windowing preset (ignored for MRI)"
-                    )
-
-                submit_btn = gr.Button("Segment Structure", variant="primary", size="lg")
+def load_demo_file():
+    """Load the demo DICOM file."""
+    if demo_file_path and os.path.exists(demo_file_path):
+        return demo_file_path, f"✅ Demo file loaded: {demo_file_path}\nReady to segment!"
+    else:
+        return None, "⚠️ Demo file not found. Please upload a DICOM file."
 
-            with gr.Column():
-                image_output = gr.Image(
-                    label="Segmentation Result",
-                    type="filepath"
+def process_with_status(dicom_file, prompt_text, modality, window_type):
+    """Wrapper function to update status during processing."""
+    if model is None or processor is None:
+        return None, "❌ Error: Model not loaded."
+    
+    if dicom_file is None:
+        return None, "⚠️ Please upload a DICOM file or load the demo file."
+    
+    result = process_medical_image(dicom_file, prompt_text, modality, window_type)
+    
+    if result is None:
+        return None, "❌ Processing failed. Check console for error details."
+    else:
+        return result, "✅ Segmentation complete!"
+
+with gr.Blocks() as demo:
+    gr.Markdown("# 🏥 NeuroSAM 3: Medical Image Segmentation")
+    
+    demo_info = ""
+    if demo_file_path:
+        demo_info = f"\n\n**📁 Demo File Available:** A sample DICOM file is ready: `{demo_file_path}`\nClick 'Load Demo File' button below to use it!"
+    
+    gr.Markdown(f"""
+    Upload a DICOM file (CT or MRI) and type what you want to find (e.g., 'brain', 'skull', 'eyes').
+    {demo_info}
+    
+    **Instructions:**
+    1. Upload a DICOM (.dcm) file (or click 'Load Demo File' if available)
+    2. Enter a text prompt describing what to segment
+    3. Select the imaging modality (CT or MRI)
+    4. Choose the windowing strategy (for CT images)
+    5. Click "Segment Structure" to process
+    """)
+    
+    with gr.Row():
+        with gr.Column():
+            file_input = gr.File(
+                label="Upload DICOM (.dcm)", 
+                file_types=[".dcm"],
+                type="filepath",
+                value=demo_file_path
+            )
+            
+            load_demo_btn = gr.Button(
+                "📁 Load Demo File", 
+                variant="secondary", 
+                size="sm",
+                visible=bool(demo_file_path)
+            )
+            
+            text_input = gr.Textbox(
+                label="Text Prompt", 
+                value="brain", 
+                placeholder="e.g. brain, tumor, skull, eyes",
+                info="Describe what anatomical structure or region you want to segment"
+            )
+            
+            with gr.Row():
+                modality_dropdown = gr.Dropdown(
+                    ["CT", "MRI"], 
+                    label="Modality", 
+                    value="MRI",
+                    info="Select the imaging modality"
                 )
-
-                gr.Markdown("### Status")
-                status_text = gr.Textbox(
-                    label="Processing Status",
-                    value="Ready. Upload a DICOM file to begin.",
-                    interactive=False
+                window_dropdown = gr.Dropdown(
+                    ["Brain (Grey Matter)", "Bone (Skull)", "Soft Tissue (Face)"], 
+                    label="Windowing Strategy (CT only)", 
+                    value="Brain (Grey Matter)",
+                    info="CT windowing preset (ignored for MRI)"
                 )
-
-        def load_demo_file_fn():
-            """Load the demo DICOM file."""
-            if demo_file_available and demo_file_path and os.path.exists(demo_file_path):
-                return demo_file_path, f"✅ Demo file loaded: {demo_file_path}\nReady to segment!"
-            else:
-                return None, "⚠️ Demo file not found. Please upload a DICOM file."
-
-        def process_with_status_fn(dicom_file, prompt_text, modality, window_type):
-            """Wrapper function to update status during processing."""
-            if model_instance is None or processor_instance is None:
-                return None, "❌ Error: Model not loaded. Please check the model loading section above."
-
-            if dicom_file is None:
-                return None, "⚠️ Please upload a DICOM file or load the demo file."
-
-            result = process_medical_image(dicom_file, prompt_text, modality, window_type, model_instance, processor_instance, device_instance)
-
-            if result is None:
-                return None, "❌ Processing failed. Check console for error details."
-            else:
-                return result, "✅ Segmentation complete!"
-
-        load_demo_btn.click(
-            fn=load_demo_file_fn,
-            inputs=[],
-            outputs=[file_input, status_text]
-        )
-
-        submit_btn.click(
-            fn=process_with_status_fn,
-            inputs=[file_input, text_input, modality_dropdown, window_dropdown],
-            outputs=[image_output, status_text]
-        )
-    return demo
+            
+            submit_btn = gr.Button("Segment Structure", variant="primary", size="lg")
+            
+        with gr.Column():
+            image_output = gr.Image(
+                label="Segmentation Result",
+                type="filepath"
+            )
+            
+            gr.Markdown("### Status")
+            status_text = gr.Textbox(
+                label="Processing Status",
+                value="Ready. Upload a DICOM file to begin.",
+                interactive=False
+            )
+
+    load_demo_btn.click(
+        fn=load_demo_file,
+        inputs=[],
+        outputs=[file_input, status_text]
+    )
+    
+    submit_btn.click(
+        fn=process_with_status,
+        inputs=[file_input, text_input, modality_dropdown, window_dropdown],
+        outputs=[image_output, status_text]
+    )
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,10 @@
+gradio>=4.0.0
+pydicom>=2.4.0
+numpy>=1.24.0
+pillow>=10.0.0
+matplotlib>=3.7.0
+torch>=2.0.0
+torchvision>=0.15.0
+transformers>=4.41.0
+huggingface-hub>=0.20.0
+