Update app.py

app.py

@@ -1,22 +1,20 @@
 # app.py
-# Gradio — TBNet (CNN model) + Lung U-Net Auto Mask + Grad-CAM + RADIO (visual model)
+# Gradio — TBNet + Lung U-Net Auto Mask + Grad-CAM + RADIO
 # + SAFER PHONE MODE + MASK POST-PROCESSING + MASK SANITY FAILSAFE
-# + 3-STATE AGREEMENT (LOW / SCREEN+ / TB+)
+# + 3-STATE CONSENSUS (LOW / INDET / SCREEN+)
 #
-# Requirements (requirements.txt):
-#   gradio
-#   torch
-#   torchvision
-#   timm
-#   opencv-python
-#   pillow
-#   transformers
-#   einops
-#   open_clip_torch
+# HF Spaces: use relative weight paths (edit below if needed)
 #
-# HF Spaces notes:
-# - weights are expected in ./weights/
-# - app launches on 0.0.0.0:7860
+# Requirements (requirements.txt):
+# gradio
+# torch
+# torchvision
+# timm
+# opencv-python
+# pillow
+# transformers
+# einops
+# open_clip_torch
 
 import os
 import cv2
@@ -30,22 +28,24 @@ import gradio as gr
 from torchvision import transforms
 from typing import List, Tuple, Dict, Any, Optional
 
-# RADIO deps (same env as TBNet)
 from transformers import AutoModel, CLIPImageProcessor
 from einops import rearrange
 from PIL import Image
 
 
 # ============================================================
-# USER CONFIG (HF Spaces friendly)
+# USER CONFIG
 # ============================================================
 
+# ---- Friendly names (UI) ----
 MODEL_NAME_TBNET = "TBNet (CNN model)"
 MODEL_NAME_RADIO = "RADIO (visual model)"
 
+# ---- Default TB/Lung weights (HF-friendly relative paths) ----
 DEFAULT_TB_WEIGHTS = "weights/best.pt"
 DEFAULT_LUNG_WEIGHTS = "weights/lung_unet_mont_shenzhen.pt"
 
+# ---- RADIO config (same env as TB) ----
 RADIO_HF_REPO = "nvidia/C-RADIOv4-SO400M"
 RADIO_REVISION = "c0457f5dc26ca145f954cd4fc5bb6114e5705ad8"
 
@@ -59,13 +59,19 @@ RADIO_THR_RED = 0.23
 RADIO_MASKED_MIN_COV = 0.15
 RADIO_GATE_DEFAULT = 0.21
 
+# ---- Consensus logic thresholds ----
 TBNET_SCREEN_THR = 0.30
+TBNET_MARGIN = 0.03   # (kept for compatibility / future use)
+
 RADIO_SCREEN_THR = RADIO_THR_SCREEN
+RADIO_MARGIN = 0.02   # (kept for compatibility / future use)
 
+# ---- Mask fail-safes ----
 FAIL_COV = 0.10
 WARN_COV = 0.18
 FAILSAFE_ON_BAD_MASK = True
 
+# ---- Device policy ----
 FORCE_CPU = True
 DEVICE = torch.device("cpu" if FORCE_CPU else ("cuda" if torch.cuda.is_available() else "cpu"))
 
@@ -75,15 +81,15 @@ DEVICE = torch.device("cpu" if FORCE_CPU else ("cuda" if torch.cuda.is_available
 # ============================================================
 CLINICAL_DISCLAIMER = """
 ⚠️ IMPORTANT CLINICAL NOTICE (Decision Support Only)
-
-This system is for **research/decision support** and is **NOT** a diagnostic device.
-It may **miss early/subtle tuberculosis**, including **miliary TB**.
-Phone photos / screenshots / downsampled images can reduce reliability.
+This AI system is for **research/decision support** and is NOT a diagnostic device.
+It may NOT reliably detect early/subtle tuberculosis, including **MILIARY TB**,
+which can appear near-normal or subtle on chest X-ray (especially on phone photos / WhatsApp images).
 
 If clinical suspicion exists (fever, weight loss, immunosuppression, known exposure),
 recommend **CBNAAT / GeneXpert**, sputum studies, and/or **CT chest** regardless of AI output.
 """
 
+# Friendly labels still map to GREEN/YELLOW/RED logic
 REPORT_LABELS = {
     "GREEN": {
         "title": "LOW TB LIKELIHOOD",
@@ -120,60 +126,20 @@ CLINICAL_GUIDANCE = (
 
 
 # ============================================================
-# USER-FRIENDLY SUMMARY BUILDER
+# NEW: OVERALL LABEL FOR TABLE (user-friendly)
 # ============================================================
-def overall_summary(tb_band: Optional[str],
-                    tb_prob: Optional[float],
-                    radio_primary: Optional[float],
-                    radio_band: Optional[str],
-                    consensus_label: str,
-                    q_score: float,
-                    cov: float,
-                    warnings: List[str]) -> str:
-    # Overall label from agreement (keeps it simple for users)
+def overall_label_from_consensus(consensus_label: str, tb_prob: Optional[float]) -> str:
     if tb_prob is None:
-        overall_title = "INDETERMINATE — NEEDS REVIEW"
-        icon = "⚠️"
-    else:
-        if "AGREE: LOW" in consensus_label:
-            overall_title = "LOW TB LIKELIHOOD"
-            icon = "✅"
-        elif "AGREE: TB+" in consensus_label:
-            overall_title = "TB FEATURES SUSPECTED"
-            icon = "🚩"
-        elif "AGREE: SCREEN+" in consensus_label:
-            overall_title = "SCREEN-POSITIVE — REVIEW RECOMMENDED"
-            icon = "⚠️"
-        else:
-            overall_title = "INDETERMINATE — REVIEW RECOMMENDED"
-            icon = "⚠️"
-
-    reliability = "Good" if (q_score >= 70 and cov >= WARN_COV) else "Limited"
-    rel_icon = "🟢" if reliability == "Good" else "🟡"
-
-    warn_line = "None" if not warnings else f"{len(warnings)} note(s) below"
-
-    tb_prob_str = "N/A" if tb_prob is None else f"{tb_prob:.4f}"
-    radio_str = "N/A" if radio_primary is None else f"{radio_primary:.4f}"
-
-    return f"""
-## {icon} Overall screening result: **{overall_title}**
-
-**Reliability:** {rel_icon} **{reliability}** (Quality: {q_score:.0f}/100 • Lung coverage: {cov*100:.1f}% • Notes: {warn_line})
-
-### What this means
-- This is a **screening support tool**, not a diagnosis.
-- Two models analyze the same image: a **CNN model** (TBNet) and a **visual model** (RADIO).
-
-### Model agreement
-- **{consensus_label}**
-- {MODEL_NAME_TBNET} probability: **{tb_prob_str}**
-- {MODEL_NAME_RADIO} probability: **{radio_str}** {f"(band={radio_band})" if radio_band else ""}
-
-### What to do next
-- If you have symptoms/risk factors, seek clinician/radiologist review.
-- If TB is clinically suspected, consider **CBNAAT/GeneXpert** and sputum testing regardless of AI output.
-"""
+        return "⚠️ INDETERMINATE"
+    if "AGREE: LOW" in consensus_label:
+        return "✅ LOW"
+    if "AGREE: SCREEN+" in consensus_label:
+        return "⚠️ SCREEN+"
+    if "AGREE: TB+" in consensus_label:
+        return "🚩 TB+"
+    if "DISAGREE" in consensus_label:
+        return "⚠️ DISAGREE"
+    return "⚠️ INDET"
 
 
 # ============================================================
@@ -190,9 +156,7 @@ class DoubleConv(nn.Module):
             nn.BatchNorm2d(out_c),
             nn.ReLU(inplace=True),
         )
-
-    def forward(self, x):
-        return self.net(x)
+    def forward(self, x): return self.net(x)
 
 class LungUNet(nn.Module):
     def __init__(self):
@@ -234,9 +198,7 @@ class TBNet(nn.Module):
         super().__init__()
         self.backbone = timm.create_model(backbone, pretrained=False, num_classes=0, global_pool="avg")
         self.fc = nn.Linear(self.backbone.num_features, 1)
-
-    def forward(self, x):
-        return self.fc(self.backbone(x)).view(-1)
+    def forward(self, x): return self.fc(self.backbone(x)).view(-1)
 
 def load_tb_weights(model: nn.Module, ckpt_path: str, device: torch.device):
     sd = torch.load(ckpt_path, map_location=device)
@@ -250,11 +212,8 @@ class GradCAM:
         target_layer.register_forward_hook(self._fwd)
         target_layer.register_full_backward_hook(self._bwd)
 
-    def _fwd(self, _, __, out):
-        self.activ = out
-
-    def _bwd(self, _, grad_in, grad_out):
-        self.grad = grad_out[0]
+    def _fwd(self, _, __, out): self.activ = out
+    def _bwd(self, _, grad_in, grad_out): self.grad = grad_out[0]
 
     def generate(self, x: torch.Tensor) -> Tuple[np.ndarray, float, float]:
         with torch.enable_grad():
@@ -312,8 +271,7 @@ def border_fraction(gray_u8: np.ndarray) -> float:
     bot = gray_u8[-b:, :]
     left = gray_u8[:, :b]
     right = gray_u8[:, -b:]
-    def frac_border(x):
-        return float(((x < 15) | (x > 240)).mean())
+    def frac_border(x): return float(((x < 15) | (x > 240)).mean())
     return float(np.mean([frac_border(top), frac_border(bot), frac_border(left), frac_border(right)]))
 
 def phone_quality_report(gray_u8: np.ndarray) -> Tuple[float, List[str]]:
@@ -328,34 +286,26 @@ def phone_quality_report(gray_u8: np.ndarray) -> Tuple[float, List[str]]:
     sharp = laplacian_sharpness(gray_u8)
     lo_clip, hi_clip = exposure_scores(gray_u8)
     border = border_fraction(gray_u8)
-
     likely_phone = (border > 0.35) or (lo_clip > 0.10) or (hi_clip > 0.05)
 
     if likely_phone:
         if sharp < 40:
-            score -= 25
-            warnings.append("Blurry / motion blur detected (likely phone capture).")
+            score -= 25; warnings.append("Blurry / motion blur detected (likely phone capture).")
         elif sharp < 80:
-            score -= 12
-            warnings.append("Slight blur detected.")
+            score -= 12; warnings.append("Slight blur detected.")
     else:
         if sharp < 30:
-            score -= 8
-            warnings.append("Low fine detail (possible downsampling).")
+            score -= 8; warnings.append("Low fine detail (possible downsampling).")
 
     if hi_clip > 0.05:
-        score -= 15
-        warnings.append("Overexposed highlights (washed-out areas).")
+        score -= 15; warnings.append("Overexposed highlights (washed-out areas).")
     if lo_clip > 0.10:
-        score -= 12
-        warnings.append("Underexposed shadows (very dark areas).")
+        score -= 12; warnings.append("Underexposed shadows (very dark areas).")
 
     if border > 0.55:
-        score -= 18
-        warnings.append("Large border/margins detected (possible screenshot/phone framing).")
+        score -= 18; warnings.append("Large border/margins detected (possible screenshot/phone framing).")
     elif border > 0.35:
-        score -= 10
-        warnings.append("Some border/margins detected.")
+        score -= 10; warnings.append("Some border/margins detected.")
 
     return float(np.clip(score, 0, 100)), warnings
 
@@ -363,22 +313,19 @@ def auto_border_crop(gray_u8: np.ndarray) -> np.ndarray:
     g = gray_u8.copy()
     g_blur = cv2.GaussianBlur(g, (5, 5), 0)
     _, th = cv2.threshold(g_blur, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
-    if th.mean() > 127:
-        th = 255 - th
+    if th.mean() > 127: th = 255 - th
 
     k = max(3, int(0.01 * min(g.shape)))
     kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (k, k))
     th = cv2.morphologyEx(th, cv2.MORPH_CLOSE, kernel, iterations=2)
 
     contours, _ = cv2.findContours(th, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    if not contours:
-        return gray_u8
+    if not contours: return gray_u8
 
     c = max(contours, key=cv2.contourArea)
     x, y, w, h = cv2.boundingRect(c)
     H, W = gray_u8.shape
-    if w * h < 0.20 * (H * W):
-        return gray_u8
+    if w * h < 0.20 * (H * W): return gray_u8
 
     pad = int(0.03 * min(H, W))
     x1 = max(0, x - pad); y1 = max(0, y - pad)
@@ -395,7 +342,6 @@ def phone_preprocess(gray_u8: np.ndarray) -> np.ndarray:
     border = border_fraction(gray_u8)
 
     g = gray_u8
-
     if border > 0.35:
         cropped = auto_border_crop(g)
         if cropped.size >= 0.70 * g.size:
@@ -439,7 +385,7 @@ def fill_holes(binary_u8: np.ndarray) -> np.ndarray:
     m = (binary_u8 * 255).astype(np.uint8)
     h, w = m.shape
     flood = m.copy()
-    mask = np.zeros((h + 2, w + 2), np.uint8)
+    mask = np.zeros((h+2, w+2), np.uint8)
     cv2.floodFill(flood, mask, (0, 0), 255)
     holes = cv2.bitwise_not(flood)
     filled = cv2.bitwise_or(m, holes)
@@ -482,7 +428,7 @@ def mask_sanity_warnings(mask_full_u8: np.ndarray) -> List[str]:
 
     border = np.concatenate([m[0, :], m[-1, :], m[:, 0], m[:, -1]])
     if border.mean() > 0.05:
-        warns.append("Lung mask touches the image border (possible cropped/non-standard CXR).")
+        warns.append("Lung mask touches image border (possible cropped/non-standard CXR).")
 
     if total > 0 and (top1 + top2) / total < 0.90:
         warns.append("Mask appears fragmented (may reduce reliability).")
@@ -491,14 +437,14 @@ def mask_sanity_warnings(mask_full_u8: np.ndarray) -> List[str]:
 
 def recommendation_for_band(band: Optional[str]) -> str:
     if band in (None, "YELLOW"):
-        return "Radiologist/clinician review is recommended (result is indeterminate)."
+        return "✅ Recommendation: Radiologist/clinician review is recommended (result is indeterminate)."
     if band == "RED":
-        return "Urgent clinical review + microbiological confirmation (CBNAAT/GeneXpert, sputum) recommended."
-    return "If symptoms/risk factors exist, clinical correlation is advised."
+        return "✅ Recommendation: Urgent clinician/radiologist review + microbiological confirmation (CBNAAT/GeneXpert, sputum)."
+    return "✅ Recommendation: If symptoms/risk factors exist, clinician/radiologist correlation is advised."
 
 
 # ============================================================
-# AGREEMENT LOGIC (TBNet vs RADIO)
+# CONSENSUS LOGIC (TBNet vs RADIO) — 3-state
 # ============================================================
 def tbnet_state(tb_prob: float, tb_band: str) -> str:
     if tb_band == "RED":
@@ -523,7 +469,7 @@ def build_consensus(
 ) -> Tuple[str, str]:
 
     if tb_prob is None or tb_band is None:
-        return ("N/A", f"{MODEL_NAME_TBNET} not available (lung segmentation failed / fail-safe).")
+        return ("N/A", f"{MODEL_NAME_TBNET} unavailable (lung segmentation failed / fail-safe).")
 
     if radio_masked is not None:
         radio_primary = radio_masked
@@ -533,27 +479,27 @@ def build_consensus(
         radio_used = "RAW"
 
     if radio_primary is None:
-        return ("TBNet only", f"{MODEL_NAME_RADIO} not available → {MODEL_NAME_TBNET}={tb_prob:.4f} (band={tb_band}).")
+        return ("TBNet only", f"{MODEL_NAME_RADIO} unavailable → {MODEL_NAME_TBNET}={tb_prob:.4f} (band={tb_band}).")
 
     t = tbnet_state(tb_prob, tb_band)
     r = radio_state_from_prob(radio_primary)
-    rb = f" (band={radio_band})" if radio_band else ""
+    rb = f" (RADIO band={radio_band})" if radio_band else ""
 
     if t == r:
         return (
             f"AGREE: {t}",
-            f"Both models indicate **{t}**. {MODEL_NAME_TBNET}={tb_prob:.4f}, {MODEL_NAME_RADIO}({radio_used})={radio_primary:.4f}{rb}."
+            f"Both: {t}. {MODEL_NAME_TBNET}={tb_prob:.4f}, {MODEL_NAME_RADIO}({radio_used})={radio_primary:.4f}{rb}."
         )
 
     if (t in ("SCREEN+", "TB+") and r == "LOW") or (r in ("SCREEN+", "TB+") and t == "LOW"):
         return (
             "DISAGREE",
-            f"Models disagree: {MODEL_NAME_TBNET} suggests **{t}** vs {MODEL_NAME_RADIO} suggests **{r}** ({radio_used})={radio_primary:.4f}{rb}."
+            f"Strong disagreement: {MODEL_NAME_TBNET}={t} (band={tb_band}) vs {MODEL_NAME_RADIO}={r} ({radio_used})={radio_primary:.4f}{rb}."
         )
 
     return (
         "MIXED/INDET",
-        f"Mixed signals: {MODEL_NAME_TBNET} suggests **{t}** vs {MODEL_NAME_RADIO} suggests **{r}** ({radio_used})={radio_primary:.4f}{rb}."
+        f"Mixed/uncertain: {MODEL_NAME_TBNET}={t} (band={tb_band}) vs {MODEL_NAME_RADIO}={r} ({radio_used})={radio_primary:.4f}{rb}."
     )
 
 
@@ -612,7 +558,6 @@ class RadioMLPHead(nn.Module):
             nn.Dropout(dropout),
             nn.Linear(hidden, 1),
         )
-
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         return self.net(x).squeeze(1)
 
@@ -796,6 +741,7 @@ def analyze_one_image(
         mask256 = torch.sigmoid(mask_logits)[0, 0].cpu().numpy()
 
     mask256_bin = (mask256 > 0.5).astype(np.uint8)
+
     mask256_bin = keep_top_k_components(mask256_bin, k=2)
     k = max(3, int(0.02 * 256))
     kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (k, k))
@@ -812,14 +758,11 @@ def analyze_one_image(
             "logit": None,
             "pred": "INDETERMINATE",
             "band": "YELLOW",
-            "band_text": (
-                "⚠️ Lung segmentation looks unreliable, so the TBNet screening score is disabled for safety.\n\n"
-                "Please use a clearer standard frontal CXR (PA/AP) or seek radiologist review."
-            ),
+            "band_text": "Lung segmentation failed. TB scoring disabled (fail-safe).",
             "quality_score": float(q_score),
             "diffuse_risk": False,
             "warnings": (
-                [f"Lung segmentation coverage too small ({coverage*100:.1f}%)."]
+                ["Lung segmentation failed (<10% lung area).", f"Lung coverage: {coverage*100:.1f}%"]
                 + (["Phone/WhatsApp mode enabled; artifacts possible."] if phone_mode else [])
                 + q_warn
             ),
@@ -842,11 +785,7 @@ def analyze_one_image(
             "logit": None,
             "pred": "INDETERMINATE",
             "band": "YELLOW",
-            "band_text": (
-                "⚠️ The image appears cropped/non-standard (mask sanity check). "
-                "TBNet screening score is disabled for safety.\n\n"
-                "Please use a standard frontal CXR (PA/AP) or seek radiologist review."
-            ),
+            "band_text": "Non-standard/cropped view or unreliable lung segmentation. TB scoring disabled (fail-safe).",
             "quality_score": float(q_score),
             "diffuse_risk": False,
             "warnings": (
@@ -883,38 +822,28 @@ def analyze_one_image(
     diffuse = detect_diffuse_risk(prob_tb, cam_up, q_score)
     band_base, _ = confidence_band(prob_tb, q_score, diffuse)
 
-    allow_red = (prob_tb >= 0.70 and q_score >= 55 and (not diffuse) and coverage >= warn_cov)
+    allow_red = (prob_tb >= 0.70 and q_score >= 55 and not diffuse and coverage >= warn_cov)
     band = "RED" if allow_red else band_base
 
     pred = REPORT_LABELS[band]["title"]
     band_text = REPORT_LABELS[band]["summary"]
 
-    if band == "YELLOW" and prob_tb < 0.05:
-        band_text = (
-            "⚠️ TB probability is very low, but the result is marked **indeterminate** because reliability is limited.\n\n"
-            + band_text
-        )
-
     heat = cv2.applyColorMap((cam_up * 255).astype(np.uint8), cv2.COLORMAP_JET)
     overlay_clean = cv2.addWeighted(rgb, 0.65, heat, 0.35, 0)
 
     overlay_annotated = overlay_clean.copy()
     text1 = f"{band}: {pred}"
-    text2 = f"TBNet prob={prob_tb:.3f} | Quality={q_score:.0f}/100 | Lung coverage={coverage*100:.1f}%"
+    text2 = f"TB prob={prob_tb:.3f} | Quality={q_score:.0f}/100 | Lung coverage={coverage*100:.1f}%"
     cv2.putText(overlay_annotated, text1, (8, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.52, (255, 255, 255), 2)
     cv2.putText(overlay_annotated, text1, (8, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.52, (0, 0, 0), 1)
     cv2.putText(overlay_annotated, text2, (8, 42), cv2.FONT_HERSHEY_SIMPLEX, 0.50, (255, 255, 255), 2)
     cv2.putText(overlay_annotated, text2, (8, 42), cv2.FONT_HERSHEY_SIMPLEX, 0.50, (0, 0, 0), 1)
 
     warnings = []
-    if phone_mode:
-        warnings.append("Phone/WhatsApp mode enabled; artifacts possible.")
-    if q_score < 55:
-        warnings.append("Image quality is low; reliability may be reduced.")
-    if coverage < warn_cov:
-        warnings.append(f"Partial lung segmentation ({coverage*100:.1f}% coverage).")
-    if diffuse:
-        warnings.append("Non-focal attention pattern; result treated cautiously.")
+    if phone_mode: warnings.append("Phone/WhatsApp mode enabled; artifacts possible.")
+    if q_score < 55: warnings.append("Suboptimal image quality limits AI reliability.")
+    if coverage < warn_cov: warnings.append(f"Partial lung segmentation ({coverage*100:.1f}% coverage).")
+    if diffuse: warnings.append("Diffuse, non-focal AI attention pattern; TB-specific features not identified.")
     warnings.extend(q_warn)
 
     return {
@@ -969,7 +898,7 @@ def run_analysis(
 
         img = cv2.imread(path, cv2.IMREAD_COLOR)
         if img is None:
-            rows.append([name, "", "SKIP", "", "Unreadable image", "", "", "", "", ""])
+            rows.append([name, "⚠️", "SKIP", "", "Unreadable image", "", "", "", ""])
             continue
 
         out = analyze_one_image(
@@ -983,16 +912,16 @@ def run_analysis(
         )
 
         # RADIO (optional)
-        radio_text = f"{MODEL_NAME_RADIO} is disabled."
+        radio_text = f"{MODEL_NAME_RADIO} disabled."
         radio_raw_overlay = None
         radio_masked_overlay = None
+
         radio_raw_val: Optional[float] = None
         radio_masked_val: Optional[float] = None
         radio_primary_val: Optional[float] = None
         radio_band: Optional[str] = None
 
-        radio_raw_str = ""
-        radio_masked_str = ""
+        radio_result_short = "Disabled"
 
         if use_radio and out["prob"] is not None:
             try:
@@ -1007,20 +936,18 @@ def run_analysis(
                 radio_primary_val = float(r["prob_primary"])
                 radio_masked_val = None if r["masked_prob"] is None else float(r["masked_prob"])
                 radio_band = str(r["band"])
-
-                radio_raw_str = f"{radio_raw_val:.4f}"
-                radio_masked_str = "" if radio_masked_val is None else f"{radio_masked_val:.4f}"
+                radio_result_short = str(r["pred"])
 
                 radio_text = (
-                    f"**{MODEL_NAME_RADIO} result:** {r['pred']} | "
-                    f"PRIMARY={radio_primary_val:.4f} | RAW={radio_raw_val:.4f}"
+                    f"**{MODEL_NAME_RADIO}:** {r['pred']} | PRIMARY={radio_primary_val:.4f} | RAW={radio_raw_val:.4f}"
                     + (f" | MASKED={radio_masked_val:.4f}" if radio_masked_val is not None else "")
-                    + f" | Band={radio_band}"
+                    + (f" | Band={radio_band}" if radio_band else "")
                 )
                 radio_raw_overlay = r["raw_overlay"]
                 radio_masked_overlay = r["masked_overlay"]
             except Exception as e:
                 radio_text = f"{MODEL_NAME_RADIO} error: {type(e).__name__}: {e}"
+                radio_result_short = "Error"
                 radio_raw_val = None
                 radio_masked_val = None
                 radio_primary_val = None
@@ -1034,24 +961,24 @@ def run_analysis(
             radio_band=radio_band,
         )
 
-        # Table row
-        prob_str = "" if out["prob"] is None else f"{out['prob']:.4f}"
-        cov_str = f"{out.get('lung_coverage', 0.0) * 100:.1f}%"
+        overall = overall_label_from_consensus(consensus_label, out["prob"])
+
+        tb_prob_str = "" if out["prob"] is None else f"{out['prob']:.4f}"
+        radio_prob_primary_str = "" if radio_primary_val is None else f"{radio_primary_val:.4f}"
 
         rows.append([
             name,
-            prob_str,
+            overall,
             out["pred"],
-            out["band"],
-            out["band_text"],
+            tb_prob_str,
+            radio_result_short,
+            radio_prob_primary_str,
             f"{out['quality_score']:.0f}",
-            cov_str,
-            radio_raw_str,
-            radio_masked_str,
+            f"{out.get('lung_coverage', 0.0) * 100:.1f}%",
             consensus_label,
         ])
 
-        # Gallery
+        # Visual outputs
         orig_rgb = cv2.cvtColor(cv2.resize(out["orig_gray"], (512, 512)), cv2.COLOR_GRAY2RGB)
         vis_rgb = cv2.cvtColor(cv2.resize(out["vis_gray"], (512, 512)), cv2.COLOR_GRAY2RGB)
         mask_overlay = cv2.resize(out["mask_overlay"], (512, 512))
@@ -1060,11 +987,9 @@ def run_analysis(
         gallery_items.append((orig_rgb, f"{name} • ORIGINAL"))
         gallery_items.append((vis_rgb, f"{name} • PHONE-PROC" if phone_mode else f"{name} • INPUT"))
         gallery_items.append((mask_overlay, f"{name} • Lung mask overlay"))
-
         if out["proc_gray"] is not None:
             proc_rgb = cv2.cvtColor(cv2.resize(out["proc_gray"], (512, 512)), cv2.COLOR_GRAY2RGB)
             gallery_items.append((proc_rgb, f"{name} • Masked model input (224x224)"))
-
         gallery_items.append((overlay_big, f"{name} • Grad-CAM overlay ({MODEL_NAME_TBNET})"))
 
         if radio_raw_overlay is not None:
@@ -1072,56 +997,35 @@ def run_analysis(
         if radio_masked_overlay is not None:
             gallery_items.append((cv2.resize(radio_masked_overlay, (512, 512)), f"{name} • RADIO MASKED heatmap"))
 
-        # Details (dashboard style)
-        summary_md = overall_summary(
-            tb_band=out.get("band"),
-            tb_prob=out.get("prob"),
-            radio_primary=radio_primary_val,
-            radio_band=radio_band,
-            consensus_label=consensus_label,
-            q_score=float(out["quality_score"]),
-            cov=float(out.get("lung_coverage", 0.0)),
-            warnings=out.get("warnings", []),
-        )
-
+        # Details panel
         warn_txt = "\n".join([f"- {w}" for w in out["warnings"]]) if out["warnings"] else "- None"
-        tb_line = "N/A (disabled by fail-safe)" if out["prob"] is None else f"{out['prob']:.4f}"
+        tb_line = "N/A (fail-safe)" if out["prob"] is None else f"{out['prob']:.4f}"
         rec_line = recommendation_for_band(out.get("band"))
 
         details_md.append(
-            f"""{summary_md}
+            f"""### {name}
 
----
+**Overall:** {overall}
+**{MODEL_NAME_TBNET} result:** **{out['pred']}**
+{rec_line}
 
-<details>
-<summary><b>{MODEL_NAME_TBNET} details</b></summary>
+**{MODEL_NAME_TBNET} probability:** {tb_line}
 
-- **Result:** {out['pred']} ({out['band']})
-- **Recommendation:** {rec_line}
-- **Probability (screening score):** {tb_line}
-- **Attention pattern:** {"Diffuse / non-focal" if out["diffuse_risk"] else "Focal / localized"}
+**Interpretation**
+{out['band_text']}
 
-</details>
-
-<details>
-<summary><b>{MODEL_NAME_RADIO} details</b></summary>
-
-{radio_text}
-
-</details>
-
-<details>
-<summary><b>Image quality & segmentation</b></summary>
-
-- **Quality score:** {out['quality_score']:.0f}/100
-- **Lung mask coverage:** {out.get('lung_coverage', 0.0) * 100:.1f}%
+**Image quality:** {out['quality_score']:.0f}/100
+**Lung mask coverage:** {out.get('lung_coverage', 0.0) * 100:.1f}%
+**Attention pattern (TBNet):** {"Diffuse / non-focal" if out["diffuse_risk"] else "Focal / localized"}
 
 **Notes that may affect reliability**
 {warn_txt}
 
-</details>
+**{MODEL_NAME_RADIO} output**
+{radio_text}
 
----
+**Agreement between models:** **{consensus_label}**
+- {consensus_detail}
 
 **Clinical guidance**
 {CLINICAL_GUIDANCE}
@@ -1144,10 +1048,10 @@ def build_ui():
     """
 
     with gr.Blocks(title="TB X-ray Assistant (TBNet + RADIO)", css=css) as demo:
-        gr.Markdown('<div class="title">TB X-ray Assistant (Research Use)</div>')
+        gr.Markdown('<div class="title">TB X-ray Assistant (Auto Lung Mask • Research Use)</div>')
         gr.Markdown(
             f"<div class='subtitle'>Auto lung mask → <b>{MODEL_NAME_TBNET}</b> + Grad-CAM • "
-            f"Optional <b>{MODEL_NAME_RADIO}</b> (C-RADIOv4 + heads) • User-friendly summary</div>"
+            f"Optional <b>{MODEL_NAME_RADIO}</b> (C-RADIOv4 + heads) • Agreement summary</div>"
         )
 
         with gr.Row():
@@ -1161,7 +1065,7 @@ def build_ui():
 
                 threshold = gr.Slider(
                     0.01, 0.99, value=TBNET_SCREEN_THR, step=0.01,
-                    label=f"Reference threshold (TBNet SCREEN+) = {TBNET_SCREEN_THR:.2f}"
+                    label=f"Reference threshold (TBNet screen+) = {TBNET_SCREEN_THR:.2f}"
                 )
 
                 phone_mode = gr.Checkbox(
@@ -1186,10 +1090,8 @@ def build_ui():
 
             with gr.Column(scale=2):
                 gr.Markdown("#### Upload images")
-                files = gr.Files(
-                    label="Upload one or multiple chest X-ray images",
-                    file_types=[".png", ".jpg", ".jpeg", ".bmp"]
-                )
+                files = gr.Files(label="Upload one or multiple X-ray images",
+                                 file_types=[".png", ".jpg", ".jpeg", ".bmp"])
                 run_btn = gr.Button("Run Analysis", variant="primary")
                 status = gr.Textbox(label="Status", value="Ready.", interactive=False)
 
@@ -1197,17 +1099,16 @@ def build_ui():
             table = gr.Dataframe(
                 headers=[
                     "Image",
-                    "TBNet Probability",
+                    "OVERALL",
                     "TBNet Result",
-                    "Band",
-                    "Meaning",
+                    "TBNet Prob",
+                    "RADIO Result",
+                    "RADIO Prob (Primary)",
                     "Quality",
                     "LungCov",
-                    "RADIO RAW",
-                    "RADIO MASKED",
-                    "AGREEMENT",
+                    "Agreement",
                 ],
-                datatype=["str","str","str","str","str","str","str","str","str","str"],
+                datatype=["str","str","str","str","str","str","str","str","str"],
                 interactive=False,
                 label="Results"
             )