git push origin mainMerge remote-tracking branch 'github/main'

app/main.py

@@ -13,7 +13,7 @@ load_dotenv()
 # Add the app directory to the path
 sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
-from app.utils.video_downloader import download_youtube_video
+from app.utils.video_downloader import download_youtube_video, cleanup_video_file
 from app.utils.video_processor import process_video
 from app.models.pose_estimator import analyze_pose
 from app.models.swing_analyzer import segment_swing, analyze_trajectory
@@ -33,11 +33,12 @@ def main():
         "\nEnable GPT analysis? (y/n, default: y): ").lower() != 'n'
 
     sample_rate_input = input(
-        "\nFrame skip rate for YOLO (1-10, default: 5, auto-adjusts for videos shorter than 5 seconds): ")
-    sample_rate = 5  # Default value
+        "\nFrame processing rate for YOLO (1-10, default: 1 for all frames): ")
+    sample_rate = 1  # Default value - process all frames
     if sample_rate_input.isdigit():
         sample_rate = max(1, min(10, int(sample_rate_input)))
 
+    video_path = None  # Initialize video_path for cleanup
     try:
         # Step 3: Download the video
         print("\nDownloading video...")
@@ -95,7 +96,11 @@ def main():
 
     except Exception as e:
         print(f"\nError: {str(e)}")
-        return
+    finally:
+        # Clean up the original downloaded video file after processing
+        if video_path:
+            print("\nCleaning up downloaded video file...")
+            cleanup_video_file(video_path)
 
 
 if __name__ == "__main__":

app/models/llm_analyzer.py

@@ -6,6 +6,9 @@ import json
 import httpx
 from openai import OpenAI
 import streamlit as st
+import re
+import numpy as np
+from app.models.pose_estimator import calculate_joint_angles
 
 
 def check_llm_services():
@@ -61,15 +64,14 @@ def generate_swing_analysis(pose_data, swing_phases, trajectory_data):
         trajectory_data (dict): Dictionary mapping frame indices to trajectory data
         
     Returns:
-        str: Detailed swing analysis and coaching tips
+        str: Detailed swing analysis and coaching tips, or error message
     """
     # Check available services
     services = check_llm_services()
 
-    # If no services are available, return sample analysis
-    if not services['ollama']['available'] and not services['openai'][
-            'available']:
-        return get_sample_analysis()
+    # If no services are available, return error message
+    if not services['ollama']['available'] and not services['openai']['available']:
+        return "Error: No AI services available. Please ensure either Ollama is running or OpenAI API key is configured."
 
     # Prepare data for LLM
     analysis_data = prepare_data_for_llm(pose_data, swing_phases,
@@ -84,7 +86,7 @@ def generate_swing_analysis(pose_data, swing_phases, trajectory_data):
             if analysis:
                 return analysis
         except Exception as e:
-            print(f"Error with Ollama: {str(e)}. Falling back to OpenAI...")
+            print(f"Error with Ollama: {str(e)}")
 
     # Try OpenAI if available
     if services['openai']['available']:
@@ -94,11 +96,10 @@ def generate_swing_analysis(pose_data, swing_phases, trajectory_data):
             if analysis:
                 return analysis
         except Exception as e:
-            print(
-                f"Error with OpenAI: {str(e)}. Using sample analysis instead.")
+            print(f"Error with OpenAI: {str(e)}")
 
-    # If both services failed, return sample analysis
-    return get_sample_analysis()
+    # If both services failed, return error message
+    return "Error: All AI services failed. Please check your API keys and service configurations."
 
 
 def call_ollama_service(prompt, config):
@@ -164,7 +165,7 @@ def call_openai_service(prompt, config):
         try:
             # Try with GPT-4 first
             response = client.chat.completions.create(
-                model="gpt-4-turbo",
+                model="gpt-4o-mini",
                 messages=[{
                     "role":
                     "system",
@@ -211,304 +212,1115 @@ def call_openai_service(prompt, config):
         return None
 
 
-def get_sample_analysis():
-    """
-    Return sample analysis when no LLM services are available
-    
-    Returns:
-        str: Sample swing analysis
-    """
-    return """
-## Swing Analysis Summary
-
-Based on the video analysis, here are some observations about your swing:
-
-### Setup Phase
-- Your stance appears slightly wider than shoulder-width, which can provide good stability
-- Your posture shows a good spine angle, though you could bend slightly more from the hips
-- The ball position looks appropriate for the club you're using
-
-### Backswing
-- Your takeaway is smooth with good tempo
-- Your wrist hinge develops appropriately in the backswing
-- Your right elbow could be kept a bit closer to your body for better consistency
-
-### Downswing
-- Good weight transfer from back foot to front foot during the transition
-- Your hips are rotating well through impact
-- The swing plane looks consistent throughout the downswing
-
-### Impact
-- Club face alignment at impact appears slightly open
-- Your head position is stable through impact
-- The club path is on a good line toward the target
-
-### Follow Through
-- Good balance maintained through the finish
-- Full extension of arms after impact
-- Complete rotation of the body toward the target
-
-## Areas for Improvement
-
-1. **Club Face Control**: The slightly open club face at impact suggests you may be prone to slicing the ball. Focus on maintaining a square club face through impact.
-
-2. **Right Elbow Position**: Keeping your right elbow closer to your body during the backswing will help create a more consistent swing plane.
-
-3. **Hip Rotation**: While your hip rotation is good, increasing the speed of rotation could generate more power in your swing.
-
-4. **Wrist Release**: Your wrist release could be more active through impact to generate additional club head speed.
-
-These adjustments should help improve both consistency and distance in your swing.
-"""
-
-
-def prepare_data_for_llm(pose_data, swing_phases, trajectory_data):
+def prepare_data_for_llm(pose_data, swing_phases, trajectory_data=None):
     """
     Prepare swing data for LLM analysis
     
     Args:
         pose_data (dict): Dictionary mapping frame indices to pose keypoints
         swing_phases (dict): Dictionary mapping phase names to lists of frame indices
-        trajectory_data (dict): Dictionary mapping frame indices to trajectory data
+        trajectory_data (dict, optional): Ball trajectory data
         
     Returns:
-        dict: Processed data for LLM analysis
+        dict: Formatted swing data for LLM
     """
-    analysis_data = {"swing_phases": {}, "joint_angles": {}, "trajectory": {}}
-
-    # Process swing phases
-    for phase, frames in swing_phases.items():
-        if frames:
-            # Get a representative frame for each phase
-            mid_frame = frames[len(frames) // 2]
-
-            # Get joint angles for the representative frame
-            if mid_frame in pose_data:
-                keypoints = pose_data[mid_frame]
-
-                # Calculate key metrics for each phase
-                analysis_data["swing_phases"][phase] = {
-                    "frame_index": mid_frame,
-                    "duration_frames": len(frames)
-                }
-
-    # Process trajectory data
-    impact_frames = swing_phases.get("impact", [])
-    if impact_frames:
-        impact_frame = impact_frames[len(impact_frames) // 2]
-        if impact_frame in trajectory_data:
-            impact_data = trajectory_data[impact_frame]
-            if "club_speed" in impact_data and impact_data["club_speed"]:
-                analysis_data["trajectory"]["club_speed_mph"] = impact_data[
-                    "club_speed"]
-
-    # Calculate backswing and downswing durations if available
-    backswing_frames = swing_phases.get("backswing", [])
+    
+    # Calculate actual biomechanical metrics from pose data
+    bio_metrics = calculate_biomechanical_metrics(pose_data, swing_phases)
+    
+    # Calculate phase durations and timing metrics
+    setup_frames = swing_phases.get("setup", [])
+    backswing_frames = swing_phases.get("backswing", []) 
     downswing_frames = swing_phases.get("downswing", [])
-
-    backswing_duration = None
-    downswing_duration = None
-
-    if backswing_frames:
-        # Assuming 30 fps video
-        backswing_duration = len(backswing_frames) / 30.0
-
-    if downswing_frames:
-        # Assuming 30 fps video
-        downswing_duration = len(downswing_frames) / 30.0
-
-    # Calculate tempo ratio if both durations are available
-    tempo_ratio = None
-    if backswing_duration and downswing_duration and downswing_duration > 0:
-        tempo_ratio = backswing_duration / downswing_duration
-
-    # Add comprehensive metrics with default values or calculated values
-    # These values would normally be calculated from pose and trajectory data
-    analysis_data["metrics"] = {
-        # Core body mechanics
-        "tempo_ratio": tempo_ratio or 3.0,  # Backswing to downswing time ratio
-        "swing_plane_consistency": 0.85,  # 0-1 scale
-        "weight_shift": 0.7,  # 0-1 scale
-        "hip_rotation": 45,  # degrees
-        "shoulder_rotation": 90,  # degrees
-        "posture_score": 0.8,  # 0-1 scale
-
-        # Upper body mechanics
-        "arm_extension": 0.8,  # 0-1 scale
-        "wrist_hinge": 80,  # degrees
-        "chest_rotation_efficiency": 0.75,  # 0-1 scale
-        "head_movement_lateral": 2.5,  # inches
-        "head_movement_vertical": 1.8,  # inches
-
-        # Lower body mechanics
-        "knee_flexion_address": 25,  # degrees
-        "knee_flexion_impact": 30,  # degrees
-        "hip_thrust": 0.6,  # 0-1 scale
-        "ground_force_efficiency": 0.7,  # 0-1 scale
-
-        # Club path and face metrics
-        "swing_path":
-        2.5,  # degrees (positive = out-to-in, negative = in-to-out)
-        "clubface_angle": 2.1,  # degrees (positive = open, negative = closed)
-        "attack_angle":
-        -4.2,  # degrees (negative = descending, positive = ascending)
-        "club_path_consistency": 0.78,  # 0-1 scale
-
-        # Tempo and timing metrics
-        "transition_smoothness": 0.75,  # 0-1 scale
-        "backswing_duration": backswing_duration or 0.9,  # seconds
-        "downswing_duration": downswing_duration or 0.3,  # seconds
-        "kinematic_sequence": 0.82,  # 0-1 scale
-
-        # Efficiency and power metrics
-        "energy_transfer": 0.78,  # 0-1 scale
-        "potential_distance": 240,  # yards
-        "power_accumulation": 0.75,  # 0-1 scale
-        "speed_generation": "Arms-dominant"  # String description
+    impact_frames = swing_phases.get("impact", [])
+    follow_through_frames = swing_phases.get("follow_through", [])
+    
+    # Calculate tempo ratio (downswing:backswing)
+    backswing_duration = len(backswing_frames) if backswing_frames else 1
+    downswing_duration = len(downswing_frames) if downswing_frames else 1
+    tempo_ratio = downswing_duration / backswing_duration if backswing_duration > 0 else 1.0
+    
+    # Calculate total swing duration and club speed estimates
+    total_frames = len(setup_frames) + len(backswing_frames) + len(downswing_frames) + len(impact_frames) + len(follow_through_frames)
+    
+    # Estimate club speed based on downswing duration (faster downswing = higher speed)
+    # Professional downswings are typically 10-15 frames at 30fps
+    if downswing_duration > 0:
+        speed_factor = max(0.5, min(2.0, 12.0 / downswing_duration))  # Normalize around 12 frames
+        estimated_club_speed = 70 + (speed_factor * 40)  # Base 70 mph, up to 110 mph
+    else:
+        estimated_club_speed = 85
+    
+    # Process joint angles if available
+    joint_angles = {}
+    if pose_data:
+        # Get a representative frame for joint analysis
+        rep_frame = None
+        if impact_frames:
+            rep_frame = impact_frames[0]
+        elif downswing_frames:
+            rep_frame = downswing_frames[len(downswing_frames) // 2]
+        elif backswing_frames:
+            rep_frame = backswing_frames[-1]
+        
+        if rep_frame and rep_frame in pose_data:
+            try:
+                from app.models.pose_estimator import calculate_joint_angles
+                joint_angles = calculate_joint_angles(pose_data[rep_frame])
+            except Exception as e:
+                print(f"Error calculating joint angles: {e}")
+                joint_angles = {}
+    
+    # Prepare the structured data
+    swing_data = {
+        "swing_phases": {
+            "setup": {
+                "frame_count": len(setup_frames),
+                "duration_ms": len(setup_frames) * 33.33  # Assuming 30fps
+            },
+            "backswing": {
+                "frame_count": len(backswing_frames),
+                "duration_ms": len(backswing_frames) * 33.33
+            },
+            "downswing": {
+                "frame_count": len(downswing_frames),
+                "duration_ms": len(downswing_frames) * 33.33
+            },
+            "impact": {
+                "frame_count": len(impact_frames),
+                "duration_ms": len(impact_frames) * 33.33
+            },
+            "follow_through": {
+                "frame_count": len(follow_through_frames),
+                "duration_ms": len(follow_through_frames) * 33.33
+            }
+        },
+        
+        "timing_metrics": {
+            "tempo_ratio": round(tempo_ratio, 2),
+            "total_swing_frames": total_frames,
+            "total_swing_time_ms": total_frames * 33.33,
+            "estimated_club_speed_mph": round(estimated_club_speed, 1)
+        },
+        
+        "biomechanical_metrics": {
+            # Core rotation metrics
+            "hip_rotation_degrees": round(bio_metrics.get("hip_rotation", 25), 1),
+            "shoulder_rotation_degrees": round(bio_metrics.get("shoulder_rotation", 60), 1),
+            "chest_rotation_efficiency_percent": round(bio_metrics.get("chest_rotation_efficiency", 0.6) * 100, 1),
+            
+            # Weight transfer and stability
+            "weight_shift_percent": round(bio_metrics.get("weight_shift", 0.5) * 100, 1),
+            "ground_force_efficiency_percent": round(bio_metrics.get("ground_force_efficiency", 0.6) * 100, 1),
+            "hip_thrust_percent": round(bio_metrics.get("hip_thrust", 0.5) * 100, 1),
+            
+            # Arm and club mechanics
+            "arm_extension_percent": round(bio_metrics.get("arm_extension", 0.6) * 100, 1),
+            "wrist_hinge_degrees": round(bio_metrics.get("wrist_hinge", 60), 1),
+            "swing_plane_consistency_percent": round(bio_metrics.get("swing_plane_consistency", 0.6) * 100, 1),
+            
+            # Posture and stability
+            "posture_score_percent": round(bio_metrics.get("posture_score", 0.6) * 100, 1),
+            "head_movement_lateral_inches": round(bio_metrics.get("head_movement_lateral", 3.0), 1),
+            "head_movement_vertical_inches": round(bio_metrics.get("head_movement_vertical", 2.0), 1),
+            
+            # Leg mechanics
+            "knee_flexion_address_degrees": round(bio_metrics.get("knee_flexion_address", 25), 1),
+            "knee_flexion_impact_degrees": round(bio_metrics.get("knee_flexion_impact", 30), 1),
+            
+            # Advanced coordination metrics
+            "transition_smoothness_percent": round(bio_metrics.get("transition_smoothness", 0.6) * 100, 1),
+            "kinematic_sequence_percent": round(bio_metrics.get("kinematic_sequence", 0.6) * 100, 1),
+            "energy_transfer_efficiency_percent": round(bio_metrics.get("energy_transfer", 0.6) * 100, 1),
+            "power_accumulation_percent": round(bio_metrics.get("power_accumulation", 0.6) * 100, 1),
+            
+            # Performance estimates
+            "potential_distance_yards": round(bio_metrics.get("potential_distance", 200), 0),
+            "speed_generation_method": bio_metrics.get("speed_generation", "Mixed")
+        },
+        
+        "joint_angles": joint_angles,
+        
+        "trajectory_analysis": trajectory_data if trajectory_data else {
+            "estimated_carry_distance": round(bio_metrics.get("potential_distance", 200) * 0.85, 0),
+            "estimated_ball_speed": round(estimated_club_speed * 1.4, 1),  # Rough conversion
+            "trajectory_type": "Mid" if bio_metrics.get("arm_extension", 0.6) > 0.7 else "Low"
+        }
     }
-
-    return analysis_data
+    
+    return swing_data
 
 
 def create_llm_prompt(analysis_data):
     """
-    Create a prompt for the LLM based on swing analysis data
+    Create a comprehensive prompt for LLM analysis with professional benchmarks
     
     Args:
-        analysis_data (dict): Processed swing analysis data
+        analysis_data (dict): Processed swing analysis data with biomechanical metrics
         
     Returns:
-        str: Prompt for LLM
+        str: Formatted prompt for LLM analysis
     """
-    prompt = """
-I've analyzed a golf swing and extracted the following data:
-
-## Swing Phases
-"""
-
-    # Add swing phases information
-    for phase, data in analysis_data["swing_phases"].items():
-        prompt += f"- {phase.capitalize()}: Frame {data['frame_index']}, Duration: {data['duration_frames']} frames\n"
-
-    # Add trajectory information
-    prompt += "\n## Trajectory Data\n"
-    if "trajectory" in analysis_data and "club_speed_mph" in analysis_data[
-            "trajectory"]:
-        prompt += f"- Club Speed: {analysis_data['trajectory']['club_speed_mph']:.1f} mph\n"
-
-    # Add detailed biomechanical metrics
-    prompt += "\n## Swing Mechanics\n"
+    
+    # Extract metrics from the new data structure
+    bio_metrics = analysis_data.get("biomechanical_metrics", {})
+    timing_metrics = analysis_data.get("timing_metrics", {})
+    swing_phases = analysis_data.get("swing_phases", {})
+    
+    prompt = """# Golf Swing Analysis
+
+## PROFESSIONAL BENCHMARKS FOR CALIBRATION
+Use these professional standards as your 100% reference for scoring. These represent elite-level golf swing mechanics based on actual LPGA Tour professional analysis:
+
+### Professional Golfer Analysis Summary (100% Reference Standards):
+
+**Atthaya Thitikul (LPGA Tour - Elite Level):**
+- Hip Rotation: 63.4°, Shoulder Rotation: 120°, Posture Score: 98.2%
+- Weight Shift: 88.4%, Arm Extension: 99.8%, Wrist Hinge: 120°
+- Energy Transfer: 96.1%, Power Accumulation: 100%, Potential Distance: 295 yards
+- Sequential Kinematic Sequence: 100%, Swing Plane Consistency: 85%
+
+**Nelly Korda (LPGA Tour - Elite Level):**
+- Hip Rotation: 90°, Shoulder Rotation: 120°, Posture Score: 97.4%
+- Weight Shift: 73.5%, Arm Extension: 96.7%, Wrist Hinge: 114.8°
+- Energy Transfer: 91.2%, Power Accumulation: 100%, Potential Distance: 289 yards
+- Sequential Kinematic Sequence: 100%, Swing Plane Consistency: 85%
+
+**Demi Runas (Professional Level):**
+- Hip Rotation: 63.4°, Shoulder Rotation: 120°, Posture Score: 95.9%
+- Weight Shift: 63.9%, Arm Extension: 96.6%, Wrist Hinge: 93.4°
+- Energy Transfer: 88.0%, Power Accumulation: 100%, Potential Distance: 286 yards
+- Sequential Kinematic Sequence: 100%, Swing Plane Consistency: 85%
+
+### **PROFESSIONAL STANDARDS CALIBRATION (100% Level):**
+**Core Biomechanical Metrics:**
+- **Hip Rotation**: 60-90° (Exceptional body turn and flexibility)
+- **Shoulder Rotation**: 120° (Full shoulder coil for maximum power)
+- **Posture Score**: 95-98% (Exceptional spine angle consistency)
+- **Weight Shift**: 70-88% (Excellent weight transfer to lead side)
+
+**Upper Body Excellence:**
+- **Arm Extension**: 96-100% (Near-perfect extension at impact)
+- **Wrist Hinge**: 95-120° (Optimal lag and release timing)
+- **Swing Plane Consistency**: 85% (Tour-level repeatability)
+- **Chest Rotation Efficiency**: 100% (Perfect coordination)
+
+**Power & Efficiency Markers:**
+- **Energy Transfer Efficiency**: 88-96% (Elite power transfer)
+- **Power Accumulation**: 100% (Maximum power generation)
+- **Sequential Kinematic Sequence**: 100% (Perfect body sequencing)
+- **Potential Distance**: 285-295 yards (Tour-level power)
+
+**Movement Quality Standards:**
+- **Head Movement**: 2-8 inches (Controlled, minimal excessive movement)
+- **Ground Force Efficiency**: 70-88% (Excellent ground interaction)
+- **Hip Thrust**: 40-100% (Strong lower body drive)
+
+### **AMATEUR REFERENCE EXAMPLES FOR CALIBRATION:**
+
+**70% Level Skilled Amateur (Female):**
+- Hip Rotation: 23.0°, Shoulder Rotation: 120° (Excellent shoulder turn, limited hip mobility)
+- Posture Score: 89.5%, Weight Shift: 90.0% (Strong fundamentals)
+- Arm Extension: 99.8%, Wrist Hinge: 49.4° (Great extension, needs more lag)
+- Energy Transfer: 94.5%, Power Accumulation: 82.1% (Very good coordination)
+- Potential Distance: 273 yards, Sequential Kinematic: 93.6%
+- Head Movement: 8.0in lateral, 6.0in vertical (Excessive movement)
+- Speed Generation: Mixed
+
+**50-60% Level Amateur (Male #1 - Body-Dominant):**
+- Hip Rotation: 90°, Shoulder Rotation: 84.8° (Great hip turn, limited shoulder)
+- Posture Score: 90.7%, Weight Shift: 90.0% (Solid fundamentals)
+- Arm Extension: 100.0%, Wrist Hinge: 66.8° (Good extension and lag)
+- Energy Transfer: 91.8%, Power Accumulation: 100.0% (Strong power generation)
+- Potential Distance: 290 yards, Sequential Kinematic: 100.0%
+- Hip Thrust: 100.0%, Ground Force: 90.0% (Excellent lower body)
+- Speed Generation: Body-dominant
+
+**50-60% Level Amateur (Male #2 - Body-Dominant):**
+- Hip Rotation: 90°, Shoulder Rotation: 120° (Excellent rotation both)
+- Posture Score: 89.3%, Weight Shift: 90.0% (Good fundamentals)
+- Arm Extension: 99.6%, Wrist Hinge: 52.6° (Great extension, limited lag)
+- Energy Transfer: 96.7%, Power Accumulation: 100.0% (Excellent coordination)
+- Potential Distance: 296 yards, Sequential Kinematic: 100.0%
+- Tempo Issues: Very fast downswing (2.86 ratio vs ideal ~0.3)
+- Speed Generation: Body-dominant
+
+**50-60% Level Amateur (Female - Arms-Dominant):**
+- Hip Rotation: 25°, Shoulder Rotation: 60° (Limited body rotation)
+- Posture Score: 80.6%, Weight Shift: 50.0% (Needs improvement)
+- Arm Extension: 94.8%, Wrist Hinge: 116.6° (Good extension, excellent lag)
+- Energy Transfer: 56.8%, Power Accumulation: 89.3% (Mixed efficiency)
+- Potential Distance: 241 yards, Sequential Kinematic: 66.8%
+- Head Movement: 3.0in lateral, 2.0in vertical (Good head control)
+- Ground Force: 50.0%, Hip Thrust: 30.0% (Weak lower body)
+- Speed Generation: Arms-dominant
+
+**CRITICAL INSIGHTS FROM AMATEUR ANALYSIS:**
+1. **Hip Rotation Varies Significantly**: From 23-90° in amateurs vs 60-90° in professionals
+2. **Shoulder Rotation Range**: 60-120° in amateurs, professionals consistently at 120°
+3. **Wrist Hinge Compensation**: Some amateurs (116.6°) exceed professional standards to compensate for limited body rotation
+4. **Power Generation Methods**: Body-dominant amateurs can achieve near-professional distances despite technical limitations
+5. **Head Movement Control**: Varies dramatically (3-8 inches) - major differentiator
+6. **Energy Transfer Efficiency**: Ranges from 56.8-96.7% in amateurs vs 88-96% in professionals
+7. **Weight Transfer Issues**: Some amateurs struggle with weight shift (50% vs professional 70-88%)
+
+## CURRENT SWING ANALYSIS
+
+### Swing Phase Breakdown
+""".format(
+        swing_phases.get("setup", {}).get("frame_count", 44),
+        swing_phases.get("backswing", {}).get("frame_count", 7), 
+        swing_phases.get("downswing", {}).get("frame_count", 12),
+        swing_phases.get("impact", {}).get("frame_count", 1),
+        swing_phases.get("follow_through", {}).get("frame_count", 37),
+        timing_metrics.get("tempo_ratio", 0.6)
+    )
+
+    # Add swing phase details
+    for phase_name, phase_data in swing_phases.items():
+        prompt += f"- {phase_name.title()}: {phase_data.get('frame_count', 0)} frames ({phase_data.get('duration_ms', 0):.0f}ms)\n"
+    
+    prompt += f"- Total Swing: {timing_metrics.get('total_swing_frames', 0)} frames ({timing_metrics.get('total_swing_time_ms', 0):.0f}ms)\n"
+    prompt += f"- Tempo Ratio (down:back): {timing_metrics.get('tempo_ratio', 1.0)}\n"
+    prompt += f"- Estimated Club Speed: {timing_metrics.get('estimated_club_speed_mph', 85)} mph\n"
 
     # Core body mechanics
-    prompt += "\n### Body Mechanics\n"
-    prompt += "- Tempo Ratio (Backswing:Downswing): {:.1f}\n".format(
-        analysis_data["metrics"].get("tempo_ratio", 0))
-    prompt += "- Hip Rotation (degrees): {}\n".format(
-        analysis_data["metrics"].get("hip_rotation", 0))
-    prompt += "- Shoulder Rotation (degrees): {}\n".format(
-        analysis_data["metrics"].get("shoulder_rotation", 0))
-    prompt += "- Posture Score: {}%\n".format(
-        int(analysis_data["metrics"].get("posture_score", 0) * 100))
+    prompt += "\n### Core Body Mechanics\n"
+    prompt += f"- Hip Rotation: {bio_metrics.get('hip_rotation_degrees', 25)}°\n"
+    prompt += f"- Shoulder Rotation: {bio_metrics.get('shoulder_rotation_degrees', 60)}°\n"
+    prompt += f"- Posture Score: {bio_metrics.get('posture_score_percent', 60)}%\n"
+    prompt += f"- Weight Shift (lead foot at impact): {bio_metrics.get('weight_shift_percent', 50)}%\n"
 
     # Upper body mechanics
     prompt += "\n### Upper Body Mechanics\n"
-    prompt += "- Arm Extension (impact): {}%\n".format(
-        int(analysis_data["metrics"].get("arm_extension", 0.8) * 100))
-    prompt += "- Wrist Hinge (degrees): {}\n".format(
-        analysis_data["metrics"].get("wrist_hinge", 0))
-    prompt += "- Shoulder Plane Consistency: {}%\n".format(
-        int(analysis_data["metrics"].get("swing_plane_consistency", 0) * 100))
-    prompt += "- Chest Rotation Efficiency: {}%\n".format(
-        int(analysis_data["metrics"].get("chest_rotation_efficiency", 0.75) *
-            100))
-    prompt += "- Head Movement (lateral): {}in\n".format(
-        analysis_data["metrics"].get("head_movement_lateral", 2.5))
-    prompt += "- Head Movement (vertical): {}in\n".format(
-        analysis_data["metrics"].get("head_movement_vertical", 1.8))
+    prompt += f"- Arm Extension: {bio_metrics.get('arm_extension_percent', 60)}%\n"
+    prompt += f"- Wrist Hinge: {bio_metrics.get('wrist_hinge_degrees', 60)}°\n"
+    prompt += f"- Shoulder Plane Consistency: {bio_metrics.get('swing_plane_consistency_percent', 60)}%\n"
+    prompt += f"- Chest Rotation Efficiency: {bio_metrics.get('chest_rotation_efficiency_percent', 60)}%\n"
+    prompt += f"- Head Movement (lateral): {bio_metrics.get('head_movement_lateral_inches', 3.0)}in\n"
+    prompt += f"- Head Movement (vertical): {bio_metrics.get('head_movement_vertical_inches', 2.0)}in\n"
 
     # Lower body mechanics
     prompt += "\n### Lower Body Mechanics\n"
-    prompt += "- Weight Shift (lead foot at impact): {}%\n".format(
-        int(analysis_data["metrics"].get("weight_shift", 0) * 100))
-    prompt += "- Knee Flexion (address): {}°\n".format(
-        analysis_data["metrics"].get("knee_flexion_address", 25))
-    prompt += "- Knee Flexion (impact): {}°\n".format(
-        analysis_data["metrics"].get("knee_flexion_impact", 30))
-    prompt += "- Hip Thrust (impact): {}%\n".format(
-        int(analysis_data["metrics"].get("hip_thrust", 0.6) * 100))
-    prompt += "- Ground Force Efficiency: {}%\n".format(
-        int(analysis_data["metrics"].get("ground_force_efficiency", 0.7) *
-            100))
-
-    # Swing path and clubface metrics
-    prompt += "\n### Club Path & Face Metrics\n"
-    prompt += "- Swing Path (degrees): {} ({})\n".format(
-        analysis_data["metrics"].get("swing_path", 2.5), "Out-to-In"
-        if analysis_data["metrics"].get("swing_path", 0) > 0 else "In-to-Out")
-    prompt += "- Clubface Angle (degrees): {} ({})\n".format(
-        analysis_data["metrics"].get("clubface_angle", 2.1), "Open"
-        if analysis_data["metrics"].get("clubface_angle", 0) > 0 else "Closed")
-    prompt += "- Attack Angle (degrees): {} ({})\n".format(
-        analysis_data["metrics"].get("attack_angle", -4.2), "Descending" if
-        analysis_data["metrics"].get("attack_angle", 0) < 0 else "Ascending")
-    prompt += "- Club Path Consistency: {}%\n".format(
-        int(analysis_data["metrics"].get("club_path_consistency", 0.78) * 100))
-
-    # Tempo and timing metrics
-    prompt += "\n### Tempo & Timing\n"
-    prompt += "- Transition Smoothness: {}%\n".format(
-        int(analysis_data["metrics"].get("transition_smoothness", 0.75) * 100))
-    prompt += "- Backswing Duration: {} seconds\n".format(
-        analysis_data["metrics"].get("backswing_duration", 0.9))
-    prompt += "- Downswing Duration: {} seconds\n".format(
-        analysis_data["metrics"].get("downswing_duration", 0.3))
-    prompt += "- Sequential Kinematic Sequence: {}%\n".format(
-        int(analysis_data["metrics"].get("kinematic_sequence", 0.82) * 100))
+    prompt += f"- Knee Flexion (address): {bio_metrics.get('knee_flexion_address_degrees', 25)}°\n"
+    prompt += f"- Knee Flexion (impact): {bio_metrics.get('knee_flexion_impact_degrees', 30)}°\n"
+    prompt += f"- Hip Thrust (impact): {bio_metrics.get('hip_thrust_percent', 50)}%\n"
+    prompt += f"- Ground Force Efficiency: {bio_metrics.get('ground_force_efficiency_percent', 60)}%\n"
+
+    # Advanced coordination metrics
+    prompt += "\n### Movement Quality & Timing\n"
+    prompt += f"- Transition Smoothness: {bio_metrics.get('transition_smoothness_percent', 60)}%\n"
+    prompt += f"- Sequential Kinematic Sequence: {bio_metrics.get('kinematic_sequence_percent', 60)}%\n"
 
     # Efficiency and power metrics
     prompt += "\n### Efficiency & Power Metrics\n"
-    prompt += "- Energy Transfer Efficiency: {}%\n".format(
-        int(analysis_data["metrics"].get("energy_transfer", 0.78) * 100))
-    prompt += "- Potential Distance: {} yards\n".format(
-        analysis_data["metrics"].get("potential_distance", 240))
-    prompt += "- Power Accumulation: {}%\n".format(
-        int(analysis_data["metrics"].get("power_accumulation", 0.75) * 100))
-    prompt += "- Speed Generation Method: {}\n".format(
-        analysis_data["metrics"].get("speed_generation", "Arms-dominant"))
+    prompt += f"- Energy Transfer Efficiency: {bio_metrics.get('energy_transfer_efficiency_percent', 60)}%\n"
+    prompt += f"- Power Accumulation: {bio_metrics.get('power_accumulation_percent', 60)}%\n"
+    prompt += f"- Potential Distance: {bio_metrics.get('potential_distance_yards', 200)} yards\n"
+    prompt += f"- Speed Generation Method: {bio_metrics.get('speed_generation_method', 'Mixed')}\n"
 
     prompt += """
 
-Based on this detailed biomechanical data, please provide:
-
-1. A comprehensive analysis of the golf swing including:
-   - Detailed breakdown of each swing phase
-   - Analysis of body mechanics and kinematic sequence
-   - Assessment of power generation and efficiency
-   - Evaluation of clubface control and swing path
-
-2. Key strengths and weaknesses in the swing, including:
-   - Specific biomechanical inefficiencies
-   - Compensatory movements
-   - Physical limitations
-   - Technical flaws
-
-3. Prioritized recommendations for improvement:
-   - Top 3-5 most impactful changes to make
-   - Root cause analysis (why these issues are occurring)
-   - Expected improvement in performance from each change
-
-4. Specific drills and exercises addressing each issue:
-   - Technical drills for swing mechanics
-   - Physical exercises to address any biomechanical limitations
-   - Feel-based drills to develop proper movement patterns
-   - Practice routine recommendations
-
-5. Long-term development plan:
-   - Sequential order of what to work on
-   - Benchmarks for measuring progress
-   - Timeline for improvement
-
-Please be specific, detailed, and actionable in your feedback, providing the kind of analysis a professional golf coach would give after a thorough assessment.
+## ANALYSIS INSTRUCTIONS
+
+Using the professional benchmarks and amateur examples above as your calibration reference, provide your analysis in the following EXACT structured format:
+
+**PERFORMANCE_CLASSIFICATION:** [XX%] (where XX is a percentage from 10% to 100%)
+
+**STRENGTHS:**
+• [Specific strength with direct comparison to professional/amateur benchmarks - e.g. "Hip rotation of 45° approaches professional range (60-90°) and exceeds most amateur examples (23-90°)"]
+• [Another strength with benchmark comparison - e.g. "Energy transfer efficiency of 88% meets professional standards (88-96%) and surpasses amateur range (56.8-96.7%)"]
+• [Third strength with specific metric comparison to benchmarks]
+
+**WEAKNESSES:**
+• [Specific weakness with gap from professional standard - e.g. "Wrist hinge of 35° falls significantly below professional range (95-120°) and amateur compensation patterns (116.6°)"]
+• [Another weakness with professional/amateur comparison - e.g. "Head movement of 12 inches exceeds both professional (2-8in) and amateur examples (3-8in)"]
+• [Third weakness with benchmark gap analysis]
+
+**PRIORITY_IMPROVEMENTS:**
+1. [Most Critical] Topic Name - Current metric vs professional benchmark vs amateur examples, specific target improvement to reach next level
+2. [Important] Topic Name - Current performance vs benchmarks, actionable steps to improve toward professional standards
+3. [Focus Area] Topic Name - Current state vs benchmark ranges, realistic improvement goals based on amateur progression examples
+
+**MANDATORY REQUIREMENTS FOR EACH SECTION:**
+
+**For STRENGTHS** - Must include:
+- Specific metric values from current analysis
+- Direct comparison to professional benchmarks (60-90° hip rotation, 95-120° wrist hinge, 88-96% energy transfer, etc.)
+- Comparison to amateur examples where relevant
+- Recognition when metrics meet or exceed professional standards
+- Acknowledgment when metrics surpass typical amateur performance
+
+**For WEAKNESSES** - Must include:
+- Specific metric gaps from professional standards
+- Comparison to amateur examples to show relative standing
+- Quantified differences (e.g., "15° below professional minimum," "20% gap from professional range")
+- Impact on overall performance potential
+
+**For PRIORITY_IMPROVEMENTS** - Must include:
+- Current metric value vs professional benchmark range
+- Reference to amateur examples showing improvement potential
+- Specific target values based on professional standards
+- Realistic progression steps based on amateur improvement patterns
+- Clear explanation of why this improvement would impact overall performance
+
+**EXAMPLE ANALYSIS STRUCTURE:**
+
+**STRENGTHS:**
+• Shoulder rotation of 118° nearly matches professional standard (120°) and exceeds many amateur examples (60-120° range)
+• Weight shift of 85% falls within professional range (70-88%) and surpasses amateur struggles (50-90% range)
+
+**WEAKNESSES:**  
+• Hip rotation of 28° falls significantly below professional minimum (60°) and amateur body-dominant examples (90°)
+• Energy transfer of 62% below professional range (88-96%) and some amateur achievements (96.7%)
+
+**PRIORITY_IMPROVEMENTS:**
+1. [Most Critical] Hip Mobility Development - Current 28° vs professional 60-90° and amateur body-dominant 90°. Target 45° as next milestone toward professional range.
+2. [Important] Kinematic Sequence Optimization - Current 70% vs professional 100% and amateur range 66.8-100%. Improve to 85% through better hip-shoulder coordination.
+
+PERFORMANCE CLASSIFICATION SCALE:
+- **90-100%**: Professional/Tour level - Consistently meets or exceeds professional benchmarks across all metrics
+- **80-89%**: Advanced amateur - Meets most professional standards with minor gaps in 1-2 areas
+- **70-79%**: Skilled amateur - Solid fundamentals with some gaps from professional standards
+- **60-69%**: Intermediate - Good basic mechanics but several areas need improvement to reach professional level
+- **50-59%**: Developing intermediate - Basic swing structure present but multiple areas below professional standards
+- **40-49%**: Advanced beginner - Some fundamentals in place but significant gaps in most areas
+- **30-39%**: Beginner - Basic swing motion present but major improvements needed across most metrics
+- **20-29%**: Novice - Limited swing fundamentals, extensive work needed on basic mechanics
+- **10-19%**: Complete beginner - Minimal swing structure, needs comprehensive fundamental development
+
+IMPORTANT ANALYSIS PRIORITIES (Based on Real Professional Data):
+1. **PRIMARY FOCUS - Critical Biomechanical Differentiators**: 
+   - Hip Rotation (Professional: 60-90°, Amateur Range: 23-90°) - MOST IMPORTANT
+   - Shoulder Rotation (Professional: 120°, Amateur Range: 60-120°) - MOST IMPORTANT  
+   - Sequential Kinematic Sequence (Professional: 100%, Amateur Range: 66.8-100%)
+   - Energy Transfer Efficiency (Professional: 88-96%, Amateur Range: 56.8-96.7%)
+
+2. **SECONDARY FOCUS - Power Generation Mechanics**: 
+   - Power Accumulation (Professional: 100%, Amateur Range: 82.1-100%)
+   - Chest Rotation Efficiency (Professional: 100%, Amateur Range: 53.7-100%)
+   - Wrist Hinge (Professional: 95-120°, Amateur Range: 49.4-116.6°)
+   - Swing Plane Consistency (Professional: 85%, Amateur: 70-85%)
+
+3. **TERTIARY FOCUS - Refinement Metrics**: 
+   - Posture Score (Professional: 95-98%, Amateur Range: 80.6-90.7%)
+   - Arm Extension (Professional: 96-100%, Amateur Range: 94.8-100%)
+   - Weight Shift (Professional: 70-88%, Amateur Range: 50-90%)
+   - Ground Force Efficiency (Professional: 70-88%, Amateur Range: 50-90%)
+
+4. **DE-EMPHASIZE - Timing Variables**: Frame counts, tempo ratios, and duration metrics vary significantly based on video capture rates and personal style preferences
+
+**SCORING CALIBRATION GUIDELINES:**
+- **Hip/Shoulder Rotation Analysis**: Compare to professional minimums (60° hip, 120° shoulder) and amateur ranges
+- **Energy Transfer <70%**: Score below 60%, compare to amateur range (56.8-96.7%)
+- **Sequential Kinematic <80%**: Score below 70%, reference amateur examples (66.8-100%)
+- **Power Accumulation <90%**: Score below 80%, compare to amateur achievements (82.1-100%)
+- **Head Movement >10 inches**: Major limitation, compare to professional (2-8in) and amateur (3-8in) ranges
+- **Weight Shift <60%**: Significant weakness, reference amateur struggles (50%) vs successes (90%)
+
+IMPORTANT FORMATTING RULES:
+- Use the exact headers shown above (PERFORMANCE_CLASSIFICATION, STRENGTHS, WEAKNESSES, PRIORITY_IMPROVEMENTS)
+- For performance classification, use format: [XX%] where XX is the percentage (10-100)
+- For strengths and weaknesses, use bullet points (•) 
+- For priority improvements, use numbered format (1., 2., 3.) with priority level in brackets
+- Each priority improvement must have: [Priority Level] Topic Name - Full description with benchmark comparisons
+- **MANDATORY**: Include specific metric values and benchmark comparisons in every strength, weakness, and improvement
+- **MANDATORY**: Reference professional standards and amateur examples in analysis content
+- Provide complete sentences with quantified comparisons - no generic statements
+- Focus analysis on biomechanical consistency rather than timing variations
+- **CRITICAL**: Every analysis point must tie back to the professional benchmarks and amateur examples provided
+
+Remember: Use the professional benchmarks (Atthaya Thitikul: 63.4° hip, 120° shoulder, 96.1% energy transfer, etc.) and amateur examples (23-90° hip rotation range, 56.8-96.7% energy transfer range, etc.) as the foundation for ALL analysis content, not just the percentage classification. Every strength, weakness, and improvement recommendation must include specific metric comparisons to these established benchmarks.
 """
 
     return prompt
+
+
+def parse_and_format_analysis(raw_analysis):
+    """
+    Parse the raw LLM analysis and format it into structured components
+    
+    Args:
+        raw_analysis (str): Raw analysis text from LLM
+        
+    Returns:
+        dict: Structured analysis with classification, strengths/weaknesses, and priorities
+    """
+    # Default structure
+    formatted_analysis = {
+        'classification': 50,  # Default to 50%
+        'strengths': [],
+        'weaknesses': [],
+        'priority_improvements': []
+    }
+    
+    # Extract percentage classification using the new structured format
+    classification_match = re.search(r'\*\*PERFORMANCE_CLASSIFICATION:\*\*\s*\[?(\d+)%?\]?', raw_analysis, re.IGNORECASE)
+    if classification_match:
+        percentage = int(classification_match.group(1))
+        # Ensure percentage is within valid range
+        formatted_analysis['classification'] = max(10, min(100, percentage))
+    else:
+        # Fallback to look for standalone percentages
+        percentage_patterns = [
+            r'(?:Performance|Classification|Level|Score).*?(\d+)%',
+            r'(\d+)%.*?(?:level|performance|classification)',
+            r'classified.*?(\d+)%',
+            r'(?:at|as)\s+(\d+)%'
+        ]
+        
+        for pattern in percentage_patterns:
+            match = re.search(pattern, raw_analysis, re.IGNORECASE)
+            if match:
+                percentage = int(match.group(1))
+                formatted_analysis['classification'] = max(10, min(100, percentage))
+                break
+    
+    # Extract strengths using the new structured format
+    strengths_match = re.search(r'\*\*STRENGTHS:\*\*\s*(.*?)(?=\*\*WEAKNESSES:\*\*|\*\*PRIORITY_IMPROVEMENTS:\*\*|$)', raw_analysis, re.IGNORECASE | re.DOTALL)
+    if strengths_match:
+        strengths_text = strengths_match.group(1)
+        # Extract bullet points
+        strength_items = re.findall(r'•\s*([^\n•]+)', strengths_text)
+        formatted_analysis['strengths'] = [item.strip() for item in strength_items if item.strip()]
+    
+    # Extract weaknesses using the new structured format
+    weaknesses_match = re.search(r'\*\*WEAKNESSES:\*\*\s*(.*?)(?=\*\*PRIORITY_IMPROVEMENTS:\*\*|$)', raw_analysis, re.IGNORECASE | re.DOTALL)
+    if weaknesses_match:
+        weaknesses_text = weaknesses_match.group(1)
+        # Extract bullet points
+        weakness_items = re.findall(r'•\s*([^\n•]+)', weaknesses_text)
+        formatted_analysis['weaknesses'] = [item.strip() for item in weakness_items if item.strip()]
+    
+    # Extract priority improvements using the new structured format
+    priority_match = re.search(r'\*\*PRIORITY_IMPROVEMENTS:\*\*\s*(.*?)$', raw_analysis, re.IGNORECASE | re.DOTALL)
+    if priority_match:
+        priority_text = priority_match.group(1)
+        # Extract numbered items with priority levels and descriptions
+        priority_items = re.findall(r'(\d+)\.\s*\[(.*?)\]\s*(.*?)(?=\d+\.\s*\[|\Z)', priority_text, re.DOTALL)
+        for num, priority_level, description in priority_items[:3]:  # Limit to 3
+            # Clean up the description
+            description = description.strip()
+            # Remove any trailing incomplete sentences
+            if description.endswith('...') or len(description.split('.')[-1].strip()) < 5:
+                sentences = description.split('.')
+                if len(sentences) > 1:
+                    description = '.'.join(sentences[:-1]) + '.'
+            
+            formatted_analysis['priority_improvements'].append({
+                'rank': int(num),
+                'priority_level': priority_level.strip(),
+                'description': f"[{priority_level.strip()}] {description}"
+            })
+    
+    # Fallback parsing if structured format wasn't used
+    if not formatted_analysis['strengths']:
+        # Try original parsing methods for strengths
+        strengths_patterns = [
+            r'(?:Strengths|Strong Points|Positives|Meets.*Standards)[\s\S]*?(?=(?:Weak|Priority|Improvement|Areas|$))',
+            r'(?:Professional Level|Exceeds.*Standards)[\s\S]*?(?=(?:Below|Weak|Priority|$))'
+        ]
+        
+        for pattern in strengths_patterns:
+            match = re.search(pattern, raw_analysis, re.IGNORECASE)
+            if match:
+                strengths_section = match.group(0)
+                strength_items = re.findall(r'[-•]\s*([^-•\n]+)', strengths_section)
+                formatted_analysis['strengths'] = [item.strip() for item in strength_items[:4]]
+                break
+    
+    if not formatted_analysis['weaknesses']:
+        # Try original parsing methods for weaknesses
+        weaknesses_patterns = [
+            r'(?:Weaknesses|Weak|Areas.*Improvement|Priority.*Areas|Below.*Standards)[\s\S]*?(?=(?:Recommendation|Priority|$))',
+            r'(?:Critical|Important|Significant.*gaps?)[\s\S]*?(?=(?:Recommendation|$))'
+        ]
+        
+        for pattern in weaknesses_patterns:
+            match = re.search(pattern, raw_analysis, re.IGNORECASE)
+            if match:
+                weaknesses_section = match.group(0)
+                weakness_items = re.findall(r'[-•]\s*([^-•\n]+)', weaknesses_section)
+                formatted_analysis['weaknesses'] = [item.strip() for item in weakness_items[:4]]
+                break
+    
+    if not formatted_analysis['priority_improvements']:
+        # Try original parsing methods for priorities
+        priority_patterns = [
+            r'(?:Priority.*Improvement|Critical.*Areas?)[\s\S]*?(?=(?:Recommendation|$))',
+            r'(?:1\..*?2\..*?3\.)',  # Numbered list
+            r'(?:Critical|Important|Fine-tuning)[\s\S]*?(?=(?:Critical|Important|Fine-tuning|$))'
+        ]
+        
+        for pattern in priority_patterns:
+            match = re.search(pattern, raw_analysis, re.IGNORECASE | re.DOTALL)
+            if match:
+                priority_text = match.group(0)
+                # Extract numbered items with better parsing
+                numbered_items = re.findall(r'(\d+)\.\s*([^1-9]+?)(?=\d+\.|$)', priority_text, re.DOTALL)
+                for num, item in numbered_items[:3]:  # Limit to 3
+                    # Clean up the item text
+                    item = item.strip()
+                    # Remove any trailing incomplete sentences
+                    sentences = item.split('.')
+                    if len(sentences) > 1 and len(sentences[-1].strip()) < 10:
+                        item = '.'.join(sentences[:-1]) + '.'
+                    
+                    formatted_analysis['priority_improvements'].append({
+                        'rank': int(num),
+                        'description': item
+                    })
+                break
+    
+    # If still no content found, use defaults based on classification
+    if not formatted_analysis['strengths']:
+        formatted_analysis['strengths'] = ['Swing analysis completed successfully']
+    
+    if not formatted_analysis['weaknesses']:
+        formatted_analysis['weaknesses'] = ['Areas for improvement identified']
+    
+    if not formatted_analysis['priority_improvements']:
+        percentage = formatted_analysis['classification']
+        if percentage >= 80:
+            formatted_analysis['priority_improvements'] = [
+                {'rank': 1, 'description': '[Most Critical] Technical Refinement - Fine-tune specific mechanics to achieve consistency at the highest level.'},
+                {'rank': 2, 'description': '[Important] Performance Optimization - Focus on maximizing efficiency and power transfer.'},
+                {'rank': 3, 'description': '[Focus Area] Competitive Preparation - Enhance mental game and course management skills.'}
+            ]
+        elif percentage >= 60:
+            formatted_analysis['priority_improvements'] = [
+                {'rank': 1, 'description': '[Most Critical] Kinematic Sequence Enhancement - Improve body rotation coordination to generate more power and consistency.'},
+                {'rank': 2, 'description': '[Important] Clubface Control - Enhance swing path consistency for better ball striking accuracy.'},
+                {'rank': 3, 'description': '[Focus Area] Energy Transfer Efficiency - Optimize power transfer throughout the swing to maximize distance.'}
+            ]
+        elif percentage >= 40:
+            formatted_analysis['priority_improvements'] = [
+                {'rank': 1, 'description': '[Most Critical] Fundamental Mechanics - Establish consistent posture, grip, and setup positions.'},
+                {'rank': 2, 'description': '[Important] Body Rotation Development - Improve hip and shoulder turn coordination.'},
+                {'rank': 3, 'description': '[Focus Area] Weight Transfer - Develop proper weight shift from back foot to front foot during swing.'}
+            ]
+        else:  # Below 40%
+            formatted_analysis['priority_improvements'] = [
+                {'rank': 1, 'description': '[Most Critical] Basic Setup and Posture - Focus on establishing proper spine angle and athletic stance.'},
+                {'rank': 2, 'description': '[Important] Fundamental Swing Motion - Develop basic backswing and downswing mechanics.'},
+                {'rank': 3, 'description': '[Focus Area] Balance and Stability - Improve overall balance throughout the swing motion.'}
+            ]
+    
+    return formatted_analysis
+
+
+def display_formatted_analysis(analysis_data):
+    """
+    Display the formatted analysis with performance classification, strengths/weaknesses table, and priorities
+    
+    Args:
+        analysis_data (dict): Structured analysis data from parse_and_format_analysis
+    """
+    # 1. Performance Classification with percentage-based progress bar
+    user_percentage = analysis_data['classification']
+    
+    # Display classification in black bolded header
+    st.markdown(f"""
+    <h2 style='color: black; font-weight: bold; text-align: center; margin-bottom: 20px;'>
+        🎯 Performance Score: {user_percentage}%
+    </h2>
+    """, unsafe_allow_html=True)
+    
+    # Create a visual progress bar
+    progress_color = "#ff4444"  # Red for low scores
+    if user_percentage >= 80:
+        progress_color = "#44aa44"  # Green for high scores
+    elif user_percentage >= 60:
+        progress_color = "#ffdd00"  # Yellow for good scores
+    elif user_percentage >= 40:
+        progress_color = "#ff8800"  # Orange for medium scores
+    
+    # Progress bar with percentage labels
+    st.markdown(f"""
+    <div style='margin: 20px 0;'>
+        <div style='display: flex; justify-content: space-between; font-size: 12px; color: #666; margin-bottom: 5px;'>
+            <span>10% - Complete Beginner</span>
+            <span>50% - Intermediate</span>
+            <span>100% - Professional</span>
+        </div>
+        <div style='width: 100%; background-color: #f0f0f0; border-radius: 25px; height: 30px; position: relative;'>
+            <div style='width: {user_percentage}%; background-color: {progress_color}; height: 30px; border-radius: 25px; 
+                        display: flex; align-items: center; justify-content: center; color: white; font-weight: bold;'>
+                {user_percentage}%
+            </div>
+        </div>
+        <div style='display: flex; justify-content: space-between; font-size: 10px; color: #888; margin-top: 5px;'>
+            <span>10%</span>
+            <span>20%</span>
+            <span>30%</span>
+            <span>40%</span>
+            <span>50%</span>
+            <span>60%</span>
+            <span>70%</span>
+            <span>80%</span>
+            <span>90%</span>
+            <span>100%</span>
+        </div>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Performance level description based on percentage
+    if user_percentage >= 90:
+        level_desc = "🏆 **Professional/Tour Level** - Consistently meets or exceeds professional benchmarks"
+        level_color = "#44aa44"
+    elif user_percentage >= 80:
+        level_desc = "🥇 **Advanced Amateur** - Meets most professional standards with minor gaps"
+        level_color = "#66bb44"
+    elif user_percentage >= 70:
+        level_desc = "🥈 **Skilled Amateur** - Solid fundamentals with some gaps from professional standards"
+        level_color = "#88cc44"
+    elif user_percentage >= 60:
+        level_desc = "🥉 **Intermediate** - Good basic mechanics but several areas need improvement"
+        level_color = "#ffdd00"
+    elif user_percentage >= 50:
+        level_desc = "📈 **Developing Intermediate** - Basic swing structure present"
+        level_color = "#ffcc00"
+    elif user_percentage >= 40:
+        level_desc = "📚 **Advanced Beginner** - Some fundamentals in place"
+        level_color = "#ff8800"
+    elif user_percentage >= 30:
+        level_desc = "🎯 **Beginner** - Basic swing motion present but major improvements needed"
+        level_color = "#ff6600"
+    elif user_percentage >= 20:
+        level_desc = "🌱 **Novice** - Limited swing fundamentals, extensive work needed"
+        level_color = "#ff4444"
+    else:
+        level_desc = "🚀 **Complete Beginner** - Minimal swing structure, needs comprehensive fundamental development"
+        level_color = "#ff2222"
+    
+    st.markdown(f"""
+    <div style='text-align: center; padding: 15px; background-color: {level_color}20; 
+                border-radius: 10px; margin: 20px 0; border: 2px solid {level_color};'>
+        <div style='color: {level_color}; font-size: 16px; font-weight: bold;'>{level_desc}</div>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    st.markdown("---")
+    
+    # 2. Strengths and Weaknesses Table
+    st.subheader("⚖️ Strengths & Areas for Improvement")
+    
+    # Create two columns for the table with a visual divider
+    col_left, col_divider, col_right = st.columns([5, 1, 5])
+    
+    with col_left:
+        st.markdown("""
+        <div style='background-color: #e8f5e8; padding: 15px; border-radius: 10px; height: 100%;'>
+            <h4 style='color: #2d5a2d; margin-top: 0;'>✅ Strengths</h4>
+        """, unsafe_allow_html=True)
+        for strength in analysis_data['strengths']:
+            st.markdown(f"• {strength}")
+        st.markdown("</div>", unsafe_allow_html=True)
+    
+    with col_divider:
+        st.markdown("""
+        <div style='width: 2px; background-color: #ddd; height: 200px; margin: 20px auto;'></div>
+        """, unsafe_allow_html=True)
+    
+    with col_right:
+        st.markdown("""
+        <div style='background-color: #fff5e6; padding: 15px; border-radius: 10px; height: 100%;'>
+            <h4 style='color: #cc6600; margin-top: 0;'>⚠️ Areas for Improvement</h4>
+        """, unsafe_allow_html=True)
+        for weakness in analysis_data['weaknesses']:
+            st.markdown(f"• {weakness}")
+        st.markdown("</div>", unsafe_allow_html=True)
+    
+    st.markdown("---")
+    
+    # 3. Priority Improvement Areas
+    st.subheader("🎯 Priority Improvement Areas")
+    
+    for priority in sorted(analysis_data['priority_improvements'], key=lambda x: x['rank']):
+        rank = priority['rank']
+        description = priority['description']
+        
+        # Better extraction of improvement area and description
+        area = ""
+        desc = description
+        
+        # Try different patterns to extract the main topic
+        if '[Most Critical]' in description or '[Important]' in description or '[Focus Area]' in description:
+            # Pattern: [Priority Level] Topic - Description
+            pattern = r'\[(.*?)\]\s*(.*?)(?:\s*-\s*(.*))?$'
+            match = re.search(pattern, description)
+            if match:
+                priority_level = match.group(1)
+                area = match.group(2).strip()
+                desc = match.group(3).strip() if match.group(3) else ""
+        elif ':' in description:
+            # Pattern: Topic: Description
+            parts = description.split(':', 1)
+            area = parts[0].strip()
+            desc = parts[1].strip()
+        elif ' - ' in description:
+            # Pattern: Topic - Description
+            parts = description.split(' - ', 1)
+            area = parts[0].strip()
+            desc = parts[1].strip()
+        else:
+            # Try to extract first meaningful phrase as area
+            words = description.split()
+            if len(words) > 5:
+                # Take first 3-5 words as the area
+                area = ' '.join(words[:4])
+                desc = ' '.join(words[4:])
+            else:
+                area = description
+                desc = ""
+        
+        # Clean up area and description
+        area = area.replace('[Most Critical]', '').replace('[Important]', '').replace('[Focus Area]', '').strip()
+        
+        # Ensure we have meaningful content
+        if not area or len(area) < 5:
+            area = f"Priority {rank} Improvement"
+        
+        if not desc or len(desc) < 10:
+            # Provide a more complete description based on the area
+            if 'posture' in area.lower():
+                desc = "Work on maintaining proper spine angle and athletic stance throughout the swing for better consistency and power transfer."
+            elif 'tempo' in area.lower() or 'timing' in area.lower():
+                desc = "Focus on developing a smooth, consistent rhythm that allows for proper sequencing of body movements."
+            elif 'rotation' in area.lower():
+                desc = "Improve the coordination and range of motion in your body turn to generate more power and accuracy."
+            elif 'weight' in area.lower() or 'shift' in area.lower():
+                desc = "Practice transferring weight from back foot to front foot during the swing for better balance and power."
+            elif 'knee' in area.lower():
+                desc = "Work on maintaining proper knee flex and stability throughout the swing for better foundation and consistency."
+            elif 'hip' in area.lower():
+                desc = "Focus on improving hip mobility and thrust timing to enhance power generation and sequencing."
+            elif 'chest' in area.lower():
+                desc = "Improve chest rotation efficiency to better coordinate upper body movement with the swing sequence."
+            else:
+                desc = description  # Use the full description if we can't categorize it
+        
+        # Display using Streamlit's native components
+        if rank == 1:
+            st.error(f"**{rank}. MOST CRITICAL: {area}**")
+            st.write(desc)
+        elif rank == 2:
+            st.warning(f"**{rank}. IMPORTANT: {area}**")
+            st.write(desc)
+        else:
+            st.info(f"**{rank}. FOCUS AREA: {area}**")
+            st.write(desc)
+        
+        st.write("")  # Add spacing between items
+
+
+def calculate_biomechanical_metrics(pose_data, swing_phases):
+    """
+    Calculate biomechanical metrics from pose keypoints data
+    
+    Args:
+        pose_data (dict): Dictionary mapping frame indices to pose keypoints
+        swing_phases (dict): Dictionary mapping phase names to lists of frame indices
+        
+    Returns:
+        dict: Calculated biomechanical metrics
+    """
+    metrics = {}
+    
+    # Get key frames for analysis
+    setup_frames = swing_phases.get("setup", [])
+    backswing_frames = swing_phases.get("backswing", [])
+    downswing_frames = swing_phases.get("downswing", [])
+    impact_frames = swing_phases.get("impact", [])
+    
+    # Get representative frames
+    setup_frame = setup_frames[len(setup_frames) // 2] if setup_frames else None
+    top_backswing_frame = backswing_frames[-1] if backswing_frames else None
+    impact_frame = impact_frames[0] if impact_frames else None
+    
+    # MediaPipe Pose landmark indices
+    # Shoulders: left(11), right(12)
+    # Hips: left(23), right(24)
+    # Knees: left(25), right(26)
+    # Ankles: left(27), right(28)
+    # Elbows: left(13), right(14)
+    # Wrists: left(15), right(16)
+    
+    try:
+        # Calculate Hip Rotation
+        if setup_frame and top_backswing_frame and setup_frame in pose_data and top_backswing_frame in pose_data:
+            setup_keypoints = pose_data[setup_frame]
+            backswing_keypoints = pose_data[top_backswing_frame]
+            
+            if len(setup_keypoints) >= 33 and len(backswing_keypoints) >= 33:
+                # Hip rotation calculation using hip landmarks
+                setup_left_hip = np.array(setup_keypoints[23][:2])
+                setup_right_hip = np.array(setup_keypoints[24][:2])
+                backswing_left_hip = np.array(backswing_keypoints[23][:2])
+                backswing_right_hip = np.array(backswing_keypoints[24][:2])
+                
+                # Calculate hip line angles
+                setup_hip_vector = setup_right_hip - setup_left_hip
+                backswing_hip_vector = backswing_right_hip - backswing_left_hip
+                
+                setup_hip_angle = np.degrees(np.arctan2(setup_hip_vector[1], setup_hip_vector[0]))
+                backswing_hip_angle = np.degrees(np.arctan2(backswing_hip_vector[1], backswing_hip_vector[0]))
+                
+                hip_rotation = abs(backswing_hip_angle - setup_hip_angle)
+                # Normalize to reasonable range (professionals typically achieve 45+ degrees)
+                metrics["hip_rotation"] = min(hip_rotation, 90)
+            else:
+                metrics["hip_rotation"] = 25  # Lower default for incomplete data
+        else:
+            metrics["hip_rotation"] = 25
+            
+        # Calculate Shoulder Rotation
+        if setup_frame and top_backswing_frame and setup_frame in pose_data and top_backswing_frame in pose_data:
+            setup_keypoints = pose_data[setup_frame]
+            backswing_keypoints = pose_data[top_backswing_frame]
+            
+            if len(setup_keypoints) >= 33 and len(backswing_keypoints) >= 33:
+                # Shoulder rotation calculation
+                setup_left_shoulder = np.array(setup_keypoints[11][:2])
+                setup_right_shoulder = np.array(setup_keypoints[12][:2])
+                backswing_left_shoulder = np.array(backswing_keypoints[11][:2])
+                backswing_right_shoulder = np.array(backswing_keypoints[12][:2])
+                
+                setup_shoulder_vector = setup_right_shoulder - setup_left_shoulder
+                backswing_shoulder_vector = backswing_right_shoulder - backswing_left_shoulder
+                
+                setup_shoulder_angle = np.degrees(np.arctan2(setup_shoulder_vector[1], setup_shoulder_vector[0]))
+                backswing_shoulder_angle = np.degrees(np.arctan2(backswing_shoulder_vector[1], backswing_shoulder_vector[0]))
+                
+                shoulder_rotation = abs(backswing_shoulder_angle - setup_shoulder_angle)
+                metrics["shoulder_rotation"] = min(shoulder_rotation, 120)
+            else:
+                metrics["shoulder_rotation"] = 60  # Lower default
+        else:
+            metrics["shoulder_rotation"] = 60
+            
+        # Calculate Weight Shift (using hip and ankle positions)
+        if setup_frame and impact_frame and setup_frame in pose_data and impact_frame in pose_data:
+            setup_keypoints = pose_data[setup_frame]
+            impact_keypoints = pose_data[impact_frame]
+            
+            if len(setup_keypoints) >= 33 and len(impact_keypoints) >= 33:
+                # Use center of mass approximation
+                setup_left_ankle = np.array(setup_keypoints[27][:2])
+                setup_right_ankle = np.array(setup_keypoints[28][:2])
+                impact_left_ankle = np.array(impact_keypoints[27][:2])
+                impact_right_ankle = np.array(impact_keypoints[28][:2])
+                
+                # Calculate weight distribution based on foot positioning
+                setup_center = (setup_left_ankle + setup_right_ankle) / 2
+                impact_center = (impact_left_ankle + impact_right_ankle) / 2
+                
+                # Weight shift calculation (simplified)
+                foot_width = np.linalg.norm(setup_right_ankle - setup_left_ankle)
+                if foot_width > 0:
+                    weight_shift_amount = np.linalg.norm(impact_center - setup_center) / foot_width
+                    # Convert to percentage (professionals typically achieve 70%+ to front foot)
+                    weight_shift = min(0.5 + weight_shift_amount * 0.5, 0.9)
+                else:
+                    weight_shift = 0.5
+                metrics["weight_shift"] = weight_shift
+            else:
+                metrics["weight_shift"] = 0.5  # Neutral default
+        else:
+            metrics["weight_shift"] = 0.5
+            
+        # Calculate Posture Score (spine angle consistency)
+        posture_scores = []
+        for frame_list in [setup_frames, backswing_frames, impact_frames]:
+            if frame_list:
+                frame = frame_list[len(frame_list) // 2]
+                if frame in pose_data and len(pose_data[frame]) >= 33:
+                    keypoints = pose_data[frame]
+                    # Use shoulder and hip landmarks to estimate spine angle
+                    left_shoulder = np.array(keypoints[11][:2])
+                    right_shoulder = np.array(keypoints[12][:2])
+                    left_hip = np.array(keypoints[23][:2])
+                    right_hip = np.array(keypoints[24][:2])
+                    
+                    shoulder_center = (left_shoulder + right_shoulder) / 2
+                    hip_center = (left_hip + right_hip) / 2
+                    
+                    spine_vector = shoulder_center - hip_center
+                    spine_angle = np.degrees(np.arctan2(spine_vector[1], spine_vector[0]))
+                    posture_scores.append(abs(spine_angle))
+        
+        if posture_scores:
+            # Good posture = consistent spine angle across phases
+            posture_consistency = 1.0 - (np.std(posture_scores) / 90.0)  # Normalize by 90 degrees
+            metrics["posture_score"] = max(0.3, min(posture_consistency, 1.0))
+        else:
+            metrics["posture_score"] = 0.6
+            
+        # Calculate Arm Extension at Impact
+        if impact_frame and impact_frame in pose_data and len(pose_data[impact_frame]) >= 33:
+            keypoints = pose_data[impact_frame]
+            right_shoulder = np.array(keypoints[12][:2])
+            right_elbow = np.array(keypoints[14][:2])
+            right_wrist = np.array(keypoints[16][:2])
+            
+            # Calculate arm extension
+            upper_arm = np.linalg.norm(right_elbow - right_shoulder)
+            forearm = np.linalg.norm(right_wrist - right_elbow)
+            total_arm_length = upper_arm + forearm
+            
+            # Calculate actual distance from shoulder to wrist
+            actual_distance = np.linalg.norm(right_wrist - right_shoulder)
+            
+            if total_arm_length > 0:
+                extension_ratio = actual_distance / total_arm_length
+                metrics["arm_extension"] = min(extension_ratio, 1.0)
+            else:
+                metrics["arm_extension"] = 0.6
+        else:
+            metrics["arm_extension"] = 0.6
+            
+        # Calculate Wrist Hinge using joint angles
+        wrist_angles = []
+        for frame_list in [backswing_frames, impact_frames]:
+            if frame_list:
+                frame = frame_list[len(frame_list) // 2]
+                if frame in pose_data:
+                    angles = calculate_joint_angles(pose_data[frame])
+                    if "right_wrist" in angles:
+                        wrist_angles.append(angles["right_wrist"])
+        
+        if wrist_angles:
+            avg_wrist_angle = np.mean(wrist_angles)
+            # Good wrist hinge is typically 80+ degrees
+            metrics["wrist_hinge"] = min(avg_wrist_angle, 120)
+        else:
+            metrics["wrist_hinge"] = 60
+            
+        # Calculate Head Movement (lateral and vertical)
+        if setup_frame and impact_frame and setup_frame in pose_data and impact_frame in pose_data:
+            setup_keypoints = pose_data[setup_frame]
+            impact_keypoints = pose_data[impact_frame]
+            
+            if len(setup_keypoints) >= 33 and len(impact_keypoints) >= 33:
+                # Use nose landmark (index 0) for head position
+                setup_head = np.array(setup_keypoints[0][:2])
+                impact_head = np.array(impact_keypoints[0][:2])
+                
+                head_movement = np.abs(impact_head - setup_head)
+                # Convert pixel movement to approximate inches (rough estimation)
+                # Assume average person's head is about 9 inches, use that as scale
+                if len(setup_keypoints) > 10:  # Have enough landmarks
+                    head_height_pixels = abs(setup_keypoints[0][1] - setup_keypoints[10][1])  # Nose to mouth
+                    if head_height_pixels > 0:
+                        pixel_to_inch = 4.0 / head_height_pixels  # Approximate nose-to-mouth is 4 inches
+                        lateral_movement = head_movement[0] * pixel_to_inch
+                        vertical_movement = head_movement[1] * pixel_to_inch
+                    else:
+                        lateral_movement = 3.0
+                        vertical_movement = 2.0
+                else:
+                    lateral_movement = 3.0
+                    vertical_movement = 2.0
+                
+                metrics["head_movement_lateral"] = min(lateral_movement, 8.0)
+                metrics["head_movement_vertical"] = min(vertical_movement, 6.0)
+            else:
+                metrics["head_movement_lateral"] = 3.0
+                metrics["head_movement_vertical"] = 2.0
+        else:
+            metrics["head_movement_lateral"] = 3.0
+            metrics["head_movement_vertical"] = 2.0
+            
+        # Calculate Knee Flexion
+        knee_flexions = {}
+        for phase_name, frame_list in [("address", setup_frames), ("impact", impact_frames)]:
+            if frame_list:
+                frame = frame_list[len(frame_list) // 2]
+                if frame in pose_data and len(pose_data[frame]) >= 33:
+                    keypoints = pose_data[frame]
+                    # Right knee angle using hip, knee, ankle
+                    right_hip = np.array(keypoints[24][:2])
+                    right_knee = np.array(keypoints[26][:2])
+                    right_ankle = np.array(keypoints[28][:2])
+                    
+                    # Calculate knee angle
+                    thigh_vector = right_hip - right_knee
+                    shin_vector = right_ankle - right_knee
+                    
+                    if np.linalg.norm(thigh_vector) > 0 and np.linalg.norm(shin_vector) > 0:
+                        cos_angle = np.dot(thigh_vector, shin_vector) / (np.linalg.norm(thigh_vector) * np.linalg.norm(shin_vector))
+                        cos_angle = np.clip(cos_angle, -1, 1)
+                        knee_angle = np.degrees(np.arccos(cos_angle))
+                        knee_flexions[phase_name] = min(knee_angle, 60)
+                    else:
+                        knee_flexions[phase_name] = 25
+                else:
+                    knee_flexions[phase_name] = 25
+        
+        metrics["knee_flexion_address"] = knee_flexions.get("address", 25)
+        metrics["knee_flexion_impact"] = knee_flexions.get("impact", 30)
+        
+        # Calculate derived metrics based on quality of basic metrics
+        # These are more complex and would require additional analysis
+        
+        # Swing Plane Consistency (based on arm and club positions across frames)
+        if metrics["shoulder_rotation"] >= 80 and metrics["arm_extension"] >= 0.75:
+            metrics["swing_plane_consistency"] = 0.85
+        elif metrics["shoulder_rotation"] >= 60 and metrics["arm_extension"] >= 0.6:
+            metrics["swing_plane_consistency"] = 0.70
+        else:
+            metrics["swing_plane_consistency"] = 0.55
+            
+        # Chest Rotation Efficiency (derived from shoulder rotation and posture)
+        chest_efficiency = (metrics["shoulder_rotation"] / 90.0) * metrics["posture_score"]
+        metrics["chest_rotation_efficiency"] = min(chest_efficiency, 1.0)
+        
+        # Hip Thrust (derived from weight shift and hip rotation)
+        hip_thrust = (metrics["weight_shift"] - 0.5) * 2 * (metrics["hip_rotation"] / 45.0)
+        metrics["hip_thrust"] = max(0.3, min(hip_thrust, 1.0))
+        
+        # Ground Force Efficiency (derived from weight shift and knee flexion consistency)
+        knee_consistency = 1.0 - abs(metrics["knee_flexion_impact"] - metrics["knee_flexion_address"]) / 30.0
+        ground_force = metrics["weight_shift"] * knee_consistency
+        metrics["ground_force_efficiency"] = max(0.4, min(ground_force, 1.0))
+        
+        # Transition Smoothness (based on posture consistency and movement quality)
+        head_movement_penalty = (metrics["head_movement_lateral"] + metrics["head_movement_vertical"]) / 10.0
+        transition_smoothness = metrics["posture_score"] * (1.0 - head_movement_penalty)
+        metrics["transition_smoothness"] = max(0.4, min(transition_smoothness, 1.0))
+        
+        # Sequential Kinematic Sequence (based on overall coordination)
+        coordination_score = (metrics["hip_rotation"] / 45.0 + metrics["shoulder_rotation"] / 90.0 + 
+                            metrics["weight_shift"] + metrics["arm_extension"]) / 4.0
+        metrics["kinematic_sequence"] = max(0.5, min(coordination_score, 1.0))
+        
+        # Energy Transfer Efficiency (based on multiple factors)
+        energy_transfer = (metrics["kinematic_sequence"] + metrics["ground_force_efficiency"] + 
+                         metrics["chest_rotation_efficiency"]) / 3.0
+        metrics["energy_transfer"] = max(0.4, min(energy_transfer, 1.0))
+        
+        # Power Accumulation (based on body mechanics)
+        power_accumulation = (metrics["hip_rotation"] / 45.0 + metrics["shoulder_rotation"] / 90.0 + 
+                            metrics["wrist_hinge"] / 80.0) / 3.0
+        metrics["power_accumulation"] = max(0.4, min(power_accumulation, 1.0))
+        
+        # Potential Distance (based on power metrics and efficiency)
+        base_distance = 180  # Base amateur distance
+        power_multiplier = metrics["power_accumulation"] * metrics["energy_transfer"]
+        potential_distance = base_distance + (power_multiplier * 120)  # Up to 300 yards for perfect mechanics
+        metrics["potential_distance"] = min(potential_distance, 320)
+        
+        # Speed Generation Method (based on power sources)
+        if metrics["hip_rotation"] >= 40 and metrics["shoulder_rotation"] >= 80:
+            metrics["speed_generation"] = "Body-dominant"
+        elif metrics["arm_extension"] >= 0.8 and metrics["wrist_hinge"] >= 75:
+            metrics["speed_generation"] = "Arms-dominant" 
+        else:
+            metrics["speed_generation"] = "Mixed"
+            
+    except Exception as e:
+        print(f"Error calculating biomechanical metrics: {str(e)}")
+        # Fail here
+        return None
+    
+    return metrics

app/models/swing_analyzer.py

@@ -23,7 +23,7 @@ def find_top_of_backswing(pose_data):
     return top_frame
 
 
-def detect_impact_frame(pose_data, detections, sample_rate=2):
+def detect_impact_frame(pose_data, detections, sample_rate=1):
     """
     Simple impact detection: ball movement first, wrist speed fallback
     """
@@ -42,12 +42,29 @@ def detect_impact_frame(pose_data, detections, sample_rate=2):
         ball_detections = [d for d in detections if d.class_name == "sports ball"]
         ball_positions = {}
         
+        # Create a mapping from original video frame indices to processed frame indices
+        original_to_processed = {}
+        for processed_idx in frame_indices:
+            original_frame_idx = processed_idx * sample_rate
+            original_to_processed[original_frame_idx] = processed_idx
+        
         for detection in ball_detections:
-            frame_idx = detection.frame_idx // sample_rate
-            if frame_idx > top_backswing:
+            original_frame_idx = detection.frame_idx
+            # Find the closest processed frame index
+            processed_frame_idx = None
+            if original_frame_idx in original_to_processed:
+                processed_frame_idx = original_to_processed[original_frame_idx]
+            else:
+                # Find closest processed frame
+                closest_original = min(original_to_processed.keys(), 
+                                     key=lambda x: abs(x - original_frame_idx))
+                if abs(closest_original - original_frame_idx) <= sample_rate:
+                    processed_frame_idx = original_to_processed[closest_original]
+            
+            if processed_frame_idx and processed_frame_idx > top_backswing:
                 x1, y1, x2, y2 = detection.bbox
                 center_x, center_y = (x1 + x2) / 2, (y1 + y2) / 2
-                ball_positions[frame_idx] = (center_x, center_y)
+                ball_positions[processed_frame_idx] = (center_x, center_y)
         
         # Find first significant ball movement
         if len(ball_positions) >= 2:
@@ -58,7 +75,7 @@ def detect_impact_frame(pose_data, detections, sample_rate=2):
                 movement = np.sqrt((curr_pos[0] - prev_pos[0])**2 + (curr_pos[1] - prev_pos[1])**2)
                 
                 if movement > 15:  # Significant movement threshold
-                    print(f"Impact detected via ball movement at frame {sorted_frames[i]}")
+                    print(f"Impact detected via ball movement at processed frame {sorted_frames[i]} (original frame {sorted_frames[i] * sample_rate})")
                     return sorted_frames[i]
     
     # Method 2: Wrist speed fallback (simple and reliable)
@@ -80,11 +97,11 @@ def detect_impact_frame(pose_data, detections, sample_rate=2):
             max_wrist_speed = wrist_speed
             impact_frame = curr_frame
     
-    print(f"Impact detected via wrist speed at frame {impact_frame}")
+    print(f"Impact detected via wrist speed at processed frame {impact_frame} (original frame {impact_frame * sample_rate if impact_frame else 'N/A'})")
     return impact_frame or downswing_frames[len(downswing_frames) // 3]
 
 
-def segment_swing_pose_based(pose_data, detections=None, sample_rate=2):
+def segment_swing_pose_based(pose_data, detections=None, sample_rate=1):
     """
     Simple swing segmentation with clean impact detection
     """
@@ -117,7 +134,7 @@ def segment_swing_pose_based(pose_data, detections=None, sample_rate=2):
         downswing_frames = [f for f in frame_indices if f > top_backswing]
         impact_frame = downswing_frames[len(downswing_frames) // 3] if downswing_frames else top_backswing + 1
 
-    print(f"Swing phases: Setup end={setup_end}, Top backswing={top_backswing}, Impact={impact_frame}")
+    print(f"Swing phases: Setup end={setup_end} (orig {setup_end * sample_rate}), Top backswing={top_backswing} (orig {top_backswing * sample_rate}), Impact={impact_frame} (orig {impact_frame * sample_rate if impact_frame else 'N/A'})")
 
     # 4. Assign phases
     for idx in frame_indices:
@@ -136,14 +153,14 @@ def segment_swing_pose_based(pose_data, detections=None, sample_rate=2):
 
 
 # Wrapper function to maintain compatibility with existing Streamlit app
-def segment_swing(pose_data, detections, sample_rate=2):
+def segment_swing(pose_data, detections, sample_rate=1):
     """
     Main swing segmentation function (wrapper for pose-based approach)
     """
     return segment_swing_pose_based(pose_data, detections, sample_rate)
 
 
-def analyze_trajectory(frames, detections, swing_phases, sample_rate=2):
+def analyze_trajectory(frames, detections, swing_phases, sample_rate=1):
     """
     Analyze ball trajectory and calculate club speed
     """

app/streamlit_app.py

@@ -19,11 +19,11 @@ load_dotenv()
 # Add the app directory to the path
 sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
-from app.utils.video_downloader import download_youtube_video, download_pro_reference
+from app.utils.video_downloader import download_youtube_video, download_pro_reference, cleanup_video_file, cleanup_downloads_directory
 from app.utils.video_processor import process_video
 from app.models.pose_estimator import analyze_pose
 from app.models.swing_analyzer import segment_swing, analyze_trajectory
-from app.models.llm_analyzer import generate_swing_analysis, create_llm_prompt, prepare_data_for_llm, check_llm_services
+from app.models.llm_analyzer import generate_swing_analysis, create_llm_prompt, prepare_data_for_llm, check_llm_services, parse_and_format_analysis, display_formatted_analysis
 from app.utils.visualizer import create_annotated_video
 from app.utils.comparison import create_key_frame_comparison, extract_key_swing_frames
 
@@ -92,6 +92,7 @@ def main():
     """Main Streamlit application"""
     st.title("Par-ity Project: Golf Swing Analysis 🏌️‍♀️")
     st.write("Founded to address the gender gap in golf participation and access to quality coaching resources, Par-ity Project is a technology-driven initiative empowering girls in golf through innovative AI based swing analysis. This technology uses computer vision and machine learning algorithms to analyze golf swings and provide personalized feedback to improve technique and performance.")
+    
     # Initialize session state for storing analysis results
     if 'video_analyzed' not in st.session_state:
         st.session_state.video_analyzed = False
@@ -107,10 +108,32 @@ def main():
         }
     if 'pro_reference_path' not in st.session_state:
         st.session_state.pro_reference_path = None
+    
+    # Add session cleanup - clean up old files when starting a new session
+    if 'session_initialized' not in st.session_state:
+        cleanup_result = cleanup_downloads_directory(keep_annotated=True)
+        if cleanup_result.get('files_removed', 0) > 0:
+            st.info(f"🗑️ Cleaned up {cleanup_result['files_removed']} old files ({cleanup_result['space_freed_mb']} MB freed)")
+        st.session_state.session_initialized = True
 
     # Sidebar for configuration
     st.sidebar.title("Configuration")
 
+    # Add Reset Session button
+    st.sidebar.markdown("---")
+    if st.sidebar.button("🗑️ Reset Session & Clean Files", help="Clear all session data and remove downloaded files"):
+        # Clean up downloads directory
+        cleanup_result = cleanup_downloads_directory(keep_annotated=False)  # Remove all files including annotated
+        
+        # Clear session state
+        for key in list(st.session_state.keys()):
+            del st.session_state[key]
+        
+        st.sidebar.success(f"Session reset! Cleaned {cleanup_result.get('files_removed', 0)} files ({cleanup_result.get('space_freed_mb', 0)} MB freed)")
+        st.rerun()
+    
+    st.sidebar.markdown("---")
+
     # Check available LLM services
     llm_services = check_llm_services()
     any_service_available = llm_services['ollama'][
@@ -161,14 +184,14 @@ def main():
     else:
         st.sidebar.info("Using sample analysis mode (no LLM required)")
 
-    # Frame skip rate for YOLO
+    # Frame processing rate for YOLO
     sample_rate = st.sidebar.slider(
-        "Frame Skip Rate (YOLO)",
+        "Frame Processing Rate (YOLO)",
         min_value=1,
         max_value=10,
-        value=2,
+        value=1,
         help=
-        "Process every Nth frame. Higher values = faster but less accurate.")
+        "Process every Nth frame. 1 = all frames (most accurate), higher values = faster but less accurate.")
         
     # Pro reference toggle
     enable_pro_comparison = st.sidebar.checkbox(
@@ -289,6 +312,10 @@ def main():
                 'prompt': prompt
             }
 
+            # Clean up the original video file after processing (keep frames in memory)
+            st.info("🗑️ Cleaning up original video file to save space...")
+            cleanup_video_file(video_path)
+
             # Present the options after analysis
             st.subheader("What would you like to do next?")
             options_col1, options_col2, options_col3 = st.columns(3)
@@ -311,6 +338,9 @@ def main():
         except Exception as e:
             st.error(f"Error during analysis: {str(e)}")
             st.session_state.video_analyzed = False
+            # Clean up on error as well
+            if video_path and os.path.exists(video_path):
+                cleanup_video_file(video_path)
 
     # Show action buttons and their results (only if analysis is complete)
     if st.session_state.video_analyzed:
@@ -421,29 +451,13 @@ def main():
                     elif llm_services['openai']['available']:
                         st.info("🤖 **Analysis generated using OpenAI**")
 
-                st.markdown(analysis)
-
-                # Add some example drills based on the analysis
-                if "Error:" not in analysis:  # Only show drills if analysis was successful
-                    st.subheader("Recommended Drills")
-                    drill1, drill2 = st.columns(2)
-
-                    with drill1:
-                        st.markdown("**Posture Drill**")
-                        st.markdown("- Stand with your back against a wall")
-                        st.markdown(
-                            "- Take your golf stance while maintaining contact"
-                        )
-                        st.markdown(
-                            "- Practice maintaining this posture during your swing"
-                        )
-
-                    with drill2:
-                        st.markdown("**Tempo Drill**")
-                        st.markdown("- Count '1-2-3' for your backswing")
-                        st.markdown("- Count '1' for your downswing")
-                        st.markdown("- Practice maintaining a 3:1 tempo ratio")
-        
+                # Parse and display the formatted analysis instead of raw markdown
+                if "Error:" not in analysis:
+                    formatted_analysis = parse_and_format_analysis(analysis)
+                    display_formatted_analysis(formatted_analysis)
+                else:
+                    # Show error message if analysis failed
+                    st.error(analysis)
         # Handle key frame analysis (new tab/option)
         if keyframe_analysis_clicked:
             try:

app/utils/comparison.py

@@ -162,6 +162,7 @@ def extract_key_swing_frames(video_path, frames, swing_phases=None):
         impact_idx = len(frames) // 2
     
     print(f"Key frame indices (relative to processed frames) - Setup: {setup_idx}, Backswing: {backswing_idx}, Impact: {impact_idx}")
+    print(f"These correspond to original video frames (approx) - Setup: ~{setup_idx * 1}, Backswing: ~{backswing_idx * 1}, Impact: ~{impact_idx * 1} (assuming sample_rate=1)")
     
     # Get rotation angle from the original video file
     rotation_angle = 0

app/utils/video_downloader.py

@@ -6,6 +6,88 @@ import os
 import yt_dlp
 
 
+def cleanup_video_file(video_path):
+    """
+    Delete a specific video file after processing
+    
+    Args:
+        video_path (str): Path to the video file to delete
+        
+    Returns:
+        bool: True if file was deleted successfully, False otherwise
+    """
+    try:
+        if os.path.exists(video_path):
+            os.remove(video_path)
+            print(f"Cleaned up video file: {video_path}")
+            return True
+        else:
+            print(f"Video file not found for cleanup: {video_path}")
+            return False
+    except Exception as e:
+        print(f"Error cleaning up video file {video_path}: {str(e)}")
+        return False
+
+
+def cleanup_downloads_directory(output_dir="downloads", keep_annotated=True):
+    """
+    Clean up downloaded videos from the downloads directory
+    
+    Args:
+        output_dir (str): Directory containing downloaded videos
+        keep_annotated (bool): Whether to keep annotated videos (default: True)
+        
+    Returns:
+        dict: Cleanup results with files removed and space freed
+    """
+    try:
+        if not os.path.exists(output_dir):
+            return {"files_removed": 0, "space_freed_mb": 0}
+            
+        files_removed = 0
+        space_freed = 0
+        
+        for filename in os.listdir(output_dir):
+            file_path = os.path.join(output_dir, filename)
+            
+            # Skip if not a file
+            if not os.path.isfile(file_path):
+                continue
+                
+            # Skip annotated videos if keep_annotated is True
+            if keep_annotated and "_annotated" in filename:
+                continue
+                
+            # Skip pro reference videos (they can be reused)
+            if "pro_reference" in filename:
+                continue
+                
+            # Get file size before deletion
+            try:
+                file_size = os.path.getsize(file_path)
+                space_freed += file_size
+                
+                # Remove the file
+                os.remove(file_path)
+                files_removed += 1
+                print(f"Cleaned up: {filename}")
+                
+            except Exception as e:
+                print(f"Error removing {filename}: {str(e)}")
+                
+        # Convert bytes to MB
+        space_freed_mb = space_freed / (1024 * 1024)
+        
+        return {
+            "files_removed": files_removed,
+            "space_freed_mb": round(space_freed_mb, 2)
+        }
+        
+    except Exception as e:
+        print(f"Error during cleanup: {str(e)}")
+        return {"error": str(e)}
+
+
 def download_youtube_video(url, output_dir="downloads"):
     """
     Download a YouTube video from the provided URL using yt-dlp

app/utils/video_processor.py

@@ -20,13 +20,13 @@ class Detection:
         self.confidence = confidence
 
 
-def process_video(video_path, sample_rate=5):
+def process_video(video_path, sample_rate=1):
     """
     Process video and detect golfer, club, and ball
     
     Args:
         video_path (str): Path to the video file
-        sample_rate (int): Process every nth frame
+        sample_rate (int): Process every nth frame (default: 1 for all frames)
         
     Returns:
         tuple: (frames, detections)
@@ -50,10 +50,7 @@ def process_video(video_path, sample_rate=5):
 
     frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
 
-    if frame_count < 150:
-        print(f"Short video detected ({frame_count} frames). Processing all frames.")
-        sample_rate = 1
-
+    # Process all frames by default
     frames = []
     detections = []
 

app/utils/visualizer.py

@@ -38,7 +38,7 @@ def create_annotated_video(video_path,
                            swing_phases,
                            trajectory_data,
                            output_dir="downloads",
-                           sample_rate=5):
+                           sample_rate=1):
     """
     Create an annotated video with swing analysis visualizations