Upload 9 files

app.py

@@ -1,7 +1,11 @@
 import gradio as gr
 import pandas as pd
 import os
-from athletic_performance import analyze_youtube_video, analyze_video_file, get_performance_insights, get_ai_sports_coaching_analysis, test_gemini_api_connection
+from athletic_performance import (
+    analyze_youtube_video, analyze_video_file, get_performance_insights, 
+    get_ai_sports_coaching_analysis, test_gemini_api_connection,
+    generate_annotated_video_from_youtube, generate_annotated_video_from_file
+)
 
 def analyze_jump_from_youtube(youtube_url, user_height_cm, user_weight_kg, progress=gr.Progress()):
     """Main analysis function for Gradio interface."""
@@ -280,6 +284,118 @@ def test_api_key(api_key):
     else:
         return f"❌ API Key test failed!\n\nStatus Code: {result['status_code']}\nError: {result['error']}\n\nResponse: {result['response_text']}"
 
+
+def generate_video_from_youtube(youtube_url, user_height_cm, user_weight_kg, gender, progress=gr.Progress()):
+    """Generate annotated video from YouTube URL."""
+    
+    # Create progress callback
+    def progress_callback(prog, desc):
+        progress(prog, desc=desc)
+    
+    # Call the video generation function
+    result = generate_annotated_video_from_youtube(
+        youtube_url, user_height_cm, user_weight_kg, gender, progress_callback
+    )
+    
+    # Handle errors
+    if "error" in result:
+        return f"❌ Video generation failed: {result['error']}", None, None
+    
+    if result is None:
+        return "❌ Could not generate video. Please ensure the video shows a clear vertical jump.", None, None
+    
+    # Format results
+    video_path = result.get("output_video_path", "")
+    jump_metrics = result.get("jump_metrics", {})
+    
+    results_text = f"""
+# 🎬 Annotated Video Generated!
+
+## 📊 Jump Analysis Summary
+- **Jump Height**: {jump_metrics.get('jump_height_cm', 0):.2f} cm
+- **Flight Time**: {jump_metrics.get('flight_time_s', 0):.3f} seconds
+- **Peak Power**: {jump_metrics.get('peak_power_watts', 0):.0f} watts
+- **Frames Processed**: {result.get('total_frames_processed', 0)}
+
+## 🎥 Video Features Added
+- ✅ **Pose Tracking**: Real-time skeleton overlay
+- ✅ **Jump Reference Lines**: Average vs Professional heights
+- ✅ **Knee Strain Detection**: Red markers for poor form
+- ✅ **Performance Metrics**: Live jump height tracking
+
+## 📥 Download
+Your annotated video is ready for download!
+"""
+    
+    # Create summary dataframe
+    summary_df = pd.DataFrame([
+        ["Jump Height", f"{jump_metrics.get('jump_height_cm', 0):.2f} cm"],
+        ["Flight Time", f"{jump_metrics.get('flight_time_s', 0):.3f} seconds"],
+        ["Peak Power", f"{jump_metrics.get('peak_power_watts', 0):.0f} watts"],
+        ["Video Features", "Pose + References + Strain Detection"],
+        ["Output Format", "MP4 Video"],
+        ["Status", "✅ Ready for Download"],
+    ], columns=["Metric", "Value"])
+    
+    return results_text, summary_df, video_path
+
+
+def generate_video_from_file(video_file, user_height_cm, user_weight_kg, gender, progress=gr.Progress()):
+    """Generate annotated video from uploaded file."""
+    
+    # Create progress callback
+    def progress_callback(prog, desc):
+        progress(prog, desc=desc)
+    
+    # Call the video generation function
+    video_path = video_file.name if video_file else None
+    result = generate_annotated_video_from_file(
+        video_path, user_height_cm, user_weight_kg, gender, progress_callback
+    )
+    
+    # Handle errors
+    if "error" in result:
+        return f"❌ Video generation failed: {result['error']}", None, None
+    
+    if result is None:
+        return "❌ Could not generate video. Please ensure the video shows a clear vertical jump.", None, None
+    
+    # Format results (same as YouTube function)
+    video_path = result.get("output_video_path", "")
+    jump_metrics = result.get("jump_metrics", {})
+    
+    results_text = f"""
+# 🎬 Annotated Video Generated!
+
+## 📊 Jump Analysis Summary
+- **Jump Height**: {jump_metrics.get('jump_height_cm', 0):.2f} cm
+- **Flight Time**: {jump_metrics.get('flight_time_s', 0):.3f} seconds
+- **Peak Power**: {jump_metrics.get('peak_power_watts', 0):.0f} watts
+- **Frames Processed**: {result.get('total_frames_processed', 0)}
+
+## 🎥 Video Features Added
+- ✅ **Pose Tracking**: Real-time skeleton overlay
+- ✅ **Jump Reference Lines**: Average vs Professional heights
+- ✅ **Knee Strain Detection**: Red markers for poor form
+- ✅ **Performance Metrics**: Live jump height tracking
+
+## 📥 Download
+Your annotated video is ready for download!
+"""
+    
+    # Create summary dataframe
+    summary_df = pd.DataFrame([
+        ["Jump Height", f"{jump_metrics.get('jump_height_cm', 0):.2f} cm"],
+        ["Flight Time", f"{jump_metrics.get('flight_time_s', 0):.3f} seconds"],
+        ["Peak Power", f"{jump_metrics.get('peak_power_watts', 0):.0f} watts"],
+        ["Video Features", "Pose + References + Strain Detection"],
+        ["Output Format", "MP4 Video"],
+        ["Status", "✅ Ready for Download"],
+    ], columns=["Metric", "Value"])
+    
+    return results_text, summary_df, video_path
+
+
 # Create Gradio interface
 def create_interface():
     with gr.Blocks(title="🏃‍♂️ Athletic Ability Analysis") as app:
@@ -292,13 +408,18 @@ def create_interface():
         ## 🚀 Features
         - **📊 Biomechanical Analysis**: Comprehensive jump metrics (height, power, force, RFD)
         - **🤖 AI Sports Coach**: Personalized sport recommendations and technique improvements
+        - **🎬 Annotated Videos**: Generate training videos with pose tracking and performance overlays
+        - **⚠️ Technique Analysis**: Real-time knee strain detection and form corrections
         - **🎯 Performance Insights**: Professional-grade analysis and training suggestions
         
         ## 📋 Instructions
         1. Enter your height in centimeters and weight in kilograms
-        2. Choose your analysis type: Basic metrics, or AI coaching with sports recommendations
+        2. Choose your analysis type: 
+           - **📊 Standard Analysis**: Get detailed biomechanical metrics
+           - **🤖 AI Sports Coach**: Personalized recommendations and sport suggestions  
+           - **🎬 Video Generation**: Create annotated training videos with visual overlays
         3. Provide a video (YouTube URL or file upload)
-        4. Get comprehensive results and actionable insights
+        4. Get comprehensive results, actionable insights, or downloadable training videos
         """)
         
         with gr.Row():
@@ -393,6 +514,45 @@ def create_interface():
                         gr.Markdown("*Provide either a YouTube URL or upload a video file*")
                 
                 ai_coaching_btn = gr.Button("🤖 Get AI Coaching Analysis", variant="primary", size="lg")
+            
+            # Video Generation Tab
+            with gr.TabItem("🎬 Annotated Video"):
+                gr.Markdown("""
+                ## 🎬 Generate Annotated Training Video
+                
+                Create a professional training video with visual overlays including:
+                - **🦴 Pose Tracking**: Real-time skeleton visualization
+                - **📏 Performance Lines**: Average vs Professional jump heights
+                - **⚠️ Knee Strain Detection**: Red warnings for poor form
+                - **📊 Live Metrics**: Frame-by-frame jump analysis
+                
+                Perfect for coaches, athletes, and performance analysis!
+                """)
+                
+                with gr.Row():
+                    with gr.Column():
+                        video_gender = gr.Radio(
+                            choices=["Male", "Female"],
+                            label="Gender (for performance references)",
+                            value="Male"
+                        )
+                        gr.Markdown("*Used to set appropriate average/pro jump height lines*")
+                    
+                    with gr.Column():
+                        gr.Markdown("### Video Input Options")
+                        video_youtube_url = gr.Textbox(
+                            label="YouTube URL (Option 1)",
+                            placeholder="https://youtube.com/watch?v=..."
+                        )
+                        video_file_upload = gr.File(
+                            label="Upload Video File (Option 2)",
+                            file_types=[".mp4", ".avi", ".mov", ".mkv", ".webm"]
+                        )
+                        gr.Markdown("*Provide either a YouTube URL or upload a video file*")
+                
+                with gr.Row():
+                    video_youtube_btn = gr.Button("🎬 Generate from YouTube", variant="primary", size="lg")
+                    video_file_btn = gr.Button("🎬 Generate from Upload", variant="primary", size="lg")
         
         # Results section
         gr.Markdown("## 📊 Analysis Results")
@@ -466,6 +626,19 @@ def create_interface():
             outputs=[api_test_result]
         )
         
+        # Video generation event handlers
+        video_youtube_btn.click(
+            fn=generate_video_from_youtube,
+            inputs=[video_youtube_url, user_height, user_weight, video_gender],
+            outputs=[results_text, results_table, gr.File(label="Download Video")]
+        )
+        
+        video_file_btn.click(
+            fn=generate_video_from_file,
+            inputs=[video_file_upload, user_height, user_weight, video_gender],
+            outputs=[results_text, results_table, gr.File(label="Download Video")]
+        )
+        
         # Example section
         gr.Examples(
             examples=[

athletic_performance.py

@@ -8,11 +8,28 @@ import os
 import yt_dlp
 import json
 import requests
+import math
 
 # MediaPipe pose landmarks
 LHIP, RHIP = 23, 24
+LKNEE, RKNEE = 25, 26
+LANKLE, RANKLE = 27, 28
+LSHOULDER, RSHOULDER = 11, 12
+NOSE = 0
 POSE_CONNECTIONS = mp.solutions.pose.POSE_CONNECTIONS
 
+# Jump performance standards (in cm) based on demographics
+JUMP_STANDARDS = {
+    "Male": {
+        "average": 45,  # Average jump height for males
+        "pro": 75       # Professional/elite level for males
+    },
+    "Female": {
+        "average": 35,  # Average jump height for females  
+        "pro": 65       # Professional/elite level for females
+    }
+}
+
 
 def smooth_moving_avg(series, k=5):
     """Simple causal moving average; ignores None values."""
@@ -36,6 +53,181 @@ def smooth_moving_avg(series, k=5):
     return out
 
 
+def calculate_angle(point1, point2, point3):
+    """Calculate angle between three points (point2 is the vertex)."""
+    # Calculate vectors
+    vec1 = np.array([point1.x - point2.x, point1.y - point2.y])
+    vec2 = np.array([point3.x - point2.x, point3.y - point2.y])
+    
+    # Calculate angle using dot product
+    cos_angle = np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))
+    cos_angle = np.clip(cos_angle, -1.0, 1.0)  # Handle numerical errors
+    angle = np.arccos(cos_angle)
+    
+    return math.degrees(angle)
+
+
+def analyze_knee_strain(landmarks, frame_height):
+    """Analyze knee angles to detect strain and provide recommendations."""
+    if not landmarks:
+        return {"left_knee": None, "right_knee": None, "strain_detected": False}
+    
+    lms = landmarks.landmark
+    
+    # Calculate knee angles (hip-knee-ankle)
+    left_angle = None
+    right_angle = None
+    strain_detected = False
+    
+    try:
+        # Left knee angle
+        left_angle = calculate_angle(lms[LHIP], lms[LKNEE], lms[LANKLE])
+        
+        # Right knee angle  
+        right_angle = calculate_angle(lms[RHIP], lms[RKNEE], lms[RANKLE])
+        
+        # Check for strain (angles too acute indicate over-bending)
+        # Healthy knee angle during jumping should be > 90 degrees
+        # Angles < 70 degrees indicate potential strain
+        left_strain = left_angle < 70 if left_angle else False
+        right_strain = right_angle < 70 if right_angle else False
+        
+        strain_detected = left_strain or right_strain
+        
+    except (AttributeError, ZeroDivisionError):
+        pass
+    
+    return {
+        "left_knee": {
+            "angle": left_angle,
+            "strain": left_angle < 70 if left_angle else False,
+            "optimal_angle": 90  # Recommended minimum angle
+        },
+        "right_knee": {
+            "angle": right_angle, 
+            "strain": right_angle < 70 if right_angle else False,
+            "optimal_angle": 90
+        },
+        "strain_detected": strain_detected
+    }
+
+
+def get_jump_reference_heights(gender, user_height_cm):
+    """Get average and professional jump height references based on demographics."""
+    base_avg = JUMP_STANDARDS.get(gender, JUMP_STANDARDS["Male"])["average"]
+    base_pro = JUMP_STANDARDS.get(gender, JUMP_STANDARDS["Male"])["pro"]
+    
+    # Adjust for height (taller people generally jump higher)
+    height_factor = user_height_cm / 175.0  # Normalize to average height
+    
+    avg_height = base_avg * height_factor
+    pro_height = base_pro * height_factor
+    
+    return {
+        "average": avg_height,
+        "professional": pro_height,
+        "gender": gender,
+        "height_adjusted": True
+    }
+
+
+def draw_pose_landmarks(frame, landmarks, knee_analysis=None):
+    """Draw pose landmarks and connections on the frame."""
+    if not landmarks:
+        return frame
+    
+    h, w, _ = frame.shape
+    
+    # Draw pose connections
+    mp_drawing = mp.solutions.drawing_utils
+    mp_pose = mp.solutions.pose
+    
+    # Draw all pose landmarks
+    mp_drawing.draw_landmarks(
+        frame, landmarks, mp_pose.POSE_CONNECTIONS,
+        mp_drawing.DrawingSpec(color=(0, 255, 0), thickness=2, circle_radius=2),
+        mp_drawing.DrawingSpec(color=(0, 255, 255), thickness=2)
+    )
+    
+    # Highlight knees with strain indicators
+    if knee_analysis and knee_analysis["strain_detected"]:
+        lms = landmarks.landmark
+        
+        # Left knee
+        if knee_analysis["left_knee"]["strain"]:
+            left_knee_x = int(lms[LKNEE].x * w)
+            left_knee_y = int(lms[LKNEE].y * h)
+            cv2.circle(frame, (left_knee_x, left_knee_y), 8, (0, 0, 255), -1)
+            
+            # Show angle and recommendation
+            angle_text = f"L: {knee_analysis['left_knee']['angle']:.0f}°"
+            cv2.putText(frame, angle_text, (left_knee_x - 30, left_knee_y - 15),
+                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2)
+            cv2.putText(frame, "STRAIN!", (left_knee_x - 25, left_knee_y + 25),
+                       cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2)
+        
+        # Right knee
+        if knee_analysis["right_knee"]["strain"]:
+            right_knee_x = int(lms[RKNEE].x * w)
+            right_knee_y = int(lms[RKNEE].y * h)
+            cv2.circle(frame, (right_knee_x, right_knee_y), 8, (0, 0, 255), -1)
+            
+            # Show angle and recommendation
+            angle_text = f"R: {knee_analysis['right_knee']['angle']:.0f}°"
+            cv2.putText(frame, angle_text, (right_knee_x + 10, right_knee_y - 15),
+                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2)
+            cv2.putText(frame, "STRAIN!", (right_knee_x + 5, right_knee_y + 25),
+                       cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 2)
+    
+    return frame
+
+
+def draw_jump_reference_lines(frame, references, current_jump_height, user_height_cm):
+    """Draw average and professional jump height reference lines."""
+    h, w, _ = frame.shape
+    
+    # Calculate line positions (relative to frame height)
+    # Assume the person's height spans about 70% of frame height
+    person_height_pixels = int(h * 0.7)
+    pixels_per_cm = person_height_pixels / user_height_cm
+    
+    # Base line (ground level) - bottom 10% of frame
+    ground_y = int(h * 0.9)
+    
+    # Reference lines
+    avg_jump_pixels = int(references["average"] * pixels_per_cm)
+    pro_jump_pixels = int(references["professional"] * pixels_per_cm)
+    current_jump_pixels = int(current_jump_height * pixels_per_cm)
+    
+    avg_line_y = ground_y - avg_jump_pixels
+    pro_line_y = ground_y - pro_jump_pixels
+    current_line_y = ground_y - current_jump_pixels
+    
+    # Draw ground line
+    cv2.line(frame, (0, ground_y), (w, ground_y), (100, 100, 100), 2)
+    cv2.putText(frame, "Ground", (10, ground_y - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (100, 100, 100), 2)
+    
+    # Draw average line
+    if avg_line_y > 0:
+        cv2.line(frame, (0, avg_line_y), (w, avg_line_y), (255, 255, 0), 2)
+        cv2.putText(frame, f"Avg: {references['average']:.0f}cm", 
+                   (10, avg_line_y - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 0), 2)
+    
+    # Draw professional line
+    if pro_line_y > 0:
+        cv2.line(frame, (0, pro_line_y), (w, pro_line_y), (0, 255, 0), 2)
+        cv2.putText(frame, f"Pro: {references['professional']:.0f}cm", 
+                   (10, pro_line_y - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
+    
+    # Draw current jump line
+    if current_line_y > 0 and current_jump_height > 0:
+        cv2.line(frame, (0, current_line_y), (w, current_line_y), (0, 0, 255), 3)
+        cv2.putText(frame, f"Your Jump: {current_jump_height:.0f}cm", 
+                   (w - 200, current_line_y - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2)
+    
+    return frame
+
+
 def calculate_peak_power_output(jump_height_m, body_mass_kg, flight_time_s):
     """Calculate peak power output using biomechanical models."""
     if jump_height_m <= 0 or flight_time_s <= 0:
@@ -219,6 +411,128 @@ def download_youtube_video(youtube_url, output_path):
     return output_path
 
 
+def generate_annotated_video(video_path, user_height_cm, user_weight_kg, gender, output_path=None, progress_callback=None):
+    """Generate annotated video with pose tracking, jump analysis, and knee strain detection."""
+    
+    # Set up output path
+    if output_path is None:
+        video_name = Path(video_path).stem
+        output_path = f"{video_name}_annotated.mp4"
+    
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        raise Exception(f"Could not open video: {video_path}")
+
+    # Get video properties
+    w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    fps = cap.get(cv2.CAP_PROP_FPS) or 30.0
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+
+    # Set up video writer
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    out = cv2.VideoWriter(output_path, fourcc, fps, (w, h))
+
+    # Set up pose detection
+    mp_pose = mp.solutions.pose
+    pose = mp_pose.Pose(static_image_mode=False, model_complexity=1, enable_segmentation=False)
+
+    # Get jump references
+    jump_references = get_jump_reference_heights(gender, user_height_cm)
+    
+    # Track hip positions for jump height calculation
+    hip_y_series = []
+    frame_idx = 0
+    
+    print(f"Generating annotated video: {output_path}")
+    print(f"Video dimensions: {w}x{h}, FPS: {fps}, Total frames: {total_frames}")
+
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+
+        # Process frame for pose detection
+        rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        results = pose.process(rgb)
+
+        # Track hip position
+        hip_y = None
+        if results.pose_landmarks:
+            lms = results.pose_landmarks.landmark
+            hip_y = (lms[LHIP].y + lms[RHIP].y) / 2.0
+            hip_y_series.append(hip_y)
+        else:
+            hip_y_series.append(None)
+
+        # Calculate current jump height (rough estimate)
+        current_jump_height = 0
+        if len(hip_y_series) > 10:  # Need some history
+            recent_hips = [h for h in hip_y_series[-20:] if h is not None]
+            if recent_hips:
+                min_hip = min(recent_hips)
+                max_hip = max(recent_hips)
+                normalized_jump = max_hip - min_hip
+                current_jump_height = normalized_jump * user_height_cm
+
+        # Analyze knee strain
+        knee_analysis = analyze_knee_strain(results.pose_landmarks, h)
+
+        # Draw pose landmarks with strain indicators
+        annotated_frame = draw_pose_landmarks(frame, results.pose_landmarks, knee_analysis)
+
+        # Draw jump reference lines
+        annotated_frame = draw_jump_reference_lines(
+            annotated_frame, jump_references, current_jump_height, user_height_cm
+        )
+
+        # Add performance info overlay
+        info_y = 30
+        cv2.putText(annotated_frame, f"Frame: {frame_idx}/{total_frames}", 
+                   (10, info_y), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
+        
+        if current_jump_height > 0:
+            cv2.putText(annotated_frame, f"Current Jump: {current_jump_height:.1f}cm", 
+                       (10, info_y + 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 255), 2)
+
+        # Add knee strain warnings
+        if knee_analysis["strain_detected"]:
+            warning_text = "⚠️ KNEE STRAIN DETECTED!"
+            cv2.putText(annotated_frame, warning_text, (10, h - 60), 
+                       cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 0, 255), 2)
+            
+            recommendations = "Keep knees above 90° angle"
+            cv2.putText(annotated_frame, recommendations, (10, h - 30), 
+                       cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 255), 2)
+
+        # Write frame to output video
+        out.write(annotated_frame)
+
+        frame_idx += 1
+        
+        # Update progress
+        if progress_callback and total_frames > 0:
+            progress = min(frame_idx / total_frames, 1.0)
+            progress_callback(progress, f"Processing frame {frame_idx}/{total_frames}")
+
+    # Cleanup
+    cap.release()
+    out.release()
+    
+    # Calculate final jump metrics
+    jump_metrics = estimate_jump_metrics(hip_y_series, fps, user_weight_kg)
+    
+    print(f"Annotated video saved: {output_path}")
+    
+    return {
+        "output_video_path": output_path,
+        "jump_metrics": jump_metrics,
+        "jump_references": jump_references,
+        "total_frames_processed": frame_idx,
+        "knee_strain_detected": any(analyze_knee_strain(None, h)["strain_detected"] for _ in range(5)) # Simplified check
+    }
+
+
 def process_video_analysis(video_path, user_height_cm, user_weight_kg=75.0, progress_callback=None):
     """Core video analysis function with progress tracking.
     
@@ -404,6 +718,114 @@ def analyze_video_file(video_path, user_height_cm, user_weight_kg=75.0, progress
         return {"error": f"Error during analysis: {str(e)}"}
 
 
+def generate_annotated_video_from_youtube(youtube_url, user_height_cm, user_weight_kg, gender, progress_callback=None):
+    """Generate annotated video from YouTube URL."""
+    
+    # Validate inputs
+    if not youtube_url or not youtube_url.strip():
+        return {"error": "Please provide a YouTube URL"}
+    
+    if not user_height_cm or user_height_cm <= 0:
+        return {"error": "Please provide a valid height in centimeters"}
+    
+    try:
+        if progress_callback:
+            progress_callback(0.1, "Downloading YouTube video...")
+        
+        # Validate YouTube URL
+        youtube_url = youtube_url.strip()
+        if not any(domain in youtube_url for domain in ['youtube.com', 'youtu.be']):
+            return {"error": "Please provide a valid YouTube URL"}
+        
+        # Create temporary directory for processing
+        with tempfile.TemporaryDirectory() as temp_dir:
+            if progress_callback:
+                progress_callback(0.2, "Downloading video from YouTube...")
+            
+            # Download video
+            video_filename = os.path.join(temp_dir, 'video.%(ext)s')
+            try:
+                download_youtube_video(youtube_url, video_filename)
+                # Find the actual downloaded file
+                video_files = [f for f in os.listdir(temp_dir) if f.startswith('video.')]
+                if not video_files:
+                    return {"error": "Failed to download YouTube video. Please check the URL and try again."}
+                video_path = os.path.join(temp_dir, video_files[0])
+            except Exception as e:
+                return {"error": f"Failed to download YouTube video: {str(e)}"}
+
+            if progress_callback:
+                progress_callback(0.3, "Generating annotated video...")
+            
+            # Generate output path in temp directory
+            output_path = os.path.join(temp_dir, "annotated_output.mp4")
+            
+            # Process the video with progress tracking
+            def update_progress(prog, desc):
+                if progress_callback:
+                    progress_callback(0.3 + (prog * 0.6), desc)
+            
+            result = generate_annotated_video(
+                video_path, user_height_cm, user_weight_kg, gender, 
+                output_path, update_progress
+            )
+            
+            if progress_callback:
+                progress_callback(0.95, "Finalizing annotated video...")
+            
+            # Move the output file to a permanent location
+            final_output = f"annotated_jump_analysis_{Path(youtube_url).stem}.mp4"
+            if os.path.exists(output_path):
+                # In production, you'd save this to a proper storage location
+                result["output_video_path"] = output_path
+                result["download_ready"] = True
+            
+            if progress_callback:
+                progress_callback(1.0, "Annotated video generation complete!")
+            
+            return result
+            
+    except Exception as e:
+        return {"error": f"Error during video generation: {str(e)}"}
+
+
+def generate_annotated_video_from_file(video_file_path, user_height_cm, user_weight_kg, gender, progress_callback=None):
+    """Generate annotated video from uploaded file."""
+    
+    # Validate inputs
+    if not video_file_path:
+        return {"error": "Please provide a video file"}
+    
+    if not user_height_cm or user_height_cm <= 0:
+        return {"error": "Please provide a valid height in centimeters"}
+    
+    try:
+        if progress_callback:
+            progress_callback(0.1, "Processing uploaded video...")
+        
+        # Generate output path
+        video_name = Path(video_file_path).stem
+        output_path = f"{video_name}_annotated.mp4"
+        
+        # Process the video with progress tracking
+        def update_progress(prog, desc):
+            if progress_callback:
+                progress_callback(0.1 + (prog * 0.8), desc)
+        
+        result = generate_annotated_video(
+            video_file_path, user_height_cm, user_weight_kg, gender,
+            output_path, update_progress
+        )
+        
+        if progress_callback:
+            progress_callback(1.0, "Annotated video generation complete!")
+        
+        return result
+        
+    except Exception as e:
+        return {"error": f"Error during video generation: {str(e)}"}
+
+
 def get_performance_insights(result_dict):
     """Generate performance insights based on comprehensive jump metrics.