Update app.py

app.py

@@ -1,6 +1,6 @@
 import os
-import json
 import math
+import json
 import tempfile
 from dataclasses import dataclass
 from typing import Dict, List, Tuple, Optional
@@ -9,52 +9,7 @@ import cv2
 import numpy as np
 import pandas as pd
 import gradio as gr
-import matplotlib.pyplot as plt
-import requests
-
 import mediapipe as mp
-from mediapipe.tasks import python
-from mediapipe.tasks.python import vision
-from mediapipe.framework.formats import landmark_pb2
-
-
-# =========================
-# Official model download (Spaces-safe)
-# =========================
-POSE_URL = "https://storage.googleapis.com/mediapipe-models/pose_landmarker/pose_landmarker_full/float16/latest/pose_landmarker_full.task"
-FACE_URL = "https://storage.googleapis.com/mediapipe-models/face_landmarker/face_landmarker/float16/latest/face_landmarker.task"
-
-BASE_DIR = os.path.dirname(os.path.abspath(__file__))
-MODELS_DIR = os.path.join(BASE_DIR, "models")
-POSE_PATH_DEFAULT = os.path.join(MODELS_DIR, "pose_landmarker_full.task")
-FACE_PATH_DEFAULT = os.path.join(MODELS_DIR, "face_landmarker.task")
-
-
-def _download_if_needed(url: str, local_path: str, min_bytes: int = 100 * 1024) -> None:
-    os.makedirs(os.path.dirname(local_path), exist_ok=True)
-    if os.path.exists(local_path) and os.path.getsize(local_path) >= min_bytes:
-        return
-    print(f"[INFO] Downloading model: {url} -> {local_path}")
-    r = requests.get(url, timeout=120)
-    r.raise_for_status()
-    with open(local_path, "wb") as f:
-        f.write(r.content)
-    print(f"[INFO] Download complete. size={os.path.getsize(local_path)} bytes")
-
-
-def ensure_models(pose_path: str, face_path: str) -> Tuple[str, str]:
-    # If user passed default paths, ensure official downloads exist.
-    # If user passed custom paths, we just trust them (but can still fail later).
-    if pose_path == POSE_PATH_DEFAULT:
-        _download_if_needed(POSE_URL, pose_path)
-    if face_path == FACE_PATH_DEFAULT:
-        _download_if_needed(FACE_URL, face_path)
-    return pose_path, face_path
-
-
-def _read_bytes(path: str) -> bytes:
-    with open(path, "rb") as f:
-        return f.read()
 
 
 # -------------------------
@@ -63,11 +18,9 @@ def _read_bytes(path: str) -> bytes:
 def _dist(a: np.ndarray, b: np.ndarray) -> float:
     return float(np.linalg.norm(a - b))
 
-
 def _safe_div(a: float, b: float, eps: float = 1e-8) -> float:
     return a / (b + eps)
 
-
 def eye_aspect_ratio(pts: Dict[int, np.ndarray], idx: List[int]) -> Optional[float]:
     """
     EAR = (||p2-p6|| + ||p3-p5||) / (2*||p1-p4||)
@@ -82,8 +35,10 @@ def eye_aspect_ratio(pts: Dict[int, np.ndarray], idx: List[int]) -> Optional[flo
     C = _dist(p1, p4)
     return _safe_div((A + B), (2.0 * C))
 
-
 def angle_3pts(a: np.ndarray, b: np.ndarray, c: np.ndarray) -> Optional[float]:
+    """
+    angle at point b in degrees formed by a-b-c
+    """
     ba = a - b
     bc = c - b
     nba = np.linalg.norm(ba)
@@ -95,89 +50,73 @@ def angle_3pts(a: np.ndarray, b: np.ndarray, c: np.ndarray) -> Optional[float]:
     return float(np.degrees(np.arccos(cosang)))
 
 
-def poly_area(pts: Dict[int, np.ndarray], idxs: List[int]) -> Optional[float]:
-    arr = []
-    for i in idxs:
-        if i not in pts:
-            return None
-        arr.append(pts[i])
-    cnt = np.array(arr, dtype=np.float32)
-    return float(cv2.contourArea(cnt))
-
-
 # -------------------------
-# Indices
+# MediaPipe indices
 # -------------------------
-LEFT_EYE_EAR_IDX = [33, 160, 158, 133, 153, 144]
+# FaceMesh landmarks for EAR (common set)
+LEFT_EYE_EAR_IDX  = [33, 160, 158, 133, 153, 144]
 RIGHT_EYE_EAR_IDX = [362, 385, 387, 263, 373, 380]
-NEEDED_FACE_IDX = set(LEFT_EYE_EAR_IDX + RIGHT_EYE_EAR_IDX)
 
+# Pose landmark enum mapping (MediaPipe Pose)
 POSE = mp.solutions.pose
 POSE_LM = POSE.PoseLandmark
 
+# Key joints for limb movement/angles
 JOINTS = {
     "left_wrist": POSE_LM.LEFT_WRIST.value,
     "right_wrist": POSE_LM.RIGHT_WRIST.value,
     "left_ankle": POSE_LM.LEFT_ANKLE.value,
     "right_ankle": POSE_LM.RIGHT_ANKLE.value,
+
     "left_shoulder": POSE_LM.LEFT_SHOULDER.value,
     "right_shoulder": POSE_LM.RIGHT_SHOULDER.value,
     "left_elbow": POSE_LM.LEFT_ELBOW.value,
     "right_elbow": POSE_LM.RIGHT_ELBOW.value,
+
     "left_hip": POSE_LM.LEFT_HIP.value,
     "right_hip": POSE_LM.RIGHT_HIP.value,
     "left_knee": POSE_LM.LEFT_KNEE.value,
     "right_knee": POSE_LM.RIGHT_KNEE.value,
 }
 
+
 # -------------------------
-# Drawing helpers (Tasks output -> draw_landmarks)
+# Drawing
 # -------------------------
 mp_drawing = mp.solutions.drawing_utils
+mp_drawing_styles = mp.solutions.drawing_styles
 mp_face_mesh = mp.solutions.face_mesh
 
+def draw_pose(image_bgr, pose_results):
+    if pose_results.pose_landmarks:
+        mp_drawing.draw_landmarks(
+            image_bgr,
+            pose_results.pose_landmarks,
+            POSE.POSE_CONNECTIONS,
+            landmark_drawing_spec=mp_drawing_styles.get_default_pose_landmarks_style(),
+        )
 
-def _to_normalized_landmark_list(lms) -> landmark_pb2.NormalizedLandmarkList:
-    return landmark_pb2.NormalizedLandmarkList(
-        landmark=[
-            landmark_pb2.NormalizedLandmark(
-                x=lm.x, y=lm.y, z=getattr(lm, "z", 0.0)
-            )
-            for lm in lms
-        ]
-    )
-
-
-def draw_pose_from_tasks(image_bgr, pose_res):
-    if not pose_res.pose_landmarks:
-        return
-    lms = pose_res.pose_landmarks[0]
-    nll = _to_normalized_landmark_list(lms)
-    mp_drawing.draw_landmarks(
-        image=image_bgr,
-        landmark_list=nll,
-        connections=POSE.POSE_CONNECTIONS,
-        landmark_drawing_spec=None,
-        connection_drawing_spec=mp_drawing.DrawingSpec(thickness=2, circle_radius=1),
-    )
-
-
-def draw_face_mesh_light(image_bgr, face_res, lightness: int = 245):
-    if not face_res.face_landmarks:
+def draw_face(image_bgr, face_results, draw_full_mesh: bool = False):
+    if not face_results.multi_face_landmarks:
         return
-    lms = face_res.face_landmarks[0]
-    nll = _to_normalized_landmark_list(lms)
-
-    light_spec = mp_drawing.DrawingSpec(
-        color=(lightness, lightness, lightness), thickness=1, circle_radius=1
-    )
-    mp_drawing.draw_landmarks(
-        image=image_bgr,
-        landmark_list=nll,
-        connections=mp_face_mesh.FACEMESH_TESSELATION,
-        landmark_drawing_spec=None,
-        connection_drawing_spec=light_spec,
-    )
+    for face_landmarks in face_results.multi_face_landmarks:
+        if draw_full_mesh:
+            # full mesh (dense) - heavier visually
+            mp_drawing.draw_landmarks(
+                image_bgr,
+                face_landmarks,
+                mp_face_mesh.FACEMESH_TESSELATION,
+                landmark_drawing_spec=None,
+                connection_drawing_spec=mp_drawing_styles.get_default_face_mesh_tesselation_style(),
+            )
+        # contours are enough for most
+        mp_drawing.draw_landmarks(
+            image_bgr,
+            face_landmarks,
+            mp_face_mesh.FACEMESH_CONTOURS,
+            landmark_drawing_spec=None,
+            connection_drawing_spec=mp_drawing_styles.get_default_face_mesh_contours_style(),
+        )
 
 
 # -------------------------
@@ -189,12 +128,16 @@ class BlinkState:
     blink_count: int = 0
     consec_below: int = 0
 
-
-def update_blink(
-    state: BlinkState, ear: Optional[float], thr: float, min_consec: int
-) -> BlinkState:
+def update_blink(state: BlinkState, ear: Optional[float], thr: float, min_consec: int) -> BlinkState:
+    """
+    Basic blink logic:
+    - ear below threshold for >= min_consec frames => blink start
+    - when ear goes back above => blink end (count once)
+    """
     if ear is None:
+        # treat missing as no-update
         return state
+
     if ear < thr:
         state.consec_below += 1
         if (not state.in_blink) and state.consec_below >= min_consec:
@@ -208,30 +151,22 @@ def update_blink(
 
 
 # -------------------------
-# Core processing (Tasks CPU-only + buffer load)
+# Core processing
 # -------------------------
 def process_video(
     video_path: str,
-    pose_model_path: str = POSE_PATH_DEFAULT,
-    face_model_path: str = FACE_PATH_DEFAULT,
-    use_gpu_delegate: bool = False,  # ignored, always CPU
-
+    pose_model_complexity: int = 1,
     min_pose_det_conf: float = 0.5,
     min_pose_track_conf: float = 0.5,
     min_face_det_conf: float = 0.5,
-
     ear_threshold: float = 0.21,
     blink_min_consec: int = 2,
-
-    draw_face_mesh: bool = True,
-    face_mesh_lightness: int = 245,
-
-    resize_width: int = 0,
-    max_frames: int = 0,
-) -> Tuple[str, str, str, str, str]:
+    draw_full_face_mesh: bool = False,
+    max_frames: int = 0,  # 0 => all
+) -> Tuple[str, str, str, str]:
     """
     Returns:
-      annotated_video_path, csv_path, json_path, plot_path, report_md_path
+      annotated_video_path, csv_path, json_path, report_md
     """
     cap = cv2.VideoCapture(video_path)
     if not cap.isOpened():
@@ -240,233 +175,176 @@ def process_video(
     fps = cap.get(cv2.CAP_PROP_FPS)
     if fps <= 1e-6:
         fps = 30.0
-
-    orig_w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-    orig_h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
     total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
 
-    if resize_width and resize_width > 0 and orig_w > 0:
-        scale = resize_width / float(orig_w)
-        width = int(orig_w * scale)
-        height = int(orig_h * scale)
-    else:
-        width, height = orig_w, orig_h
-
-    tmpdir = tempfile.mkdtemp(prefix="mp_tasks_analysis_")
+    # output paths
+    tmpdir = tempfile.mkdtemp(prefix="mp_analysis_")
     out_video = os.path.join(tmpdir, "annotated.mp4")
     out_csv = os.path.join(tmpdir, "per_frame_metrics.csv")
     out_json = os.path.join(tmpdir, "summary.json")
-    out_plot = os.path.join(tmpdir, "motion_eye_timeseries.png")
     out_report = os.path.join(tmpdir, "report.md")
 
     fourcc = cv2.VideoWriter_fourcc(*"mp4v")
     writer = cv2.VideoWriter(out_video, fourcc, fps, (width, height))
 
-    # ---- MediaPipe Tasks init ----
-    BaseOptions = python.BaseOptions
-    RunningMode = vision.RunningMode
-
-    # Ensure official models exist (download if default paths)
-    pose_model_path, face_model_path = ensure_models(pose_model_path, face_model_path)
-
-    # Always CPU in Spaces (stable)
-    delegate_used = "CPU"
-
-    def _create_landmarkers_cpu_buffer():
-        pose_data = _read_bytes(pose_model_path)
-        face_data = _read_bytes(face_model_path)
-
-        pose_options = vision.PoseLandmarkerOptions(
-            base_options=BaseOptions(model_asset_buffer=pose_data, delegate=BaseOptions.Delegate.CPU),
-            running_mode=RunningMode.VIDEO,
-            num_poses=1,
-            min_pose_detection_confidence=min_pose_det_conf,
-            min_pose_presence_confidence=min_pose_det_conf,
-            min_tracking_confidence=min_pose_track_conf,
-        )
-        face_options = vision.FaceLandmarkerOptions(
-            base_options=BaseOptions(model_asset_buffer=face_data, delegate=BaseOptions.Delegate.CPU),
-            running_mode=RunningMode.VIDEO,
-            num_faces=1,
-            min_face_detection_confidence=min_face_det_conf,
-            min_face_presence_confidence=min_face_det_conf,
-            min_tracking_confidence=min_face_det_conf,
-        )
-        pose_landmarker = vision.PoseLandmarker.create_from_options(pose_options)
-        face_landmarker = vision.FaceLandmarker.create_from_options(face_options)
-        return pose_landmarker, face_landmarker
-
-    pose_landmarker, face_landmarker = _create_landmarkers_cpu_buffer()
-
-    # ---- per-frame states ----
-    rows = []
-    left_blink = BlinkState()
-    right_blink = BlinkState()
-
-    prev_pose_px: Dict[str, np.ndarray] = {}
-    prev_eye_area = {"L": None, "R": None}
-
-    times = []
-    limb_pix_series = []
-    eye_area_diff_series = []
-
-    frame_idx = 0
-    while True:
-        ok, frame_bgr = cap.read()
-        if not ok:
-            break
-        frame_idx += 1
-        if max_frames and frame_idx > max_frames:
-            break
-
-        if (width != orig_w) or (height != orig_h):
-            frame_bgr = cv2.resize(frame_bgr, (width, height), interpolation=cv2.INTER_AREA)
-
-        frame_rgb = cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2RGB)
-        mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=frame_rgb)
-        timestamp_ms = int((frame_idx - 1) * 1000.0 / fps)
-
-        pose_res = pose_landmarker.detect_for_video(mp_image, timestamp_ms)
-        face_res = face_landmarker.detect_for_video(mp_image, timestamp_ms)
-
-        # ---- Face: EAR + eye area ----
-        face_pts: Dict[int, np.ndarray] = {}
-        if face_res.face_landmarks:
-            lms = face_res.face_landmarks[0]
-            for i in NEEDED_FACE_IDX:
-                lm = lms[i]
-                face_pts[i] = np.array([lm.x * width, lm.y * height], dtype=np.float32)
-
-        left_ear = eye_aspect_ratio(face_pts, LEFT_EYE_EAR_IDX)
-        right_ear = eye_aspect_ratio(face_pts, RIGHT_EYE_EAR_IDX)
-
-        left_blink = update_blink(left_blink, left_ear, ear_threshold, blink_min_consec)
-        right_blink = update_blink(right_blink, right_ear, ear_threshold, blink_min_consec)
-
-        left_eye_area = poly_area(face_pts, LEFT_EYE_EAR_IDX)
-        right_eye_area = poly_area(face_pts, RIGHT_EYE_EAR_IDX)
-
-        def area_diff(cur, key):
-            prev = prev_eye_area[key]
-            prev_eye_area[key] = cur
-            if cur is None:
-                return None
-            if prev is None:
-                return 0.0
-            return float(abs(cur - prev))
-
-        left_eye_area_diff = area_diff(left_eye_area, "L")
-        right_eye_area_diff = area_diff(right_eye_area, "R")
-        eye_area_diff_total = sum(v for v in [left_eye_area_diff, right_eye_area_diff] if v is not None)
-
-        # ---- Pose: pixel displacement + angles ----
-        pose_px: Dict[str, Optional[np.ndarray]] = {}
-        if pose_res.pose_landmarks:
-            lms = pose_res.pose_landmarks[0]
-            for name, idx in JOINTS.items():
-                lm = lms[idx]
-                pose_px[name] = np.array([lm.x * width, lm.y * height], dtype=np.float32)
-        else:
-            for name in JOINTS:
-                pose_px[name] = None
-
-        def pixel_disp(key: str) -> Optional[float]:
-            cur = pose_px.get(key)
-            if cur is None:
-                return None
-            prev = prev_pose_px.get(key)
-            prev_pose_px[key] = cur
-            if prev is None:
-                return 0.0
-            return float(np.linalg.norm(cur - prev))
-
-        lw_pix = pixel_disp("left_wrist")
-        rw_pix = pixel_disp("right_wrist")
-        la_pix = pixel_disp("left_ankle")
-        ra_pix = pixel_disp("right_ankle")
-        limbs_pix_total = sum(v for v in [lw_pix, rw_pix, la_pix, ra_pix] if v is not None)
-
-        def get_angle(a, b, c):
-            if a is None or b is None or c is None:
-                return None
-            return angle_3pts(a, b, c)
-
-        left_elbow_ang = get_angle(pose_px["left_shoulder"], pose_px["left_elbow"], pose_px["left_wrist"])
-        right_elbow_ang = get_angle(pose_px["right_shoulder"], pose_px["right_elbow"], pose_px["right_wrist"])
-        left_knee_ang = get_angle(pose_px["left_hip"], pose_px["left_knee"], pose_px["left_ankle"])
-        right_knee_ang = get_angle(pose_px["right_hip"], pose_px["right_knee"], pose_px["right_ankle"])
-
-        # ---- Draw overlays ----
-        draw_pose_from_tasks(frame_bgr, pose_res)
-        if draw_face_mesh:
-            draw_face_mesh_light(frame_bgr, face_res, lightness=int(face_mesh_lightness))
-
-        hud_lines = [
-            f"frame: {frame_idx}/{total_frames if total_frames>0 else '?'}  fps:{fps:.1f}  delegate:{delegate_used}",
-            f"EAR L:{left_ear:.3f}" if left_ear is not None else "EAR L:None",
-            f"EAR R:{right_ear:.3f}" if right_ear is not None else "EAR R:None",
-            f"Blink L:{left_blink.blink_count}  R:{right_blink.blink_count}",
-            f"LimbPix(sum): {limbs_pix_total:.2f}   EyeAreaDiff(sum): {eye_area_diff_total:.2f}",
-        ]
-        y0 = 24
-        for line in hud_lines:
-            cv2.putText(frame_bgr, line, (12, y0), cv2.FONT_HERSHEY_SIMPLEX, 0.55, (255, 255, 255), 2)
-            y0 += 20
-
-        writer.write(frame_bgr)
-
-        t = (frame_idx - 1) / fps
-        times.append(t)
-        limb_pix_series.append(limbs_pix_total)
-        eye_area_diff_series.append(eye_area_diff_total)
-
-        rows.append({
-            "frame": frame_idx,
-            "time_s": t,
-            "left_ear": left_ear,
-            "right_ear": right_ear,
-            "lw_pix_disp": lw_pix,
-            "rw_pix_disp": rw_pix,
-            "la_pix_disp": la_pix,
-            "ra_pix_disp": ra_pix,
-            "limbs_pix_disp_sum": limbs_pix_total,
-            "left_eye_area_px2": left_eye_area,
-            "right_eye_area_px2": right_eye_area,
-            "left_eye_area_diff_px2": left_eye_area_diff,
-            "right_eye_area_diff_px2": right_eye_area_diff,
-            "eye_area_diff_sum_px2": eye_area_diff_total,
-            "left_elbow_angle": left_elbow_ang,
-            "right_elbow_angle": right_elbow_ang,
-            "left_knee_angle": left_knee_ang,
-            "right_knee_angle": right_knee_ang,
-        })
+    # MediaPipe init - using legacy API (works without model downloads)
+    with mp.solutions.pose.Pose(
+        static_image_mode=False,
+        model_complexity=pose_model_complexity,
+        enable_segmentation=False,
+        min_detection_confidence=min_pose_det_conf,
+        min_tracking_confidence=min_pose_track_conf,
+    ) as pose, mp_face_mesh.FaceMesh(
+        static_image_mode=False,
+        max_num_faces=1,
+        refine_landmarks=True,  # improves eye landmarks
+        min_detection_confidence=min_face_det_conf,
+        min_tracking_confidence=min_face_det_conf,
+    ) as face_mesh:
+
+        rows = []
+        prev_pts = {}  # for movement delta (normalized coordinates)
+        left_blink = BlinkState()
+        right_blink = BlinkState()
+
+        frame_idx = 0
+        while True:
+            ok, frame_bgr = cap.read()
+            if not ok:
+                break
+            frame_idx += 1
+            if max_frames and frame_idx > max_frames:
+                break
+
+            frame_rgb = cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2RGB)
+
+            pose_res = pose.process(frame_rgb)
+            face_res = face_mesh.process(frame_rgb)
+
+            # Extract face landmarks (pixel coords)
+            face_pts: Dict[int, np.ndarray] = {}
+            if face_res.multi_face_landmarks:
+                lm = face_res.multi_face_landmarks[0].landmark
+                for i in range(len(lm)):
+                    face_pts[i] = np.array([lm[i].x * width, lm[i].y * height], dtype=np.float32)
+
+            # EAR
+            left_ear = eye_aspect_ratio(face_pts, LEFT_EYE_EAR_IDX)
+            right_ear = eye_aspect_ratio(face_pts, RIGHT_EYE_EAR_IDX)
+
+            left_blink = update_blink(left_blink, left_ear, ear_threshold, blink_min_consec)
+            right_blink = update_blink(right_blink, right_ear, ear_threshold, blink_min_consec)
+
+            # Extract pose landmarks (normalized coords + pixel)
+            pose_norm: Dict[str, Optional[np.ndarray]] = {}
+            pose_px: Dict[str, Optional[np.ndarray]] = {}
+            if pose_res.pose_landmarks:
+                lms = pose_res.pose_landmarks.landmark
+                for name, idx in JOINTS.items():
+                    if idx < len(lms):
+                        pose_norm[name] = np.array([lms[idx].x, lms[idx].y], dtype=np.float32)
+                        pose_px[name] = np.array([lms[idx].x * width, lms[idx].y * height], dtype=np.float32)
+                    else:
+                        pose_norm[name] = None
+                        pose_px[name] = None
+            else:
+                for name in JOINTS:
+                    pose_norm[name] = None
+                    pose_px[name] = None
+
+            # Limb movement: per-frame displacement & speed (in normalized units)
+            def movement_metrics(key: str):
+                cur = pose_norm.get(key)
+                if cur is None:
+                    return None, None
+                prev = prev_pts.get(key)
+                if prev is None:
+                    d = 0.0
+                else:
+                    d = float(np.linalg.norm(cur - prev))
+                v = d * fps
+                prev_pts[key] = cur
+                return d, v
+
+            lw_d, lw_v = movement_metrics("left_wrist")
+            rw_d, rw_v = movement_metrics("right_wrist")
+            la_d, la_v = movement_metrics("left_ankle")
+            ra_d, ra_v = movement_metrics("right_ankle")
+
+            # Joint angles (pixel coords for stability)
+            def get_angle(a, b, c):
+                if a is None or b is None or c is None:
+                    return None
+                return angle_3pts(a, b, c)
+
+            left_elbow_ang = get_angle(pose_px["left_shoulder"], pose_px["left_elbow"], pose_px["left_wrist"])
+            right_elbow_ang = get_angle(pose_px["right_shoulder"], pose_px["right_elbow"], pose_px["right_wrist"])
+            left_knee_ang = get_angle(pose_px["left_hip"], pose_px["left_knee"], pose_px["left_ankle"])
+            right_knee_ang = get_angle(pose_px["right_hip"], pose_px["right_knee"], pose_px["right_ankle"])
+
+            # Draw overlays
+            draw_pose(frame_bgr, pose_res)
+            draw_face(frame_bgr, face_res, draw_full_mesh=draw_full_face_mesh)
+
+            # HUD text
+            hud_lines = [
+                f"frame: {frame_idx}/{total_frames if total_frames>0 else '?'}  fps:{fps:.1f}",
+                f"EAR L:{left_ear:.3f}" if left_ear is not None else "EAR L:None",
+                f"EAR R:{right_ear:.3f}" if right_ear is not None else "EAR R:None",
+                f"Blink L:{left_blink.blink_count}  R:{right_blink.blink_count}",
+            ]
+            y0 = 24
+            for line in hud_lines:
+                cv2.putText(frame_bgr, line, (12, y0), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
+                y0 += 22
+
+            writer.write(frame_bgr)
+
+            rows.append({
+                "frame": frame_idx,
+                "time_s": (frame_idx - 1) / fps,
+
+                "left_ear": left_ear,
+                "right_ear": right_ear,
+
+                "lw_disp": lw_d,
+                "rw_disp": rw_d,
+                "la_disp": la_d,
+                "ra_disp": ra_d,
+
+                "lw_speed": lw_v,
+                "rw_speed": rw_v,
+                "la_speed": la_v,
+                "ra_speed": ra_v,
+
+                "left_elbow_angle": left_elbow_ang,
+                "right_elbow_angle": right_elbow_ang,
+                "left_knee_angle": left_knee_ang,
+                "right_knee_angle": right_knee_ang,
+            })
 
     cap.release()
     writer.release()
 
-    try:
-        pose_landmarker.close()
-        face_landmarker.close()
-    except Exception:
-        pass
-
     df = pd.DataFrame(rows)
 
+    # Summaries
     def _sum_series(s: pd.Series):
         s2 = s.dropna()
         if len(s2) == 0:
             return {"mean": None, "min": None, "max": None}
         return {"mean": float(s2.mean()), "min": float(s2.min()), "max": float(s2.max())}
 
+    # movement totals in normalized units (roughly proportional)
     summary = {
         "video": {
             "fps": float(fps),
-            "width": int(width),
-            "height": int(height),
+            "width": width,
+            "height": height,
             "frames_processed": int(len(df)),
-            "duration_s": float(len(df) / fps) if len(df) else 0.0,
-            "delegate_used": delegate_used,
-            "resize_width": int(resize_width),
+            "duration_s": float(len(df) / fps),
         },
         "blink": {
             "ear_threshold": float(ear_threshold),
@@ -475,62 +353,69 @@ def process_video(
             "right_blinks": int(right_blink.blink_count),
             "left_blinks_per_min": float(_safe_div(left_blink.blink_count, (len(df)/fps)/60.0)) if len(df) else 0.0,
             "right_blinks_per_min": float(_safe_div(right_blink.blink_count, (len(df)/fps)/60.0)) if len(df) else 0.0,
-            "left_ear_stats": _sum_series(df["left_ear"]) if len(df) else {"mean": None, "min": None, "max": None},
-            "right_ear_stats": _sum_series(df["right_ear"]) if len(df) else {"mean": None, "min": None, "max": None},
+            "left_ear_stats": _sum_series(df["left_ear"]),
+            "right_ear_stats": _sum_series(df["right_ear"]),
         },
-        "pixel_motion": {
-            "limbs_pix_disp_sum_stats": _sum_series(df["limbs_pix_disp_sum"]) if len(df) else {"mean": None, "min": None, "max": None},
-            "eye_area_diff_sum_px2_stats": _sum_series(df["eye_area_diff_sum_px2"]) if len(df) else {"mean": None, "min": None, "max": None},
+        "limb_movement": {
+            "total_disp": {
+                "left_wrist": float(df["lw_disp"].fillna(0).sum()),
+                "right_wrist": float(df["rw_disp"].fillna(0).sum()),
+                "left_ankle": float(df["la_disp"].fillna(0).sum()),
+                "right_ankle": float(df["ra_disp"].fillna(0).sum()),
+            },
+            "speed_stats": {
+                "left_wrist": _sum_series(df["lw_speed"]),
+                "right_wrist": _sum_series(df["rw_speed"]),
+                "left_ankle": _sum_series(df["la_speed"]),
+                "right_ankle": _sum_series(df["ra_speed"]),
+            },
+            "angle_stats_deg": {
+                "left_elbow": _sum_series(df["left_elbow_angle"]),
+                "right_elbow": _sum_series(df["right_elbow_angle"]),
+                "left_knee": _sum_series(df["left_knee_angle"]),
+                "right_knee": _sum_series(df["right_knee_angle"]),
+            }
         }
     }
 
+    # Save outputs
     df.to_csv(out_csv, index=False)
     with open(out_json, "w", encoding="utf-8") as f:
         json.dump(summary, f, ensure_ascii=False, indent=2)
 
-    plt.figure()
-    plt.plot(times, limb_pix_series, label="Limb pixel displacement (sum)")
-    plt.plot(times, eye_area_diff_series, label="Eye area diff (sum, px^2)")
-    plt.xlabel("Time (s)")
-    plt.ylabel("Pixel difference")
-    plt.legend()
-    plt.tight_layout()
-    plt.savefig(out_plot, dpi=150)
-    plt.close()
+    report_md = f"""# MediaPipe Pose + FaceLandmarks Analysis Report
 
-    report_md = f"""# MediaPipe Tasks（CPU-only）分析报告
-
-## 视频信息
-- 分辨率: {width} x {height}
+## Video Information
+- Resolution: {width} x {height}
 - FPS: {fps:.2f}
-- 处理帧数: {len(df)}
-- 时长(秒): {summary["video"]["duration_s"]:.2f}
-- Delegate: {delegate_used}
-- Resize width: {resize_width}
-
-## 眨眼分析（EAR）
-- 阈值: {ear_threshold}
-- 最小连续帧数: {blink_min_consec}
-- 左眼眨眼次数: {summary["blink"]["left_blinks"]}（{summary["blink"]["left_blinks_per_min"]:.2f} 次/分钟）
-- 右眼眨眼次数: {summary["blink"]["right_blinks"]}（{summary["blink"]["right_blinks_per_min"]:.2f} 次/分钟）
-- 左眼 EAR: mean={summary["blink"]["left_ear_stats"]["mean"]}  min={summary["blink"]["left_ear_stats"]["min"]}  max={summary["blink"]["left_ear_stats"]["max"]}
-- 右眼 EAR: mean={summary["blink"]["right_ear_stats"]["mean"]}  min={summary["blink"]["right_ear_stats"]["min"]}  max={summary["blink"]["right_ear_stats"]["max"]}
-
-## Pixel Difference 指标（横轴时间）
-- 四肢运动 pixel displacement：对 左/右手腕 + 左/右脚踝 的逐帧像素位移求和（单位像素）
-- 眼睛面积 pixel diff：左右眼(6点多边形)面积的逐帧差值求和（单位像素^2）
-> 对应曲线图：motion_eye_timeseries.png
-
-## 输出文件
-- annotated.mp4：叠加 Pose + 浅色 FaceMesh 的视频
-- per_frame_metrics.csv：逐帧指标（含 limbs pixel disp、eye area diff）
-- summary.json：汇总统计
-- motion_eye_timeseries.png：时间序列曲线图
+- Frames Processed: {len(df)}
+- Duration (seconds): {summary["video"]["duration_s"]:.2f}
+
+## Blink Analysis (EAR)
+- Threshold: {ear_threshold}
+- Minimum Consecutive Frames: {blink_min_consec}
+- Left Eye Blinks: {summary["blink"]["left_blinks"]} ({summary["blink"]["left_blinks_per_min"]:.2f} blinks/min)
+- Right Eye Blinks: {summary["blink"]["right_blinks"]} ({summary["blink"]["right_blinks_per_min"]:.2f} blinks/min)
+- Left Eye EAR: mean={summary["blink"]["left_ear_stats"]["mean"]}  min={summary["blink"]["left_ear_stats"]["min"]}  max={summary["blink"]["left_ear_stats"]["max"]}
+- Right Eye EAR: mean={summary["blink"]["right_ear_stats"]["mean"]} min={summary["blink"]["right_ear_stats"]["min"]} max={summary["blink"]["right_ear_stats"]["max"]}
+
+## Limb Movement (normalized units)
+> Displacement/speed based on normalized coordinates (0~1), suitable for relative comparison and trend analysis.
+- Total Displacement (higher = more movement):
+  - Left Wrist: {summary["limb_movement"]["total_disp"]["left_wrist"]:.6f}
+  - Right Wrist: {summary["limb_movement"]["total_disp"]["right_wrist"]:.6f}
+  - Left Ankle: {summary["limb_movement"]["total_disp"]["left_ankle"]:.6f}
+  - Right Ankle: {summary["limb_movement"]["total_disp"]["right_ankle"]:.6f}
+
+## Output Files
+- annotated.mp4: Video with Pose and FaceMesh overlays
+- per_frame_metrics.csv: Frame-by-frame metrics (EAR / displacement / speed / joint angles)
+- summary.json: Statistical summary
 """
     with open(out_report, "w", encoding="utf-8") as f:
         f.write(report_md)
 
-    return out_video, out_csv, out_json, out_plot, out_report
+    return out_video, out_csv, out_json, out_report
 
 
 # -------------------------
@@ -538,99 +423,89 @@ def process_video(
 # -------------------------
 def ui_process(
     video,
-    pose_model_path,
-    face_model_path,
+    pose_model_complexity,
     min_pose_det_conf,
     min_pose_track_conf,
     min_face_det_conf,
     ear_threshold,
     blink_min_consec,
-    draw_face_mesh,
-    face_mesh_lightness,
-    resize_width,
+    draw_full_face_mesh,
     max_frames
 ):
+    # video may be dict in some gradio versions
     if isinstance(video, dict) and "path" in video:
         video_path = video["path"]
     else:
         video_path = video
 
-    out_video, out_csv, out_json, out_plot, out_report = process_video(
-        video_path=str(video_path),
-        pose_model_path=str(pose_model_path),
-        face_model_path=str(face_model_path),
-        use_gpu_delegate=False,  # always CPU
-        min_pose_det_conf=float(min_pose_det_conf),
-        min_pose_track_conf=float(min_pose_track_conf),
-        min_face_det_conf=float(min_face_det_conf),
-        ear_threshold=float(ear_threshold),
-        blink_min_consec=int(blink_min_consec),
-        draw_face_mesh=bool(draw_face_mesh),
-        face_mesh_lightness=int(face_mesh_lightness),
-        resize_width=int(resize_width),
-        max_frames=int(max_frames),
-    )
+    try:
+        out_video, out_csv, out_json, out_report = process_video(
+            video_path=str(video_path),
+            pose_model_complexity=int(pose_model_complexity),
+            min_pose_det_conf=float(min_pose_det_conf),
+            min_pose_track_conf=float(min_pose_track_conf),
+            min_face_det_conf=float(min_face_det_conf),
+            ear_threshold=float(ear_threshold),
+            blink_min_consec=int(blink_min_consec),
+            draw_full_face_mesh=bool(draw_full_face_mesh),
+            max_frames=int(max_frames),
+        )
 
-    with open(out_report, "r", encoding="utf-8") as f:
-        report_text = f.read()
+        # Show report text + return files
+        with open(out_report, "r", encoding="utf-8") as f:
+            report_text = f.read()
 
-    return out_video, out_csv, out_json, out_plot, report_text
+        return out_video, out_csv, out_json, report_text
+    
+    except Exception as e:
+        error_msg = f"# Error Processing Video\n\n{str(e)}"
+        return None, None, None, error_msg
 
 
-demo = gr.Blocks(title="Video Pose + FaceLandmarker (CPU-only) + CSV + Plot")
+demo = gr.Blocks(title="Video Pose + FaceLandmarks + Blink/Limb Analytics")
 
 with demo:
-    gr.Markdown("## 上传视频 → MediaPipe Tasks（PoseLandmarker + FaceLandmarker，CPU-only）→ CSV + 曲线图 + 标注视频")
+    gr.Markdown("## Upload Video → MediaPipe Pose + FaceMesh → Limb Movement & Blink Quantification (EAR)")
 
     with gr.Row():
-        video_in = gr.Video(label="上传视频", sources=["upload"])
+        video_in = gr.Video(label="Upload Video")
 
-    with gr.Accordion("模型与性能参数", open=False):
-        pose_model_path = gr.Textbox(value=POSE_PATH_DEFAULT, label="Pose .task 路径（默认自动下载官方模型）")
-        face_model_path = gr.Textbox(value=FACE_PATH_DEFAULT, label="Face .task 路径（默认自动下载官方模型）")
-        resize_width = gr.Slider(0, 1280, value=640, step=10, label="Resize width（0=不缩放；建议 640 加速）")
-        max_frames = gr.Number(value=0, precision=0, label="最多处理帧数（0=全处理，调试可设 300）")
-
-    with gr.Accordion("检测阈值参数", open=False):
+    with gr.Accordion("Parameters (defaults work well)", open=False):
+        pose_model_complexity = gr.Radio([0, 1, 2], value=1, label="Pose model_complexity (0=fast / 2=accurate)")
         min_pose_det_conf = gr.Slider(0.1, 0.9, value=0.5, step=0.05, label="Pose min_detection_confidence")
         min_pose_track_conf = gr.Slider(0.1, 0.9, value=0.5, step=0.05, label="Pose min_tracking_confidence")
         min_face_det_conf = gr.Slider(0.1, 0.9, value=0.5, step=0.05, label="Face min_detection_confidence")
-        ear_threshold = gr.Slider(0.10, 0.35, value=0.21, step=0.01, label="眨眼阈值 EAR（越小越严格）")
-        blink_min_consec = gr.Slider(1, 6, value=2, step=1, label="眨眼最小连续帧数（抗抖动）")
 
-    with gr.Accordion("可视化参数", open=False):
-        draw_face_mesh = gr.Checkbox(value=True, label="输出视频叠加 FaceMesh")
-        face_mesh_lightness = gr.Slider(200, 255, value=245, step=1, label="FaceMesh 颜色浅度（越大越浅）")
+        ear_threshold = gr.Slider(0.10, 0.35, value=0.21, step=0.01, label="Blink Threshold EAR (lower = stricter)")
+        blink_min_consec = gr.Slider(1, 6, value=2, step=1, label="Blink Min Consecutive Frames (anti-jitter)")
 
-    run_btn = gr.Button("开始分析")
+        draw_full_face_mesh = gr.Checkbox(value=False, label="Overlay Full FaceMesh (denser/slower)")
+        max_frames = gr.Number(value=0, precision=0, label="Max Frames to Process (0=all, set 300 for debugging)")
+
+    run_btn = gr.Button("Start Analysis", variant="primary")
 
     with gr.Row():
-        video_out = gr.Video(label="输出：标注视频（浅色 FaceMesh）")
-    with gr.Row():
-        csv_out = gr.File(label="逐帧指标 CSV（per_frame_metrics.csv）")
-        json_out = gr.File(label="汇总 JSON（summary.json）")
+        video_out = gr.Video(label="Output: Annotated Video")
     with gr.Row():
-        plot_out = gr.Image(label="曲线图：四肢像素位移 & 眼睛面积变化", type="filepath")
+        csv_out = gr.File(label="Per-Frame Metrics CSV")
+        json_out = gr.File(label="Summary JSON")
     report_out = gr.Markdown()
 
     run_btn.click(
         fn=ui_process,
         inputs=[
             video_in,
-            pose_model_path,
-            face_model_path,
+            pose_model_complexity,
             min_pose_det_conf,
             min_pose_track_conf,
             min_face_det_conf,
             ear_threshold,
             blink_min_consec,
-            draw_face_mesh,
-            face_mesh_lightness,
-            resize_width,
+            draw_full_face_mesh,
             max_frames,
         ],
-        outputs=[video_out, csv_out, json_out, plot_out, report_out],
+        outputs=[video_out, csv_out, json_out, report_out],
     )
 
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    demo.launch(server_name="0.0.0.0", server_port=7860)