save

app.py

@@ -2,9 +2,10 @@ from fastapi import FastAPI, UploadFile, File, Response,Header, BackgroundTasks,
 from fastapi.staticfiles import StaticFiles
 from vitpose import VitPose
 from dotenv import load_dotenv
-from tasks import process_video
+from tasks import process_video,process_salto_alto
 from fastapi.responses import JSONResponse
 from config import AI_API_TOKEN
+from typing import Any
 import logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -50,4 +51,39 @@ async def upload(background_tasks: BackgroundTasks,
 
     # Return the file as a response
     return JSONResponse(content={"message": "Video uploaded successfully", "status": 200})
-    
+    
+@app.post("/exercise/salto_alto")
+async def upload(background_tasks: BackgroundTasks,
+                 file: UploadFile = File(...), 
+                 token: str = Header(...),
+                 player_data: str = Body(...),
+                 repetitions: int|str = Body(...),
+                 exercise_id: str = Body(...)
+                 ):
+    
+    import json
+    player_data = json.loads(player_data)
+
+    if token != AI_API_TOKEN:
+        return JSONResponse(content={"message": "Unauthorized", "status": 401})
+    
+    logger.info("reading contents")
+    contents = await file.read()
+    
+    # Save the file to the local directory
+    logger.info("saving file")
+    with open(file.filename, "wb") as f:
+        f.write(contents)
+    
+    logger.info(f"file saved {file.filename}")
+    
+    # Create a clone of the file with content already read
+    background_tasks.add_task(process_salto_alto, 
+                              file.filename,
+                              vitpose, 
+                              player_data,
+                              repetitions,
+                              exercise_id)  
+
+    # Return the file as a response
+    return JSONResponse(content={"message": "Video uploaded successfully", "status": 200})

tasks.py

@@ -4,9 +4,14 @@ import os
 from config import API_URL,API_KEY
 from fastapi import UploadFile
 import logging
+import cv2
+import numpy as np
+
+import time
+import json
+
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
-
 def process_video(file_name: str,vitpose: VitPose,user_id: str,player_id: str):
     
     video_path = file_name
@@ -45,4 +50,514 @@ def process_video(file_name: str,vitpose: VitPose,user_id: str,player_id: str):
     logger.info(f"Response: {response.status_code}")
     logger.info(f"Response: {response.text}")
     logger.info(f"Video sent to {url}")
-    
+    
+
+def process_salto_alto(file_name: str, vitpose: VitPose, player_data: dict, repetitions: int, exercise_id: str):
+    """
+    Process a high jump exercise video using VitPose for pose estimation.
+    
+    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
+    """
+    # Use the provided VitPose instance
+    model = vitpose.pipeline
+    
+    # Get player parameters from player_data or use defaults
+    reference_height = player_data.get('height', 1.68)  # Altura aproximada de la persona en metros
+    body_mass_kg = player_data.get('weight', 64)  # Peso corporal en kg
+    
+    # Generate output paths
+    output_video = file_name.replace('.mp4', '_analyzed.mp4')
+    output_json = output_video.replace('.mp4', '.json')
+    
+    # Process the video and get the jump metrics
+    results_dict = analyze_jump_video(
+        model=model,
+        input_video=file_name,
+        output_video=output_video,
+        reference_height=reference_height,
+        body_mass_kg=body_mass_kg
+    )
+    
+    # Save results to JSON
+    with open(output_json, 'w') as f:
+        json.dumps(results_dict, indent=4)
+    
+    # Print summary
+    print("\nResultados finales:")
+    print(f"Salto Relativo máximo: {results_dict['jump_metrics']['max_relative_jump']:.2f}m")
+    print(f"Salto Alto máximo: {results_dict['jump_metrics']['max_high_jump']:.2f}m")
+    print(f"Potencia Sayer (estimada): {results_dict['jump_metrics']['peak_power_sayer']:.2f} W")
+    
+    # Return results dictionary
+    return {
+        "output_video": output_video,
+        "output_json": output_json,
+        "metrics": results_dict
+    }
+
+
+def analyze_jump_video(model, input_video, output_video, reference_height=1.68, body_mass_kg=64):
+    """
+    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
+        reference_height: Height of the person in meters
+        body_mass_kg: Weight of the person in kg
+        
+    Returns:
+        Dictionary containing jump metrics and video analysis data
+    """
+    # 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 = []
+    
+    # Open the video
+    cap = cv2.VideoCapture(input_video)
+    if not cap.isOpened():
+        print("Error al abrir el video")
+        return {}
+    
+    # Get first frame to calibrate and get initial shoulder positions
+    ret, frame = cap.read()
+    if not ret:
+        print("Error al leer el video")
+        return {}
+    
+    # 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
+    results_first_frame = model(frame)  # Detect pose in first frame
+    if results_first_frame and results_first_frame[0].keypoints and len(results_first_frame[0].keypoints.xy[0]) > 0:
+        kpts_first = results_first_frame[0].keypoints.xy[0].cpu().numpy()
+        if kpts_first[0][1] > 0 and kpts_first[15][1] > 0 and kpts_first[16][1] > 0:  # Nose and ankles
+            initial_person_height_px = min(kpts_first[15][1], kpts_first[16][1]) - kpts_first[0][1]
+            PX_PER_METER = initial_person_height_px / reference_height
+            print(f"Escala calculada: {PX_PER_METER:.2f} px/m")
+        if kpts_first[5][0] > 0 and kpts_first[6][0] > 0:  # Left (5) and right (6) shoulders
+            initial_left_shoulder_x = int(kpts_first[5][0])
+            initial_right_shoulder_x = int(kpts_first[6][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 {}
+    
+    # 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))
+    
+    # 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
+    person_detected = False  # Flag to indicate if person was detected in any frame
+    current_power = 0.0
+    repetition_count = 0
+    jump_in_air = False
+    
+    # Process each frame
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            break
+        
+        annotated_frame = frame.copy()
+        results = model(annotated_frame)
+        
+        if results and results[0].keypoints and len(results[0].keypoints.xy[0]) > 0:
+            person_detected = True
+            kpts = results[0].keypoints.xy[0].cpu().numpy()
+            nose = kpts[0]
+            ankles = [kpts[15], kpts[16]]
+            left_shoulder = kpts[5]
+            right_shoulder = kpts[6]
+            
+            if nose[1] > 0 and all(a[1] > 0 for a in ankles) and left_shoulder[0] > 0 and right_shoulder[0] > 0:
+                current_ankle_y = min(a[1] for a in ankles)
+                last_detected_ankles_y = current_ankle_y  # Save current ankle position
+                current_head_y = nose[1]
+                current_left_shoulder_x = int(left_shoulder[0])
+                current_right_shoulder_x = int(right_shoulder[0])
+                
+                # 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
+                
+                # Detect jump end
+                if jump_started and relative_ankle_change <= JUMP_THRESHOLD_PERCENT:
+                    # Add to repetition data
+                    salto_alto = calculate_absolute_jump_height(reference_height, max_jump_height)
+                    repetition_data.append({
+                        "repetition": repetition_count + 1,
+                        "relative_jump_m": round(max_jump_height, 3),
+                        "absolute_jump_m": round(salto_alto, 3),
+                        "peak_power_watts": round(current_power, 1)
+                    })
+                    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 > peak_power_sayer:
+                            peak_power_sayer = current_power
+        else:
+            last_detected_ankles_y = None  # Reset position if ankles not detected
+            velocity_vertical = 0.0  # Reset velocity if no reliable detection
+        
+        # Calculate absolute jump height
+        salto_alto = calculate_absolute_jump_height(reference_height, max_jump_height)
+        
+        # Draw floating metric boxes
+        annotated_frame = draw_metrics_overlay(
+            frame=annotated_frame,
+            max_jump_height=max_jump_height,
+            salto_alto=salto_alto,
+            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_below_feet_offset=METRICS_BELOW_FEET_OFFSET,
+            horizontal_offset_factor=HORIZONTAL_OFFSET_FACTOR
+        )
+        
+        out.write(annotated_frame)
+    
+    # Prepare results dictionary
+    results_dict = {
+        "jump_metrics": {
+            "max_relative_jump": float(max(0, max_jump_height)),
+            "max_high_jump": float(max(0, salto_alto)),
+            "peak_power_sayer": float(peak_power_sayer),
+            "repetitions": int(repetition_count),
+            "reference_height": float(reference_height),
+            "body_mass_kg": float(body_mass_kg),
+            "px_per_meter": float(PX_PER_METER) if PX_PER_METER is not None else 0.0
+        },
+        "video_analysis": {
+            "input_video": str(input_video),
+            "output_video": str(output_video),
+            "fps": float(fps),
+            "resolution": f"{int(width)}x{int(height)}"
+        },
+        "repetition_data": [
+            {
+                "repetition": int(rep["repetition"]),
+                "relative_jump_m": float(rep["relative_jump_m"]),
+                "absolute_jump_m": float(rep["absolute_jump_m"]),
+                "peak_power_watts": float(rep["peak_power_watts"])
+            } for rep in repetition_data
+        ]
+    }
+    
+    cap.release()
+    out.release()
+    
+    return results_dict
+
+
+def calculate_peak_power_sayer(jump_height_m, body_mass_kg):
+    """
+    Estimates peak anaerobic power using Sayer's equation.
+    
+    Args:
+        jump_height_m: Jump height in meters
+        body_mass_kg: Body mass in kg
+        
+    Returns:
+        Estimated peak power in watts
+    """
+    jump_height_cm = jump_height_m * 100
+    return (60.7 * jump_height_cm) + (45.3 * body_mass_kg) - 2055
+
+
+def calculate_absolute_jump_height(reference_height, relative_jump):
+    """
+    Calculate absolute jump height based on reference height and relative jump.
+    
+    Args:
+        reference_height: Reference height in meters
+        relative_jump: Relative jump height in meters
+        
+    Returns:
+        Absolute jump height in meters
+    """
+    absolute_jump = reference_height + relative_jump
+    # Apply validation rule
+    if absolute_jump > 1.72:
+        return absolute_jump
+    else:
+        return 0
+
+
+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,
+                        horizontal_offset_factor=0.75):
+    """
+    Draw metrics overlay on the frame.
+    
+    Args:
+        frame: Input frame
+        max_jump_height: Maximum jump height in meters
+        salto_alto: Absolute jump height in meters
+        velocity_vertical: Vertical velocity in m/s
+        peak_power_sayer: Peak power in watts
+        repetition_count: Number of repetitions
+        last_detected_ankles_y: Y-coordinate of last detected ankles
+        initial_left_shoulder_x: X-coordinate of left shoulder
+        initial_right_shoulder_x: X-coordinate of right shoulder
+        width: Frame width
+        height: Frame height
+        colors: Dictionary with color values
+        metrics_below_feet_offset: Offset for metrics below feet
+        horizontal_offset_factor: Factor for horizontal offset
+        
+    Returns:
+        Frame with metrics overlay
+    """
+    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
+    
+    # --- 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
+    
+    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
+    
+    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"
+        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)
+    
+    # Blend overlay with original frame
+    result = cv2.addWeighted(overlay, alpha, frame, 1 - alpha, 0)
+    return result

vitpose.py

@@ -17,7 +17,7 @@ class VitPose:
             object_detection_checkpoint="PekingU/rtdetr_r50vd_coco_o365",
             pose_estimation_checkpoint="usyd-community/vitpose-plus-small",
             device="cuda" if torch.cuda.is_available() else "cpu",
-            dtype=torch.bfloat16,
+            dtype=torch.float16,
             compile=True,  # or True to get more speedup
         )
         self.output_video_path = None
@@ -104,4 +104,7 @@ class VitPose:
             else:
                 # Already vertical, no rotation needed
                 out.write(frame)    
-        out.release()     
+        out.release()     
+
+
+