Update app.py

app.py

@@ -13,578 +13,284 @@
 # 5) Gradio UI: video in → gallery of clips + status text out.
 #
 # Fencing Scoreboard Clips - YOLO x AutoGluon (Gradio)
-
-import os, sys, zipfile, shutil, subprocess, tempfile, pathlib
+import os, cv2, zipfile, shutil, tempfile, subprocess, pathlib
+import numpy as np, pandas as pd
 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]):
+# =====================================================
+# Configuration
+# =====================================================
+YOLO_REPO_ID  = "mastefan/fencing-scoreboard-yolov8"
+YOLO_FILENAME = "best.pt"
+
+AG_REPO_ID    = "emkessle/2024-24679-fencing-touch-predictor"
+AG_ZIP_NAME   = "autogluon_predictor_dir.zip"
+
+FRAME_SKIP = 2
+KEEP_CONF  = 0.70
+YOLO_CONF  = 0.25
+YOLO_IOU   = 0.50
+CLIP_PAD_S = 2.0
+MIN_SEP_S  = 1.2
+GROUP_GAP_S = 1.5
+
+DEBUG_MODE = False   # set True to save debug images/CSVs
+
+# =====================================================
+# Dependency setup
+# =====================================================
+def _pip(pkgs):
     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
+    from ultralytics import YOLO
 except:
-    try:
-        _pip(["ffmpeg-python"])
-        import ffmpeg
-    except Exception:
-        ffmpeg = None
-
+    _pip(["ultralytics"]); from ultralytics import YOLO
 try:
     from autogluon.tabular import TabularPredictor
 except:
-    _pip(["autogluon.tabular"])
-    from autogluon.tabular import TabularPredictor
-
+    _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
+    _pip(["huggingface_hub"]); from huggingface_hub import hf_hub_download
 
-# ----------------------------
-# 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")
+# =====================================================
+# Model loading
+# =====================================================
+CACHE_DIR = pathlib.Path("hf_assets"); CACHE_DIR.mkdir(exist_ok=True)
 
-# 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.70"))# 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:
+def load_yolo_from_hub():
     w = hf_hub_download(repo_id=YOLO_REPO_ID, filename=YOLO_FILENAME, cache_dir=CACHE_DIR)
+    print(f"[INFO] Loaded YOLO weights from {w}")
     return YOLO(w)
 
-def load_autogluon_tabular_from_hub() -> TabularPredictor:
+def load_autogluon_tabular_from_hub():
     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)
+    if extract_dir.exists(): shutil.rmtree(extract_dir)
+    with zipfile.ZipFile(z, "r") as zip_ref: zip_ref.extractall(extract_dir)
+    print(f"[INFO] Loaded AutoGluon predictor from {extract_dir}")
     return TabularPredictor.load(str(extract_dir))
 
 _YOLO = None
-_AG_PRED = None
-
-def yolo() -> YOLO:
+_AGP  = None
+def yolo():        # lazy load
     global _YOLO
-    if _YOLO is None:
-        _YOLO = load_yolo_from_hub()
+    if _YOLO is None: _YOLO = load_yolo_from_hub()
     return _YOLO
+def ag_predictor():
+    global _AGP
+    if _AGP is None: _AGP = load_autogluon_tabular_from_hub()
+    return _AGP
 
-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)
+# =====================================================
+# Image + feature utilities
+# =====================================================
+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,
+                             debug: bool = DEBUG_MODE,
                              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).
-    """
+    """Grayscale everything except the largest YOLO box ≥ keep_conf."""
     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 = 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]))
+            valid = [(b, s) for b, s in zip(boxes, scores) if float(s) >= keep_conf]
+            if valid:
+                chosen_box, _ = max(valid, key=lambda bs: (bs[0][2]-bs[0][0])*(bs[0][3]-bs[0][1]))
+                x1, y1, x2, y2 = [int(v) for v in chosen_box]
+                gray[y1:y2, x1:x2] = frame_bgr[y1:y2, x1:x2]
 
-            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}")
-
+            x1, y1, x2, y2 = [int(v) for v in chosen_box]
+            cv2.rectangle(dbg, (x1, y1), (x2, y2), (0,255,0), 2)
+        cv2.imwrite(str(DEBUG_DIR / f"frame_{frame_id:06d}.jpg"), dbg)
     return gray
 
-
-# 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:
-        raise ValueError("ch must be 0 (red) or 1 (green)")
+def _count_color_pixels(rgb, ch):
+    R, G, B = rgb[:,:,0], rgb[:,:,1], rgb[:,:,2]
+    if ch==0: mask=(R>150)&(R>1.2*G)&(R>1.2*B)
+    else:     mask=(G>100)&(G>1.05*R)&(G>1.05*B)
     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))
-
+def color_pixel_ratio(rgb,ch): return _count_color_pixels(rgb,ch)/(rgb.shape[0]*rgb.shape[1]+1e-9)
+
+def rolling_z(series, win=45):
+    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 extraction
+# =====================================================
+def extract_feature_timeseries(video_path:str, frame_skip:int=FRAME_SKIP, debug:bool=DEBUG_MODE):
+    cap=cv2.VideoCapture(video_path)
+    if not cap.isOpened(): return pd.DataFrame(),0.0
+    fps=cap.get(cv2.CAP_PROP_FPS) or 30.0
+    total=int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) or 1
+    print(f"[INFO] Reading {total} frames @ {fps:.2f}fps ...")
+
+    rec,idx=[],0
     while True:
-        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,
+        ret,frame=cap.read()
+        if not ret: break
+        if idx%frame_skip==0:
+            ts=idx/fps
+            masked=isolate_scoreboard_color(frame,debug=debug,frame_id=idx)
+            rgb=cv2.cvtColor(masked,cv2.COLOR_BGR2RGB)
+            rec.append({
+                "frame_id":idx,"timestamp":ts,
+                "red_ratio":color_pixel_ratio(rgb,0),
+                "green_ratio":color_pixel_ratio(rgb,1)
             })
-        frame_idx += 1
-
+        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
+    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)
+    df["z_red"]=rolling_z(df["red_ratio"])
+    df["z_green"]=rolling_z(df["green_ratio"])
+    print(f"[INFO] Extracted {len(df)} processed frames.")
+    return df,fps
+
+# =====================================================
+# Predictor & event logic
+# =====================================================
+def predict_scores(df):
+    feats=["red_ratio","green_ratio","red_diff","green_diff","z_red","z_green"]
+    X=df[feats].copy()
+    ag=ag_predictor()
     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}")
+        proba=ag.predict_proba(X)
+        if isinstance(proba,pd.DataFrame) and (1 in proba.columns): return proba[1]
+    except: pass
+    s=pd.Series(ag.predict(X)).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,score,fps):
+    z=rolling_z(score,45); strong=(z>4.0); keep=strong.rolling(3,min_periods=1).sum()>=2
+    min_dist=max(1,int(MIN_SEP_S*fps))
+    y=score.values; out=[]; last=-min_dist
+    for i in range(1,len(y)-1):
+        if keep.iloc[i] and y[i]>y[i-1] and y[i]>y[i+1] and (i-last)>=min_dist:
+            out.append(float(df.iloc[i]["timestamp"])); last=i
+    if not out and len(y)>0: out=[float(df.iloc[int(np.argmax(y))]["timestamp"])]
+    grouped=[]
+    for t in sorted(out):
+        if (not grouped) or (t-grouped[-1])>GROUP_GAP_S: grouped.append(t)
     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()
-
-    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:
+# =====================================================
+# Clip utilities
+# =====================================================
+def _probe_duration(video_path):
     try:
-        if ffmpeg is None:
-            raise RuntimeError("ffmpeg-python not available")
-        meta = ffmpeg.probe(video_path)
+        import ffmpeg
+        meta=ffmpeg.probe(video_path)
         return float(meta["format"]["duration"])
-    except Exception:
-        return 0.0
+    except: return 0.0
 
-def cut_clip(video_path: str, start: float, end: float, out_path: str) -> str:
-    # Fast path (copy) if ffmpeg available
+def cut_clip(video_path,start,end,out_path):
     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 Exception:
-        pass
-
-    # Fallback: moviepy re-encode
+        cmd=["ffmpeg","-y","-ss",str(start),"-to",str(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
     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(start,end)
+    clip.write_videofile(out_path,codec="libx264",audio_codec="aac",verbose=False,logger=None)
     return out_path
 
-# ----------------------------
-# 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:
-        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
-# ----------------------------
+def extract_score_clips(video_path:str,debug:bool=DEBUG_MODE):
+    df,fps=extract_feature_timeseries(video_path,FRAME_SKIP,debug)
+    if df.empty: return [],"No frames processed."
+    score=predict_scores(df); events=pick_events(df,score,fps)
+    print(f"[INFO] Detected {len(events)} potential events: {events}")
+    dur=_probe_duration(video_path) or float(df["timestamp"].max()+CLIP_PAD_S+0.5)
+    out=[]; base=os.path.splitext(os.path.basename(video_path))[0]
+    for i,t in enumerate(events):
+        s=max(0,t-CLIP_PAD_S); e=min(dur,t+CLIP_PAD_S)
+        tmp=os.path.join(tempfile.gettempdir(),f"{base}_score_{i+1:02d}.mp4")
+        print(f"[INFO] Cutting clip {i+1}: {s:.2f}s→{e:.2f}s")
+        cut_clip(video_path,s,e,tmp)
+        out.append((tmp,f"Touch {i+1} @ {t:.2f}s"))
+    return out,f"✅ Detected {len(out)} event(s)."
+
+# =====================================================
+# Progress GUI helpers
+# =====================================================
 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 */
-}
+.gradio-container {max-width:900px;margin:auto;}
+.full-width{width:100%!important;}
+.progress-bar{width:100%;height:30px;background:#e0e0e0;border-radius:15px;margin:15px 0;position:relative;overflow:hidden;}
+.progress-fill{height:100%;background:#4CAF50;border-radius:15px;text-align:center;line-height:30px;color:white;font-weight:bold;transition:width .3s;}
+.fencer{position:absolute;top:-5px;font-size:24px;transition:left .3s;transform:scaleX(-1);}
 """
 
-def _make_progress_bar(percent: int, final_text: str = None):
-    text = f"{percent}%" if not final_text else final_text
+def _make_progress_bar(percent:int,final_text:str=None,label:str=""):
+    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="progress-fill" class="progress-fill" style="width:{percent}%">{label} {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)
+        yield [],"Please upload a video.",_make_progress_bar(0)
         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)
+    print("[GUI] Starting processing...")
+    yield [],"🔄 Extracting frames...",_make_progress_bar(20,"","Pipeline")
+    df,fps=extract_feature_timeseries(video_file,FRAME_SKIP,DEBUG_MODE)
     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 run(video_file):
-        if not video_file:
-            return [], "Please upload a video file."
-        clips, status_msg = extract_score_clips(video_file, debug=False)
-        return clips, status_msg
-    
-    run_btn.click(fn=run, inputs=in_video, outputs=[gallery, status])
-
-if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860, show_api=False)
-
+        yield [],"❌ No frames processed!",_make_progress_bar(100,"No Frames ❌","Pipeline");return
+    yield [],"🔄 YOLO masking...",_make_progress_bar(40,"","Pipeline")
+    yield [],"🔄 Feature analysis...",_make_progress_bar(60,"","Pipeline")
+    yield [],"🔄 Scoring...",_make_progress_bar(80,"","Pipeline")
+    clips,msg=extract_score_clips(video_file,DEBUG_MODE)
+    final=_make_progress_bar(100,f"Detected {len(clips)} Touches ⚡","Pipeline")
+    print("[GUI] Finished.")
+    yield clips,msg,final
+
+# =====================================================
+# Gradio interface
+# =====================================================
+with gr.Blocks(css=CSS,title="Fencing Scoreboard Detector") as demo:
+    gr.Markdown("## 🤺 Fencing Score Detector\nUpload a fencing bout video and automatically detect scoreboard lights using YOLO + AutoGluon.")
+    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="Progress",visible=False)
+    status=gr.Markdown("Ready.")
+    gallery=gr.Gallery(label="Detected Clips",columns=1,height=400,visible=False)
+
+    def wrapped_run(video_file):
+        print("[SYSTEM] User started detection.")
+        yield [],"Processing started...",gr.update(value=_make_progress_bar(0),visible=True)
+        for clips,msg,bar in run_with_progress(video_file):
+            print(f"[SYSTEM] {msg}")
+            yield gr.update(value=clips,visible=bool(clips)),msg,gr.update(value=bar,visible=True)
+
+    run_btn.click(fn=wrapped_run,inputs=in_video,outputs=[gallery,status,progress_html])
+
+if __name__=="__main__":
+    demo.launch(debug=True)