Spaces:
Runtime error
Runtime error
| 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, | |
| 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.""" | |
| # Create progress callback for the athletic_performance module | |
| def progress_callback(prog, desc): | |
| progress(prog, desc=desc) | |
| # Call the core analysis function | |
| result = analyze_youtube_video(youtube_url, user_height_cm, user_weight_kg, progress_callback) | |
| # 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 for display | |
| # 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 | |
| normalized_rise = result.get('normalized_rise', 0) or 0 | |
| peak_power = result.get('peak_power_watts', 0) or 0 | |
| peak_force = result.get('peak_force_n', 0) or 0 | |
| impulse = result.get('impulse_ns', 0) or 0 | |
| rfd = result.get('rate_of_force_development', 0) or 0 | |
| takeoff_duration = result.get('takeoff_phase_duration_s', 0) or 0 | |
| ground_contact = result.get('ground_contact_time_s', 0) or 0 | |
| results_text = f""" | |
| ## 🎉 Comprehensive Jump Analysis Results | |
| ### 📊 Core Performance Metrics | |
| - **Jump Height**: {jump_height:.2f} cm | |
| - **Flight Time**: {flight_time:.3f} seconds | |
| - **Normalized Rise**: {normalized_rise:.3f} ({normalized_rise*100:.1f}%) | |
| ### ⚡ Power & Force Metrics | |
| - **Peak Power Output**: {peak_power:.0f} watts | |
| - **Peak Force**: {peak_force:.0f} N | |
| - **Impulse**: {impulse:.2f} N⋅s | |
| ### 🚀 Explosiveness Metrics | |
| - **Rate of Force Development**: {rfd:.2f} | |
| - **Takeoff Phase Duration**: {takeoff_duration:.3f} seconds | |
| - **Ground Contact Time**: {ground_contact:.3f} seconds | |
| ### 📹 Video Information | |
| - **Total Frames**: {result['frames']} | |
| - **Frame Rate**: {result['fps']:.2f} FPS | |
| - **Video File**: {result['video']} | |
| - **Subject Weight**: {result.get('user_weight_kg', 'N/A')} kg | |
| ### 📈 Performance Insights | |
| """ | |
| # Add performance insights using the new function | |
| insights = get_performance_insights(result) | |
| for insight in insights: | |
| results_text += f"{insight}\n" | |
| # Create a comprehensive results dataframe for the table | |
| results_df = pd.DataFrame([ | |
| ["Jump Height", f"{jump_height:.2f} cm"], | |
| ["Flight Time", f"{flight_time:.3f} seconds"], | |
| ["Peak Power", f"{peak_power:.0f} watts"], | |
| ["Peak Force", f"{peak_force:.0f} N"], | |
| ["Rate of Force Development", f"{rfd:.2f}"], | |
| ["Ground Contact Time", f"{ground_contact:.3f} seconds"], | |
| ["Impulse", f"{impulse:.2f} N⋅s"], | |
| ["Takeoff Duration", f"{takeoff_duration:.3f} seconds"], | |
| ["Normalized Rise", f"{normalized_rise*100:.1f}%"], | |
| ["Video Frames", f"{result.get('frames', 0)}"], | |
| ["Frame Rate", f"{result.get('fps', 0):.2f} FPS"], | |
| ], columns=["Metric", "Value"]) | |
| return results_text, results_df, "✅ Analysis completed successfully!" | |
| def analyze_jump_from_file(video_file, user_height_cm, user_weight_kg, progress=gr.Progress()): | |
| """Analysis function for uploaded video files.""" | |
| # Create progress callback for the athletic_performance module | |
| def progress_callback(prog, desc): | |
| progress(prog, desc=desc) | |
| # Call the core analysis function | |
| video_path = video_file.name if video_file else None | |
| result = analyze_video_file(video_path, user_height_cm, user_weight_kg, progress_callback) | |
| # 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) | |
| # 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 | |
| normalized_rise = result.get('normalized_rise', 0) or 0 | |
| peak_power = result.get('peak_power_watts', 0) or 0 | |
| peak_force = result.get('peak_force_n', 0) or 0 | |
| impulse = result.get('impulse_ns', 0) or 0 | |
| rfd = result.get('rate_of_force_development', 0) or 0 | |
| takeoff_duration = result.get('takeoff_phase_duration_s', 0) or 0 | |
| ground_contact = result.get('ground_contact_time_s', 0) or 0 | |
| results_text = f""" | |
| ## 🎉 Comprehensive Jump Analysis Results | |
| ### 📊 Core Performance Metrics | |
| - **Jump Height**: {jump_height:.2f} cm | |
| - **Flight Time**: {flight_time:.3f} seconds | |
| - **Normalized Rise**: {normalized_rise:.3f} ({normalized_rise*100:.1f}%) | |
| ### ⚡ Power & Force Metrics | |
| - **Peak Power Output**: {peak_power:.0f} watts | |
| - **Peak Force**: {peak_force:.0f} N | |
| - **Impulse**: {impulse:.2f} N⋅s | |
| ### 🚀 Explosiveness Metrics | |
| - **Rate of Force Development**: {rfd:.2f} | |
| - **Takeoff Phase Duration**: {takeoff_duration:.3f} seconds | |
| - **Ground Contact Time**: {ground_contact:.3f} seconds | |
| ### 📹 Video Information | |
| - **Total Frames**: {result['frames']} | |
| - **Frame Rate**: {result['fps']:.2f} FPS | |
| - **Video File**: {result['video']} | |
| - **Subject Weight**: {result.get('user_weight_kg', 'N/A')} kg | |
| ### 📈 Performance Insights | |
| """ | |
| # Add performance insights using the new function | |
| insights = get_performance_insights(result) | |
| for insight in insights: | |
| results_text += f"{insight}\n" | |
| # Create a comprehensive results dataframe for the table | |
| results_df = pd.DataFrame([ | |
| ["Jump Height", f"{jump_height:.2f} cm"], | |
| ["Flight Time", f"{flight_time:.3f} seconds"], | |
| ["Peak Power", f"{peak_power:.0f} watts"], | |
| ["Peak Force", f"{peak_force:.0f} N"], | |
| ["Rate of Force Development", f"{rfd:.2f}"], | |
| ["Ground Contact Time", f"{ground_contact:.3f} seconds"], | |
| ["Impulse", f"{impulse:.2f} N⋅s"], | |
| ["Takeoff Duration", f"{takeoff_duration:.3f} seconds"], | |
| ["Normalized Rise", f"{normalized_rise*100:.1f}%"], | |
| ["Video Frames", f"{result.get('frames', 0)}"], | |
| ["Frame Rate", f"{result.get('fps', 0):.2f} FPS"], | |
| ], columns=["Metric", "Value"]) | |
| return results_text, results_df, "✅ Analysis completed successfully!" | |
| def get_ai_coaching_recommendations(youtube_url, video_file, user_height_cm, user_weight_kg, gender, favorite_sports, gemini_api_key, progress=gr.Progress()): | |
| """Get AI-powered sports coaching recommendations.""" | |
| # Validate inputs | |
| if not gemini_api_key or not gemini_api_key.strip(): | |
| return "❌ Please provide your Gemini API key", None, None | |
| if not gender: | |
| return "❌ Please select your gender", None, None | |
| if not user_height_cm or user_height_cm <= 0: | |
| return "❌ Please provide a valid height", None, None | |
| # Validate favorite sports | |
| if not favorite_sports or len(favorite_sports) == 0: | |
| return "❌ Please select at least one favorite sport", None, None | |
| if len(favorite_sports) > 5: | |
| return "❌ Please select maximum 5 favorite sports", None, None | |
| # Determine which video source to use | |
| video_source = None | |
| if youtube_url and youtube_url.strip(): | |
| video_source = "youtube" | |
| progress(0.1, desc="Analyzing YouTube video...") | |
| elif video_file: | |
| video_source = "file" | |
| progress(0.1, desc="Analyzing uploaded video...") | |
| else: | |
| return "❌ Please provide either a YouTube URL or upload a video file", None, None | |
| try: | |
| # First, get the jump analysis | |
| progress(0.2, desc="Performing biomechanical analysis...") | |
| def progress_callback(prog, desc): | |
| progress(0.2 + (prog * 0.5), desc=desc) | |
| if video_source == "youtube": | |
| result = analyze_youtube_video(youtube_url, user_height_cm, user_weight_kg, progress_callback) | |
| else: | |
| video_path = video_file.name if video_file else None | |
| result = analyze_video_file(video_path, user_height_cm, user_weight_kg, progress_callback) | |
| # Handle analysis errors | |
| if "error" in result: | |
| return f"❌ Video analysis failed: {result['error']}", None, None | |
| if result is None: | |
| return "❌ Could not analyze jump. Please ensure the video shows a clear vertical jump.", None, None | |
| progress(0.7, desc="Getting AI coaching analysis...") | |
| # Get AI coaching analysis | |
| ai_result = get_ai_sports_coaching_analysis( | |
| jump_height_cm=result['jump_height_cm'], | |
| user_height_cm=user_height_cm, | |
| gender=gender, | |
| favorite_sports=favorite_sports, | |
| peak_power_watts=result.get('peak_power_watts'), | |
| flight_time_s=result.get('flight_time_s'), | |
| rfd=result.get('rate_of_force_development'), | |
| api_key=gemini_api_key.strip() | |
| ) | |
| progress(0.9, desc="Formatting results...") | |
| if "error" in ai_result: | |
| return f"❌ AI analysis failed: {ai_result['error']}", None, None | |
| # Format the comprehensive results | |
| # 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 | |
| peak_power = result.get('peak_power_watts', 0) or 0 | |
| # Format favorite sports list for display | |
| sports_display = ", ".join(favorite_sports) | |
| results_text = f""" | |
| # 🤖 AI Sports Coaching Analysis | |
| ## 📊 Performance Summary | |
| - **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 | |
| - **Gender**: {gender} | |
| - **Height**: {user_height_cm} cm | |
| - **Favorite Sports**: {sports_display} | |
| ## 🏆 AI Expert Coaching Analysis | |
| **📊 Performance Percentiles:** | |
| {chr(10).join([f"- **{sport}**: {percentile}th percentile" for sport, percentile in ai_result.get('analysis', {}).get('sports', {}).items()])} | |
| **💡 Improvement Tips:** | |
| {chr(10).join([f"{i+1}. {tip}" for i, tip in enumerate(ai_result.get('analysis', {}).get('tips', []))])} | |
| --- | |
| *Analysis powered by Google Gemini AI* | |
| """ | |
| # Create summary dataframe | |
| rfd = result.get('rate_of_force_development', 0) or 0 | |
| summary_df = pd.DataFrame([ | |
| ["Jump Height", f"{jump_height:.2f} cm"], | |
| ["Relative Jump Height", f"{(jump_height/user_height_cm*100):.1f}%"], | |
| ["Flight Time", f"{flight_time:.3f} seconds"], | |
| ["Peak Power", f"{peak_power:.0f} watts"], | |
| ["Rate of Force Development", f"{rfd:.2f}"], | |
| ["Gender", gender], | |
| ["Height", f"{user_height_cm} cm"], | |
| ["Weight", f"{user_weight_kg} kg"], | |
| ["Favorite Sports", sports_display], | |
| ], columns=["Metric", "Value"]) | |
| progress(1.0, desc="AI coaching analysis complete!") | |
| return results_text, summary_df, "✅ AI coaching analysis completed!" | |
| except Exception as e: | |
| return f"❌ Unexpected error: {str(e)}", None, None | |
| def test_api_key(api_key): | |
| """Test the API key connection.""" | |
| if not api_key or not api_key.strip(): | |
| return "❌ Please provide an API key to test" | |
| result = test_gemini_api_connection(api_key.strip()) | |
| if result["success"]: | |
| return f"✅ API Key is working! Status: {result['status_code']}\n\nResponse preview: {result['response_text'][:100]}..." | |
| 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: | |
| gr.Markdown(""" | |
| # 🏃♂️ 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 | |
| ## 📋 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 | |
| 3. Provide a video (YouTube URL or file upload) | |
| 4. Get comprehensive results, actionable insights, or downloadable training videos | |
| """) | |
| with gr.Row(): | |
| with gr.Column(): | |
| user_height = gr.Number( | |
| label="Your Height (cm)", | |
| value=175, | |
| minimum=100, | |
| maximum=250 | |
| ) | |
| with gr.Column(): | |
| user_weight = gr.Number( | |
| label="Your Weight (kg)", | |
| value=75, | |
| 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 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 YouTube Video", variant="primary") | |
| # File Upload Tab | |
| with gr.TabItem("📁 Upload Video"): | |
| gr.Markdown("📁 *Upload a video file showing someone performing a jump*") | |
| video_file = gr.File( | |
| label="Upload Video File", | |
| file_types=[".mp4", ".avi", ".mov", ".mkv", ".webm"] | |
| ) | |
| file_btn = gr.Button("🚀 Analyze Uploaded Video", variant="primary") | |
| # AI Coaching Tab | |
| with gr.TabItem("🤖 AI Sports Coach"): | |
| gr.Markdown(""" | |
| ## 🤖 AI-Powered Sports Coaching Analysis | |
| Get personalized performance analysis for your favorite sports and targeted improvement suggestions from our AI sports coach powered by Google Gemini. | |
| **What you'll get:** | |
| - 📊 **Percentile Rankings** across your favorite sports based on your performance | |
| - 🎯 **Combined Performance Improvement** recommendations (3-4 key pointers) | |
| - 📈 **Sport-Specific Analysis** tailored to your athletic interests | |
| """) | |
| with gr.Row(): | |
| with gr.Column(): | |
| ai_gender = gr.Radio( | |
| choices=["Male", "Female"], | |
| label="Gender", | |
| value="Male" | |
| ) | |
| favorite_sports = gr.CheckboxGroup( | |
| choices=[ | |
| "Basketball", "Volleyball", "Track and Field", "Football", "Soccer", | |
| "Tennis", "Badminton", "Swimming", "Gymnastics", "Boxing", | |
| "Wrestling", "Baseball", "Hockey", "Rugby", "Cricket", | |
| "Martial Arts", "Rock Climbing", "Parkour", "Dancing", "CrossFit" | |
| ], | |
| label="Favorite Sports (Select 1-5)", | |
| value=["Basketball"] | |
| ) | |
| gr.Markdown("💡 *Select your favorite sports to get percentile rankings showing how your jump performance compares to typical athletes in each sport*") | |
| # 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", | |
| type="password", | |
| value=default_api_key | |
| ) | |
| with gr.Row(): | |
| test_api_btn = gr.Button("🧪 Test API Key", size="sm") | |
| api_test_result = gr.Textbox( | |
| 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) | |
| 📱 **Privacy**: Your API key is only used for this analysis and not stored. | |
| """) | |
| 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( | |
| 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") | |
| with gr.Row(): | |
| with gr.Column(scale=2): | |
| results_text = gr.Markdown(label="Results") | |
| with gr.Column(scale=1): | |
| results_table = gr.Dataframe( | |
| label="Metrics Summary", | |
| headers=["Metric", "Value"], | |
| datatype=["str", "str"] | |
| ) | |
| 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, | |
| inputs=[youtube_url, user_height, user_weight], | |
| outputs=[results_text, results_table, status_message] | |
| ) | |
| file_btn.click( | |
| fn=analyze_jump_from_file, | |
| inputs=[video_file, user_height, user_weight], | |
| 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, favorite_sports, ai_gemini_key], | |
| outputs=[results_text, results_table, status_message] | |
| ) | |
| # API key test handler | |
| def test_and_show_result(api_key): | |
| result = test_api_key(api_key) | |
| return gr.update(value=result, visible=True) | |
| test_api_btn.click( | |
| fn=test_and_show_result, | |
| inputs=[ai_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=[ | |
| ["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 | |
| if __name__ == "__main__": | |
| app = create_interface() | |
| app.launch(debug=True, share=True) | |