Create app.py

app.py

@@ -0,0 +1,99 @@
+import gradio as gr
+import cv2
+import mediapipe as mp
+import numpy as np
+
+# Initialize MediaPipe once (better performance than creating per-frame)
+mp_hands = mp.solutions.hands
+mp_pose = mp.solutions.pose
+mp_drawing = mp.solutions.drawing_utils
+
+hands = mp_hands.Hands(
+    static_image_mode=False,
+    max_num_hands=2,
+    min_detection_confidence=0.5,
+    min_tracking_confidence=0.5
+)
+
+pose = mp_pose.Pose(
+    static_image_mode=False,
+    model_complexity=1,           # 0 for fastest, 1 is a good balance
+    enable_segmentation=False,
+    min_detection_confidence=0.5,
+    min_tracking_confidence=0.5
+)
+
+def process_frame(frame, target_width, return_original_size):
+    """
+    frame: BGR numpy array from webcam (gradio provides RGB -> but gr.Image returns RGB by default)
+    We'll handle color conversions explicitly.
+    """
+    if frame is None:
+        return None
+
+    # Gradio's Image provides RGB ndarray; convert to BGR for OpenCV ops if needed
+    rgb_in = frame  # already RGB
+    h0, w0 = rgb_in.shape[:2]
+
+    # Compute resize keeping aspect ratio
+    target_width = max(160, int(target_width))
+    scale = target_width / float(w0)
+    target_height = int(round(h0 * scale))
+
+    # Resize for processing
+    rgb_small = cv2.resize(rgb_in, (target_width, target_height), interpolation=cv2.INTER_AREA)
+
+    # Run MediaPipe on resized frame
+    # (MediaPipe expects RGB)
+    hand_results = hands.process(rgb_small)
+    pose_results = pose.process(rgb_small)
+
+    # Convert to BGR for drawing (MediaPipe drawing utils expect BGR or RGB? They draw on the array directly; we’ll use BGR for OpenCV compatibility)
+    bgr_draw = cv2.cvtColor(rgb_small, cv2.COLOR_RGB2BGR)
+
+    # Draw hands
+    if hand_results.multi_hand_landmarks:
+        for hand_landmarks in hand_results.multi_hand_landmarks:
+            mp_drawing.draw_landmarks(bgr_draw, hand_landmarks, mp_hands.HAND_CONNECTIONS)
+
+    # Draw pose
+    if pose_results.pose_landmarks:
+        mp_drawing.draw_landmarks(bgr_draw, pose_results.pose_landmarks, mp_pose.POSE_CONNECTIONS)
+
+    # Convert back to RGB for Gradio
+    rgb_out_small = cv2.cvtColor(bgr_draw, cv2.COLOR_BGR2RGB)
+
+    if return_original_size:
+        # Upscale back to original frame size
+        rgb_out = cv2.resize(rgb_out_small, (w0, h0), interpolation=cv2.INTER_LINEAR)
+        return rgb_out
+    else:
+        return rgb_out_small
+
+with gr.Blocks(title="Live Hand & Body Pose Detection") as demo:
+    gr.Markdown("# Live Hand & Body Pose Detection")
+    gr.Markdown("Upload from webcam; frames are resized before processing for better performance.")
+
+    with gr.Row():
+        cam = gr.Image(
+            source="webcam",
+            streaming=True,
+            label="Webcam",
+        )
+        out = gr.Image(label="Processed", streaming=True)
+
+    with gr.Row():
+        target_width = gr.Slider(
+            minimum=160, maximum=1280, value=640, step=20,
+            label="Processing width (px)"
+        )
+        return_original = gr.Checkbox(
+            value=False, label="Return at original webcam resolution"
+        )
+
+    # Live streaming
+    cam.stream(fn=process_frame, inputs=[cam, target_width, return_original], outputs=out)
+
+if __name__ == "__main__":
+    # queue for backpressure; single worker avoids MP thread issues
+    demo.queue(concurrency_count=1).launch()