refactor

CLAUDE.md

@@ -0,0 +1,100 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Development Commands
+
+### Running the Application
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Start the FastAPI server
+uvicorn app:app --host 0.0.0.0 --port 7860
+
+# Alternative development server with reload
+uvicorn app:app --reload
+```
+
+### Docker Deployment
+```bash
+# Build the Docker image
+docker build -t sportsai .
+
+# Run the container
+docker run -p 7860:7860 sportsai
+```
+
+### Environment Setup
+- Create `.env` file with required environment variables:
+  - `API_URL`: External API endpoint URL
+  - `API_KEY`: Authentication key for external API
+  - `AI_API_TOKEN`: Token for authenticating incoming requests
+
+## Architecture Overview
+
+### Core Components
+
+**FastAPI Application (`app.py`)**
+- Main web server with two primary endpoints:
+  - `/upload`: General video processing with pose estimation
+  - `/exercise/salto_alto`: Specialized high jump exercise analysis
+- Uses background tasks for asynchronous video processing
+- Handles file uploads and API authentication
+
+**Pose Estimation (`vitpose.py`)**
+- Wraps the `rt-pose` library with VitPose model
+- Provides pose estimation pipeline with CUDA/CPU support
+- Handles video-to-frames conversion and frame annotation
+- Automatically rotates landscape videos to portrait orientation
+
+**Video Analysis (`tasks.py`)**
+- Contains `process_salto_alto()` function for high jump analysis
+- Implements comprehensive jump metrics calculation:
+  - Jump height detection using pose keypoints
+  - Sayer power estimation
+  - Repetition counting
+  - Metrics visualization overlay
+- Sends results to external API endpoints via webhooks
+
+**Configuration (`config.py`)**
+- Manages environment variables and API credentials
+- Uses python-dotenv for environment file loading
+
+### Key Features
+
+**High Jump Analysis Pipeline:**
+1. Video upload and pose estimation using VitPose
+2. Calibration using person height in first frame
+3. Jump detection based on ankle movement thresholds
+4. Real-time metrics calculation and overlay visualization
+5. Results packaging and webhook delivery
+
+**Pose Estimation:**
+- Uses PekingU/rtdetr object detection + usyd-community/vitpose-plus-small
+- Supports both CUDA and CPU inference
+- Model compilation enabled for performance optimization
+
+**Video Processing:**
+- Automatic landscape-to-portrait rotation
+- Skeleton visualization with keypoint connections
+- Metrics overlay with rounded rectangles and real-time updates
+
+### Dependencies
+- **FastAPI**: Web framework for API endpoints
+- **rt-pose**: Pose estimation pipeline
+- **OpenCV**: Video processing and computer vision
+- **Supervision**: Keypoint visualization utilities
+- **PyTorch**: Deep learning framework for pose models
+
+### File Structure
+- `app.py`: Main FastAPI application
+- `vitpose.py`: VitPose wrapper class
+- `tasks.py`: Video processing and analysis functions
+- `config.py`: Environment configuration
+- `requirements.txt`: Python dependencies
+- `Dockerfile`: Container deployment configuration
+- `static/`: Directory for processed video outputs (git-ignored)
+
+### API Authentication
+All endpoints require token-based authentication via header or body parameters. Unauthorized requests return 401 status codes.

app.py

@@ -13,7 +13,7 @@ from tasks import process_video,process_salto_alto
 from fastapi.responses import JSONResponse
 from config import AI_API_TOKEN
 import logging
-
+import json
 
 
 logging.basicConfig(level=logging.INFO)
@@ -76,7 +76,7 @@ async def upload(background_tasks: BackgroundTasks,
                  exercise_id: str = Body(...)
                  ):
     
-    import json
+    
     player_data = json.loads(player_data)
 
     if token != AI_API_TOKEN:
@@ -105,3 +105,4 @@ async def upload(background_tasks: BackgroundTasks,
     print(f"returning response")
     return JSONResponse(content={"message": "Video uploaded successfully",
                                  "status": 200})
+

tasks.py

@@ -6,6 +6,8 @@ from fastapi import UploadFile
 import logging
 import cv2
 import numpy as np
+from dataclasses import dataclass
+from typing import Optional, Tuple, Dict, List
 
 import time
 import json
@@ -13,8 +15,108 @@ from fastapi.responses import JSONResponse
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
+
+# Jump Analysis Constants
+JUMP_THRESHOLD_PERCENT = 0.05
+SMOOTHING_WINDOW = 5
+HORIZONTAL_OFFSET_FACTOR = 0.75
+VELOCITY_WINDOW = 3
+METRICS_BELOW_FEET_OFFSET = 20
+
+# Color Constants
+BLUE = (255, 0, 0)
+GREEN = (0, 255, 0)
+YELLOW = (0, 255, 255)
+WHITE = (255, 255, 255)
+BLACK = (0, 0, 0)
+GRAY = (128, 128, 128)
+LIGHT_GRAY = (200, 200, 200)
+
+COLORS = {
+    "blue": BLUE,
+    "green": GREEN,
+    "yellow": YELLOW,
+    "white": WHITE,
+    "black": BLACK,
+    "gray": GRAY,
+    "light_gray": LIGHT_GRAY
+}
+
+# Keypoint indices
+KEYPOINT_INDICES = {
+    'L_Ankle': 15, 'L_Ear': 3, 'L_Elbow': 7, 'L_Eye': 1, 'L_Hip': 11, 
+    'L_Knee': 13, 'L_Shoulder': 5, 'L_Wrist': 9, 'Nose': 0, 'R_Ankle': 16, 
+    'R_Ear': 4, 'R_Elbow': 8, 'R_Eye': 2, 'R_Hip': 12, 'R_Knee': 14, 
+    'R_Shoulder': 6, 'R_Wrist': 10
+}
+
+# Skeleton connections
+SKELETON_CONNECTIONS = [
+    ("Nose", "L_Eye"), ("Nose", "R_Eye"), ("L_Eye", "L_Ear"), ("R_Eye", "R_Ear"),
+    ("Nose", "L_Shoulder"), ("Nose", "R_Shoulder"), ("L_Shoulder", "R_Shoulder"),
+    ("L_Shoulder", "L_Elbow"), ("R_Shoulder", "R_Elbow"), ("L_Elbow", "L_Wrist"), 
+    ("R_Elbow", "R_Wrist"), ("L_Shoulder", "L_Hip"), ("R_Shoulder", "R_Hip"),
+    ("L_Hip", "R_Hip"), ("L_Hip", "L_Knee"), ("R_Hip", "R_Knee"),
+    ("L_Knee", "L_Ankle"), ("R_Knee", "R_Ankle")
+]
+
+@dataclass
+class JumpMetrics:
+    max_jump_height: float = 0.0
+    velocity_vertical: float = 0.0
+    peak_power_sayer: float = 0.0
+    jump_peak_power: float = 0.0
+    repetition_count: int = 0
+    ground_level: Optional[float] = None
+    takeoff_head_y: Optional[float] = None
+    max_head_height_px: Optional[float] = None
+    jump_started: bool = False
+
+@dataclass
+class OverlayConfig:
+    alpha: float = 0.7
+    font: int = cv2.FONT_HERSHEY_SIMPLEX
+    font_scale_title_metric: float = 0.5
+    font_scale_value: float = 0.7
+    font_scale_title_main: float = 1.2
+    font_thickness_metric: int = 1
+    font_thickness_title_main: int = 1
+    line_height_title_metric: int = int(20 * 1.2)
+    line_height_value: int = int(25 * 1.2)
+    padding_vertical: int = int(15 * 1.2)
+    padding_horizontal: int = int(15 * 1.2)
+    border_thickness: int = 1
+    corner_radius: int = 10
+    spacing_horizontal: int = 30
+    title_y_offset: int = 50
+    metrics_y_offset_alto: int = 80
+
+@dataclass
+class FramePosition:
+    x: int
+    y: int
+    width: int
+    height: int
 def process_video(file_name: str,vitpose: VitPose,user_id: str,player_id: str):
+    """
+    Process a video file using VitPose for pose estimation and send results to webhook.
+    
+    This function processes a video file by applying pose estimation, saving the annotated
+    video to the static directory, and sending the processed video to a webhook endpoint.
     
+    Args:
+        file_name (str): Path to the input video file
+        vitpose (VitPose): VitPose instance for pose estimation
+        user_id (str): ID of the user uploading the video
+        player_id (str): ID of the player in the video
+        
+    Returns:
+        None
+        
+    Raises:
+        ValueError: If video file cannot be opened or processed
+        requests.RequestException: If webhook request fails
+    """
     video_path = file_name
 
     contents = open(video_path, "rb").read()
@@ -59,14 +161,27 @@ def process_salto_alto(file_name: str,
                        exercise_id: str,
                        repetitions) -> dict:
     """
-    Process a high jump exercise video using VitPose for pose estimation.
+    Process a high jump exercise video using VitPose for pose estimation and analyze jump metrics.
+    
+    This function processes a high jump video by analyzing pose keypoints to calculate
+    jump metrics including height, velocity, and power. Results are sent to an API endpoint.
     
     Args:
-        file_name: Path to the input video
-        vitpose: VitPose instance for pose estimation
-        player_data: Dictionary containing player information
-        repetitions: Expected number of repetitions
-        exercise_id: ID of the exercise
+        file_name (str): Path to the input video file
+        vitpose (VitPose): VitPose instance for pose estimation
+        player_data (dict): Dictionary containing player information including:
+            - height: Player height in cm
+            - weight: Player weight in kg
+            - id: Player identifier
+        exercise_id (str): Unique identifier for the exercise
+        repetitions (int): Expected number of jump repetitions in the video
+        
+    Returns:
+        dict: Dictionary containing analysis results and video information
+        
+    Raises:
+        ValueError: If video processing fails or player data is invalid
+        requests.RequestException: If API request fails
     """
     # Use the provided VitPose instance
     
@@ -109,7 +224,26 @@ def send_results_api(results_dict: dict,
                      exercise_id: str,
                      video_path: str) -> JSONResponse:
     """
-    Updated function to send results to the new webhook endpoint
+    Send video analysis results to the API webhook endpoint.
+    
+    This function uploads the analyzed video file along with the computed metrics
+    to the API's webhook endpoint for processing and storage.
+    
+    Args:
+        results_dict (dict): Dictionary containing analysis results including:
+            - video_analysis: Information about the processed video
+            - repetition_data: List of metrics for each jump repetition
+        player_id (str): Unique identifier for the player
+        exercise_id (str): Unique identifier for the exercise
+        video_path (str): Path to the video file to upload
+        
+    Returns:
+        JSONResponse: HTTP response from the API endpoint
+        
+    Raises:
+        FileNotFoundError: If the video file doesn't exist
+        requests.RequestException: If the API request fails
+        json.JSONEncodeError: If results_dict cannot be serialized to JSON
     """
     url = API_URL + "/excercises/webhooks/video-processed-results"
     logger.info(f"Sending video results to {url}")
@@ -142,73 +276,68 @@ def send_results_api(results_dict: dict,
     return response 
 
 
-
-
-
-
-def analyze_jump_video(model: VitPose,
-                       input_video: str,
-                       output_video: str,
-                       player_height: float,
-                       body_mass_kg: float,
-                       repetitions: int) -> dict | None:
+def setup_video_capture(input_video: str, output_video: str) -> Tuple[cv2.VideoCapture, cv2.VideoWriter, int, int]:
     """
-    Analyze a jump video to calculate various jump metrics.
+    Initialize video capture and writer objects for video processing.
+    
+    This function creates OpenCV VideoCapture and VideoWriter objects with matching
+    properties (frame rate, dimensions) for reading from input and writing to output.
     
     Args:
-        model: VitPose model instance
-        input_video: Path to input video
-        output_video: Path to output video
-        reference_height: Height of the person in meters
-        body_mass_kg: Weight of the person in kg
+        input_video (str): Path to the input video file
+        output_video (str): Path for the output video file
         
     Returns:
-        Dictionary containing jump metrics and video analysis data
+        Tuple[cv2.VideoCapture, cv2.VideoWriter, int, int]: A tuple containing:
+            - cap: VideoCapture object for reading input video
+            - out: VideoWriter object for writing output video
+            - width: Video frame width in pixels
+            - height: Video frame height in pixels
+            
+    Raises:
+        ValueError: If the input video cannot be opened or read
+        cv2.error: If video writer initialization fails
     """
+    cap = cv2.VideoCapture(input_video)
+    if not cap.isOpened():
+        raise ValueError("Error al abrir el video")
     
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    out = cv2.VideoWriter(output_video, cv2.VideoWriter_fourcc(*'mp4v'), fps, (width, height))
     
-    #TODO: REFACTOR THIS FUNCTION
-    
-    
-    
-    # Configuration parameters
-    JUMP_THRESHOLD_PERCENT = 0.05  # Porcentaje de cambio en la altura del tobillo para detectar el inicio del salto
-    SMOOTHING_WINDOW = 5  # Ventana para suavizar la altura de los tobillos
-    HORIZONTAL_OFFSET_FACTOR = 0.75  # Factor para ubicar el cuadro entre el hombro y el borde
-    VELOCITY_WINDOW = 3  # Número de frames para calcular la velocidad
-    METRICS_BELOW_FEET_OFFSET = 20  # Offset en píxeles para colocar los cuadros debajo de los pies
-    
-    # Color palette
-    BLUE = (255, 0, 0)
-    GREEN = (0, 255, 0)
-    YELLOW = (0, 255, 255)
-    WHITE = (255, 255, 255)
-    BLACK = (0, 0, 0)
-    GRAY = (128, 128, 128)
-    LIGHT_GRAY = (200, 200, 200)
-    
-    repetition_data = []
+    return cap, out, width, height
+
+
+def calibrate_pose_detection(model, cap, player_height: float) -> Tuple[float, int, int]:
+    """
+    Calibrate pose detection scale and reference points using the first video frame.
     
-    # Open the video
-    cap = cv2.VideoCapture(input_video)
-    if not cap.isOpened():
-        print("Error al abrir el video")
-        return {}
+    This function analyzes the first frame to establish the pixel-to-meter conversion
+    ratio based on the player's known height and detects initial shoulder positions
+    for reference during video processing.
     
-    # Get first frame to calibrate and get initial shoulder positions
+    Args:
+        model: VitPose model instance for pose estimation
+        cap: OpenCV VideoCapture object
+        player_height (float): Actual height of the player in meters
+        
+    Returns:
+        Tuple[float, int, int]: A tuple containing:
+            - PX_PER_METER: Conversion factor from pixels to meters
+            - initial_left_shoulder_x: X-coordinate of left shoulder in pixels
+            - initial_right_shoulder_x: X-coordinate of right shoulder in pixels
+            
+    Raises:
+        ValueError: If video cannot be read or pose detection fails on first frame
+        IndexError: If required keypoints are not detected in the first frame
+    """
     ret, frame = cap.read()
     if not ret:
-        print("Error al leer el video")
-        return {}
+        raise ValueError("Error al leer el video")
     
-    # Initialize calibration variables
-    PX_PER_METER = None
-    initial_person_height_px = None
-    initial_left_shoulder_x = None
-    initial_right_shoulder_x = None
-    
-    # Process first frame to calibrate
-    output = model(frame)  # Detect pose in first frame
+    output = model(frame)
     keypoints = output.keypoints_xy.float().cpu().numpy()
     labels = model.pose_estimator_config.label2id
 
@@ -218,276 +347,413 @@ def analyze_jump_video(model: VitPose,
     L_shoulder_keypoint = labels["L_Shoulder"]
     R_shoulder_keypoint = labels["R_Shoulder"]
 
-    if (
-        keypoints is not None
-        and len(keypoints) > 0
-        and len(keypoints[0]) > 0):
-        
+    PX_PER_METER = None
+    initial_left_shoulder_x = None
+    initial_right_shoulder_x = None
+
+    if (keypoints is not None and len(keypoints) > 0 and len(keypoints[0]) > 0):
         kpts_first = keypoints[0]
-        if len(kpts_first[nose_keypoint]) > 0 and len(kpts_first[L_ankle_keypoint]) > 0:  # Nose and ankles
+        if len(kpts_first[nose_keypoint]) > 0 and len(kpts_first[L_ankle_keypoint]) > 0:
             initial_person_height_px = min(kpts_first[L_ankle_keypoint][1], kpts_first[R_ankle_keypoint][1]) - kpts_first[nose_keypoint][1]
             PX_PER_METER = initial_person_height_px / player_height
-        if len(kpts_first[L_shoulder_keypoint]) > 0 and len(kpts_first[R_shoulder_keypoint]) > 0:  # Left (5) and right (6) shoulders
+        if len(kpts_first[L_shoulder_keypoint]) > 0 and len(kpts_first[R_shoulder_keypoint]) > 0:
             initial_left_shoulder_x = int(kpts_first[L_shoulder_keypoint][0])
             initial_right_shoulder_x = int(kpts_first[R_shoulder_keypoint][0])
-    
+
     if PX_PER_METER is None or initial_left_shoulder_x is None or initial_right_shoulder_x is None:
-        print("No se pudo calibrar la escala o detectar los hombros en el primer frame.")
-        cap.release()
-        return None
+        raise ValueError("No se pudo calibrar la escala o detectar los hombros en el primer frame.")
         
-    # Reset video for processing
-    cap.release()
-    cap = cv2.VideoCapture(input_video)
-    fps = cap.get(cv2.CAP_PROP_FPS)
-    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-    out = cv2.VideoWriter(output_video, cv2.VideoWriter_fourcc(*'mp4v'), fps, (width, height))
+    return PX_PER_METER, initial_left_shoulder_x, initial_right_shoulder_x
+
+
+def process_frame_keypoints(model, frame):
+    """
+    Process a video frame and extract human pose keypoints.
+    
+    This function applies the pose estimation model to a frame and validates
+    that all required keypoints (nose, ankles, shoulders) are detected and visible.
     
-    # Variables for metrics and visualization
-    ground_level = None
-    takeoff_head_y = None
-    max_jump_height = 0  # Maximum relative jump
-    max_head_height_px = None  # Maximum head height in pixels (lowest in y coordinates)
-    jump_started = False
-    head_y_history = []
-    ankle_y_history = []
-    last_detected_ankles_y = None
-    head_y_buffer = []
-    velocity_vertical = 0.0
-    peak_power_sayer = 0.0  # Initialize Sayer power
-    current_power = 0.0
-    repetition_count = 0
-    jump_peak_power = 0.0  # Peak power for current jump only
-    
-    # Process each frame
-    while cap.isOpened():
-        ret, frame = cap.read()
-        if not ret:
-            break
-        
-        annotated_frame = frame.copy()
-        if repetition_count == repetitions:
-            continue
-        
-        # Add try-except block around the model inference to catch any model errors
-        try:
-            output = model(annotated_frame)
-            keypoints = output.keypoints_xy.float().cpu().numpy()
+    Args:
+        model: VitPose model instance for pose estimation
+        frame: Input video frame as numpy array
+        
+    Returns:
+        Tuple containing:
+        - success (bool): True if all required keypoints were detected, False otherwise
+        - current_ankle_y (float or None): Y-coordinate of the highest ankle point if detected
+        - current_head_y (float or None): Y-coordinate of the nose point if detected
+        - keypoints (numpy.ndarray or None): Array of detected keypoints if successful
+    """
+    try:
+        output = model(frame)
+        keypoints = output.keypoints_xy.float().cpu().numpy()
+        labels = model.pose_estimator_config.label2id
+        
+        nose_keypoint = labels["Nose"]
+        L_ankle_keypoint = labels["L_Ankle"]
+        R_ankle_keypoint = labels["R_Ankle"]
+        L_shoulder_keypoint = labels["L_Shoulder"]
+        R_shoulder_keypoint = labels["R_Shoulder"]
+        
+        if (keypoints is not None and 
+            len(keypoints) > 0 and 
+            len(keypoints[0]) > 0 and
+            keypoints.size > 0):
             
-            # Verify that keypoints array has valid data before processing
-            if (keypoints is not None and 
-                len(keypoints) > 0 and 
-                len(keypoints[0]) > 0 and
-                keypoints.size > 0):  # Check if array is not empty
-                kpts = keypoints[0]
+            kpts = keypoints[0]
+            
+            if (nose_keypoint < len(kpts) and L_ankle_keypoint < len(kpts) and 
+                R_ankle_keypoint < len(kpts) and L_shoulder_keypoint < len(kpts) and 
+                R_shoulder_keypoint < len(kpts)):
+                
+                nose = kpts[nose_keypoint]
+                ankles = [kpts[L_ankle_keypoint], kpts[R_ankle_keypoint]]
+                left_shoulder = kpts[L_shoulder_keypoint]
+                right_shoulder = kpts[R_shoulder_keypoint]
                 
-                # Make sure all required keypoints are detected
-                if (nose_keypoint < len(kpts) and L_ankle_keypoint < len(kpts) and 
-                    R_ankle_keypoint < len(kpts) and L_shoulder_keypoint < len(kpts) and 
-                    R_shoulder_keypoint < len(kpts)):
+                if (nose[0] > 0 and nose[1] > 0 and 
+                    all(a[0] > 0 and a[1] > 0 for a in ankles) and 
+                    left_shoulder[0] > 0 and left_shoulder[1] > 0 and 
+                    right_shoulder[0] > 0 and right_shoulder[1] > 0):
                     
-                    nose = kpts[nose_keypoint]
-                    ankles = [kpts[L_ankle_keypoint], kpts[R_ankle_keypoint]]
-                    left_shoulder = kpts[L_shoulder_keypoint]
-                    right_shoulder = kpts[R_shoulder_keypoint]
+                    current_ankle_y = min(a[1] for a in ankles)
+                    current_head_y = nose[1]
                     
-                    # Check if keypoints have valid coordinates
-                    if (nose[0] > 0 and nose[1] > 0 and 
-                        all(a[0] > 0 and a[1] > 0 for a in ankles) and 
-                        left_shoulder[0] > 0 and left_shoulder[1] > 0 and 
-                        right_shoulder[0] > 0 and right_shoulder[1] > 0):
-                        
-                        # Continue with existing processing
-                        current_ankle_y = min(a[1] for a in ankles)
-                        last_detected_ankles_y = current_ankle_y
-                        current_head_y = nose[1]
-                        
-                        # Smooth ankle and head positions
-                        ankle_y_history.append(current_ankle_y)
-                        if len(ankle_y_history) > SMOOTHING_WINDOW:
-                            ankle_y_history.pop(0)
-                        smoothed_ankle_y = np.mean(ankle_y_history)
-                        
-                        head_y_history.append(current_head_y)
-                        if len(head_y_history) > SMOOTHING_WINDOW:
-                            head_y_history.pop(0)
-                        smoothed_head_y = np.mean(head_y_history)
-                        
-                        # Calculate vertical velocity (using head position)
-                        head_y_buffer.append(smoothed_head_y)
-                        if len(head_y_buffer) > VELOCITY_WINDOW:
-                            head_y_buffer.pop(0)
-                            if PX_PER_METER is not None and fps > 0:
-                                delta_y_pixels = head_y_buffer[0] - head_y_buffer[-1]
-                                delta_y_meters = delta_y_pixels / PX_PER_METER
-                                delta_t = VELOCITY_WINDOW / fps
-                                velocity_vertical = delta_y_meters / delta_t
-                        
-                        # Set ground level in first frame where ankles are detected
-                        if ground_level is None:
-                            ground_level = smoothed_ankle_y
-                            takeoff_head_y = smoothed_head_y
-                        
-                        relative_ankle_change = (ground_level - smoothed_ankle_y) / ground_level if ground_level > 0 else 0
-                        
-                        # Detect jump start
-                        if not jump_started and relative_ankle_change > JUMP_THRESHOLD_PERCENT:
-                            jump_started = True
-                            takeoff_head_y = smoothed_head_y
-                            max_jump_height = 0
-                            max_head_height_px = smoothed_head_y
-                            jump_peak_power = 0.0  # Reset for this jump
-                        
-                        # Detect jump end
-                        if jump_started and relative_ankle_change <= JUMP_THRESHOLD_PERCENT:
-                            # Add to repetition data
-                            high_jump = calculate_high_jump(player_height, max_jump_height)
-                            repetition_data.append({
-                                "repetition": repetition_count + 1,
-                                "distancia_elevada": round(max_jump_height, 2),
-                                "salto_alto": round(high_jump, 2),
-                                "potencia_sayer": round(jump_peak_power, 2)  # Use jump-specific peak
-                            })
-                            repetition_count += 1
-                            jump_started = False
-                        
-                        # Update jump metrics while in air
-                        if jump_started:
-                            relative_jump = (takeoff_head_y - smoothed_head_y) / PX_PER_METER
-                            if relative_jump > max_jump_height:
-                                max_jump_height = relative_jump
-                            if smoothed_head_y < max_head_height_px:
-                                max_head_height_px = smoothed_head_y
-                            if relative_jump:
-                                current_power = calculate_peak_power_sayer(relative_jump, body_mass_kg)
-                                if current_power > jump_peak_power:  # Track peak for THIS jump
-                                    jump_peak_power = current_power
-                                if current_power > peak_power_sayer:  # Keep global peak too
-                                    peak_power_sayer = current_power
-                    else:
-                        # Skip processing for this frame - invalid coordinates
-                        print("Skipping frame - invalid keypoint coordinates")
-                        print(f"keypoints {keypoints}")
-                else:
-                    # Skip processing for this frame - missing required keypoints
-                    print("Skipping frame - missing required keypoints")
-                    print(f"keypoints {keypoints}")
+                    return True, current_ankle_y, current_head_y, keypoints
+        
+        return False, None, None, None
+        
+    except Exception as e:
+        print(f"Error processing frame: {e}")
+        return False, None, None, None
+
+
+def detect_jump_events(metrics: JumpMetrics, smoothed_ankle_y: float, smoothed_head_y: float, 
+                      repetition_data: List[Dict], player_height: float, body_mass_kg: float, 
+                      repetitions: int) -> bool:
+    """
+    Detect jump start and end events based on ankle position changes.
+    
+    This function monitors ankle position relative to ground level to detect when
+    a jump begins and ends. It calculates jump metrics for completed jumps and
+    tracks repetition count.
+    
+    Args:
+        metrics (JumpMetrics): Object tracking current jump state and metrics
+        smoothed_ankle_y (float): Current smoothed ankle Y-coordinate
+        smoothed_head_y (float): Current smoothed head Y-coordinate
+        repetition_data (List[Dict]): List to store completed jump data
+        player_height (float): Player height in meters
+        body_mass_kg (float): Player body mass in kilograms
+        repetitions (int): Target number of repetitions to detect
+        
+    Returns:
+        bool: True if target number of repetitions has been reached, False otherwise
+        
+    Side Effects:
+        - Updates metrics object with jump state
+        - Appends completed jump data to repetition_data list
+        - Modifies metrics.ground_level, metrics.jump_started, metrics.repetition_count
+    """
+    if metrics.ground_level is None:
+        metrics.ground_level = smoothed_ankle_y
+        metrics.takeoff_head_y = smoothed_head_y
+        return False
+    
+    relative_ankle_change = (metrics.ground_level - smoothed_ankle_y) / metrics.ground_level if metrics.ground_level > 0 else 0
+    
+    # Detect jump start
+    if not metrics.jump_started and relative_ankle_change > JUMP_THRESHOLD_PERCENT:
+        metrics.jump_started = True
+        metrics.takeoff_head_y = smoothed_head_y
+        metrics.max_jump_height = 0
+        metrics.max_head_height_px = smoothed_head_y
+        metrics.jump_peak_power = 0.0
+        return False
+    
+    # Detect jump end
+    if metrics.jump_started and relative_ankle_change <= JUMP_THRESHOLD_PERCENT:
+        high_jump = calculate_high_jump(player_height, metrics.max_jump_height)
+        repetition_data.append({
+            "repetition": metrics.repetition_count + 1,
+            "distancia_elevada": round(metrics.max_jump_height, 2),
+            "salto_alto": round(high_jump, 2),
+            "potencia_sayer": round(metrics.jump_peak_power, 2)
+        })
+        metrics.repetition_count += 1
+        metrics.jump_started = False
+        
+        return metrics.repetition_count >= repetitions
+    
+    return False
+
+
+def calculate_jump_metrics(metrics: JumpMetrics, smoothed_head_y: float, PX_PER_METER: float, 
+                          body_mass_kg: float, head_y_buffer: List[float], fps: float):
+    """
+    Calculate jump metrics during an active jump phase.
+    
+    This function continuously updates jump metrics while a jump is in progress,
+    tracking maximum jump height, peak power, and other performance indicators.
+    
+    Args:
+        metrics (JumpMetrics): Object containing current jump state and metrics
+        smoothed_head_y (float): Current smoothed head Y-coordinate in pixels
+        PX_PER_METER (float): Conversion factor from pixels to meters
+        body_mass_kg (float): Player body mass in kilograms
+        head_y_buffer (List[float]): Buffer of recent head positions for velocity calculation
+        fps (float): Video frame rate in frames per second
+        
+    Returns:
+        None
+        
+    Side Effects:
+        - Updates metrics.max_jump_height if current jump exceeds previous maximum
+        - Updates metrics.max_head_height_px with lowest Y-coordinate (highest position)
+        - Updates metrics.jump_peak_power and metrics.peak_power_sayer with calculated power values
+    """
+    if not metrics.jump_started:
+        return
+    
+    relative_jump = (metrics.takeoff_head_y - smoothed_head_y) / PX_PER_METER
+    if relative_jump > metrics.max_jump_height:
+        metrics.max_jump_height = relative_jump
+    
+    if smoothed_head_y < metrics.max_head_height_px:
+        metrics.max_head_height_px = smoothed_head_y
+    
+    if relative_jump:
+        current_power = calculate_peak_power_sayer(relative_jump, body_mass_kg)
+        if current_power > metrics.jump_peak_power:
+            metrics.jump_peak_power = current_power
+        if current_power > metrics.peak_power_sayer:
+            metrics.peak_power_sayer = current_power
+
+
+def calculate_velocity(head_y_buffer: List[float], PX_PER_METER: float, fps: float) -> float:
+    """
+    Calculate vertical velocity based on head position changes over time.
+    
+    This function computes the vertical velocity by analyzing the change in head
+    position over a specified time window, converting from pixel coordinates to
+    real-world units.
+    
+    Args:
+        head_y_buffer (List[float]): Buffer containing recent head Y-coordinates in pixels
+        PX_PER_METER (float): Conversion factor from pixels to meters
+        fps (float): Video frame rate in frames per second
+        
+    Returns:
+        float: Vertical velocity in meters per second (positive = upward motion)
+               Returns 0.0 if calculation cannot be performed
+               
+    Note:
+        - Requires at least VELOCITY_WINDOW frames in the buffer
+        - Velocity is calculated as the change from oldest to newest position
+        - Y-coordinates decrease as objects move upward in image coordinates
+    """
+    if len(head_y_buffer) < VELOCITY_WINDOW or PX_PER_METER is None or fps <= 0:
+        return 0.0
+    
+    delta_y_pixels = head_y_buffer[0] - head_y_buffer[-1]
+    delta_y_meters = delta_y_pixels / PX_PER_METER
+    delta_t = VELOCITY_WINDOW / fps
+    return delta_y_meters / delta_t
+
+
+def draw_skeleton(frame, keypoints):
+    """
+    Draw human pose skeleton on a video frame.
+    
+    This function visualizes the detected pose by drawing keypoints as circles
+    and connecting them with lines according to the human body structure.
+    
+    Args:
+        frame (numpy.ndarray): Video frame to draw on (modified in-place)
+        keypoints (numpy.ndarray or None): Array of detected keypoints with shape (N, 17, 2)
+                                          where N is batch size, 17 is number of keypoints,
+                                          and 2 represents (x, y) coordinates
+        
+    Returns:
+        None
+        
+    Side Effects:
+        - Modifies the input frame by drawing circles for keypoints
+        - Draws lines connecting related body parts (skeleton connections)
+        - Uses GREEN color for keypoints and YELLOW for connections
+        
+    Note:
+        - Safely handles None or empty keypoints arrays
+        - Only draws keypoints and connections with positive coordinates
+        - Uses SKELETON_CONNECTIONS constant for body part relationships
+    """
+    if keypoints is None or len(keypoints) == 0 or len(keypoints[0]) == 0:
+        return
+    
+    try:
+        kpts = keypoints[0]
+        
+        # Draw points
+        for point in kpts:
+            if point[0] > 0 and point[1] > 0:
+                cv2.circle(frame, (int(point[0]), int(point[1])), 5, GREEN, -1)
+        
+        # Draw connections
+        for connection in SKELETON_CONNECTIONS:
+            start_name, end_name = connection
+            start_idx = KEYPOINT_INDICES[start_name]
+            end_idx = KEYPOINT_INDICES[end_name]
+            
+            if (start_idx < len(kpts) and end_idx < len(kpts) and 
+                kpts[start_idx][0] > 0 and kpts[start_idx][1] > 0 and 
+                kpts[end_idx][0] > 0 and kpts[end_idx][1] > 0):
+                
+                start_point = (int(kpts[start_idx][0]), int(kpts[start_idx][1]))
+                end_point = (int(kpts[end_idx][0]), int(kpts[end_idx][1]))
+                cv2.line(frame, start_point, end_point, YELLOW, 2)
+                
+    except Exception as e:
+        print(f"Error drawing skeleton: {e}")
+
+
+
+
+
+
+def analyze_jump_video(model: VitPose,
+                       input_video: str,
+                       output_video: str,
+                       player_height: float,
+                       body_mass_kg: float,
+                       repetitions: int) -> dict | None:
+    """
+    Analyze a jump video to calculate various jump metrics.
+    
+    Args:
+        model: VitPose model instance
+        input_video: Path to input video
+        output_video: Path to output video
+        player_height: Height of the person in meters
+        body_mass_kg: Weight of the person in kg
+        repetitions: Expected number of repetitions
+        
+    Returns:
+        Dictionary containing jump metrics and video analysis data
+    """
+    try:
+        # Setup video capture and writer
+        cap, out, width, height = setup_video_capture(input_video, output_video)
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        
+        # Calibrate pose detection
+        PX_PER_METER, initial_left_shoulder_x, initial_right_shoulder_x = calibrate_pose_detection(
+            model, cap, player_height)
+        
+        # Reset video for processing
+        cap.release()
+        cap = cv2.VideoCapture(input_video)
+        
+        # Initialize tracking variables
+        metrics = JumpMetrics()
+        repetition_data = []
+        head_y_history = []
+        ankle_y_history = []
+        head_y_buffer = []
+        last_detected_ankles_y = None
+        
+        # Process each frame
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret:
+                break
+            
+            annotated_frame = frame.copy()
+            if metrics.repetition_count >= repetitions:
+                out.write(annotated_frame)
+                continue
+            
+            # Process frame keypoints
+            keypoints_valid, current_ankle_y, current_head_y, keypoints = process_frame_keypoints(model, annotated_frame)
+            
+            if keypoints_valid:
+                last_detected_ankles_y = current_ankle_y
+                
+                # Smooth positions
+                ankle_y_history.append(current_ankle_y)
+                if len(ankle_y_history) > SMOOTHING_WINDOW:
+                    ankle_y_history.pop(0)
+                smoothed_ankle_y = np.mean(ankle_y_history)
+                
+                head_y_history.append(current_head_y)
+                if len(head_y_history) > SMOOTHING_WINDOW:
+                    head_y_history.pop(0)
+                smoothed_head_y = np.mean(head_y_history)
+                
+                # Calculate velocity
+                head_y_buffer.append(smoothed_head_y)
+                if len(head_y_buffer) > VELOCITY_WINDOW:
+                    head_y_buffer.pop(0)
+                    metrics.velocity_vertical = calculate_velocity(head_y_buffer, PX_PER_METER, fps)
+                
+                # Detect jump events
+                should_stop = detect_jump_events(metrics, smoothed_ankle_y, smoothed_head_y, 
+                                               repetition_data, player_height, body_mass_kg, repetitions)
+                if should_stop:
+                    break
+                
+                # Calculate jump metrics during jump
+                calculate_jump_metrics(metrics, smoothed_head_y, PX_PER_METER, body_mass_kg, head_y_buffer, fps)
             else:
-                # Skip processing for this frame - no valid keypoints detected
-                print("Skipping frame - no valid keypoints detected")
-                print(f"keypoints {keypoints}")
                 last_detected_ankles_y = None
-                velocity_vertical = 0.0
-        except Exception as e:
-            # Handle any other exceptions that might occur during model inference
-            print(f"Error processing frame: {e}")
-            print(f"keypoints {keypoints}")
-            last_detected_ankles_y = None
-            velocity_vertical = 0.0
-        
-        # Calculate metrics and draw overlay even if keypoints weren't detected
-        # This ensures video continues to show previous metrics
-        high_jump = calculate_high_jump(player_height, max_jump_height)
-        
-        # Draw floating metric boxes
-        annotated_frame = draw_metrics_overlay(
-            frame=annotated_frame,
-            max_jump_height=max_jump_height,
-            salto_alto=high_jump,
-            velocity_vertical=velocity_vertical,
-            peak_power_sayer=peak_power_sayer,
-            repetition_count=repetition_count,
-            last_detected_ankles_y=last_detected_ankles_y,
-            initial_left_shoulder_x=initial_left_shoulder_x,
-            initial_right_shoulder_x=initial_right_shoulder_x,
-            width=width,
-            height=height,
-            colors={
-                "blue": BLUE,
-                "green": GREEN,
-                "yellow": YELLOW,
-                "white": WHITE,
-                "black": BLACK,
-                "gray": GRAY,
-                "light_gray": LIGHT_GRAY
+                metrics.velocity_vertical = 0.0
+            
+            # Draw overlay and skeleton
+            high_jump = calculate_high_jump(player_height, metrics.max_jump_height)
+            annotated_frame = draw_metrics_overlay(
+                frame=annotated_frame,
+                max_jump_height=metrics.max_jump_height,
+                salto_alto=high_jump,
+                velocity_vertical=metrics.velocity_vertical,
+                peak_power_sayer=metrics.peak_power_sayer,
+                repetition_count=metrics.repetition_count,
+                last_detected_ankles_y=last_detected_ankles_y,
+                initial_left_shoulder_x=initial_left_shoulder_x,
+                initial_right_shoulder_x=initial_right_shoulder_x,
+                width=width,
+                height=height,
+                colors=COLORS,
+                metrics_below_feet_offset=METRICS_BELOW_FEET_OFFSET,
+                horizontal_offset_factor=HORIZONTAL_OFFSET_FACTOR
+            )
+            
+            if keypoints_valid and keypoints is not None:
+                draw_skeleton(annotated_frame, keypoints)
+            
+            out.write(annotated_frame)
+        
+        # Prepare results
+        results_dict = {
+            "video_analysis": {
+                "output_video": str(output_video),
             },
-            metrics_below_feet_offset=METRICS_BELOW_FEET_OFFSET,
-            horizontal_offset_factor=HORIZONTAL_OFFSET_FACTOR
-        )
+            "repetition_data": [
+                {
+                    "repetition": int(rep["repetition"]),
+                    "distancia_elevada": float(rep["distancia_elevada"]),
+                    "salto_alto": float(rep["salto_alto"]),
+                    "potencia_sayer": float(rep["potencia_sayer"])
+                } for rep in repetition_data
+            ]
+        }
         
-        # Draw person skeleton keypoints
-        try:
-            if keypoints is not None and len(keypoints) > 0 and len(keypoints[0]) > 0:
-                # Use the exact keypoint indices
-                keypoint_indices = {
-                    'L_Ankle': 15, 'L_Ear': 3, 'L_Elbow': 7, 'L_Eye': 1, 'L_Hip': 11, 
-                    'L_Knee': 13, 'L_Shoulder': 5, 'L_Wrist': 9, 'Nose': 0, 'R_Ankle': 16, 
-                    'R_Ear': 4, 'R_Elbow': 8, 'R_Eye': 2, 'R_Hip': 12, 'R_Knee': 14, 
-                    'R_Shoulder': 6, 'R_Wrist': 10
-                }
-                
-                # Define skeleton connections (pairs of keypoints that should be connected)
-                skeleton_connections = [
-                    (keypoint_indices["Nose"], keypoint_indices["L_Eye"]), 
-                    (keypoint_indices["Nose"], keypoint_indices["R_Eye"]),
-                    (keypoint_indices["L_Eye"], keypoint_indices["L_Ear"]), 
-                    (keypoint_indices["R_Eye"], keypoint_indices["R_Ear"]),
-                    (keypoint_indices["Nose"], keypoint_indices["L_Shoulder"]),
-                    (keypoint_indices["Nose"], keypoint_indices["R_Shoulder"]),
-                    (keypoint_indices["L_Shoulder"], keypoint_indices["R_Shoulder"]),
-                    (keypoint_indices["L_Shoulder"], keypoint_indices["L_Elbow"]), 
-                    (keypoint_indices["R_Shoulder"], keypoint_indices["R_Elbow"]),
-                    (keypoint_indices["L_Elbow"], keypoint_indices["L_Wrist"]), 
-                    (keypoint_indices["R_Elbow"], keypoint_indices["R_Wrist"]),
-                    (keypoint_indices["L_Shoulder"], keypoint_indices["L_Hip"]), 
-                    (keypoint_indices["R_Shoulder"], keypoint_indices["R_Hip"]),
-                    (keypoint_indices["L_Hip"], keypoint_indices["R_Hip"]),
-                    (keypoint_indices["L_Hip"], keypoint_indices["L_Knee"]), 
-                    (keypoint_indices["R_Hip"], keypoint_indices["R_Knee"]),
-                    (keypoint_indices["L_Knee"], keypoint_indices["L_Ankle"]), 
-                    (keypoint_indices["R_Knee"], keypoint_indices["R_Ankle"])
-                ]
-                
-                kpts = keypoints[0]
-                # Draw points
-                for i, point in enumerate(kpts):
-                    if point[0] > 0 and point[1] > 0:  # Only draw if keypoint is valid
-                        cv2.circle(annotated_frame, (int(point[0]), int(point[1])), 5, GREEN, -1)
-                        
-                # Draw connections
-                for connection in skeleton_connections:
-                    start_idx, end_idx = connection
-                    if (start_idx < len(kpts) and end_idx < len(kpts) and 
-                        kpts[start_idx][0] > 0 and kpts[start_idx][1] > 0 and 
-                        kpts[end_idx][0] > 0 and kpts[end_idx][1] > 0):
-                        start_point = (int(kpts[start_idx][0]), int(kpts[start_idx][1]))
-                        end_point = (int(kpts[end_idx][0]), int(kpts[end_idx][1]))
-                        cv2.line(annotated_frame, start_point, end_point, YELLOW, 2)
-        except Exception as e:
-            print(f"Error drawing skeleton: {e}")
-        
-        out.write(annotated_frame)
-    
-    # Prepare results dictionary
-    results_dict = {
-        "video_analysis": {
-            "output_video": str(output_video),
-        },
-        "repetition_data": [
-            {
-                "repetition": int(rep["repetition"]),
-                "distancia_elevada": float(rep["distancia_elevada"]),
-                "salto_alto": float(rep["salto_alto"]),
-                "potencia_sayer": float(rep["potencia_sayer"])
-            } for rep in repetition_data
-        ]
-    }
-    
-    cap.release()
-    out.release()
-    
-    return results_dict
+        cap.release()
+        out.release()
+        
+        return results_dict
+        
+    except Exception as e:
+        print(f"Error in analyze_jump_video: {e}")
+        return None
 
 
 def calculate_peak_power_sayer(jump_height_m, body_mass_kg):
@@ -520,6 +786,234 @@ def calculate_high_jump(player_height:float, max_jump_height:float) -> float:
     return player_height + max_jump_height
 
 
+def draw_rounded_rect(img, pt1, pt2, color, thickness=-1, lineType=cv2.LINE_AA, radius=10):
+    """
+    Draw a rectangle with rounded corners on an image.
+    
+    This function creates a rounded rectangle by drawing four corner ellipses
+    and connecting them with straight rectangular sections.
+    
+    Args:
+        img (numpy.ndarray): Image to draw on (modified in-place)
+        pt1 (tuple): Top-left corner coordinates (x, y)
+        pt2 (tuple): Bottom-right corner coordinates (x, y)
+        color (tuple): BGR color tuple (B, G, R)
+        thickness (int, optional): Line thickness. -1 for filled rectangle. Defaults to -1.
+        lineType (int, optional): Type of line drawing. Defaults to cv2.LINE_AA.
+        radius (int, optional): Corner radius in pixels. Defaults to 10.
+        
+    Returns:
+        numpy.ndarray: The modified image with rounded rectangle drawn
+        
+    Note:
+        - If radius is 0, draws a regular rectangle
+        - For filled rectangles, use thickness=-1
+        - Corner ellipses are drawn at each corner with specified radius
+        - Rectangle sections fill the gaps between ellipses
+    """
+    x1, y1 = pt1
+    x2, y2 = pt2
+    if radius > 0:
+        img = cv2.ellipse(img, (x1 + radius, y1 + radius), (radius, radius), 0, 0, 90, color, thickness, lineType)
+        img = cv2.ellipse(img, (x2 - radius, y1 + radius), (radius, radius), 0, 90, 180, color, thickness, lineType)
+        img = cv2.ellipse(img, (x2 - radius, y2 - radius), (radius, radius), 0, 180, 270, color, thickness, lineType)
+        img = cv2.ellipse(img, (x1 + radius, y2 - radius), (radius, radius), 0, 270, 360, color, thickness, lineType)
+        
+        img = cv2.rectangle(img, (x1, y1 + radius), (x2, y2 - radius), color, thickness, lineType)
+        img = cv2.rectangle(img, (x1 + radius, y1), (x2 - radius, y2), color, thickness, lineType)
+    else:
+        img = cv2.rectangle(img, pt1, pt2, color, thickness, lineType)
+    return img
+
+
+def draw_main_title(overlay, config: OverlayConfig, width: int, colors: Dict):
+    """
+    Draw the main title text centered at the top of the video frame.
+    
+    This function renders "Ejercicio de Salto" (Jump Exercise) as the main title
+    using specified font configuration and centers it horizontally.
+    
+    Args:
+        overlay (numpy.ndarray): Image overlay to draw on (modified in-place)
+        config (OverlayConfig): Configuration object containing font settings
+        width (int): Width of the video frame in pixels
+        colors (Dict): Dictionary containing color definitions
+        
+    Returns:
+        None
+        
+    Side Effects:
+        - Draws text on the overlay image using white color
+        - Text is positioned at the top center of the frame
+        - Uses config.font_scale_title_main and config.font_thickness_title_main
+    """
+    title_text = "Ejercicio de Salto"
+    title_text_size = cv2.getTextSize(title_text, config.font, config.font_scale_title_main, config.font_thickness_title_main)[0]
+    title_x = (width - title_text_size[0]) // 2
+    title_y = config.title_y_offset
+    cv2.putText(overlay, title_text, (title_x, title_y), config.font, config.font_scale_title_main, 
+                colors["white"], config.font_thickness_title_main, cv2.LINE_AA)
+
+
+def calculate_metric_box_size(title: str, value: str, config: OverlayConfig) -> Tuple[int, int]:
+    """
+    Calculate the required dimensions for a metric display box.
+    
+    This function determines the width and height needed to display a metric
+    with its title and value, including padding and spacing requirements.
+    
+    Args:
+        title (str): The metric title text (e.g., "SALTO ALTO")
+        value (str): The metric value text (e.g., "2.15 m")
+        config (OverlayConfig): Configuration object with font and spacing settings
+        
+    Returns:
+        Tuple[int, int]: A tuple containing:
+            - bg_width: Required width in pixels for the metric box
+            - bg_height: Required height in pixels for the metric box
+            
+    Note:
+        - Width is based on the maximum of title and value text widths
+        - Height accounts for both text lines plus vertical padding
+        - Includes horizontal padding on both sides
+    """
+    title_size = cv2.getTextSize(title, config.font, config.font_scale_title_metric, config.font_thickness_metric)[0]
+    value_size = cv2.getTextSize(value, config.font, config.font_scale_value, config.font_thickness_metric)[0]
+    
+    bg_width = max(title_size[0], value_size[0]) + 2 * config.padding_horizontal
+    bg_height = config.line_height_title_metric + config.line_height_value + 2 * config.padding_vertical
+    
+    return bg_width, bg_height
+
+
+def draw_metric_box(overlay, title: str, value: str, x: int, y: int, bg_width: int, bg_height: int, 
+                   config: OverlayConfig, colors: Dict):
+    """
+    Draw a styled metric box with title and value text.
+    
+    This function creates a rounded rectangle background and draws metric information
+    with proper text alignment and styling for video overlay display.
+    
+    Args:
+        overlay (numpy.ndarray): Image overlay to draw on (modified in-place)
+        title (str): Metric title text (displayed in smaller font)
+        value (str): Metric value text (displayed in larger font)
+        x (int): X-coordinate of box top-left corner
+        y (int): Y-coordinate of box top-left corner
+        bg_width (int): Width of the background box in pixels
+        bg_height (int): Height of the background box in pixels
+        config (OverlayConfig): Configuration object with styling settings
+        colors (Dict): Dictionary containing color definitions
+        
+    Returns:
+        numpy.ndarray: The modified overlay with the metric box drawn
+        
+    Side Effects:
+        - Draws a rounded rectangle background with gray fill and white border
+        - Centers title text in light gray color
+        - Centers value text in white color below the title
+        - Uses different font scales for title and value
+    """
+    pt1 = (x, y)
+    pt2 = (x + bg_width, y + bg_height)
+    
+    # Draw background
+    overlay = draw_rounded_rect(overlay, pt1, pt2, colors["gray"], cv2.FILLED, cv2.LINE_AA, config.corner_radius)
+    cv2.rectangle(overlay, pt1, pt2, colors["white"], config.border_thickness, cv2.LINE_AA)
+    
+    # Draw title
+    title_size = cv2.getTextSize(title, config.font, config.font_scale_title_metric, config.font_thickness_metric)[0]
+    title_x = x + (bg_width - title_size[0]) // 2
+    title_y = y + config.padding_vertical + config.line_height_title_metric // 2 + 2
+    cv2.putText(overlay, title, (title_x, title_y), config.font, config.font_scale_title_metric, 
+                colors["light_gray"], config.font_thickness_metric, cv2.LINE_AA)
+    
+    # Draw value
+    value_size = cv2.getTextSize(value, config.font, config.font_scale_value, config.font_thickness_metric)[0]
+    value_x = x + (bg_width - value_size[0]) // 2
+    value_y = y + config.padding_vertical + config.line_height_title_metric + config.line_height_value // 2 + 5
+    cv2.putText(overlay, value, (value_x, value_y), config.font, config.font_scale_value, 
+                colors["white"], config.font_thickness_metric, cv2.LINE_AA)
+    
+    return overlay
+
+
+def calculate_positions(width: int, height: int, last_detected_ankles_y: Optional[float], 
+                       initial_left_shoulder_x: Optional[int], initial_right_shoulder_x: Optional[int],
+                       config: OverlayConfig, horizontal_offset_factor: float, 
+                       metrics_below_feet_offset: int) -> Dict[str, Tuple[int, int]]:
+    """
+    Calculate optimal positions for all metric display boxes on the video frame.
+    
+    This function determines where to place metric boxes based on detected body positions
+    to avoid overlapping with the person while maintaining good visibility.
+    
+    Args:
+        width (int): Video frame width in pixels
+        height (int): Video frame height in pixels
+        last_detected_ankles_y (Optional[float]): Y-coordinate of last detected ankles
+        initial_left_shoulder_x (Optional[int]): X-coordinate of left shoulder reference
+        initial_right_shoulder_x (Optional[int]): X-coordinate of right shoulder reference
+        config (OverlayConfig): Configuration object with layout settings
+        horizontal_offset_factor (float): Factor for horizontal positioning relative to shoulders
+        metrics_below_feet_offset (int): Vertical offset below feet for metric placement
+        
+    Returns:
+        Dict[str, Tuple[int, int]]: Dictionary mapping metric names to (x, y) positions:
+            - "relativo": Position for relative jump metric
+            - "alto": Position for high jump metric
+            - "reps": Position for repetitions counter
+            - "velocidad": Position for velocity metric (if ankles detected)
+            - "potencia": Position for power metric (if ankles detected)
+            
+    Note:
+        - Positions are calculated to avoid overlapping with the detected person
+        - Some metrics are positioned relative to body parts when available
+        - Falls back to default positions when body parts are not detected
+    """
+    positions = {}
+    
+    # Relative jump box (left side, dynamically positioned)
+    relativo_bg_width, relativo_bg_height = calculate_metric_box_size("SALTO RELATIVO", "0.00 m", config)
+    x_relativo = 20
+    
+    if last_detected_ankles_y is not None:
+        y_relativo = int(last_detected_ankles_y - relativo_bg_height - 10)
+        if y_relativo < config.title_y_offset + 50:
+            y_relativo = int(last_detected_ankles_y + metrics_below_feet_offset)
+    else:
+        y_relativo = height - 150
+    
+    positions["relativo"] = (x_relativo, y_relativo)
+    
+    # High jump box (top right)
+    alto_bg_width, alto_bg_height = calculate_metric_box_size("SALTO ALTO", "0.00 m", config)
+    x_alto = width - alto_bg_width - 20
+    
+    if initial_right_shoulder_x is not None:
+        available_space = width - initial_right_shoulder_x
+        x_alto_calculated = initial_right_shoulder_x + int(available_space * (1 - horizontal_offset_factor)) - alto_bg_width
+        if (x_alto_calculated > x_relativo + relativo_bg_width + config.spacing_horizontal + 10 and 
+            x_alto_calculated + alto_bg_width < width - 10):
+            x_alto = x_alto_calculated
+    
+    positions["alto"] = (x_alto, config.metrics_y_offset_alto)
+    
+    # Repetitions box (below relative jump)
+    positions["reps"] = (x_relativo, y_relativo + relativo_bg_height + 10)
+    
+    # Velocity and power boxes (centered below feet)
+    if last_detected_ankles_y is not None:
+        velocidad_bg_width, velocidad_bg_height = calculate_metric_box_size("VELOCIDAD VERTICAL", "0.00 m/s", config)
+        x_velocidad = int(width / 2 - velocidad_bg_width / 2)
+        y_velocidad = int(last_detected_ankles_y + metrics_below_feet_offset + velocidad_bg_height)
+        
+        positions["velocidad"] = (x_velocidad, y_velocidad - velocidad_bg_height)
+        positions["potencia"] = (x_velocidad, y_velocidad + 5)
+    
+    return positions
+
+
 def draw_metrics_overlay(frame, max_jump_height, salto_alto, velocity_vertical, peak_power_sayer, 
                         repetition_count, last_detected_ankles_y, initial_left_shoulder_x, 
                         initial_right_shoulder_x, width, height, colors, metrics_below_feet_offset=20,
@@ -546,165 +1040,52 @@ def draw_metrics_overlay(frame, max_jump_height, salto_alto, velocity_vertical,
     Returns:
         Frame with metrics overlay
     """
+    overlay = frame.copy()
+    config = OverlayConfig()
     
-     
-    #TODO: REFACTOR THIS FUNCTION
+    # Draw main title
+    draw_main_title(overlay, config, width, colors)
     
+    # Calculate positions for all metric boxes
+    positions = calculate_positions(width, height, last_detected_ankles_y, 
+                                  initial_left_shoulder_x, initial_right_shoulder_x,
+                                  config, horizontal_offset_factor, metrics_below_feet_offset)
     
-    overlay = frame.copy()
-    alpha = 0.7
-    font = cv2.FONT_HERSHEY_SIMPLEX
-    font_scale_title_metric = 0.5
-    font_scale_value = 0.7
-    font_scale_title_main = 1.2  # Scale for main title (larger)
-    font_thickness_metric = 1
-    font_thickness_title_main = 1  # Thickness for main title
-    line_height_title_metric = int(20 * 1.2)
-    line_height_value = int(25 * 1.2)
-    padding_vertical = int(15 * 1.2)
-    padding_horizontal = int(15 * 1.2)
-    text_color_title = colors["light_gray"]
-    text_color_value = colors["white"]
-    text_color_title_main = colors["white"]
-    bg_color = colors["gray"]
-    border_color = colors["white"]
-    border_thickness = 1
-    corner_radius = 10
-    spacing_horizontal = 30
-    title_y_offset = 50  # Lower vertical position of title
-    metrics_y_offset_alto = 80  # Adjust Salto Alto position to leave space below
-    metrics_y_offset_relativo = None  # Will be calculated dynamically
-    metrics_y_offset_velocidad = None  # Will be calculated dynamically
-    metrics_y_offset_potencia = None  # Will be calculated dynamically
-    
-    # Helper function to draw rounded rectangles
-    def draw_rounded_rect(img, pt1, pt2, color, thickness=-1, lineType=cv2.LINE_AA, radius=10):
-        x1, y1 = pt1
-        x2, y2 = pt2
-        w = x2 - x1
-        h = y2 - y1
-        if radius > 0:
-            img = cv2.ellipse(img, (x1 + radius, y1 + radius), (radius, radius), 0, 0, 90, color, thickness, lineType)
-            img = cv2.ellipse(img, (x2 - radius, y1 + radius), (radius, radius), 0, 90, 180, color, thickness, lineType)
-            img = cv2.ellipse(img, (x2 - radius, y2 - radius), (radius, radius), 0, 180, 270, color, thickness, lineType)
-            img = cv2.ellipse(img, (x1 + radius, y2 - radius), (radius, radius), 0, 270, 360, color, thickness, lineType)
-            
-            img = cv2.rectangle(img, (x1, y1 + radius), (x2, y2 - radius), color, thickness, lineType)
-            img = cv2.rectangle(img, (x1 + radius, y1), (x2 - radius, y2), color, thickness, lineType)
-        else:
-            img = cv2.rectangle(img, pt1, pt2, color, thickness, lineType)
-        return img
+    # Draw relative jump box
+    if "relativo" in positions:
+        relativo_value = f"{max(0, max_jump_height):.2f} m"
+        bg_width, bg_height = calculate_metric_box_size("SALTO RELATIVO", relativo_value, config)
+        x, y = positions["relativo"]
+        overlay = draw_metric_box(overlay, "SALTO RELATIVO", relativo_value, x, y, bg_width, bg_height, config, colors)
     
-    # --- Main Title ---
-    title_text = "Ejercicio de Salto"
-    title_text_size = cv2.getTextSize(title_text, font, font_scale_title_main, font_thickness_title_main)[0]
-    title_x = (width - title_text_size[0]) // 2
-    title_y = title_y_offset
-    cv2.putText(overlay, title_text, (title_x, title_y), font, font_scale_title_main, text_color_title_main, font_thickness_title_main, cv2.LINE_AA)
-    
-    # --- Relative Jump Box (dynamically positioned) ---
-    relativo_text = "SALTO RELATIVO"
-    relativo_value = f"{max(0, max_jump_height):.2f} m"
-    relativo_text_size = cv2.getTextSize(relativo_text, font, font_scale_title_metric, font_thickness_metric)[0]
-    relativo_value_size = cv2.getTextSize(relativo_value, font, font_scale_value, font_thickness_metric)[0]
-    bg_width_relativo = max(relativo_text_size[0], relativo_value_size[0]) + 2 * padding_horizontal
-    bg_height_relativo = line_height_title_metric + line_height_value + 2 * padding_vertical
-    x_relativo = 20
+    # Draw high jump box
+    if "alto" in positions:
+        alto_value = f"{max(0, salto_alto):.2f} m"
+        bg_width, bg_height = calculate_metric_box_size("SALTO ALTO", alto_value, config)
+        x, y = positions["alto"]
+        overlay = draw_metric_box(overlay, "SALTO ALTO", alto_value, x, y, bg_width, bg_height, config, colors)
     
-    if last_detected_ankles_y is not None and bg_height_relativo is not None:
-        metrics_y_offset_relativo = int(last_detected_ankles_y - bg_height_relativo - 10)  # 10 pixels above ankle
-        # Make sure box doesn't go off top
-        if metrics_y_offset_relativo < title_y_offset + 50:
-            metrics_y_offset_relativo = int(last_detected_ankles_y + metrics_below_feet_offset)  # Show below
-    else:
-        metrics_y_offset_relativo = height - 150  # Default position if ankles not detected
-    
-    if metrics_y_offset_relativo is not None:
-        y_relativo = metrics_y_offset_relativo
-        pt1_relativo = (x_relativo, y_relativo)
-        pt2_relativo = (x_relativo + bg_width_relativo, y_relativo + bg_height_relativo)
-        overlay = draw_rounded_rect(overlay, pt1_relativo, pt2_relativo, bg_color, cv2.FILLED, cv2.LINE_AA, corner_radius)
-        cv2.rectangle(overlay, pt1_relativo, pt2_relativo, border_color, border_thickness, cv2.LINE_AA)
-        cv2.putText(overlay, relativo_text, (x_relativo + (bg_width_relativo - relativo_text_size[0]) // 2, y_relativo + padding_vertical + line_height_title_metric // 2 + 2), font, font_scale_title_metric, text_color_title, font_thickness_metric, cv2.LINE_AA)
-        cv2.putText(overlay, relativo_value, (x_relativo + (bg_width_relativo - relativo_value_size[0]) // 2, y_relativo + padding_vertical + line_height_title_metric + line_height_value // 2 + 5), font, font_scale_value, text_color_value, font_thickness_metric, cv2.LINE_AA)
-    
-    # --- High Jump Box (stays in top right) ---
-    alto_text = "SALTO ALTO"
-    alto_value = f"{max(0, salto_alto):.2f} m"
-    alto_text_size = cv2.getTextSize(alto_text, font, font_scale_title_metric, font_thickness_metric)[0]
-    alto_value_size = cv2.getTextSize(alto_value, font, font_scale_value, font_thickness_metric)[0]
-    bg_width_alto = max(alto_text_size[0], alto_value_size[0]) + 2 * padding_horizontal
-    bg_height_alto = line_height_title_metric + line_height_value + 2 * padding_vertical
-    x_alto = width - bg_width_alto - 20  # Default position near right edge
+    # Draw repetitions box
+    if "reps" in positions:
+        reps_value = f"{repetition_count}"
+        bg_width, bg_height = calculate_metric_box_size("REPETICIONES", reps_value, config)
+        x, y = positions["reps"]
+        overlay = draw_metric_box(overlay, "REPETICIONES", reps_value, x, y, bg_width, bg_height, config, colors)
     
-    if initial_right_shoulder_x is not None:
-        available_space = width - initial_right_shoulder_x
-        x_alto_calculated = initial_right_shoulder_x + int(available_space * (1 - horizontal_offset_factor)) - bg_width_alto
-        # Make sure doesn't go off left edge and there's space from first box
-        if x_alto_calculated > x_relativo + bg_width_relativo + spacing_horizontal + 10 and x_alto_calculated + bg_width_alto < width - 10:
-            x_alto = x_alto_calculated
-    y_alto = metrics_y_offset_alto
-    pt1_alto = (x_alto, y_alto)
-    pt2_alto = (x_alto + bg_width_alto, y_alto + bg_height_alto)
-    overlay = draw_rounded_rect(overlay, pt1_alto, pt2_alto, bg_color, cv2.FILLED, cv2.LINE_AA, corner_radius)
-    cv2.rectangle(overlay, pt1_alto, pt2_alto, border_color, border_thickness, cv2.LINE_AA)
-    cv2.putText(overlay, alto_text, (x_alto + (bg_width_alto - alto_text_size[0]) // 2, y_alto + padding_vertical + line_height_title_metric // 2 + 2), font, font_scale_title_metric, text_color_title, font_thickness_metric, cv2.LINE_AA)
-    cv2.putText(overlay, alto_value, (x_alto + (bg_width_alto - alto_value_size[0]) // 2, y_alto + padding_vertical + line_height_title_metric + line_height_value // 2 + 5), font, font_scale_value, text_color_value, font_thickness_metric, cv2.LINE_AA)
-    
-    # --- Repetitions Box ---
-    reps_text = "REPETICIONES"
-    reps_value = f"{repetition_count}"
-    reps_text_size = cv2.getTextSize(reps_text, font, font_scale_title_metric, font_thickness_metric)[0]
-    reps_value_size = cv2.getTextSize(reps_value, font, font_scale_value, font_thickness_metric)[0]
-    bg_width_reps = max(reps_text_size[0], reps_value_size[0]) + 2 * padding_horizontal
-    bg_height_reps = line_height_title_metric + line_height_value + 2 * padding_vertical
-    x_reps = x_relativo
-    y_reps = y_relativo + bg_height_relativo + 10
-    
-    pt1_reps = (x_reps, y_reps)
-    pt2_reps = (x_reps + bg_width_reps, y_reps + bg_height_reps)
-    overlay = draw_rounded_rect(overlay, pt1_reps, pt2_reps, bg_color, cv2.FILLED, cv2.LINE_AA, corner_radius)
-    cv2.rectangle(overlay, pt1_reps, pt2_reps, border_color, border_thickness, cv2.LINE_AA)
-    cv2.putText(overlay, reps_text, (x_reps + (bg_width_reps - reps_text_size[0]) // 2, y_reps + padding_vertical + line_height_title_metric // 2 + 2), font, font_scale_title_metric, text_color_title, font_thickness_metric, cv2.LINE_AA)
-    cv2.putText(overlay, reps_value, (x_reps + (bg_width_reps - reps_value_size[0]) // 2, y_reps + padding_vertical + line_height_title_metric + line_height_value // 2 + 5), font, font_scale_value, text_color_value, font_thickness_metric, cv2.LINE_AA)
-    
-    # --- Vertical Velocity Box (below feet) ---
-    if last_detected_ankles_y is not None:
-        velocidad_text = "VELOCIDAD VERTICAL"
-        velocidad_value = f"{abs(velocity_vertical):.2f} m/s"  # Show absolute value
-        velocidad_text_size = cv2.getTextSize(velocidad_text, font, font_scale_title_metric, font_thickness_metric)[0]
-        velocidad_value_size = cv2.getTextSize(velocidad_value, font, font_scale_value, font_thickness_metric)[0]
-        bg_width_velocidad = max(velocidad_text_size[0], velocidad_value_size[0]) + 2 * padding_horizontal
-        bg_height_velocidad = line_height_title_metric + line_height_value + 2 * padding_vertical
-        
-        x_velocidad = int(width / 2 - bg_width_velocidad / 2)  # Horizontally centered
-        y_velocidad = int(last_detected_ankles_y + metrics_below_feet_offset + bg_height_velocidad)
-        
-        pt1_velocidad = (int(x_velocidad), int(y_velocidad - bg_height_velocidad))
-        pt2_velocidad = (int(x_velocidad + bg_width_velocidad), int(y_velocidad))
-        overlay = draw_rounded_rect(overlay, pt1_velocidad, pt2_velocidad, bg_color, cv2.FILLED, cv2.LINE_AA, corner_radius)
-        cv2.rectangle(overlay, pt1_velocidad, pt2_velocidad, border_color, border_thickness, cv2.LINE_AA)
-        cv2.putText(overlay, velocidad_text, (int(x_velocidad + (bg_width_velocidad - velocidad_text_size[0]) // 2), int(y_velocidad - bg_height_velocidad + padding_vertical + line_height_title_metric // 2 + 2)), font, font_scale_title_metric, text_color_title, font_thickness_metric, cv2.LINE_AA)
-        cv2.putText(overlay, velocidad_value, (int(x_velocidad + (bg_width_velocidad - velocidad_value_size[0]) // 2), int(y_velocidad - bg_height_velocidad + padding_vertical + line_height_title_metric + line_height_value // 2 + 5)), font, font_scale_value, text_color_value, font_thickness_metric, cv2.LINE_AA)
-        
-        # --- Sayer Power Box (below velocity box) ---
-        potencia_text = "POTENCIA SAYER"
+    # Draw velocity box (only if ankles detected)
+    if "velocidad" in positions:
+        velocidad_value = f"{abs(velocity_vertical):.2f} m/s"
+        bg_width, bg_height = calculate_metric_box_size("VELOCIDAD VERTICAL", velocidad_value, config)
+        x, y = positions["velocidad"]
+        overlay = draw_metric_box(overlay, "VELOCIDAD VERTICAL", velocidad_value, x, y, bg_width, bg_height, config, colors)
+    
+    # Draw power box (only if ankles detected)
+    if "potencia" in positions:
         potencia_value = f"{peak_power_sayer:.2f} W"
-        potencia_text_size = cv2.getTextSize(potencia_text, font, font_scale_title_metric, font_thickness_metric)[0]
-        potencia_value_size = cv2.getTextSize(potencia_value, font, font_scale_value, font_thickness_metric)[0]
-        bg_width_potencia = max(potencia_text_size[0], potencia_value_size[0]) + 2 * padding_horizontal
-        bg_height_potencia = line_height_title_metric + line_height_value + 2 * padding_vertical
-        
-        x_potencia = x_velocidad  # Same horizontal position as velocity
-        y_potencia = y_velocidad + 5  # Below velocity box
-        
-        pt1_potencia = (int(x_potencia), int(y_potencia))
-        pt2_potencia = (int(x_potencia + bg_width_potencia), int(y_potencia + bg_height_potencia))
-        overlay = draw_rounded_rect(overlay, pt1_potencia, pt2_potencia, bg_color, cv2.FILLED, cv2.LINE_AA, corner_radius)
-        cv2.rectangle(overlay, pt1_potencia, pt2_potencia, border_color, border_thickness, cv2.LINE_AA)
-        cv2.putText(overlay, potencia_text, (int(x_potencia + (bg_width_potencia - potencia_text_size[0]) // 2), int(y_potencia + padding_vertical + line_height_title_metric // 2 + 2)), font, font_scale_title_metric, text_color_title, font_thickness_metric, cv2.LINE_AA)
-        cv2.putText(overlay, potencia_value, (int(x_potencia + (bg_width_potencia - potencia_value_size[0]) // 2), int(y_potencia + padding_vertical + line_height_title_metric + line_height_value // 2 + 5)), font, font_scale_value, text_color_value, font_thickness_metric, cv2.LINE_AA)
+        bg_width, bg_height = calculate_metric_box_size("POTENCIA SAYER", potencia_value, config)
+        x, y = positions["potencia"]
+        overlay = draw_metric_box(overlay, "POTENCIA SAYER", potencia_value, x, y, bg_width, bg_height, config, colors)
     
     # Blend overlay with original frame
-    result = cv2.addWeighted(overlay, alpha, frame, 1 - alpha, 0)
+    result = cv2.addWeighted(overlay, config.alpha, frame, 1 - config.alpha, 0)
     return result