Upload 9 files

app.py

@@ -1,186 +1,26 @@
-import cv2
-import numpy as np
-import mediapipe as mp
-from collections import deque
-from pathlib import Path
-import json
-import tempfile
-import os
-import yt_dlp
 import gradio as gr
 import pandas as pd
-
-LHIP, RHIP = 23, 24
-POSE_CONNECTIONS = mp.solutions.pose.POSE_CONNECTIONS
-
-def smooth_moving_avg(series, k=5):
-    """Simple causal moving average; ignores None values."""
-    out = []
-    q = deque()
-    s = 0.0
-    cnt = 0
-    for v in series:
-        if v is not None:
-            q.append(v); s += v; cnt += 1
-        else:
-            q.append(None)
-        if len(q) > k:
-            old = q.popleft()
-            if old is not None:
-                s -= old; cnt -= 1
-        out.append((s / max(cnt, 1)) if cnt > 0 else None)
-    return out
-
-def estimate_jump_metrics(hip_y_series, fps):
-    """Return jump_height_norm (0..1), flight_time_s using hip trajectory."""
-    # Remove None
-    hip = [h for h in hip_y_series if h is not None]
-    if len(hip) < 3:
-        return None, None
-
-    # Smooth
-    hip = smooth_moving_avg(hip, k=5)
-
-    # Jump height (normalized): deepest crouch (max y) to apex (min y)
-    min_y = min(hip)  # apex (body highest)
-    max_y = max(hip)  # deepest crouch (body lowest)
-    jump_height_norm = max(0.0, (max_y - min_y))
-
-    # Flight time heuristic using vertical velocity pattern
-    hip_arr = np.array(hip, dtype=float)
-    vel = np.diff(hip_arr)
-    if vel.size == 0:
-        flight_time_s = 0.0
-    else:
-        takeoff_idx = int(np.argmin(vel))   # most negative velocity
-        landing_idx = int(np.argmax(vel))   # most positive velocity
-        flight_frames = max(0, landing_idx - takeoff_idx)
-        flight_time_s = flight_frames / float(fps or 30.0)
-
-    return jump_height_norm, flight_time_s
-
-def download_youtube_video(youtube_url, output_path):
-    """Download YouTube video to specified path."""
-    ydl_opts = {
-        'format': 'best[height<=720]',  # Limit quality for faster processing
-        'outtmpl': output_path,
-        'quiet': True,
-        'no_warnings': True,
-    }
-    
-    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-        ydl.download([youtube_url])
-    return output_path
-
-def process_video_analysis(video_path, user_height_cm, progress_callback=None):
-    """Core video analysis function with progress tracking."""
-    cap = cv2.VideoCapture(video_path)
-    if not cap.isOpened():
-        raise Exception(f"Could not open video: {video_path}")
-
-    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))
-
-    mp_pose = mp.solutions.pose
-    pose = mp_pose.Pose(static_image_mode=False, model_complexity=1, enable_segmentation=False)
-
-    hip_y_series = []
-    frame_idx = 0
-
-    print(f"Processing video: {Path(video_path).name}")
-    print(f"Video dimensions: {w}x{h}, FPS: {fps}, Total frames: {total_frames}")
-
-    ok, frame = cap.read()
-    while ok:
-        rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-        res = pose.process(rgb)
-
-        if res.pose_landmarks:
-            lms = res.pose_landmarks.landmark
-            mid_hip_y = (lms[LHIP].y + lms[RHIP].y) / 2.0
-            hip_y_series.append(float(mid_hip_y))
-        else:
-            hip_y_series.append(None)
-
-        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}")
-        
-        ok, frame = cap.read()
-
-    cap.release()
-    print(f"Completed processing {frame_idx} frames")
-
-    jump_norm, flight_time_s = estimate_jump_metrics(hip_y_series, fps)
-
-    if jump_norm is None:
-        return None
-
-    jump_height_cm = jump_norm * user_height_cm
-
-    return {
-        "video": Path(video_path).name,
-        "frames": len(hip_y_series),
-        "fps": fps,
-        "jump_height_cm": jump_height_cm,
-        "normalized_rise": jump_norm,
-        "flight_time_s": flight_time_s
-    }
+from athletic_performance import analyze_youtube_video, analyze_video_file, get_performance_insights
 
 def analyze_jump_from_youtube(youtube_url, user_height_cm, progress=gr.Progress()):
     """Main analysis function for Gradio interface."""
     
-    # Validate inputs
-    if not youtube_url or not youtube_url.strip():
-        return "❌ Please provide a YouTube URL", None, None
+    # Create progress callback for the athletic_performance module
+    def progress_callback(prog, desc):
+        progress(prog, desc=desc)
     
-    if not user_height_cm or user_height_cm <= 0:
-        return "❌ Please provide a valid height in centimeters", None, None
+    # Call the core analysis function
+    result = analyze_youtube_video(youtube_url, user_height_cm, progress_callback)
     
-    try:
-        progress(0.1, desc="Validating YouTube URL...")
-        
-        # Validate YouTube URL
-        youtube_url = youtube_url.strip()
-        if not any(domain in youtube_url for domain in ['youtube.com', 'youtu.be']):
-            return "❌ Please provide a valid YouTube URL", None, None
-        
-        # Create temporary directory for processing
-        with tempfile.TemporaryDirectory() as temp_dir:
-            progress(0.2, desc="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 "❌ Failed to download YouTube video. Please check the URL and try again.", None, None
-                video_path = os.path.join(temp_dir, video_files[0])
-            except Exception as e:
-                return f"❌ Failed to download YouTube video: {str(e)}", None, None
-
-            progress(0.3, desc="Starting video analysis...")
-            
-            # Process the video with progress tracking
-            def update_progress(prog, desc):
-                progress(0.3 + (prog * 0.6), desc=desc)
-            
-            result = process_video_analysis(video_path, user_height_cm, update_progress)
-            
-            progress(0.9, desc="Generating results...")
-            
-            if result is None:
-                return "⚠️ Could not analyze jump. Make sure the video shows a person clearly performing a vertical jump.", None, None
-            
-            # Format results for display
-            results_text = f"""
+    # Handle errors
+    if "error" in result:
+        return f"❌ {result['error']}", None, None, None
+    
+    if result is None:
+        return "⚠️ Could not analyze jump. Make sure the video shows a person clearly performing a vertical jump.", None, None, None
+    
+    # Format results for display
+    results_text = f"""
 ## 🎉 Jump Analysis Results
 
 ### 📊 Performance Metrics
@@ -195,64 +35,54 @@ def analyze_jump_from_youtube(youtube_url, user_height_cm, progress=gr.Progress(
 
 ### 📈 Performance Insights
 """
-            
-            # Add performance insights
-            if result['jump_height_cm'] > 60:
-                results_text += "🔥 **Excellent jump height!** This is above average performance.\n"
-            elif result['jump_height_cm'] > 40:
-                results_text += "👍 **Good jump height!** Solid athletic performance.\n"
-            elif result['jump_height_cm'] > 25:
-                results_text += "📈 **Moderate jump height.** Room for improvement with training.\n"
-            else:
-                results_text += "🎯 **Starting point identified.** Focus on technique and strength training.\n"
-            
-            if result['flight_time_s'] > 0.5:
-                results_text += "⏱️ **Great flight time!** Shows good explosive power.\n"
-            elif result['flight_time_s'] > 0.3:
-                results_text += "⏱️ **Decent flight time.** Good coordination.\n"
-            
-            # Create a results dataframe for the table
-            results_df = pd.DataFrame([
-                ["Jump Height", f"{result['jump_height_cm']:.2f} cm"],
-                ["Flight Time", f"{result['flight_time_s']:.3f} seconds"],
-                ["Normalized Rise", f"{result['normalized_rise']*100:.1f}%"],
-                ["Video Frames", f"{result['frames']}"],
-                ["Frame Rate", f"{result['fps']:.2f} FPS"],
-            ], columns=["Metric", "Value"])
-            
-            progress(1.0, desc="Analysis complete!")
-            
-            return results_text, results_df, "✅ Analysis completed successfully!"
-            
-    except Exception as e:
-        return f"❌ Error during analysis: {str(e)}", None, None
+    
+    # Add performance insights using the new function
+    insights = get_performance_insights(result['jump_height_cm'], result['flight_time_s'])
+    for insight in insights:
+        results_text += f"{insight}\n"
+    
+    # Add technique analysis insights
+    results_text += f"""
+### 🎯 Technique Analysis
+- **Knee Position**: Analyzed for valgus and injury prevention
+- **Shoulder Position**: Evaluated overhead squat mechanics
+- **Movement Quality**: Real-time feedback on form
+"""
+    
+    # Create a results dataframe for the table
+    results_df = pd.DataFrame([
+        ["Jump Height", f"{result['jump_height_cm']:.2f} cm"],
+        ["Flight Time", f"{result['flight_time_s']:.3f} seconds"],
+        ["Normalized Rise", f"{result['normalized_rise']*100:.1f}%"],
+        ["Video Frames", f"{result['frames']}"],
+        ["Frame Rate", f"{result['fps']:.2f} FPS"],
+    ], columns=["Metric", "Value"])
+    
+    # Return overlay video if available
+    overlay_video = result.get('overlay_video', None)
+    
+    return results_text, results_df, overlay_video, "✅ Analysis completed successfully!"
 
 def analyze_jump_from_file(video_file, user_height_cm, progress=gr.Progress()):
     """Analysis function for uploaded video files."""
     
-    # Validate inputs
-    if video_file is None:
-        return "❌ Please upload a video file", None, None
+    # Create progress callback for the athletic_performance module
+    def progress_callback(prog, desc):
+        progress(prog, desc=desc)
     
-    if not user_height_cm or user_height_cm <= 0:
-        return "❌ Please provide a valid height in centimeters", None, None
+    # Call the core analysis function
+    video_path = video_file.name if video_file else None
+    result = analyze_video_file(video_path, user_height_cm, progress_callback)
     
-    try:
-        progress(0.1, desc="Processing uploaded video...")
-        
-        # Process the video with progress tracking
-        def update_progress(prog, desc):
-            progress(0.1 + (prog * 0.8), desc=desc)
-        
-        result = process_video_analysis(video_file.name, user_height_cm, update_progress)
-        
-        progress(0.9, desc="Generating results...")
-        
-        if result is None:
-            return "⚠️ Could not analyze jump. Make sure the video shows a person clearly performing a vertical jump.", None, None
-        
-        # Format results (same as YouTube function)
-        results_text = f"""
+    # Handle errors
+    if "error" in result:
+        return f"❌ {result['error']}", None, None, None
+    
+    if result is None:
+        return "⚠️ Could not analyze jump. Make sure the video shows a person clearly performing a vertical jump.", None, None, None
+    
+    # Format results (same as YouTube function)
+    results_text = f"""
 ## 🎉 Jump Analysis Results
 
 ### 📊 Performance Metrics
@@ -267,37 +97,33 @@ def analyze_jump_from_file(video_file, user_height_cm, progress=gr.Progress()):
 
 ### 📈 Performance Insights
 """
-        
-        # Add performance insights
-        if result['jump_height_cm'] > 60:
-            results_text += "🔥 **Excellent jump height!** This is above average performance.\n"
-        elif result['jump_height_cm'] > 40:
-            results_text += "👍 **Good jump height!** Solid athletic performance.\n"
-        elif result['jump_height_cm'] > 25:
-            results_text += "📈 **Moderate jump height.** Room for improvement with training.\n"
-        else:
-            results_text += "🎯 **Starting point identified.** Focus on technique and strength training.\n"
-        
-        if result['flight_time_s'] > 0.5:
-            results_text += "⏱️ **Great flight time!** Shows good explosive power.\n"
-        elif result['flight_time_s'] > 0.3:
-            results_text += "⏱️ **Decent flight time.** Good coordination.\n"
-        
-        # Create a results dataframe for the table
-        results_df = pd.DataFrame([
-            ["Jump Height", f"{result['jump_height_cm']:.2f} cm"],
-            ["Flight Time", f"{result['flight_time_s']:.3f} seconds"],
-            ["Normalized Rise", f"{result['normalized_rise']*100:.1f}%"],
-            ["Video Frames", f"{result['frames']}"],
-            ["Frame Rate", f"{result['fps']:.2f} FPS"],
-        ], columns=["Metric", "Value"])
-        
-        progress(1.0, desc="Analysis complete!")
-        
-        return results_text, results_df, "✅ Analysis completed successfully!"
-        
-    except Exception as e:
-        return f"❌ Error during analysis: {str(e)}", None, None
+    
+    # Add performance insights using the new function
+    insights = get_performance_insights(result['jump_height_cm'], result['flight_time_s'])
+    for insight in insights:
+        results_text += f"{insight}\n"
+    
+    # Add technique analysis insights
+    results_text += f"""
+### 🎯 Technique Analysis
+- **Knee Position**: Analyzed for valgus and injury prevention
+- **Shoulder Position**: Evaluated overhead squat mechanics
+- **Movement Quality**: Real-time feedback on form
+"""
+    
+    # Create a results dataframe for the table
+    results_df = pd.DataFrame([
+        ["Jump Height", f"{result['jump_height_cm']:.2f} cm"],
+        ["Flight Time", f"{result['flight_time_s']:.3f} seconds"],
+        ["Normalized Rise", f"{result['normalized_rise']*100:.1f}%"],
+        ["Video Frames", f"{result['frames']}"],
+        ["Frame Rate", f"{result['fps']:.2f} FPS"],
+    ], columns=["Metric", "Value"])
+    
+    # Return overlay video if available
+    overlay_video = result.get('overlay_video', None)
+    
+    return results_text, results_df, overlay_video, "✅ Analysis completed successfully!"
 
 # Create Gradio interface
 def create_interface():
@@ -308,11 +134,17 @@ def create_interface():
         Analyze jumping performance from videos using computer vision and pose estimation.
         Upload a video or provide a YouTube URL to get detailed metrics about jump height, flight time, and athletic performance.
         
+        ## 🆕 New Features
+        - **🎥 Video Overlays**: Watch your movement with real-time technique analysis
+        - **🦵 Knee Injury Prevention**: Detect knee valgus and movement patterns
+        - **💪 Shoulder Position Analysis**: Evaluate overhead squat mechanics
+        - **📊 Performance Insights**: Get personalized coaching feedback
+        
         ## 📋 Instructions
         1. Enter your height in centimeters
         2. Choose either YouTube URL or file upload
         3. Wait for the analysis to complete
-        4. View your detailed jump performance results
+        4. View your detailed jump performance results and technique analysis video
         """)
         
         with gr.Row():
@@ -356,6 +188,16 @@ def create_interface():
                     datatype=["str", "str"]
                 )
         
+        # Video output section
+        gr.Markdown("## 🎥 Technique Analysis Video")
+        gr.Markdown("📹 *Watch your movement with real-time technique feedback overlays*")
+        
+        overlay_video = gr.Video(
+            label="Analysis Video with Overlays",
+            interactive=False,
+            info="Video showing pose landmarks and technique analysis"
+        )
+        
         status_message = gr.Textbox(label="Status", interactive=False)
         
         # Video requirements
@@ -379,19 +221,23 @@ def create_interface():
            - Jump height relative to your body size
            - Flight time during the airborne phase
            - Normalized rise showing jump efficiency
+        4. **Technique Analysis**: Real-time movement assessment:
+           - Knee position analysis for injury prevention
+           - Shoulder position for overhead squat mechanics
+           - Visual overlays with color-coded feedback
         """)
         
         # Event handlers
         youtube_btn.click(
             fn=analyze_jump_from_youtube,
             inputs=[youtube_url, user_height],
-            outputs=[results_text, results_table, status_message]
+            outputs=[results_text, results_table, overlay_video, status_message]
         )
         
         file_btn.click(
             fn=analyze_jump_from_file,
             inputs=[video_file, user_height],
-            outputs=[results_text, results_table, status_message]
+            outputs=[results_text, results_table, overlay_video, status_message]
         )
         
         # Example section

athletic_performance.py

@@ -0,0 +1,430 @@
+import cv2
+import numpy as np
+import mediapipe as mp
+from collections import deque
+from pathlib import Path
+import tempfile
+import os
+import yt_dlp
+
+# MediaPipe pose landmarks
+LHIP, RHIP = 23, 24
+LANKLE, RANKLE = 27, 28
+LKNEEL, RKNEEL = 25, 26
+LSHOULDER, RSHOULDER = 11, 12
+LELBOW, RELBOW = 13, 14
+LWRIST, RWRIST = 15, 16
+POSE_CONNECTIONS = mp.solutions.pose.POSE_CONNECTIONS
+
+
+def smooth_moving_avg(series, k=5):
+    """Simple causal moving average; ignores None values."""
+    out = []
+    q = deque()
+    s = 0.0
+    cnt = 0
+    for v in series:
+        if v is not None:
+            q.append(v)
+            s += v
+            cnt += 1
+        else:
+            q.append(None)
+        if len(q) > k:
+            old = q.popleft()
+            if old is not None:
+                s -= old
+                cnt -= 1
+        out.append((s / max(cnt, 1)) if cnt > 0 else None)
+    return out
+
+
+def estimate_jump_metrics(hip_y_series, fps):
+    """Return jump_height_norm (0..1), flight_time_s using hip trajectory."""
+    # Remove None
+    hip = [h for h in hip_y_series if h is not None]
+    if len(hip) < 3:
+        return None, None
+
+    # Smooth
+    hip = smooth_moving_avg(hip, k=5)
+
+    # Jump height (normalized): deepest crouch (max y) to apex (min y)
+    min_y = min(hip)  # apex (body highest)
+    max_y = max(hip)  # deepest crouch (body lowest)
+    jump_height_norm = max(0.0, (max_y - min_y))
+
+    # Flight time heuristic using vertical velocity pattern
+    hip_arr = np.array(hip, dtype=float)
+    vel = np.diff(hip_arr)
+    if vel.size == 0:
+        flight_time_s = 0.0
+    else:
+        takeoff_idx = int(np.argmin(vel))   # most negative velocity
+        landing_idx = int(np.argmax(vel))   # most positive velocity
+        flight_frames = max(0, landing_idx - takeoff_idx)
+        flight_time_s = flight_frames / float(fps or 30.0)
+
+    return jump_height_norm, flight_time_s
+
+
+def download_youtube_video(youtube_url, output_path):
+    """Download YouTube video to specified path."""
+    ydl_opts = {
+        'format': 'best[height<=720]',  # Limit quality for faster processing
+        'outtmpl': output_path,
+        'quiet': True,
+        'no_warnings': True,
+    }
+    
+    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+        ydl.download([youtube_url])
+    return output_path
+
+
+def process_video_analysis(video_path, user_height_cm, progress_callback=None, generate_overlay_video=True):
+    """Core video analysis function with progress tracking and overlay video generation.
+    
+    Args:
+        video_path (str): Path to the video file
+        user_height_cm (float): User's height in centimeters
+        progress_callback (callable, optional): Function to call with progress updates
+            Signature: progress_callback(progress_float, description_string)
+        generate_overlay_video (bool): Whether to generate overlay video with technique analysis
+    
+    Returns:
+        dict: Analysis results containing jump metrics, video info, and overlay video path
+        None: If analysis failed
+    """
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        raise Exception(f"Could not open video: {video_path}")
+
+    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))
+
+    mp_pose = mp.solutions.pose
+    pose = mp_pose.Pose(static_image_mode=False, model_complexity=1, enable_segmentation=False)
+
+    hip_y_series = []
+    frame_idx = 0
+    
+    # Setup video writer for overlay video
+    overlay_video_path = None
+    out = None
+    if generate_overlay_video:
+        overlay_video_path = str(Path(video_path).parent / f"overlay_{Path(video_path).name}")
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        out = cv2.VideoWriter(overlay_video_path, fourcc, fps, (w, h))
+
+    print(f"Processing video: {Path(video_path).name}")
+    print(f"Video dimensions: {w}x{h}, FPS: {fps}, Total frames: {total_frames}")
+
+    ok, frame = cap.read()
+    while ok:
+        rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        res = pose.process(rgb)
+
+        if res.pose_landmarks:
+            lms = res.pose_landmarks.landmark
+            mid_hip_y = (lms[LHIP].y + lms[RHIP].y) / 2.0
+            hip_y_series.append(float(mid_hip_y))
+            
+            # Generate overlay frame with technique analysis
+            if generate_overlay_video and out:
+                overlay_frame = draw_technique_overlay(frame.copy(), res.pose_landmarks, h, w)
+                out.write(overlay_frame)
+        else:
+            hip_y_series.append(None)
+            
+            # Write original frame if no pose detected
+            if generate_overlay_video and out:
+                out.write(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}")
+        
+        ok, frame = cap.read()
+
+    cap.release()
+    if out:
+        out.release()
+    
+    print(f"Completed processing {frame_idx} frames")
+
+    jump_norm, flight_time_s = estimate_jump_metrics(hip_y_series, fps)
+
+    if jump_norm is None:
+        return None
+
+    jump_height_cm = jump_norm * user_height_cm
+
+    result = {
+        "video": Path(video_path).name,
+        "frames": len(hip_y_series),
+        "fps": fps,
+        "jump_height_cm": jump_height_cm,
+        "normalized_rise": jump_norm,
+        "flight_time_s": flight_time_s
+    }
+    
+    if generate_overlay_video and overlay_video_path:
+        result["overlay_video"] = overlay_video_path
+    
+    return result
+
+
+def analyze_youtube_video(youtube_url, user_height_cm, progress_callback=None):
+    """Analyze jump from YouTube video.
+    
+    Args:
+        youtube_url (str): YouTube video URL
+        user_height_cm (float): User's height in centimeters
+        progress_callback (callable, optional): Function to call with progress updates
+    
+    Returns:
+        dict: Analysis results or error information
+    """
+    # 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, "Validating YouTube URL...")
+        
+        # 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, "Starting video analysis...")
+            
+            # Process the video with progress tracking
+            def update_progress(prog, desc):
+                if progress_callback:
+                    progress_callback(0.3 + (prog * 0.6), desc)
+            
+            result = process_video_analysis(video_path, user_height_cm, update_progress)
+            
+            if progress_callback:
+                progress_callback(0.9, "Analysis complete!")
+            
+            return result
+            
+    except Exception as e:
+        return {"error": f"Error during analysis: {str(e)}"}
+
+
+def analyze_video_file(video_path, user_height_cm, progress_callback=None):
+    """Analyze jump from video file.
+    
+    Args:
+        video_path (str): Path to video file
+        user_height_cm (float): User's height in centimeters
+        progress_callback (callable, optional): Function to call with progress updates
+    
+    Returns:
+        dict: Analysis results or error information
+    """
+    # Validate inputs
+    if not video_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 video file...")
+        
+        # Process the video with progress tracking
+        def update_progress(prog, desc):
+            if progress_callback:
+                progress_callback(0.1 + (prog * 0.8), desc)
+        
+        result = process_video_analysis(video_path, user_height_cm, update_progress)
+        
+        if progress_callback:
+            progress_callback(1.0, "Analysis complete!")
+        
+        return result
+        
+    except Exception as e:
+        return {"error": f"Error during analysis: {str(e)}"}
+
+
+def analyze_knee_position(landmarks, frame_height, frame_width):
+    """Analyze knee position for injury prevention."""
+    if not landmarks:
+        return None, "No pose detected"
+    
+    lms = landmarks.landmark
+    
+    # Get knee and ankle positions
+    lknee = (int(lms[LKNEEL].x * frame_width), int(lms[LKNEEL].y * frame_height))
+    rknee = (int(lms[RKNEEL].x * frame_width), int(lms[RKNEEL].y * frame_height))
+    lankle = (int(lms[LANKLE].x * frame_width), int(lms[LANKLE].y * frame_height))
+    rankle = (int(lms[RANKLE].x * frame_width), int(lms[RANKLE].y * frame_height))
+    
+    # Calculate knee angle (simplified)
+    knee_angle_l = calculate_angle(lankle, lknee, lms[LHIP])
+    knee_angle_r = calculate_angle(rankle, rknee, lms[RHIP])
+    
+    feedback = []
+    color = (0, 255, 0)  # Green by default
+    
+    # Check for knee valgus (knee caving in)
+    if knee_angle_l < 160 or knee_angle_r < 160:
+        feedback.append("⚠️ Knee valgus detected - risk of injury")
+        color = (0, 0, 255)  # Red
+    elif knee_angle_l < 170 or knee_angle_r < 170:
+        feedback.append("💡 Keep knees tracking over toes")
+        color = (0, 165, 255)  # Orange
+    
+    return color, feedback
+
+def analyze_shoulder_position(landmarks, frame_height, frame_width):
+    """Analyze shoulder position and overhead squat mechanics."""
+    if not landmarks:
+        return None, "No pose detected"
+    
+    lms = landmarks.landmark
+    
+    # Get shoulder, elbow, and wrist positions
+    lshoulder = (int(lms[LSHOULDER].x * frame_width), int(lms[LSHOULDER].y * frame_height))
+    rshoulder = (int(lms[RSHOULDER].x * frame_width), int(lms[RSHOULDER].y * frame_height))
+    lwrist = (int(lms[LWRIST].x * frame_width), int(lms[LWRIST].y * frame_height))
+    rwrist = (int(lms[RWRIST].x * frame_width), int(lms[RWRIST].y * frame_height))
+    
+    feedback = []
+    color = (0, 255, 0)  # Green by default
+    
+    # Check if arms are overhead (OHS position)
+    shoulder_y = (lshoulder[1] + rshoulder[1]) / 2
+    wrist_y = (lwrist[1] + rwrist[1]) / 2
+    
+    if wrist_y < shoulder_y - 50:  # Arms significantly overhead
+        feedback.append("✅ Good overhead position")
+        color = (0, 255, 0)  # Green
+    elif wrist_y < shoulder_y:
+        feedback.append("💡 Arms overhead - good OHS position")
+        color = (0, 255, 255)  # Yellow
+    else:
+        feedback.append("⚠️ Arms not overhead - improve shoulder mobility")
+        color = (0, 0, 255)  # Red
+    
+    return color, feedback
+
+def calculate_angle(point1, point2, point3):
+    """Calculate angle between three points."""
+    # Convert MediaPipe landmark to tuple if needed
+    if hasattr(point3, 'x'):
+        point3 = (int(point3.x * 1000), int(point3.y * 1000))  # Scale for calculation
+    
+    # Calculate vectors
+    v1 = np.array(point1) - np.array(point2)
+    v2 = np.array(point3) - np.array(point2)
+    
+    # Calculate angle
+    cos_angle = np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))
+    cos_angle = np.clip(cos_angle, -1.0, 1.0)
+    angle = np.arccos(cos_angle)
+    
+    return np.degrees(angle)
+
+def draw_technique_overlay(frame, landmarks, frame_height, frame_width):
+    """Draw technique analysis overlay on frame."""
+    if not landmarks:
+        return frame
+    
+    # Analyze knee position
+    knee_color, knee_feedback = analyze_knee_position(landmarks, frame_height, frame_width)
+    
+    # Analyze shoulder position
+    shoulder_color, shoulder_feedback = analyze_shoulder_position(landmarks, frame_height, frame_width)
+    
+    # Draw pose landmarks
+    mp_drawing = mp.solutions.drawing_utils
+    mp_drawing.draw_landmarks(frame, landmarks, mp.solutions.pose.POSE_CONNECTIONS)
+    
+    # Draw knee analysis
+    lms = landmarks.landmark
+    lknee = (int(lms[LKNEEL].x * frame_width), int(lms[LKNEEL].y * frame_height))
+    rknee = (int(lms[RKNEEL].x * frame_width), int(lms[RKNEEL].y * frame_height))
+    
+    cv2.circle(frame, lknee, 8, knee_color, -1)
+    cv2.circle(frame, rknee, 8, knee_color, -1)
+    
+    # Draw shoulder analysis
+    lshoulder = (int(lms[LSHOULDER].x * frame_width), int(lms[LSHOULDER].y * frame_height))
+    rshoulder = (int(lms[RSHOULDER].x * frame_width), int(lms[RSHOULDER].y * frame_height))
+    
+    cv2.circle(frame, lshoulder, 8, shoulder_color, -1)
+    cv2.circle(frame, rshoulder, 8, shoulder_color, -1)
+    
+    # Add text feedback
+    y_offset = 30
+    for feedback in knee_feedback + shoulder_feedback:
+        cv2.putText(frame, feedback, (10, y_offset), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
+        cv2.putText(frame, feedback, (10, y_offset), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 1)
+        y_offset += 30
+    
+    return frame
+
+def get_performance_insights(jump_height_cm, flight_time_s):
+    """Generate performance insights based on jump metrics.
+    
+    Args:
+        jump_height_cm (float): Jump height in centimeters
+        flight_time_s (float): Flight time in seconds
+    
+    Returns:
+        list: List of insight strings
+    """
+    insights = []
+    
+    # Jump height insights
+    if jump_height_cm > 60:
+        insights.append("🔥 **Excellent jump height!** This is above average performance.")
+    elif jump_height_cm > 40:
+        insights.append("👍 **Good jump height!** Solid athletic performance.")
+    elif jump_height_cm > 25:
+        insights.append("📈 **Moderate jump height.** Room for improvement with training.")
+    else:
+        insights.append("🎯 **Starting point identified.** Focus on technique and strength training.")
+    
+    # Flight time insights
+    if flight_time_s > 0.5:
+        insights.append("⏱️ **Great flight time!** Shows good explosive power.")
+    elif flight_time_s > 0.3:
+        insights.append("⏱️ **Decent flight time.** Good coordination.")
+    
+    return insights