Upload 9 files

athletic_performance.py

@@ -182,124 +182,42 @@ def draw_pose_landmarks(frame, landmarks, knee_analysis=None):
     return frame
 
 
-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.
+def draw_jump_reference_lines(frame, references, current_jump_height, user_height_cm):
+    """Draw average and professional jump height reference lines."""
+    h, w, _ = frame.shape
     
-    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
+    # 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
     
-    Returns:
-        frame: Frame with reference arrows drawn
-    """
-    if not is_jumping or not person_landmarks:
-        return frame
+    # Base line (ground level) - bottom 10% of frame
+    ground_y = int(h * 0.9)
     
-    h, w, _ = frame.shape
+    # Reference lines
+    avg_jump_pixels = int(references["average"] * pixels_per_cm)
+    pro_jump_pixels = int(references["professional"] * pixels_per_cm)
     
-    # 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)
+    avg_line_y = ground_y - avg_jump_pixels
+    pro_line_y = ground_y - pro_jump_pixels
     
-    return frame
-
-
-def detect_jumping_phase(landmarks, frame_height):
-    """
-    Detect if the person is currently in a jumping phase based on pose.
+    # 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)
     
-    Args:
-        landmarks: MediaPipe pose landmarks
-        frame_height (int): Height of the video frame
+    # 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)
     
-    Returns:
-        bool: True if person appears to be jumping
-    """
-    if not landmarks:
-        return False
+    # 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)
     
-    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
+    return frame
 
 
 def calculate_peak_power_output(jump_height_m, body_mass_kg, flight_time_s):
@@ -555,12 +473,9 @@ 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)
 
-        # 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
+        # Draw jump reference lines
+        annotated_frame = draw_jump_reference_lines(
+            annotated_frame, jump_references, current_jump_height, user_height_cm
         )
 
         # Add performance info overlay