Upload app.py with huggingface_hub

app.py

@@ -1,29 +1,218 @@
+"""
+Image Processing Studio + NPH Neuroimaging Analysis
+Unified Gradio app with filters, ML models, and NPH-specific segmentation.
+"""
+
 import gradio as gr
 import numpy as np
 from PIL import Image, ImageFilter, ImageEnhance, ImageOps
 from transformers import pipeline
+import cv2
+import json
+import tempfile
+import os
+
 from segment_neuroimaging import (
     segment_nph, segment_ventricles, compute_evans_index,
     compute_callosal_angle, compute_temporal_horn_width,
     compute_third_ventricle_width, score_pvh, assess_desh,
     create_overlay, add_annotations, create_comparison,
-    preprocess_image, create_roi_mask, Modality, COLORS
+    preprocess_image, create_roi_mask, morphological_cleanup,
+    filter_by_area, Modality, VENTRICLE_THRESHOLDS, CSF_MODE,
+    CSFAppearance, COLORS
 )
-import cv2
-import json
-import tempfile
-import os
 
-# ---- Load models (cached on first use) ----
+# ---- Load ML models (cached on first use) ----
 classifier = pipeline("image-classification", model="google/vit-base-patch16-224")
 detector = pipeline("object-detection", model="facebook/detr-resnet-50")
 segmenter = pipeline("image-segmentation", model="facebook/detr-resnet-50-panoptic")
 
-# ---- Tab 1: Filters & Effects ----
+
+# ===========================================================================
+# Tab 1: NPH Neuroimaging Analysis (Enhanced)
+# ===========================================================================
+
+def analyze_nph(image, modality, sensitivity, overlay_alpha, pixel_spacing_str):
+    if image is None:
+        raise gr.Error("Please upload a brain MRI or CT image first.")
+
+    # Save temp file for the pipeline
+    with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as f:
+        Image.fromarray(image).save(f.name)
+        temp_path = f.name
+
+    try:
+        modality_map = {
+            "Axial FLAIR": "FLAIR",
+            "Axial T1": "T1",
+            "Axial T2": "T2",
+            "Coronal T2": "T2",
+            "Axial T2 FFE": "T2",
+            "Sagittal T1": "T1",
+            "CT Head": "CT_HEAD",
+        }
+        mod_key = modality_map.get(modality, "T1")
+        mod = Modality[mod_key]
+        is_coronal = "Coronal" in modality
+
+        # Parse pixel spacing
+        pixel_spacing = None
+        if pixel_spacing_str and pixel_spacing_str.strip():
+            try:
+                pixel_spacing = float(pixel_spacing_str.strip())
+            except ValueError:
+                pass
+
+        # Load and preprocess
+        img_rgb, gray, _ = preprocess_image(temp_path)
+        h, w = gray.shape[:2]
+        blurred = cv2.GaussianBlur(gray, (5, 5), 0)
+        roi_mask = create_roi_mask(blurred, threshold=30)
+
+        # Sensitivity-adjusted thresholds
+        orig_thresh = dict(VENTRICLE_THRESHOLDS[mod])
+        sens_adj = (sensitivity - 50) / 50.0
+
+        custom_thresholds = dict(orig_thresh)
+        if CSF_MODE[mod] == CSFAppearance.DARK:
+            custom_thresholds["csf_high"] = max(20, min(120,
+                int(orig_thresh["csf_high"] + sens_adj * 30)))
+        else:
+            custom_thresholds["csf_low"] = max(100, min(220,
+                int(orig_thresh["csf_low"] - sens_adj * 30)))
+
+        # Segment ventricles
+        vent_mask = segment_ventricles(gray, mod, roi_mask, custom_thresholds=custom_thresholds)
+
+        # Default pixel spacing estimate for non-DICOM
+        if pixel_spacing is None:
+            pixel_spacing = round(180.0 / max(w, 256), 2)
+
+        # Compute all biomarkers
+        ei_data = compute_evans_index(vent_mask, image_width=w, pixel_spacing_mm=pixel_spacing)
+        th_data = compute_temporal_horn_width(vent_mask, pixel_spacing)
+        tv_data = compute_third_ventricle_width(vent_mask, pixel_spacing)
+        desh_data = assess_desh(vent_mask, gray, roi_mask, mod, pixel_spacing)
+
+        # PVH (FLAIR only)
+        pvh_data = None
+        if mod == Modality.FLAIR:
+            pvh_data = score_pvh(gray, vent_mask)
+
+        # Callosal angle
+        ca_data = compute_callosal_angle(vent_mask) if is_coronal else {}
+
+        # Ventricle stats
+        vent_area = int((vent_mask > 0).sum())
+        brain_area = int((roi_mask > 0).sum())
+        vent_brain_ratio = round(vent_area / brain_area, 4) if brain_area > 0 else 0
+
+        # Build display masks
+        display_masks = {"ventricles": vent_mask}
+        parenchyma = cv2.bitwise_and(roi_mask, cv2.bitwise_not(vent_mask))
+        display_masks["parenchyma"] = parenchyma
+
+        if pvh_data and mod == Modality.FLAIR:
+            display_masks["pvh"] = pvh_data["pvh_mask"]
+        if "sylvian_mask" in desh_data:
+            display_masks["sylvian_fissures"] = desh_data["sylvian_mask"]
+        if "convexity_mask" in desh_data:
+            display_masks["high_convexity_sulci"] = desh_data["convexity_mask"]
+
+        # Visualization
+        overlay = create_overlay(img_rgb, display_masks, alpha=overlay_alpha)
+
+        biomarkers_for_annotation = dict(ei_data)
+        biomarkers_for_annotation.update(th_data)
+        if pvh_data:
+            biomarkers_for_annotation["pvh_grade"] = pvh_data["pvh_grade"]
+        biomarkers_for_annotation["is_desh_positive"] = desh_data["is_desh_positive"]
+        if ca_data.get("callosal_angle_deg") is not None:
+            biomarkers_for_annotation["callosal_angle_deg"] = ca_data["callosal_angle_deg"]
+
+        annotated = add_annotations(
+            overlay, display_masks,
+            f"{modality} -- NPH Analysis",
+            biomarkers_for_annotation,
+        )
+
+        # Draw Evans' index measurement line
+        row = ei_data.get("measurement_row", 0)
+        if row > 0:
+            cols = np.where(vent_mask[row, :] > 0)[0]
+            if len(cols) > 0:
+                minX, maxX = int(cols[0]), int(cols[-1])
+                cv2.line(annotated, (minX, row), (maxX, row), (255, 220, 0), 2)
+                skull_d = ei_data.get("skull_diameter_px", w)
+                center_x = w // 2
+                half_skull = skull_d // 2
+                cv2.line(annotated, (center_x - half_skull, row + 8),
+                         (center_x + half_skull, row + 8), (200, 200, 200), 1)
+
+        comparison = create_comparison(img_rgb, annotated, f"{modality} -- NPH Analysis")
+
+        # Build report
+        report_lines = ["## NPH Biomarker Report\n"]
+
+        ei = ei_data.get("evans_index", 0)
+        status = "**ABNORMAL (>0.3)**" if ei > 0.3 else "Normal"
+        report_lines.append(f"**Evans' Index:** {ei:.3f} -- {status}")
+
+        if ei_data.get("frontal_horn_width_mm"):
+            report_lines.append(f"  - Frontal horn width: {ei_data['frontal_horn_width_mm']} mm")
+            report_lines.append(f"  - Skull diameter: {ei_data['skull_diameter_mm']} mm")
+
+        thw = th_data.get("temporal_horn_width_px", 0)
+        if thw > 0:
+            thw_mm = th_data.get("temporal_horn_width_mm", "")
+            mm_str = f" ({thw_mm} mm)" if thw_mm else ""
+            report_lines.append(f"**Temporal Horn Width:** {thw} px{mm_str}")
+
+        tvw = tv_data.get("third_ventricle_width_px", 0)
+        if tvw > 0:
+            tvw_mm = tv_data.get("third_ventricle_width_mm", "")
+            mm_str = f" ({tvw_mm} mm)" if tvw_mm else ""
+            report_lines.append(f"**Third Ventricle Width:** {tvw} px{mm_str}")
+
+        report_lines.append(f"**Ventricle/Brain Ratio:** {vent_brain_ratio:.4f} ({vent_area} / {brain_area} px)")
+
+        if pvh_data:
+            grade_desc = {0: "None", 1: "Pencil-thin rim", 2: "Smooth halo", 3: "Irregular, deep WM"}
+            report_lines.append(f"**PVH Grade:** {pvh_data['pvh_grade']}/3 -- {grade_desc.get(pvh_data['pvh_grade'], '')}")
+            report_lines.append(f"  - PVH ratio: {pvh_data['pvh_ratio']:.4f}")
+
+        if ca_data.get("callosal_angle_deg") is not None:
+            ca = ca_data["callosal_angle_deg"]
+            ca_status = "Suggestive of NPH" if ca < 90 else ("Indeterminate" if ca < 120 else "Normal/ex vacuo")
+            report_lines.append(f"**Callosal Angle:** {ca:.1f} deg -- {ca_status}")
+
+        desh = desh_data.get("is_desh_positive", False)
+        desh_str = "**POSITIVE**" if desh else "Negative"
+        desh_score = desh_data.get("total_score", 0)
+        report_lines.append(f"\n### DESH Assessment: {desh_str} (score: {desh_score}/6)")
+        report_lines.append(f"- Ventriculomegaly: {desh_data.get('ventriculomegaly_score', 'N/A')}/2")
+        report_lines.append(f"- Sylvian dilation: {desh_data.get('sylvian_dilation_score', 'N/A')}/2")
+        report_lines.append(f"- Convexity tightness: {desh_data.get('convexity_tightness_score', 'N/A')}/2")
+        scr = desh_data.get("sylvian_convexity_ratio", "N/A")
+        report_lines.append(f"- Sylvian/Convexity ratio: {scr}")
+
+        report_lines.append(f"\n---\n*Sensitivity: {sensitivity}% | Thresholds: CSF [{custom_thresholds['csf_low']}-{custom_thresholds['csf_high']}] | Pixel spacing: {pixel_spacing} mm/px*")
+        report_lines.append("*Structures:* " + ", ".join(display_masks.keys()))
+
+        report = "\n".join(report_lines)
+        return annotated, comparison, report
+
+    finally:
+        os.unlink(temp_path)
+
+
+# ===========================================================================
+# Tab 2: Filters & Effects
+# ===========================================================================
+
 def apply_filter(image, effect, intensity):
     if image is None:
         raise gr.Error("Please upload an image first.")
-
     img = Image.fromarray(image)
 
     if effect == "Grayscale":
@@ -60,26 +249,23 @@ def apply_filter(image, effect, intensity):
         filtered = enhancer.enhance(0.5 + intensity * 2)
     else:
         filtered = img
-
     return np.array(filtered)
 
 
-# ---- Tab 2: Image Classification ----
+# ===========================================================================
+# Tab 3-5: ML Models
+# ===========================================================================
+
 def classify_image(image):
     if image is None:
         raise gr.Error("Please upload an image first.")
-    img = Image.fromarray(image)
-    results = classifier(img)
+    results = classifier(Image.fromarray(image))
     return {r["label"]: r["score"] for r in results}
 
-
-# ---- Tab 3: Object Detection ----
 def detect_objects(image, threshold):
     if image is None:
         raise gr.Error("Please upload an image first.")
-    img = Image.fromarray(image)
-    results = detector(img, threshold=threshold)
-
+    results = detector(Image.fromarray(image), threshold=threshold)
     annotations = []
     for r in results:
         box = r["box"]
@@ -87,170 +273,70 @@ def detect_objects(image, threshold):
             (box["xmin"], box["ymin"], box["xmax"], box["ymax"]),
             f"{r['label']} ({r['score']:.0%})"
         ))
-
     return (image, annotations)
 
-
-# ---- Tab 4: General Segmentation ----
 def segment_image(image):
     if image is None:
         raise gr.Error("Please upload an image first.")
-    img = Image.fromarray(image)
-    results = segmenter(img)
-
+    results = segmenter(Image.fromarray(image))
     annotations = []
     for r in results:
         mask = np.array(r["mask"])
         annotations.append((mask, r["label"]))
-
     return (image, annotations)
 
 
-# ---- Tab 5: NPH Neuroimaging Analysis ----
-def analyze_nph(image, modality, overlay_alpha):
-    if image is None:
-        raise gr.Error("Please upload a brain MRI or CT image first.")
-
-    # Save temp file for the segmentation pipeline
-    with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as f:
-        Image.fromarray(image).save(f.name)
-        temp_path = f.name
+# ===========================================================================
+# Build the UI
+# ===========================================================================
 
-    try:
-        # Map display name to modality key
-        modality_map = {
-            "Axial FLAIR": "FLAIR",
-            "Axial T1": "T1",
-            "Axial T2": "T2",
-            "Coronal T2": "T2",
-            "Axial T2 FFE": "T2",
-            "Sagittal T1": "T1",
-            "CT Head": "CT_HEAD",
-        }
-        mod_key = modality_map.get(modality, "T1")
-        is_coronal = "Coronal" in modality
-
-        result = segment_nph(
-            temp_path,
-            modality=mod_key,
-            compute_biomarkers=True,
-        )
-
-        # Build biomarker report
-        meta = result.metadata
-        report_lines = ["## NPH Biomarker Report\n"]
-
-        # Evans' Index
-        ei = meta.get("evans_index")
-        if ei is not None:
-            status = "**ABNORMAL (>0.3)**" if ei > 0.3 else "Normal"
-            report_lines.append(f"**Evans' Index:** {ei:.3f} -- {status}")
-
-        # Temporal Horn Width
-        thw = meta.get("temporal_horn_width_px", 0)
-        if thw > 0:
-            report_lines.append(f"**Temporal Horn Width:** {thw} px")
-
-        # Third Ventricle Width
-        tvw = meta.get("third_ventricle_width_px", 0)
-        if tvw > 0:
-            report_lines.append(f"**Third Ventricle Width:** {tvw} px")
-
-        # PVH Grade (FLAIR only)
-        pvh = meta.get("pvh_grade")
-        if pvh is not None:
-            grade_desc = {0: "None", 1: "Pencil-thin rim", 2: "Smooth halo", 3: "Irregular, deep WM"}
-            report_lines.append(f"**PVH Grade:** {pvh}/3 -- {grade_desc.get(pvh, '')}")
-
-        # DESH Assessment
-        desh = meta.get("is_desh_positive")
-        if desh is not None:
-            desh_str = "**POSITIVE**" if desh else "Negative"
-            desh_score = meta.get("desh_total_score", "")
-            report_lines.append(f"**DESH Pattern:** {desh_str} (score: {desh_score}/6)")
-
-        # DESH details
-        desh_details = meta.get("desh_details")
-        if desh_details:
-            report_lines.append(f"\n### DESH Components")
-            report_lines.append(f"- Ventriculomegaly: {desh_details.get('ventriculomegaly_score', 'N/A')}/2")
-            report_lines.append(f"- Sylvian dilation: {desh_details.get('sylvian_dilation_score', 'N/A')}/2")
-            report_lines.append(f"- Convexity tightness: {desh_details.get('convexity_tightness_score', 'N/A')}/2")
-
-        # Callosal angle for coronal images
-        if is_coronal:
-            vent_mask = result.masks.get("ventricles")
-            if vent_mask is not None:
-                ca_data = compute_callosal_angle(vent_mask)
-                ca = ca_data.get("callosal_angle_deg")
-                if ca is not None:
-                    ca_status = "Suggestive of NPH" if ca < 90 else ("Indeterminate" if ca < 120 else "Normal/ex vacuo")
-                    report_lines.append(f"\n**Callosal Angle:** {ca:.1f} deg -- {ca_status}")
-
-        report_lines.append("\n---")
-        report_lines.append("*Structures segmented:* " + ", ".join(meta.get("structures_found", [])))
-        report_lines.append("\n*Note: Pixel-based measurements without DICOM spacing are approximate.*")
-
-        report = "\n".join(report_lines)
-
-        # Build overlay with custom alpha
-        display_masks = {k: v for k, v in result.masks.items() if k != "skull"}
-        img_rgb, gray, _ = preprocess_image(temp_path)
-        overlay = create_overlay(img_rgb, display_masks, alpha=overlay_alpha)
-
-        biomarkers_for_annotation = {
-            k: v for k, v in meta.items()
-            if k in ("evans_index", "callosal_angle_deg", "temporal_horn_width_px",
-                      "pvh_grade", "is_desh_positive")
-        }
-        annotated = add_annotations(overlay, display_masks, f"{modality} -- NPH Analysis", biomarkers_for_annotation)
-
-        # Side-by-side comparison
-        comparison = create_comparison(img_rgb, annotated, f"{modality} -- NPH Analysis")
-
-        return annotated, comparison, report
-
-    finally:
-        os.unlink(temp_path)
-
-
-# ---- Build the UI ----
 css = """
 .main-title { text-align: center; margin-bottom: 0.5em; }
 .subtitle { text-align: center; color: #666; margin-top: 0; }
+.nph-ref-table th, .nph-ref-table td { padding: 4px 12px; }
 """
 
 with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
     gr.Markdown("# Image Processing Studio", elem_classes="main-title")
     gr.Markdown(
-        "Upload an image and explore filters, classification, object detection, segmentation, and **NPH neuroimaging analysis** -- all powered by state-of-the-art models.",
+        "Filters, classification, object detection, panoptic segmentation, and **NPH neuroimaging analysis** -- all in one place.",
         elem_classes="subtitle"
     )
 
+    # ── NPH Analysis Tab ──
     with gr.Tab("NPH Analysis"):
         gr.Markdown(
-            "### Normal Pressure Hydrocephalus -- Neuroimaging Segmentation & Biomarkers\n"
-            "Upload a brain MRI or CT scan to compute Evans' index, DESH pattern, PVH scoring, "
-            "callosal angle (coronal), and more."
+            "### Normal Pressure Hydrocephalus -- Segmentation & Biomarkers\n"
+            "Upload a brain MRI or CT scan. Computes Evans' index, DESH pattern, temporal horn width, "
+            "callosal angle (coronal), PVH scoring (FLAIR), and ventricle/brain ratio.\n\n"
+            "**Sensitivity slider** adjusts the CSF thresholds -- increase to capture more ventricle, "
+            "decrease to be more conservative."
         )
         with gr.Row():
-            with gr.Column():
+            with gr.Column(scale=1):
                 nph_input = gr.Image(label="Upload Brain Scan", type="numpy")
                 nph_modality = gr.Dropdown(
-                    choices=[
-                        "Axial FLAIR", "Axial T1", "Axial T2",
-                        "Coronal T2", "Axial T2 FFE", "Sagittal T1",
-                        "CT Head"
-                    ],
+                    choices=["Axial FLAIR", "Axial T1", "Axial T2", "Coronal T2",
+                             "Axial T2 FFE", "Sagittal T1", "CT Head"],
                     value="Axial FLAIR",
                     label="Modality / Sequence"
                 )
+                nph_sensitivity = gr.Slider(
+                    minimum=10, maximum=90, value=50, step=5,
+                    label="Sensitivity (%)"
+                )
                 nph_alpha = gr.Slider(
                     minimum=0.1, maximum=0.9, value=0.45, step=0.05,
                     label="Overlay Opacity"
                 )
-                nph_btn = gr.Button("Analyze for NPH", variant="primary")
-            with gr.Column():
+                nph_spacing = gr.Textbox(
+                    label="Pixel Spacing (mm/px)",
+                    placeholder="e.g. 0.5 (leave blank for auto-estimate)",
+                    value=""
+                )
+                nph_btn = gr.Button("Analyze for NPH", variant="primary", size="lg")
+
+            with gr.Column(scale=2):
                 nph_overlay = gr.Image(label="Segmentation Overlay", type="numpy")
                 nph_comparison = gr.Image(label="Side-by-Side Comparison", type="numpy")
 
@@ -258,48 +344,74 @@ with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
 
         nph_btn.click(
             fn=analyze_nph,
-            inputs=[nph_input, nph_modality, nph_alpha],
+            inputs=[nph_input, nph_modality, nph_sensitivity, nph_alpha, nph_spacing],
             outputs=[nph_overlay, nph_comparison, nph_report]
         )
 
+        with gr.Accordion("NPH Reference Values & Interpretation Guide", open=False):
+            gr.Markdown(
+                "| Biomarker | Normal | Suggestive of NPH | Strongly suggestive |\n"
+                "|---|---|---|---|\n"
+                "| Evans' Index | < 0.3 | > 0.3 | > 0.33 |\n"
+                "| Callosal Angle | > 120 deg | < 90 deg | < 60 deg |\n"
+                "| Temporal Horn | < 2 mm | 2-5 mm | > 5 mm |\n"
+                "| Third Ventricle | < 5 mm | 5-10 mm | > 10 mm |\n"
+                "| PVH (FLAIR) | Grade 0 | Grade 2 | Grade 3 |\n"
+                "| DESH Pattern | Absent | -- | Present |\n\n"
+                "**DESH** (Disproportionately Enlarged Subarachnoid-space Hydrocephalus): "
+                "Enlarged sylvian fissures + tight high-convexity sulci + ventriculomegaly. "
+                "This pattern distinguishes iNPH from Alzheimer's and normal aging.\n\n"
+                "**Color Legend:** "
+                "Blue = Ventricles | Green = Parenchyma | Yellow = PVH | "
+                "Purple = Sylvian fissures | Orange = High-convexity sulci\n\n"
+                "*Note: Measurements from JPEG/PNG images without DICOM metadata are approximate. "
+                "For clinical use, provide pixel spacing from the DICOM header.*"
+            )
+
+    # ── Client-Side NPH Detector Tab ──
+    with gr.Tab("NPH Detector (Browser)"):
         gr.Markdown(
-            "#### NPH Reference Values\n"
-            "| Biomarker | Normal | Suggestive of NPH |\n"
-            "|---|---|---|\n"
-            "| Evans' Index | < 0.3 | > 0.3 |\n"
-            "| Callosal Angle | > 120 deg | < 90 deg |\n"
-            "| Temporal Horn | < 2 mm | > 5 mm |\n"
-            "| PVH (FLAIR) | Grade 0 | Grade 2-3 |\n"
-            "| DESH Pattern | Absent | Present |"
+            "### Client-Side NPH Detector\n"
+            "This tab runs the full NPH segmentation pipeline **entirely in your browser** using JavaScript. "
+            "No data is sent to any server -- everything stays on your device.\n\n"
+            "Upload a brain scan below and select the modality."
+        )
+        gr.HTML(
+            value='<iframe src="https://mmrech-nph-detector-js.hf.space" '
+                  'width="100%" height="900" frameborder="0" '
+                  'allow="clipboard-write" '
+                  'style="border-radius: 12px; border: 1px solid #333;"></iframe>',
         )
 
+    # ── Video Demo Tab ──
+    with gr.Tab("Video Demo"):
+        gr.Markdown(
+            "### Whole-Brain Segmentation Demo\n"
+            "Watch a slice-by-slice ventricle segmentation across a full MRI series."
+        )
+        gr.Video(
+            value="examples/hydromorph_whole_brain_segmentation.mp4",
+            label="NPH Segmentation Video",
+            autoplay=False,
+        )
+
+    # ── Filters Tab ──
     with gr.Tab("Filters & Effects"):
         with gr.Row():
             with gr.Column():
                 filter_input = gr.Image(label="Upload Image", type="numpy")
                 filter_effect = gr.Dropdown(
-                    choices=[
-                        "Grayscale", "Sepia", "Blur", "Sharpen",
-                        "Edge Detect", "Emboss", "Invert", "Posterize",
-                        "Brightness", "Contrast"
-                    ],
-                    value="Sepia",
-                    label="Effect"
-                )
-                filter_intensity = gr.Slider(
-                    minimum=0.0, maximum=1.0, value=0.7, step=0.05,
-                    label="Intensity"
+                    choices=["Grayscale", "Sepia", "Blur", "Sharpen", "Edge Detect",
+                             "Emboss", "Invert", "Posterize", "Brightness", "Contrast"],
+                    value="Sepia", label="Effect"
                 )
+                filter_intensity = gr.Slider(minimum=0.0, maximum=1.0, value=0.7, step=0.05, label="Intensity")
                 filter_btn = gr.Button("Apply Filter", variant="primary")
             with gr.Column():
                 filter_output = gr.Image(label="Result", type="numpy")
+        filter_btn.click(fn=apply_filter, inputs=[filter_input, filter_effect, filter_intensity], outputs=filter_output)
 
-        filter_btn.click(
-            fn=apply_filter,
-            inputs=[filter_input, filter_effect, filter_intensity],
-            outputs=filter_output
-        )
-
+    # ── Classification Tab ──
     with gr.Tab("Image Classification"):
         with gr.Row():
             with gr.Column():
@@ -307,31 +419,20 @@ with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
                 cls_btn = gr.Button("Classify", variant="primary")
             with gr.Column():
                 cls_output = gr.Label(label="Predictions", num_top_classes=5)
+        cls_btn.click(fn=classify_image, inputs=cls_input, outputs=cls_output)
 
-        cls_btn.click(
-            fn=classify_image,
-            inputs=cls_input,
-            outputs=cls_output
-        )
-
+    # ── Object Detection Tab ──
     with gr.Tab("Object Detection"):
         with gr.Row():
             with gr.Column():
                 det_input = gr.Image(label="Upload Image", type="numpy")
-                det_threshold = gr.Slider(
-                    minimum=0.1, maximum=0.95, value=0.5, step=0.05,
-                    label="Confidence Threshold"
-                )
+                det_threshold = gr.Slider(minimum=0.1, maximum=0.95, value=0.5, step=0.05, label="Confidence Threshold")
                 det_btn = gr.Button("Detect Objects", variant="primary")
             with gr.Column():
                 det_output = gr.AnnotatedImage(label="Detections")
+        det_btn.click(fn=detect_objects, inputs=[det_input, det_threshold], outputs=det_output)
 
-        det_btn.click(
-            fn=detect_objects,
-            inputs=[det_input, det_threshold],
-            outputs=det_output
-        )
-
+    # ── Segmentation Tab ──
     with gr.Tab("Segmentation"):
         with gr.Row():
             with gr.Column():
@@ -339,11 +440,6 @@ with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
                 seg_btn = gr.Button("Segment", variant="primary")
             with gr.Column():
                 seg_output = gr.AnnotatedImage(label="Segmentation Map")
-
-        seg_btn.click(
-            fn=segment_image,
-            inputs=seg_input,
-            outputs=seg_output
-        )
+        seg_btn.click(fn=segment_image, inputs=seg_input, outputs=seg_output)
 
 demo.launch()