Update app.py

app.py

@@ -9,15 +9,11 @@ import cv2
 import numpy as np
 import pandas as pd
 import gradio as gr
-
-# Headless plotting (HF Spaces safe)
-import matplotlib
-matplotlib.use("Agg")
 import matplotlib.pyplot as plt
 
 import mediapipe as mp
-from mediapipe.tasks import python as mp_python
-from mediapipe.tasks.python import vision as mp_vision
+from mediapipe.tasks import python
+from mediapipe.tasks.python import vision
 from mediapipe.framework.formats import landmark_pb2
 
 
@@ -45,9 +41,6 @@ def eye_aspect_ratio(pts: Dict[int, np.ndarray], idx: List[int]) -> Optional[flo
     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)
@@ -58,15 +51,23 @@ def angle_3pts(a: np.ndarray, b: np.ndarray, c: np.ndarray) -> Optional[float]:
     cosang = max(-1.0, min(1.0, cosang))
     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))
+
 
 # -------------------------
-# MediaPipe indices
+# Indices
 # -------------------------
 LEFT_EYE_EAR_IDX  = [33, 160, 158, 133, 153, 144]
 RIGHT_EYE_EAR_IDX = [362, 385, 387, 263, 373, 380]
-NEEDED_FACE_IDXS = sorted(set(LEFT_EYE_EAR_IDX + RIGHT_EYE_EAR_IDX))
+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
 
@@ -89,53 +90,43 @@ JOINTS = {
 
 
 # -------------------------
-# Drawing (Tasks results)
+# Drawing helpers (Tasks output -> draw_landmarks)
 # -------------------------
 mp_drawing = mp.solutions.drawing_utils
-mp_drawing_styles = mp.solutions.drawing_styles
 mp_face_mesh = mp.solutions.face_mesh
 
-LIGHT_MESH = mp_drawing.DrawingSpec(color=(245, 245, 245), thickness=1, circle_radius=1)
-
-def _to_nll_from_tasks_landmarks(tasks_landmarks) -> landmark_pb2.NormalizedLandmarkList:
-    # tasks_landmarks: list[NormalizedLandmark] (has x,y,z,visibility,presence sometimes)
-    nll = landmark_pb2.NormalizedLandmarkList(
-        landmark=[
-            landmark_pb2.NormalizedLandmark(
-                x=float(lm.x),
-                y=float(lm.y),
-                z=float(getattr(lm, "z", 0.0)),
-                visibility=float(getattr(lm, "visibility", 0.0)) if hasattr(lm, "visibility") else 0.0,
-                presence=float(getattr(lm, "presence", 0.0)) if hasattr(lm, "presence") else 0.0,
-            )
-            for lm in tasks_landmarks
-        ]
+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]
     )
-    return nll
 
-def draw_pose_tasks(image_bgr, pose_res):
-    # pose_res.pose_landmarks: list[list[NormalizedLandmark]]
+def draw_pose_from_tasks(image_bgr, pose_res):
     if not pose_res.pose_landmarks:
         return
-    nll = _to_nll_from_tasks_landmarks(pose_res.pose_landmarks[0])
+    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=mp_drawing_styles.get_default_pose_landmarks_style(),
+        landmark_drawing_spec=None,
+        connection_drawing_spec=mp_drawing.DrawingSpec(thickness=2, circle_radius=1),
     )
 
-def draw_face_mesh_light(image_bgr, face_res):
-    # face_res.face_landmarks: list[list[NormalizedLandmark]]
+def draw_face_mesh_light(image_bgr, face_res, lightness: int = 245):
+    # lightness: 0~255, bigger => lighter
     if not face_res.face_landmarks:
         return
-    nll = _to_nll_from_tasks_landmarks(face_res.face_landmarks[0])
+    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_MESH,
+        connection_drawing_spec=light_spec,
     )
 
 
@@ -164,69 +155,7 @@ def update_blink(state: BlinkState, ear: Optional[float], thr: float, min_consec
 
 
 # -------------------------
-# Task landmarker creation (GPU delegate with fallback)
-# -------------------------
-def create_pose_landmarker(
-    model_path: str,
-    min_pose_det_conf: float,
-    min_pose_track_conf: float,
-    use_gpu: bool = True,
-):
-    BaseOptions = mp_python.BaseOptions
-    RunningMode = mp_vision.RunningMode
-
-    def _make(delegate):
-        opts = mp_vision.PoseLandmarkerOptions(
-            base_options=BaseOptions(model_asset_path=model_path, delegate=delegate),
-            running_mode=RunningMode.VIDEO,
-            num_poses=1,
-            min_pose_detection_confidence=float(min_pose_det_conf),
-            min_pose_presence_confidence=float(min_pose_det_conf),
-            min_tracking_confidence=float(min_pose_track_conf),
-        )
-        return mp_vision.PoseLandmarker.create_from_options(opts)
-
-    if use_gpu:
-        try:
-            return _make(BaseOptions.Delegate.GPU), "GPU"
-        except Exception:
-            # Fallback to CPU
-            return _make(BaseOptions.Delegate.CPU), "CPU(Fallback)"
-    else:
-        return _make(BaseOptions.Delegate.CPU), "CPU"
-
-def create_face_landmarker(
-    model_path: str,
-    min_face_det_conf: float,
-    use_gpu: bool = True,
-):
-    BaseOptions = mp_python.BaseOptions
-    RunningMode = mp_vision.RunningMode
-
-    def _make(delegate):
-        opts = mp_vision.FaceLandmarkerOptions(
-            base_options=BaseOptions(model_asset_path=model_path, delegate=delegate),
-            running_mode=RunningMode.VIDEO,
-            num_faces=1,
-            min_face_detection_confidence=float(min_face_det_conf),
-            min_face_presence_confidence=float(min_face_det_conf),
-            min_tracking_confidence=float(min_face_det_conf),
-            # NOTE: FaceLandmarker has extra options (output_face_blendshapes, output_facial_transformation_matrixes)
-            # We keep them off for speed.
-        )
-        return mp_vision.FaceLandmarker.create_from_options(opts)
-
-    if use_gpu:
-        try:
-            return _make(BaseOptions.Delegate.GPU), "GPU"
-        except Exception:
-            return _make(BaseOptions.Delegate.CPU), "CPU(Fallback)"
-    else:
-        return _make(BaseOptions.Delegate.CPU), "CPU"
-
-
-# -------------------------
-# Core processing
+# Core processing (Tasks + GPU delegate)
 # -------------------------
 def process_video(
     video_path: str,
@@ -241,20 +170,16 @@ def process_video(
     ear_threshold: float = 0.21,
     blink_min_consec: int = 2,
 
-    max_frames: int = 0,  # 0 => all
+    draw_face_mesh: bool = True,
+    face_mesh_lightness: int = 245,
+
+    resize_width: int = 0,  # 0 => no resize; e.g. 640 to speed up
+    max_frames: int = 0,    # 0 => all
 ) -> Tuple[str, str, str, str, str]:
     """
     Returns:
-      annotated_video_path, csv_path, json_path, plot_png_path, report_md_path
+      annotated_video_path, csv_path, json_path, plot_path, report_md_path
     """
-    if not os.path.exists(video_path):
-        raise RuntimeError("Video path not found.")
-
-    if not os.path.exists(pose_model_path):
-        raise RuntimeError(f"Pose model not found: {pose_model_path} (请把 .task 模型放到这个路径)")
-    if not os.path.exists(face_model_path):
-        raise RuntimeError(f"Face model not found: {face_model_path} (请把 .task 模型放到这个路径)")
-
     cap = cv2.VideoCapture(video_path)
     if not cap.isOpened():
         raise RuntimeError("Cannot open video. Please upload a valid video file.")
@@ -262,10 +187,19 @@ def process_video(
     fps = cap.get(cv2.CAP_PROP_FPS)
     if fps <= 1e-6:
         fps = 30.0
-    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+
+    orig_w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    orig_h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
     total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
 
+    # optional resize target
+    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_")
     out_video = os.path.join(tmpdir, "annotated.mp4")
     out_csv = os.path.join(tmpdir, "per_frame_metrics.csv")
@@ -276,19 +210,44 @@ def process_video(
     fourcc = cv2.VideoWriter_fourcc(*"mp4v")
     writer = cv2.VideoWriter(out_video, fourcc, fps, (width, height))
 
-    # Create task landmarkers
-    pose_landmarker, pose_device = create_pose_landmarker(
-        model_path=pose_model_path,
-        min_pose_det_conf=min_pose_det_conf,
-        min_pose_track_conf=min_pose_track_conf,
-        use_gpu=use_gpu_delegate,
-    )
-    face_landmarker, face_device = create_face_landmarker(
-        model_path=face_model_path,
-        min_face_det_conf=min_face_det_conf,
-        use_gpu=use_gpu_delegate,
-    )
+    # ---- MediaPipe Tasks init ----
+    BaseOptions = python.BaseOptions
+    RunningMode = vision.RunningMode
+
+    delegate = BaseOptions.Delegate.GPU if use_gpu_delegate else BaseOptions.Delegate.CPU
 
+    def _create_landmarkers(delegate_to_use):
+        pose_options = vision.PoseLandmarkerOptions(
+            base_options=BaseOptions(model_asset_path=pose_model_path, delegate=delegate_to_use),
+            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_path=face_model_path, delegate=delegate_to_use),
+            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
+
+    # try GPU, fallback to CPU if GPU delegate fails (HF 有时环境/驱动不齐)
+    try:
+        pose_landmarker, face_landmarker = _create_landmarkers(delegate)
+        delegate_used = "GPU" if use_gpu_delegate else "CPU"
+    except Exception as e:
+        # fallback
+        pose_landmarker, face_landmarker = _create_landmarkers(BaseOptions.Delegate.CPU)
+        delegate_used = "CPU(fallback)"
+        print("[WARN] GPU delegate init failed, fallback to CPU. Error:", repr(e))
+
+    # ---- per-frame states ----
     rows = []
     left_blink = BlinkState()
     right_blink = BlinkState()
@@ -301,177 +260,159 @@ def process_video(
     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: extract only needed points for 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 ----
+        # pose skeleton
+        draw_pose_from_tasks(frame_bgr, pose_res)
+        # light face mesh
+        if draw_face_mesh:
+            draw_face_mesh_light(frame_bgr, face_res, lightness=int(face_mesh_lightness))
+
+        # HUD
+        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,
+
+            # pixel displacement per joint
+            "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,
+
+            # eye area / diffs
+            "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,
+
+            # angles
+            "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()
+
+    # close landmarker resources
     try:
-        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)
-            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 points (ONLY needed idxs) in pixel coords
-            face_pts: Dict[int, np.ndarray] = {}
-            if face_res.face_landmarks:
-                lms = face_res.face_landmarks[0]
-                for i in NEEDED_FACE_IDXS:
-                    lm = lms[i]
-                    face_pts[i] = np.array([lm.x * width, lm.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)
-
-            # Eye area + area diff (pixel^2)
-            def poly_area(idxs):
-                pts = [face_pts.get(i) for i in idxs]
-                if any(p is None for p in pts):
-                    return None
-                cnt = np.array(pts, dtype=np.float32)
-                return float(cv2.contourArea(cnt))
-
-            left_eye_area = poly_area(LEFT_EYE_EAR_IDX)
-            right_eye_area = poly_area(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 coords
-            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):
-                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)
-
-            # Joint angles (pixel coords)
-            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_tasks(frame_bgr, pose_res)
-            draw_face_mesh_light(frame_bgr, face_res)
-
-            # HUD
-            hud_lines = [
-                f"frame: {frame_idx}/{total_frames if total_frames>0 else '?'}  fps:{fps:.1f}",
-                f"Pose:{pose_device}  Face:{face_device}  GPU_req:{use_gpu_delegate}",
-                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"Limb pix disp(sum): {limbs_pix_total:.2f}" if limbs_pix_total is not None else "Limb pix disp(sum): None",
-                f"Eye area diff(sum): {eye_area_diff_total:.2f}" if eye_area_diff_total is not None else "Eye area diff(sum): None",
-            ]
-            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(float(limbs_pix_total) if limbs_pix_total is not None else 0.0)
-            eye_area_diff_series.append(float(eye_area_diff_total) if eye_area_diff_total is not None else 0.0)
-
-            rows.append({
-                "frame": frame_idx,
-                "time_s": t,
-
-                "left_ear": left_ear,
-                "right_ear": right_ear,
-
-                "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_total_px2": eye_area_diff_total,
-
-                "lw_pix_disp": lw_pix,
-                "rw_pix_disp": rw_pix,
-                "la_pix_disp": la_pix,
-                "ra_pix_disp": ra_pix,
-                "limbs_pix_disp_total": limbs_pix_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,
-            })
-
-    finally:
-        cap.release()
-        writer.release()
-        # Close landmarkers
-        try:
-            pose_landmarker.close()
-        except Exception:
-            pass
-        try:
-            face_landmarker.close()
-        except Exception:
-            pass
+        pose_landmarker.close()
+        face_landmarker.close()
+    except Exception:
+        pass
 
     df = pd.DataFrame(rows)
 
-    # Plot
-    plt.figure()
-    plt.plot(times, limb_pix_series, label="Limb pixel displacement (sum)")
-    plt.plot(times, eye_area_diff_series, label="Eye area pixel 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()
-
-    # Summaries
+    # ---- Summaries ----
     def _sum_series(s: pd.Series):
         s2 = s.dropna()
         if len(s2) == 0:
@@ -485,13 +426,8 @@ def process_video(
             "height": int(height),
             "frames_processed": int(len(df)),
             "duration_s": float(len(df) / fps) if len(df) else 0.0,
-        },
-        "runtime": {
-            "use_gpu_delegate_requested": bool(use_gpu_delegate),
-            "pose_device": str(pose_device),
-            "face_device": str(face_device),
-            "pose_model_path": str(pose_model_path),
-            "face_model_path": str(face_model_path),
+            "delegate_used": delegate_used,
+            "resize_width": int(resize_width),
         },
         "blink": {
             "ear_threshold": float(ear_threshold),
@@ -500,48 +436,40 @@ 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 "left_ear" in df else {"mean": None, "min": None, "max": None},
-            "right_ear_stats": _sum_series(df["right_ear"]) if "right_ear" in df else {"mean": None, "min": None, "max": None},
-            "left_eye_area_diff_stats_px2": _sum_series(df["left_eye_area_diff_px2"]) if "left_eye_area_diff_px2" in df else {"mean": None, "min": None, "max": None},
-            "right_eye_area_diff_stats_px2": _sum_series(df["right_eye_area_diff_px2"]) if "right_eye_area_diff_px2" in df else {"mean": None, "min": None, "max": None},
+            "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},
         },
-        "limb_motion_pixel": {
-            "total_disp_px": {
-                "left_wrist": float(df["lw_pix_disp"].fillna(0).sum()) if "lw_pix_disp" in df else 0.0,
-                "right_wrist": float(df["rw_pix_disp"].fillna(0).sum()) if "rw_pix_disp" in df else 0.0,
-                "left_ankle": float(df["la_pix_disp"].fillna(0).sum()) if "la_pix_disp" in df else 0.0,
-                "right_ankle": float(df["ra_pix_disp"].fillna(0).sum()) if "ra_pix_disp" in df else 0.0,
-                "sum_limbs": float(df["limbs_pix_disp_total"].fillna(0).sum()) if "limbs_pix_disp_total" in df else 0.0,
-            },
-            "per_frame_sum_stats_px": _sum_series(df["limbs_pix_disp_total"]) if "limbs_pix_disp_total" in df else {"mean": None, "min": None, "max": None},
-            "angle_stats_deg": {
-                "left_elbow": _sum_series(df["left_elbow_angle"]) if "left_elbow_angle" in df else {"mean": None, "min": None, "max": None},
-                "right_elbow": _sum_series(df["right_elbow_angle"]) if "right_elbow_angle" in df else {"mean": None, "min": None, "max": None},
-                "left_knee": _sum_series(df["left_knee_angle"]) if "left_knee_angle" in df else {"mean": None, "min": None, "max": None},
-                "right_knee": _sum_series(df["right_knee_angle"]) if "right_knee_angle" in df else {"mean": None, "min": None, "max": None},
-            }
+        "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},
         }
     }
 
-    # Save outputs
+    # ---- 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)
 
-    report_md = f"""# MediaPipe Tasks (GPU Delegate) 分析报告
+    # ---- Plot ----
+    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 Tasks (GPU delegate) 分析报告
 
 ## 视频信息
 - 分辨率: {width} x {height}
 - FPS: {fps:.2f}
 - 处理帧数: {len(df)}
 - 时长(秒): {summary["video"]["duration_s"]:.2f}
-
-## 运行设备
-- 请求 GPU delegate: {use_gpu_delegate}
-- Pose 实际设备: {pose_device}
-- Face 实际设备: {face_device}
-
-> 如果这里显示 CPU(Fallback)，说明 GPU delegate 初始化失败（例如环境没 GPU 或驱动/依赖不匹配）。
+- Delegate: {delegate_used}
+- Resize width: {resize_width}
 
 ## 眨眼分析（EAR）
 - 阈值: {ear_threshold}
@@ -551,23 +479,16 @@ def process_video(
 - 左眼 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^2）
-- 左眼面积变化: mean={summary["blink"]["left_eye_area_diff_stats_px2"]["mean"]}  min={summary["blink"]["left_eye_area_diff_stats_px2"]["min"]}  max={summary["blink"]["left_eye_area_diff_stats_px2"]["max"]}
-- 右眼面积变化: mean={summary["blink"]["right_eye_area_diff_stats_px2"]["mean"]} min={summary["blink"]["right_eye_area_diff_stats_px2"]["min"]} max={summary["blink"]["right_eye_area_diff_stats_px2"]["max"]}
-
-## 四肢运动像素位移（pixel）
-- 累计位移（像素）:
-  - 左手腕: {summary["limb_motion_pixel"]["total_disp_px"]["left_wrist"]:.2f}
-  - 右手腕: {summary["limb_motion_pixel"]["total_disp_px"]["right_wrist"]:.2f}
-  - 左脚踝: {summary["limb_motion_pixel"]["total_disp_px"]["left_ankle"]:.2f}
-  - 右脚踝: {summary["limb_motion_pixel"]["total_disp_px"]["right_ankle"]:.2f}
-  - 四肢合计: {summary["limb_motion_pixel"]["total_disp_px"]["sum_limbs"]:.2f}
+## Pixel Difference 指标（横轴时间）
+- 四肢运动 pixel displacement：对 左/右手腕 + 左/右脚踝 的逐帧像素位移求和（单位像素）
+- 眼睛面积 pixel diff：左右眼(6点多边形)面积的逐帧差值求和（单位像素^2）
+> 对应曲线图：motion_eye_timeseries.png
 
 ## 输出文件
-- annotated.mp4：叠加了 Pose + “浅色 FaceMesh”
-- per_frame_metrics.csv：逐帧指标（包含四肢像素位移、眼睛面积变化等）
+- annotated.mp4：叠加 Pose + 浅色 FaceMesh 的视频
+- per_frame_metrics.csv：逐帧指标（含 limbs pixel disp、eye area diff）
 - summary.json：汇总统计
-- motion_eye_timeseries.png：时间序列曲线图（横轴时间）
+- motion_eye_timeseries.png：时间序列曲线图
 """
     with open(out_report, "w", encoding="utf-8") as f:
         f.write(report_md)
@@ -588,7 +509,10 @@ def ui_process(
     min_face_det_conf,
     ear_threshold,
     blink_min_consec,
-    max_frames,
+    draw_face_mesh,
+    face_mesh_lightness,
+    resize_width,
+    max_frames
 ):
     if isinstance(video, dict) and "path" in video:
         video_path = video["path"]
@@ -600,11 +524,18 @@ def ui_process(
         pose_model_path=str(pose_model_path),
         face_model_path=str(face_model_path),
         use_gpu_delegate=bool(use_gpu_delegate),
+
         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),
     )
 
@@ -614,41 +545,41 @@ def ui_process(
     return out_video, out_csv, out_json, out_plot, report_text
 
 
-demo = gr.Blocks(title="Video Pose + FaceLandmarks + Blink/Limb Analytics (GPU Delegate)")
+demo = gr.Blocks(title="Video Pose + FaceLandmarker (GPU) + CSV + Plot")
 
 with demo:
-    gr.Markdown(
-        "## 上传视频 → MediaPipe Tasks (Pose+FaceLandmarker) → 四肢像素位移 & 眼睛面积变化（时间序列）\n\n"
-        "- 需要你把 `.task` 模型放到指定路径（默认：`models/pose_landmarker_lite.task`、`models/face_landmarker.task`）\n"
-        "- 勾选 GPU delegate 后，若环境不支持会自动 fallback 到 CPU，并在报告里显示。"
-    )
+    gr.Markdown("## 上传视频 → MediaPipe Tasks (PoseLandmarker + FaceLandmarker, GPU delegate) → CSV + 曲线图 + 标注视频")
 
     with gr.Row():
         video_in = gr.Video(label="上传视频", sources=["upload"])
 
-    with gr.Accordion("模型与参数", open=False):
+    with gr.Accordion("模型与性能参数", open=False):
         pose_model_path = gr.Textbox(value="models/pose_landmarker_lite.task", label="Pose .task 路径")
         face_model_path = gr.Textbox(value="models/face_landmarker.task", label="Face .task 路径")
-        use_gpu_delegate = gr.Checkbox(value=True, label="使用 GPU delegate（不支持会自动回退 CPU）")
+        use_gpu_delegate = gr.Checkbox(value=True, label="使用 GPU delegate（失败会自动 fallback CPU）")
+        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):
         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="眨眼最小连续帧数（抗抖动）")
 
-        max_frames = gr.Number(value=0, precision=0, label="最多处理帧数（0=全处理，调试可设 300）")
+    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 颜色浅度（越大越浅）")
 
     run_btn = gr.Button("开始分析")
 
     with gr.Row():
-        video_out = gr.Video(label="输出：叠加标注视频（浅色 FaceMesh）")
-    with gr.Row():
-        plot_out = gr.Image(label="输出：时间序列图（四肢像素位移 & 眼睛面积变化）")
+        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）")
+    with gr.Row():
+        plot_out = gr.Image(label="曲线图：四肢像素位移 & 眼睛面积变化", type="filepath")
     report_out = gr.Markdown()
 
     run_btn.click(
@@ -663,6 +594,9 @@ with demo:
             min_face_det_conf,
             ear_threshold,
             blink_min_consec,
+            draw_face_mesh,
+            face_mesh_lightness,
+            resize_width,
             max_frames,
         ],
         outputs=[video_out, csv_out, json_out, plot_out, report_out],