Update app.py

app.py

@@ -13,130 +13,91 @@
 # 5) Gradio UI: video in → gallery of clips + status text out.
 #
 # Fencing Scoreboard Clips - YOLO x AutoGluon (Gradio)
-# -*- coding: utf-8 -*-
-# Fencing Scoreboard Detector — YOLO × AutoGluon × Gradio (Stable Hugging Face Build)
 
-import os, sys, zipfile, shutil, tempfile, subprocess, threading, time, types, warnings
+import os, sys, zipfile, shutil, subprocess, tempfile, pathlib
 from typing import List, Tuple
-import pathlib
+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
+
 from ultralytics import YOLO
-from autogluon.tabular import TabularPredictor
-from huggingface_hub import hf_hub_download
-
-# Silence noisy warnings
-warnings.filterwarnings("ignore", category=UserWarning)
-warnings.filterwarnings("ignore", category=FutureWarning)
-warnings.filterwarnings("ignore", category=DeprecationWarning)
-
-# ---------------- Configuration ----------------
-YOLO_REPO_ID   = os.getenv("YOLO_REPO_ID", "mastefan/fencing-scoreboard-yolov8")
-YOLO_FILENAME  = os.getenv("YOLO_FILENAME", "best.pt")
-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")
-
-FRAME_SKIP     = 2
-KEEP_CONF      = 0.70
-YOLO_CONF      = 0.20
-YOLO_IOU       = 0.50
-GROUP_GAP_S    = 1.5
-CLIP_PAD_S     = 2.0
 
+# ----------------------------
+# 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)
 
-_YOLO = None
-_AG_PRED = None
-from threading import Lock
-_load_lock = Lock()
-
-# ---------------- Model loaders ----------------
 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:
-    """Download + extract predictor ZIP, stub FastAI classes, and load predictor."""
-    z = hf_hub_download(repo_id=AG_REPO_ID, filename=AG_ZIP_NAME,
-                        cache_dir=CACHE_DIR, force_download=True)
+    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))
 
-        # ---- Patch FastAI / fasttransform stubs (final ultra-safe version) ----
-        try:
-            import sys, types
-        
-            # ---- fasttransform stubs ----
-            if "fasttransform" not in sys.modules:
-                fasttransform_stub = types.ModuleType("fasttransform")
-                sys.modules["fasttransform"] = fasttransform_stub
-        
-            if "fasttransform.transform" not in sys.modules:
-                ft_trans_stub = types.ModuleType("fasttransform.transform")
-        
-                class Pipeline:
-                    def __init__(self, *a, **kw): pass
-                    def fit(self, *a, **kw): return self
-                    def transform(self, X): return X
-                    def fit_transform(self, X): return X
-                    def __call__(self, *a, **kw): return self
-                    def __getattr__(self, name): return self
-        
-                ft_trans_stub.Pipeline = Pipeline
-                sys.modules["fasttransform.transform"] = ft_trans_stub
-        
-            # ---- TabWeightedDL stub ----
-            import fastai.tabular.core as ftc
-        
-            class Dummy:
-                """Generic self-replicating dummy for chained calls like .new().to().cpu()"""
-                def __init__(self, *a, **kw): pass
-                def __call__(self, *a, **kw): return self
-                def __getattr__(self, name): return self
-                def __iter__(self): return iter([])
-                def __next__(self): raise StopIteration
-                def __len__(self): return 0
-        
-            ftc.TabWeightedDL = Dummy
-        
-            print("[INFO] Ultra-safe FastAI/fasttransform stubs patched.")
-        except Exception as e:
-            print("[WARN] Could not patch FastAI stubs:", e)
-
-
-        # ---- Load predictor safely ----
-    from autogluon.tabular import TabularPredictor
-    pred = TabularPredictor.load(
-        str(extract_dir),
-        require_py_version_match=False,
-        require_version_match=False
-    )
-
-        # ------------- SAFE LOAD PATCH -------------
-    try:
-        model_names = []
-        # Compatible with all AutoGluon builds
-        if hasattr(pred, "get_model_names"):
-            model_names = pred.get_model_names()
-        elif hasattr(pred, "_trainer") and hasattr(pred._trainer, "get_model_names"):
-            model_names = pred._trainer.get_model_names()
-        elif hasattr(pred, "_learner") and hasattr(pred._learner, "trainer") \
-             and hasattr(pred._learner.trainer, "get_model_names"):
-            model_names = pred._learner.trainer.get_model_names()
-
-        bad_models = [m for m in model_names if "NN" in m or "fastai" in m]
-        if bad_models:
-            print("[INFO] Removing unusable FastAI models:", bad_models)
-            pred.delete_models(models_to_delete=bad_models, dry_run=False)
-    except Exception as e:
-        print("[WARN] Could not prune predictor:", e)
-    # -------------------------------------------
+_YOLO = None
+_AG_PRED = None
 
 def yolo() -> YOLO:
     global _YOLO
@@ -146,61 +107,130 @@ def yolo() -> YOLO:
 
 def ag_predictor() -> TabularPredictor:
     global _AG_PRED
-    with _load_lock:
-        if _AG_PRED is None:
-            print("[INFO] Loading AutoGluon predictor…")
-            _AG_PRED = load_autogluon_tabular_from_hub()
+    if _AG_PRED is None:
+        _AG_PRED = load_autogluon_tabular_from_hub()
     return _AG_PRED
 
-# ---------------- Vision helpers ----------------
+# ----------------------------
+# 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) -> np.ndarray:
-    """Grayscale everything except the largest scoreboard bounding box."""
+                             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)
+
+    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()
+            boxes  = r.boxes.xyxy.cpu().numpy()
             scores = r.boxes.conf.cpu().numpy()
-            candidates = [(b, s) for b, s in zip(boxes, scores) if s >= 0.78]
-            if candidates:
-                chosen_box, _ = max(
-                    candidates,
-                    key=lambda bs: (bs[0][2]-bs[0][0])*(bs[0][3]-bs[0][1])
-                )
+            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]
-                gray[y1:y2, x1:x2] = frame_bgr[y1:y2, x1:x2]
+                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 color_pixel_ratio(rgb: np.ndarray, ch: int) -> float:
+
+# 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 > 150) & (R > 1.2*G) & (R > 1.2*B)
+        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 > 100) & (G > 1.05*R) & (G > 1.05*B)
-    return np.sum(mask) / (rgb.shape[0]*rgb.shape[1] + 1e-9)
+        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)
+        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
-
-# ---------------- Frame & feature extraction ----------------
-def extract_feature_timeseries(video_path: str, frame_skip: int = FRAME_SKIP) -> Tuple[pd.DataFrame, float]:
+    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
-    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
     records, frame_idx = [], 0
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
 
     while True:
         ret, frame = cap.read()
@@ -208,7 +238,7 @@ def extract_feature_timeseries(video_path: str, frame_skip: int = FRAME_SKIP) ->
             break
         if frame_idx % frame_skip == 0:
             ts = frame_idx / fps
-            masked = isolate_scoreboard_color(frame)
+            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)
@@ -216,112 +246,288 @@ def extract_feature_timeseries(video_path: str, frame_skip: int = FRAME_SKIP) ->
                 "frame_id": frame_idx,
                 "timestamp": ts,
                 "red_ratio": red_ratio,
-                "green_ratio": green_ratio
+                "green_ratio": green_ratio,
             })
         frame_idx += 1
-    cap.release()
 
+    cap.release()
     df = pd.DataFrame(records)
-    if df.empty: return df, fps
-    df["red_diff"] = df["red_ratio"].diff().fillna(0)
+    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"])
+    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
 
-# ---------------- Predictor & detection ----------------
+# ----------------------------
+# 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"]
+    feat_cols = ["red_ratio", "green_ratio", "red_diff", "green_diff", "z_red", "z_green"]
     X = df[feat_cols].copy()
-    pred_model = ag_predictor()
-    if pred_model is None:
-        return pd.Series(np.zeros(len(df)))
+    pred = ag_predictor().predict(X)
+
+    # Prefer classification proba if available
     try:
-        proba = pred_model.predict_proba(X)
+        proba = ag_predictor().predict_proba(X)
         if isinstance(proba, pd.DataFrame) and (1 in proba.columns):
             return proba[1]
     except Exception:
         pass
-    s = pd.Series(pred_model.predict(X)).astype(float)
+
+    # 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)
+    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)
-    z_cutoff = max(2.0, 0.6 * z.max())
-    out_times, min_dist_frames = [], int(fps)
-    y, last_kept = score.values, -int(fps)
+    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:
+        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:
+
+    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]
-    grouped=[]
+        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:
+        if (not grouped) or (t - grouped[-1]) > GROUP_GAP_S:
             grouped.append(t)
+
+    print(f"[DEBUG] Final detected events: {grouped}")
     return grouped
 
-# ---------------- Video clipping ----------------
+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()
+
+    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:
-        import ffmpeg
+        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:
-        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: pass
+        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)
+    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_path: str) -> Tuple[List[Tuple[str,str]], str]:
-    df,fps=extract_feature_timeseries(video_path)
-    if df.empty: return [],"No frames processed."
-    score=predict_scores(df)
-    if score.max()<=1e-6: return [],"⚠️ No scoreboard detected or illumination scores flat."
-    events=pick_events(df,score,fps)
-    if not events: return [],"⚠️ No touches confidently detected."
-    duration=_probe_duration(video_path) or df["timestamp"].max()+CLIP_PAD_S+0.5
-    clips=[]
-    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)
-        out=os.path.join(tempfile.gettempdir(),f"{base}_score_{i+1:02d}.mp4")
-        cut_clip(video_path,s,e,out)
-        clips.append((out,f"Touch {i+1} @ {t:.2f}s"))
-    return clips,f"✅ Detected {len(clips)} event(s)."
-
-# ---------------- Gradio GUI ----------------
+# ----------------------------
+# Orchestrator: detect + cut + debug
+# ----------------------------
+def extract_score_clips(video_path: str, debug: bool = False) -> 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:
+        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:
+        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
+# ----------------------------
 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:#e0e0e0;border-radius:15px;margin:15px 0;position:relative;}
-.progress-fill {height:100%;background:#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);}
+.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_fencer_strip(percent: int):
+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}%"></div>
+      <div id="progress-fill" class="progress-fill" style="width:{percent}%">{text}</div>
       <div id="fencer" class="fencer" style="left:{percent}%">🤺</div>
     </div>
     """
@@ -331,39 +537,78 @@ def run_with_progress(video_file):
         yield [], "Please upload a video file.", gr.update(visible=False)
         return
 
-    result = {}
-    def run_pipeline():
-        try:
-            clips, msg = extract_score_clips(video_file)
-        except Exception as e:
-            clips, msg = [], f"❌ Error: {e}"
-        result["clips"], result["msg"] = clips, msg
-
-    t = threading.Thread(target=run_pipeline)
-    t.start()
-    pos = 0
-    while t.is_alive():
-        pos = (pos + 5) % 100
-        yield gr.update(value=[], visible=False), "Processing...", gr.update(value=_make_fencer_strip(pos), visible=True)
-        time.sleep(0.1)
-    clips = result.get("clips", [])
-    msg = result.get("msg", "⚠️ Unknown error during processing.")
-    yield gr.update(value=clips, visible=True), msg, gr.update(value=_make_fencer_strip(100), visible=True)
+    # 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\nUpload a fencing bout video. The system detects scoreboard lights and returns highlight clips around each scoring event.")
+        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="", 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)
-    run_btn.click(fn=run_with_progress,
-                  inputs=in_video,
-                  outputs=[gallery, status, progress_html])
 
-if __name__ == "__main__":
-    demo.launch(debug=True)
+    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(debug=True)