Start

app.py

@@ -0,0 +1,120 @@
+import cv2
+import mediapipe as mp
+import numpy as np
+import gradio as gr
+
+# Initialize MediaPipe Pose.
+mp_pose = mp.solutions.pose
+pose = mp_pose.Pose(
+    static_image_mode=False,
+    model_complexity=1,
+    enable_segmentation=False,
+    min_detection_confidence=0.5,
+    min_tracking_confidence=0.5
+)
+
+# Initialize MediaPipe Face Mesh.
+mp_face_mesh = mp.solutions.face_mesh
+face_mesh = mp_face_mesh.FaceMesh(
+    static_image_mode=False,
+    max_num_faces=1,
+    refine_landmarks=True,
+    min_detection_confidence=0.5,
+    min_tracking_confidence=0.5
+)
+
+def process_frame(image):
+    """
+    Processes an input image (from the webcam) by:
+      1. Converting from RGB (Gradio default) to BGR for OpenCV.
+      2. Flipping the frame for a mirror view.
+      3. Creating a black background.
+      4. Using MediaPipe Pose to draw body landmarks (excluding facial parts) and compute the shoulder center.
+      5. Using MediaPipe Face Mesh to draw the full facial mesh and extract the chin point.
+      6. Drawing a neck line from the shoulder center to the chin.
+      7. Converting the result back to RGB for display.
+    """
+    # Convert the input image from RGB (Gradio default) to BGR.
+    frame = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+    
+    # Flip the frame horizontally for a mirror view.
+    frame = cv2.flip(frame, 1)
+    
+    # Create a black background image of the same size.
+    output = np.zeros_like(frame)
+    
+    # Convert frame to RGB for MediaPipe processing.
+    rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+    
+    # --- Body Posture Analysis using MediaPipe Pose ---
+    pose_results = pose.process(rgb_frame)
+    shoulder_center = None
+    if pose_results.pose_landmarks:
+        h, w, _ = frame.shape
+        landmarks = [(int(lm.x * w), int(lm.y * h)) for lm in pose_results.pose_landmarks.landmark]
+        
+        # Draw body skeleton (only drawing non-facial landmarks, i.e. indices 11 and above).
+        for connection in mp_pose.POSE_CONNECTIONS:
+            start_idx, end_idx = connection
+            if start_idx >= 11 and end_idx >= 11:
+                if start_idx < len(landmarks) and end_idx < len(landmarks):
+                    cv2.line(output, landmarks[start_idx], landmarks[end_idx], (255, 255, 0), 2)
+        
+        # Draw landmarks as yellow circles.
+        for i, pt in enumerate(landmarks):
+            if i >= 11:
+                cv2.circle(output, pt, 3, (255, 255, 0), -1)
+        
+        # Calculate shoulder center using landmarks 11 (left shoulder) and 12 (right shoulder).
+        if len(landmarks) > 12:
+            left_shoulder = landmarks[11]
+            right_shoulder = landmarks[12]
+            shoulder_center = ((left_shoulder[0] + right_shoulder[0]) // 2,
+                               (left_shoulder[1] + right_shoulder[1]) // 2)
+            cv2.circle(output, shoulder_center, 4, (0, 255, 255), -1)
+    
+    # --- Facemesh Analysis using MediaPipe Face Mesh ---
+    chin_point = None
+    fm_results = face_mesh.process(rgb_frame)
+    if fm_results.multi_face_landmarks:
+        for face_landmarks in fm_results.multi_face_landmarks:
+            h, w, _ = frame.shape
+            fm_points = [(int(lm.x * w), int(lm.y * h)) for lm in face_landmarks.landmark]
+            
+            # Draw red lines connecting facial landmarks.
+            for connection in mp_face_mesh.FACEMESH_TESSELATION:
+                start_idx, end_idx = connection
+                if start_idx < len(fm_points) and end_idx < len(fm_points):
+                    cv2.line(output, fm_points[start_idx], fm_points[end_idx], (0, 0, 255), 1)
+            
+            # Draw green dots for each facial landmark.
+            for pt in fm_points:
+                cv2.circle(output, pt, 2, (0, 255, 0), -1)
+            
+            # Extract the chin point (landmark 152 is generally at the bottom of the chin).
+            if len(face_landmarks.landmark) > 152:
+                lm = face_landmarks.landmark[152]
+                chin_point = (int(lm.x * w), int(lm.y * h))
+                cv2.circle(output, chin_point, 4, (0, 0, 255), -1)
+            break  # Process only the first detected face.
+    
+    # --- Draw the Neck Line ---
+    if shoulder_center and chin_point:
+        cv2.line(output, shoulder_center, chin_point, (0, 255, 255), 2)
+    
+    # Convert the processed image back to RGB for display.
+    output_rgb = cv2.cvtColor(output, cv2.COLOR_BGR2RGB)
+    return output_rgb
+
+# Create the Gradio interface.
+iface = gr.Interface(
+    fn=process_frame,
+    inputs=gr.Image(source="webcam", type="numpy", label="Webcam"),
+    outputs=gr.Image(type="numpy", label="Processed Output"),
+    live=True,
+    title="Body Posture & Neck Analysis (No Face Pose)",
+    description="Webcam-based analysis using MediaPipe Pose and Face Mesh."
+)
+
+# Launch the Gradio app.
+iface.launch()

requirements.txt

@@ -0,0 +1,6 @@
+opencv-python
+mediapipe
+numpy
+gradio
+pillow
+protobuf==3.20.*