Upload 9 files

athletic_performance.py

@@ -182,52 +182,126 @@ def draw_pose_landmarks(frame, landmarks, knee_analysis=None):
     return frame
 
 
-def draw_jump_reference_lines(frame, references, current_jump_height, user_height_cm):
-    """Draw average and professional jump height reference lines."""
+def draw_jump_reference_arrows(frame, references, person_landmarks, is_jumping, user_height_cm):
+    """
+    Draw reference arrows for average and professional jump heights near the person.
+    Only shows when the person is actively jumping.
+    
+    Args:
+        frame: Video frame to draw on
+        references (dict): Jump height references {'average': float, 'professional': float}
+        person_landmarks: MediaPipe pose landmarks
+        is_jumping (bool): Whether the person is currently jumping
+        user_height_cm (float): User's height for scaling
+    
+    Returns:
+        frame: Frame with reference arrows drawn
+    """
+    if not is_jumping or not person_landmarks:
+        return frame
+    
     h, w, _ = frame.shape
     
-    # Calculate line positions (relative to frame height)
-    # Assume the person's height spans about 70% of frame height
-    person_height_pixels = int(h * 0.7)
-    pixels_per_cm = person_height_pixels / user_height_cm
-    
-    # Base line (ground level) - bottom 10% of frame
-    ground_y = int(h * 0.9)
-    
-    # Reference lines
-    avg_jump_pixels = int(references["average"] * pixels_per_cm)
-    pro_jump_pixels = int(references["professional"] * pixels_per_cm)
-    current_jump_pixels = int(current_jump_height * pixels_per_cm)
-    
-    avg_line_y = ground_y - avg_jump_pixels
-    pro_line_y = ground_y - pro_jump_pixels
-    current_line_y = ground_y - current_jump_pixels
-    
-    # Draw ground line
-    cv2.line(frame, (0, ground_y), (w, ground_y), (100, 100, 100), 2)
-    cv2.putText(frame, "Ground", (10, ground_y - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (100, 100, 100), 2)
-    
-    # Draw average line
-    if avg_line_y > 0:
-        cv2.line(frame, (0, avg_line_y), (w, avg_line_y), (255, 255, 0), 2)
-        cv2.putText(frame, f"Avg: {references['average']:.0f}cm", 
-                   (10, avg_line_y - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 0), 2)
-    
-    # Draw professional line
-    if pro_line_y > 0:
-        cv2.line(frame, (0, pro_line_y), (w, pro_line_y), (0, 255, 0), 2)
-        cv2.putText(frame, f"Pro: {references['professional']:.0f}cm", 
-                   (10, pro_line_y - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
-    
-    # Draw current jump line
-    if current_line_y > 0 and current_jump_height > 0:
-        cv2.line(frame, (0, current_line_y), (w, current_line_y), (0, 0, 255), 3)
-        cv2.putText(frame, f"Your Jump: {current_jump_height:.0f}cm", 
-                   (w - 200, current_line_y - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2)
+    # Get person's hip position (center point)
+    left_hip = person_landmarks.landmark[mp.solutions.pose.PoseLandmark.LEFT_HIP]
+    right_hip = person_landmarks.landmark[mp.solutions.pose.PoseLandmark.RIGHT_HIP]
+    
+    # Calculate person center
+    person_x = int((left_hip.x + right_hip.x) / 2 * w)
+    person_y = int((left_hip.y + right_hip.y) / 2 * h)
+    
+    # Calculate scaling factor (pixels per cm based on person height in frame)
+    head = person_landmarks.landmark[mp.solutions.pose.PoseLandmark.NOSE]
+    left_ankle = person_landmarks.landmark[mp.solutions.pose.PoseLandmark.LEFT_ANKLE]
+    right_ankle = person_landmarks.landmark[mp.solutions.pose.PoseLandmark.RIGHT_ANKLE]
+    
+    # Person height in frame (head to ankle)
+    ankle_y = (left_ankle.y + right_ankle.y) / 2
+    person_height_pixels = abs(ankle_y - head.y) * h
+    pixels_per_cm = person_height_pixels / user_height_cm if user_height_cm > 0 else 1
+    
+    # Ground reference (ankle level)
+    ground_y = int(ankle_y * h)
+    
+    # Calculate reference positions
+    avg_height = references.get('average', 0)
+    pro_height = references.get('professional', 0)
+    
+    # Position arrows to the right side of the person
+    arrow_x_start = person_x + 60
+    arrow_x_end = person_x + 120
+    
+    # Draw average performance arrow
+    if avg_height > 0:
+        avg_y = int(ground_y - (avg_height * pixels_per_cm))
+        if 20 < avg_y < h - 20:  # Only draw if within frame
+            # Draw arrow pointing to average height
+            cv2.arrowedLine(frame, (arrow_x_start, avg_y), (arrow_x_end, avg_y), 
+                           (255, 255, 0), 4, tipLength=0.3)  # Yellow arrow
+            cv2.putText(frame, f"Avg: {avg_height:.0f}cm", (arrow_x_end + 10, avg_y + 5), 
+                       cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 0), 2)
+    
+    # Draw professional performance arrow
+    if pro_height > 0:
+        pro_y = int(ground_y - (pro_height * pixels_per_cm))
+        if 20 < pro_y < h - 20:  # Only draw if within frame
+            # Draw arrow pointing to professional height
+            cv2.arrowedLine(frame, (arrow_x_start, pro_y), (arrow_x_end, pro_y), 
+                           (0, 255, 0), 4, tipLength=0.3)  # Green arrow
+            cv2.putText(frame, f"Pro: {pro_height:.0f}cm", (arrow_x_end + 10, pro_y + 5), 
+                       cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
     
     return frame
 
 
+def detect_jumping_phase(landmarks, frame_height):
+    """
+    Detect if the person is currently in a jumping phase based on pose.
+    
+    Args:
+        landmarks: MediaPipe pose landmarks
+        frame_height (int): Height of the video frame
+    
+    Returns:
+        bool: True if person appears to be jumping
+    """
+    if not landmarks:
+        return False
+    
+    try:
+        # Get key landmarks
+        left_ankle = landmarks.landmark[mp.solutions.pose.PoseLandmark.LEFT_ANKLE]
+        right_ankle = landmarks.landmark[mp.solutions.pose.PoseLandmark.RIGHT_ANKLE]
+        left_knee = landmarks.landmark[mp.solutions.pose.PoseLandmark.LEFT_KNEE]
+        right_knee = landmarks.landmark[mp.solutions.pose.PoseLandmark.RIGHT_KNEE]
+        left_hip = landmarks.landmark[mp.solutions.pose.PoseLandmark.LEFT_HIP]
+        right_hip = landmarks.landmark[mp.solutions.pose.PoseLandmark.RIGHT_HIP]
+        
+        # Calculate average positions
+        ankle_y = (left_ankle.y + right_ankle.y) / 2
+        knee_y = (left_knee.y + right_knee.y) / 2
+        hip_y = (left_hip.y + right_hip.y) / 2
+        
+        # Check if person is in jumping posture
+        # Jumping indicators:
+        # 1. Knees are significantly bent (knee-hip distance is small)
+        # 2. Person is in takeoff/landing phase (dynamic posture)
+        
+        knee_hip_distance = abs(knee_y - hip_y) * frame_height
+        ankle_knee_distance = abs(ankle_y - knee_y) * frame_height
+        
+        # If knees are bent (shorter distances) or in dynamic position, likely jumping
+        is_crouched = knee_hip_distance < 40 or ankle_knee_distance < 40
+        
+        # Additional check: if ankles are not at the bottom of frame, person might be airborne
+        is_airborne = ankle_y < 0.85  # If ankles are not in bottom 15% of frame
+        
+        return is_crouched or is_airborne
+        
+    except (AttributeError, IndexError):
+        return False
+
+
 def calculate_peak_power_output(jump_height_m, body_mass_kg, flight_time_s):
     """Calculate peak power output using biomechanical models."""
     if jump_height_m <= 0 or flight_time_s <= 0:
@@ -481,19 +555,18 @@ def generate_annotated_video(video_path, user_height_cm, user_weight_kg, gender,
         # Draw pose landmarks with strain indicators
         annotated_frame = draw_pose_landmarks(frame, results.pose_landmarks, knee_analysis)
 
-        # Draw jump reference lines
-        annotated_frame = draw_jump_reference_lines(
-            annotated_frame, jump_references, current_jump_height, user_height_cm
+        # Detect if person is currently jumping
+        is_jumping = detect_jumping_phase(results.pose_landmarks, h)
+
+        # Draw jump reference arrows (only when jumping)
+        annotated_frame = draw_jump_reference_arrows(
+            annotated_frame, jump_references, results.pose_landmarks, is_jumping, user_height_cm
         )
 
         # Add performance info overlay
         info_y = 30
         cv2.putText(annotated_frame, f"Frame: {frame_idx}/{total_frames}", 
                    (10, info_y), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
-        
-        if current_jump_height > 0:
-            cv2.putText(annotated_frame, f"Current Jump: {current_jump_height:.1f}cm", 
-                       (10, info_y + 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 255), 2)
 
         # Add knee strain warnings
         if knee_analysis["strain_detected"]: