Update app.py

app.py

@@ -14,148 +14,603 @@
 #
 # Fencing Scoreboard Clips - YOLO x AutoGluon (Gradio)
 
-# app.py — Hugging Face Spaces-ready version
-# Author: Michael Stefanov
-# Purpose: Detect scoring touches in fencing bouts (YOLO + AutoGluon)
+import os, sys, zipfile, shutil, subprocess, tempfile, pathlib
+from typing import List, Tuple
+import uuid
+
+import numpy as np
+import pandas as pd
+import cv2
+import gradio as gr
+
+# ---- Robust imports/installs for Colab/Spaces ----
+def _pip(pkgs: List[str]):
+    import subprocess, sys
+    subprocess.check_call([sys.executable, "-m", "pip", "install", "--quiet", *pkgs])
+
+try:
+    import ultralytics
+except:
+    _pip(["ultralytics"])
+    import ultralytics
+
+try:
+    import ffmpeg   # optional helper for duration probe
+except:
+    try:
+        _pip(["ffmpeg-python"])
+        import ffmpeg
+    except Exception:
+        ffmpeg = None
+
+try:
+    from autogluon.tabular import TabularPredictor
+except:
+    _pip(["autogluon.tabular"])
+    from autogluon.tabular import TabularPredictor
+
+try:
+    from huggingface_hub import hf_hub_download
+except:
+    _pip(["huggingface_hub"])
+    from huggingface_hub import hf_hub_download
 
-import os, zipfile, shutil, pathlib, tempfile
-import numpy as np, pandas as pd, cv2, gradio as gr
 from ultralytics import YOLO
-from autogluon.tabular import TabularPredictor
-
-# ---------------------------------------------------------------------
-# Configuration
-# ---------------------------------------------------------------------
-ASSETS_DIR = pathlib.Path("hf_assets")
-YOLO_PATH  = ASSETS_DIR / "best.pt"
-AG_ZIP     = ASSETS_DIR / "autogluon_predictor_dir.zip"
-EXTRACT_DIR = ASSETS_DIR / "ag_predictor_native"
-OUTPUT_DIR  = pathlib.Path("outputs"); OUTPUT_DIR.mkdir(exist_ok=True)
-
-FRAME_SKIP  = 2
-KEEP_CONF   = 0.85
-YOLO_CONF   = 0.25
-YOLO_IOU    = 0.5
-CLIP_PAD_S  = 2.0
-
-# ---------------------------------------------------------------------
-# Load models once
-# ---------------------------------------------------------------------
-print("Loading YOLO and AutoGluon models ...")
-_YOLO = YOLO(str(YOLO_PATH))
-
-if EXTRACT_DIR.exists():
-    shutil.rmtree(EXTRACT_DIR)
-with zipfile.ZipFile(AG_ZIP, "r") as zf:
-    zf.extractall(EXTRACT_DIR)
-_AG  = TabularPredictor.load(str(EXTRACT_DIR))
-
-# ---------------------------------------------------------------------
-# Helper functions
-# ---------------------------------------------------------------------
-def isolate_scoreboard_color(frame_bgr):
-    """Grayscale background, keep color in main scoreboard bbox."""
+
+# ----------------------------
+# Config — HF Hub repositories
+# ----------------------------
+# YOLO scoreboard detector weights (pushed by your training file)
+YOLO_REPO_ID   = os.getenv("YOLO_REPO_ID",   "mastefan/fencing-scoreboard-yolov8")
+YOLO_FILENAME  = os.getenv("YOLO_FILENAME",  "best.pt")
+
+# AutoGluon Tabular detector (your color/timeseries model zip)
+AG_REPO_ID     = os.getenv("AG_REPO_ID",     "emkessle/2024-24679-fencing-touch-predictor")
+AG_ZIP_NAME    = os.getenv("AG_ZIP_NAME",    "autogluon_predictor_dir.zip")
+
+# Processing parameters
+FRAME_SKIP     = int(os.getenv("FRAME_SKIP", "2"))    # process every Nth frame
+KEEP_CONF      = float(os.getenv("KEEP_CONF", "0.85"))# YOLO conf to keep color inside bbox
+YOLO_CONF      = float(os.getenv("YOLO_CONF", "0.25"))
+YOLO_IOU       = float(os.getenv("YOLO_IOU",  "0.50"))
+MIN_SEP_S      = float(os.getenv("MIN_SEP_S", "1.2")) # min gap between events (s)
+CLIP_PAD_S     = float(os.getenv("CLIP_PAD_S","2.0")) # before/after padding each hit
+GROUP_GAP_S    = float(os.getenv("GROUP_GAP_S","1.5"))# cluster close frames to single event
+
+# ----------------
+# Model loaders
+# ----------------
+CACHE_DIR = pathlib.Path("hf_assets")
+CACHE_DIR.mkdir(parents=True, exist_ok=True)
+
+def load_yolo_from_hub() -> YOLO:
+    w = hf_hub_download(repo_id=YOLO_REPO_ID, filename=YOLO_FILENAME, cache_dir=CACHE_DIR)
+    return YOLO(w)
+
+def load_autogluon_tabular_from_hub() -> TabularPredictor:
+    z = hf_hub_download(repo_id=AG_REPO_ID, filename=AG_ZIP_NAME, cache_dir=CACHE_DIR)
+    extract_dir = CACHE_DIR / "ag_predictor_native"
+    if extract_dir.exists():
+        shutil.rmtree(extract_dir)
+    with zipfile.ZipFile(z, "r") as zip_ref:
+        zip_ref.extractall(extract_dir)
+    return TabularPredictor.load(str(extract_dir))
+
+_YOLO = None
+_AG_PRED = None
+
+def yolo() -> YOLO:
+    global _YOLO
+    if _YOLO is None:
+        _YOLO = load_yolo_from_hub()
+    return _YOLO
+
+def ag_predictor() -> TabularPredictor:
+    global _AG_PRED
+    if _AG_PRED is None:
+        _AG_PRED = load_autogluon_tabular_from_hub()
+    return _AG_PRED
+
+# ----------------------------
+# Vision helpers
+# ----------------------------
+DEBUG_DIR = pathlib.Path("debug_frames")
+DEBUG_DIR.mkdir(exist_ok=True)
+
+def isolate_scoreboard_color(frame_bgr: np.ndarray,
+                             conf: float = YOLO_CONF,
+                             iou: float = YOLO_IOU,
+                             keep_conf: float = KEEP_CONF,
+                             debug: bool = False,
+                             frame_id: int = None) -> np.ndarray:
+    """
+    Reverted version:
+      - Choose the largest bbox among candidates meeting confidence.
+      - Primary threshold: >= max(0.80, keep_conf)
+      - Fallback threshold: >= (primary - 0.02)  (i.e., ~0.78 by default)
+      - Entire chosen bbox is restored to color; everything else is grayscale.
+      - Single safeguard: reject very low-saturation ROIs (likely flat/neutral areas).
+    """
     H, W = frame_bgr.shape[:2]
+
+    # start fully grayscale
     gray = cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2GRAY)
     gray = cv2.cvtColor(gray, cv2.COLOR_GRAY2BGR)
 
-    res = _YOLO.predict(frame_bgr, conf=YOLO_CONF, iou=YOLO_IOU, verbose=False)
-    if len(res) and getattr(res[0], "boxes", None) is not None and len(res[0].boxes) > 0:
-        boxes  = res[0].boxes.xyxy.cpu().numpy()
-        scores = res[0].boxes.conf.cpu().numpy()
-        valid  = [(b, s) for b, s in zip(boxes, scores) if s >= KEEP_CONF]
-        if valid:
-            b, _ = max(valid, key=lambda bs: (bs[0][2]-bs[0][0])*(bs[0][3]-bs[0][1]))
-            x1, y1, x2, y2 = map(int, b)
-            gray[y1:y2, x1:x2] = frame_bgr[y1:y2, x1:x2]
+    primary_thr  = max(0.80, keep_conf)        # accept ≥0.80 as "good"
+    fallback_thr = max(0.7, primary_thr - 0.05)  # accept ≥0.75 as fallback
+
+
+    chosen_box = None
+    res = yolo().predict(frame_bgr, conf=conf, iou=iou, verbose=False)
+    if len(res):
+        r = res[0]
+        if getattr(r, "boxes", None) is not None and len(r.boxes) > 0:
+            boxes  = r.boxes.xyxy.cpu().numpy()
+            scores = r.boxes.conf.cpu().numpy()
+            candidates = list(zip(boxes, scores))
+
+            # Prefer largest box that meets primary threshold
+            strong = [(b, s) for (b, s) in candidates if float(s) >= primary_thr]
+            if strong:
+                chosen_box, _ = max(strong, key=lambda bs: (bs[0][2]-bs[0][0]) * (bs[0][3]-bs[0][1]))
+            else:
+                # Fallback: largest box meeting fallback threshold
+                medium = [(b, s) for (b, s) in candidates if float(s) >= fallback_thr]
+                if medium:
+                    chosen_box, _ = max(medium, key=lambda bs: (bs[0][2]-bs[0][0]) * (bs[0][3]-bs[0][1]))
+
+            if chosen_box is not None:
+                x1, y1, x2, y2 = [int(round(v)) for v in chosen_box]
+                x1, y1 = max(0, x1), max(0, y1)
+                x2, y2 = min(W-1, x2), min(H-1, y2)
+
+                if x2 > x1 and y2 > y1:
+                    # Single safeguard: reject very low-saturation ROIs
+                    roi_color = frame_bgr[y1:y2, x1:x2]
+                    if roi_color.size > 0:
+                        hsv = cv2.cvtColor(roi_color, cv2.COLOR_BGR2HSV)
+                        sat_mean = hsv[:, :, 1].mean()
+                        if sat_mean < 25:  # flat/neutral area → reject
+                            print(f"[WARN] Rejected bbox due to low saturation (mean={sat_mean:.1f})")
+                            chosen_box = None
+
+                    # If accepted, restore whole bbox to color
+                    if chosen_box is not None:
+                        gray[y1:y2, x1:x2] = frame_bgr[y1:y2, x1:x2]
+
+    # Optional debug save
+    if debug and frame_id is not None:
+        dbg = gray.copy()
+        if chosen_box is not None:
+            x1, y1, x2, y2 = [int(round(v)) for v in chosen_box]
+            cv2.rectangle(dbg, (x1, y1), (x2, y2), (0, 255, 0), 2)
+        out_path = DEBUG_DIR / f"frame_{frame_id:06d}.jpg"
+        cv2.imwrite(str(out_path), dbg)
+        print(f"[DEBUG] Saved debug frame → {out_path}")
+
     return gray
 
-def _count_color(rgb, ch, thr, dom):
-    R,G,B = rgb[:,:,0], rgb[:,:,1], rgb[:,:,2]
-    if ch == "r":
-        mask = (R>thr) & (R>dom*G) & (R>dom*B)
+
+# Color features
+def _count_color_pixels(rgb: np.ndarray, ch: int,
+                        red_thresh=150, green_thresh=100,
+                        red_dom=1.2, green_dom=1.05) -> int:
+    R, G, B = rgb[:, :, 0], rgb[:, :, 1], rgb[:, :, 2]
+    if ch == 0:
+        mask = (R > red_thresh) & (R > red_dom*G) & (R > red_dom*B)
+    elif ch == 1:
+        mask = (G > green_thresh) & (G > green_dom*R) & (G > green_dom*B)
     else:
-        mask = (G>thr) & (G>dom*R) & (G>dom*B)
-    return np.sum(mask)
-
-def features_from_video(video):
-    cap = cv2.VideoCapture(video)
-    fps = cap.get(cv2.CAP_PROP_FPS) or 30
-    rec=[]
-    i=0
+        raise ValueError("ch must be 0 (red) or 1 (green)")
+    return int(np.sum(mask))
+
+def color_pixel_ratio(rgb: np.ndarray, ch: int) -> float:
+    return _count_color_pixels(rgb, ch) / float(rgb.shape[0]*rgb.shape[1] + 1e-9)
+
+def rolling_z(series: pd.Series, win: int = 45) -> pd.Series:
+    med = series.rolling(win, min_periods=5).median()
+    mad = series.rolling(win, min_periods=5).apply(
+        lambda x: np.median(np.abs(x - np.median(x))), raw=True
+    )
+    mad = mad.replace(0, mad[mad > 0].min() if (mad > 0).any() else 1.0)
+    return (series - med) / mad
+
+# ----------------------------
+# Video → feature table
+# ----------------------------
+def extract_feature_timeseries(video_path: str,
+                               frame_skip: int = FRAME_SKIP,
+                               debug: bool = False) -> Tuple[pd.DataFrame, float]:
+    print("[INFO] Starting frame extraction...")
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        print("[ERROR] Could not open video.")
+        return pd.DataFrame(), 0.0
+
+    fps = cap.get(cv2.CAP_PROP_FPS) or 30.0
+    records, frame_idx = [], 0
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+
     while True:
-        ok,f = cap.read()
-        if not ok: break
-        if i%FRAME_SKIP==0:
-            ts=i/fps
-            m= isolate_scoreboard_color(f)
-            rgb=cv2.cvtColor(m, cv2.COLOR_BGR2RGB)
-            r=_count_color(rgb,"r",150,1.2)/(rgb.size/3)
-            g=_count_color(rgb,"g",100,1.05)/(rgb.size/3)
-            rec.append({"timestamp":ts,"red_ratio":r,"green_ratio":g})
-        i+=1
+        ret, frame = cap.read()
+        if not ret:
+            break
+        if frame_idx % frame_skip == 0:
+            ts = frame_idx / fps
+            masked = isolate_scoreboard_color(frame, debug=debug, frame_id=frame_idx)
+            rgb = cv2.cvtColor(masked, cv2.COLOR_BGR2RGB)
+            red_ratio   = color_pixel_ratio(rgb, 0)
+            green_ratio = color_pixel_ratio(rgb, 1)
+            records.append({
+                "frame_id": frame_idx,
+                "timestamp": ts,
+                "red_ratio": red_ratio,
+                "green_ratio": green_ratio,
+            })
+        frame_idx += 1
+
+    cap.release()
+    df = pd.DataFrame(records)
+    print(f"[INFO] Processed {len(df)} frames out of {total_frames} (fps={fps:.2f})")
+
+    if df.empty:
+        return df, fps
+
+    df["red_diff"]   = df["red_ratio"].diff().fillna(0)
+    df["green_diff"] = df["green_ratio"].diff().fillna(0)
+    df["z_red"]      = rolling_z(df["red_ratio"])
+    df["z_green"]    = rolling_z(df["green_ratio"])
+
+    if debug:
+        out_csv = DEBUG_DIR / f"features_{uuid.uuid4().hex}.csv"
+        df.to_csv(out_csv, index=False)
+        print(f"[DEBUG] Saved feature CSV → {out_csv}")
+
+    return df, fps
+
+
+# ----------------------------
+# AutoGluon inference + event picking
+# ----------------------------
+def predict_scores(df: pd.DataFrame) -> pd.Series:
+    feat_cols = ["red_ratio", "green_ratio", "red_diff", "green_diff", "z_red", "z_green"]
+    X = df[feat_cols].copy()
+    pred = ag_predictor().predict(X)
+
+    # Prefer classification proba if available
+    try:
+        proba = ag_predictor().predict_proba(X)
+        if isinstance(proba, pd.DataFrame) and (1 in proba.columns):
+            return proba[1]
+    except Exception:
+        pass
+
+    # Fallback: normalize regression-like output to 0..1 robustly
+    s = pd.Series(pred).astype(float)
+    rng = (s.quantile(0.95) - s.quantile(0.05)) or 1.0
+    return ((s - s.quantile(0.05)) / rng).clip(0, 1)
+
+def pick_events(df: pd.DataFrame, score: pd.Series, fps: float) -> List[float]:
+    """
+    Adaptive hybrid event detection:
+    - Adaptive raw threshold = 0.7 × max score
+    - Adaptive z-threshold   = max(2.0, 0.6 × max z-score)
+    - Must be a local peak
+    - Enforce min spacing (1.0s) and group gap (1.5s)
+    - Ignore any detections before 1.0s
+    """
+    max_score = score.max()
+    raw_cutoff = 0.7 * max_score if max_score > 0 else 0.4
+
+    z = rolling_z(score, win=45)
+    max_z = z.max()
+    z_cutoff = max(2.0, 0.6 * max_z)
+
+    print(f"[DEBUG] Predictor score stats: min={score.min():.3f}, max={max_score:.3f}, mean={score.mean():.3f}")
+    print(f"[DEBUG] Adaptive thresholds: raw>{raw_cutoff:.3f}, z>{z_cutoff:.2f}")
+
+    out_times = []
+    min_dist_frames = max(1, int(1.0 * max(1.0, fps)))  # 1.0s spacing
+    y = score.values
+    last_kept = -min_dist_frames
+
+    for i in range(1, len(y)-1):
+        ts = float(df.iloc[i]["timestamp"])
+        local_peak = y[i] > y[i-1] and y[i] > y[i+1]
+        if ts >= 1.0 and ((z.iloc[i] > z_cutoff) or (y[i] > raw_cutoff)) and local_peak and (i - last_kept) >= min_dist_frames:
+            out_times.append(ts)
+            last_kept = i
+
+    if not out_times and len(y) > 0:
+        best_idx = int(np.argmax(y))
+        ts = float(df.iloc[best_idx]["timestamp"])
+        if ts >= 1.0:
+            out_times = [ts]
+            print(f"[DEBUG] Fallback → using global max at {ts:.2f}s")
+        else:
+            print(f"[DEBUG] Ignored fallback at {ts:.2f}s (within first second)")
+
+    out_times.sort()
+
+    grouped = []
+    for t in out_times:
+        if (not grouped) or (t - grouped[-1]) > GROUP_GAP_S:
+            grouped.append(t)
+
+    print(f"[DEBUG] Final detected events: {grouped}")
+    return grouped
+
+def save_event_snapshot(video_path: str, timestamp: float, out_path: str, fps: float):
+    """Save a snapshot frame at timestamp with YOLO bbox drawn."""
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        print("[ERROR] Could not open video for snapshot.")
+        return None
+
+    frame_idx = int(timestamp * fps)
+    cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx)
+    ret, frame = cap.read()
     cap.release()
-    df=pd.DataFrame(rec)
-    if df.empty: return df,fps
-    df["red_diff"]=df["red_ratio"].diff().fillna(0)
-    df["green_diff"]=df["green_ratio"].diff().fillna(0)
-    return df,fps
-
-def predict_score(df):
-    cols=["red_ratio","green_ratio","red_diff","green_diff"]
-    pred=_AG.predict(df[cols])
+
+    if not ret or frame is None:
+        print(f"[WARN] Could not grab frame at {timestamp:.2f}s")
+        return None
+
+    masked = isolate_scoreboard_color(frame, debug=False)
+    res = yolo().predict(frame, conf=YOLO_CONF, iou=YOLO_IOU, verbose=False)
+
+    if len(res) and getattr(res[0], "boxes", None) is not None and len(res[0].boxes) > 0:
+        boxes = res[0].boxes.xyxy.cpu().numpy()
+        scores = res[0].boxes.conf.cpu().numpy()
+        valid = [(box, score) for box, score in zip(boxes, scores) if float(score) >= KEEP_CONF]
+        if valid:
+            largest, _ = max(valid, key=lambda bs: (bs[0][2]-bs[0][0])*(bs[0][3]-bs[0][1]))
+            x1, y1, x2, y2 = [int(round(v)) for v in largest]
+            cv2.rectangle(masked, (x1, y1), (x2, y2), (0, 255, 0), 3)
+
+    cv2.imwrite(out_path, masked)
+    print(f"[DEBUG] Saved snapshot → {out_path}")
+    return out_path
+
+import matplotlib.pyplot as plt
+def save_debug_plot(df: pd.DataFrame, score: pd.Series, events: List[float], base_name="debug_plot"):
+    plt.figure(figsize=(12, 5))
+    plt.plot(df["timestamp"], score, label="Predicted Score")
+    plt.axhline(y=0.5, color="gray", linestyle="--", alpha=0.5)
+    first = True
+    for ev in events:
+        plt.axvline(x=ev, color="red", linestyle="--", label="Detected Event" if first else None)
+        first = False
+    plt.xlabel("Time (s)")
+    plt.ylabel("Score")
+    plt.title("AutoGluon Score vs Time")
+    plt.legend()
+    out_path = DEBUG_DIR / f"{base_name}.png"
+    plt.savefig(out_path)
+    plt.close()
+    print(f"[DEBUG] Saved debug score plot → {out_path}")
+
+
+# ----------------------------
+# Clip cutting (ffmpeg w/ moviepy fallback)
+# ----------------------------
+def _probe_duration(video_path: str) -> float:
+    try:
+        if ffmpeg is None:
+            raise RuntimeError("ffmpeg-python not available")
+        meta = ffmpeg.probe(video_path)
+        return float(meta["format"]["duration"])
+    except Exception:
+        return 0.0
+
+def cut_clip(video_path: str, start: float, end: float, out_path: str) -> str:
+    # Fast path (copy) if ffmpeg available
     try:
-        proba=_AG.predict_proba(df[cols])
-        if 1 in proba.columns: return proba[1]
-    except Exception: pass
-    s=pd.Series(pred).astype(float)
-    return (s-s.min())/(s.max()-s.min()+1e-9)
-
-def detect_touches(df,score,fps):
-    peaks=[]
-    for i in range(1,len(score)-1):
-        if score[i]>0.7 and score[i]>score[i-1] and score[i]>score[i+1]:
-            peaks.append(df.iloc[i]["timestamp"])
-    return peaks[:3]  # cap to 3 clips for speed
-
-def cut_clip(video,start,end,out_path):
-    import subprocess
-    cmd=["ffmpeg","-y","-ss",str(start),"-to",str(end),"-i",video,
-         "-c","copy",out_path]
-    subprocess.run(cmd,stdout=subprocess.DEVNULL,stderr=subprocess.DEVNULL)
+        cmd = ["ffmpeg", "-y", "-ss", str(max(0, start)), "-to", str(max(start, end)),
+               "-i", video_path, "-c", "copy", out_path]
+        sp = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        if sp.returncode == 0 and os.path.exists(out_path):
+            return out_path
+    except Exception:
+        pass
+
+    # Fallback: moviepy re-encode
+    from moviepy.editor import VideoFileClip
+    clip = VideoFileClip(video_path).subclip(max(0, start), max(start, end))
+    clip.write_videofile(out_path, codec="libx264", audio_codec="aac", verbose=False, logger=None)
     return out_path
 
-def extract_score_clips(video_file):
-    df,fps=features_from_video(video_file)
+# ----------------------------
+# Orchestrator: detect + cut + debug
+# ----------------------------
+
+def extract_score_clips(video_path: str, debug: bool = True) -> Tuple[List[Tuple[str, str]], str]:
+    print("[INFO] Running full detection pipeline...")
+    df, fps = extract_feature_timeseries(video_path, frame_skip=FRAME_SKIP, debug=debug)
     if df.empty:
-        return [],"No frames processed."
-    score=predict_score(df)
-    events=detect_touches(df,score,fps)
+        print("[WARN] Empty dataframe — no frames processed.")
+        return [], "No frames processed."
+
+    print("[INFO] Feature extraction done. Running predictor...")
+    score = predict_scores(df)
+
+    # Bail early if the model produced no signal at all
+    if score.max() <= 1e-6:
+        print("[WARN] Flat scores from predictor (possible YOLO miss or feature mismatch).")
+        return [], "⚠️ No scoreboard detected or illumination scores flat. Please check video or model."
+
+    print("[INFO] Picking events from predictor scores...")
+    events = pick_events(df, score, fps)
+    print(f"[INFO] Picked {len(events)} event(s): {events}")
+
     if not events:
-        return [],"No touches detected."
-    clips=[]
-    base=os.path.splitext(os.path.basename(video_file))[0]
-    for i,t in enumerate(events):
-        s=max(0,t-CLIP_PAD_S); e=t+CLIP_PAD_S
-        out=str(OUTPUT_DIR / f"{base}_touch_{i+1}.mp4")
-        cut_clip(video_file,s,e,out)
-        clips.append((out,f"Touch {i+1} @ {t:.2f}s"))
-    return clips,f"Detected {len(clips)} touch(es)."
-
-# ---------------------------------------------------------------------
+        topk = np.argsort(score.values)[-5:][::-1]
+        dbg = [(float(df.iloc[i]['timestamp']), float(score.iloc[i])) for i in topk]
+        print(f"[DEBUG] Top-5 peaks (ts,score): {dbg}")
+        return [], "⚠️ No touches confidently detected in this video."
+
+    duration = _probe_duration(video_path)
+    if duration <= 0:
+        duration = float(df["timestamp"].max() + CLIP_PAD_S + 0.5)
+
+    clips = []
+    snapshots = []
+    base = os.path.splitext(os.path.basename(video_path))[0]
+    for i, t in enumerate(events):
+        s = max(0.0, t - CLIP_PAD_S)
+        e = min(duration, t + CLIP_PAD_S)
+        clip_path = os.path.join(tempfile.gettempdir(), f"{base}_score_{i+1:02d}.mp4")
+        img_path  = os.path.join(tempfile.gettempdir(), f"{base}_score_{i+1:02d}.jpg")
+        cut_clip(video_path, s, e, clip_path)
+        save_event_snapshot(video_path, t, img_path, fps)
+        label = f"Touch {i+1} @ {t:.2f}s"
+        clips.append((clip_path, label))
+        snapshots.append(img_path)
+
+    if debug:
+        debug_csv = DEBUG_DIR / f"scores_{base}.csv"
+        pd.DataFrame({"timestamp": df["timestamp"], "score": score}).to_csv(debug_csv, index=False)
+        print(f"[DEBUG] Saved score debug CSV → {debug_csv}")
+        save_debug_plot(df, score, events, base_name=base)
+        print(f"[DEBUG] Saved debug frames in {DEBUG_DIR}/")
+
+    return clips, f"✅ Detected {len(clips)} event(s). Snapshots saved to temp."
+
+import time
+
+def looping_progress():
+    """
+    Infinite generator that loops the fencer animation from 0 → 100%.
+    Yields progress bar HTML until stopped by the pipeline finishing.
+    """
+    while True:
+        for i in range(101):
+            bar = _make_progress_bar(i)
+            yield gr.update(value=bar, visible=True)
+            time.sleep(0.05)  # controls speed of march (~5s per loop)
+
+# ----------------------------
 # Gradio UI
-# ---------------------------------------------------------------------
-def run(video):
-    if not video: return [],"Please upload a video."
-    return extract_score_clips(video)
-
-demo = gr.Interface(
-    fn=run,
-    inputs=gr.Video(label="Upload fencing bout"),
-    outputs=[gr.Gallery(label="Detected Clips"), gr.Textbox(label="Status")],
-    title="🤺 Fencing Scoreboard Detector",
-    description="YOLO + AutoGluon model to detect scoreboard-light touches."
-)
+# ----------------------------
+CSS = """
+.gradio-container {max-width: 900px; margin: auto;}
+.header {text-align: center; margin-bottom: 20px;}
+.full-width {width: 100% !important;}
+.progress-bar {
+    width: 100%;
+    height: 30px;
+    background-color: #e0e0e0;
+    border-radius: 15px;
+    margin: 15px 0;
+    position: relative;
+    overflow: hidden;
+}
+.progress-fill {
+    height: 100%;
+    background-color: #4CAF50;
+    border-radius: 15px;
+    text-align: center;
+    line-height: 30px;
+    color: white;
+    font-weight: bold;
+    transition: width 0.3s;
+}
+.fencer {
+    position: absolute;
+    top: -5px;
+    font-size: 24px;
+    transition: left 0.3s;
+    transform: scaleX(-1);   /* flip to face right */
+}
+"""
+
+def _make_progress_bar(percent: int, final_text: str = None):
+    text = f"{percent}%" if not final_text else final_text
+    return f"""
+    <div class="progress-bar">
+      <div id="progress-fill" class="progress-fill" style="width:{percent}%">{text}</div>
+      <div id="fencer" class="fencer" style="left:{percent}%">🤺</div>
+    </div>
+    """
+
+def run_with_progress(video_file):
+    if not video_file:
+        yield [], "Please upload a video file.", gr.update(visible=False)
+        return
+
+    # Step 1: Extract frames + features
+    yield [], "🔄 Extracting frames...", _make_progress_bar(20)
+    df, fps = extract_feature_timeseries(video_file, frame_skip=FRAME_SKIP, debug=False)
+    if df.empty:
+        yield [], "❌ No frames processed!", _make_progress_bar(100, "No Frames ❌")
+        return
+
+    # Step 2–4: Predict & pick events via the single orchestrator
+    yield [], "🔄 Scoring & detecting touches...", _make_progress_bar(80)
+    clips, status_msg = extract_score_clips(video_file, debug=True)
+
+    # Step 5: Done (and cutting already handled in orchestrator)
+    final_bar = _make_progress_bar(100, f"Detected {len(clips)} Touches ⚡" if clips else "No Touches")
+    yield clips, status_msg, final_bar
+
+with gr.Blocks(css=CSS, title="Fencing Scoreboard Detector") as demo:
+    with gr.Row(elem_classes="header"):
+        gr.Markdown(
+            "## 🤺 Fencing Score Detector\n"
+            "Upload a fencing bout video. We’ll detect scoreboard lights (YOLO + AutoGluon), "
+            "and return 4-second highlight clips around each scoring event."
+        )
+
+    in_video = gr.Video(label="Upload Bout Video", elem_classes="full-width", height=400)
+    run_btn  = gr.Button("⚡ Detect Touches", elem_classes="full-width")
+
+    progress_html = gr.HTML(value="", label="Processing Progress", visible=False)
+    status = gr.Markdown("Ready.")
+    gallery = gr.Gallery(
+        label="Detected Clips",
+        columns=1,
+        height=400,
+        preview=True,
+        allow_preview=True,
+        show_download_button=True,
+        visible=False
+    )
+
+    def wrapped_run(video_file):
+        if not video_file:
+            yield gr.update(value=[], visible=False), "Please upload a video file.", gr.update(value=_make_progress_bar(0), visible=False)
+            return
+
+        # Start looping animation
+        progress_iter = looping_progress()
+
+        # Run pipeline in background, but yield progress until it finishes
+        import threading
+
+        result = {}
+
+        def run_pipeline():
+            clips, status_msg = extract_score_clips(video_file, debug=False)
+            result["clips"] = clips
+            result["status"] = status_msg
+
+        t = threading.Thread(target=run_pipeline)
+        t.start()
+
+        while t.is_alive():
+            yield gr.update(value=[], visible=False), "Processing...", next(progress_iter)
+
+        # When pipeline is done → final bar at 100% + output
+        clips, status_msg = result["clips"], result["status"]
+        final_bar = _make_progress_bar(100, "✅ Done")
+        yield gr.update(value=clips, visible=True), status_msg, final_bar
+
+    run_btn.click(
+        fn=wrapped_run,
+        inputs=in_video,
+        outputs=[gallery, status, progress_html],
+    )
 
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    demo.launch(debug=True)