Upload 9 files

app.py

@@ -4,7 +4,8 @@ import os
 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
+    generate_annotated_video_from_youtube, generate_annotated_video_from_file,
+    generate_complete_analysis_with_video
 )
 
 def analyze_jump_from_youtube(youtube_url, user_height_cm, user_weight_kg, progress=gr.Progress()):
@@ -62,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:
@@ -99,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
@@ -141,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:
@@ -396,6 +397,139 @@ 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():
     with gr.Blocks(title="🏃‍♂️ Athletic Ability Analysis") as app:
@@ -411,25 +545,25 @@ def create_interface():
         - **🎬 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
-           - **🤖 AI Sports Coach**: Personalized recommendations and sport suggestions  
-           - **🎬 Video Generation**: Create annotated training videos with visual overlays
+           - **📊 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, actionable insights, or downloadable training videos
+        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)",
@@ -458,34 +592,48 @@ def create_interface():
                 )
                 file_btn = gr.Button("🚀 Analyze Uploaded Video", variant="primary")
             
-            # AI Coaching Tab
-            with gr.TabItem("🤖 AI Sports Coach"):
+            # Complete Analysis Tab  
+            with gr.TabItem("🎬 Complete Analysis + AI Coach"):
                 gr.Markdown("""
-                ## 🤖 AI-Powered Sports Coaching Analysis
+                ## 🎬 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
                 
-                Get personalized sports recommendations and jump technique improvement suggestions from our AI sports coach powered by Google Gemini.
+                ### 🤖 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
                 
-                **What you'll get:**
-                - 🏆 **Recommended Sports** (top 3 that match your athletic profile)
-                - 🎯 **Jump Technique Analysis** with specific improvement suggestions
-                - 📊 **Personalized Training Recommendations**
+                ### 📺 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():
-                        ai_gender = gr.Radio(
+                        complete_gender = gr.Radio(
                             choices=["Male", "Female"],
                             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", "")
-                        ai_gemini_key = gr.Textbox(
-                            label="Gemini API Key",
-                            placeholder="Enter your Google Gemini API key" if not default_api_key else "API key loaded from environment",
+                        complete_gemini_key = gr.Textbox(
+                            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
                         )
+                        
                         with gr.Row():
                             test_api_btn = gr.Button("🧪 Test API Key", size="sm")
                         
@@ -499,60 +647,21 @@ def create_interface():
                         gr.Markdown("""
                         💡 **Get your free API key**: [Google AI Studio](https://aistudio.google.com/app/apikey)
                         
-                        📱 **Privacy**: Your API key is only used for this analysis and not stored.
+                        ⚠️ **Note**: Video generation works without API key, but AI coaching requires one
                         """)
                     
                     with gr.Column():
-                        ai_youtube_url = gr.Textbox(
-                            label="YouTube URL (Optional)",
-                            placeholder="https://youtube.com/watch?v=..."
-                        )
-                        ai_video_file = gr.File(
-                            label="Upload Video File (Optional)",
-                            file_types=[".mp4", ".avi", ".mov", ".mkv", ".webm"]
-                        )
-                        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(
+                        complete_youtube_url = gr.Textbox(
                             label="YouTube URL (Option 1)",
                             placeholder="https://youtube.com/watch?v=..."
                         )
-                        video_file_upload = gr.File(
+                        complete_video_file = 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")
+                complete_analysis_btn = gr.Button("🚀 Get Complete Analysis + Video", variant="primary", size="lg")
         
         # Results section
         gr.Markdown("## 📊 Analysis Results")
@@ -567,6 +676,14 @@ def create_interface():
                     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
@@ -609,10 +726,25 @@ def create_interface():
             outputs=[results_text, results_table, status_message]
         )
         
-        ai_coaching_btn.click(
-            fn=get_ai_coaching_recommendations,
-            inputs=[ai_youtube_url, ai_video_file, user_height, user_weight, ai_gender, ai_gemini_key],
-            outputs=[results_text, results_table, status_message]
+        # Complete analysis with video streaming
+        def complete_analysis_with_video_display(youtube_url, video_file, user_height_cm, user_weight_kg, gender, gemini_api_key, progress=gr.Progress()):
+            # Get the complete analysis
+            results_text_output, summary_df, video_path, status = complete_analysis_with_video_stream(
+                youtube_url, video_file, user_height_cm, user_weight_kg, gender, gemini_api_key, progress
+            )
+            
+            # Update video component visibility and content
+            if video_path and os.path.exists(video_path):
+                video_update = gr.update(value=video_path, visible=True)
+            else:
+                video_update = gr.update(visible=False)
+            
+            return results_text_output, summary_df, video_update, status
+        
+        complete_analysis_btn.click(
+            fn=complete_analysis_with_video_display,
+            inputs=[complete_youtube_url, complete_video_file, user_height, user_weight, complete_gender, complete_gemini_key],
+            outputs=[results_text, results_table, analysis_video, status_message]
         )
         
         # API key test handler
@@ -622,23 +754,10 @@ def create_interface():
         
         test_api_btn.click(
             fn=test_and_show_result,
-            inputs=[ai_gemini_key],
+            inputs=[complete_gemini_key],
             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

@@ -826,6 +826,102 @@ def generate_annotated_video_from_file(video_file_path, user_height_cm, user_wei
         return {"error": f"Error during video generation: {str(e)}"}
 
 
+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.
+    
+    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_callback:
+            progress_callback(0.1, "Starting comprehensive analysis...")
+        
+        def video_progress(prog, desc):
+            if progress_callback:
+                progress_callback(0.1 + (prog * 0.4), f"Video: {desc}")
+        
+        # Generate annotated video
+        if video_source == "youtube":
+            video_result = generate_annotated_video_from_youtube(
+                video_path_or_url, user_height_cm, user_weight_kg, gender, video_progress
+            )
+        else:
+            video_result = generate_annotated_video_from_file(
+                video_path_or_url, user_height_cm, user_weight_kg, gender, video_progress
+            )
+        
+        if "error" in video_result:
+            return video_result
+        
+        # Phase 2: AI Sports Coaching Analysis (30% of progress)
+        if progress_callback:
+            progress_callback(0.5, "Generating AI sports coaching analysis...")
+        
+        ai_result = None
+        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,
+                gender=gender,
+                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=api_key
+            )
+            
+            if progress_callback:
+                progress_callback(0.8, "AI analysis complete!")
+        
+        # Phase 3: Combine results (20% of progress)
+        if progress_callback:
+            progress_callback(0.9, "Finalizing comprehensive analysis...")
+        
+        jump_metrics = video_result.get("jump_metrics", {})
+        jump_references = video_result.get("jump_references", {})
+        
+        # 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"
+        }
+        
+        if progress_callback:
+            progress_callback(1.0, "Complete analysis ready!")
+        
+        return result
+        
+    except Exception as e:
+        return {"error": f"Error during complete analysis: {str(e)}"}
+
+
 def get_performance_insights(result_dict):
     """Generate performance insights based on comprehensive jump metrics.