Upload app.py with huggingface_hub

app.py

@@ -1,16 +1,18 @@
 """
 Image Processing Studio + NPH Neuroimaging Analysis
-Unified Gradio app with filters, ML models, and NPH-specific segmentation.
+Unified Gradio app with filters, ML models, YOLO NPH detection, clinical scoring,
+and intensity-based NPH segmentation.
 """
 
 import gradio as gr
 import numpy as np
-from PIL import Image, ImageFilter, ImageEnhance, ImageOps
+from PIL import Image, ImageFilter, ImageEnhance, ImageOps, ImageDraw, ImageFont
 from transformers import pipeline
 import cv2
-import json
 import tempfile
 import os
+import threading
+import logging
 
 from segment_neuroimaging import (
     segment_nph, segment_ventricles, compute_evans_index,
@@ -22,21 +24,120 @@ from segment_neuroimaging import (
     CSFAppearance, COLORS
 )
 
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
 # ---- 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")
 
+# ---- YOLO model for NPH structure detection ----
+YOLO_MODEL_PATH = "best.pt"
+_yolo_model = None
+_yolo_lock = threading.Lock()
+
+# Class-specific colors for YOLO detections (BGR for OpenCV, RGB for display)
+YOLO_COLORS = {
+    "ventricle":        (0, 150, 255),   # bright blue
+    "sylvian_fissure":  (200, 100, 255), # purple
+    "tight_convexity":  (255, 150, 100), # orange
+    "pvh":              (255, 200, 0),   # yellow
+    "skull_inner":      (200, 200, 200), # gray
+}
+
+
+def _get_yolo_model():
+    """Lazy-load YOLOv8 model."""
+    global _yolo_model
+    if _yolo_model is None:
+        with _yolo_lock:
+            if _yolo_model is None and os.path.exists(YOLO_MODEL_PATH):
+                try:
+                    from ultralytics import YOLO
+                    _yolo_model = YOLO(YOLO_MODEL_PATH)
+                    logger.info("YOLO model loaded from %s", YOLO_MODEL_PATH)
+                except Exception as e:
+                    logger.error("Failed to load YOLO model: %s", e)
+    return _yolo_model
+
+
+def _compute_nph_score(data: dict) -> dict:
+    """
+    Compute NPH probability score from structured metrics.
+    Weighted formula: VSR(40%) + Evans Index(25%) + Callosal Angle(20%) + DESH(10%) + Sylvian(5%)
+    With triad bonus (+15%) and cortical atrophy penalty (-30%).
+    """
+    score = 0.0
+    evans = data.get("evansIndex") or 0.0
+    callosal = data.get("callosalAngle")
+    desh = data.get("deshScore") or 0
+    sylvian = bool(data.get("sylvianDilation"))
+    vsr = data.get("vsr")
+    triad = data.get("triad") or []
+    atrophy = data.get("corticalAtrophy") or "unknown"
+
+    has_vsr = vsr is not None
+    has_callosal = callosal is not None
+
+    if has_vsr:
+        if vsr > 2.0:
+            score += 40 * min((vsr - 2.0) / 2.0, 1)
+        if evans > 0.3:
+            score += 25 * min((evans - 0.3) / 0.15, 1)
+        if has_callosal and callosal < 90:
+            score += 20 * min((90 - callosal) / 50, 1)
+        score += (desh / 3) * 10
+        if sylvian:
+            score += 5
+    else:
+        # Redistribute VSR weight across remaining criteria
+        scale = 100 / 60
+        if evans > 0.3:
+            score += 25 * scale * min((evans - 0.3) / 0.15, 1)
+        if has_callosal and callosal < 90:
+            score += 20 * scale * min((90 - callosal) / 50, 1)
+        score += (desh / 3) * 10 * scale
+        if sylvian:
+            score += 5 * scale
+
+    triad_count = sum(1 for v in triad if v)
+    if triad_count == 3:
+        score = min(score * 1.15, 100)
+    elif triad_count == 2:
+        score = min(score * 1.05, 100)
+
+    if atrophy == "significant":
+        score *= 0.7
+    elif atrophy == "moderate":
+        score *= 0.85
+
+    score = int(round(min(score, 100)))
+
+    if score >= 75:
+        label = "Probable NPH"
+        recommendation = "Strongly consider CSF tap test and neurosurgical referral for VP shunt evaluation."
+    elif score >= 50:
+        label = "Possible NPH"
+        recommendation = "CSF tap test recommended. Consider supplementary MRI for DESH confirmation."
+    elif score >= 30:
+        label = "Low Suspicion"
+        recommendation = "NPH less likely. Consider alternative diagnoses. Follow-up imaging in 6 months if clinical concern persists."
+    else:
+        label = "Unlikely NPH"
+        recommendation = "Ventriculomegaly likely ex-vacuo or other etiology. Investigate alternative causes of symptoms."
+
+    return {"score": score, "label": label, "recommendation": recommendation}
+
 
 # ===========================================================================
-# Tab 1: NPH Neuroimaging Analysis (Enhanced)
+# Tab 1: NPH Neuroimaging Analysis (Intensity-based Segmentation)
 # ===========================================================================
 
 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
@@ -55,7 +156,6 @@ def analyze_nph(image, modality, sensitivity, overlay_alpha, pixel_spacing_str):
         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:
@@ -63,13 +163,11 @@ def analyze_nph(image, modality, sensitivity, overlay_alpha, pixel_spacing_str):
             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
 
@@ -81,33 +179,26 @@ def analyze_nph(image, modality, sensitivity, overlay_alpha, pixel_spacing_str):
             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
@@ -119,7 +210,6 @@ def analyze_nph(image, modality, sensitivity, overlay_alpha, pixel_spacing_str):
         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)
@@ -136,7 +226,6 @@ def analyze_nph(image, modality, sensitivity, overlay_alpha, pixel_spacing_str):
             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]
@@ -151,7 +240,6 @@ def analyze_nph(image, modality, sensitivity, overlay_alpha, pixel_spacing_str):
 
         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)
@@ -207,7 +295,241 @@ def analyze_nph(image, modality, sensitivity, overlay_alpha, pixel_spacing_str):
 
 
 # ===========================================================================
-# Tab 2: Filters & Effects
+# Tab 2: YOLO NPH Detection
+# ===========================================================================
+
+def yolo_detect_nph(image, conf_threshold):
+    """Run YOLO model on a brain scan to detect NPH structures."""
+    if image is None:
+        raise gr.Error("Please upload a brain CT or MRI image first.")
+
+    model = _get_yolo_model()
+    if model is None:
+        raise gr.Error(
+            "YOLO model (best.pt) not available. "
+            "Make sure the model file is in the Space repository."
+        )
+
+    with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as f:
+        Image.fromarray(image).save(f.name)
+        temp_path = f.name
+
+    try:
+        results = model(temp_path, verbose=False)[0]
+
+        h, w = image.shape[:2]
+        annotated_img = image.copy()
+        boxes_data = []
+
+        for box in results.boxes:
+            conf = float(box.conf[0])
+            if conf < conf_threshold:
+                continue
+            x1, y1, x2, y2 = [int(round(v)) for v in box.xyxy[0].tolist()]
+            cls_id = int(box.cls[0])
+            cls_name = model.names.get(cls_id, str(cls_id))
+            color = YOLO_COLORS.get(cls_name, (255, 255, 255))
+
+            boxes_data.append({
+                "class": cls_name,
+                "x1": x1, "y1": y1, "x2": x2, "y2": y2,
+                "confidence": round(conf, 4),
+            })
+
+            # Draw bounding box
+            cv2.rectangle(annotated_img, (x1, y1), (x2, y2), color, 2)
+
+            # Label background
+            label = f"{cls_name} {conf:.0%}"
+            (lw, lh), _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1)
+            cv2.rectangle(annotated_img, (x1, y1 - lh - 8), (x1 + lw + 4, y1), color, -1)
+            cv2.putText(annotated_img, label, (x1 + 2, y1 - 4),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0), 1, cv2.LINE_AA)
+
+        # Compute metrics from detected boxes
+        metrics = _derive_yolo_metrics(boxes_data, w, h)
+
+        # Build Gradio annotations for the AnnotatedImage output
+        annotations = []
+        for b in boxes_data:
+            annotations.append((
+                (b["x1"], b["y1"], b["x2"], b["y2"]),
+                f"{b['class']} ({b['confidence']:.0%})"
+            ))
+
+        # Build report
+        report_lines = ["## YOLO NPH Detection Report\n"]
+        report_lines.append(f"**Detections:** {len(boxes_data)} structures found at {conf_threshold:.0%} confidence\n")
+
+        for b in boxes_data:
+            bw = b["x2"] - b["x1"]
+            bh = b["y2"] - b["y1"]
+            report_lines.append(f"- **{b['class']}**: {b['confidence']:.1%} confidence, {bw}x{bh} px at ({b['x1']},{b['y1']})")
+
+        report_lines.append(f"\n### Derived Metrics")
+        ei = metrics.get("evans_index", 0)
+        ei_status = "ABNORMAL (>0.3)" if ei > 0.3 else "Normal"
+        report_lines.append(f"**Evans' Index:** {ei:.3f} -- {ei_status}")
+        report_lines.append(f"**DESH Score:** {metrics.get('desh_score', 0)}/3")
+        report_lines.append(f"**Sylvian Dilation:** {'Yes' if metrics.get('sylvian_dilation') else 'No'}")
+        report_lines.append(f"**PVH Detected:** {'Yes' if metrics.get('periventricular_changes') else 'No'}")
+
+        prob = metrics.get("nph_probability", 0)
+        report_lines.append(f"**NPH Probability:** {prob:.0%}")
+
+        # Auto-compute NPH score from YOLO metrics
+        score_input = {
+            "evansIndex": metrics["evans_index"],
+            "callosalAngle": metrics.get("callosal_angle"),
+            "deshScore": metrics.get("desh_score", 0),
+            "sylvianDilation": metrics.get("sylvian_dilation", False),
+            "vsr": metrics.get("vsr"),
+            "triad": [],
+            "corticalAtrophy": metrics.get("cortical_atrophy", "unknown"),
+        }
+        nph_score = _compute_nph_score(score_input)
+
+        report_lines.append(f"\n### Clinical NPH Score: **{nph_score['score']}/100** -- {nph_score['label']}")
+        report_lines.append(f"*{nph_score['recommendation']}*")
+
+        report = "\n".join(report_lines)
+
+        return (image, annotations), annotated_img, report
+
+    finally:
+        os.unlink(temp_path)
+
+
+def _derive_yolo_metrics(boxes, image_width, image_height):
+    """Compute NPH metrics from YOLO detection boxes."""
+    ventricle = next((b for b in boxes if b["class"] == "ventricle"), None)
+    skull = next((b for b in boxes if b["class"] == "skull_inner"), None)
+
+    if ventricle and skull:
+        vent_w = ventricle["x2"] - ventricle["x1"]
+        skull_w = skull["x2"] - skull["x1"]
+        evans_index = round(vent_w / skull_w, 4) if skull_w > 0 else 0.0
+    elif ventricle:
+        vent_w = ventricle["x2"] - ventricle["x1"]
+        evans_index = round(vent_w / image_width, 4) if image_width > 0 else 0.0
+    else:
+        evans_index = 0.0
+
+    desh_classes = {"tight_convexity", "sylvian_fissure", "pvh"}
+    detected_desh = {b["class"] for b in boxes if b["class"] in desh_classes}
+    desh_score = len(detected_desh)
+
+    sylvian_dilation = any(b["class"] == "sylvian_fissure" for b in boxes)
+    periventricular_changes = any(b["class"] == "pvh" for b in boxes)
+
+    return {
+        "evans_index": evans_index,
+        "callosal_angle": None,
+        "desh_score": desh_score,
+        "sylvian_dilation": sylvian_dilation,
+        "vsr": None,
+        "periventricular_changes": periventricular_changes,
+        "cortical_atrophy": "unknown",
+        "nph_probability": round(sum([evans_index > 0.3, desh_score >= 2, sylvian_dilation]) / 3, 4),
+    }
+
+
+# ===========================================================================
+# Tab 3: NPH Clinical Scoring Calculator
+# ===========================================================================
+
+def compute_clinical_score(
+    evans_index, callosal_angle_str, desh_score,
+    sylvian_dilation, vsr_str,
+    gait, cognition, urinary,
+    cortical_atrophy
+):
+    """Interactive NPH clinical scoring calculator."""
+    callosal = None
+    if callosal_angle_str and callosal_angle_str.strip():
+        try:
+            callosal = float(callosal_angle_str.strip())
+        except ValueError:
+            pass
+
+    vsr = None
+    if vsr_str and vsr_str.strip():
+        try:
+            vsr = float(vsr_str.strip())
+        except ValueError:
+            pass
+
+    triad = [gait, cognition, urinary]
+
+    atrophy_map = {
+        "None/Mild": "none",
+        "Moderate": "moderate",
+        "Significant": "significant",
+    }
+
+    score_data = {
+        "evansIndex": evans_index,
+        "callosalAngle": callosal,
+        "deshScore": int(desh_score),
+        "sylvianDilation": sylvian_dilation,
+        "vsr": vsr,
+        "triad": triad,
+        "corticalAtrophy": atrophy_map.get(cortical_atrophy, "unknown"),
+    }
+
+    result = _compute_nph_score(score_data)
+
+    # Build detailed breakdown
+    lines = []
+    lines.append(f"# NPH Score: {result['score']}/100")
+    lines.append(f"## {result['label']}\n")
+    lines.append(f"{result['recommendation']}\n")
+
+    lines.append("---\n### Input Summary\n")
+    lines.append(f"- **Evans' Index:** {evans_index:.3f}" + (" (>0.3 = abnormal)" if evans_index > 0.3 else ""))
+    if callosal is not None:
+        lines.append(f"- **Callosal Angle:** {callosal:.1f} deg" + (" (<90 = suggestive)" if callosal < 90 else ""))
+    else:
+        lines.append("- **Callosal Angle:** Not provided")
+    lines.append(f"- **DESH Score:** {int(desh_score)}/3")
+    lines.append(f"- **Sylvian Dilation:** {'Yes' if sylvian_dilation else 'No'}")
+    if vsr is not None:
+        lines.append(f"- **VSR:** {vsr:.2f}" + (" (>2.0 = strong NPH indicator)" if vsr > 2.0 else ""))
+    else:
+        lines.append("- **VSR:** Not available")
+    triad_count = sum(triad)
+    lines.append(f"- **Hakim Triad:** {triad_count}/3 (Gait: {'Yes' if gait else 'No'}, Cognition: {'Yes' if cognition else 'No'}, Urinary: {'Yes' if urinary else 'No'})")
+    lines.append(f"- **Cortical Atrophy:** {cortical_atrophy}")
+
+    lines.append("\n---\n### Scoring Weights\n")
+    if vsr is not None:
+        lines.append("| Component | Weight | Status |")
+        lines.append("|---|---|---|")
+        lines.append(f"| VSR | 40% | {'Contributing' if vsr and vsr > 2.0 else 'Not met'} |")
+        lines.append(f"| Evans Index | 25% | {'Contributing' if evans_index > 0.3 else 'Not met'} |")
+        lines.append(f"| Callosal Angle | 20% | {'Contributing' if callosal and callosal < 90 else 'N/A' if callosal is None else 'Not met'} |")
+        lines.append(f"| DESH Pattern | 10% | {int(desh_score)}/3 |")
+        lines.append(f"| Sylvian Fissure | 5% | {'Contributing' if sylvian_dilation else 'Not met'} |")
+    else:
+        lines.append("*VSR not available -- weights redistributed across remaining criteria.*\n")
+        lines.append("| Component | Weight (adjusted) | Status |")
+        lines.append("|---|---|---|")
+        lines.append(f"| Evans Index | 41.7% | {'Contributing' if evans_index > 0.3 else 'Not met'} |")
+        lines.append(f"| Callosal Angle | 33.3% | {'Contributing' if callosal and callosal < 90 else 'N/A' if callosal is None else 'Not met'} |")
+        lines.append(f"| DESH Pattern | 16.7% | {int(desh_score)}/3 |")
+        lines.append(f"| Sylvian Fissure | 8.3% | {'Contributing' if sylvian_dilation else 'Not met'} |")
+
+    if triad_count >= 2:
+        lines.append(f"\n**Triad Bonus:** +{15 if triad_count == 3 else 5}% (Hakim triad {'complete' if triad_count == 3 else 'partial'})")
+    if cortical_atrophy in ("Moderate", "Significant"):
+        penalty = 30 if cortical_atrophy == "Significant" else 15
+        lines.append(f"\n**Atrophy Penalty:** -{penalty}% (suggests ex-vacuo component)")
+
+    return "\n".join(lines)
+
+
+# ===========================================================================
+# Tabs 4-8: Filters & ML Models
 # ===========================================================================
 
 def apply_filter(image, effect, intensity):
@@ -252,10 +574,6 @@ def apply_filter(image, effect, intensity):
     return np.array(filtered)
 
 
-# ===========================================================================
-# Tab 3-5: ML Models
-# ===========================================================================
-
 def classify_image(image):
     if image is None:
         raise gr.Error("Please upload an image first.")
@@ -299,11 +617,12 @@ css = """
 with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
     gr.Markdown("# Image Processing Studio", elem_classes="main-title")
     gr.Markdown(
-        "Filters, classification, object detection, panoptic segmentation, and **NPH neuroimaging analysis** -- all in one place.",
+        "Filters, classification, object detection, panoptic segmentation, **YOLO NPH detection**, "
+        "clinical NPH scoring, and **intensity-based NPH analysis** -- all in one place.",
         elem_classes="subtitle"
     )
 
-    # ── NPH Analysis Tab ──
+    # ── Tab 1: NPH Analysis (Intensity-based) ──
     with gr.Tab("NPH Analysis"):
         gr.Markdown(
             "### Normal Pressure Hydrocephalus -- Segmentation & Biomarkers\n"
@@ -368,7 +687,110 @@ with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
                 "For clinical use, provide pixel spacing from the DICOM header.*"
             )
 
-    # ── Client-Side NPH Detector Tab ──
+    # ── Tab 2: YOLO NPH Detection ──
+    with gr.Tab("YOLO NPH Detection"):
+        gr.Markdown(
+            "### Deep Learning NPH Structure Detection\n"
+            "Uses a trained YOLOv8 model to detect NPH-related structures on brain CT/MRI slices: "
+            "**ventricle**, **sylvian fissure**, **tight convexity**, **PVH**, and **skull inner boundary**.\n\n"
+            "The model outputs bounding boxes with confidence scores, computes Evans' Index from "
+            "detected structures, and generates an overall NPH clinical score."
+        )
+        with gr.Row():
+            with gr.Column(scale=1):
+                yolo_input = gr.Image(label="Upload Brain Scan", type="numpy")
+                yolo_conf = gr.Slider(
+                    minimum=0.1, maximum=0.95, value=0.25, step=0.05,
+                    label="Confidence Threshold"
+                )
+                yolo_btn = gr.Button("Detect NPH Structures", variant="primary", size="lg")
+
+            with gr.Column(scale=2):
+                yolo_annotated = gr.AnnotatedImage(label="Detected Structures")
+                yolo_overlay = gr.Image(label="Annotated Image", type="numpy")
+
+        yolo_report = gr.Markdown(label="YOLO Detection Report")
+
+        yolo_btn.click(
+            fn=yolo_detect_nph,
+            inputs=[yolo_input, yolo_conf],
+            outputs=[yolo_annotated, yolo_overlay, yolo_report]
+        )
+
+        with gr.Accordion("YOLO Model Details", open=False):
+            gr.Markdown(
+                "**Model:** YOLOv8 fine-tuned on NPH brain CT/MRI dataset\n\n"
+                "**Detected Classes:**\n\n"
+                "| Class | Description | Color |\n"
+                "|---|---|---|\n"
+                "| ventricle | Lateral ventricles | Blue |\n"
+                "| sylvian_fissure | Sylvian fissures (bilateral) | Purple |\n"
+                "| tight_convexity | Tight high-convexity sulci | Orange |\n"
+                "| pvh | Periventricular hyperintensities | Yellow |\n"
+                "| skull_inner | Inner skull boundary | Gray |\n\n"
+                "**Evans' Index** is computed from the ventricle and skull inner boundary boxes. "
+                "If no skull boundary is detected, the image width is used as fallback.\n\n"
+                "**NPH Score** is computed using the weighted formula: "
+                "VSR (40%) + Evans Index (25%) + Callosal Angle (20%) + DESH (10%) + Sylvian (5%), "
+                "with bonuses for Hakim triad and penalties for cortical atrophy."
+            )
+
+    # ── Tab 3: NPH Clinical Scoring Calculator ──
+    with gr.Tab("NPH Score Calculator"):
+        gr.Markdown(
+            "### Clinical NPH Scoring Calculator\n"
+            "Enter imaging biomarkers and clinical findings to compute a weighted NPH probability score.\n\n"
+            "This calculator uses the same scoring formula as the YOLO detection tab but lets you "
+            "input values manually -- useful for combining measurements from different imaging studies."
+        )
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("#### Imaging Biomarkers")
+                calc_evans = gr.Slider(
+                    minimum=0.0, maximum=0.6, value=0.30, step=0.01,
+                    label="Evans' Index"
+                )
+                calc_callosal = gr.Textbox(
+                    label="Callosal Angle (degrees)",
+                    placeholder="e.g. 85 (leave blank if not measured)",
+                    value=""
+                )
+                calc_desh = gr.Slider(
+                    minimum=0, maximum=3, value=0, step=1,
+                    label="DESH Score (0-3)"
+                )
+                calc_sylvian = gr.Checkbox(label="Sylvian Fissure Dilation", value=False)
+                calc_vsr = gr.Textbox(
+                    label="VSR (Ventricle-to-SAS Ratio)",
+                    placeholder="e.g. 2.5 (leave blank if not measured)",
+                    value=""
+                )
+
+            with gr.Column():
+                gr.Markdown("#### Clinical Findings (Hakim Triad)")
+                calc_gait = gr.Checkbox(label="Gait disturbance", value=False)
+                calc_cognition = gr.Checkbox(label="Cognitive impairment", value=False)
+                calc_urinary = gr.Checkbox(label="Urinary incontinence", value=False)
+
+                gr.Markdown("#### Modifiers")
+                calc_atrophy = gr.Radio(
+                    choices=["None/Mild", "Moderate", "Significant"],
+                    value="None/Mild",
+                    label="Cortical Atrophy"
+                )
+
+                calc_btn = gr.Button("Calculate NPH Score", variant="primary", size="lg")
+
+        calc_report = gr.Markdown(label="NPH Score Report")
+
+        calc_btn.click(
+            fn=compute_clinical_score,
+            inputs=[calc_evans, calc_callosal, calc_desh, calc_sylvian, calc_vsr,
+                    calc_gait, calc_cognition, calc_urinary, calc_atrophy],
+            outputs=calc_report
+        )
+
+    # ── Tab 4: Client-Side NPH Detector ──
     with gr.Tab("NPH Detector (Browser)"):
         gr.Markdown(
             "### Client-Side NPH Detector\n"
@@ -383,7 +805,7 @@ with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
                   'style="border-radius: 12px; border: 1px solid #333;"></iframe>',
         )
 
-    # ── Video Demo Tab ──
+    # ── Tab 5: Video Demo ──
     with gr.Tab("Video Demo"):
         gr.Markdown(
             "### Whole-Brain Segmentation Demo\n"
@@ -395,7 +817,7 @@ with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
             autoplay=False,
         )
 
-    # ── Filters Tab ──
+    # ── Tab 6: Filters ──
     with gr.Tab("Filters & Effects"):
         with gr.Row():
             with gr.Column():
@@ -411,7 +833,7 @@ with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
                 filter_output = gr.Image(label="Result", type="numpy")
         filter_btn.click(fn=apply_filter, inputs=[filter_input, filter_effect, filter_intensity], outputs=filter_output)
 
-    # ── Classification Tab ──
+    # ── Tab 7: Classification ──
     with gr.Tab("Image Classification"):
         with gr.Row():
             with gr.Column():
@@ -421,7 +843,7 @@ with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
                 cls_output = gr.Label(label="Predictions", num_top_classes=5)
         cls_btn.click(fn=classify_image, inputs=cls_input, outputs=cls_output)
 
-    # ── Object Detection Tab ──
+    # ── Tab 8: Object Detection ──
     with gr.Tab("Object Detection"):
         with gr.Row():
             with gr.Column():
@@ -432,7 +854,7 @@ with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
                 det_output = gr.AnnotatedImage(label="Detections")
         det_btn.click(fn=detect_objects, inputs=[det_input, det_threshold], outputs=det_output)
 
-    # ── Segmentation Tab ──
+    # ── Tab 9: Segmentation ──
     with gr.Tab("Segmentation"):
         with gr.Row():
             with gr.Column():