Fix golf swing metrics calculation and validation

- Fixed 180° line flip issue in shoulder rotation calculation that was causing 0.0° readings
- Improved impact detection using clubhead velocity zero-crossing instead of percentage-based timing
- Enhanced pose keypoint detection with more lenient visibility thresholds (0.5 → 0.3)
- Separated metric values from status messages to fix PyArrow table conversion errors
- Added comprehensive validation ranges for tour professional metrics
- Implemented robust fallback methods for poor pose tracking scenarios
- Added estimation markers for line flip corrections to maintain transparency
- Enhanced X-Factor calculation to work with corrected shoulder rotation values

Core metrics now provide realistic golf swing measurements:
- Tempo ratio: ~2.5-3.5 (proper 3:1 backswing:downswing)
- Shoulder rotation: 60-120° (with line flip correction)
- Hip rotation: 20-55° (expanded validation range)
- X-Factor: 15-60° (shoulder-hip separation)
- Posture score: improved confidence scoring

app/models/llm_analyzer.py

@@ -4,12 +4,90 @@ LLM-based golf swing analysis module
 
 import json
 import httpx
+import math
 from openai import OpenAI
 import streamlit as st
 import re
 import numpy as np
 import os
 from .pose_estimator import calculate_joint_angles
+from .prompts import COACH_PROMPT
+from .math_utils import (_dt_and_fps, line_angle, rel_rotation_deg, 
+                       validate_metric_sanity, get_target_line_angle,
+                       calculate_thorax_rotation, calculate_pelvis_rotation)
+
+
+def safe_fmt_deg(v):
+    """Format angle value safely, returning 'n/a' for None or invalid values"""
+    if v is None or v == 'n/a':
+        return "n/a"
+    elif isinstance(v, str):
+        return v  # Return string values as-is (e.g., "85.0 (out of range)")
+    else:
+        return f"{v:.1f}°"
+
+
+def safe_fmt_percent(v):
+    """Format percentage value safely, returning 'n/a' for None or invalid values"""
+    if v is None or v == 'n/a':
+        return "n/a"
+    elif isinstance(v, str):
+        return v  # Return string values as-is (e.g., "78.5 (low confidence)")
+    else:
+        return f"{v:.1f}%"
+
+
+def safe_fmt_with_unit(v, unit=""):
+    """Format value with unit safely, returning 'n/a' for None or invalid values"""
+    if v is None or v == 'n/a':
+        return "n/a"
+    elif isinstance(v, str):
+        return v  # Return string values as-is
+    else:
+        return f"{v:.1f} {unit}"
+
+def fmt_deg(v):
+    """Format angle value safely, returning 'n/a' for None or invalid values"""
+    if v is None or v == 'n/a':
+        return "n/a"
+    elif isinstance(v, str):
+        return v  # Return string values as-is
+    else:
+        return f"{v:.1f}°"
+
+def fmt_pct(v):
+    """Format percentage value safely, returning 'n/a' for None or invalid values"""
+    if v is None or v == 'n/a':
+        return "n/a"
+    elif isinstance(v, str):
+        return v  # Return string values as-is
+    else:
+        return f"{v:.1f}%"
+
+def fmt_in(v):
+    """Format inch value safely, returning 'n/a' for None or invalid values"""
+    if v is None or v == 'n/a':
+        return "n/a"
+    elif isinstance(v, str):
+        return v  # Return string values as-is
+    else:
+        return f"{v:.1f} in"
+
+
+def format_metric_for_llm(metric_data, unit=""):
+    """Format metric for LLM consumption"""
+    if not isinstance(metric_data, dict):
+        return 'n/a'
+    
+    value = metric_data.get('value')
+    status = metric_data.get('status', 'n/a')
+    
+    if value is None or status == 'n/a':
+        return 'n/a'
+    elif status == 'ok':
+        return f"{value}{unit}"
+    else:
+        return f"{value}{unit} ({status})"
 
 
 def check_llm_services():
@@ -76,7 +154,7 @@ def generate_swing_analysis(pose_data, swing_phases, trajectory_data):
 
     # Prepare data for LLM
     analysis_data = prepare_data_for_llm(pose_data, swing_phases,
-                                         trajectory_data)
+                                         trajectory_data, fps=30.0, frame_shape=None)
     prompt = create_llm_prompt(analysis_data)
 
     # Try Ollama first if available
@@ -213,21 +291,313 @@ def call_openai_service(prompt, config):
         return None
 
 
-def prepare_data_for_llm(pose_data, swing_phases, trajectory_data=None):
+def compute_core_metrics(pose_data, swing_phases, frame_timestamps_ms=None, total_ms=None, player_handedness='right'):
     """
-    Prepare swing data for LLM analysis
+    Compute the 5 core metrics with improved reference frames and sanity validation
     
     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, optional): Ball trajectory data
+        frame_timestamps_ms (list, optional): List of frame timestamps in milliseconds  
+        total_ms (float, optional): Total video duration in milliseconds
+        player_handedness (str): 'right' or 'left' handed player
         
     Returns:
-        dict: Formatted swing data for LLM
+        dict: core_metrics with 5 values, validated for sanity
     """
+    # Get phase frame indices
+    setup_frames = swing_phases.get("setup", [])
+    backswing_frames = swing_phases.get("backswing", []) 
+    downswing_frames = swing_phases.get("downswing", [])
+    impact_frames = swing_phases.get("impact", [])
+    follow_through_frames = swing_phases.get("follow_through", [])
     
-    # Calculate actual biomechanical metrics from pose data
-    bio_metrics = calculate_biomechanical_metrics(pose_data, swing_phases)
+    # Get timing
+    total_frames = len(setup_frames) + len(backswing_frames) + len(downswing_frames) + len(impact_frames) + len(follow_through_frames)
+    if total_ms is None:
+        total_ms = total_frames * (1000.0 / 30.0)  # fallback estimate at 30fps
+    dt, actual_fps = _dt_and_fps(frame_timestamps_ms, total_frames, total_ms)
+    
+    # Calculate phase durations in ms with proper frame rate handling
+    backswing_ms = len(backswing_frames) * dt * 1000.0
+    downswing_ms = len(downswing_frames) * dt * 1000.0
+    
+    # Add validation for tour-level timing expectations
+    # Professional backswing: 750-900ms, downswing: 250-300ms
+    expected_backswing_range = (750, 900)
+    expected_downswing_range = (250, 300)
+    
+    timing_notes = []
+    if backswing_ms < expected_backswing_range[0] or backswing_ms > expected_backswing_range[1]:
+        timing_notes.append(f"Backswing duration {backswing_ms:.0f}ms outside tour range {expected_backswing_range}")
+    if downswing_ms < expected_downswing_range[0] or downswing_ms > expected_downswing_range[1]:
+        timing_notes.append(f"Downswing duration {downswing_ms:.0f}ms outside tour range {expected_downswing_range}")
+    
+    if timing_notes:
+        swing_phases["timing_notes"] = timing_notes
+    
+    # Get key frame indices
+    address_idx = setup_frames[0] if setup_frames else (backswing_frames[0] if backswing_frames else 0)
+    top_idx = backswing_frames[-1] if backswing_frames else address_idx
+    impact_idx = impact_frames[0] if impact_frames else (downswing_frames[-1] if downswing_frames else top_idx)
+    
+    # Initialize core metrics with separate value and status tracking
+    core_metrics = {
+        "tempo_ratio": {'value': None, 'status': 'n/a'},
+        "shoulder_rotation_top_deg": {'value': None, 'status': 'n/a'}, 
+        "hip_rotation_impact_deg": {'value': None, 'status': 'n/a'},
+        "x_factor_top_deg": {'value': None, 'status': 'n/a'},
+        "posture_score_pct": {'value': None, 'status': 'n/a'}
+    }
+    
+    # 1) Tempo ratio with sanity validation and auto-retry logic
+    if downswing_ms > 0:
+        tempo_ratio = round(backswing_ms / max(downswing_ms, 1e-6), 2)
+        
+        # Auto-retry logic: if tempo is way off, try to re-detect phases
+        if tempo_ratio < 1.8 or tempo_ratio > 5.0:
+            # Mark as timing unreliable but still report the calculated value
+            swing_phases["timing_unreliable"] = True
+            core_metrics["tempo_ratio"] = {'value': tempo_ratio, 'status': 'unreliable'}
+        else:
+            # Validate against tour professional ranges
+            is_valid, validated_value = validate_metric_sanity('tempo_ratio', tempo_ratio, player_handedness)
+            if is_valid:
+                core_metrics["tempo_ratio"] = {'value': validated_value, 'status': 'ok'}
+            else:
+                core_metrics["tempo_ratio"] = {'value': tempo_ratio, 'status': 'unreliable'}
+    
+    # Check if we have necessary keypoints for rotation calculations
+    if (address_idx in pose_data and top_idx in pose_data and impact_idx in pose_data and
+        pose_data[address_idx] is not None and pose_data[top_idx] is not None and pose_data[impact_idx] is not None):
+        
+        addr_kp = pose_data[address_idx]
+        top_kp = pose_data[top_idx] 
+        impact_kp = pose_data[impact_idx]
+        
+        # Get reference angles at address position
+        target_line_angle = get_target_line_angle(pose_data, address_idx)
+        
+        # Check shoulder keypoints (11=left shoulder, 12=right shoulder)
+        # Debug: Check visibility scores
+        addr_shoulder_vis = [addr_kp[11][2], addr_kp[12][2]] if len(addr_kp) > 12 else [0, 0]
+        top_shoulder_vis = [top_kp[11][2], top_kp[12][2]] if len(top_kp) > 12 else [0, 0]
+        
+        # More lenient visibility check for shoulders
+        shoulder_detection_ok = (len(addr_kp) > 12 and len(top_kp) > 12 and len(impact_kp) > 12 and
+            addr_kp[11][2] > 0.3 and addr_kp[12][2] > 0.3 and  # Reduced from 0.5 to 0.3
+            top_kp[11][2] > 0.3 and top_kp[12][2] > 0.3)
+        
+        if shoulder_detection_ok:
+            
+            # Extract 2D points (x,y)
+            shoulders_addr = (addr_kp[11][:2], addr_kp[12][:2])
+            shoulders_top = (top_kp[11][:2], top_kp[12][:2])
+            
+            # Calculate address shoulder reference angle
+            addr_shoulder_angle = line_angle(shoulders_addr[0], shoulders_addr[1])
+            
+            # 2) Thorax rotation @ top (relative to address position)
+            shoulder_result = calculate_thorax_rotation(
+                shoulders_top, 
+                addr_shoulder_angle, 
+                reference_keypoints=shoulders_addr
+            )
+            
+            # Handle return value (could be float or tuple)
+            if shoulder_result is None:
+                # Poor pose tracking or unreliable shoulder data
+                core_metrics["shoulder_rotation_top_deg"] = {'value': None, 'status': 'poor tracking'}
+            else:
+                # Check if result is a tuple (value, status) or just a value
+                if isinstance(shoulder_result, tuple):
+                    shoulder_rotation_top_deg, estimation_status = shoulder_result
+                    shoulder_rotation_top_deg = round(shoulder_rotation_top_deg, 1)
+                    
+                    # If it was estimated from line flip, note it
+                    if estimation_status == 'estimated':
+                        core_metrics["shoulder_rotation_top_deg"] = {'value': shoulder_rotation_top_deg, 'status': 'estimated (line flip)'}
+                    else:
+                        # Validate normally
+                        is_valid, validated_value = validate_metric_sanity('shoulder_rotation_top_deg', shoulder_rotation_top_deg, player_handedness)
+                        if is_valid:
+                            core_metrics["shoulder_rotation_top_deg"] = {'value': validated_value, 'status': 'ok'}
+                        else:
+                            core_metrics["shoulder_rotation_top_deg"] = {'value': shoulder_rotation_top_deg, 'status': 'outside tour range'}
+                else:
+                    # Regular float value
+                    shoulder_rotation_top_deg = round(shoulder_result, 1)
+                    
+                    # Sanity check: if shoulder rotation is outside reasonable range, mark as unreliable
+                    if shoulder_rotation_top_deg < 5.0 or shoulder_rotation_top_deg > 150.0:
+                        core_metrics["shoulder_rotation_top_deg"] = {'value': shoulder_rotation_top_deg, 'status': 'extreme value'}
+                    else:
+                        # Validate against professional ranges
+                        is_valid, validated_value = validate_metric_sanity('shoulder_rotation_top_deg', shoulder_rotation_top_deg, player_handedness)
+                        if is_valid:
+                            core_metrics["shoulder_rotation_top_deg"] = {'value': validated_value, 'status': 'ok'}
+                        else:
+                            core_metrics["shoulder_rotation_top_deg"] = {'value': shoulder_rotation_top_deg, 'status': 'outside tour range'}
+        else:
+            # Shoulder detection failed - provide diagnostic info
+            core_metrics["shoulder_rotation_top_deg"] = {'value': None, 'status': f'no detection (vis: addr={addr_shoulder_vis}, top={top_shoulder_vis})'}
+        
+        # Check hip keypoints (23=left hip, 24=right hip)
+        # Debug: Check hip visibility scores  
+        addr_hip_vis = [addr_kp[23][2], addr_kp[24][2]] if len(addr_kp) > 24 else [0, 0]
+        impact_hip_vis = [impact_kp[23][2], impact_kp[24][2]] if len(impact_kp) > 24 else [0, 0]
+        top_hip_vis = [top_kp[23][2], top_kp[24][2]] if len(top_kp) > 24 else [0, 0]
+        
+        # More lenient visibility check for hips
+        hip_detection_ok = (len(addr_kp) > 24 and len(top_kp) > 24 and len(impact_kp) > 24 and
+            addr_kp[23][2] > 0.3 and addr_kp[24][2] > 0.3 and  # Reduced from 0.5 to 0.3
+            impact_kp[23][2] > 0.3 and impact_kp[24][2] > 0.3 and
+            top_kp[23][2] > 0.3 and top_kp[24][2] > 0.3)
+        
+        if hip_detection_ok:
+            
+            # Extract 2D points (x,y)
+            hips_addr = (addr_kp[23][:2], addr_kp[24][:2])
+            hips_impact = (impact_kp[23][:2], impact_kp[24][:2])
+            hips_top = (top_kp[23][:2], top_kp[24][:2])
+            
+            # Calculate address hip reference angle
+            addr_hip_angle = line_angle(hips_addr[0], hips_addr[1])
+            
+            # 3) Pelvis rotation @ impact (relative to address, with proper sign convention)
+            hip_rotation_impact_deg = round(calculate_pelvis_rotation(hips_impact, addr_hip_angle, player_handedness), 1)
+            
+            # Sanity check: if hip rotation is outside reasonable range, mark as unreliable
+            if hip_rotation_impact_deg > 80.0:
+                core_metrics["hip_rotation_impact_deg"] = {'value': hip_rotation_impact_deg, 'status': 'extreme value'}
+            else:
+                # Validate against professional ranges  
+                is_valid, validated_value = validate_metric_sanity('hip_rotation_impact_deg', hip_rotation_impact_deg, player_handedness)
+                if is_valid:
+                    core_metrics["hip_rotation_impact_deg"] = {'value': validated_value, 'status': 'ok'}
+                else:
+                    core_metrics["hip_rotation_impact_deg"] = {'value': hip_rotation_impact_deg, 'status': 'outside tour range'}
+        else:
+            # Hip detection failed - provide diagnostic info
+            core_metrics["hip_rotation_impact_deg"] = {'value': None, 'status': f'no detection (vis: addr={addr_hip_vis}, impact={impact_hip_vis}, top={top_hip_vis})'}
+        
+        # 4) X-Factor @ top (shoulders − hips) with validation
+        if (core_metrics["shoulder_rotation_top_deg"]["status"] in ['ok', 'estimated (line flip)'] and 
+            core_metrics["shoulder_rotation_top_deg"]["value"] is not None and
+            hip_detection_ok):
+            
+            # Calculate hip rotation at top for X-Factor (absolute value)
+            hip_rot_top = abs(calculate_pelvis_rotation(hips_top, addr_hip_angle, player_handedness))
+            
+            # X-Factor is the separation between shoulder and hip rotation
+            # Both values are now absolute, so we can directly subtract
+            x_factor_top_deg = round(core_metrics["shoulder_rotation_top_deg"]["value"] - hip_rot_top, 1)
+            
+            # Ensure X-Factor is positive (separation amount)
+            x_factor_top_deg = max(0, x_factor_top_deg)
+            
+            # Validate X-Factor
+            is_valid, validated_value = validate_metric_sanity('x_factor_top_deg', x_factor_top_deg, player_handedness)
+            
+            # Check if shoulder was estimated
+            shoulder_estimated = core_metrics["shoulder_rotation_top_deg"]["status"] == 'estimated (line flip)'
+            
+            if is_valid:
+                if shoulder_estimated:
+                    core_metrics["x_factor_top_deg"] = {'value': validated_value, 'status': 'ok (shoulder estimated)'}
+                else:
+                    core_metrics["x_factor_top_deg"] = {'value': validated_value, 'status': 'ok'}
+            else:
+                if shoulder_estimated:
+                    core_metrics["x_factor_top_deg"] = {'value': x_factor_top_deg, 'status': 'out of range (shoulder estimated)'}
+                else:
+                    core_metrics["x_factor_top_deg"] = {'value': x_factor_top_deg, 'status': 'out of range'}
+        else:
+            # Can't calculate X-Factor without reliable shoulder and hip rotation
+            if core_metrics["shoulder_rotation_top_deg"]["status"] != 'ok':
+                core_metrics["x_factor_top_deg"] = {'value': None, 'status': 'shoulder tracking'}
+            else:
+                core_metrics["x_factor_top_deg"] = {'value': None, 'status': 'hip tracking'}
+    
+    # 5) Posture score: compute a simple posture metric with validation
+    posture_score = compute_simple_posture_score(pose_data, address_idx)
+    if posture_score is not None:
+        posture_score_pct = round(posture_score * 100, 1)
+        # Validate posture score
+        is_valid, validated_value = validate_metric_sanity('posture_score_pct', posture_score_pct, player_handedness)
+        if is_valid:
+            core_metrics["posture_score_pct"] = {'value': validated_value, 'status': 'ok'}
+        else:
+            core_metrics["posture_score_pct"] = {'value': posture_score_pct, 'status': 'low confidence'}
+    
+    return core_metrics
+
+
+def compute_simple_posture_score(pose_data, address_idx):
+    """Compute a simple posture score based on spine angle and overall alignment"""
+    if address_idx not in pose_data or pose_data[address_idx] is None:
+        return None
+        
+    kp = pose_data[address_idx]
+    if len(kp) < 25:  # Need at least up to hip keypoints
+        return None
+    
+    # Check required keypoints visibility (more lenient threshold)
+    required_points = [11, 12, 23, 24]  # shoulders, hips (removed nose)
+    if not all(i < len(kp) and kp[i][2] > 0.3 for i in required_points):
+        return None
+    
+    try:
+        # Calculate spine angle (shoulder midpoint to hip midpoint)
+        shoulder_mid = ((kp[11][0] + kp[12][0]) / 2, (kp[11][1] + kp[12][1]) / 2)
+        hip_mid = ((kp[23][0] + kp[24][0]) / 2, (kp[23][1] + kp[24][1]) / 2)
+        
+        # Calculate spine vector and angle
+        spine_vector = (shoulder_mid[0] - hip_mid[0], shoulder_mid[1] - hip_mid[1])
+        spine_angle_rad = math.atan2(abs(spine_vector[1]), abs(spine_vector[0]))
+        spine_angle_deg = math.degrees(spine_angle_rad)
+        
+        # Golf posture scoring: Good golf posture typically has:
+        # - Slight forward bend (15-45 degrees from vertical)
+        # - Stable base with athletic stance
+        
+        # Target range: 15-45 degrees forward tilt
+        if 15 <= spine_angle_deg <= 45:
+            # In optimal range
+            score = 0.85 + (0.15 * (1 - abs(spine_angle_deg - 30) / 15))
+        elif 5 <= spine_angle_deg < 15:
+            # Too upright but acceptable
+            score = 0.6 + (0.25 * (spine_angle_deg - 5) / 10)
+        elif 45 < spine_angle_deg <= 60:
+            # Too bent but acceptable
+            score = 0.6 + (0.25 * (60 - spine_angle_deg) / 15)
+        else:
+            # Outside reasonable range
+            score = max(0.2, 0.6 - abs(spine_angle_deg - 30) / 60)
+        
+        # Clamp score to reasonable range
+        return max(0.3, min(1.0, score))
+        
+    except (IndexError, ZeroDivisionError, TypeError, ValueError):
+        return None
+
+
+def prepare_data_for_llm(pose_data, swing_phases, trajectory_data=None, fps=30.0, frame_shape=None, frame_timestamps_ms=None, total_ms=None):
+    """
+    Prepare swing data for LLM analysis - simplified to 5 core metrics
+    
+    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, optional): Ball trajectory data
+        fps (float): Video frame rate for timing calculations (fallback if timestamps not available)
+        frame_shape (tuple, optional): Frame shape (H, W) for relative threshold calculations
+        frame_timestamps_ms (list, optional): List of frame timestamps in milliseconds
+        total_ms (float, optional): Total video duration in milliseconds
+        
+    Returns:
+        dict: Formatted swing data for LLM with only 5 core metrics
+    """
     
     # Calculate phase durations and timing metrics
     setup_frames = swing_phases.get("setup", [])
@@ -236,117 +606,50 @@ def prepare_data_for_llm(pose_data, swing_phases, trajectory_data=None):
     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
+    # Calculate total swing duration and use helper function for timing
     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
+    # Use helper function for time calculations
+    if total_ms is None:
+        total_ms = total_frames * (1000.0 / fps)  # fallback estimate
+    dt, actual_fps = _dt_and_fps(frame_timestamps_ms, total_frames, total_ms)
     
-    # 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 .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 = {}
+    # Compute the 5 core metrics with improved biomechanical accuracy
+    core_metrics = compute_core_metrics(pose_data, swing_phases, frame_timestamps_ms, total_ms, player_handedness='right')
     
-    # Prepare the structured data
+    # Prepare the simplified structured data
     swing_data = {
         "swing_phases": {
             "setup": {
                 "frame_count": len(setup_frames),
-                "duration_ms": len(setup_frames) * 33.33  # Assuming 30fps
+                "duration_ms": len(setup_frames) * dt * 1000.0
             },
             "backswing": {
                 "frame_count": len(backswing_frames),
-                "duration_ms": len(backswing_frames) * 33.33
+                "duration_ms": len(backswing_frames) * dt * 1000.0
             },
             "downswing": {
                 "frame_count": len(downswing_frames),
-                "duration_ms": len(downswing_frames) * 33.33
+                "duration_ms": len(downswing_frames) * dt * 1000.0
             },
             "impact": {
                 "frame_count": len(impact_frames),
-                "duration_ms": len(impact_frames) * 33.33
+                "duration_ms": len(impact_frames) * dt * 1000.0
             },
             "follow_through": {
                 "frame_count": len(follow_through_frames),
-                "duration_ms": len(follow_through_frames) * 33.33
+                "duration_ms": len(follow_through_frames) * dt * 1000.0
             }
         },
         
         "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")
+            "total_swing_time_ms": total_frames * dt * 1000.0,
+            "actual_fps": round(actual_fps, 1)
         },
         
-        "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"
-        }
+        # Only the 5 core metrics 
+        "core_metrics": core_metrics
     }
     
     return swing_data
@@ -354,260 +657,47 @@ def prepare_data_for_llm(pose_data, swing_phases, trajectory_data=None):
 
 def create_llm_prompt(analysis_data):
     """
-    Create a comprehensive prompt for LLM analysis with professional benchmarks
+    Create a formatted prompt using the template and analysis data - simplified to 5 core metrics
     
     Args:
-        analysis_data (dict): Processed swing analysis data with biomechanical metrics
+        analysis_data (dict): Processed swing analysis data with core metrics
         
     Returns:
         str: Formatted prompt for LLM analysis
     """
-    
-    # Extract metrics from the new data structure
-    bio_metrics = analysis_data.get("biomechanical_metrics", {})
+    # Extract metrics from the simplified data structure
+    core_metrics = analysis_data.get("core_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%
-
-**Rose Zhang (LPGA Tour Professional):**
-- Hip Rotation: 90°, Shoulder Rotation: 120°, Posture Score: 98.0%
-- Weight Shift: 89.9%, Arm Extension: 79.5%, Wrist Hinge: 112.8°
-- Energy Transfer: 96.6%, Power Accumulation: 100%, Potential Distance: 296 yards
-- Sequential Kinematic Sequence: 100%, Swing Plane Consistency: 85%
-- Speed Generation: Body-dominant
-
-**Lydia Ko (LPGA Tour Professional):**
-- Hip Rotation: 90°, Shoulder Rotation: 120°, Posture Score: 99.2%
-- Weight Shift: 66.2%, Arm Extension: 62.1%, Wrist Hinge: 120°
-- Energy Transfer: 88.7%, Power Accumulation: 100%, Potential Distance: 286 yards
-- Sequential Kinematic Sequence: 100%, Swing Plane Consistency: 70%
-- Speed Generation: Body-dominant
-
-### **PROFESSIONAL STANDARDS CALIBRATION (100% Level):**
-**Core Biomechanical Metrics:**
-- **Hip Rotation**: 25-90° (Professional range - multiple successful approaches)
-- **Shoulder Rotation**: 60-120° (Professional upper body coil range)
-- **Posture Score**: 95-99% (Exceptional spine angle consistency across all professionals)
-- **Weight Shift**: 53-90% (Professional range varies significantly by style)
-
-**Upper Body Excellence:**
-- **Arm Extension**: 62-100% (Wide professional range - Lydia shows low extension can work)
-- **Wrist Hinge**: 93-120° (Optimal lag and release timing)
-- **Swing Plane Consistency**: 70-85% (Professional-level repeatability)
-- **Chest Rotation Efficiency**: 66-100% (Coordination varies by swing style)
-
-**Power & Efficiency Markers:**
-- **Energy Transfer Efficiency**: 65-97% (Wide professional range - multiple successful approaches)
-- **Power Accumulation**: 84-100% (Power generation across all styles)
-- **Sequential Kinematic Sequence**: 69-100% (Professional coordination standards)
-- **Potential Distance**: 242-296 yards (Professional power range)
-
-**Movement Quality Standards:**
-- **Head Movement**: 1-8 inches (Controlled movement varies by professional)
-- **Ground Force Efficiency**: 53-90% (Professional ground interaction range)
-- **Hip Thrust**: 30-100% (Lower body drive varies significantly)
-
-### **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 (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 PROFESSIONAL AND AMATEUR ANALYSIS:**
-1. **Hip Rotation Shows Variation**: Professionals range from 63-90°, with moderate rotation (63°) and full rotation (90°) both achieving elite results
-2. **Shoulder Rotation Critical Threshold**: 120° consistently achieved by all professionals, showing this as the elite standard
-3. **Multiple Successful Swing Styles**: Body-dominant swings both achieve elite results with different hip mobility approaches
-4. **Posture Consistency Universal**: All professionals maintain 95-99% posture scores regardless of swing style
-5. **Arm Extension Varies Dramatically**: Professional range 62-100% shows that both high extension (96-100%) and compact swings (62%) can be highly effective
-6. **Energy Transfer Multiple Pathways**: Range from 88-97% in professionals, showing consistent high-level power generation approaches
-7. **Power Accumulation Excellence**: All professionals achieve 100% efficiency, showing this as the elite standard
-8. **Distance Generation Diversity**: Professional distances range 285-296 yards through different mechanical approaches
-9. **Weight Transfer Success Patterns**: Professional range 63-90% shows multiple effective weight shift strategies
-10. **Sequential Timing Excellence**: Professional kinematic sequence consistently at 100%, showing perfect coordination as the standard
-11. **Wrist Hinge Consistency**: Professionals range 93-120°, showing different but effective lag and release strategies
-12. **Ground Force Utilization Excellence**: Range 63-90% with elite players achieving consistent high efficiency through proper lower body mechanics
-
-## 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
+    # Format swing phase data (keep for LLM context)
+    swing_phase_data = ""
     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### 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 += 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 += 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 += 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 += """
-
-## ANALYSIS INSTRUCTIONS
-
-**GOLF SWING ANALYSIS FORMAT**
-Use the benchmarks above to guide your evaluation. Follow this exact format:
-
-**PERFORMANCE_CLASSIFICATION:** [XX%]
-(XX = number from 10% to 100%)
-
-**Strengths**
-
-Write exactly 3 strengths, numbered 1–3. For each:
-- Start with the topic name followed by a colon
-- Write 1 short, positive sentence
-- Compare to pro-level or elite standards
-
-Example:
-1. Arm Extension:
-Excellent extension at impact, this maintains a wide swing arc, just like elite players.
-
-**Areas for Improvement**
-
-Write exactly 3 areas for improvement, numbered 1–3. For each:
-- Use format: Topic — Your metric, pro range
-- Write 1 short sentence explaining the issue
-
-Example:
-1. Hip Rotation — 12.7°, pros range from 25–90°
-Limited rotation reduces power and distance.
-
-**Practice Tips**
-
-Write exactly 3 practice tips, numbered 1–3. For each:
-- Start with the topic name followed by “Drill:”
-- Write 1 short sentence that describes what to practice
-
-Example:
-1. Ground Force Timing Drill:
-Focus on pushing against the ground earlier in the downswing.
-
-**SCORING GUIDELINES (Use to help decide % score)**
-
-| Metric | Professional Standard | Note |
-|--------|----------------------|------|
-| Hip Rotation | 25°–90° | <25° is weak |
-| Shoulder Rotation | 60°–120° | <60° is weak |
-| Energy Transfer | 65–97% | <65% = score <60% |
-| Sequential Kinematics | 69–100% | <69% = score <70% |
-| Weight Shift | 53–90% | <53% = weakness |
-| Head Movement | 1–8 in | >8 in = major issue |
-| Arm Extension | 62–100% | <62% = weakness |
-| Power Accumulation | 84–100% | <84% = weakness |
-
-**Classification Bands:**
-- **90–100%**: Tour-level
-- **80–89%**: Advanced amateur
-- **70–79%**: Skilled
-- **60–69%**: Intermediate
-- **50–59%**: Developing
-- **40–49%**: Beginner
-- **10–39%**: Novice
-
-**STYLE & FORMATTING RULES:**
-- Use these headers: PERFORMANCE_CLASSIFICATION, Strengths, Areas for Improvement, Practice Tips
-- No emojis anywhere in the response
-- Use an em dash in Areas for Improvement (Topic — metric), and colons elsewhere
-- Use numbered lists (1-3) for each section
-- Tie all points to professional standards
-- Use a positive, coaching tone throughout
-- Avoid saying "perfect" — say "strong" or "meets standards"
-- Focus on biomechanics, not timing (e.g. tempo, frame count)
-
-**PRACTICE TIPS MUST USE ONLY THESE PROVEN SWING DRILLS:**
-- Ground Force Timing (push against ground earlier in downswing)
-- Halfway Back Drill (check club position when lead arm parallel to ground)
-- Takeaway Drill (practice one-piece takeaway movement)
-- Impact Drill (work on strong left side position at impact)
-- Extension & Rotation Drill (perfect arm rotation through impact)
-- Feet Together L-to-L Swings (continuous swings with feet together)
-- Two-Tee Drill (swing through tee gate for driver path)
-- Mirror Work (practice setup and positions)
-- Ballistic Exercises (explosive movements for power development)
-- Strength Training (for mobility and power foundation)
-"""
-
-    return prompt
+        swing_phase_data += f"- {phase_name.title()}: {phase_data.get('frame_count', 0)} frames ({phase_data.get('duration_ms', 0):.0f}ms)\n"
+    swing_phase_data += f"- Total Swing: {timing_metrics.get('total_swing_frames', 0)} frames ({timing_metrics.get('total_swing_time_ms', 0):.0f}ms)\n"
+    tempo_display = format_metric_for_llm(core_metrics.get('tempo_ratio', {}))
+    swing_phase_data += f"- Tempo Ratio (back:down): {tempo_display}\n"
+    
+    # Format the 5 core metrics
+    core_mechanics = f"- Tempo Ratio: {tempo_display}\n"
+    core_mechanics += f"- Shoulder Rotation (at top): {format_metric_for_llm(core_metrics.get('shoulder_rotation_top_deg', {}), '°')}\n"
+    core_mechanics += f"- Hip Rotation (at impact): {format_metric_for_llm(core_metrics.get('hip_rotation_impact_deg', {}), '°')}\n"
+    core_mechanics += f"- X-Factor (at top): {format_metric_for_llm(core_metrics.get('x_factor_top_deg', {}), '°')}\n"
+    core_mechanics += f"- Posture Score: {format_metric_for_llm(core_metrics.get('posture_score_pct', {}), '%')}\n"
+
+    # Simplified sections (no longer used but keep for template compatibility)
+    upper_body = "- Core metrics focused analysis\n"
+    lower_body = "- Core metrics focused analysis\n"
+    movement_quality = "- Core metrics focused analysis\n"
+
+    # Format the template
+    return COACH_PROMPT.format(
+        swing_phase_data=swing_phase_data,
+        core_mechanics=core_mechanics,
+        upper_body=upper_body,
+        lower_body=lower_body,
+        movement_quality=movement_quality
+    )
 
 
 def parse_and_format_analysis(raw_analysis):
@@ -618,14 +708,18 @@ def parse_and_format_analysis(raw_analysis):
         raw_analysis (str): Raw analysis text from LLM
         
     Returns:
-        dict: Structured analysis with classification, strengths/weaknesses, and priorities
+        dict: Structured analysis with classification and metric evaluations
     """
     # Default structure
     formatted_analysis = {
         'classification': 50,  # Default to 50%
-        'strengths': [],
-        'weaknesses': [],
-        'priority_improvements': []
+        'metric_evaluations': {
+            'tempo_ratio': '',
+            'shoulder_rotation': '',
+            'hip_rotation': '',
+            'x_factor': '',
+            'posture_score': ''
+        }
     }
     
     # Extract percentage classification using the new structured format
@@ -650,47 +744,40 @@ def parse_and_format_analysis(raw_analysis):
                 formatted_analysis['classification'] = max(10, min(100, percentage))
                 break
     
-    # Extract strengths using the new structured format
-    strengths_match = re.search(r'\*\*Strengths\*\*\s*(.*?)(?=\*\*Areas for Improvement\*\*|\*\*Practice Tips\*\*|$)', raw_analysis, re.IGNORECASE | re.DOTALL)
-    if strengths_match:
-        strengths_text = strengths_match.group(1)
-        # Extract numbered items allowing digits/percentages in description until next numbered item
-        # Pattern: 1. Topic: Sentence.
-        strength_items = re.findall(r'\n?\s*\d+\.\s*([^:]+):\s*([\s\S]*?)(?=(?:\n\s*\d+\.|\n\s*\*\*|$))', strengths_text)
-        cleaned_strengths = []
-        for topic, desc in strength_items:
-            topic_clean = topic.strip()
-            # Clean and preserve the full description
-            desc_clean = desc.strip().replace('\n', ' ')
-            if topic_clean and desc_clean:
-                cleaned_strengths.append(f"{topic_clean}: {desc_clean}")
-        # Ensure exactly three strengths
-        formatted_analysis['strengths'] = cleaned_strengths[:3]
-        # If fewer than three were parsed, fall back to any colon-style lines present
-        if len(formatted_analysis['strengths']) < 3:
-            fallback_items = re.findall(r'^[\-•]?\s*([^:\n]+):\s*(.+)$', strengths_text, re.MULTILINE)
-            for topic, desc in fallback_items:
-                item = f"{topic.strip()}: {desc.strip()}"
-                if item not in formatted_analysis['strengths']:
-                    formatted_analysis['strengths'].append(item)
-                if len(formatted_analysis['strengths']) >= 3:
-                    break
+    # Extract metric evaluations
+    metric_patterns = {
+        'tempo_ratio': r'\*\*1\.\s*Tempo\s*Ratio\s*Evaluation:\*\*\s*(.*?)(?=\*\*2\.|$)',
+        'shoulder_rotation': r'\*\*2\.\s*Shoulder\s*Rotation.*?Evaluation:\*\*\s*(.*?)(?=\*\*3\.|$)',
+        'hip_rotation': r'\*\*3\.\s*Hip\s*Rotation.*?Evaluation:\*\*\s*(.*?)(?=\*\*4\.|$)',
+        'x_factor': r'\*\*4\.\s*X-Factor.*?Evaluation:\*\*\s*(.*?)(?=\*\*5\.|$)',
+        'posture_score': r'\*\*5\.\s*Posture\s*Score\s*Evaluation:\*\*\s*(.*?)(?=\*\*|$)'
+    }
+    
+    for metric_key, pattern in metric_patterns.items():
+        match = re.search(pattern, raw_analysis, re.IGNORECASE | re.DOTALL)
+        if match:
+            evaluation_text = match.group(1).strip()
+            # Clean up the text and remove extra whitespace/newlines
+            evaluation_clean = re.sub(r'\s+', ' ', evaluation_text).strip()
+            formatted_analysis['metric_evaluations'][metric_key] = evaluation_clean
+    
+    # Fallback evaluations if any metrics are missing
+    fallback_evaluations = {
+        'tempo_ratio': 'Analysis in progress. Tempo ratio measures the relationship between backswing and downswing timing. Professional golfers typically maintain consistent tempo ratios for optimal power transfer.',
+        'shoulder_rotation': 'Analysis in progress. Shoulder rotation at the top of the backswing is critical for power generation. Elite players achieve 60-120 degrees of shoulder turn.',
+        'hip_rotation': 'Analysis in progress. Hip rotation at impact determines power transfer efficiency. Professional standards range from 25-90 degrees depending on swing style.',
+        'x_factor': 'Analysis in progress. X-Factor represents the separation between shoulders and hips at the top. This differential creates the coil needed for power generation.',
+        'posture_score': 'Analysis in progress. Posture score reflects spine angle consistency throughout the swing. Elite players maintain 95-99% posture scores for optimal mechanics.'
+    }
     
-    # Extract areas for improvement using the new structured format
-    weaknesses_match = re.search(r'\*\*Areas for Improvement\*\*\s*(.*?)(?=\*\*Practice Tips\*\*|$)', raw_analysis, re.IGNORECASE | re.DOTALL)
-    if weaknesses_match:
-        weaknesses_text = weaknesses_match.group(1)
-        # Extract numbered items (1. Topic — metric info\nExplanation)
-        weakness_items = re.findall(r'\d+\.\s*([^—\n]+)—([^\n]+)\n?([^\d]+)?', weaknesses_text)
-        formatted_analysis['weaknesses'] = []
-        for topic, metric, explanation in weakness_items:
-            if topic.strip() and metric.strip():
-                full_text = f"{topic.strip()} — {metric.strip()}"
-                if explanation and explanation.strip():
-                    full_text += f"\n{explanation.strip()}"
-                formatted_analysis['weaknesses'].append(full_text)
+    for metric_key, fallback in fallback_evaluations.items():
+        if not formatted_analysis['metric_evaluations'][metric_key]:
+            formatted_analysis['metric_evaluations'][metric_key] = fallback
     
-    # Extract practice tips using the new structured format
+    return formatted_analysis
+
+
+def display_formatted_analysis(analysis_data):
     priority_match = re.search(r'\*\*Practice Tips\*\*\s*(.*?)$', raw_analysis, re.IGNORECASE | re.DOTALL)
     if priority_match:
         priority_text = priority_match.group(1)
@@ -850,374 +937,37 @@ def parse_and_format_analysis(raw_analysis):
 
 def display_formatted_analysis(analysis_data):
     """
-    Display the formatted analysis with performance classification, strengths/weaknesses table, and priorities
+    Display the formatted analysis with individual metric evaluations
     
     Args:
         analysis_data (dict): Structured analysis data from parse_and_format_analysis
     """
-    # 1. Performance classification is kept for logic but hidden from the UI
+    # Performance classification is kept for logic but hidden from the UI
     user_percentage = analysis_data['classification']
     
     st.markdown("---")
     
-    # 2. Strengths and Weaknesses Table
-    st.subheader("Strengths & Areas for Improvement")
-    
-    # Create responsive columns - divider hidden on mobile
-    st.markdown("""
-    <style>
-    @media (max-width: 768px) {
-        .desktop-divider { display: none !important; }
-    }
-    </style>
-    """, unsafe_allow_html=True)
-    
-    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 i, strength in enumerate(analysis_data['strengths'], 1):
-            st.markdown(f"{i}. {strength}")
-        st.markdown("</div>", unsafe_allow_html=True)
-    
-    with col_divider:
-        st.markdown("""
-        <div class='desktop-divider' 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 i, weakness in enumerate(analysis_data['weaknesses'], 1):
-            st.markdown(f"{i}. {weakness}")
-        st.markdown("</div>", unsafe_allow_html=True)
-    
-    # Practice Tips are computed but intentionally not displayed in the UI
-
-
-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
-    """
-    # Initialize default metrics that will be returned even if calculations fail
-    metrics = {
-        "hip_rotation": 25,
-        "shoulder_rotation": 60,
-        "weight_shift": 0.5,
-        "posture_score": 0.6,
-        "arm_extension": 0.6,
-        "wrist_hinge": 60,
-        "head_movement_lateral": 3.0,
-        "head_movement_vertical": 2.0,
-        "knee_flexion_address": 25,
-        "knee_flexion_impact": 30,
-        "swing_plane_consistency": 0.6,
-        "chest_rotation_efficiency": 0.6,
-        "hip_thrust": 0.5,
-        "ground_force_efficiency": 0.6,
-        "transition_smoothness": 0.6,
-        "kinematic_sequence": 0.6,
-        "energy_transfer": 0.6,
-        "power_accumulation": 0.6,
-        "potential_distance": 200,
-        "speed_generation": "Mixed"
-    }
-    
-    def safe_get_keypoint(keypoints, index, default_pos=[0.0, 0.0]):
-        """Safely get a keypoint position with bounds checking"""
-        try:
-            if index < len(keypoints) and keypoints[index] is not None:
-                kp = keypoints[index]
-                # Handle different keypoint formats
-                if isinstance(kp, (list, tuple)) and len(kp) >= 2:
-                    return [float(kp[0]), float(kp[1])]
-                elif hasattr(kp, 'x') and hasattr(kp, 'y'):
-                    return [float(kp.x), float(kp.y)]
-            return default_pos
-        except (IndexError, TypeError, AttributeError):
-            return default_pos
-    
-    # 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) >= 25 and len(backswing_keypoints) >= 25:
-                # Hip rotation calculation using hip landmarks
-                setup_left_hip = np.array(safe_get_keypoint(setup_keypoints, 23))
-                setup_right_hip = np.array(safe_get_keypoint(setup_keypoints, 24))
-                backswing_left_hip = np.array(safe_get_keypoint(backswing_keypoints, 23))
-                backswing_right_hip = np.array(safe_get_keypoint(backswing_keypoints, 24))
-                
-                # Calculate hip line angles
-                setup_hip_vector = setup_right_hip - setup_left_hip
-                backswing_hip_vector = backswing_right_hip - backswing_left_hip
-                
-                if np.linalg.norm(setup_hip_vector) > 0 and np.linalg.norm(backswing_hip_vector) > 0:
-                    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)
-            
-        # 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) >= 13 and len(backswing_keypoints) >= 13:
-                # Shoulder rotation calculation
-                setup_left_shoulder = np.array(safe_get_keypoint(setup_keypoints, 11))
-                setup_right_shoulder = np.array(safe_get_keypoint(setup_keypoints, 12))
-                backswing_left_shoulder = np.array(safe_get_keypoint(backswing_keypoints, 11))
-                backswing_right_shoulder = np.array(safe_get_keypoint(backswing_keypoints, 12))
-                
-                setup_shoulder_vector = setup_right_shoulder - setup_left_shoulder
-                backswing_shoulder_vector = backswing_right_shoulder - backswing_left_shoulder
-                
-                if np.linalg.norm(setup_shoulder_vector) > 0 and np.linalg.norm(backswing_shoulder_vector) > 0:
-                    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)
-            
-        # 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) >= 29 and len(impact_keypoints) >= 29:
-                # Use center of mass approximation
-                setup_left_ankle = np.array(safe_get_keypoint(setup_keypoints, 27))
-                setup_right_ankle = np.array(safe_get_keypoint(setup_keypoints, 28))
-                impact_left_ankle = np.array(safe_get_keypoint(impact_keypoints, 27))
-                impact_right_ankle = np.array(safe_get_keypoint(impact_keypoints, 28))
-                
-                # 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)
-                    metrics["weight_shift"] = weight_shift
-            
-        # 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]) >= 25:
-                    keypoints = pose_data[frame]
-                    # Use shoulder and hip landmarks to estimate spine angle
-                    left_shoulder = np.array(safe_get_keypoint(keypoints, 11))
-                    right_shoulder = np.array(safe_get_keypoint(keypoints, 12))
-                    left_hip = np.array(safe_get_keypoint(keypoints, 23))
-                    right_hip = np.array(safe_get_keypoint(keypoints, 24))
-                    
-                    shoulder_center = (left_shoulder + right_shoulder) / 2
-                    hip_center = (left_hip + right_hip) / 2
-                    
-                    spine_vector = shoulder_center - hip_center
-                    if np.linalg.norm(spine_vector) > 0:
-                        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))
-            
-        # Calculate Arm Extension at Impact
-        if impact_frame and impact_frame in pose_data and len(pose_data[impact_frame]) >= 17:
-            keypoints = pose_data[impact_frame]
-            right_shoulder = np.array(safe_get_keypoint(keypoints, 12))
-            right_elbow = np.array(safe_get_keypoint(keypoints, 14))
-            right_wrist = np.array(safe_get_keypoint(keypoints, 16))
-            
-            # 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)
-            
-        # 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:
-                    try:
-                        angles = calculate_joint_angles(pose_data[frame])
-                        if angles and "right_wrist" in angles:
-                            wrist_angles.append(angles["right_wrist"])
-                    except Exception:
-                        pass  # Skip if joint angle calculation fails
-        
-        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)
-            
-        # 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) >= 1 and len(impact_keypoints) >= 1:
-                # Use nose landmark (index 0) for head position
-                setup_head = np.array(safe_get_keypoint(setup_keypoints, 0))
-                impact_head = np.array(safe_get_keypoint(impact_keypoints, 0))
-                
-                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
-                    mouth_pos = safe_get_keypoint(setup_keypoints, 10)
-                    head_height_pixels = abs(setup_head[1] - mouth_pos[1])
-                    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)
-            
-        # 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]) >= 29:
-                    keypoints = pose_data[frame]
-                    # Right knee angle using hip, knee, ankle
-                    right_hip = np.array(safe_get_keypoint(keypoints, 24))
-                    right_knee = np.array(safe_get_keypoint(keypoints, 26))
-                    right_ankle = np.array(safe_get_keypoint(keypoints, 28))
-                    
-                    # 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)
-        
-        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
+    # Display metric evaluations
+    st.subheader("Individual Metric Evaluations")
+    
+    # Define the metric names and order
+    metrics = [
+        ('tempo_ratio', 'Tempo Ratio'),
+        ('shoulder_rotation', 'Shoulder Rotation @ Top'), 
+        ('hip_rotation', 'Hip Rotation @ Impact'),
+        ('x_factor', 'X-Factor @ Top'),
+        ('posture_score', 'Posture Score')
+    ]
+    
+    for metric_key, metric_display_name in metrics:
+        evaluation = analysis_data['metric_evaluations'].get(metric_key, '')
+        
+        if evaluation:
+            st.markdown(f"""
+            <div style='background-color: #f8f9fa; padding: 15px; border-radius: 10px; margin-bottom: 15px; border-left: 4px solid #0066cc;'>
+                <h4 style='color: #0066cc; margin-top: 0; margin-bottom: 10px;'>{metric_display_name}</h4>
+                <p style='margin: 0; line-height: 1.6;'>{evaluation}</p>
+            </div>
+            """, unsafe_allow_html=True)
         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)}")
-        # Don't return None - instead return the default metrics that were initialized
-        pass
-    
-    return metrics
+            st.markdown(f"**{metric_display_name}**: Evaluation not available")

app/models/math_utils.py

@@ -0,0 +1,349 @@
+"""
+Minimal math utilities for golf swing analysis
+"""
+import math
+import numpy as np
+
+# New functions for 5 core metrics implementation
+def _angle_deg_2d(ax, ay, bx, by):
+    """angle of vector a->b vs +X axis, in degrees"""
+    return math.degrees(math.atan2(by - ay, bx - ax))
+
+def line_angle(points_left, points_right):
+    """points_* are (x,y) tuples; returns angle of L->R line in degrees"""
+    (lx, ly), (rx, ry) = points_left, points_right
+    return _angle_deg_2d(lx, ly, rx, ry)
+
+def rel_rotation_deg(angle_now, angle_addr):
+    """normalize relative rotation to [-180,180]"""
+    d = angle_now - angle_addr
+    while d > 180: d -= 360
+    while d < -180: d += 360
+    return d
+
+MP_SHOULDERS = (11, 12)
+MP_HIPS = (23, 24)
+
+def vis_ok(kp, idxs, thr=0.4):
+    """Check if keypoints at given indices have sufficient visibility"""
+    if kp is None or len(kp) <= max(idxs): 
+        return False
+    return all(kp[i][2] >= thr for i in idxs)
+
+def seg_angle(p1, p2):
+    """Angle (deg) of segment p1->p2 vs +x axis"""
+    return math.degrees(math.atan2(p2[1]-p1[1], p2[0]-p1[0]))
+
+def ang_diff(a, b):
+    """Signed difference in [-180, 180]"""
+    d = (a - b + 180) % 360 - 180
+    return d
+
+def pair_rotation_deg(kp_now, kp_addr, ids_pair, clamp=None):
+    """Rotation between the same landmark pair now vs address, robust in 2D."""
+    if kp_now is None or kp_addr is None: 
+        return None
+    L, R = ids_pair
+    if not (vis_ok(kp_now, (L, R)) and vis_ok(kp_addr, (L, R))):
+        return None
+
+    pL_now, pR_now = kp_now[L][:2], kp_now[R][:2]
+    pL_addr, pR_addr = kp_addr[L][:2], kp_addr[R][:2]
+
+    ang_now  = seg_angle(pL_now,  pR_now)
+    ang_addr = seg_angle(pL_addr, pR_addr)
+    rot = abs(ang_diff(ang_now, ang_addr))
+    if clamp:
+        lo, hi = clamp
+        rot = max(lo, min(hi, rot))
+    return rot
+
+def med1d(vals, k=5):
+    """Median filter that ignores None; returns None if a window has no numbers."""
+    if not vals:
+        return vals
+    x = np.array([np.nan if v is None else float(v) for v in vals], dtype=float)
+    n = len(x)
+    if n < k:
+        # simple: return the original list; but convert NaN back to None
+        return [None if np.isnan(v) else float(v) for v in x]
+
+    pad = k // 2
+    xp = np.pad(x, (pad, pad), mode='edge')
+
+    out = []
+    for i in range(n):
+        win = xp[i:i+k]
+        # ignore NaNs
+        nn = win[~np.isnan(win)]
+        if nn.size == 0:
+            out.append(None)             # <-- key: not NaN
+        else:
+            out.append(float(np.median(nn)))
+    return out
+
+
+def _dt_and_fps(frame_timestamps_ms, frames: int, total_ms: float):
+    """
+    Calculate time delta and FPS from frame data.
+    
+    Args:
+        frame_timestamps_ms: List of frame timestamps in milliseconds (optional)
+        frames: Total number of frames
+        total_ms: Total duration in milliseconds
+        
+    Returns:
+        tuple: (dt in seconds, fps)
+    """
+    if frame_timestamps_ms and len(frame_timestamps_ms) >= 2:
+        dt = (frame_timestamps_ms[-1] - frame_timestamps_ms[0]) / max(len(frame_timestamps_ms) - 1, 1) / 1000.0
+    else:
+        dt = (total_ms / 1000.0) / max(frames, 1)
+    return dt, 1.0 / max(dt, 1e-6)
+
+
+def detect_arm_velocity_zero_crossing(pose_data, frames):
+    """
+    Detect top of swing using multiple biomechanical markers for robustness.
+    
+    Args:
+        pose_data: Dictionary mapping frame indices to pose keypoints
+        frames: List of frame indices to analyze
+        
+    Returns:
+        int: Frame index of top of swing (or fallback to time-based)
+    """
+    if len(frames) < 8:  # Need minimum frames for velocity calculation
+        return frames[len(frames)//3] if frames else 0
+    
+    # Try multiple methods to find top of backswing
+    top_candidates = []
+    
+    # Method 1: Lead arm angular velocity zero crossing
+    arm_angles = []
+    valid_frames = []
+    
+    for frame_idx in frames:
+        if frame_idx not in pose_data or pose_data[frame_idx] is None:
+            continue
+        kp = pose_data[frame_idx]
+        
+        # Check for lead arm keypoints (right arm for right-handed golfer)
+        if (len(kp) > 16 and kp[12][2] > 0.4 and kp[16][2] > 0.4):  # right shoulder & wrist
+            shoulder = kp[12][:2]
+            wrist = kp[16][:2]
+            # Calculate arm angle relative to horizontal (more stable than vertical)
+            angle = math.degrees(math.atan2(wrist[1] - shoulder[1], wrist[0] - shoulder[0]))
+            arm_angles.append(angle)
+            valid_frames.append(frame_idx)
+    
+    if len(arm_angles) >= 5:
+        # Smooth the angles to reduce noise
+        smoothed_angles = []
+        window = 3
+        for i in range(len(arm_angles)):
+            start_idx = max(0, i - window//2)
+            end_idx = min(len(arm_angles), i + window//2 + 1)
+            smoothed_angles.append(sum(arm_angles[start_idx:end_idx]) / (end_idx - start_idx))
+        
+        # Calculate angular velocity with smoothed data
+        velocities = []
+        for i in range(1, len(smoothed_angles)):
+            vel = smoothed_angles[i] - smoothed_angles[i-1]
+            velocities.append(vel)
+        
+        # Find the most significant zero crossing (velocity → 0 or negative)
+        for i in range(2, len(velocities)-1):  # Skip first/last to avoid noise
+            if velocities[i-1] > 0.5 and velocities[i] <= 0:  # Threshold to avoid noise
+                top_candidates.append(valid_frames[i])
+                break
+        
+        # Fallback: maximum angle position
+        if not top_candidates and smoothed_angles:
+            max_idx = smoothed_angles.index(max(smoothed_angles))
+            if max_idx < len(valid_frames):
+                top_candidates.append(valid_frames[max_idx])
+    
+    if top_candidates:
+        return top_candidates[0]
+    
+    # Final fallback: time-based estimate (typically 65-70% through backswing phase)
+    fallback_idx = int(len(frames) * 0.65)
+    return frames[min(fallback_idx, len(frames)-1)] if frames else 0
+
+
+def validate_metric_sanity(metric_name, value, player_handedness='right'):
+    """
+    Validate biomechanical metrics against tour professional ranges.
+    
+    Args:
+        metric_name: Name of the metric to validate
+        value: The calculated value
+        player_handedness: 'right' or 'left' handed player
+        
+    Returns:
+        tuple: (is_valid, corrected_value_or_none)
+    """
+    if value is None or value == 'n/a':
+        return True, value
+    
+    # Define tour professional ranges (all absolute values now)
+    ranges = {
+        'tempo_ratio': (2.0, 5.0),  # Typical 2:1 to 5:1 backswing:downswing
+        'shoulder_rotation_top_deg': (60.0, 120.0),  # Thorax rotation magnitude at top (more lenient range)
+        'hip_rotation_impact_deg': (20.0, 55.0),  # Hip opening magnitude at impact (expanded for variation)
+        'x_factor_top_deg': (15.0, 60.0),  # Shoulder-hip separation (expanded range)
+        'posture_score_pct': (50.0, 100.0)  # Posture percentage (more lenient)
+    }
+    
+    if metric_name not in ranges:
+        return True, value  # Unknown metric, don't validate
+    
+    min_val, max_val = ranges[metric_name]
+    
+    # Check if value is within reasonable range (values are now all absolute)
+    if min_val <= value <= max_val:
+        return True, value
+    else:
+        # Value is outside professional range - flag as unreliable
+        return False, None
+
+
+def get_target_line_angle(pose_data, address_frame_idx):
+    """
+    Estimate target line angle from golfer's stance at address.
+    Uses the line between feet to approximate target direction.
+    
+    Args:
+        pose_data: Dictionary mapping frame indices to pose keypoints  
+        address_frame_idx: Frame index for address position
+        
+    Returns:
+        float: Target line angle in degrees (0 = pointing right, 90 = pointing up)
+    """
+    if address_frame_idx not in pose_data or pose_data[address_frame_idx] is None:
+        return 0.0  # Default to horizontal
+    
+    kp = pose_data[address_frame_idx]
+    
+    # Use ankle positions (27=left ankle, 28=right ankle) for stance line
+    if (len(kp) > 28 and kp[27][2] > 0.5 and kp[28][2] > 0.5):
+        left_ankle = kp[27][:2]
+        right_ankle = kp[28][:2]
+        return line_angle(left_ankle, right_ankle)
+    
+    # Fallback to hip line if ankles not visible
+    if (len(kp) > 24 and kp[23][2] > 0.5 and kp[24][2] > 0.5):
+        left_hip = kp[23][:2]
+        right_hip = kp[24][:2]
+        return line_angle(left_hip, right_hip)
+    
+    return 0.0  # Default fallback
+
+
+def calculate_thorax_rotation(shoulder_keypoints, reference_angle=0.0, target_line_angle=0.0, reference_keypoints=None):
+    """
+    Calculate thorax (upper torso) rotation for golf swing analysis.
+    Returns constrained rotation magnitude from address position.
+
+    Args:
+        shoulder_keypoints: Tuple of (left_shoulder, right_shoulder) points
+        reference_angle: Reference angle (e.g., at address) in degrees
+        target_line_angle: Target line angle in degrees
+        reference_keypoints: Optional reference shoulder positions for fallback calculation
+
+    Returns:
+        float or tuple: Thorax rotation magnitude in degrees, or (value, 'estimated') if line flip corrected
+    """
+    left_shoulder, right_shoulder = shoulder_keypoints
+
+    # Calculate shoulder line angle
+    current_angle = line_angle(left_shoulder, right_shoulder)
+
+    # Calculate rotation relative to reference (address position)
+    relative_rotation = rel_rotation_deg(current_angle, reference_angle)
+
+    # Take absolute value for magnitude
+    rotation_magnitude = abs(relative_rotation)
+
+    # Debug: If rotation is very small, it might indicate tracking issues
+    if rotation_magnitude < 10.0:
+        # Try alternative calculation using shoulder displacement
+        if reference_keypoints is not None:
+            ref_left, ref_right = reference_keypoints
+            
+            # Calculate actual shoulder movement (displacement method)
+            left_displacement = ((left_shoulder[0] - ref_left[0])**2 + 
+                               (left_shoulder[1] - ref_left[1])**2)**0.5
+            right_displacement = ((right_shoulder[0] - ref_right[0])**2 + 
+                                (right_shoulder[1] - ref_right[1])**2)**0.5
+            
+            # If significant displacement occurred, estimate rotation
+            if left_displacement > 20 or right_displacement > 20:
+                # Use displacement to estimate rotation (approximate)
+                estimated_rotation = max(left_displacement, right_displacement) * 0.5  # rough conversion
+                rotation_magnitude = max(rotation_magnitude, min(estimated_rotation, 100.0))
+        
+        # Check if shoulders are reasonably spaced
+        shoulder_distance = ((left_shoulder[0] - right_shoulder[0])**2 + 
+                           (left_shoulder[1] - right_shoulder[1])**2)**0.5
+        
+        # If shoulders are too close together, pose estimation might be poor
+        if shoulder_distance < 50:  # pixels - shoulders should be reasonably far apart
+            return None  # Indicate unreliable measurement
+        
+        # If still very small but shoulders are properly spaced, use minimum for golf
+        if rotation_magnitude < 25.0:
+            # Golf swings always have significant shoulder rotation, so set a reasonable minimum
+            rotation_magnitude = 35.0  # Conservative estimate for golf swing when tracking is poor
+    
+    # Constrain to reasonable golf swing range
+    # If we get exactly 180° or very close, it's likely a line flip issue
+    line_flip_corrected = False
+    if rotation_magnitude > 160:
+        print(f"DEBUG CALC: Line flip detected! Original magnitude: {rotation_magnitude}")
+        # Likely a 180° flip - this indicates significant shoulder rotation
+        # For golf swings, a 180° flip usually means ~90° actual rotation
+        rotation_magnitude = 90.0  # Reasonable estimate for significant shoulder turn
+        line_flip_corrected = True
+        print(f"DEBUG CALC: Corrected to: {rotation_magnitude}")
+    
+    # Clamp to maximum reasonable shoulder rotation (140° is extreme but possible)
+    rotation_magnitude = min(rotation_magnitude, 140.0)
+    
+    # Return with status if it was an estimate
+    if line_flip_corrected:
+        return rotation_magnitude, 'estimated'
+    else:
+        return rotation_magnitude
+
+
+def calculate_pelvis_rotation(hip_keypoints, reference_angle=0.0, player_handedness='right', target_line_angle=0.0):
+    """
+    Calculate pelvis rotation for golf swing analysis with proper golf conventions.
+
+    Args:
+        hip_keypoints: Tuple of (left_hip, right_hip) points
+        reference_angle: Reference angle (e.g., at address) in degrees
+        player_handedness: 'right' or 'left' handed player
+        target_line_angle: Target line angle in degrees
+
+    Returns:
+        float: Pelvis rotation in degrees (positive = open to target for impact measurement)
+    """
+    left_hip, right_hip = hip_keypoints
+
+    # Calculate hip line angle
+    current_angle = line_angle(left_hip, right_hip)
+
+    # Calculate rotation relative to reference
+    rotation = rel_rotation_deg(current_angle, reference_angle)
+
+    # Take absolute value for magnitude
+    rotation_magnitude = abs(rotation)
+
+    # Constrain to reasonable hip rotation range
+    # Tour pros typically open 30-40° at impact, maximum realistic is ~60°
+    rotation_magnitude = min(rotation_magnitude, 60.0)
+
+    return rotation_magnitude

app/models/pose_estimator.py

@@ -5,13 +5,16 @@ Pose estimation module for golf swing analysis
 import cv2
 import numpy as np
 import mediapipe as mp
+import math
 from tqdm import tqdm
 
+# Keep only essential imports for pose detection
+
 class PoseEstimator:
     def __init__(self):
         self.mp_pose = mp.solutions.pose
         self.pose = self.mp_pose.Pose(static_image_mode=False,
-                                      model_complexity=1,
+                                      model_complexity=2,  # Improved hip/foot stability
                                       enable_segmentation=False,
                                       min_detection_confidence=0.5,
                                       min_tracking_confidence=0.5)
@@ -19,20 +22,27 @@ class PoseEstimator:
     def process_frame(self, frame):
         frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
         results = self.pose.process(frame_rgb)
-        keypoints = []
         h, w, _ = frame.shape
 
         if results.pose_landmarks:
+            keypoints = []
+            total_visibility = 0
             for landmark in results.pose_landmarks.landmark:
                 x, y = int(landmark.x * w), int(landmark.y * h)
                 visibility = landmark.visibility
                 keypoints.append([x, y, visibility])
+                total_visibility += visibility
+            
+            # Check if this is a reasonable pose detection
+            avg_visibility = total_visibility / len(results.pose_landmarks.landmark)
+            if avg_visibility > 0.3:  # Only return if average visibility is decent
+                return keypoints
+            else:
+                # Poor quality detection, return fallback
+                return [[w//2, h//2, 0.05] for _ in range(33)]
         else:
-            center_x, center_y = w // 2, h // 2
-            for _ in range(33):
-                keypoints.append([center_x, center_y, 0.0])
-
-        return keypoints
+            # No pose detected, return very low confidence markers
+            return [[w//2, h//2, 0.05] for _ in range(33)]
 
     def close(self):
         self.pose.close()
@@ -52,55 +62,49 @@ def analyze_pose(frames):
 
     for i, frame in enumerate(tqdm(frames, desc="Analyzing pose")):
         keypoints = pose_estimator.process_frame(frame)
-        # Store all frames, even if no pose is detected
-        pose_data[i] = keypoints if keypoints is not None else []
+        # Always store keypoints (never None due to fallback in process_frame)
+        pose_data[i] = keypoints
 
     pose_estimator.close()
     return pose_data
+
+
+# Deprecated - joint angle calculations removed (not part of 5 core metrics)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 def calculate_joint_angles(keypoints):
     """
-    Calculate joint angles from keypoints.
+    Deprecated function - joint angles are not part of the 5 core metrics.
+    Returns empty dict to maintain backward compatibility.
     
     Args:
-        keypoints: List of [x, y, visibility] for each landmark
+        keypoints: List of [x, y, visibility] for each landmark or None
         
     Returns:
-        Dictionary of joint angles
+        Empty dictionary (joint angles deprecated)
     """
-    if not keypoints or len(keypoints) < 33:  # MediaPipe Pose has 33 landmarks
-        return {}
-    
-    angles = {}
-    
-    # Right shoulder angle (landmarks 11, 13, 15)
-    if all(keypoints[i][2] > 0.5 for i in [11, 13, 15]):
-        shoulder = np.array(keypoints[11][:2])
-        elbow = np.array(keypoints[13][:2])
-        wrist = np.array(keypoints[15][:2])
-        v1 = shoulder - elbow
-        v2 = wrist - elbow
-        angle = np.degrees(np.arccos(np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))))
-        angles["right_shoulder"] = angle
-    
-    # Right elbow angle (landmarks 13, 15, 17)
-    if all(keypoints[i][2] > 0.5 for i in [13, 15, 17]):
-        upper_arm = np.array(keypoints[13][:2])
-        elbow = np.array(keypoints[15][:2])
-        wrist = np.array(keypoints[17][:2])
-        v1 = upper_arm - elbow
-        v2 = wrist - elbow
-        angle = np.degrees(np.arccos(np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))))
-        angles["right_elbow"] = angle
-    
-    # Right wrist angle (landmarks 15, 17, 19)
-    if all(keypoints[i][2] > 0.5 for i in [15, 17, 19]):
-        elbow = np.array(keypoints[15][:2])
-        wrist = np.array(keypoints[17][:2])
-        hand = np.array(keypoints[19][:2])
-        v1 = elbow - wrist
-        v2 = hand - wrist
-        angle = np.degrees(np.arccos(np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))))
-        angles["right_wrist"] = angle
-    
-    return angles
+    # Return empty dict since joint angles are not part of the 5 core metrics
+    return {}

app/models/segmentation.py

@@ -0,0 +1,118 @@
+"""
+Simple swing segmentation with downswing re-gating
+"""
+from .math_utils import _dt_and_fps, detect_arm_velocity_zero_crossing
+
+def segment_swing(pose_data, detections=None, sample_rate=1, frame_shape=None, 
+                 frame_timestamps_ms=None, total_ms=None, fps=30.0):
+    """
+    Simplified swing segmentation with downswing re-gating logic.
+    
+    Args:
+        pose_data: Dictionary mapping frame indices to pose keypoints
+        detections: Object detections (unused in current implementation)
+        sample_rate: Frame sampling rate
+        frame_shape: Frame shape (unused in current implementation)
+        frame_timestamps_ms: List of frame timestamps in milliseconds
+        total_ms: Total video duration in milliseconds
+        fps: Video frame rate (fallback if timestamps not available)
+        
+    Returns:
+        dict: Dictionary with swing phases and timing_unreliable flag
+    """
+    frames = [i for i in sorted(pose_data) if pose_data[i] is not None]
+    out = {"setup":[], "backswing":[], "downswing":[], "impact":[], "follow_through":[], "timing_unreliable": False}
+    if not frames: 
+        return out
+    
+    # Improved segmentation using biomechanical markers
+    total_frames = len(frames)
+    
+    # Setup phase - first 12.5% (this is fairly reliable)
+    setup_end_idx = max(1, total_frames // 8)
+    setup_end = frames[setup_end_idx]
+    
+    # Detect top of swing using arm velocity zero crossing (more reliable than time-based)
+    backswing_frames_for_analysis = [f for f in frames if f > setup_end]
+    top = detect_arm_velocity_zero_crossing(pose_data, backswing_frames_for_analysis)
+    
+    # Robust impact detection using clubhead velocity zero-crossing
+    # Look for the frame where clubhead velocity changes from downward to upward
+    impact_candidates = []
+    if pose_data:
+        # Get frames after top for impact analysis
+        frames_after_top = [f for f in frames if f > top and f in pose_data]
+
+        if len(frames_after_top) >= 5:
+            clubhead_positions = []
+            valid_frames = []
+
+            for frame_idx in frames_after_top:
+                kp = pose_data[frame_idx]
+                if kp and len(kp) > 15:
+                    # Use wrist as proxy for clubhead (lead arm wrist for right-handed)
+                    wrist = kp[15][:2]  # Right wrist
+                    if kp[15][2] > 0.5:  # Good visibility
+                        clubhead_positions.append(wrist[1])  # Y-coordinate (vertical)
+                        valid_frames.append(frame_idx)
+
+            if len(clubhead_positions) >= 5:
+                # Calculate vertical velocity (downward = positive, upward = negative)
+                velocities = []
+                for i in range(1, len(clubhead_positions)):
+                    vel = clubhead_positions[i] - clubhead_positions[i-1]
+                    velocities.append(vel)
+
+                # Find zero crossing: velocity changes from positive to negative
+                for i in range(1, len(velocities)):
+                    if velocities[i-1] > 0 and velocities[i] <= 0:
+                        # Found impact - clubhead starts moving upward
+                        impact_candidates.append(valid_frames[i])
+                        break
+
+    # Fallback: if no velocity zero-crossing found, use timing-based estimate
+    if not impact_candidates:
+        top_idx_in_total = frames.index(top) if top in frames else total_frames // 3
+        remaining_frames_after_top = total_frames - top_idx_in_total
+        # Tour pro downswing: ~8-10 frames at 30fps (25-30% of total swing)
+        expected_downswing_frames = max(8, int(total_frames * 0.25))
+        impact_idx = min(total_frames - 1, top_idx_in_total + expected_downswing_frames)
+        imp = frames[impact_idx]
+    else:
+        imp = impact_candidates[0]
+    
+    # Assign frames to phases
+    for f in frames:
+        if f <= setup_end: 
+            out["setup"].append(f)
+        elif f <= top: 
+            out["backswing"].append(f)
+        elif f < imp: 
+            out["downswing"].append(f)
+        elif f == imp: 
+            out["impact"].append(f)
+        else: 
+            out["follow_through"].append(f)
+    
+    # Get timing information for downswing re-gating
+    if total_ms is None:
+        total_ms = total_frames * (1000.0 / fps)  # fallback estimate
+    dt, actual_fps = _dt_and_fps(frame_timestamps_ms, total_frames, total_ms)
+    
+    # Downswing re-gating logic
+    downswing_frames = out["downswing"]
+    if downswing_frames:
+        downswing_duration_frames = len(downswing_frames)
+        
+        # Scale expected range by fps (~30 fps baseline)
+        fps_scale = actual_fps / 30.0
+        min_expected = max(1, int(6 * fps_scale))
+        max_expected = int(15 * fps_scale)
+        
+        # Check if downswing is outside expected range
+        if downswing_duration_frames < min_expected or downswing_duration_frames > max_expected:
+            # Mark timing as unreliable when downswing duration is outside expected range
+            # (Angular velocity re-gating removed for 5 core metrics simplification)
+            out["timing_unreliable"] = True
+    
+    return out

app/streamlit_app.py

@@ -24,7 +24,7 @@ from utils.video_downloader import download_youtube_video, download_pro_referenc
 from utils.video_processor import process_video
 from models.pose_estimator import analyze_pose
 from models.swing_analyzer import segment_swing, analyze_trajectory
-from 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 models.llm_analyzer import generate_swing_analysis, create_llm_prompt, prepare_data_for_llm, check_llm_services, parse_and_format_analysis, display_formatted_analysis, compute_core_metrics
 from utils.visualizer import create_annotated_video
 from utils.comparison import create_key_frame_comparison, extract_key_swing_frames
 
@@ -163,6 +163,97 @@ def load_rag_system():
         st.error(f"❌ RAG system failed to load: {str(e)}")
         return None
 
+def clamp_for_display(value, min_val, max_val):
+    """Clamp a value for display purposes only"""
+    if value == 'n/a' or value is None:
+        return value
+    try:
+        float_val = float(value)
+        return max(min_val, min(max_val, float_val))
+    except (ValueError, TypeError):
+        return value
+
+
+def format_metric_value(metric_data, unit=""):
+    """Format metric value with status indication"""
+    if not isinstance(metric_data, dict):
+        return 'n/a'
+    
+    value = metric_data.get('value')
+    status = metric_data.get('status', 'n/a')
+    
+    if value is None or status == 'n/a':
+        return 'n/a'
+    elif status == 'ok':
+        return f"{value}{unit}"
+    else:
+        return f"{value} ({status}){unit}"
+
+
+def display_core_summary(core_metrics):
+    """Display the 5 core metrics in a clean summary table"""
+    st.subheader("Core Summary")
+    
+    # Create the metrics data with proper formatting
+    metrics_data = [
+        ["Tempo Ratio", format_metric_value(core_metrics.get("tempo_ratio", {}))],
+        ["Shoulder Rotation @ Top", format_metric_value(core_metrics.get("shoulder_rotation_top_deg", {}), "°")],
+        ["Hip Rotation @ Impact", format_metric_value(core_metrics.get("hip_rotation_impact_deg", {}), "°")],
+        ["X-Factor @ Top", format_metric_value(core_metrics.get("x_factor_top_deg", {}), "°")],
+        ["Posture Score", format_metric_value(core_metrics.get("posture_score_pct", {}), "%")]
+    ]
+    
+    # Display as a clean table
+    import pandas as pd
+    df = pd.DataFrame(metrics_data, columns=["Metric", "Value"])
+    
+    # Style the table
+    styled_df = df.style.set_properties(**{
+        'background-color': '#f8f9fa',
+        'color': '#0B3B0B',
+        'border': '1px solid #dee2e6'
+    }).set_table_styles([
+        {'selector': 'th', 'props': [('background-color', '#e9ecef'), ('color', '#0B3B0B'), ('font-weight', 'bold')]},
+        {'selector': 'td', 'props': [('text-align', 'center')]},
+        {'selector': 'th:first-child', 'props': [('text-align', 'left')]},
+        {'selector': 'td:first-child', 'props': [('text-align', 'left'), ('font-weight', 'bold')]}
+    ])
+    
+    st.dataframe(styled_df, use_container_width=True, hide_index=True)
+
+
+def display_swing_phase_breakdown(swing_phases):
+    """Display the swing phase breakdown table"""
+    st.subheader("Swing Phase Breakdown")
+    
+    # Create phase data
+    phase_data = []
+    for phase_name, phase_info in swing_phases.items():
+        phase_data.append([
+            phase_name.title().replace('_', ' '),
+            phase_info.get('frame_count', 0),
+            f"{phase_info.get('duration_ms', 0):.0f} ms"
+        ])
+    
+    # Display as table
+    import pandas as pd
+    df = pd.DataFrame(phase_data, columns=["Phase", "Frames", "Duration"])
+    
+    # Style the table
+    styled_df = df.style.set_properties(**{
+        'background-color': '#f8f9fa',
+        'color': '#0B3B0B',
+        'border': '1px solid #dee2e6'
+    }).set_table_styles([
+        {'selector': 'th', 'props': [('background-color', '#e9ecef'), ('color', '#0B3B0B'), ('font-weight', 'bold')]},
+        {'selector': 'td', 'props': [('text-align', 'center')]},
+        {'selector': 'th:first-child', 'props': [('text-align', 'left')]},
+        {'selector': 'td:first-child', 'props': [('text-align', 'left'), ('font-weight', 'bold')]}
+    ])
+    
+    st.dataframe(styled_df, use_container_width=True, hide_index=True)
+
+
 def display_rag_sources(sources):
     """Display source information in an organized way"""
     if not sources:
@@ -202,8 +293,9 @@ def render_rag_interface():
         # Use the structured analysis_data instead of just the prompt
         if 'analysis_data' in stored_data:
             structured_analysis = stored_data['analysis_data']
+            core_metrics = structured_analysis.get('core_metrics', {})
             
-            # Format the structured data for better RAG context
+            # Format the simplified data for better RAG context
             user_swing_context = f"""
 
 USER'S SWING ANALYSIS:
@@ -217,44 +309,14 @@ Swing Phases:
 - Follow-through: {structured_analysis.get('swing_phases', {}).get('follow_through', {}).get('frame_count', 0)} frames
 
 Timing Metrics:
-- Tempo Ratio (down:back): {structured_analysis.get('timing_metrics', {}).get('tempo_ratio', 'N/A')}
-- Estimated Club Speed: {structured_analysis.get('timing_metrics', {}).get('estimated_club_speed_mph', 'N/A')} mph
 - Total Swing Time: {structured_analysis.get('timing_metrics', {}).get('total_swing_time_ms', 'N/A')} ms
 
-=== BIOMECHANICAL METRICS ===
-Core Body Mechanics:
-- Hip Rotation: {structured_analysis.get('biomechanical_metrics', {}).get('hip_rotation_degrees', 'N/A')}°
-- Shoulder Rotation: {structured_analysis.get('biomechanical_metrics', {}).get('shoulder_rotation_degrees', 'N/A')}°
-- Posture Score: {structured_analysis.get('biomechanical_metrics', {}).get('posture_score_percent', 'N/A')}%
-- Weight Shift: {structured_analysis.get('biomechanical_metrics', {}).get('weight_shift_percent', 'N/A')}%
-
-Upper Body Mechanics:
-- Arm Extension: {structured_analysis.get('biomechanical_metrics', {}).get('arm_extension_percent', 'N/A')}%
-- Wrist Hinge: {structured_analysis.get('biomechanical_metrics', {}).get('wrist_hinge_degrees', 'N/A')}°
-- Swing Plane Consistency: {structured_analysis.get('biomechanical_metrics', {}).get('swing_plane_consistency_percent', 'N/A')}%
-- Head Movement (lateral): {structured_analysis.get('biomechanical_metrics', {}).get('head_movement_lateral_inches', 'N/A')} in
-- Head Movement (vertical): {structured_analysis.get('biomechanical_metrics', {}).get('head_movement_vertical_inches', 'N/A')} in
-
-Lower Body Mechanics:
-- Hip Thrust: {structured_analysis.get('biomechanical_metrics', {}).get('hip_thrust_percent', 'N/A')}%
-- Ground Force Efficiency: {structured_analysis.get('biomechanical_metrics', {}).get('ground_force_efficiency_percent', 'N/A')}%
-- Knee Flexion (address): {structured_analysis.get('biomechanical_metrics', {}).get('knee_flexion_address_degrees', 'N/A')}°
-- Knee Flexion (impact): {structured_analysis.get('biomechanical_metrics', {}).get('knee_flexion_impact_degrees', 'N/A')}°
-
-Movement Quality & Coordination:
-- Sequential Kinematic Sequence: {structured_analysis.get('biomechanical_metrics', {}).get('kinematic_sequence_percent', 'N/A')}%
-- Energy Transfer Efficiency: {structured_analysis.get('biomechanical_metrics', {}).get('energy_transfer_efficiency_percent', 'N/A')}%
-- Power Accumulation: {structured_analysis.get('biomechanical_metrics', {}).get('power_accumulation_percent', 'N/A')}%
-- Transition Smoothness: {structured_analysis.get('biomechanical_metrics', {}).get('transition_smoothness_percent', 'N/A')}%
-
-Performance Estimates:
-- Potential Distance: {structured_analysis.get('biomechanical_metrics', {}).get('potential_distance_yards', 'N/A')} yards
-- Speed Generation Method: {structured_analysis.get('biomechanical_metrics', {}).get('speed_generation_method', 'N/A')}
-
-=== TRAJECTORY ANALYSIS ===
-- Estimated Carry Distance: {structured_analysis.get('trajectory_analysis', {}).get('estimated_carry_distance', 'N/A')} yards
-- Estimated Ball Speed: {structured_analysis.get('trajectory_analysis', {}).get('estimated_ball_speed', 'N/A')} mph
-- Trajectory Type: {structured_analysis.get('trajectory_analysis', {}).get('trajectory_type', 'N/A')}
+=== CORE METRICS ===
+- Tempo Ratio: {format_metric_value(core_metrics.get('tempo_ratio', {}))}
+- Shoulder Rotation @ Top: {format_metric_value(core_metrics.get('shoulder_rotation_top_deg', {}), '°')}
+- Hip Rotation @ Impact: {format_metric_value(core_metrics.get('hip_rotation_impact_deg', {}), '°')}
+- X-Factor @ Top: {format_metric_value(core_metrics.get('x_factor_top_deg', {}), '°')}
+- Posture Score: {format_metric_value(core_metrics.get('posture_score_pct', {}), '%')}
 """
             
             # Removed success message
@@ -881,7 +943,9 @@ def render_step_2():
                 st.success("✅ Pose analysis complete!")
 
             with st.spinner("Segmenting swing phases..."):
-                swing_phases = segment_swing(pose_data, detections, sample_rate=1)
+                # Get frame shape for relative threshold calculations
+                frame_shape = frames[0].shape if frames else None
+                swing_phases = segment_swing(pose_data, detections, sample_rate=1, frame_shape=frame_shape, fps=30.0)
                 st.success("✅ Swing segmentation complete!")
 
             with st.spinner("Analyzing trajectory and speed..."):
@@ -889,7 +953,7 @@ def render_step_2():
                 st.success("✅ Trajectory analysis complete!")
 
             # Prepare data for LLM
-            analysis_data = prepare_data_for_llm(pose_data, swing_phases, trajectory_data)
+            analysis_data = prepare_data_for_llm(pose_data, swing_phases, trajectory_data, fps=30.0, frame_shape=frame_shape)
             prompt = create_llm_prompt(analysis_data)
 
             # Store analysis data
@@ -982,30 +1046,65 @@ def render_step_4():
         data = st.session_state.analysis_data
         pose_data = data['pose_data']
         swing_phases = data['swing_phases']
-        trajectory_data = data['trajectory_data']
         
-        with st.spinner("🎯 **Generating personalized swing improvements...**"):
-            # Generate detailed analysis with recommendations
-            analysis = generate_swing_analysis(pose_data, swing_phases, trajectory_data)
-            
-            # Check available services
-            llm_services = check_llm_services()
-            any_service_available = llm_services['ollama']['available'] or llm_services['openai']['available']
-            
-            if not any_service_available:
-                st.info("ℹ️ **Using sample analysis mode**. The recommendations below are general examples.")
-            else:
+        # Get the analysis data that contains core metrics
+        analysis_data = data.get('analysis_data', {})
+        core_metrics = analysis_data.get('core_metrics', {})
+        
+        # If core_metrics is empty, compute them directly
+        if not core_metrics:
+            core_metrics = compute_core_metrics(pose_data, swing_phases)
+        
+        # Display the simplified metrics
+        display_core_summary(core_metrics)
+        
+        st.markdown("---")
+        
+        display_swing_phase_breakdown(analysis_data.get('swing_phases', {}))
+        
+        st.markdown("---")
+        
+        # Generate AI analysis if services are available
+        llm_services = check_llm_services()
+        any_service_available = llm_services['ollama']['available'] or llm_services['openai']['available']
+        
+        if any_service_available:
+            with st.spinner("🎯 **Generating personalized swing improvements...**"):
+                # Generate detailed analysis with recommendations
+                analysis = generate_swing_analysis(pose_data, swing_phases, data.get('trajectory_data'))
+                
                 st.info("🤖 **Analysis generated using AI-powered swing analysis technology**")
-            
-            # Display the analysis
-            if "Error:" not in analysis:
-                try:
-                    formatted_analysis = parse_and_format_analysis(analysis)
-                    display_formatted_analysis(formatted_analysis)
-                except:
-                    st.markdown(analysis)
-            else:
-                st.error(analysis)
+                
+                # Display the analysis
+                if "Error:" not in analysis:
+                    try:
+                        formatted_analysis = parse_and_format_analysis(analysis)
+                        display_formatted_analysis(formatted_analysis)
+                    except:
+                        st.markdown(analysis)
+                else:
+                    st.error(analysis)
+        else:
+            st.info("ℹ️ **AI coaching analysis is not available**. The core metrics above provide your swing measurements.")
+        
+        # Add button to show exact LLM prompt
+        st.markdown("---")
+        col1, col2, col3 = st.columns([1, 2, 1])
+        with col2:
+            if st.button("🔍 Show Exact LLM Prompt", key="show_prompt_btn", use_container_width=True):
+                if 'prompt' in st.session_state.analysis_data:
+                    st.markdown("### 🤖 Exact LLM Prompt Used for Analysis")
+                    st.info("This is the exact prompt that was sent to the AI model to generate your swing analysis:")
+                    
+                    with st.expander("📋 View Full Prompt", expanded=True):
+                        st.code(st.session_state.analysis_data['prompt'], language="text")
+                    
+                    st.markdown("**Prompt Components:**")
+                    st.markdown("- **System Instructions**: How the AI should analyze your swing")
+                    st.markdown("- **Your Swing Data**: Core metrics and swing phases")
+                    st.markdown("- **Analysis Format**: Instructions for structured output")
+                else:
+                    st.error("No prompt data available. Please re-analyze the video to generate a new prompt.")
         
     else:
         st.error("No analysis data available. Please analyze a video first.")