Update app.py

app.py

@@ -1,19 +1,17 @@
 """
 Glaucoma Visual Field Simulator  v4
-────────────────────────────────────
-Expected file format  (XLSX / CSV / TSV):
-  • Optional header row — detected automatically if VF columns are non-numeric.
-    Recognised header names: 'subject'|'id'|'patient' for the ID column,
-                             'laterality'|'lat'|'eye' for the eye column.
-  • Two data rows per subject — one OD and one OS.
-  • Columns: subject_id | laterality | vf_0 … vf_60  (63 cols total)
-  • Laterality values: OD / OS / R / L / RIGHT / LEFT  (case-insensitive)
-  • VF values: numeric dB; use −1, blank, or '/' for scotoma / blind-spot.
-
-If a subject has only one eye present (e.g. monocular data), the missing eye
-is treated as full sensitivity (30 dB everywhere) in the binocular simulation.
-
-The app ships with built-in demo subjects from the GRAPE/PAPILA mini dataset.
+─────────────────────────────────────────────────────────────────────────────────
+File format (XLSX / CSV / TSV):
+  • Optional header row — auto-detected if first cell is non-numeric.
+  • Expected columns:
+        col 0  subject / patient ID
+        col 1  laterality  (OD | OS | R | L)
+        col 2… 61 VF sensitivity values (dB; −1 or "/" = scotoma/blind spot)
+  • TWO rows per subject, one for OD and one for OS.
+    If only one eye is present the simulation runs monocularly.
+
+The dropdown lists subjects (not individual rows).
+Both eyes are combined into a binocular simulation and a side-by-side VF grid.
 """
 
 import gradio as gr
@@ -23,39 +21,167 @@ from scipy.ndimage import gaussian_filter
 import os, csv
 
 # ════════════════════════════════════════════════════════════════════════════════
-# Built-in demo subjects  (grouped as {subject_id: {OD: [...], OS: [...]}})
+# Default dataset — loaded from the bundled example file at startup
 # ════════════════════════════════════════════════════════════════════════════════
-BUILTIN = {
-    "Demo — Sub 1  (OAG 46F)": {
-        "OD": [21,22,20,23,24,25,14,25,25,20,18,21,16,18,18,23,22,23,25,24,26,-1,14,18,17,14,14,24,22,18,21,23,-1,21,18,19,19,20,22,25,17,14,14,16,16,16,18,19,20,21,19,20,22,21,23,26,14,13,19,20,21],
-        "OS": [24,26,23,26,26,27,23,26,28,26,24,26,22,22,22,24,25,28,27,27,27,-1,22,22,23,22,22,28,25,23,29,25,-1,21,20,20,20,21,21,22,21,22,23,26,26,22,21,22,25,27,23,21,22,21,21,21,23,25,22,25,22],
-        "info": "OAG · Age 46 · F · IOP 14.7/15.3 mmHg · RNFL 113/93 µm",
-    },
-    "Demo — Sub 2  (OAG 57M, advanced loss)": {
-        "OD": None,
-        "OS": [25,29,23,6,24,27,19,6,19,22,20,20,7,3,16,4,1,4,15,4,16,-1,10,9,-1,-1,-1,-1,-1,-1,-1,1,-1,19,21,21,15,3,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,2,14,17,20,24,13,-1,-1,-1,-1,-1,23],
-        "info": "OAG · Age 57 · M · IOP 15.5 mmHg · RNFL 62 µm  (OS only)",
-    },
-    "Demo — Sub 3  (ACG 41M, progressed ★)": {
-        "OD": [29,29,26,27,27,29,25,29,29,29,27,29,25,25,29,27,27,29,29,29,29,-1,24,26,27,25,25,30,28,25,29,28,-1,21,20,21,20,21,22,21,20,22,21,41,22,21,22,21,23,23,23,20,21,22,20,20,14,18,16,21,18],
-        "OS": None,
-        "info": "ACG · Age 41 · M · IOP 17.0 mmHg · RNFL 89 µm  (OD only) · PROGRESSED",
-    },
-    "Demo — Normal (all 30 dB)": {
-        "OD": [30] * 61,
-        "OS": [30] * 61,
-        "info": "Simulated — full sensitivity both eyes",
-    },
-    "Demo — Severe central scotoma": {
-        "OD": [5 if i in {5,6,7,8,11,12,13,14,17,18,19,20,25,26,27,28,33,34,35,36} else 28 for i in range(61)],
-        "OS": [5 if i in {5,6,7,8,11,12,13,14,17,18,19,20,25,26,27,28,33,34,35,36} else 28 for i in range(61)],
-        "info": "Simulated — bilateral central scotoma",
-    },
-}
+
+_SCRIPT_DIR     = os.path.dirname(os.path.abspath(__file__))
+DEFAULT_VF_FILE = os.path.join(_SCRIPT_DIR, "glaucoma_vf_example.xlsx")
+
+# Module-level store: subject_id → {id, info, OD, OS}
+_subjects: dict = {}
+
+
+def _load_demo():
+    """Load subjects from the bundled example XLSX; hard-coded fallback if missing."""
+    global _subjects
+    if os.path.exists(DEFAULT_VF_FILE):
+        loaded, _ = parse_uploaded_file(DEFAULT_VF_FILE)
+        if loaded:
+            _subjects = loaded
+            return
+    # Fallback: Subject 1 OD+OS from GRAPE mini
+    _subjects = {
+        "1": {
+            "id": "1",
+            "info": "OD mean 19.8 dB · scotoma 2/61  |  OS mean 23.7 dB · scotoma 2/61",
+            "OD": [21,22,20,23,24,25,14,25,25,20,18,21,16,18,18,23,22,23,25,24,26,-1,14,18,17,14,14,24,22,18,21,23,-1,21,18,19,19,20,22,25,17,14,14,16,16,16,18,19,20,21,19,20,22,21,23,26,14,13,19,20,21],
+            "OS": [24,26,23,26,26,27,23,26,28,26,24,26,22,22,22,24,25,28,27,27,27,-1,22,22,23,22,22,28,25,23,29,25,-1,21,20,20,20,21,21,22,21,22,23,26,26,22,21,22,25,27,23,21,22,21,21,21,23,25,22,25,22],
+        }
+    }
+
+
+# ════════════════════════════════════════════════════════════════════════════════
+# File parser
+# ════════════════════════════════════════════════════════════════════════════════
+def _norm_lat(raw):
+    s = str(raw).strip().upper()
+    return "OD" if s in {"OD", "R", "RIGHT", "RE"} else "OS"
+
+_LAT_VALUES = {"OD", "OS", "R", "L", "RIGHT", "LEFT", "RE", "LE"}
+
+def _row_is_header(row):
+    """
+    True if the first row is a column-name header, not a data row.
+    We check column 1 (the laterality column): if it holds a recognised
+    laterality code the row is data; if it holds anything else (e.g. the
+    string "laterality") it is a header.  This is robust to non-numeric
+    patient IDs such as "P001" or "sub_A".
+    """
+    if not row or len(row) < 2:
+        return False
+    lat_cell = str(row[1]).strip().upper() if row[1] is not None else ""
+    return lat_cell not in _LAT_VALUES
+
+def parse_uploaded_file(filepath):
+    """
+    Parse XLSX / CSV / TSV into a dict of subjects.
+
+    Returns (subjects_dict, status_message)
+    subjects_dict: { subject_id: {id, info, OD, OS} }
+    """
+    if filepath is None:
+        return {}, "No file provided."
+
+    ext = os.path.splitext(filepath)[1].lower()
+    raw_rows = []
+
+    try:
+        if ext in {".xlsx", ".xls"}:
+            import openpyxl
+            wb = openpyxl.load_workbook(filepath, data_only=True)
+            ws = wb.active
+            for row in ws.iter_rows(values_only=True):
+                if all(v is None for v in row):
+                    continue
+                raw_rows.append(list(row))
+        else:
+            with open(filepath, newline="", encoding="utf-8-sig") as f:
+                sample = f.read(4096)
+            delim = max([",", "\t", ";", " "], key=lambda d: sample.count(d))
+            with open(filepath, newline="", encoding="utf-8-sig") as f:
+                for row in csv.reader(f, delimiter=delim):
+                    if row:
+                        raw_rows.append(row)
+    except Exception as e:
+        return {}, f"Could not read file: {e}"
+
+    if not raw_rows:
+        return {}, "File appears to be empty."
+
+    # Skip header row if detected (checks laterality column, not ID column)
+    data_rows = raw_rows[1:] if _row_is_header(raw_rows[0]) else raw_rows
+
+    if not data_rows:
+        return {}, "Only a header row found — no data."
+
+    subjects = {}   # subject_id → {id, info, OD, OS}
+    skipped  = []
+
+    for ri, raw in enumerate(data_rows, start=2):
+        cells = [c for c in raw if c is not None and str(c).strip() not in ("", "None")]
+        if len(cells) < 63:
+            skipped.append(f"Row {ri}: {len(cells)} cols (need 63: subject + laterality + 61 VF). Skipped.")
+            continue
+
+        sid = str(cells[0]).strip()
+        lat = _norm_lat(cells[1])
+
+        vf_raw = cells[2:63]   # exactly 61 values
+        try:
+            vf = [float(v) if str(v).strip() not in ("-1", "/", "", "None") or str(v).strip() == "-1"
+                  else -1.0
+                  for v in vf_raw]
+            # Normalise: anything non-numeric → -1
+            vf_clean = []
+            for v in vf_raw:
+                sv = str(v).strip()
+                if sv in ("/", "", "None"):
+                    vf_clean.append(-1.0)
+                else:
+                    try:
+                        vf_clean.append(float(sv))
+                    except ValueError:
+                        vf_clean.append(-1.0)
+            vf = vf_clean
+        except Exception as e:
+            skipped.append(f"Row {ri} (ID={sid}): VF parse error — {e}. Skipped.")
+            continue
+
+        if sid not in subjects:
+            subjects[sid] = {"id": sid, "info": f"Subject {sid}", "OD": None, "OS": None}
+        subjects[sid][lat] = vf
+
+    if not subjects:
+        msg = "No valid subjects found."
+        if skipped:
+            msg += "\n" + "\n".join(skipped[:5])
+        return {}, msg
+
+    # Build info strings
+    for sid, s in subjects.items():
+        eyes = []
+        for lat in ("OD", "OS"):
+            vf = s[lat]
+            if vf is None:
+                eyes.append(f"{lat}: —")
+            else:
+                valid = [v for v in vf if v >= 0]
+                mean  = f"{np.mean(valid):.1f}" if valid else "N/A"
+                scot  = sum(1 for v in vf if v < 0)
+                eyes.append(f"{lat} mean {mean} dB · scotoma {scot}/61")
+        s["info"] = "  |  ".join(eyes)
+
+    if skipped:
+        print(f"[VF parser] {len(skipped)} rows skipped:")
+        for m in skipped:
+            print(" ", m)
+
+    n_eyes = sum(1 for s in subjects.values() for lat in ("OD","OS") if s[lat] is not None)
+    return subjects, f"✓ Loaded {len(subjects)} subject(s), {n_eyes} eye(s) total."
 
 
 # ════════════════════════════════════════════════════════════════════════════════
-# VF grid constants
+# VF layout
 # ════════════════════════════════════════════════════════════════════════════════
 VF_GRID = [
     [None,None,None,None,None,None,None,None,None],
@@ -70,33 +196,33 @@ VF_GRID = [
     [None,None,51,  52,  53,  54,  55,  56,  None],
     [None,None,None,57,  58,  59,  60,  None,None],
 ]
-NROWS  = len(VF_GRID)
-NCOLS  = len(VF_GRID[0])
-BS_OD  = {21, 32}
-BS_OS  = {20, 33}
-MAX_DB = 30.0
+NROWS = len(VF_GRID)
+NCOLS = len(VF_GRID[0])
+BS_OD = {21, 32}
+BS_OS = {20, 33}
+MAX_SENS = 30.0
 
 
 # ════════════════════════════════════════════════════════════════════════════════
 # Colour helpers
 # ════════════════════════════════════════════════════════════════════════════════
 def sens_fill(v, is_bs=False):
-    if is_bs:              return (68,  68,  65)
-    if v is None or v < 0: return (216, 90,  48)
-    if v >= 25:            return (8,   80,  65)
-    if v >= 20:            return (29,  158, 117)
-    if v >= 15:            return (159, 225, 203)
-    if v >= 10:            return (250, 199, 117)
-    return                        (216, 90,  48)
+    if is_bs:               return (68,  68,  65)
+    if v is None or v < 0:  return (216, 90,  48)
+    if v >= 25:             return (8,   80,  65)
+    if v >= 20:             return (29,  158, 117)
+    if v >= 15:             return (159, 225, 203)
+    if v >= 10:             return (250, 199, 117)
+    return                         (216, 90,  48)
 
 def sens_ink(v, is_bs=False):
-    if is_bs:              return (180, 178, 169)
-    if v is None or v < 0: return (250, 236, 231)
-    if v >= 25:            return (225, 245, 238)
-    if v >= 20:            return (4,   52,  44)
-    if v >= 15:            return (4,   52,  44)
-    if v >= 10:            return (65,  36,   2)
-    return                        (250, 236, 231)
+    if is_bs:               return (180, 178, 169)
+    if v is None or v < 0:  return (250, 236, 231)
+    if v >= 25:             return (225, 245, 238)
+    if v >= 20:             return (4,   52,  44)
+    if v >= 15:             return (4,   52,  44)
+    if v >= 10:             return (65,  36,   2)
+    return                         (250, 236, 231)
 
 
 # ════════════════════════════════════════════════════════════════════════════════
@@ -116,28 +242,24 @@ def vf_points(laterality):
 
 
 # ════════════════════════════════════════════════════════════════════════════════
-# Sensitivity field builder
+# Sensitivity field
 # ════════════════════════════════════════════════════════════════════════════════
-def build_field(vf, laterality, W, H, fov_deg=36, sigma=30):
-    """Gaussian-interpolate 61 VF points → smooth 2-D sensitivity field [0,1]."""
-    cx, cy  = W / 2, H / 2
-    ppd     = min(W, H) / (2 * fov_deg)
+def build_sensitivity_field(vf, laterality, W, H, fov_deg=36, sigma=30):
+    cx, cy = W / 2, H / 2
+    ppd    = min(W, H) / (2 * fov_deg)
     val_map = np.zeros((H, W), dtype=np.float32)
     wt_map  = np.zeros((H, W), dtype=np.float32)
-
     for xd, yd, vi, is_bs in vf_points(laterality):
         v    = vf[vi]
-        sens = 0.0 if (is_bs or v < 0) else min(v / MAX_DB, 1.0)
+        sens = 0.0 if (is_bs or v < 0) else min(v / MAX_SENS, 1.0)
         px   = int(np.clip(cx + xd * ppd, 0, W - 1))
         py   = int(np.clip(cy - yd * ppd, 0, H - 1))
         val_map[py, px] += sens
         wt_map [py, px] += 1.0
-
     vs = gaussian_filter(val_map, sigma=sigma)
     ws = gaussian_filter(wt_map,  sigma=sigma)
     with np.errstate(invalid="ignore", divide="ignore"):
         field = np.where(ws > 1e-6, vs / ws, 1.0)
-
     Y, X    = np.mgrid[0:H, 0:W]
     outside = np.sqrt((X - cx)**2 + (Y - cy)**2) > fov_deg * ppd * 1.05
     field[outside] = 1.0
@@ -147,65 +269,68 @@ def build_field(vf, laterality, W, H, fov_deg=36, sigma=30):
 # ════════════════════════════════════════════════════════════════════════════════
 # Binocular scene simulation
 # ════════════════════════════════════════════════════════════════════════════════
-_FULL = None   # sentinel for "eye not available → full sensitivity"
-
-def _full_field(W, H):
-    return np.ones((H, W), dtype=np.float32)
-
 def apply_vf_binocular(img_pil, vf_od, vf_os, blur_scotoma, show_dots, sigma):
     """
-    Apply binocular VF loss.
-    Left visual hemifield  → OD (right eye drives left VF).
-    Right visual hemifield → OS (left  eye drives right VF).
-    Soft cosine blend ±15° around fixation.
-    Missing eye → full sensitivity on that side.
+    Binocular blend:
+      Left visual field  (x < centre) ← driven by OD (right eye, temporal field)
+      Right visual field (x > centre) ← driven by OS (left eye,  temporal field)
+    Soft hemifield crossfade ±½ image-width around fixation.
+    If one eye is absent its field defaults to 1.0 (no loss) on its side.
     """
     img  = img_pil.convert("RGB")
     W, H = img.size
     arr  = np.array(img, dtype=np.float32)
 
-    fod = build_field(vf_od, "OD", W, H, sigma=sigma) if vf_od else _full_field(W, H)
-    fos = build_field(vf_os, "OS", W, H, sigma=sigma) if vf_os else _full_field(W, H)
+    f_od = build_sensitivity_field(vf_od, "OD", W, H, sigma=sigma) if vf_od else np.ones((H, W), np.float32)
+    f_os = build_sensitivity_field(vf_os, "OS", W, H, sigma=sigma) if vf_os else np.ones((H, W), np.float32)
 
-    cx    = W / 2
-    xn    = (np.arange(W) - cx) / (W / 2)          # −1 … +1
-    od_w  = np.clip(-xn + 0.5, 0, 1)[None, :] * np.ones((H, 1))
-    os_w  = np.clip( xn + 0.5, 0, 1)[None, :] * np.ones((H, 1))
-    bino  = (od_w * fod + os_w * fos) / (od_w + os_w)
+    cx    = W // 2
+    xn    = (np.arange(W) - cx) / (W / 2)           # −1 … +1
+    od_w  = np.clip(-xn + 0.5, 0, 1)[None, :] * np.ones((H, 1))   # higher left
+    os_w  = np.clip( xn + 0.5, 0, 1)[None, :] * np.ones((H, 1))   # higher right
+    bino  = (od_w * f_od + os_w * f_os) / (od_w + os_w)
 
     if blur_scotoma:
         blur_amt = np.clip(1.0 - bino, 0, 1)
         blurred  = np.array(img.filter(ImageFilter.GaussianBlur(radius=14)), dtype=np.float32)
-        arr      = arr * (1 - blur_amt[:,:,None]) + blurred * blur_amt[:,:,None]
+        arr      = arr * (1 - blur_amt[:, :, None]) + blurred * blur_amt[:, :, None]
 
-    arr    = np.clip(arr * bino[:,:,None], 0, 255).astype(np.uint8)
+    arr    = np.clip(arr * bino[:, :, None], 0, 255).astype(np.uint8)
     result = Image.fromarray(arr)
 
     if show_dots:
-        overlay = Image.new("RGBA", (W, H), (0,0,0,0))
+        overlay = Image.new("RGBA", (W, H), (0, 0, 0, 0))
         od      = ImageDraw.Draw(overlay)
-        ppd     = min(W, H) / (2 * 36)
+        fov_deg = 36
+        ppd     = min(W, H) / (2 * fov_deg)
         for vf, lat in [(vf_od, "OD"), (vf_os, "OS")]:
             if vf is None:
                 continue
             for xd, yd, vi, is_bs in vf_points(lat):
-                px = int(W/2 + xd * ppd)
-                py = int(H/2 - yd * ppd)
-                fg = sens_fill(vf[vi], is_bs) + (200,)
-                od.ellipse([px-7,py-7,px+7,py+7], fill=fg, outline=(255,255,255,90))
+                v  = vf[vi]
+                px = int(W / 2 + xd * ppd)
+                py = int(H / 2 - yd * ppd)
+                r  = 7
+                fg = sens_fill(v, is_bs) + (200,)
+                od.ellipse([px-r, py-r, px+r, py+r], fill=fg, outline=(255,255,255,90))
         result = Image.alpha_composite(result.convert("RGBA"), overlay).convert("RGB")
 
     return result
 
 
 # ════════════════════════════════════════════════════════════════════════════════
-# VF sensitivity grid (one or two eyes side by side)
+# VF sensitivity grid — both eyes side by side
 # ════════════════════════════════════════════════════════════════════════════════
-def make_vf_grid(vf_od, vf_os, subject_label, info_str):
+def make_vf_grid_panel(subject):
+    vf_od = subject["OD"]
+    vf_os = subject["OS"]
+    sid   = subject["id"]
+    info  = subject["info"]
+
     CELL     = 40
     PAD_X    = 52
-    PAD_TOP  = 50
-    GAP      = 30
+    PAD_TOP  = 54
+    GAP      = 32
     LEG_H    = 58
     AXIS_GAP = 6
 
@@ -213,40 +338,53 @@ def make_vf_grid(vf_od, vf_os, subject_label, info_str):
     panel_h = NROWS * CELL
     n_eyes  = (1 if vf_od else 0) + (1 if vf_os else 0)
 
+    if n_eyes == 0:
+        canvas = Image.new("RGB", (420, 80), (248, 248, 250))
+        ImageDraw.Draw(canvas).text((14, 28), "No VF data available.", fill=(80, 80, 80))
+        return canvas
+
     total_w = PAD_X * 2 + n_eyes * panel_w + (n_eyes - 1) * GAP
     total_h = PAD_TOP + panel_h + 24 + LEG_H
 
     canvas = Image.new("RGB", (total_w, total_h), (248, 248, 250))
     draw   = ImageDraw.Draw(canvas)
 
-    draw.text((PAD_X, 10), str(subject_label)[:80], fill=(38, 38, 38))
-    draw.text((PAD_X, 28), str(info_str)[:100],     fill=(80, 80, 120))
+    # Header
+    draw.text((PAD_X, 8),  f"Subject: {sid}", fill=(38, 38, 38))
+    draw.text((PAD_X, 26), info[:total_w // 7], fill=(80, 80, 120))
 
-    def draw_eye(vf, lat, ox):
+    def draw_one(vf, lat, ox):
         bs = BS_OD if lat == "OD" else BS_OS
 
-        draw.text((ox + panel_w//2 - len(lat)*4, PAD_TOP - 20), lat, fill=(30,30,30))
+        # Eye label
+        draw.text((ox + panel_w // 2 - len(lat) * 4, PAD_TOP - 20), lat, fill=(30, 30, 30))
 
+        # Y axis
         for r in range(NROWS):
             yd = (4 - r) * 6
             if yd % 12 == 0:
                 lbl = f"{yd:+d}°"
-                draw.text((ox - len(lbl)*6 - AXIS_GAP - 2, PAD_TOP + r*CELL + CELL//2 - 7),
-                          lbl, fill=(150,150,150))
+                draw.text((ox - len(lbl)*6 - AXIS_GAP - 2,
+                           PAD_TOP + r*CELL + CELL//2 - 7), lbl, fill=(150,150,150))
+        # X axis
         for c in range(NCOLS):
-            xd = ((c-4)*6) * (-1 if lat=="OS" else 1)
+            xr = (c - 4) * 6
+            xd = -xr if lat == "OS" else xr
             if xd % 12 == 0:
                 draw.text((ox + c*CELL + 2, PAD_TOP + panel_h + AXIS_GAP),
                           f"{xd:+d}°", fill=(150,150,150))
 
+        # Fixation cross
         fx = ox + 4*CELL + CELL//2
         fy = PAD_TOP + 4*CELL + CELL//2
         draw.line([(fx-9,fy),(fx+9,fy)], fill=(180,50,50), width=2)
         draw.line([(fx,fy-9),(fx,fy+9)], fill=(180,50,50), width=2)
 
+        # Cells
         for r, row in enumerate(VF_GRID):
             for c, vi in enumerate(row):
-                x0 = ox + c*CELL;  y0 = PAD_TOP + r*CELL
+                x0 = ox + c*CELL
+                y0 = PAD_TOP + r*CELL
                 x1, y1 = x0+CELL-2, y0+CELL-2
                 if vi is None:
                     draw.rectangle([x0,y0,x1,y1], fill=(238,238,240), outline=(220,220,222))
@@ -254,279 +392,114 @@ def make_vf_grid(vf_od, vf_os, subject_label, info_str):
                 is_bs = vi in bs
                 v     = vf[vi]
                 draw.rectangle([x0,y0,x1,y1], fill=sens_fill(v,is_bs), outline=(255,255,255))
-                lbl = "BS" if is_bs else ("—" if v<0 else str(int(v)))
-                draw.text((x0+CELL//2 - len(lbl)*3, y0+CELL//2-7), lbl,
-                          fill=sens_ink(v, is_bs))
+                lbl = "BS" if is_bs else ("—" if v < 0 else str(int(v)))
+                lw  = len(lbl) * 6
+                draw.text((x0+CELL//2-lw//2, y0+CELL//2-7), lbl, fill=sens_ink(v,is_bs))
 
-    x = PAD_X
+    x_cur = PAD_X
     if vf_od:
-        draw_eye(vf_od, "OD", x); x += panel_w + GAP
+        draw_one(vf_od, "OD", x_cur)
+        x_cur += panel_w + GAP
     if vf_os:
-        draw_eye(vf_os, "OS", x)
+        draw_one(vf_os, "OS", x_cur)
 
     # Legend
     tiers = [
-        ("≥25 dB",(8,80,65),(225,245,238)), ("20–24",(29,158,117),(4,52,44)),
-        ("15–19",(159,225,203),(4,52,44)),  ("10–14",(250,199,117),(65,36,2)),
-        ("<10 dB",(216,90,48),(250,236,231)),("Scotoma",(216,90,48),(250,236,231)),
-        ("BS",(68,68,65),(180,178,169)),
+        ("≥25 dB",  (8,80,65),    (225,245,238)),
+        ("20–24",   (29,158,117), (4,52,44)),
+        ("15–19",   (159,225,203),(4,52,44)),
+        ("10–14",   (250,199,117),(65,36,2)),
+        ("<10 dB",  (216,90,48),  (250,236,231)),
+        ("Scotoma", (216,90,48),  (250,236,231)),
+        ("BS",      (68,68,65),   (180,178,169)),
     ]
     leg_y = PAD_TOP + panel_h + 24 + 4
     sw    = (total_w - PAD_X*2) // len(tiers)
     for i, (lbl, bg, fg) in enumerate(tiers):
         lx = PAD_X + i*sw
-        draw.rectangle([lx,leg_y,lx+sw-3,leg_y+24], fill=bg)
-        draw.text((lx+4,leg_y+5), lbl, fill=fg)
+        draw.rectangle([lx, leg_y, lx+sw-3, leg_y+24], fill=bg)
+        draw.text((lx+4, leg_y+5), lbl, fill=fg)
     draw.text((PAD_X, leg_y+32),
               "Fixation cross = (0°,0°)  ·  Axis = degrees from fixation  ·  BS = blind spot",
               fill=(165,165,165))
-    return canvas
-
-
-# ═════════════════════════════════════════════════════════════��══════════════════
-# File parser — groups rows by subject, expects OD + OS pair
-# ════════════════════════════════════════════════════════════════════════════════
-_LAT_MAP = {"OD":"OD","R":"OD","RIGHT":"OD","RE":"OD",
-            "OS":"OS","L":"OS","LEFT":"OS","LE":"OS"}
 
-# Known header synonyms for the two key columns
-_ID_NAMES  = {"subject","id","patient","sub","patient_id","subject_id"}
-_LAT_NAMES = {"laterality","lat","eye","side"}
-
-
-def _parse_vf_value(v):
-    """Convert a cell to float; return -1.0 for missing/scotoma."""
-    if v is None or str(v).strip() in ("", "/", "NA", "na", "NaN"):
-        return -1.0
-    try:
-        return float(v)
-    except (ValueError, TypeError):
-        return -1.0
-
-
-def _read_raw_rows(filepath):
-    """Return list-of-lists from XLSX or delimited file."""
-    ext = os.path.splitext(filepath)[1].lower()
-    if ext in {".xlsx", ".xls"}:
-        import openpyxl
-        wb = openpyxl.load_workbook(filepath, data_only=True)
-        ws = wb.active
-        return [list(row) for row in ws.iter_rows(values_only=True)
-                if any(v is not None for v in row)]
-    else:
-        with open(filepath, newline="", encoding="utf-8-sig") as f:
-            sample = f.read(4096)
-        counts = {d: sample.count(d) for d in [",","\t",";"," "]}
-        delim  = max(counts, key=counts.get)
-        with open(filepath, newline="", encoding="utf-8-sig") as f:
-            return [r for r in csv.reader(f, delimiter=delim) if any(c.strip() for c in r)]
-
-
-def parse_file_to_subjects(filepath):
-    """
-    Parse file into a dict:  subject_label → {"OD": [...], "OS": [...], "info": str}
-
-    Returns (subjects_dict, status_message).
-    """
-    if filepath is None:
-        return {}, "No file provided."
-
-    try:
-        raw = _read_raw_rows(filepath)
-    except Exception as e:
-        return {}, f"Could not read file: {e}"
-
-    if not raw:
-        return {}, "File appears to be empty."
-
-    # ── Detect header row ────────────────────────────────────────────────────
-    first = [str(v).strip().lower() if v is not None else "" for v in raw[0]]
-    has_header = any(f in _ID_NAMES or f in _LAT_NAMES for f in first)
-
-    if has_header:
-        header   = first
-        data_rows = raw[1:]
-        # Find column indices
-        id_col  = next((i for i,h in enumerate(header) if h in _ID_NAMES), 0)
-        lat_col = next((i for i,h in enumerate(header) if h in _LAT_NAMES), 1)
-        # VF columns: everything that isn't id or lat (look for vf_* or numeric-named cols)
-        vf_cols = [i for i,h in enumerate(header)
-                   if i not in {id_col, lat_col} and len(header) - i <= 61 + 5]
-        # Simpler: just take the 61 cols after lat_col
-        vf_start = lat_col + 1
-    else:
-        data_rows = raw
-        id_col    = 0
-        lat_col   = 1
-        vf_start  = 2
-
-    # ── Group rows by subject ────────────────────────────────────────────────
-    from collections import defaultdict
-    grouped = defaultdict(dict)   # {subject_id: {"OD": vf_list, "OS": vf_list}}
-    skipped = []
-
-    for ri, row in enumerate(data_rows, start=2 if has_header else 1):
-        # Pad row if short
-        row = list(row) + [None] * max(0, vf_start + 61 - len(row))
-
-        sid = str(row[id_col]).strip() if row[id_col] is not None else f"row{ri}"
-        lat_raw = str(row[lat_col]).strip().upper() if row[lat_col] is not None else ""
-        lat = _LAT_MAP.get(lat_raw)
-
-        if lat is None:
-            skipped.append(f"Row {ri}: unrecognised laterality '{lat_raw}' — skipped.")
-            continue
-
-        vf_raw = row[vf_start : vf_start + 61]
-        if len(vf_raw) < 61:
-            skipped.append(f"Row {ri} (ID={sid}): only {len(vf_raw)} VF values — need 61. Skipped.")
-            continue
-
-        vf = [_parse_vf_value(v) for v in vf_raw]
-
-        if lat in grouped[sid]:
-            skipped.append(f"Row {ri} (ID={sid}): duplicate {lat} — overwriting previous entry.")
-        grouped[sid][lat] = vf
-
-    if not grouped:
-        msg = "No valid rows parsed."
-        if skipped:
-            msg += "\n" + "\n".join(skipped[:5])
-        return {}, msg
-
-    # ── Build subject dict ────────────────────────────────────────────────────
-    subjects = {}
-    for sid, eyes in grouped.items():
-        vf_od = eyes.get("OD")
-        vf_os = eyes.get("OS")
-        eyes_present = " + ".join(k for k in ["OD","OS"] if eyes.get(k) is not None)
-
-        def _mean(vf, lat):
-            if vf is None: return None
-            bs = BS_OD if lat=="OD" else BS_OS
-            vals = [v for i,v in enumerate(vf) if i not in bs and v>=0]
-            return round(np.mean(vals),1) if vals else None
-
-        parts = []
-        m = _mean(vf_od,"OD")
-        if m is not None: parts.append(f"OD mean {m} dB")
-        m = _mean(vf_os,"OS")
-        if m is not None: parts.append(f"OS mean {m} dB")
-        info = f"ID {sid} · {eyes_present} · " + " · ".join(parts)
-
-        subjects[f"{sid}"] = {"OD": vf_od, "OS": vf_os, "info": info}
-
-    n_ok  = len(subjects)
-    n_skip = len(skipped)
-    msg   = f"✓ Loaded {n_ok} subject(s)"
-    if n_skip:
-        msg += f"  ({n_skip} row(s) skipped — see console)"
-        for s in skipped: print("[VF parser]", s)
-
-    return subjects, msg
+    return canvas
 
 
 # ════════════════════════════════════════════════════════════════════════════════
-# Global state
+# Info banner
 # ════════════════════════════════════════════════════════════════════════════════
-_subjects: dict = {}   # label → {OD, OS, info}
-
-def _use_builtin():
-    global _subjects
-    _subjects = dict(BUILTIN)
+def make_info_banner(subject, W):
+    sid  = subject["id"]
+    info = subject["info"]
+    panel = Image.new("RGB", (W, 72), (245, 245, 248))
+    draw  = ImageDraw.Draw(panel)
+    draw.text((14, 10), f"Subject: {sid}"[:100], fill=(30, 30, 30))
+    draw.text((14, 34), info[:110],               fill=(55, 75, 140))
 
-_use_builtin()
+    n_od = subject["OD"] is not None
+    n_os = subject["OS"] is not None
+    mode = "Binocular (OD + OS)" if (n_od and n_os) else ("OD only" if n_od else "OS only")
+    draw.text((14, 54), f"Mode: {mode}", fill=(100, 100, 100))
+    return panel
 
 
 # ════════════════════════════════════════════════════════════════════════════════
-# Default scene
+# Default street scene
 # ════════════════════════════════════════════════════════════════════════════════
-def create_default_scene():
+def load_default_scene():
+    """Load placeholder_scene.jpg from the app directory; generate a fallback if missing."""
+    scene_path = os.path.join(_SCRIPT_DIR, "placeholder_scene.jpg")
+    if os.path.exists(scene_path):
+        return Image.open(scene_path).convert("RGB")
+    # Minimal fallback — plain grey gradient so the app still launches
     W, H = 640, 400
-    img  = Image.new("RGB", (W, H))
-    draw = ImageDraw.Draw(img)
-    for y in range(220):
-        t = y/220
-        draw.line([(0,y),(W,y)], fill=(int(120+t*40),int(180-t*50),int(230-t*30)))
-    for y in range(220, H):
-        t = (y-220)/(H-220)
-        draw.line([(0,y),(W,y)], fill=(int(70+t*25),int(110+t*15),55))
-    draw.polygon([(240,400),(400,400),(340,215),(300,215)], fill=(75,75,75))
-    for i in range(6):
-        y1=235+i*28; w=2+i*2
-        draw.rectangle([320-w,y1,320+w,y1+14], fill=(240,240,240))
-    draw.rectangle([15,110,215,395], fill=(175,135,95))
-    draw.rectangle([15, 90,215,115], fill=(155,115,75))
-    for wx in [35,80,125,170]:
-        for wy in [135,195,255,315]:
-            draw.rectangle([wx,wy,wx+28,wy+38], fill=(145,190,225))
-    draw.rectangle([430,75,625,395], fill=(155,155,165))
-    draw.rectangle([430,55,625, 80], fill=(135,135,145))
-    for wx in [445,490,540,582]:
-        for wy in [95,155,215,275,335]:
-            draw.rectangle([wx,wy,wx+32,wy+42], fill=(135,180,215))
-    for tx,ty in [(150,155),(475,148),(500,162)]:
-        draw.ellipse([tx-28,ty-45,tx+28,ty+22], fill=(28,95,28))
-        draw.rectangle([tx-5,ty+18,tx+5,ty+58], fill=(75,45,18))
-    for px,py in [(265,318),(312,298),(375,312)]:
-        draw.ellipse([px-9,py-32,px+9,py-14], fill=(55,38,28))
-        draw.rectangle([px-7,py-14,px+7,py+12], fill=(75,55,120))
-        draw.rectangle([px-11,py+12,px-4,py+32], fill=(58,48,78))
-        draw.rectangle([px+4, py+12,px+11,py+32], fill=(58,48,78))
-    draw.ellipse([558,28,608,78], fill=(255,238,90))
-    return img.filter(ImageFilter.SMOOTH)
-
-DEFAULT_SCENE = create_default_scene()
+    img  = Image.new("RGB", (W, H), (180, 180, 180))
+    ImageDraw.Draw(img).text((20, 180), "Place placeholder_scene.jpg here", fill=(80, 80, 80))
+    return img
 
+DEFAULT_SCENE = load_default_scene()
 
-# ════════════════════════════════════════════════════════════════════════════════
-# Info banner
-# ════════════════════════════════════════════════════════════════════════════════
-def make_banner(subject_label, info_str, W):
-    panel = Image.new("RGB", (W, 72), (245,245,248))
-    draw  = ImageDraw.Draw(panel)
-    draw.text((14, 10), f"Subject: {subject_label}"[:100], fill=(30,30,30))
-    draw.text((14, 34), str(info_str)[:110], fill=(55,75,140))
-    return panel
+# Populate _subjects now that parse_uploaded_file is defined
+_load_demo()
 
 
 # ════════════════════════════════════════════════════════════════════════════════
 # Gradio callbacks
 # ════════════════════════════════════════════════════════════════════════════════
-def on_upload(filepath):
+def on_file_upload(filepath):
     global _subjects
     if filepath is None:
-        _use_builtin()
+        _load_demo()
         choices = list(_subjects.keys())
-        return gr.update(choices=choices, value=choices[0]), "Using built-in demo subjects."
+        return gr.update(choices=choices, value=choices[0]), "Loaded default example (glaucoma_vf_example.xlsx)."
 
-    loaded, msg = parse_file_to_subjects(filepath)
+    loaded, msg = parse_uploaded_file(filepath)
     if not loaded:
-        _use_builtin()
+        _load_demo()
         choices = list(_subjects.keys())
-        return gr.update(choices=choices, value=choices[0]), f"⚠ {msg}  Falling back to demo subjects."
+        return gr.update(choices=choices, value=choices[0]), f"⚠ {msg}  Falling back to default example."
 
     _subjects = loaded
     choices   = list(_subjects.keys())
     return gr.update(choices=choices, value=choices[0]), msg
 
 
-def on_clear():
-    _use_builtin()
+def on_clear_file():
+    global _subjects
+    _load_demo()
     choices = list(_subjects.keys())
-    return gr.update(choices=choices, value=choices[0]), "Cleared — using built-in demo subjects."
+    return gr.update(choices=choices, value=choices[0]), "Cleared — loaded default example (glaucoma_vf_example.xlsx)."
 
 
-def run_all(subject_label, input_image, blur_scotoma, show_dots, smoothing):
-    sub = _subjects.get(subject_label)
-    if sub is None:
-        return None, None
+def simulate(subject_id, input_image, blur_scotoma, show_dots, smoothing):
+    subject = _subjects.get(subject_id)
+    if subject is None:
+        return None
 
-    vf_od = sub["OD"]
-    vf_os = sub["OS"]
-    info  = sub.get("info", "")
+    vf_od = subject["OD"]
+    vf_os = subject["OS"]
 
-    # ── Scene ──
     if input_image is None:
         scene = DEFAULT_SCENE.copy()
     elif isinstance(input_image, np.ndarray):
@@ -536,7 +509,7 @@ def run_all(subject_label, input_image, blur_scotoma, show_dots, smoothing):
     scene = scene.resize((640, 400), Image.LANCZOS)
 
     simulated = apply_vf_binocular(scene, vf_od, vf_os, blur_scotoma, show_dots, smoothing)
-    banner    = make_banner(subject_label, info, scene.width * 2 + 8)
+    banner    = make_info_banner(subject, scene.width * 2 + 8)
 
     W, H   = scene.size
     canvas = Image.new("RGB", (W*2+8, H+banner.height+4), (220,220,225))
@@ -544,45 +517,55 @@ def run_all(subject_label, input_image, blur_scotoma, show_dots, smoothing):
     canvas.paste(simulated, (W+8,   0))
     canvas.paste(banner,    (0,     H+4))
     d = ImageDraw.Draw(canvas)
-    for lx, txt in [(6,"Normal vision"),(W+14,"Simulated VF loss")]:
-        d.rectangle([lx,4,lx+156,20], fill=(0,0,0))
-        d.text((lx+5,5), txt, fill=(255,255,255))
+    for lx, txt in [(6, "Normal vision"), (W+14, "Simulated VF loss")]:
+        d.rectangle([lx, 4, lx+156, 20], fill=(0,0,0))
+        d.text((lx+5, 5), txt, fill=(255,255,255))
 
-    # ── Grid ──
-    grid = make_vf_grid(vf_od, vf_os, subject_label, info)
+    return canvas
+
+
+def vf_grid(subject_id):
+    subject = _subjects.get(subject_id)
+    if subject is None:
+        return None
+    return make_vf_grid_panel(subject)
 
-    return canvas, grid
+
+def run_all(subject_id, input_image, blur_scotoma, show_dots, smoothing):
+    return simulate(subject_id, input_image, blur_scotoma, show_dots, smoothing), \
+           vf_grid(subject_id)
 
 
 # ════════════════════════════════════════════════════════════════════════════════
-# UI
+# Gradio UI
 # ════════════════════════════════════════════════════════════════════════════════
 _init_choices = list(_subjects.keys())
 
 with gr.Blocks(title="Glaucoma VF Simulator") as demo:
     gr.Markdown(
         "# Glaucoma Visual Field Simulator\n"
-        "Upload an **XLSX or delimited file** to load your own VF data, "
-        "or explore the built-in demo subjects.\n\n"
-        "**Expected format** — one header row (`subject`, `laterality`, `vf_0` … `vf_60`), "
-        "then **two rows per subject** (one OD, one OS). "
-        "Laterality: `OD`/`OS`/`R`/`L`. "
-        "VF values in dB; use `−1` or blank for scotoma / blind spot."
+        "Upload a file to load your own subjects, or explore the built-in demo data.\n\n"
+        "**File format** — XLSX or delimited (CSV / TSV), **with or without a header row**:  \n"
+        "`subject` · `laterality` (OD/OS) · `vf_0` … `vf_60`  \n"
+        "Two rows per subject (one OD, one OS). A subject with only one eye runs monocularly."
     )
 
     with gr.Row():
-        # ── Controls ──────────────────────────────────────────────────────────
+        # ── Left: controls ────────────────────────────────────────────────────
         with gr.Column(scale=1, min_width=310):
+
             with gr.Group():
                 gr.Markdown("### Data source")
                 vf_file = gr.File(
-                    label="Upload VF file  (XLSX / CSV / TSV — see format above)",
-                    file_types=[".xlsx",".xls",".csv",".tsv",".txt"],
+                    label="Upload VF file  (XLSX / CSV / TSV)",
+                    file_types=[".xlsx", ".xls", ".csv", ".tsv", ".txt"],
                     type="filepath",
                 )
                 file_status = gr.Textbox(
-                    value="Using built-in demo subjects.",
-                    label="Status", interactive=False, lines=1,
+                    value="Loaded default example (glaucoma_vf_example.xlsx).",
+                    label="Status",
+                    interactive=False,
+                    lines=1,
                 )
                 clear_btn = gr.Button("✕  Clear / reset to demo subjects",
                                       size="sm", variant="secondary")
@@ -592,7 +575,7 @@ with gr.Blocks(title="Glaucoma VF Simulator") as demo:
                 subject_dd = gr.Dropdown(
                     choices=_init_choices,
                     value=_init_choices[0],
-                    label="Select subject (both eyes loaded automatically)",
+                    label="Select subject",
                     interactive=True,
                 )
 
@@ -600,38 +583,38 @@ with gr.Blocks(title="Glaucoma VF Simulator") as demo:
                 label="Scene — upload a photo or keep the default",
                 value=np.array(DEFAULT_SCENE),
                 type="numpy",
-                sources=["upload","clipboard"],
+                sources=["upload", "clipboard"],
             )
             with gr.Accordion("Simulation options", open=True):
                 blur_cb   = gr.Checkbox(value=True,  label="Blur scotoma regions (diffusion)")
                 dots_cb   = gr.Checkbox(value=False, label="Show VF test-point dots on scene")
                 smooth_sl = gr.Slider(10, 60, value=28, step=2,
-                                      label="Field smoothness  (Gaussian σ, px)")
+                                      label="Field smoothness  (Gaussian σ px)")
             run_btn = gr.Button("▶  Run simulation", variant="primary")
 
-        # ── Outputs ───────────────────────────────────────────────────────────
+        # ── Right: outputs ────────────────────────────────────────────────────
         with gr.Column(scale=2):
             with gr.Tabs():
                 with gr.TabItem("Vision simulation"):
                     sim_out  = gr.Image(label="Normal  vs  Simulated VF loss", type="pil")
                 with gr.TabItem("VF sensitivity grid"):
-                    grid_out = gr.Image(label="Annotated Humphrey 24-2 grid (OD + OS)", type="pil")
+                    grid_out = gr.Image(label="Annotated Humphrey 24-2 grid  (OD + OS)", type="pil")
 
     gr.Markdown(
         "**Colour scale** — "
         "🟩 ≥25 dB · 🟢 20–24 · 🩵 15–19 · 🟡 10–14 · 🟠 <10 dB · 🔴 scotoma · ⚫ blind spot  \n"
-        "*Binocular model: left visual hemifield driven by OD, right by OS, "
-        "soft blend at fixation. Missing eye → full sensitivity on that side.  "
+        "*Binocular model: left visual field driven by OD, right by OS, soft crossfade at fixation.  "
         "Data: GRAPE/PAPILA baseline cohort (mini).*"
     )
 
     sim_inputs = [subject_dd, image_in, blur_cb, dots_cb, smooth_sl]
 
-    vf_file.change(fn=on_upload, inputs=[vf_file],   outputs=[subject_dd, file_status])
-    clear_btn.click(fn=on_clear, inputs=[],           outputs=[subject_dd, file_status])
-    run_btn.click(  fn=run_all,  inputs=sim_inputs,   outputs=[sim_out, grid_out])
-    subject_dd.change(fn=run_all,inputs=sim_inputs,   outputs=[sim_out, grid_out])
-    demo.load(      fn=run_all,  inputs=sim_inputs,   outputs=[sim_out, grid_out])
+    vf_file.change(fn=on_file_upload, inputs=[vf_file],  outputs=[subject_dd, file_status])
+    clear_btn.click(fn=on_clear_file, inputs=[],          outputs=[subject_dd, file_status])
+
+    run_btn.click(fn=run_all,    inputs=sim_inputs, outputs=[sim_out, grid_out])
+    subject_dd.change(fn=run_all, inputs=sim_inputs, outputs=[sim_out, grid_out])
+    demo.load(fn=run_all,         inputs=sim_inputs, outputs=[sim_out, grid_out])
 
 
 if __name__ == "__main__":