Upload 10 files

app.py

@@ -5,7 +5,7 @@ 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,
-    complete_analysis_with_video_stream
+    generate_complete_analysis_with_video
 )
 
 def analyze_jump_from_youtube(youtube_url, user_height_cm, user_weight_kg, progress=gr.Progress()):
@@ -63,7 +63,7 @@ def analyze_jump_from_youtube(youtube_url, user_height_cm, user_weight_kg, progr
 
 ### 📈 Performance Insights
 """
-    
+            
     # Add performance insights using the new function
     insights = get_performance_insights(result)
     for insight in insights:
@@ -100,11 +100,11 @@ def analyze_jump_from_file(video_file, user_height_cm, user_weight_kg, progress=
     # Handle errors
     if "error" in result:
         return f"❌ {result['error']}", 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
-    
-    # Format results (same as YouTube function)
+        
+        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)
     # Handle potential None values safely
     jump_height = result.get('jump_height_cm', 0) or 0
     flight_time = result.get('flight_time_s', 0) or 0
@@ -142,7 +142,7 @@ def analyze_jump_from_file(video_file, user_height_cm, user_weight_kg, progress=
 
 ### 📈 Performance Insights
 """
-    
+        
     # Add performance insights using the new function
     insights = get_performance_insights(result)
     for insight in insights:
@@ -397,95 +397,173 @@ Your annotated video is ready for download!
     return results_text, summary_df, video_path
 
 
+def complete_analysis_with_video_stream(youtube_url, video_file, user_height_cm, user_weight_kg, gender, gemini_api_key, progress=gr.Progress()):
+    """Complete analysis with AI coaching and video streaming."""
+    
+    # Validate inputs
+    if not user_height_cm or user_height_cm <= 0:
+        return "❌ Please provide a valid height", None, None, None
+    
+    if not user_weight_kg or user_weight_kg <= 0:
+        return "❌ Please provide a valid weight", None, None, None
+    
+    if not gender:
+        return "❌ Please select your gender", None, None, None
+    
+    # Determine video source and path
+    video_source = None
+    video_path_or_url = None
+    
+    if youtube_url and youtube_url.strip():
+        video_source = "youtube"
+        video_path_or_url = youtube_url.strip()
+        progress(0.05, desc="Processing YouTube video...")
+    elif video_file:
+        video_source = "file"
+        video_path_or_url = video_file.name
+        progress(0.05, desc="Processing uploaded video...")
+    else:
+        return "❌ Please provide either a YouTube URL or upload a video file", None, None, None
+    
+    try:
+        # Create progress callback
+        def progress_callback(prog, desc):
+            progress(prog, desc=desc)
+        
+        # Run complete analysis
+        result = generate_complete_analysis_with_video(
+            video_source=video_source,
+            video_path_or_url=video_path_or_url,
+            user_height_cm=user_height_cm,
+            user_weight_kg=user_weight_kg,
+            gender=gender,
+            api_key=gemini_api_key.strip() if gemini_api_key else None,
+            progress_callback=progress_callback
+        )
+        
+        # Handle errors
+        if "error" in result:
+            return f"❌ Analysis failed: {result['error']}", None, None, None
+        
+        if not result.get("success"):
+            return "❌ Analysis failed. Please ensure the video shows a clear vertical jump.", None, None, None
+        
+        # Extract results
+        video_path = result.get("video_path")
+        jump_metrics = result.get("jump_metrics", {})
+        jump_references = result.get("jump_references", {})
+        ai_coaching = result.get("ai_coaching")
+        
+        # Handle potential None values safely
+        jump_height = jump_metrics.get('jump_height_cm', 0) or 0
+        flight_time = jump_metrics.get('flight_time_s', 0) or 0
+        peak_power = jump_metrics.get('peak_power_watts', 0) or 0
+        rfd = jump_metrics.get('rate_of_force_development', 0) or 0
+        
+        # Format comprehensive results
+        results_text = f"""
+# 🎬 Complete Athletic Performance Analysis
+
+## 📊 Performance Metrics
+- **Jump Height**: {jump_height:.2f} cm
+- **Relative Jump**: {(jump_height/user_height_cm*100):.1f}% of body height
+- **Flight Time**: {flight_time:.3f} seconds
+- **Peak Power**: {peak_power:.0f} watts
+- **Rate of Force Development**: {rfd:.2f}
+
+## 📏 Performance Comparison
+- **Your Performance**: {jump_height:.1f} cm
+- **Average for {gender}**: {jump_references.get('average', 0):.1f} cm
+- **Professional Level**: {jump_references.get('professional', 0):.1f} cm
+
+## 🎥 Video Analysis Features
+- ✅ **Real-time Pose Tracking**: Skeleton overlay throughout jump
+- ✅ **Performance Reference Lines**: Average vs Professional benchmarks  
+- ✅ **Knee Strain Detection**: Automatic form analysis with warnings
+- ✅ **Live Metrics Display**: Frame-by-frame jump height tracking
+
+"""
+        
+        # Add AI coaching analysis if available
+        if ai_coaching and ai_coaching.get("success"):
+            results_text += f"""
+## 🤖 AI Sports Coach Analysis
+
+{ai_coaching.get('analysis', 'AI analysis not available')}
+
+---
+*Analysis powered by Google Gemini AI*
+"""
+        elif gemini_api_key:
+            results_text += """
+## 🤖 AI Sports Coach Analysis
+
+❌ AI coaching analysis failed. Please check your API key and try again.
+"""
+        else:
+            results_text += """
+## 🤖 AI Sports Coach Analysis
+
+💡 **Provide a Gemini API key to get personalized sports recommendations and technique improvements!**
+
+Get your free API key at: [Google AI Studio](https://aistudio.google.com/app/apikey)
+"""
+        
+        # Create comprehensive summary dataframe
+        summary_data = [
+            ["Jump Height", f"{jump_height:.2f} cm"],
+            ["Flight Time", f"{flight_time:.3f} seconds"],
+            ["Peak Power", f"{peak_power:.0f} watts"],
+            ["Rate of Force Development", f"{rfd:.2f}"],
+            ["Performance vs Average", f"{((jump_height/jump_references.get('average', 1))*100):.0f}%"],
+            ["Performance vs Pro", f"{((jump_height/jump_references.get('professional', 1))*100):.0f}%"],
+            ["Video Features", "Pose + References + Strain Detection"],
+            ["AI Coaching", "✅ Included" if ai_coaching and ai_coaching.get("success") else "❌ Not Available"],
+        ]
+        
+        summary_df = pd.DataFrame(summary_data, columns=["Metric", "Value"])
+        
+        # Return results with video for streaming
+        return results_text, summary_df, video_path, "✅ Complete analysis ready!"
+        
+    except Exception as e:
+        return f"❌ Unexpected error: {str(e)}", None, None, None
+
+
 # Create Gradio interface
 def create_interface():
-    # Custom CSS for dark theme with green accents
-    custom_css = """
-    .gradio-container {
-        background: linear-gradient(135deg, #0a0a0a 0%, #1a1a1a 100%) !important;
-        color: #00ff88 !important;
-    }
-    .gr-button {
-        background: linear-gradient(45deg, #00ff88, #00cc6a) !important;
-        border: none !important;
-        color: #000 !important;
-        font-weight: bold !important;
-        border-radius: 8px !important;
-        transition: all 0.3s ease !important;
-    }
-    .gr-button:hover {
-        transform: translateY(-2px) !important;
-        box-shadow: 0 6px 20px rgba(0, 255, 136, 0.3) !important;
-    }
-    .gr-textbox, .gr-file, .gr-number {
-        background: #222 !important;
-        border: 1px solid #00ff88 !important;
-        color: #fff !important;
-        border-radius: 8px !important;
-    }
-    .gr-markdown {
-        color: #e0e0e0 !important;
-    }
-    .gr-markdown h1 {
-        color: #00ff88 !important;
-        text-shadow: 0 0 10px rgba(0, 255, 136, 0.5) !important;
-        text-align: center !important;
-    }
-    .gr-markdown h2 {
-        color: #00cc6a !important;
-    }
-    .gr-radio label {
-        background: #222 !important;
-        border: 1px solid #555 !important;
-        border-radius: 8px !important;
-        color: #fff !important;
-    }
-    .gr-radio label:checked {
-        background: #00ff88 !important;
-        color: #000 !important;
-    }
-    .gr-tab {
-        background: #333 !important;
-        border: 1px solid #00ff88 !important;
-        border-radius: 8px 8px 0 0 !important;
-        color: #fff !important;
-    }
-    .gr-tab.selected {
-        background: linear-gradient(45deg, #00ff88, #00cc6a) !important;
-        color: #000 !important;
-    }
-    .gr-dataframe {
-        background: #222 !important;
-        border: 1px solid #00ff88 !important;
-        border-radius: 8px !important;
-    }
-    .gr-video {
-        border: 2px solid #00ff88 !important;
-        border-radius: 12px !important;
-        box-shadow: 0 0 20px rgba(0, 255, 136, 0.3) !important;
-        background: #111 !important;
-    }
-    .gr-form {
-        background: #1a1a1a !important;
-        border-radius: 12px !important;
-        padding: 20px !important;
-    }
-    """
-    
-    with gr.Blocks(title="🚀 Athletic Performance AI", css=custom_css, theme=gr.themes.Soft()) as app:
+    with gr.Blocks(title="🏃‍♂️ Athletic Ability Analysis") as app:
         gr.Markdown("""
-        # 🚀 Athletic Performance AI
-        **Advanced jump analysis with AI coaching & pose tracking**
+        # 🏃‍♂️ Athletic Ability Analysis & AI Sports Coach
+        
+        Analyze jumping performance from videos using computer vision and get AI-powered sports coaching recommendations.
+        Upload a video or provide a YouTube URL to get detailed metrics and personalized coaching insights.
+        
+        ## 🚀 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
+        - **📺 Video Streaming**: Watch your annotated analysis video directly in the browser
+        
+        ## 📋 Instructions
+        1. Enter your height in centimeters and weight in kilograms
+        2. Choose your analysis type: 
+           - **📊 Standard Analysis**: Get detailed biomechanical metrics only
+           - **🎬 Complete Analysis**: Get annotated video + AI coaching + streaming (Recommended!)
+        3. Provide a video (YouTube URL or file upload)
+        4. Get comprehensive results with video streaming and AI coaching insights
         """)
         
         with gr.Row():
             with gr.Column():
                 user_height = gr.Number(
-                    label="Your Height (cm)",
-                    value=175,
-                    minimum=100,
-                    maximum=250
-                )
+                label="Your Height (cm)",
+                value=175,
+                minimum=100,
+                maximum=250
+            )
             with gr.Column():
                 user_weight = gr.Number(
                     label="Your Weight (kg)",
@@ -493,27 +571,50 @@ def create_interface():
                     minimum=30,
                     maximum=200
                 )
+        gr.Markdown("💡 *Enter your height and weight for accurate biomechanical calculations*")
         
         with gr.Tabs():
             # YouTube URL Tab
-            with gr.TabItem("🎥 YouTube"):
+            with gr.TabItem("🎥 YouTube Video"):
+                gr.Markdown("📺 *Paste a YouTube URL containing a video of someone jumping*")
                 youtube_url = gr.Textbox(
                     label="YouTube URL",
                     placeholder="https://youtube.com/watch?v=..."
                 )
-                youtube_btn = gr.Button("🚀 Analyze", variant="primary")
+                youtube_btn = gr.Button("🚀 Analyze YouTube Video", variant="primary")
             
             # File Upload Tab
-            with gr.TabItem("📁 Upload"):
+            with gr.TabItem("📁 Upload Video"):
+                gr.Markdown("📁 *Upload a video file showing someone performing a jump*")
                 video_file = gr.File(
-                    label="Upload Video",
+                    label="Upload Video File",
                     file_types=[".mp4", ".avi", ".mov", ".mkv", ".webm"]
                 )
-                file_btn = gr.Button("🚀 Analyze", variant="primary")
+                file_btn = gr.Button("🚀 Analyze Uploaded Video", variant="primary")
             
             # Complete Analysis Tab  
-            with gr.TabItem("🎬 AI Coach + Video"):
-                gr.Markdown("**🤖 AI coaching + 🎥 annotated video + 📊 pose tracking**")
+            with gr.TabItem("🎬 Complete Analysis + AI Coach"):
+                gr.Markdown("""
+                ## 🎬 Complete Athletic Performance Analysis
+                
+                Get the ultimate training analysis combining:
+                
+                ### 🎥 Annotated Training Video
+                - **🦴 Real-time Pose Tracking**: Skeleton overlay throughout jump
+                - **📏 Performance Reference Lines**: Average vs Professional benchmarks
+                - **⚠️ Knee Strain Detection**: Automatic form analysis with red warnings
+                - **📊 Live Metrics Display**: Frame-by-frame jump height tracking
+                
+                ### 🤖 AI Sports Coach Analysis  
+                - **🏆 Sport Recommendations**: Top 3 sports matching your athletic profile
+                - **🎯 Technique Improvements**: Specific jump form corrections
+                - **📈 Training Insights**: Personalized performance enhancement tips
+                
+                ### 📺 Video Streaming
+                - **Watch directly in browser**: No downloads required
+                - **Professional annotations**: Training-ready video output
+                - **Shareable results**: Perfect for coaches and athletes
+                """)
                 
                 with gr.Row():
                     with gr.Column():
@@ -522,58 +623,96 @@ def create_interface():
                             label="Gender",
                             value="Male"
                         )
+                        gr.Markdown("*Used for performance references and AI analysis*")
                         
+                        # Check if API key is available in environment
                         default_api_key = os.getenv("GEMINI_API_KEY", "")
                         complete_gemini_key = gr.Textbox(
-                            label="Gemini API Key (Optional)",
-                            placeholder="Enter API key for AI coaching" if not default_api_key else "API key loaded",
+                            label="Gemini API Key (Optional for AI Coaching)",
+                            placeholder="Enter your Google Gemini API key for AI coaching" if not default_api_key else "API key loaded from environment",
                             type="password",
                             value=default_api_key
                         )
                         
-                        test_api_btn = gr.Button("🧪 Test", size="sm")
+                        with gr.Row():
+                            test_api_btn = gr.Button("🧪 Test API Key", size="sm")
+                        
                         api_test_result = gr.Textbox(
-                            label="Test Result",
-                            lines=2,
+                            label="API Test Result",
+                            lines=3,
                             interactive=False,
                             visible=False
                         )
+                        
+                        gr.Markdown("""
+                        💡 **Get your free API key**: [Google AI Studio](https://aistudio.google.com/app/apikey)
+                        
+                        ⚠️ **Note**: Video generation works without API key, but AI coaching requires one
+                        """)
                     
                     with gr.Column():
                         complete_youtube_url = gr.Textbox(
-                            label="YouTube URL",
+                            label="YouTube URL (Option 1)",
                             placeholder="https://youtube.com/watch?v=..."
                         )
                         complete_video_file = gr.File(
-                            label="Or Upload Video",
+                            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*")
                 
-                complete_analysis_btn = gr.Button("🚀 Generate Analysis + Video", variant="primary", size="lg")
+                complete_analysis_btn = gr.Button("🚀 Get Complete Analysis + Video", variant="primary", size="lg")
         
         # Results section
-        gr.Markdown("## 📊 Results")
-        
-        # Video streaming section - make it prominent
-        with gr.Row():
-            analysis_video = gr.Video(
-                label="📺 Analysis Video",
-                visible=False,
-                height=400
-            )
+        gr.Markdown("## 📊 Analysis Results")
         
         with gr.Row():
             with gr.Column(scale=2):
-                results_text = gr.Markdown(label="Analysis")
+                results_text = gr.Markdown(label="Results")
             with gr.Column(scale=1):
                 results_table = gr.Dataframe(
-                    label="Metrics",
+                    label="Metrics Summary",
                     headers=["Metric", "Value"],
                     datatype=["str", "str"]
                 )
         
+        # Video streaming section
+        with gr.Row():
+            with gr.Column():
+                analysis_video = gr.Video(
+                    label="📺 Annotated Training Video",
+                    visible=False
+                )
+        
         status_message = gr.Textbox(label="Status", interactive=False)
         
+        # Video requirements
+        gr.Markdown("""
+        ## 📝 Video Requirements
+        
+        For best results, ensure your videos meet these criteria:
+        
+        - **Full body visible**: The person should be completely visible in the frame
+        - **Clear movement**: Good lighting and minimal background clutter  
+        - **Vertical jumps**: Works best with straight vertical jumps
+        - **Duration**: 3-30 seconds is optimal
+        - **Quality**: Higher quality videos produce better results
+        - **Public videos**: For YouTube, ensure the video is not private
+        
+        ## 🔬 How it Works
+        
+        1. **Pose Detection**: Uses Google's MediaPipe to detect human pose landmarks
+        2. **Hip Tracking**: Tracks the midpoint between left and right hip joints
+        3. **Biomechanical Analysis**: Calculates comprehensive metrics based on hip trajectory:
+           - **Jump Height**: Relative to your body size
+           - **Flight Time**: Duration in the air
+           - **Peak Power Output**: Maximum power generated during takeoff
+           - **Rate of Force Development (RFD)**: Speed of force generation
+           - **Ground Contact Time**: Efficiency in stretch-shortening cycle
+           - **Impulse & Peak Force**: Force characteristics during takeoff
+           - **Takeoff Phase Duration**: Time from crouch to launch
+        """)
+        
         # Event handlers
         youtube_btn.click(
             fn=analyze_jump_from_youtube,
@@ -618,6 +757,15 @@ def create_interface():
             inputs=[complete_gemini_key],
             outputs=[api_test_result]
         )
+        
+        # Example section
+        gr.Examples(
+            examples=[
+                ["https://www.youtube.com/watch?v=dQw4w9WgXcQ", 175, 75],  # This is just a placeholder
+            ],
+            inputs=[youtube_url, user_height, user_weight],
+            label="📚 Example (Replace with actual jump video URLs)"
+        )
     
     return app
 

athletic_performance.py

@@ -9,7 +9,6 @@ import yt_dlp
 import json
 import requests
 import math
-import pandas as pd
 
 # MediaPipe pose landmarks
 LHIP, RHIP = 23, 24
@@ -827,44 +826,31 @@ def generate_annotated_video_from_file(video_file_path, user_height_cm, user_wei
         return {"error": f"Error during video generation: {str(e)}"}
 
 
-def complete_analysis_with_video_stream(youtube_url, video_file, user_height_cm, user_weight_kg, gender, gemini_api_key, progress=None):
-    """Complete analysis with AI coaching and video streaming."""
+def generate_complete_analysis_with_video(video_source, video_path_or_url, user_height_cm, user_weight_kg, gender, api_key=None, progress_callback=None):
+    """
+    Complete analysis combining annotated video generation + AI sports coaching.
     
-    # Validate inputs
-    if not user_height_cm or user_height_cm <= 0:
-        return "❌ Please provide a valid height", None, None, None
-    
-    if not user_weight_kg or user_weight_kg <= 0:
-        return "❌ Please provide a valid weight", None, None, None
-    
-    if not gender:
-        return "❌ Please select your gender", None, None, None
-    
-    # Determine video source and path
-    video_source = None
-    video_path_or_url = None
-    
-    if youtube_url and youtube_url.strip():
-        video_source = "youtube"
-        video_path_or_url = youtube_url.strip()
-        if progress:
-            progress(0.05, desc="Processing YouTube video...")
-    elif video_file:
-        video_source = "file"
-        video_path_or_url = video_file.name
-        if progress:
-            progress(0.05, desc="Processing uploaded video...")
-    else:
-        return "❌ Please provide either a YouTube URL or upload a video file", None, None, None
+    Args:
+        video_source (str): "youtube" or "file"
+        video_path_or_url (str): YouTube URL or file path
+        user_height_cm (float): User's height in centimeters
+        user_weight_kg (float): User's weight in kilograms
+        gender (str): "Male" or "Female"
+        api_key (str, optional): Gemini API key for AI coaching
+        progress_callback (callable, optional): Progress tracking function
+    
+    Returns:
+        dict: Complete analysis with video path, AI coaching, and metrics
+    """
     
     try:
         # Phase 1: Generate annotated video (50% of progress)
-        if progress:
-            progress(0.1, desc="Starting video generation...")
+        if progress_callback:
+            progress_callback(0.1, "Starting comprehensive analysis...")
         
         def video_progress(prog, desc):
-            if progress:
-                progress(0.1 + (prog * 0.4), desc=f"Video: {desc}")
+            if progress_callback:
+                progress_callback(0.1 + (prog * 0.4), f"Video: {desc}")
         
         # Generate annotated video
         if video_source == "youtube":
@@ -877,16 +863,20 @@ def complete_analysis_with_video_stream(youtube_url, video_file, user_height_cm,
             )
         
         if "error" in video_result:
-            return f"❌ Video generation failed: {video_result['error']}", None, None, None
+            return video_result
         
         # Phase 2: AI Sports Coaching Analysis (30% of progress)
-        if progress:
-            progress(0.5, desc="Generating AI sports coaching analysis...")
+        if progress_callback:
+            progress_callback(0.5, "Generating AI sports coaching analysis...")
         
         ai_result = None
-        if gemini_api_key:
+        if api_key:
             jump_metrics = video_result.get("jump_metrics", {})
             
+            def ai_progress(prog, desc):
+                if progress_callback:
+                    progress_callback(0.5 + (prog * 0.3), f"AI: {desc}")
+            
             ai_result = get_ai_sports_coaching_analysis(
                 jump_height_cm=jump_metrics.get('jump_height_cm', 0),
                 user_height_cm=user_height_cm,
@@ -894,97 +884,42 @@ def complete_analysis_with_video_stream(youtube_url, video_file, user_height_cm,
                 peak_power_watts=jump_metrics.get('peak_power_watts'),
                 flight_time_s=jump_metrics.get('flight_time_s'),
                 rfd=jump_metrics.get('rate_of_force_development'),
-                api_key=gemini_api_key
+                api_key=api_key
             )
             
-            if progress:
-                progress(0.8, desc="AI analysis complete!")
+            if progress_callback:
+                progress_callback(0.8, "AI analysis complete!")
         
         # Phase 3: Combine results (20% of progress)
-        if progress:
-            progress(0.9, desc="Finalizing comprehensive analysis...")
+        if progress_callback:
+            progress_callback(0.9, "Finalizing comprehensive analysis...")
         
         jump_metrics = video_result.get("jump_metrics", {})
         jump_references = video_result.get("jump_references", {})
         
-        # Handle potential None values safely
-        jump_height = jump_metrics.get('jump_height_cm', 0) or 0
-        flight_time = jump_metrics.get('flight_time_s', 0) or 0
-        peak_power = jump_metrics.get('peak_power_watts', 0) or 0
-        rfd = jump_metrics.get('rate_of_force_development', 0) or 0
-        
-        # Format comprehensive results
-        results_text = f"""
-# 🎬 Complete Athletic Performance Analysis
-
-## 📊 Performance Metrics
-- **Jump Height**: {jump_height:.2f} cm
-- **Relative Jump**: {(jump_height/user_height_cm*100):.1f}% of body height
-- **Flight Time**: {flight_time:.3f} seconds
-- **Peak Power**: {peak_power:.0f} watts
-- **Rate of Force Development**: {rfd:.2f}
-
-## 📏 Performance Comparison
-- **Your Performance**: {jump_height:.1f} cm
-- **Average for {gender}**: {jump_references.get('average', 0):.1f} cm
-- **Professional Level**: {jump_references.get('professional', 0):.1f} cm
-
-## 🎥 Video Analysis Features
-- ✅ **Real-time Pose Tracking**: Skeleton overlay throughout jump
-- ✅ **Performance Reference Lines**: Average vs Professional benchmarks  
-- ✅ **Knee Strain Detection**: Automatic form analysis with warnings
-- ✅ **Live Metrics Display**: Frame-by-frame jump height tracking
-
-"""
-        
-        # Add AI coaching analysis if available
-        if ai_result and ai_result.get("success"):
-            results_text += f"""
-## 🤖 AI Sports Coach Analysis
-
-{ai_result.get('analysis', 'AI analysis not available')}
-
----
-*Analysis powered by Google Gemini AI*
-"""
-        elif gemini_api_key:
-            results_text += """
-## 🤖 AI Sports Coach Analysis
-
-❌ AI coaching analysis failed. Please check your API key and try again.
-"""
-        else:
-            results_text += """
-## 🤖 AI Sports Coach Analysis
-
-💡 **Provide a Gemini API key to get personalized sports recommendations and technique improvements!**
-
-Get your free API key at: [Google AI Studio](https://aistudio.google.com/app/apikey)
-"""
-        
-        # Create comprehensive summary dataframe
-        summary_data = [
-            ["Jump Height", f"{jump_height:.2f} cm"],
-            ["Flight Time", f"{flight_time:.3f} seconds"],
-            ["Peak Power", f"{peak_power:.0f} watts"],
-            ["Rate of Force Development", f"{rfd:.2f}"],
-            ["Performance vs Average", f"{((jump_height/jump_references.get('average', 1))*100):.0f}%"],
-            ["Performance vs Pro", f"{((jump_height/jump_references.get('professional', 1))*100):.0f}%"],
-            ["Video Features", "Pose + References + Strain Detection"],
-            ["AI Coaching", "✅ Included" if ai_result and ai_result.get("success") else "❌ Not Available"],
-        ]
-        
-        summary_df = pd.DataFrame(summary_data, columns=["Metric", "Value"])
+        # Create comprehensive result
+        result = {
+            "success": True,
+            "video_path": video_result.get("output_video_path"),
+            "jump_metrics": jump_metrics,
+            "jump_references": jump_references,
+            "ai_coaching": ai_result if ai_result and "error" not in ai_result else None,
+            "video_features": {
+                "pose_tracking": True,
+                "reference_lines": True,
+                "knee_strain_detection": True,
+                "live_metrics": True
+            },
+            "analysis_type": "complete_with_video"
+        }
         
-        # Return results with video for streaming
-        video_path = video_result.get("output_video_path")
-        if progress:
-            progress(1.0, desc="Complete analysis ready!")
+        if progress_callback:
+            progress_callback(1.0, "Complete analysis ready!")
         
-        return results_text, summary_df, video_path, "✅ Complete analysis ready!"
+        return result
         
     except Exception as e:
-        return f"❌ Unexpected error: {str(e)}", None, None, None
+        return {"error": f"Error during complete analysis: {str(e)}"}
 
 
 def get_performance_insights(result_dict):