Add head height change metric to replace hip turn metric

- Implemented single head height change metric measuring address to impact movement
- Added comprehensive debug output for head height calculations
- Removed all confidence calculations from DTL metrics
- Added helper functions for head landmark detection and temporal smoothing
- Updated validation ranges for new metric
- Enhanced inch scale calculation with debug output

app/main.py

@@ -51,7 +51,7 @@ def main():
 
         # Step 5: Analyze pose throughout the swing
         print("\nAnalyzing golfer's pose...")
-        pose_data = analyze_pose(frames)
+        pose_data, world_landmarks = analyze_pose(frames)
 
         # Step 6: Segment swing into phases
         print("\nSegmenting swing phases...")

app/models/coach_prompt.md

@@ -1,150 +1,42 @@
 # 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 professional analysis:
-
-### Professional Golfer Analysis Summary (100% Reference Standards):
-
-**Lydia Ko Iron (LPGA Tour Professional):** https://www.youtube.com/shorts/ING2iZ3M8wg
-- Shaft Plane @ Top: Slightly Laid-off — 🟢 Mild laid-off bias — Confidence ~75%
-- Back Tilt @ Setup: 33.9° — 🟢 On-plane posture — Confidence ~85%
-- Knee Flexion: 27.6° — 🟢 Athletic — Confidence ~60%
-- Wrist Pattern: Set-Hold-Release — Excellent — 🟢 — Confidence ~75%
-- Power Source: Hip-Led — 🟢 60% hip power
-- Shoulder Turn Quality: Excellent — 🟢 Complete shoulder rotation — Confidence ~70% DTL-only
-
-Raw values for qualitative assessments - for calibration purposes:
-• Shaft Angle @ Top: -26.2° (status: needs_work)
-• Hip Rotation @ Impact: None° (status: needs_face_on)
-• X-Factor @ Top: None° (status: needs_face_on)
-• Shoulder Rotation @ Top: 45.0° (status: ok)
-
-**Nelly Korda Iron (Pink):** https://www.youtube.com/shorts/GRzaXCNJq1o
-- Shaft Plane @ Top: Neutral — 🟢 Good plane control
-- Back Tilt @ Setup: 34.9° — 🟢 On-plane posture — Confidence ~85%
-- Knee Flexion: 18.7° — 🟢 Athletic — Confidence ~60%
-- Wrist Pattern: Set-Hold-Release — Excellent — 🟢 — Confidence ~75%
-- Power Source: Hip-Led — 🟢 60% hip power
-- Shoulder Turn Quality: Excellent — 🟢 Complete shoulder rotation — Confidence ~70% DTL-only
-
-Raw values for qualitative assessments - for calibration purposes:
-• Shaft Angle @ Top: None° (status: club_not_visible)
-• Hip Rotation @ Impact: None° (status: needs_face_on)
-• X-Factor @ Top: None° (status: needs_face_on)
-• Shoulder Rotation @ Top: 45.0° (status: ok)
-
-**Nelly Korda Iron (Blue):** https://www.youtube.com/shorts/M1eaHdaSzh4
-- Shaft Plane @ Top: Neutral — 🟢 Good plane control
-- Back Tilt @ Setup: 31.2° — 🟢 On-plane posture — Confidence ~85%
-- Knee Flexion: 16.4° — 🟢 Athletic — Confidence ~60%
-- Wrist Pattern: Set-Hold-Release — Excellent — 🟢 — Confidence ~75%
-- Power Source: Hip-Led — 🟢 60% hip power
-- Shoulder Turn Quality: Excellent — 🟢 Complete shoulder rotation — Confidence ~70% DTL-only
-
-Raw values for qualitative assessments - for calibration purposes:
-• Shaft Angle @ Top: None° (status: club_not_visible)
-• Hip Rotation @ Impact: None° (status: needs_face_on)
-• X-Factor @ Top: None° (status: needs_face_on)
-• Shoulder Rotation @ Top: 45.0° (status: ok)
-
-**Park Sunghyun Iron:** https://www.youtube.com/shorts/imtyz_n06gA
-- Back Tilt @ Setup: 29.2° — 🟢 On-plane posture — Confidence ~90%
-- Knee Flexion: 25.9° — 🟢 Athletic — Confidence ~90%
-- Wrist Pattern: Inconsistent Pattern — 🟠 — Confidence ~75% approx.
-💡 Tip: Work on consistent wrist angles.
-- Kinematic Sequence (DTL-approx): Good Hip Turn — 🟢 Good hip rotation DTL-only
-- Shoulder Turn Quality: Excellent — 🟢 Complete shoulder rotation — Confidence ~70% approx. DTL-only
-
-Raw values for qualitative assessments - for calibration purposes:
-• Shaft Angle @ Top: None° (status: Unavailable (club occluded))
-• Hip Rotation @ Impact: None° (status: needs_face_on)
-• X-Factor @ Top: None° (status: needs_face_on)
-• Shoulder Rotation @ Top: None° (status: DTL proxy only, low confidence)
-
-**Minjee Lee Driver:** https://www.youtube.com/shorts/Ioo3VSiCUhs
-- Back Tilt @ Setup: 27.6° — 🟠 Slightly out of range — Confidence ~90%
-- Knee Flexion: 24.8° — 🟢 Athletic — Confidence ~90%
-- Wrist Pattern: Set-Hold-Release — Excellent — 🟢 Needs work — Confidence ~75% approx.
-- Kinematic Sequence (DTL-approx): Good Hip Turn — 🟢 Good hip rotation
-- Shoulder Turn Quality: Excellent — 🟢 Complete shoulder rotation — Confidence ~70% approx. DTL-only
-
-Raw values for qualitative assessments - for calibration purposes:
-• Shaft Angle @ Top: None° (status: Unavailable (club occluded))
-• Hip Rotation @ Impact: None° (status: needs_face_on)
-• X-Factor @ Top: None° (status: needs_face_on)
-• Shoulder Rotation @ Top: None° (status: DTL proxy only, low confidence)
-
-**Hyoo Joo Kim Iron:** https://www.youtube.com/watch?v=zDheOLEEmdU&t=7s
-- Back Tilt @ Setup: 27.3° — 🟠 Slightly out of range — Confidence ~90%
-- Knee Flexion: 26.8° — 🟢 Athletic — Confidence ~90%
-- Wrist Pattern: Set-Hold-Release — Excellent — 🟢 Needs work — Confidence ~75% approx.
-- Kinematic Sequence (DTL-approx): Good Hip Turn — 🟢 Good hip rotation
-- Shoulder Turn Quality: Excellent — 🟢 Complete shoulder rotation — Confidence ~70% approx. DTL-only
-
-Raw values for qualitative assessments - for calibration purposes:
-• Shaft Angle @ Top: None° (status: target_line_error)
-• Hip Rotation @ Impact: None° (status: needs_face_on)
-• X-Factor @ Top: None° (status: needs_face_on)
-• Shoulder Rotation @ Top: None° (status: DTL proxy only, low confidence)
-
-**Nasa Hataoka Iron:** https://www.youtube.com/shorts/sMqEwl1Tfus
-- Back Tilt @ Setup: 25.3° — 🟠 Slightly out of range — Confidence ~90%
-- Knee Flexion: 24.1° — 🟢 Athletic — Confidence ~90%
-- Wrist Pattern: Set-Hold-Release — Excellent — 🟢 Needs work — Confidence ~75% approx.
-- Kinematic Sequence (DTL-approx): Good Hip Turn — 🟢 Good hip rotation
-- Shoulder Turn Quality: Excellent — 🟢 Complete shoulder rotation — Confidence ~70% approx. DTL-only
-
-Raw values for qualitative assessments - for calibration purposes:
-• Shaft Angle @ Top: None° (status: target_line_error)
-• Hip Rotation @ Impact: None° (status: needs_face_on)
-• X-Factor @ Top: None° (status: needs_face_on)
-• Shoulder Rotation @ Top: None° (status: DTL proxy only, low confidence)
-
-### **AMATEUR REFERENCE EXAMPLES FOR CALIBRATION:**
-
-**90% Amateur Swing:**
-Known problems: Wrist casting during downswing/impact, lacks powerful hip rotation, possibly too much knee flex
-- Shaft Plane @ Top: Neutral — 🟢 Good plane control — Confidence ~85%
-- Back Tilt @ Setup: 69.4° — 🔴 Likely problematic — Confidence ~60% - detected wrong
-💡 Tip: Typical tour range ≈30–40°.
-- Knee Flexion: 26.0° — 🟢 Athletic — Confidence ~60%
-- Wrist Pattern: Set-Hold-Release — Excellent — 🟢 — Confidence ~75%
-- Power Source: Hip-Led — 🟢 60% hip power
-- Shoulder Turn Quality: Excellent — 🟢 Complete shoulder rotation — Confidence ~70% DTL-only
-
-Raw values for qualitative assessments - for calibration purposes:
-• Shaft Angle @ Top: -6.8° (status: good)
-• Hip Rotation @ Impact: None° (status: needs_face_on)
-• X-Factor @ Top: None° (status: needs_face_on)
-• Shoulder Rotation @ Top: 45.0° (status: ok)
-
-**40-50% Male Amateur Swing:**
-Known problems: Standing up during impact, head movement severe, bent arms in follow through, inconsistent swing path and ball contact, wrong stance because the club is too short for his height, some wrist casting during impact
-- Back Tilt @ Setup: 39.0° — 🟠 Slightly out of range — Confidence ~90%
-- Knee Flexion: 39.4° — 🟠 Too bent — Confidence ~90%
-- Wrist Pattern: Set-Hold-Release — Excellent — 🟢 Needs work — Confidence ~75% approx.
-- Kinematic Sequence (DTL-approx): Good Hip Turn — 🟢 Good hip rotation
-- Shoulder Turn Quality: Excellent — 🟢 Complete shoulder rotation — Confidence ~70% approx. DTL-only
-
-Raw values for qualitative assessments - for calibration purposes:
-• Shaft Angle @ Top: None° (status: target_line_error)
-• Hip Rotation @ Impact: None° (status: needs_face_on)
-• X-Factor @ Top: None° (status: needs_face_on)
-• Shoulder Rotation @ Top: None° (status: DTL proxy only, low confidence)
-
-**40-50% Female Amateur Swing:**
-Known problems: Hands keep going at the top of backswing when they should stop, wrist casting, hands leading downswing not hips, standing up during impact, head movement
-- Knee Flexion: 33.8° — 🟠 Slightly too bent — Confidence ~90%
-- Wrist Pattern: Inconsistent Pattern — 🟠 Needs work — Confidence ~75% approx.
-💡 Tip: Work on consistent wrist angles.
-- Kinematic Sequence (DTL-approx): Good Hip Turn — 🟢 Good hip rotation
-- Shoulder Turn Quality: Excellent — 🟢 Complete shoulder rotation — Confidence ~70% approx. DTL-only
-
-Raw values for qualitative assessments - for calibration purposes:
-• Shaft Angle @ Top: None° (status: target_line_error)
-• Hip Rotation @ Impact: None° (status: needs_face_on)
-• X-Factor @ Top: None° (status: needs_face_on)
-• Shoulder Rotation @ Top: None° (status: DTL proxy only, low confidence)
+## NEW METRICS CALIBRATION
+Use these new professional/amateur benchmarks for scoring. These represent updated golf swing mechanics based on the latest analysis:
+
+### **NEW FRONT-FACING METRICS:**
+
+**Shoulder Tilt @ Impact:**
+- Professional = 39°
+- 30 Handicap = 27°
+
+# Hip Turn @ Impact metric removed from DTL analysis
+
+**Hip Sway @ Top:**
+- Professional = 3.9" towards target
+- 30 Handicap = 2.5" towards target
+
+**Hip Sway @ Impact:**
+- To be measured and calibrated
+
+**Wrist Hinge @ Top:**
+- To be measured and calibrated
+
+### **NEW DTL METRICS:**
+
+**Shoulder Tilt/Swing Plane Angle @ Top:**
+- Professional = 36°
+- 30 Handicap = 29°
+
+**Back Tilt (°):**
+- To be measured and calibrated
+
+**Knee Flexion (°):**
+- To be measured and calibrated
+
+**Hip Depth / Early Extension (cm or %):**
+- To be measured and calibrated
+
+# Hip Turn @ Impact metric removed from DTL analysis
 
 ### **KEY AMATEUR SWING PROBLEMS FOR EVALUATION REFERENCE:**
 **Common Issues in 40-50% Level Swings:**
@@ -211,14 +103,15 @@ Raw values for qualitative assessments - for calibration purposes:
 - Weight transfer issues may manifest as poor hip rotation or kinematic sequence problems
 - Over-the-top swing path affects shaft plane and swing consistency
 
-### **PROFESSIONAL STANDARDS CALIBRATION (100% Level):**
-**Core Biomechanical Metrics (Based on 7 LPGA Tour Professionals):**
-- **Back Tilt @ Setup**: 25-35° (Professional range: Nasa 25.3° to Nelly Blue 34.9°)
-- **Knee Flexion**: 16-28° (Professional range: Nelly Blue 16.4° to Lydia Ko 27.6°)
-- **Shaft Plane @ Top**: Neutral to slightly laid-off (Professional plane control when visible)
-- **Wrist Pattern**: Set-Hold-Release sequence (Excellent timing and control across all professionals)
-- **Power Source**: Hip-Led 60% hip power (Professional power generation standard)
-- **Shoulder Turn Quality**: Excellent complete rotation (Consistent across all professionals)
+### **UPDATED METRICS CALIBRATION:**
+**New Core Biomechanical Metrics:**
+- **Shoulder Tilt @ Impact**: Professional = 39°, 30 Handicap = 27°
+- **Hip Turn @ Impact**: Professional = 36°, 30 Handicap = 19°
+- **Hip Sway @ Top**: Professional = 3.9" towards target, 30 Handicap = 2.5" towards target
+- **Shoulder Tilt/Swing Plane @ Top**: Professional = 36°, 30 Handicap = 29°
+- **Back Tilt @ Setup**: To be calibrated with new data
+- **Knee Flexion @ Setup**: To be calibrated with new data
+- **Hip Depth / Early Extension**: To be calibrated with new data
 
 ## CURRENT SWING ANALYSIS
 
@@ -240,35 +133,64 @@ Use the benchmarks above to guide your evaluation. Follow this exact format:
 
 **Metric Evaluations**
 
-For each of the 5 DTL-reliable core metrics below, write exactly 3 sentences evaluating the metric:
-1. First sentence: State if it's good, bad, or needs improvement compared to elite standards
-2. Second sentence: Compare the specific value to professional ranges  
+For each of the new metrics below, write exactly 3 sentences evaluating the metric:
+1. First sentence: State if it's good, bad, or needs improvement compared to professional standards
+2. Second sentence: Compare the specific value to professional/amateur ranges  
 3. Third sentence: Brief explanation of impact on swing performance
 
-**1. Shaft Plane @ Top Evaluation:**
-[3 sentences about club shaft position relative to target line at top]
+**FRONT-FACING METRICS:**
+
+**1. Shoulder Tilt @ Impact Evaluation:**
+[3 sentences about shoulder tilt angle at impact - professional = 39°, 30 handicap = 27°]
+
+# Hip Turn @ Impact evaluation removed from DTL analysis
+
+**3. Hip Sway @ Top Evaluation:**
+[3 sentences about hip sway at top - professional = 3.9" towards target, 30 handicap = 2.5" towards target]
+
+**4. Hip Sway @ Impact Evaluation:**
+[3 sentences about hip sway at impact]
+
+**5. Wrist Hinge @ Top Evaluation:**
+[3 sentences about wrist hinge angle at top of backswing]
 
-**2. Head Sway Evaluation:**
-[3 sentences about head movement as percentage of shoulder width]
+**DTL METRICS:**
 
-**3. Back Tilt @ Setup Evaluation:**
+**1. Shoulder Tilt/Swing Plane @ Top Evaluation:**
+[3 sentences about shoulder tilt/swing plane angle at top - professional = 36°, 30 handicap = 29°]
+
+**2. Back Tilt @ Setup Evaluation:**
 [3 sentences about spine forward tilt angle during setup position]
 
-**4. Knee Flexion @ Setup Evaluation:**
+**3. Knee Flexion @ Setup Evaluation:**
 [3 sentences about knee flexion angle during setup position]
 
-**5. Wrist Pattern Evaluation:**
-[3 sentences about wrist hinge sequence and early casting]
+**4. Hip Depth / Early Extension Evaluation:**
+[3 sentences about hip depth maintenance and early extension]
+
+# Hip Turn @ Impact evaluation removed from DTL analysis
 
 **SCORING GUIDELINES (Use to help decide % score)**
 
-| Metric | Professional Standard | Amateur Problem Indicators | Note |
-|--------|----------------------|---------------------------|------|
-| Shaft Angle @ Top | Neutral to slightly laid-off | N/A (often not visible) | Neutral (0°), slightly laid-off (-26°) acceptable |
-| Head Sway | <15% shoulder width | Severe movement (40-50% level) | Stable head during swing |
-| Back Tilt @ Setup | 25-35° | >35° problematic (39° seen in 40-50% level) | Forward spine tilt from vertical |
-| Knee Flexion @ Setup | 16-28° | >35° problematic (33-39° seen in 40-50% level) | Athletic stance flexion |
-| Wrist Pattern | Set-Hold-Release sequence | Casting, inconsistent patterns | Excellent timing and control, no early casting |
+**FRONT-FACING METRICS:**
+
+| Metric | Professional Standard | 30 Handicap Standard | Note |
+|--------|----------------------|---------------------|------|
+| Shoulder Tilt @ Impact | 39° | 27° | Shoulder tilt angle at impact |
+# Hip Turn @ Impact metric removed from DTL analysis
+| Hip Sway @ Top | 3.9" towards target | 2.5" towards target | Hip lateral movement at top |
+| Hip Sway @ Impact | To be calibrated | To be calibrated | Hip lateral movement at impact |
+| Wrist Hinge @ Top | To be calibrated | To be calibrated | Wrist angle at top of backswing |
+
+**DTL METRICS:**
+
+| Metric | Professional Standard | 30 Handicap Standard | Note |
+|--------|----------------------|---------------------|------|
+| Shoulder Tilt/Swing Plane @ Top | 36° | 29° | Shoulder tilt/swing plane angle at top |
+| Back Tilt @ Setup | To be calibrated | To be calibrated | Forward spine tilt from vertical |
+| Knee Flexion @ Setup | To be calibrated | To be calibrated | Athletic stance flexion |
+| Hip Depth / Early Extension | To be calibrated | To be calibrated | Hip depth maintenance |
+# Hip Turn @ Impact metric removed from DTL analysis
 
 **Classification Bands:**
 - **90–100%**: Tour-level
@@ -280,15 +202,16 @@ For each of the 5 DTL-reliable core metrics below, write exactly 3 sentences eva
 - **10–39%**: Novice
 
 **STYLE & FORMATTING RULES:**
-- Use these headers: OVERALL_SUMMARY, PERFORMANCE_CLASSIFICATION, Metric Evaluations, and the 5 numbered metric sections
+- Use these headers: OVERALL_SUMMARY, PERFORMANCE_CLASSIFICATION, Metric Evaluations, and the numbered metric sections for both Front-Facing and DTL metrics
 - No emojis anywhere in the response  
 - Write 1-2 sentences maximum for the overall summary - be concise and highlight main strengths/improvement areas
 - Write exactly 3 sentences for each metric evaluation
-- Tie all evaluations to professional standards and ranges based on 7 LPGA Tour professionals (Lydia Ko, Nelly Korda, Park Sunghyun, Minjee Lee, Hyoo Joo Kim, Nasa Hataoka)
+- Tie all evaluations to the new professional/amateur standards and ranges provided
 - Use a positive, coaching tone throughout
 - Avoid saying "perfect" — say "strong" or "meets standards"
-- Focus on biomechanics and compare actual values to professional ranges (25-35° back tilt, 16-28° knee flexion, etc.)
+- Focus on biomechanics and compare actual values to the new professional ranges (39° shoulder tilt, etc.) - Hip turn removed from DTL metrics
 - Consider common amateur swing issues when evaluating: over-swinging, over-the-top path, lack of weight transfer, early extension, lifting the ball, wrist casting, head movement/standing up
 - Look for combinations of swing problems that often compound each other in amateur golfers
+- Use the new calibration values: Professional = 39° shoulder tilt, 3.9" hip sway vs 30 Handicap = 27° shoulder tilt, 2.5" hip sway (Hip turn removed from DTL metrics)
 
 

app/models/front_facing_metrics.py

@@ -398,8 +398,46 @@ def pelvis_hat(world_frame):
     except Exception:
         return None
 
+def _pelvis_rel_to_target(world_frame, target_hat):
+    """Get pelvis orientation relative to target axis"""
+    ph = pelvis_hat(world_frame)
+    return None if ph is None else wrap180(signed_angle2(target_hat, ph))
+
+def _address_pelvis_rel(world_landmarks, setup_frames, target_hat):
+    """Calculate median pelvis orientation relative to target at address"""
+    vals = []
+    for f in setup_frames[:8]:
+        if f in world_landmarks:
+            rel = _pelvis_rel_to_target(world_landmarks[f], target_hat)
+            if rel is not None:
+                vals.append(rel)
+    return float(np.median(vals)) if vals else None
+
+def grade_hip_turn(delta_deg: float, club: str = "iron") -> dict:
+    """Grade hip turn with club-aware bands and actionable tips"""
+    c = club.lower()
+    bands = {
+        "driver": {"excellent": (38,48), "good_low": (32,38), "good_high": (48,52)},
+        "iron":   {"excellent": (32,40), "good_low": (28,32), "good_high": (40,44)},
+        "wedge":  {"excellent": (25,35), "good_low": (22,25), "good_high": (35,38)},
+    }
+    b = bands["driver" if "driver" in c else "wedge" if "wedge" in c else "iron"]
+    x = delta_deg
+
+    if b["excellent"][0] <= x <= b["excellent"][1]:
+        label, color, tip = "🟢 Excellent", "green", "Great rotation with control."
+    elif b["good_low"][0] <= x < b["good_low"][1]:
+        label, color, tip = "🟠 Good (slightly low)", "orange", "Open a touch more through impact."
+    elif b["good_high"][0] <= x <= b["good_high"][1]:
+        label, color, tip = "🟠 Good (slightly high)", "orange", "Post on lead leg; avoid over-spinning hips."
+    else:
+        label, color, tip = "🔴 Needs work", "red", (
+            "Too little: shift then open. Too much: trail heel down longer; post into lead glute."
+        )
+    return {"label": label, "color": color, "tip": tip}
+
 def _target_hat_from_toes_world(world_landmarks, setup_frames, handedness='right'):
-    """Build stable target axis from toe line at address"""
+    """Build stable target axis from toe line at address with outlier trimming"""
     LEFT_TOE, RIGHT_TOE = 31, 32
     
     toe_vecs = []
@@ -421,8 +459,12 @@ def _target_hat_from_toes_world(world_landmarks, setup_frames, handedness='right
         dbg("target_axis - NO VALID TOE VECTORS, using default")
         return (1.0, 0.0)
     
-    # Target axis is parallel to toe line (not perpendicular)
-    target_hat = unit2(np.median(toe_vecs, axis=0))
+    # Drop 20% widest-angle outliers before median
+    toe_vecs = np.array(toe_vecs, dtype=float)
+    angles = np.degrees(np.arctan2(toe_vecs[:,1], toe_vecs[:,0]))
+    med, dev = np.median(angles), np.abs(angles - np.median(angles))
+    keep = dev <= np.percentile(dev, 80)
+    target_hat = unit2(np.median(toe_vecs[keep], axis=0))
     
     # Optional: flip sign for consistency if you want +X toward target for left-handed
     if handedness == 'left':
@@ -431,33 +473,207 @@ def _target_hat_from_toes_world(world_landmarks, setup_frames, handedness='right
     return target_hat
 
 
-def _simple_pixel_sway_fallback(sm, setup_frames, top_frame):
-    """Simple pixel-based sway fallback that ALWAYS returns a value"""
-    # Get pelvis centers in pixels
-    def get_pelvis_center_px(frame_idx):
-        lm = sm.get(frame_idx)
+def _pick_quiet_address(sm, swing_phases, warp2, max_frames=6, speed_thr_in=0.20):
+    """Pick early address frames with strict stillness criteria"""
+    cand = swing_phases.get("setup", [])[:16]
+    if not cand: return []
+    # pelvis centers in ground
+    ctrs = []
+    for f in cand:
+        lm = sm.get(f)
+        if not lm or not lm[23] or not lm[24]: 
+            ctrs.append(None)
+            continue
+        g = warp2([[lm[23][0], lm[23][1]], [lm[24][0], lm[24][1]]])
+        ctrs.append(((g[0]+g[1])/2).astype(float))
+    keep = []
+    prev = None
+    for f,c in zip(cand, ctrs):
+        if c is None: break
+        spd = 0.0 if prev is None else float(np.linalg.norm(c - prev))
+        if spd <= speed_thr_in: 
+            keep.append(f)
+            if len(keep) >= max_frames: break
+        else:
+            break
+        prev = c
+    return keep or cand[:max_frames]
+
+def _pick_stable_setup_frames(sm, swing_phases, max_frames=6):
+    """Pick first address frames with low pelvis motion (reduces waggle bias)."""
+    cand = swing_phases.get("setup", [])[:12]
+    if not cand:
+        return []
+    def pelvis_ctr_px(f):
+        lm = sm.get(f)
+        if not lm or not lm[23] or not lm[24]: return None
+        return np.array([(lm[23][0]+lm[24][0])*0.5, (lm[23][1]+lm[24][1])*0.5], float)
+    centers = [(f, pelvis_ctr_px(f)) for f in cand]
+    centers = [(f, c) for f,c in centers if c is not None]
+    if len(centers) < 2: return [f for f,_ in centers][:max_frames]
+    # speed threshold: keep earliest frames whose step-to-step pelvis motion is small
+    speeds = []
+    for i in range(1, len(centers)):
+        f0,c0 = centers[i-1]; f1,c1 = centers[i]
+        speeds.append((f1, float(np.linalg.norm(c1-c0))))
+    if not speeds: return [centers[0][0]]
+    # pick prefix until motion inflates (waggle begins)
+    thr = max(1.5, np.median([s for _,s in speeds])*2.5)
+    keep = [centers[0][0]]
+    for f,s in speeds:
+        if s <= thr and len(keep) < max_frames:
+            keep.append(f)
+        else:
+            break
+    return keep
+
+def _pick_still_address_by_hand(sm, swing_phases, handed='right', max_frames=6):
+    cand = swing_phases.get("setup", [])[:16]
+    if not cand: return []
+    # choose lead wrist landmark
+    WR = 15 if handed=='right' else 16
+    pts = []
+    for f in cand:
+        lm = sm.get(f)
+        if lm and lm[WR] and lm[WR][2] >= 0.5:
+            pts.append((f, np.array([lm[WR][0], lm[WR][1]], float)))
+        else:
+            break
+    if len(pts) < 2:
+        return [f for f,_ in pts][:max_frames]
+
+    speeds = [0.0]
+    for i in range(1, len(pts)):
+        speeds.append(float(np.linalg.norm(pts[i][1] - pts[i-1][1])))
+    # tight threshold to capture true stillness before takeaway/waggle
+    thr = max(0.4, np.median(speeds) * 2.0)
+    keep = [pts[0][0]]
+    for (f,_), s in zip(pts[1:], speeds[1:]):
+        if s <= thr and len(keep) < max_frames:
+            keep.append(f)
+        else:
+            break
+    return keep
+
+def _build_foot_only_homography(sm, setup_frames):
+    """
+    Build ground-plane H from 4 foot points only (no hips).
+    Image pts: L_heel(31), R_heel(32), L_toe(29), R_toe(30)
+    Ground pts are a rectangle in arbitrary inches; scale will be calibrated later.
+    """
+    import cv2
+    for f in setup_frames:
+        lm = sm.get(f)
+        if not lm: continue
+        needed = [29,30,31,32]
+        if any((i>=len(lm) or lm[i] is None or lm[i][2] < 0.5) for i in needed):
+            continue
+        img = np.array([
+            [lm[31][0], lm[31][1]],  # L heel
+            [lm[32][0], lm[32][1]],  # R heel
+            [lm[29][0], lm[29][1]],  # L toe
+            [lm[30][0], lm[30][1]],  # R toe
+        ], dtype=np.float32)
+        # A reasonable shoe: heel-to-toe depth ~11" and stance width ~ 16" default box
+        # (We will re-scale to true inches using 3D toe spacing shortly.)
+        ground = np.array([
+            [-8.0,   0.0],  # L heel
+            [ 8.0,   0.0],  # R heel
+            [-8.0,  11.0],  # L toe
+            [ 8.0,  11.0],  # R toe
+        ], dtype=np.float32)
+        H, mask = cv2.findHomography(img, ground, cv2.RANSAC, 2.0)
+        if H is None: 
+            continue
+        det = abs(np.linalg.det(H[:2,:2]))
+        if det > 1e-5:
+            return H, True, f
+    return None, False, None
+
+def _simple_pixel_sway_fallback(sm, setup_frames, top_frame, swing_phases=None, world_landmarks=None):
+    """Improved pixel-based sway fallback with world landmark scale calibration"""
+    def get_lm(frame_idx):
+        return sm.get(frame_idx)
+
+    # pick a setup frame that has feet + hips
+    setup_ok = [f for f in setup_frames
+                if get_lm(f) and get_lm(f)[23] and get_lm(f)[24] and get_lm(f)[31] and get_lm(f)[32]]
+    if not setup_ok:
+        return 0.0
+
+    f0 = setup_ok[0]
+    lm0 = get_lm(f0)
+
+    # pelvis centers (pixels)
+    def pelvis_ctr_px(f):
+        lm = get_lm(f)
         if not lm or not lm[23] or not lm[24]:
             return None
-        return [(lm[23][0] + lm[24][0]) / 2, (lm[23][1] + lm[24][1]) / 2]
-    
-    # Setup center (median)
-    setup_centers = [get_pelvis_center_px(f) for f in setup_frames]
-    setup_centers = [c for c in setup_centers if c is not None]
-    if not setup_centers:
-        return 0.0  # Default value if no setup data
-    setup_ctr = np.median(setup_centers, axis=0)
-    
-    # Top center
-    top_ctr = get_pelvis_center_px(top_frame)
+        return np.array([(lm[23][0] + lm[24][0]) * 0.5,
+                         (lm[23][1] + lm[24][1]) * 0.5], dtype=float)
+
+    setup_ctrs = [pelvis_ctr_px(f) for f in setup_ok]
+    setup_ctrs = [c for c in setup_ctrs if c is not None]
+    if not setup_ctrs:
+        return 0.0
+    setup_ctr = np.median(np.stack(setup_ctrs), axis=0)
+
+    top_ctr = pelvis_ctr_px(top_frame)
     if top_ctr is None:
-        return 0.0  # Default value if no top data
+        return 0.0
+
+    # toe vector in pixels from the same setup frame
+    toe_v = np.array([lm0[32][0] - lm0[31][0],
+                      lm0[32][1] - lm0[31][1]], dtype=float)
+    n = np.linalg.norm(toe_v)
+    if n < 1e-6:
+        # fallback to horizontal approximation if toes are missing
+        toe_hat_px = np.array([1.0, 0.0])
+    else:
+        toe_hat_px = toe_v / n
+
+    # Target axis (toe line itself) in pixel space
+    target_hat_px = toe_hat_px / (np.linalg.norm(toe_hat_px) + 1e-9)
+
+    # --- NEW: sign disambiguation using address -> impact pelvis centers in pixel space ---
+    if swing_phases and swing_phases.get("impact"):
+        f_imp = swing_phases["impact"][0]
+        # median address pelvis center in px
+        addr_ctrs = [pelvis_ctr_px(f) for f in setup_ok]
+        addr_ctrs = [c for c in addr_ctrs if c is not None]
+        imp_ctr = pelvis_ctr_px(f_imp)
+        if addr_ctrs and imp_ctr is not None:
+            addr_ctr = np.median(np.stack(addr_ctrs), axis=0)
+            fwd_vec_px = imp_ctr - addr_ctr
+            if float(np.dot(fwd_vec_px, target_hat_px)) < 0.0:
+                target_hat_px = -target_hat_px
+
+    delta_px = top_ctr - setup_ctr
+    sway_px = float(np.dot(delta_px, target_hat_px))
+
+    # Improved px→inch scale using world landmarks if available
+    px_per_inch = 10.0  # default fallback
+    if world_landmarks is not None and f0 in world_landmarks:
+        try:
+            wf = world_landmarks[f0]
+            L_FOOT_INDEX, R_FOOT_INDEX = 29, 30
+            Lt, Rt = wf[L_FOOT_INDEX], wf[R_FOOT_INDEX]
+            if Lt and Rt:
+                # 3D toe spacing in meters → inches
+                d_m = math.hypot(Rt[0]-Lt[0], Rt[2]-Lt[2])
+                d_in_true = d_m * 39.3701
+                # Pixel toe spacing
+                d_px = float(np.linalg.norm(toe_v))
+                if d_px > 1e-3 and d_in_true > 1e-3:
+                    px_per_inch = d_px / d_in_true
+                    print(f"DEBUG pixel_fallback: calibrated px_per_inch={px_per_inch:.2f} from 3D toes")
+        except Exception:
+            pass
     
-    # Simple horizontal movement in pixels, convert with rough estimate
-    delta_px = top_ctr[0] - setup_ctr[0]
-    # Rough conversion: assume ~10 pixels per inch (typical for phone videos)
-    sway_inches = delta_px / 10.0
+    sway_inches = sway_px / px_per_inch
+    print(f"DEBUG pixel_fallback: sway_px={sway_px:.1f}, px_per_inch={px_per_inch:.2f}, sway_in={sway_inches:.2f}")
     
-    return float(sway_inches)
+    return sway_inches
 
 
 def _subframe_impact_refinement(world_landmarks: Dict[int, List], impact_candidate: int) -> float:
@@ -621,152 +837,29 @@ def _impact_frame(world_landmarks: Dict[int, List], swing_phases: Dict[str, List
     return impact_frames[0] if impact_frames else None
 
 
-def _conf3d(world_landmarks, impact_frame, setup_frames):
-    """Compute 3D confidence and pelvis change in one function"""
-    if not world_landmarks or impact_frame not in world_landmarks:
-        return 0.0, 100.0
-    
-    try:
-        # Check frames around impact for stability
-        test_frames = [f for f in range(impact_frame-2, impact_frame+3) if f in world_landmarks]
-        if len(test_frames) < 3:
-            return 0.3, 100.0
-        
-        yaws = []
-        z_positions = []
-        
-        for f in test_frames:
-            frame = world_landmarks[f]
-            if frame and len(frame) > 24 and frame[23] and frame[24]:
-                ph = pelvis_hat(frame)
-                if ph is not None:
-                    yaw_approx = math.degrees(math.atan2(ph[1], ph[0]))
-                    yaws.append(yaw_approx)
-                    
-                    # Z position (depth stability)
-                    lz, rz = frame[23][2], frame[24][2]
-                    z_positions.append((lz + rz) / 2)
-        
-        if len(yaws) < 3:
-            return 0.3, 100.0
-        
-        # Compute stability metrics
-        yaw_std = np.std(yaws)
-        z_std = np.std(z_positions)
-        
-        # Pelvis length change from setup
-        setup_pelvis_lens = []
-        for f in setup_frames[:5]:
-            if f in world_landmarks:
-                frame = world_landmarks[f]
-                if frame and len(frame) > 24 and frame[23] and frame[24]:
-                    lx, lz = frame[23][0], frame[23][2]
-                    rx, rz = frame[24][0], frame[24][2]
-                    setup_pelvis_lens.append(math.sqrt((rx-lx)**2 + (rz-lz)**2))
-        
-        pelvis_change_pct = 100.0
-        if setup_pelvis_lens:
-            impact_frame_data = world_landmarks[impact_frame]
-            if (impact_frame_data and len(impact_frame_data) > 24 and 
-                impact_frame_data[23] and impact_frame_data[24]):
-                lx, lz = impact_frame_data[23][0], impact_frame_data[23][2]
-                rx, rz = impact_frame_data[24][0], impact_frame_data[24][2]
-                impact_pelvis_len = math.sqrt((rx-lx)**2 + (rz-lz)**2)
-                
-                avg_setup = np.mean(setup_pelvis_lens)
-                if avg_setup > 0:
-                    pelvis_change_pct = abs(impact_pelvis_len - avg_setup) / avg_setup * 100
-        
-        # Score components (higher = better)
-        yaw_score = max(0, 1.0 - yaw_std / 5.0)  # Good if <5° std
-        pelvis_score = max(0, 1.0 - pelvis_change_pct / 15.0)  # Good if <15% change
-        z_score = max(0, 1.0 - z_std / 0.05)  # Good if <5cm Z std
-        
-        # Combined confidence
-        conf_3d = (yaw_score * 0.4 + pelvis_score * 0.4 + z_score * 0.2)
-        
-        if pelvis_change_pct > 15.0:
-            dbg(f"3D_conf - pelvis_change={pelvis_change_pct:.1f}% suggests occlusion")
-        
-        return max(0.0, min(1.0, conf_3d)), pelvis_change_pct
-        
-    except Exception:
-        return 0.3, 100.0
 
-def _compute_2d_confidence(pose_data, swing_phases, setup_frames):
-    """
-    Compute 2D confidence based on homography quality and geometric consistency
-    Returns confidence score 0.0-1.0
-    """
-    try:
-        sm = smooth_landmarks(pose_data)
-        H, valid_H, reason = _build_ground_homography(sm, setup_frames)
-        
-        if not valid_H:
-            return 0.0
-        
-        # Check target/toe angle consistency
-        target_vecs_2d = []
-        toe_vecs_2d = []
-        
-        for f in setup_frames[:3]:
-            lm = sm.get(f)
-            if lm and len(lm) > 32 and lm[31] and lm[32]:
-                # Toe vector in ground plane
-                toe_img = [[lm[31][0], lm[31][1]], [lm[32][0], lm[32][1]]]
-                try:
-                    import cv2
-                    toe_ground = cv2.perspectiveTransform(np.array(toe_img, dtype=np.float32).reshape(1,-1,2), H)[0]
-                    toe_vec = toe_ground[1] - toe_ground[0]
-                    norm = np.linalg.norm(toe_vec)
-                    if norm > 1e-6:
-                        toe_vecs_2d.append(toe_vec / norm)
-                        # Target perpendicular to toe
-                        target_vec = np.array([-toe_vec[1], toe_vec[0]]) / norm
-                        target_vecs_2d.append(target_vec)
-                except:
-                    continue
-        
-        if not target_vecs_2d:
-            return 0.2
-        
-        # Check consistency of target direction
-        target_consistency = 1.0 - np.std([math.degrees(math.atan2(tv[1], tv[0])) for tv in target_vecs_2d]) / 10.0
-        
-        # Check toe-target perpendicularity
-        toe_target_angles = []
-        for toe_vec, target_vec in zip(toe_vecs_2d, target_vecs_2d):
-            angle = abs(math.degrees(math.acos(np.clip(np.dot(toe_vec, target_vec), -1, 1))))
-            toe_target_angles.append(abs(angle - 90.0))
-        
-        perp_score = max(0, 1.0 - np.mean(toe_target_angles) / 5.0)  # Good if within 5° of 90°
-        
-        # Homography quality score (det and error already checked in valid_H)
-        h_score = 0.8 if valid_H else 0.0
-        
-        conf_2d = (target_consistency * 0.3 + perp_score * 0.4 + h_score * 0.3)
-        
-        
-        return max(0.0, min(1.0, conf_2d))
-        
-    except Exception:
-        return 0.0
 
 def calculate_hip_turn_at_impact(
     pose_data: Dict[int, List],
     swing_phases: Dict[str, List],
     world_landmarks: Optional[Dict[int, List]] = None,
     frames: Optional[List[np.ndarray]] = None
-) -> Union[float, None]:
+) -> Union[Dict[str, Union[float, None]], None]:
     """
     Hip turn @ impact: TARGET-RELATIVE degrees (positive = open to target).
+    Returns dict with both absolute and delta (change from address) values.
     Fixed to use target line reference instead of camera-relative angles.
     """
     PLAUSIBLE = 70.0
 
     if not world_landmarks:
         # Fallback: calculate from 2D pose data only
-        return _calculate_hip_turn_2d_fallback(pose_data, swing_phases, _impact_frame(pose_data, swing_phases))
+        fallback_result = _calculate_hip_turn_2d_fallback(pose_data, swing_phases, _impact_frame(pose_data, swing_phases))
+        return {
+            "abs_deg": fallback_result,
+            "delta_deg": None,
+            "addr_deg": None,
+        } if fallback_result is not None else None
     
     # Get setup frames for target axis and baseline
     setup_frames = swing_phases.get("setup", [])[:10]
@@ -776,7 +869,12 @@ def calculate_hip_turn_at_impact(
         if all_frames:
             setup_frames = all_frames[:min(5, len(all_frames))]
         else:
-            return _calculate_hip_turn_2d_fallback(pose_data, swing_phases, _impact_frame(pose_data, swing_phases))
+            fallback_result = _calculate_hip_turn_2d_fallback(pose_data, swing_phases, _impact_frame(pose_data, swing_phases))
+            return {
+                "abs_deg": fallback_result,
+                "delta_deg": None,
+                "addr_deg": None,
+            } if fallback_result is not None else None
         
     # Build stable target axis from toe line
     target_hat = _target_hat_from_toes_world(world_landmarks, setup_frames, handedness='right')
@@ -785,17 +883,27 @@ def calculate_hip_turn_at_impact(
     impact_f = _impact_frame(world_landmarks, swing_phases)
     if impact_f is None or impact_f not in world_landmarks:
         # Fallback: use 2D calculation
-        return _calculate_hip_turn_2d_fallback(pose_data, swing_phases, _impact_frame(pose_data, swing_phases))
+        fallback_result = _calculate_hip_turn_2d_fallback(pose_data, swing_phases, _impact_frame(pose_data, swing_phases))
+        return {
+            "abs_deg": fallback_result,
+            "delta_deg": None,
+            "addr_deg": None,
+        } if fallback_result is not None else None
     
     # Get pelvis direction at impact
     impact_pelvis_hat = pelvis_hat(world_landmarks[impact_f])
     
     if impact_pelvis_hat is None:
         # Fallback: use 2D calculation
-        return _calculate_hip_turn_2d_fallback(pose_data, swing_phases, impact_f)
+        fallback_result = _calculate_hip_turn_2d_fallback(pose_data, swing_phases, impact_f)
+        return {
+            "abs_deg": fallback_result,
+            "delta_deg": None,
+            "addr_deg": None,
+        } if fallback_result is not None else None
     
-    # ±1 frame median for stability at impact
-    impact_frames_nearby = [f for f in range(impact_f-1, impact_f+2) if f in world_landmarks]
+    # ±2 frame median for stability at impact (expanded window)
+    impact_frames_nearby = [f for f in range(impact_f-2, impact_f+3) if f in world_landmarks]
     if len(impact_frames_nearby) > 1:
         impact_rels = []
         for f in impact_frames_nearby:
@@ -809,37 +917,36 @@ def calculate_hip_turn_at_impact(
     else:
         impact_rel = signed_angle2(target_hat, impact_pelvis_hat)
     
-    # Hip turn = absolute open angle vs target at impact (not delta from setup)
+    # Hip orientation (absolute) vs target at impact
     hip_turn_abs = wrap180(impact_rel)
+
+    # NEW: compute address (baseline) and delta turn
+    addr_rel = _address_pelvis_rel(world_landmarks, setup_frames, target_hat)
+    hip_turn_delta = None if addr_rel is None else wrap180(hip_turn_abs - addr_rel)
     
-    # 3D confidence check
-    conf_3d, pelvis_change_pct = _conf3d(world_landmarks, impact_f, setup_frames)
+    # Use 3D calculation as primary method
+    final_turn = hip_turn_abs
     
-    # Use 3D if high confidence and stable pelvis
-    if conf_3d >= 0.75 and pelvis_change_pct <= 15.0:
-        final_turn = hip_turn_abs
-    else:
-        # Try 2D fallback
-        turn_2d = _calculate_hip_turn_2d_fallback(pose_data, swing_phases, impact_f)
-        if turn_2d is not None:
-            _, valid_H, _ = _build_ground_homography(smooth_landmarks(pose_data), setup_frames)
-            if valid_H and abs(hip_turn_abs - turn_2d) <= 20.0:
-                final_turn = turn_2d
-                dbg(f"hip_turn - using 2D fallback: {turn_2d:.1f}°")
-            else:
-                final_turn = hip_turn_abs
-        else:
-            final_turn = hip_turn_abs
-            if conf_3d < 0.75 or pelvis_change_pct > 15.0:
-                dbg(f"hip_turn - 3D unreliable (conf={conf_3d:.3f}, pelvis_change={pelvis_change_pct:.1f}%)")
+    # Prepare both absolute and delta values
+    final_abs = float(final_turn)
+    final_delta = None if addr_rel is None else wrap180(final_turn - addr_rel)
+
+    # Plausibility clamp for delta (pros ~30–45 by club); still always return something
+    if final_delta is not None and abs(final_delta) > PLAUSIBLE:
+        final_delta = PLAUSIBLE if final_delta > 0 else -PLAUSIBLE
+
+    # Final plausible check for absolute
+    if abs(final_abs) > PLAUSIBLE:
+        dbg(f"hip_turn - VALUE {final_abs:.1f}° EXCEEDS PLAUSIBLE RANGE, clamping")
+        # Clamp to reasonable range rather than returning None
+        final_abs = PLAUSIBLE if final_abs > 0 else -PLAUSIBLE
     
-    # Plausible check - but ALWAYS return something
-    if abs(final_turn) > PLAUSIBLE:
-        if conf_3d < 0.8:
-            dbg(f"hip_turn - VALUE {final_turn:.1f}° EXCEEDS PLAUSIBLE RANGE, clamping")
-            # Clamp to reasonable range rather than returning None
-            final_turn = PLAUSIBLE if final_turn > 0 else -PLAUSIBLE
-    return float(final_turn)
+    # Return both values and metadata for UI
+    return {
+        "abs_deg": final_abs,
+        "delta_deg": final_delta,
+        "addr_deg": addr_rel
+    }
 
 
 def _build_ground_homography(sm, setup_frames):
@@ -950,8 +1057,43 @@ def _calculate_hip_turn_2d_fallback(pose_data: Dict[int, List], swing_phases: Di
             return None
             
         toe_hat_2d = np.median(toe_vecs_ground, axis=0)
-        # Target is parallel to toe line (not perpendicular)
-        target_hat_2d = toe_hat_2d
+        toe_hat_2d = toe_hat_2d / (np.linalg.norm(toe_hat_2d) + 1e-9)
+        
+        # Target is PERPENDICULAR to toe line (raw)
+        target_hat_2d = np.array([-toe_hat_2d[1], toe_hat_2d[0]])
+        target_hat_2d /= (np.linalg.norm(target_hat_2d) + 1e-9)
+        
+        # --- NEW: sign disambiguation using address -> impact movement ---
+        candidate_fwd = None
+        if "impact" in swing_phases and swing_phases["impact"]:
+            candidate_fwd = swing_phases["impact"][0]
+        elif "downswing" in swing_phases and swing_phases["downswing"]:
+            candidate_fwd = swing_phases["downswing"][-1]
+        else:
+            all_frames_sorted = sorted(pose_data.keys())
+            candidate_fwd = all_frames_sorted[-1] if all_frames_sorted else None
+
+        if candidate_fwd is not None:
+            # Get address and impact pelvis centers in ground plane
+            addr_ctrs = []
+            for f in setup_frames:
+                lm = sm.get(f)
+                if lm and len(lm) > 32 and lm[23] and lm[24]:
+                    hip_img = [[lm[23][0], lm[23][1]], [lm[24][0], lm[24][1]]]
+                    hip_ground = warp_pts(hip_img)
+                    addr_ctrs.append((hip_ground[0] + hip_ground[1]) / 2)
+            
+            lm_impact = sm.get(candidate_fwd)
+            if addr_ctrs and lm_impact and lm_impact[23] and lm_impact[24]:
+                hip_img = [[lm_impact[23][0], lm_impact[23][1]], [lm_impact[24][0], lm_impact[24][1]]]
+                impact_ground = warp_pts(hip_img)
+                impact_ctr = (impact_ground[0] + impact_ground[1]) / 2
+                
+                addr_ctr = np.median(np.stack(addr_ctrs), axis=0)
+                fwd_vec = impact_ctr - addr_ctr
+                # If forward (address->impact) projects negative, flip target axis
+                if float(np.dot(fwd_vec, target_hat_2d)) < 0.0:
+                    target_hat_2d = -target_hat_2d
         
         # Get pelvis directions in ground plane
         def pelvis_hat_ground(frame_idx):
@@ -980,85 +1122,156 @@ def _calculate_hip_turn_2d_fallback(pose_data: Dict[int, List], swing_phases: Di
     except Exception:
         return None
 
-
-
-
-
-
-
-
 def calculate_hip_sway_at_top(pose_data: Dict[int, List], swing_phases: Dict[str, List], 
-                             world_landmarks: Optional[Dict[int, List]] = None) -> Union[float, None]:
-    """Calculate hip sway at top using 2D homography projection along toe/target axis"""
-    smoothed_pose_data = smooth_landmarks(pose_data)
-    
-    setup_frames = _address_frames(swing_phases)
-    if not setup_frames:
-        return None
-    
-    # Find top frame
+                              world_landmarks: Optional[Dict[int, List]] = None) -> Union[float, None]:
+    sm = smooth_landmarks(pose_data)
+
+    # (1) robust address & top
+    initial_setup_frames = _pick_stable_setup_frames(sm, swing_phases, max_frames=6)
+    if not initial_setup_frames: return None
     backswing_frames = swing_phases.get("backswing", [])
-    if not backswing_frames:
-        return None
-    
-    top_frame = _pick_top_frame_hinge(smoothed_pose_data, backswing_frames, handed='right')
-    if top_frame is None:
-        top_frame = backswing_frames[-1]
+    if not backswing_frames: return None
+    top_frame = _pick_top_frame_hinge(sm, backswing_frames, handed='right') or backswing_frames[-1]
+
+    # (2) foot-only homography (no hips); reduces circularity/instability
+    H, valid_H, H_frame = _build_foot_only_homography(sm, initial_setup_frames)
     
-    # Use 2D homography as primary method (world landmarks can re-center per frame)
-    H, valid_H, _ = _build_ground_homography(smoothed_pose_data, setup_frames)
-    if not valid_H:
-        # ALWAYS DISPLAY SOMETHING - fallback to simple pixel measurement if homography fails
-        return _simple_pixel_sway_fallback(smoothed_pose_data, setup_frames, top_frame)
-        
-    try:
+    # (2.5) improved processing if homography is valid
+    if valid_H and H is not None:
         import cv2
+        warp2 = lambda pts: cv2.perspectiveTransform(np.array(pts, dtype=np.float32).reshape(1, -1, 2), H)[0]
         
-        def pelvis_center_ground(frame_idx):
-            lm = smoothed_pose_data.get(frame_idx)
-            if not lm or not lm[23] or not lm[24]:
-                return None
-            hip_img = np.array([[lm[23][0], lm[23][1]], [lm[24][0], lm[24][1]]], dtype=np.float32)
-            g = cv2.perspectiveTransform(hip_img.reshape(1,-1,2), H)[0]
-            return (g[0] + g[1]) / 2
+        # Improved address selection with stillness criteria
+        setup_frames = _pick_quiet_address(sm, swing_phases, warp2, max_frames=6)
+        if not setup_frames:
+            setup_frames = initial_setup_frames
         
-        # Toe direction (ground) = target axis
+        # Refine top frame using velocity
         toe_vecs = []
         for f in setup_frames:
-            lm = smoothed_pose_data.get(f)
-            if lm and lm[31] and lm[32]:
-                toe_img = np.array([[lm[31][0], lm[31][1]], [lm[32][0], lm[32][1]]], dtype=np.float32)
-                toe_g = cv2.perspectiveTransform(toe_img.reshape(1,-1,2), H)[0]
-                v = toe_g[1] - toe_g[0]
-                n = np.linalg.norm(v)
-                if n > 1e-6:
-                    toe_vecs.append(v/n)
-        
-        if not toe_vecs:
-            return None
-            
-        target_hat_g = np.median(toe_vecs, axis=0)  # unit 2D vector in ground coords
-        
-        # Setup center (median)
-        setup_centers = [pelvis_center_ground(f) for f in setup_frames]
-        setup_centers = [c for c in setup_centers if c is not None]
-        if not setup_centers:
-            return None
-        setup_ctr = np.median(setup_centers, axis=0)
-        
-        # Top center
-        top_ctr = pelvis_center_ground(top_frame)
-        if top_ctr is None:
-            return None
-        
-        # Project movement onto toe/target axis
-        delta = top_ctr - setup_ctr
-        sway_inches = float(np.dot(delta, target_hat_g))  # ground_pts are in inches already
-        return sway_inches
-        
-    except Exception:
-        # ALWAYS DISPLAY SOMETHING - fallback if homography projection fails
-        return _simple_pixel_sway_fallback(smoothed_pose_data, setup_frames, top_frame)
+            lm = sm.get(f)
+            if not lm or not lm[31] or not lm[32]: continue
+            toe_img = [[lm[31][0], lm[31][1]], [lm[32][0], lm[32][1]]]
+            toe_g = warp2(toe_img)
+            v = toe_g[1] - toe_g[0]
+            n = np.linalg.norm(v)
+            if n > 1e-6:
+                toe_vecs.append(v / n)
+        if toe_vecs:
+            toe_hat_g_vel = np.median(np.stack(toe_vecs), axis=0)
+            toe_hat_g_vel /= (np.linalg.norm(toe_hat_g_vel) + 1e-9)
+            # Target line is PERPENDICULAR to toe line
+            target_hat_g = np.array([-toe_hat_g_vel[1], toe_hat_g_vel[0]], dtype=float)
+            target_hat_g /= (np.linalg.norm(target_hat_g) + 1e-9)
+            top_frame = _refine_top_by_lat_vel(sm, backswing_frames, warp2, target_hat_g, top_frame)
+    else:
+        setup_frames = initial_setup_frames
+    if not valid_H:
+        # fallback improved: compute px→inch using world toes if available
+        return _simple_pixel_sway_fallback(sm, setup_frames, top_frame, swing_phases, world_landmarks)
+
+    import cv2
+
+    def warp2(pts):
+        A = np.array(pts, dtype=np.float32).reshape(1, -1, 2)
+        return cv2.perspectiveTransform(A, H)[0]
+
+    # (3) target axis from toe line (ground), same as before
+    toe_vecs = []
+    for f in setup_frames:
+        lm = sm.get(f)
+        if not lm or not lm[31] or not lm[32]: continue
+        toe_img = [[lm[31][0], lm[31][1]], [lm[32][0], lm[32][1]]]
+        toe_g = warp2(toe_img)
+        v = toe_g[1] - toe_g[0]
+        n = np.linalg.norm(v)
+        if n > 1e-6:
+            toe_vecs.append(v / n)
+    if not toe_vecs:
+        return None
+    toe_hat_g = np.median(np.stack(toe_vecs), axis=0)
+    toe_hat_g /= (np.linalg.norm(toe_hat_g) + 1e-9)
+    # Target line is PERPENDICULAR to toe line (down-the-line toward the flag)
+    target_hat_g = np.array([-toe_hat_g[1], toe_hat_g[0]], dtype=float)
+    target_hat_g /= (np.linalg.norm(target_hat_g) + 1e-9)
+    print(f"DEBUG sway2: toe_hat_g={toe_hat_g}, target_hat_g={target_hat_g}, dot≈{float(np.dot(toe_hat_g, target_hat_g)):.3f}")
+
+    # (4) sign disambiguation using address→impact pelvis motion (keep)
+    candidate_fwd = None
+    if swing_phases.get("impact"): candidate_fwd = swing_phases["impact"][0]
+    elif swing_phases.get("downswing"): candidate_fwd = swing_phases["downswing"][-1]
+    else:
+        allf = sorted(sm.keys()); candidate_fwd = allf[-1] if allf else None
+
+    def pelvis_center_ground(f):
+        lm = sm.get(f)
+        if not lm or not lm[23] or not lm[24]: return None
+        g = warp2([[lm[23][0], lm[23][1]], [lm[24][0], lm[24][1]]])
+        return (g[0] + g[1]) / 2
+
+    if candidate_fwd is not None:
+        addr_ctrs = [pelvis_center_ground(f) for f in setup_frames]
+        addr_ctrs = [c for c in addr_ctrs if c is not None]
+        imp_ctr = pelvis_center_ground(candidate_fwd)
+        if addr_ctrs and imp_ctr is not None:
+            addr_ctr = np.median(np.stack(addr_ctrs), axis=0)
+            fwd_vec = imp_ctr - addr_ctr
+            if float(np.dot(fwd_vec, target_hat_g)) < 0.0:
+                target_hat_g = -target_hat_g
+
+    # (5) centers at address (median) and at top
+    setup_centers = [pelvis_center_ground(f) for f in setup_frames]
+    setup_centers = [c for c in setup_centers if c is not None]
+    if not setup_centers: return None
+    setup_ctr = np.median(np.stack(setup_centers), axis=0)
+    top_ctr = pelvis_center_ground(top_frame)
+    if top_ctr is None: return None
+
+    # (6) ***Calibrate inches*** with world toes if available
+    inch_scale = 1.0
+    if world_landmarks is not None and H_frame in world_landmarks:
+        wf = world_landmarks[H_frame]
+        # 3D toe XZ spacing (meters) → inches
+        try:
+            L_FOOT_INDEX, R_FOOT_INDEX = 29, 30
+            Lt, Rt = wf[L_FOOT_INDEX], wf[R_FOOT_INDEX]
+            if Lt and Rt:
+                d_m = math.hypot(Rt[0]-Lt[0], Rt[2]-Lt[2])  # XZ
+                d_in_true = d_m * 39.3701
+                # 2D ground length from homography at same frame:
+                lmH = sm.get(H_frame)
+                toe_img = [[lmH[31][0], lmH[31][1]], [lmH[32][0], lmH[32][1]]]
+                toe_g = warp2(toe_img)
+                d_in_curr = float(np.linalg.norm(toe_g[1]-toe_g[0]))
+                if d_in_curr > 1e-3 and d_in_true > 1e-3:
+                    inch_scale = d_in_true / d_in_curr
+        except Exception:
+            pass
+
+    delta = (top_ctr - setup_ctr) * inch_scale
+    lat = float(np.dot(delta, target_hat_g))   # toward target (lateral)
+    fwd = float(np.dot(delta, np.array([-target_hat_g[1], target_hat_g[0]])))  # forward/back
+    print(f"DEBUG sway2: lat_in={lat:.2f}, fwd_in={fwd:.2f}, inch_scale={inch_scale:.3f}")
+    
+    # Compute lead hip sway as alternative measurement
+    lead_sway = _lead_hip_sway(sm, setup_frames, top_frame, warp2, target_hat_g)
+    if lead_sway is not None:
+        lead_sway_inches = lead_sway * inch_scale
+        print(f"DEBUG sway2: lead_hip_sway_in={lead_sway_inches:.2f}")
+        # Prefer lead hip measurement if available
+        sway_inches = lead_sway_inches
+    else:
+        sway_inches = lat
+
+    print(f"DEBUG sway2: H_frame={H_frame}, inch_scale={inch_scale:.3f}, "
+          f"setup_ctr_g={setup_ctr*inch_scale}, top_ctr_g={top_ctr*inch_scale}, "
+          f"sway_in={sway_inches:.2f}")
+
+    # sanity note only
+    if abs(sway_inches) < 0.2:
+        print(f"DEBUG sway2: tiny sway {sway_inches:.2f}\" — check camera or address selection")
+
+    return sway_inches
 
 
 
@@ -1074,29 +1287,142 @@ def angle_between(u, v):
 
 
 
-def _hinge2d(lm, handed='right'):
-    """Simple 2D hinge angle: elbow-wrist vs wrist-index (robust, repeatable)"""
-    if not lm:
+def _shaft_vec_proxy(lm, handed='right'):
+    """Approximate shaft/handle direction using the two wrists."""
+    L_WR, R_WR = 15, 16
+    if not lm or not lm[L_WR] or not lm[R_WR]:
         return None
-    EL, WR = (13, 15) if handed=='right' else (14, 16)  # Lead arm
-    IM = 19 if handed=='right' else 20
-    if not lm[EL] or not lm[WR] or not lm[IM]:
+    if lm[L_WR][2] < 0.5 or lm[R_WR][2] < 0.5:
         return None
+    # For right-handed golfer, shaft points from lead (L) to trail (R)
+    v = (lm[R_WR][0] - lm[L_WR][0], lm[R_WR][1] - lm[L_WR][1]) if handed=='right' \
+        else (lm[L_WR][0] - lm[R_WR][0], lm[L_WR][1] - lm[R_WR][1])
+    return np.array(v, float)
+
+def _hand_point(lm, handed='right'):
+    # Mediapipe Pose: L index=19, L pinky=17, L thumb=21; R index=20, R pinky=18, R thumb=22
+    if handed == 'right':
+        IDX, THU, PNK = 19, 21, 17  # lead arm = left arm landmarks
+    else:
+        IDX, THU, PNK = 20, 22, 18  # lead arm = right arm landmarks
     
-    u = np.array([lm[WR][0]-lm[EL][0], lm[WR][1]-lm[EL][1]], float)  # forearm
-    v = np.array([lm[IM][0]-lm[WR][0], lm[IM][1]-lm[WR][1]], float)  # hand
-    nu, nv = np.linalg.norm(u), np.linalg.norm(v)
-    if nu < 1e-6 or nv < 1e-6:
+    cand = []
+    for i in (IDX, THU, PNK):
+        if i < len(lm) and lm[i] and lm[i][2] >= 0.5:
+            cand.append((lm[i][0], lm[i][1]))
+    if not cand:
+        return None
+    # prefer index+thumb average if both exist
+    has_idx = (len(lm) > IDX and lm[IDX] and lm[IDX][2] >= 0.5)
+    has_thu = (len(lm) > THU and lm[THU] and lm[THU][2] >= 0.5)
+    if has_idx and has_thu:
+        return ((lm[IDX][0] + lm[THU][0]) * 0.5, (lm[IDX][1] + lm[THU][1]) * 0.5)
+    # else median of whatever we have
+    xs, ys = zip(*cand)
+    return (float(np.median(xs)), float(np.median(ys)))
+
+def _hinge2d_shaft(lm, handed='right'):
+    """Hinge = 180° - angle(forearm, shaft_proxy)."""
+    if not lm: return None
+    EL, WR = (13, 15) if handed=='right' else (14, 16)  # lead elbow/wrist
+    if not lm[EL] or not lm[WR] or lm[EL][2] < 0.5 or lm[WR][2] < 0.5:
         return None
-    
-    ang = math.degrees(math.acos(np.clip(np.dot(u,v)/(nu*nv), -1, 1)))  # 0..180
-    return 180.0 - ang  # more hinge → larger value
-
-
-
-
 
+    # Forearm vector
+    u = np.array([lm[WR][0]-lm[EL][0], lm[WR][1]-lm[EL][1]], float)
+    nu = np.linalg.norm(u)
+    if nu < 1e-6: return None
+
+    # Shaft proxy
+    s = _shaft_vec_proxy(lm, handed)
+    if s is None:
+        # Fallback: keep your old hand-point method but guard against colinearity
+        hp = _hand_point(lm, handed)
+        if hp is None: return None
+        s = np.array([hp[0]-lm[WR][0], hp[1]-lm[WR][1]], float)
+    ns = np.linalg.norm(s)
+    if ns < 1e-6: return None
+
+    # Angle between lines (ignore direction)
+    c = float(np.clip(np.dot(u, s)/(nu*ns), -1, 1))
+    theta = math.degrees(math.acos(c))     # 0..180, 90° when perpendicular
+    hinge = 180.0 - theta                  # hinge large when shaft closer to perpendicular to forearm
+
+    # Sanity clamp
+    return max(20.0, min(160.0, hinge))
 
+def _hinge2d(lm, handed='right'):
+    """Legacy function - now calls shaft-based version"""
+    return _hinge2d_shaft(lm, handed)
+
+def _pelvis_ctr_ground_series(sm, frames, warp2):
+    """Get pelvis centers in ground plane for given frames"""
+    ctrs = []
+    for f in frames:
+        lm = sm.get(f)
+        if not lm or not lm[23] or not lm[24]: 
+            ctrs.append(None)
+            continue
+        g = warp2([[lm[23][0], lm[23][1]], [lm[24][0], lm[24][1]]])
+        ctrs.append(((g[0]+g[1])/2).astype(float))
+    return ctrs
+
+def _refine_top_by_lat_vel(sm, backswing_frames, warp2, target_hat_g, init_top):
+    """Refine top frame using lateral pelvis velocity zero-crossing"""
+    # compute pelvis centers along backswing and project onto target axis
+    ctrs = _pelvis_ctr_ground_series(sm, backswing_frames, warp2)
+    ts = [i for i,c in enumerate(ctrs) if c is not None]
+    if len(ts) < 5: 
+        return init_top  # not enough samples
+    proj = np.array([float(np.dot(ctrs[i], target_hat_g)) if ctrs[i] is not None else np.nan for i in range(len(ctrs))])
+    # smooth (5-pt)
+    k = 5
+    proj_s = np.convolve(np.nan_to_num(proj), np.ones(k)/k, mode='same')
+    # finite diff
+    vel = np.gradient(proj_s)
+    # take frame near init_top where vel≈0 and |vel| is locally minimal (change of direction)
+    idx0 = backswing_frames.index(init_top) if init_top in backswing_frames else len(backswing_frames)-1
+    win = range(max(0, idx0-4), min(len(vel), idx0+5))
+    # find zero-cross or min |vel|
+    cand = min(win, key=lambda i: abs(vel[i]))
+    return backswing_frames[cand]
+
+def _point_ground(frame_idx, sm, warp2, i):
+    """Get ground-plane position of landmark i in frame frame_idx"""
+    lm = sm.get(frame_idx)
+    if not lm or not lm[i]: return None
+    return warp2([[lm[i][0], lm[i][1]]])[0].astype(float)
+
+def _lead_hip_sway(sm, addr_frames, top_frame, warp2, target_hat_g):
+    """Compute lead hip sway as alternative to pelvis center"""
+    L_HIP = 23
+    addr_pts = [_point_ground(f, sm, warp2, L_HIP) for f in addr_frames]
+    addr_pts = [p for p in addr_pts if p is not None]
+    top_pt  = _point_ground(top_frame, sm, warp2, L_HIP)
+    if not addr_pts or top_pt is None: return None
+    addr_med = np.median(np.stack(addr_pts), axis=0)
+    delta = top_pt - addr_med
+    return float(np.dot(delta, target_hat_g))
+
+def _pick_p3_lead_arm_parallel(sm, backswing_frames, handed='right', tol_deg=15.0):
+    """Pick the backswing frame where the lead shoulder→lead wrist vector is most horizontal."""
+    L_SHO, WR = (11, 15) if handed=='right' else (12, 16)
+    best = None
+    best_abs = 1e9
+    for f in backswing_frames:
+        lm = sm.get(f)
+        if not lm or not lm[L_SHO] or not lm[WR]: 
+            continue
+        if lm[L_SHO][2] < 0.5 or lm[WR][2] < 0.5:
+            continue
+        dx = lm[WR][0] - lm[L_SHO][0]
+        dy = lm[WR][1] - lm[L_SHO][1]
+        if abs(dx) + abs(dy) < 1e-6:
+            continue
+        ang = abs(math.degrees(math.atan2(dy, dx)))  # 0° is perfectly horizontal
+        if ang < best_abs:
+            best_abs, best = ang, f
+    return best
 
 def _pick_top_frame_hinge(sm, backswing_frames, handed='right'):
     """Pick frame with maximum hinge in backswing"""
@@ -1112,16 +1438,9 @@ def _pick_top_frame_hinge(sm, backswing_frames, handed='right'):
     top_frame, hinge_top = max(top_vals, key=lambda x: x[1])
     return top_frame
 
-
-
-
-
-
-
-
 def calculate_wrist_hinge_at_top(pose_data: Dict[int, List], swing_phases: Dict[str, List], 
-                                frames: Optional[List[np.ndarray]] = None) -> Union[Dict[str, float], None]:
-    """Calculate wrist hinge using simple 2D angle method"""
+                                frames: Optional[List[np.ndarray]] = None, handedness: str = 'right') -> Union[Dict[str, float], None]:
+    """Calculate wrist hinge using shaft-based method with both P3 and top measurements"""
     sm = smooth_landmarks(pose_data)
     
     backswing_frames = swing_phases.get("backswing", [])
@@ -1136,68 +1455,104 @@ def calculate_wrist_hinge_at_top(pose_data: Dict[int, List], swing_phases: Dict[
         else:
             return None  # Truly no data
     
-    # Top = max hinge in backswing
-    top_frame = _pick_top_frame_hinge(sm, backswing_frames, handed='right')
-    if top_frame is None:
-        top_frame = backswing_frames[-1]  # Use last frame as fallback
-    
-    hinge_top = _hinge2d(sm.get(top_frame), handed='right')
-    if hinge_top is None:
-        # Try to find any frame with valid hinge data
-        for frame_idx in backswing_frames:
-            test_hinge = _hinge2d(sm.get(frame_idx), handed='right')
-            if test_hinge is not None:
-                hinge_top = test_hinge
-                break
-        if hinge_top is None:
-            return None  # Truly no wrist data available
-    
-    # Address median for delta calculation
-    setup_frames = _address_frames(swing_phases)
-    addr_vals = [_hinge2d(sm.get(f), handed='right') for f in setup_frames[:5]]
-    addr_vals = [h for h in addr_vals if h is not None]
-    hinge_addr = np.median(addr_vals) if addr_vals else None
-
-    result = {"radial_deviation_deg": hinge_top}
-    if hinge_addr is not None:
-        delta = hinge_top - hinge_addr
-        result["delta_deg"] = delta
-        
-        # Quality check for typical range
-        if not (15.0 <= delta <= 50.0):
-            result["definition_suspect"] = True
-    
+    # Top frame and hinge
+    top_frame = _pick_top_frame_hinge(sm, backswing_frames, handed=handedness) or backswing_frames[-1]
+    hinge_top = _hinge2d_shaft(sm.get(top_frame), handedness)
+
+    # NEW: P3 frame and hinge
+    p3_frame = _pick_p3_lead_arm_parallel(sm, backswing_frames, handedness)
+    hinge_p3 = _hinge2d_shaft(sm.get(p3_frame), handedness) if p3_frame is not None else None
+
+    # Address baseline (use shaft-based hinge to avoid "palm vector too short")
+    setup_frames = _pick_still_address_by_hand(sm, swing_phases, handedness, max_frames=6) or _address_frames(swing_phases)
+    addr_vals = []
+    for f in setup_frames[:6]:
+        h = _hinge2d_shaft(sm.get(f), handedness)
+        if h is not None: addr_vals.append(h)
+    hinge_addr = float(np.median(addr_vals)) if addr_vals else None
+
+    result = {
+        "radial_deviation_deg_top": hinge_top,
+        "radial_deviation_deg_p3": hinge_p3,
+        "addr_deg": hinge_addr,
+        "delta_deg_p3": (hinge_p3 - hinge_addr) if (hinge_p3 is not None and hinge_addr is not None) else None,
+        "delta_deg_top": (hinge_top - hinge_addr) if (hinge_top is not None and hinge_addr is not None) else None,
+        # Flag outside typical pro band for P3
+        "definition_suspect": (hinge_p3 is None) or not (50 <= hinge_p3 <= 130),
+        # Legacy field for backward compatibility
+        "radial_deviation_deg": hinge_p3 if hinge_p3 is not None else hinge_top
+    }
     return result
 
 
 def compute_front_facing_metrics(pose_data: Dict[int, List], swing_phases: Dict[str, List], 
                                 world_landmarks: Optional[Dict[int, List]] = None,
-                                frames: Optional[List[np.ndarray]] = None) -> Dict[str, Dict[str, Union[float, None]]]:
-    """Compute the 4 required front-facing golf swing metrics"""
+                                frames: Optional[List[np.ndarray]] = None,
+                                club: str = "iron", 
+                                handedness: str = "right") -> Dict[str, Dict[str, Union[float, str, None]]]:
+    """Compute the 4 required front-facing golf swing metrics with club-aware grading"""
     
     # Calculate individual metrics
     shoulder_tilt_impact = calculate_shoulder_tilt_at_impact(
-        pose_data, swing_phases, world_landmarks, frames=frames
+        pose_data, swing_phases, world_landmarks, frames=frames, handedness=handedness
     )
-    hip_turn_impact = calculate_hip_turn_at_impact(pose_data, swing_phases, world_landmarks, frames)
+    hip_turn_result = calculate_hip_turn_at_impact(pose_data, swing_phases, world_landmarks, frames)
     hip_sway_top = calculate_hip_sway_at_top(pose_data, swing_phases, world_landmarks)
-    wrist_hinge_result = calculate_wrist_hinge_at_top(pose_data, swing_phases, frames)
+    wrist_hinge_result = calculate_wrist_hinge_at_top(pose_data, swing_phases, frames, handedness=handedness)
+    
+    # Process hip turn results
+    hip_turn_data = {}
+    if hip_turn_result:
+        hip_abs = hip_turn_result.get('abs_deg')
+        hip_delta = hip_turn_result.get('delta_deg')
+        hip_addr = hip_turn_result.get('addr_deg')
+        
+        # Prefer delta if available, fallback to absolute
+        display_value = hip_delta if hip_delta is not None else hip_abs
+        value_type = "delta" if hip_delta is not None else "absolute"
+        
+        # Get club-aware grading
+        if display_value is not None:
+            grading = grade_hip_turn(display_value, club)
+            hip_turn_data = {
+                'value': display_value,
+                'abs_deg': hip_abs,
+                'delta_deg': hip_delta, 
+                'addr_deg': hip_addr,
+                'value_type': value_type,
+                'grade_label': grading['label'],
+                'grade_color': grading['color'],
+                'grade_tip': grading['tip'],
+            }
+        else:
+            hip_turn_data = {'value': None}
+    else:
+        hip_turn_data = {'value': None}
     
-    # Extract wrist hinge values
-    wrist_radial_dev = wrist_hinge_result.get('radial_deviation_deg') if wrist_hinge_result else None
-    wrist_hinge_delta = wrist_hinge_result.get('delta_deg') if wrist_hinge_result else None
+    # Extract wrist hinge values (NEW: prioritize P3 measurements)
+    wrist_p3 = wrist_hinge_result.get('radial_deviation_deg_p3') if wrist_hinge_result else None
+    wrist_top = wrist_hinge_result.get('radial_deviation_deg_top') if wrist_hinge_result else None
+    wrist_addr = wrist_hinge_result.get('addr_deg') if wrist_hinge_result else None
+    delta_p3 = wrist_hinge_result.get('delta_deg_p3') if wrist_hinge_result else None
+    delta_top = wrist_hinge_result.get('delta_deg_top') if wrist_hinge_result else None
     definition_suspect = wrist_hinge_result.get('definition_suspect', False) if wrist_hinge_result else False
     
-    # ALWAYS DISPLAY A METRIC - use delta first, then absolute as fallback
-    wrist_final = wrist_hinge_delta
-    if wrist_final is None and wrist_radial_dev is not None:
-        wrist_final = wrist_radial_dev  # Use absolute as fallback
+    # Prefer P3 delta, then P3 absolute, then top values
+    wrist_final = delta_p3 if delta_p3 is not None else (wrist_p3 if wrist_p3 is not None else wrist_top)
         
     front_facing_metrics = {
         'shoulder_tilt_impact_deg': {'value': shoulder_tilt_impact},
-        'hip_turn_impact_deg': {'value': hip_turn_impact},
+        'hip_turn_impact_deg': hip_turn_data,
         'hip_sway_top_inches': {'value': hip_sway_top},
-        'wrist_hinge_top_deg': {'value': wrist_final}
+        'wrist_hinge_top_deg': {
+            'value': wrist_final,
+            'p3_deg': wrist_p3,
+            'top_deg': wrist_top,
+            'addr_deg': wrist_addr,
+            'delta_p3_deg': delta_p3,
+            'delta_top_deg': delta_top,
+            'definition_suspect': definition_suspect
+        }
     }
     
     return front_facing_metrics

app/models/llm_analyzer.py

@@ -11,9 +11,42 @@ import re
 from typing import Dict, Any, Optional
 from .metrics_calculator import (
     calculate_back_tilt_degree, calculate_knee_bend_degree, 
-    calculate_hip_depth_early_extension, calculate_shaft_angle_at_address,
-    calculate_head_vertical_displacement, calculate_metric_confidence
+    calculate_hip_depth_early_extension,
+    calculate_shoulder_tilt_swing_plane_at_top,
+    compute_dtl_five_metrics,
+    compute_dtl_three
 )
+from .front_facing_metrics import compute_front_facing_metrics
+
+# Import grading functions to avoid duplication
+try:
+    from ..streamlit_app import (
+        get_shoulder_tilt_swing_plane_grading,
+        get_back_tilt_grading,
+        get_knee_flexion_grading,
+        get_hip_depth_grading,
+        # get_hip_turn_impact_grading, # Removed hip turn metric
+        get_shoulder_tilt_impact_grading,
+        get_hip_sway_grading,
+        get_wrist_hinge_grading
+    )
+except ImportError:
+    # Fallback if imports fail - define minimal grading functions
+    def get_shoulder_tilt_swing_plane_grading(value, confidence):
+        return {'value': value, 'status': 'n/a', 'badge': '⚪'}
+    def get_back_tilt_grading(value, confidence):
+        return {'value': value, 'status': 'n/a', 'badge': '⚪'}
+    def get_knee_flexion_grading(value, confidence):
+        return {'value': value, 'status': 'n/a', 'badge': '⚪'}
+    def get_hip_depth_grading(value, confidence):
+        return {'value': value, 'status': 'n/a', 'badge': '⚪'}
+    # Hip turn grading function removed per user request
+    def get_shoulder_tilt_impact_grading(value, confidence):
+        return {'value': value, 'status': 'n/a', 'badge': '⚪'}
+    def get_hip_sway_grading(value, confidence, position):
+        return {'value': value, 'status': 'n/a', 'badge': '⚪'}
+    def get_wrist_hinge_grading(value, confidence, position):
+        return {'value': value, 'status': 'n/a', 'badge': '⚪'}
 
 
 def safe_fmt_deg(v):
@@ -104,7 +137,7 @@ def call_ollama_service(prompt, config):
         return None
 
 
-def compute_core_metrics(pose_data, swing_phases, frame_timestamps_ms=None, total_ms=None, player_handedness='right', is_front_facing=False, frames=None):
+def compute_core_metrics(pose_data, swing_phases, frame_timestamps_ms=None, total_ms=None, player_handedness='right', is_front_facing=False, frames=None, world_landmarks=None, club="iron"):
     """Compute core golf swing metrics
     
     Args:
@@ -114,10 +147,88 @@ def compute_core_metrics(pose_data, swing_phases, frame_timestamps_ms=None, tota
         total_ms (float, optional): Total video duration in milliseconds
         player_handedness (str): 'right' or 'left' handed player
         is_front_facing (bool): True for front-facing camera view
+        club (str): Club type for grading ("driver", "iron", "wedge")
         
     Returns:
         dict: Core metrics with confidence scores and status
     """
+    if is_front_facing:
+        # Use front-facing metrics
+        return compute_front_facing_core_metrics(pose_data, swing_phases, frames, world_landmarks, club)
+    else:
+        # Use DTL metrics (existing implementation)
+        return compute_dtl_core_metrics(pose_data, swing_phases, frame_timestamps_ms, total_ms, player_handedness, frames)
+
+
+def compute_dtl_core_metrics(pose_data, swing_phases, frame_timestamps_ms=None, total_ms=None, player_handedness='right', frames=None):
+    """Compute DTL (Down-the-Line) golf swing metrics using new unified function"""
+    
+    # Extract frame dimensions from frames if available
+    frame_w, frame_h = 1920, 1080  # Default values
+    if frames and len(frames) > 0:
+        if hasattr(frames[0], 'shape'):
+            frame_h, frame_w = frames[0].shape[:2]
+    
+    # Use the new unified DTL metrics function
+    try:
+        dtl_metrics = compute_dtl_three(pose_data, swing_phases, frame_w, frame_h, frames)
+        if dtl_metrics is None:
+            # Fallback to individual calculations if unified function fails
+            return compute_dtl_core_metrics_fallback(pose_data, swing_phases, frame_timestamps_ms, total_ms, player_handedness, frames)
+        
+        # Convert to the expected format with grading
+        core_metrics = {}
+        
+        # Map the new metric names to the expected format (hip depth and hip turn removed)
+        metric_mapping = {
+            'shoulder_plane_top_deg': ('shoulder_tilt_swing_plane_top_deg', get_shoulder_tilt_swing_plane_grading),
+            'back_tilt_setup_deg': ('back_tilt_deg', get_back_tilt_grading),
+            'knee_flexion_deg': ('knee_flexion_deg', get_knee_flexion_grading),
+            # Hip turn mapping removed per user request
+        }
+        
+        for new_key, (old_key, grading_func) in metric_mapping.items():
+            value = dtl_metrics.get(new_key)
+            if value is not None:
+                try:
+                    grading = grading_func(value, 0.8)
+                    if grading:
+                        # Hip turn debug info removed per user request
+                        core_metrics[old_key] = grading
+                except Exception:
+                    # Fallback format if grading fails
+                    core_metrics[old_key] = {
+                        'value': value,
+                        'status': 'Calculated',
+                        'badge': '✅'
+                    }
+        
+        # Add validation info if available
+        validation = dtl_metrics.get('_validation')
+        if validation:
+            core_metrics['_validation'] = validation
+        
+        # Add debug info if available
+        debug_info = dtl_metrics.get('_debug')
+        if debug_info:
+            core_metrics['_debug'] = debug_info
+            
+        return core_metrics
+        
+    except Exception as e:
+        print(f"Error in compute_dtl_three: {e}")
+        # Fallback to individual calculations
+        return compute_dtl_core_metrics_fallback(pose_data, swing_phases, frame_timestamps_ms, total_ms, player_handedness, frames)
+
+
+def compute_dtl_core_metrics_fallback(pose_data, swing_phases, frame_timestamps_ms=None, total_ms=None, player_handedness='right', frames=None):
+    """Fallback function using individual metric calculations"""
+    # Extract frame dimensions from frames if available
+    frame_w, frame_h = 1920, 1080  # Default values
+    if frames and len(frames) > 0:
+        if hasattr(frames[0], 'shape'):
+            frame_h, frame_w = frames[0].shape[:2]
+    
     # Get phase frame indices
     setup_frames = swing_phases.get("setup", [])
     backswing_frames = swing_phases.get("backswing", []) 
@@ -129,192 +240,119 @@ def compute_core_metrics(pose_data, swing_phases, frame_timestamps_ms=None, tota
     top_idx = backswing_frames[-1] if backswing_frames else address_idx
     impact_idx = impact_frames[0] if impact_frames else top_idx
     
-    # Initialize core metrics
-    core_metrics = {
-        "back_tilt_deg": {'value': None, 'status': 'n/a'},
-        "knee_bend_deg": {'value': None, 'status': 'n/a'},
-        "hip_depth_early_extension": {'value': None, 'status': 'n/a'},
-        "shaft_angle_address": {'value': None, 'status': 'n/a'},
-        "head_vertical_displacement": {'value': None, 'status': 'n/a'}
-    }
+    # Initialize core metrics with new DTL metrics - don't set default status, let grading functions handle it
+    core_metrics = {}
+    
+    # Calculate Shoulder Tilt / Swing Plane Angle at Top - professional = 36°, 30 handicap = 29°
+    try:
+        # Ensure we have valid indices and data
+        if backswing_frames and top_idx in pose_data and pose_data[top_idx] is not None:
+            shoulder_tilt_swing_plane = calculate_shoulder_tilt_swing_plane_at_top(pose_data, swing_phases, top_idx, frames)
+            if shoulder_tilt_swing_plane is not None and isinstance(shoulder_tilt_swing_plane, (int, float)):
+                grading = get_shoulder_tilt_swing_plane_grading(shoulder_tilt_swing_plane, 0.8)
+                if grading and isinstance(grading, dict):
+                    core_metrics["shoulder_tilt_swing_plane_top_deg"] = grading
+    except Exception as e:
+        # Silently continue if calculation fails
+        pass
     
     # Calculate Back Tilt @ Setup
-    back_tilt = calculate_back_tilt_degree(pose_data, swing_phases, address_idx, frames)
-    if back_tilt is not None:
-        confidence = calculate_metric_confidence(
-            pose_data, 'back_tilt', [11, 12, 23, 24], setup_frames[:3]
-        )
-        
-        if 25 <= back_tilt <= 35:
-            badge = '🟢'
-            status = 'On-plane posture'
-        elif (20 <= back_tilt < 25) or (35 < back_tilt <= 40):
-            badge = '🟠'
-            status = 'Acceptable posture'
-        else:
-            badge = '🔴'
-            status = 'Needs adjustment'
-        
-        core_metrics["back_tilt_deg"] = {
-            'value': round(back_tilt, 1),
-            'confidence': round(confidence, 2),
-            'status': f'{status} — {badge}',
-            'badge': badge
-        }
+    try:
+        # Ensure we have valid indices and data
+        if setup_frames and address_idx in pose_data and pose_data[address_idx] is not None:
+            back_tilt = calculate_back_tilt_degree(pose_data, swing_phases, address_idx, frames)
+            if back_tilt is not None and isinstance(back_tilt, (int, float)):
+                grading = get_back_tilt_grading(back_tilt, 0.8)
+                if grading and isinstance(grading, dict):
+                    core_metrics["back_tilt_deg"] = grading
+    except Exception as e:
+        # Silently continue if calculation fails
+        pass
     
-    # Calculate Knee Flexion
+    # Calculate Knee Flexion @ Setup
     knee_bend_data = calculate_knee_bend_degree(pose_data, address_idx)
     if knee_bend_data is not None:
-        # Use the new structure with separate lead and trail measurements
-        lead_flexion = knee_bend_data.get('lead_knee_flexion')
-        trail_flexion = knee_bend_data.get('trail_knee_flexion')
         primary_value = knee_bend_data.get('primary_value')  # Average or single value
-        
         if primary_value is not None:
-            confidence = calculate_metric_confidence(
-                pose_data, 'knee_flexion', [23, 24, 25, 26, 27, 28], setup_frames[:3]
-            )
-            
-            if 15 <= primary_value <= 35:
-                badge = '🟢'
-                status = 'Athletic'
-            elif (10 <= primary_value < 15) or (35 < primary_value <= 45):
-                badge = '🟠'
-                status = 'Acceptable'
-            else:
-                badge = '🔴'
-                status = 'Needs adjustment'
-            
-            # Include detailed breakdown if available
-            knee_metric = {
-                'value': round(primary_value, 1),
-                'confidence': round(confidence, 2),
-                'status': f'{status} — {badge}',
-                'badge': badge
-            }
+            grading = get_knee_flexion_grading(primary_value, 0.8)
             
             # Add separate lead/trail values if available
+            lead_flexion = knee_bend_data.get('lead_knee_flexion')
+            trail_flexion = knee_bend_data.get('trail_knee_flexion')
             if lead_flexion is not None:
-                knee_metric['lead_knee_flexion'] = round(lead_flexion, 1)
+                grading['lead_knee_flexion'] = round(lead_flexion, 1)
             if trail_flexion is not None:
-                knee_metric['trail_knee_flexion'] = round(trail_flexion, 1)
-            if 'overall_confidence' in knee_bend_data:
-                knee_metric['overall_confidence'] = round(knee_bend_data['overall_confidence'], 2)
+                grading['trail_knee_flexion'] = round(trail_flexion, 1)
             
-            core_metrics["knee_bend_deg"] = knee_metric
+            core_metrics["knee_flexion_deg"] = grading
     
     # Calculate Hip Depth / Early Extension
-    hip_depth_data = calculate_hip_depth_early_extension(pose_data, swing_phases)
-    if hip_depth_data:
-        # Check if it's an error message
-        if 'error' in hip_depth_data:
-            core_metrics["hip_depth_early_extension"] = {
-                'value': None,
-                'detailed_data': hip_depth_data,
-                'confidence': 0.0,
-                'status': f'Error: {hip_depth_data["error"]}',
-                'badge': '🔴',
-                'error': True
-            }
-        else:
-            depth_loss_pct = hip_depth_data.get('depth_loss_pct', 0)
-            # Use the confidence from the enhanced calculation, with fallback to traditional method
-            calculation_confidence = hip_depth_data.get('confidence', 1.0)
-            traditional_confidence = calculate_metric_confidence(
-                pose_data, 'hip_depth', [23, 24], [address_idx, impact_idx]
-            )
-            # Combine both confidence measures, weighted toward the calculation confidence
-            combined_confidence = (calculation_confidence * 0.7) + (traditional_confidence * 0.3)
-            
-            # Adjust badge based on confidence level
-            if combined_confidence < 0.5:
-                confidence_badge = '⚠️'
-                confidence_note = ' (low confidence)'
-            elif combined_confidence < 0.8:
-                confidence_badge = '⚡'
-                confidence_note = ' (moderate confidence)'
-            else:
-                confidence_badge = ''
-                confidence_note = ''
-            
-            if depth_loss_pct < 5:
-                badge = '🟢'
-                status = 'Good depth maintenance'
-            elif depth_loss_pct < 15:
-                badge = '🟠'
-                status = 'Some early extension'
+    try:
+        hip_depth_data = calculate_hip_depth_early_extension(pose_data, swing_phases)
+        if hip_depth_data:
+            # Check if it's an error message
+            if 'error' in hip_depth_data:
+                # Store error but still try to display it
+                core_metrics["hip_depth_early_extension"] = {
+                    'value': None,
+                    'detailed_data': hip_depth_data,
+                    'status': f'Error: {hip_depth_data["error"]}',
+                    'badge': '🔴',
+                    'error': True
+                }
+            elif isinstance(hip_depth_data, dict) and 'depth_loss_pct' in hip_depth_data:
+                # Valid data structure - proceed with grading
+                grading = get_hip_depth_grading(hip_depth_data, 0.8)
+                if grading:
+                    core_metrics["hip_depth_early_extension"] = grading
             else:
-                badge = '🔴'
-                status = 'Early extension'
-            
-            core_metrics["hip_depth_early_extension"] = {
-                'value': depth_loss_pct,
-                'detailed_data': hip_depth_data,
-                'confidence': round(combined_confidence, 2),
-                'status': f'{status}{confidence_note} — {badge}{confidence_badge}',
-                'badge': badge,
-                'calculation_confidence': round(calculation_confidence, 2),
-                'traditional_confidence': round(traditional_confidence, 2)
-            }
-    
-    # Calculate Shaft Angle at Address
-    shaft_address_angle = calculate_shaft_angle_at_address(pose_data, swing_phases, frames)
-    if shaft_address_angle is not None:
-        confidence = calculate_metric_confidence(
-            pose_data, 'shaft_angle_address', [15, 16, 12, 14], setup_frames[:3]
-        )
-        
-        if 45 <= shaft_address_angle <= 65:
-            badge = '🟢'
-            status = 'Good setup'
-        elif (35 <= shaft_address_angle < 45) or (65 < shaft_address_angle <= 75):
-            badge = '🟠'
-            status = 'Acceptable'
-        else:
-            badge = '🔴'
-            status = 'Needs adjustment'
-        
-        core_metrics["shaft_angle_address"] = {
-            'value': round(shaft_address_angle, 1),
-            'confidence': round(confidence, 2),
-            'status': f'{status} — {badge}',
-            'badge': badge
+                # Unexpected data structure - create a fallback entry
+                core_metrics["hip_depth_early_extension"] = {
+                    'value': None,
+                    'status': 'Data format error',
+                    'badge': '🔴'
+                }
+    except Exception as e:
+        # Create a fallback entry for display
+        core_metrics["hip_depth_early_extension"] = {
+            'value': None,
+            'status': 'Calculation failed',
+            'badge': '🔴'
         }
     
-    # Calculate Head Vertical Displacement
-    head_displacement_data = calculate_head_vertical_displacement(pose_data, swing_phases)
-    if head_displacement_data:
-        displacement_pct = head_displacement_data.get('displacement_pct', 0)
-        confidence = calculate_metric_confidence(
-            pose_data, 'head_displacement', [0, 1, 2, 3, 4], [address_idx, impact_idx]
-        )
-        
-        if displacement_pct < 5:
-            badge = '🟢'
-            status = 'Very stable head'
-        elif displacement_pct < 15:
-            badge = '🟠'
-            status = 'Some movement'
+    # Hip turn calculation removed per user request
+    
+    return core_metrics
+
+
+def compute_front_facing_core_metrics(pose_data, swing_phases, frames=None, world_landmarks=None, club="iron"):
+    """Compute front-facing golf swing metrics"""
+    # Get front-facing metrics from the new module
+    front_metrics = compute_front_facing_metrics(pose_data, swing_phases, world_landmarks=world_landmarks, frames=frames, club=club, handedness="right")
+    
+    # Convert to the expected format with status and badges
+    core_metrics = {}
+    
+    
+    # Process each front-facing metric with new calibration values
+    for metric_name, metric_data in front_metrics.items():
+        if 'hip_turn_impact' in metric_name and isinstance(metric_data, dict) and 'grade_label' in metric_data:
+            # New hip turn data structure with club-aware grading - pass through directly
+            core_metrics[metric_name] = metric_data
         else:
-            badge = '🔴'
-            status = 'Excessive movement'
-        
-        # Include the documented denominator and method information
-        head_metric = {
-            'value': round(displacement_pct, 1),
-            'confidence': round(confidence, 2),
-            'status': f'{status} — {badge}',
-            'badge': badge,
-            'detailed_data': head_displacement_data
-        }
-        
-        # Add documented denominator information if available
-        if 'height_reference_method' in head_displacement_data:
-            head_metric['height_reference_method'] = head_displacement_data['height_reference_method']
-        if 'denominator_documented' in head_displacement_data:
-            head_metric['denominator_documented'] = head_displacement_data['denominator_documented']
-        
-        core_metrics["head_vertical_displacement"] = head_metric
+            # Handle other metrics with traditional processing
+            value = metric_data.get('value') if isinstance(metric_data, dict) else metric_data
+            
+            if 'shoulder_tilt_impact' in metric_name:
+                core_metrics[metric_name] = get_shoulder_tilt_impact_grading(value, 0.9)
+            # Hip turn metric processing removed per user request
+            elif 'hip_sway_top' in metric_name:
+                core_metrics[metric_name] = get_hip_sway_grading(value, 0.8, "top")
+            elif 'wrist_hinge_top' in metric_name:
+                core_metrics[metric_name] = get_wrist_hinge_grading(value, 0.8, "top")
+            else:
+                # Default case
+                core_metrics[metric_name] = {'value': value, 'status': 'n/a'}
     
     return core_metrics
 
@@ -487,4 +525,113 @@ def display_formatted_analysis(analysis_data):
     if not analysis_data:
         return "No analysis data available"
     
-    return analysis_data.get('formatted_analysis', analysis_data.get('raw_analysis', 'No analysis available'))
+    return analysis_data.get('formatted_analysis', analysis_data.get('raw_analysis', 'No analysis available'))
+
+
+def test_dtl_five_metrics_fixes(pose_data, swing_phases, frames=None):
+    """Test function to validate the DTL metric fixes
+    
+    This function tests the fixes for:
+    1. Shoulder tilt no longer returning ~90° due to yaw correction
+    2. Hip turn no longer returning ~90° due to width-ratio method
+    3. Hip depth properly comparing posterior hip positions
+    4. All 5 metrics being computed and returned
+    
+    Args:
+        pose_data (dict): Dictionary mapping frame indices to pose keypoints
+        swing_phases (dict): Dictionary mapping phase names to lists of frame indices
+        frames (list, optional): Video frames for analysis
+        
+    Returns:
+        dict: Test results showing before/after values and validation
+    """
+    print("\n=== Testing DTL Five Metrics Fixes ===")
+    
+    # Test the new aggregator
+    metrics = compute_dtl_five_metrics(pose_data, swing_phases, frames)
+    
+    if metrics is None:
+        print("❌ Failed: compute_dtl_five_metrics returned None")
+        return None
+    
+    print(f"✅ Success: Got {len(metrics)} metrics")
+    
+    # Validate each metric
+    expected_metrics = [
+        "shoulder_plane_top_deg",
+        "back_tilt_setup_deg", 
+        "knee_flexion_deg",
+        "hip_depth_pct",
+        # "hip_turn_impact_deg" # Removed hip turn metric
+    ]
+    
+    results = {
+        "total_metrics": len(metrics),
+        "expected_metrics": len(expected_metrics),
+        "metric_values": {},
+        "validation_results": {}
+    }
+    
+    for metric_name in expected_metrics:
+        value = metrics.get(metric_name)
+        results["metric_values"][metric_name] = value
+        
+        if value is None:
+            print(f"⚠️  {metric_name}: None (calculation failed or outside sanity bounds)")
+            results["validation_results"][metric_name] = "failed_or_clamped"
+        elif metric_name.endswith("_deg") and value >= 80:
+            print(f"❌ {metric_name}: {value}° (unrealistic high value - check calculation)")
+            results["validation_results"][metric_name] = "unrealistic_high"
+        else:
+            print(f"✅ {metric_name}: {value}{'%' if 'pct' in metric_name else '°'} (reasonable value)")
+            results["validation_results"][metric_name] = "success"
+    
+    # Summary
+    successful_metrics = sum(1 for v in results["validation_results"].values() if v == "success")
+    print(f"\n📊 Summary: {successful_metrics}/{len(expected_metrics)} metrics returning reasonable values")
+    
+    if successful_metrics >= 4:
+        print("🎉 Overall: GOOD - Most metrics working properly")
+    elif successful_metrics >= 2:
+        print("⚠️  Overall: FAIR - Some metrics still need work")
+    else:
+        print("❌ Overall: POOR - Major issues remain")
+    
+    results["overall_status"] = "good" if successful_metrics >= 4 else "fair" if successful_metrics >= 2 else "poor"
+    
+    return results
+
+
+def get_hip_depth_grading_from_value(value, confidence):
+    """Helper function to create hip depth grading from just the percentage value"""
+    if value is None:
+        return None
+    
+    # Create a mock hip_depth_data structure for the existing grading function
+    mock_data = {
+        'depth_loss_pct': value,
+        'confidence': confidence
+    }
+    
+    # Try to import the grading function from streamlit_app
+    try:
+        from ..streamlit_app import get_hip_depth_grading
+        return get_hip_depth_grading(mock_data, confidence)
+    except ImportError:
+        # Fallback grading logic
+        if value <= 5:
+            status = "Excellent - minimal early extension"
+            badge = "🟢"
+        elif value <= 15:
+            status = "Good - slight early extension"
+            badge = "🟡"
+        else:
+            status = "Needs work - significant early extension"
+            badge = "🔴"
+        
+        return {
+            'value': value,
+            'status': status,
+            'badge': badge,
+            'detailed_data': mock_data
+        }

app/models/metrics_calculator.py

@@ -9,136 +9,77 @@ import math
 import numpy as np
 import cv2
 
+# Head landmark indices for head height calculation
+L_EYE, R_EYE = 2, 5
+L_EAR, R_EAR = 7, 8
+NOSE = 0
 
-def wrap180_deg(a):
-    """Returns angle in (-180, 180] range - bulletproof implementation"""
-    a = (a + 180.0) % 360.0 - 180.0
-    return a
+# Enable debug output for head height calculations
+VERBOSE = True
 
+def dbg(msg):
+    """Debug print helper"""
+    if VERBOSE:
+        print(f"[DEBUG] {msg}")
 
-def calculate_metric_confidence(pose_data, metric_name, keypoint_indices, frame_indices=None):
-    """Calculate confidence for a specific metric based on keypoint visibility and geometry checks
-    
-    Fixed implementation:
-    - Computes per metric from the lowest keypoint confidence used + line length / geometry checks
-    - Avoids blanket confidence values
-    - Metric-specific confidence calculations
+
+def to_pixels_if_needed(kp, frame_w=None, frame_h=None):
+    """Convert keypoints to pixels if they appear normalized (0..1).
+    Works even if frame_w/frame_h are None by assuming a sane default size.
     
     Args:
-        pose_data (dict): Dictionary mapping frame indices to pose keypoints
-        metric_name (str): Name of the metric for specific adjustments
-        keypoint_indices (list): List of keypoint indices used in the calculation
-        frame_indices (list, optional): Specific frames to check (defaults to all frames)
+        kp: list of (x, y, vis) keypoints
+        frame_w: frame width in pixels (optional)
+        frame_h: frame height in pixels (optional)
         
     Returns:
-        float: Confidence score between 0.0 and 1.0
+        list: keypoints converted to pixel coordinates
     """
-    if frame_indices is None:
-        frame_indices = list(pose_data.keys())
-    
-    if not frame_indices:
-        return 0.0
-    
-    # Calculate base confidence from keypoint visibility
-    keypoint_confidences = []
-    geometry_checks = []
-    
-    for frame_idx in frame_indices:
-        if frame_idx not in pose_data or pose_data[frame_idx] is None:
-            continue
-            
-        kp = pose_data[frame_idx]
-        
-        # Get minimum keypoint confidence (weakest link)
-        frame_keypoint_confidences = []
-        for kp_idx in keypoint_indices:
-            if kp_idx >= len(kp):
-                frame_keypoint_confidences.append(0.0)  # Missing keypoint
-            else:
-                visibility = kp[kp_idx][2]
-                frame_keypoint_confidences.append(visibility)
-        
-        if frame_keypoint_confidences:
-            min_confidence = min(frame_keypoint_confidences)
-            keypoint_confidences.append(min_confidence)
-            
-            # Geometry checks based on metric type
-            geometry_confidence = 1.0
-            
-            if metric_name == 'shaft_angle_address':
-                # Check if grip and estimated clubhead positions are reasonable
-                if len(kp) > 16 and kp[16][2] > 0.3:  # Right wrist
-                    grip_pos = np.array(kp[16][:2])
-                    if len(kp) > 14 and kp[14][2] > 0.3:  # Elbow for forearm direction
-                        elbow_pos = np.array(kp[14][:2])
-                        forearm_length = np.linalg.norm(grip_pos - elbow_pos)
-                        if forearm_length < 10 or forearm_length > 100:  # Unreasonable
-                            geometry_confidence *= 0.5
-                    else:
-                        geometry_confidence *= 0.7  # No elbow reference
-                else:
-                    geometry_confidence *= 0.0  # No grip reference
-            
-            elif metric_name == 'back_tilt':
-                # Check if shoulder and hip positions are reasonable
-                if len(kp) > 24:
-                    shoulder_mid = np.array([(kp[11][0] + kp[12][0]) / 2, (kp[11][1] + kp[12][1]) / 2])
-                    hip_mid = np.array([(kp[23][0] + kp[24][0]) / 2, (kp[23][1] + kp[24][1]) / 2])
-                    spine_length = np.linalg.norm(shoulder_mid - hip_mid)
-                    if spine_length < 15 or spine_length > 200:  # Unreasonable spine length
-                        geometry_confidence *= 0.5
-            
-            elif metric_name == 'knee_flexion':
-                # Check if leg segments are reasonable lengths
-                for leg_points in [(23, 25, 27), (24, 26, 28)]:  # Left and right legs
-                    if all(i < len(kp) and kp[i][2] > 0.3 for i in leg_points):
-                        hip_pos = np.array(kp[leg_points[0]][:2])
-                        knee_pos = np.array(kp[leg_points[1]][:2])
-                        ankle_pos = np.array(kp[leg_points[2]][:2])
-                        
-                        thigh_length = np.linalg.norm(hip_pos - knee_pos)
-                        shin_length = np.linalg.norm(knee_pos - ankle_pos)
-                        
-                        if thigh_length < 10 or thigh_length > 80 or shin_length < 10 or shin_length > 80:
-                            geometry_confidence *= 0.6
-            
-            elif metric_name == 'head_displacement':
-                # Check if head position is reasonable
-                head_pos = calculate_head_center(kp)
-                if head_pos is not None:
-                    # Check if head is within reasonable bounds
-                    if head_pos[1] < 0 or head_pos[1] > 1000:  # Unreasonable Y position
-                        geometry_confidence *= 0.5
-                else:
-                    geometry_confidence *= 0.3
-            
-            geometry_checks.append(geometry_confidence)
-    
-    if not keypoint_confidences:
-        return 0.0
-    
-    # Calculate final confidence
-    avg_keypoint_confidence = np.mean(keypoint_confidences)
-    avg_geometry_confidence = np.mean(geometry_checks) if geometry_checks else 1.0
-    
-    # Combine keypoint and geometry confidence
-    final_confidence = avg_keypoint_confidence * avg_geometry_confidence
-    
-    # Apply metric-specific adjustments
-    if metric_name == 'shaft_angle_address':
-        final_confidence *= 0.8  # Inherently less reliable due to club estimation
-    elif metric_name == 'head_displacement':
-        final_confidence *= 0.85  # Head tracking can be noisy
-    elif metric_name == 'hip_depth':
-        final_confidence *= 0.75  # Hip depth is challenging to measure accurately
-    elif metric_name in ['back_tilt', 'knee_flexion']:
-        final_confidence *= 0.95  # These are more reliable measurements
-    
-    # Frame span penalty - fewer frames = lower confidence
-    frame_span_penalty = min(1.0, len(frame_indices) / 5.0)  # Full confidence with 5+ frames
-    final_confidence *= frame_span_penalty
-    
-    return min(1.0, max(0.0, final_confidence))
+    if not kp:
+        return kp
+
+    # Extract coords
+    xs = [p[0] for p in kp if p and len(p) >= 2 and p[0] is not None]
+    ys = [p[1] for p in kp if p and len(p) >= 2 and p[1] is not None]
+    if not xs or not ys:
+        return kp
+
+    # Heuristic: normalized if 90th percentile < ~2.0
+    looks_normalized = (np.percentile(xs, 90) < 2.0 and np.percentile(ys, 90) < 2.0)
+
+    # If we don't know frame size but coords look normalized, assume 1920x1080
+    if (frame_w is None or frame_h is None) and looks_normalized:
+        frame_w = frame_w or 1920
+        frame_h = frame_h or 1080
+
+    # If we still don't have dims, or they already look like pixels, return as-is
+    if frame_w is None or frame_h is None or not looks_normalized:
+        return kp
+
+    # Convert normalized → pixels
+    kp_pixels = []
+    for p in kp:
+        if p and len(p) >= 3 and p[0] is not None and p[1] is not None:
+            kp_pixels.append([p[0] * frame_w, p[1] * frame_h, p[2]])
+        else:
+            kp_pixels.append(p)
+    return kp_pixels
+
+
+def wrap180_deg(a):
+    """Returns angle in (-180, 180] range - bulletproof implementation"""
+    a = (a + 180.0) % 360.0 - 180.0
+    return a
+
+
+# Safe no-op to avoid NameError in validation/overlay paths
+def calculate_shaft_angle_at_address(*args, **kwargs):
+    """Safe stub for removed shaft angle function to prevent NameError"""
+    return None
+
+
+# Note: calculate_metric_confidence removed - not used by the 5 DTL metrics
+# This function was defined but never called by the displayed metrics
 
 
 def detect_ground_line_angle(pose_data, swing_phases, frames=None):
@@ -185,36 +126,37 @@ def detect_ground_line_angle(pose_data, swing_phases, frames=None):
                 
             kp = pose_data[frame_idx]
             
-            # Try ankle line (most reliable for ground reference)
-            if (len(kp) > 28 and kp[27][2] > 0.4 and kp[28][2] > 0.4):
+            # Try ankle line (most reliable for ground reference) - looser thresholds
+            if (len(kp) > 28 and kp[27][2] > 0.2 and kp[28][2] > 0.2):
                 left_ankle = np.array(kp[27][:2])
                 right_ankle = np.array(kp[28][:2])
                 ankle_vec = right_ankle - left_ankle
-                if np.linalg.norm(ankle_vec) > 20:  # Reasonable distance
+                if np.linalg.norm(ankle_vec) > 10:  # Reduced minimum distance
                     ankle_angle = math.atan2(ankle_vec[1], ankle_vec[0])
                     ankle_angle_deg = math.degrees(ankle_angle)
                     ankle_angle_wrapped = wrap180_deg(ankle_angle_deg)
                     
-                    # Validate ankle line is horizontal-ish
-                    if abs(ankle_angle_wrapped) <= 15.0:
+                    # Validate ankle line is horizontal-ish (looser tolerance)
+                    if abs(ankle_angle_wrapped) <= 20.0:
                         ground_angles.append(ankle_angle)
             
-            # Try knee line as backup
-            if (len(kp) > 26 and kp[25][2] > 0.4 and kp[26][2] > 0.4):
+            # Try knee line as backup - looser thresholds
+            if (len(kp) > 26 and kp[25][2] > 0.2 and kp[26][2] > 0.2):
                 left_knee = np.array(kp[25][:2])
                 right_knee = np.array(kp[26][:2])
                 knee_vec = right_knee - left_knee
-                if np.linalg.norm(knee_vec) > 15:
+                if np.linalg.norm(knee_vec) > 10:  # Reduced minimum distance
                     knee_angle = math.atan2(knee_vec[1], knee_vec[0])
                     knee_angle_deg = math.degrees(knee_angle)
                     knee_angle_wrapped = wrap180_deg(knee_angle_deg)
                     
-                    # Validate knee line is horizontal-ish
-                    if abs(knee_angle_wrapped) <= 15.0:
+                    # Validate knee line is horizontal-ish (looser tolerance)
+                    if abs(knee_angle_wrapped) <= 20.0:
                         ground_angles.append(knee_angle)
     
+    # Final fallback: assume level ground (0 rad) rather than None
     if not ground_angles:
-        return None  # No ground line detected
+        return 0.0  # Horizontal ground assumption
     
     # Use median for robustness
     return np.median(ground_angles)
@@ -313,23 +255,208 @@ def calculate_head_center(keypoints):
     return None
 
 
-def calculate_back_tilt_degree(pose_data, swing_phases, address_idx=None, frames=None):
+def _pick_head_y(lm, vis_thr=0.5):
+    """Return y in pixels for best-available head landmark; else approximate from shoulders.
+    
+    Args:
+        lm: pose landmarks for a single frame
+        vis_thr: minimum visibility threshold
+        
+    Returns:
+        float: head y coordinate in pixels, or None if unavailable
+    """
+    cand = []
+    for idx in (L_EYE, R_EYE, L_EAR, R_EAR):
+        if idx < len(lm) and lm[idx] and len(lm[idx]) >= 3:
+            visibility = getattr(lm[idx], "visibility", lm[idx][2] if len(lm[idx]) > 2 else 1.0)
+            if visibility >= vis_thr:
+                cand.append((lm[idx][1], visibility))  # y coordinate, visibility
+    
+    if cand:
+        # weighted by vis^2 for stability
+        wsum = sum(v*v for _, v in cand)
+        return sum(y*(v*v) for y, v in cand) / (wsum if wsum else len(cand))
+
+    # Fallback: estimate from shoulders (keeps relative motion consistent)
+    if len(lm) > 24 and lm[11] and lm[12] and lm[23] and lm[24]:
+        # Use shoulder keypoints (11=left shoulder, 12=right shoulder)
+        # and hip keypoints (23=left hip, 24=right hip)
+        y_sho = 0.5 * (lm[11][1] + lm[12][1])
+        y_hip = 0.5 * (lm[23][1] + lm[24][1])
+        return y_sho - 0.25 * (y_sho - y_hip)  # small offset above shoulders
+
+    return None
+
+
+def _median_head_y(frames_lm, idx, k=5, vis_thr=0.5):
+    """Median head y over a small temporal window.
+    
+    Args:
+        frames_lm: list of pose landmarks for all frames
+        idx: center frame index
+        k: window size (frames to consider around center)
+        vis_thr: visibility threshold
+        
+    Returns:
+        float: median head y coordinate, or None if unavailable
+    """
+    n = len(frames_lm)
+    hys = []
+    a = max(0, idx - k//2)
+    b = min(n, idx + k//2 + 1)
+    
+    for i in range(a, b):
+        try:
+            hy = _pick_head_y(frames_lm[i], vis_thr)
+            if hy is not None:
+                hys.append(hy)
+        except Exception:
+            continue
+    
+    if not hys:
+        return None
+    return float(np.median(hys))
+
+
+def head_height_change(frames_lm, addr_idx, top_idx, imp_idx, inch_scale, vis_thr=0.5):
+    """Calculate single head height change metric from address to impact.
+    
+    This measures head stability during the swing - positive values mean head moved DOWN.
+    
+    Args:
+        frames_lm: list of pose landmarks for all frames (pose_data as list)
+        addr_idx: address frame index
+        top_idx: top of backswing frame index (not used for final metric, but kept for debug)
+        imp_idx: impact frame index
+        inch_scale: pixels per inch conversion factor
+        vis_thr: visibility threshold
+        
+    Returns:
+        float: head change from address to impact in inches (positive = moved DOWN)
+    """
+    dbg(f"=== HEAD HEIGHT CHANGE CALCULATION ===")
+    dbg(f"Frame indices - Address: {addr_idx}, Top: {top_idx}, Impact: {imp_idx}")
+    dbg(f"Inch scale: {inch_scale:.3f} px/in, Visibility threshold: {vis_thr}")
+    
+    # Convert pose_data dict to list format for compatibility
+    if isinstance(frames_lm, dict):
+        max_frame = max(frames_lm.keys()) if frames_lm else 0
+        frames_list = [None] * (max_frame + 1)
+        for frame_idx, landmarks in frames_lm.items():
+            frames_list[frame_idx] = landmarks
+        frames_lm = frames_list
+        dbg(f"Converted pose_data dict to list format ({len(frames_list)} frames)")
+    
+    y_addr = _median_head_y(frames_lm, addr_idx, vis_thr=vis_thr)
+    y_top  = _median_head_y(frames_lm, top_idx,  vis_thr=vis_thr)
+    y_imp  = _median_head_y(frames_lm, imp_idx,  vis_thr=vis_thr)
+
+    dbg(f"Head Y coordinates - Address: {y_addr}, Top: {y_top}, Impact: {y_imp}")
+
+    if None in (y_addr, y_imp):
+        dbg(f"❌ Missing head Y coordinates - cannot calculate head height change")
+        return None
+        
+    if not inch_scale or inch_scale <= 0:
+        dbg(f"❌ Invalid inch scale ({inch_scale}) - cannot calculate head height change")
+        return None
+
+    # Calculate primary metric: address to impact change
+    head_change_in = (y_imp - y_addr) / inch_scale
+    
+    # Also calculate top drop for debug info
+    drop_top_in = (y_top - y_addr) / inch_scale if y_top is not None else None
+    
+    dbg(f"📏 Head movement calculations:")
+    if drop_top_in is not None:
+        dbg(f"   Address → Top: {y_top - y_addr:+.1f} px = {drop_top_in:+.2f} inches (debug only)")
+    dbg(f"   Address → Impact: {y_imp - y_addr:+.1f} px = {head_change_in:+.2f} inches (PRIMARY METRIC)")
+    
+    # Interpret primary metric (address to impact)
+    if abs(head_change_in) <= 1.0:
+        dbg(f"✅ Excellent head stability ({head_change_in:+.2f}\") - within ±1\"")
+    elif abs(head_change_in) <= 2.5:
+        dbg(f"⚠️  Moderate head movement ({head_change_in:+.2f}\") - caution zone")
+    else:
+        dbg(f"❌ Excessive head movement ({head_change_in:+.2f}\") - likely EE/low-point issues")
+    
+    # Debug info for top drop
+    if drop_top_in is not None:
+        if drop_top_in > 4.0:
+            dbg(f"⚠️  Excessive head drop at top ({drop_top_in:.2f}\") - too much 'sit' (debug)")
+        elif 1.0 <= drop_top_in <= 3.0:
+            dbg(f"✅ Good head drop at top ({drop_top_in:.2f}\") - within typical range (debug)")
+        elif drop_top_in < 0:
+            dbg(f"⚠️  Head rose at top ({drop_top_in:.2f}\") - unusual movement (debug)")
+    
+    dbg(f"=== HEAD HEIGHT CALCULATION COMPLETE ===")
+    
+    return head_change_in
+
+
+def calculate_inch_scale_from_shoulders(pose_data, address_idx, frame_w=None, frame_h=None, assumed_shoulder_width_in=15.5):
+    """Calculate inch scale using shoulder width as reference.
+    
+    Args:
+        pose_data: dictionary mapping frame indices to pose keypoints
+        address_idx: address frame index
+        frame_w: frame width in pixels
+        frame_h: frame height in pixels
+        assumed_shoulder_width_in: assumed shoulder width in inches (default 15.5" average)
+        
+    Returns:
+        float: pixels per inch scale factor, or None if calculation fails
+    """
+    dbg(f"=== CALCULATING INCH SCALE FROM SHOULDERS ===")
+    dbg(f"Address frame: {address_idx}, Assumed shoulder width: {assumed_shoulder_width_in}\"")
+    
+    if address_idx not in pose_data or pose_data[address_idx] is None:
+        dbg(f"❌ Address frame {address_idx} not found in pose data")
+        return None
+    
+    kp = pose_data[address_idx]
+    if len(kp) < 13:  # Need shoulder keypoints
+        dbg(f"❌ Insufficient keypoints ({len(kp)}) - need at least 13 for shoulders")
+        return None
+    
+    # Ensure pixels
+    kp = to_pixels_if_needed(kp, frame_w, frame_h)
+    
+    # Calculate shoulder width in pixels
+    if kp[11] and kp[12] and len(kp[11]) >= 2 and len(kp[12]) >= 2:
+        left_shoulder = kp[11][:2]
+        right_shoulder = kp[12][:2]
+        shoulder_width_px = abs(kp[12][0] - kp[11][0])
+        
+        dbg(f"Shoulder positions - Left: ({left_shoulder[0]:.1f}, {left_shoulder[1]:.1f}), Right: ({right_shoulder[0]:.1f}, {right_shoulder[1]:.1f})")
+        dbg(f"Shoulder width: {shoulder_width_px:.1f} pixels")
+        
+        if shoulder_width_px > 10:  # Reasonable minimum
+            inch_scale = shoulder_width_px / assumed_shoulder_width_in
+            dbg(f"✅ Calculated inch scale: {inch_scale:.3f} pixels per inch")
+            dbg(f"=== INCH SCALE CALCULATION COMPLETE ===")
+            return inch_scale
+        else:
+            dbg(f"❌ Shoulder width too small ({shoulder_width_px:.1f} px) - unreliable scale")
+    else:
+        dbg(f"❌ Missing or invalid shoulder keypoints")
+    
+    dbg(f"❌ Inch scale calculation failed")
+    return None
+
+
+def calculate_back_tilt_degree(pose_data, swing_phases, address_idx=None, frames=None, frame_w=None, frame_h=None):
     """Calculate back tilt: forward bend vs ground using bulletproof geometry
     
-    Fixed implementation:
-    - Uses exact math with degrees everywhere
-    - dx_spine = shoulder_mid_x - hip_mid_x
-    - dy_spine = shoulder_mid_y - hip_mid_y (usually negative at setup)
-    - theta_spine = atan2(dy_spine, dx_spine) in degrees
-    - theta_ground = atan2(y2-y1, x2-x1) from detected ground line
-    - theta_rel_horiz = wrap180_deg(theta_spine - theta_ground)
-    - back_tilt = 90.0 - abs(theta_rel_horiz)
+    Target values: 30-45° depending on club (driver vs wedge)
     
     Args:
         pose_data (dict): Dictionary mapping frame indices to pose keypoints
         swing_phases (dict): Dictionary mapping phase names to lists of frame indices
         address_idx (int, optional): Frame index for address/setup position (auto-detected if None)
         frames (list, optional): Video frames for Hough line detection
+        frame_w (int, optional): Frame width in pixels
+        frame_h (int, optional): Frame height in pixels
         
     Returns:
         float: Back tilt angle in degrees (None if calculation fails)
@@ -347,12 +474,21 @@ def calculate_back_tilt_degree(pose_data, swing_phases, address_idx=None, frames
     if len(kp) < 25:  # Need at least up to hip keypoints
         return None
     
-    # Check required keypoints visibility - shoulders and hips
+    # Always calculate even with low visibility - no hiding metrics
+    # Check if keypoints exist but don't hide based on visibility
     required_points = [11, 12, 23, 24]  # left shoulder, right shoulder, left hip, right hip
-    if not all(i < len(kp) and kp[i][2] > 0.3 for i in required_points):
+    if not all(i < len(kp) for i in required_points):
         return None
     
+    # Try to get frame dimensions if not provided
+    if frame_w is None or frame_h is None:
+        frame_w = frame_w or 1920
+        frame_h = frame_h or 1080
+    
     try:
+        # Ensure pixels
+        kp = to_pixels_if_needed(kp, frame_w, frame_h)
+        
         # Get ground line angle using improved Hough detection
         ground_angle = detect_ground_line_angle(pose_data, swing_phases, frames)
         
@@ -371,7 +507,7 @@ def calculate_back_tilt_degree(pose_data, swing_phases, address_idx=None, frames
         dy_spine = shoulder_mid_y - hip_mid_y  # usually negative at setup (shoulders above hips)
         
         spine_length = math.sqrt(dx_spine**2 + dy_spine**2)
-        if spine_length < 15:  # Too short to be reliable
+        if spine_length < 30:  # Adjusted for pixel coordinates
             return None
         
         # Calculate spine angle using atan2 (degrees everywhere)
@@ -389,9 +525,6 @@ def calculate_back_tilt_degree(pose_data, swing_phases, address_idx=None, frames
         # Clamp to 0-90° range
         back_tilt = max(0.0, min(back_tilt, 90.0))
         
-        # Note: Not rejecting values based on ranges - let UI display all measurements
-        # Even unusual values might be valid for certain body types or setups
-        
         return back_tilt
         
     except (ZeroDivisionError, ValueError, IndexError):
@@ -437,8 +570,9 @@ def calculate_knee_bend_degree(pose_data, address_idx):
             if len(kp) < max(hip_idx, knee_idx, ankle_idx) + 1:
                 continue
                 
-            # Check keypoint visibility
-            if not all(kp[i][2] > 0.3 for i in [hip_idx, knee_idx, ankle_idx]):
+            # Always calculate even with low visibility - no hiding metrics
+            # Check if keypoints exist but don't hide based on visibility
+            if not all(i < len(kp) for i in [hip_idx, knee_idx, ankle_idx]):
                 continue
                 
             try:
@@ -535,15 +669,15 @@ def calculate_scale_aware_hip_width_threshold(pose_data, swing_phases):
     """
     setup_frames = swing_phases.get("setup", [])
     if not setup_frames:
-        return 15.0  # Default fallback
+        return None  # No fallback values - show actual result
     
     address_idx = setup_frames[0]
     if address_idx not in pose_data or pose_data[address_idx] is None:
-        return 15.0
+        return None  # No fallback values - show actual result
     
     addr_kp = pose_data[address_idx]
     if len(addr_kp) < 25:
-        return 15.0
+        return None  # No fallback values - show actual result
     
     # Use shoulder width as a reference for body scale
     # Keypoints: 11=left shoulder, 12=right shoulder
@@ -562,7 +696,7 @@ def calculate_scale_aware_hip_width_threshold(pose_data, swing_phases):
         adaptive_threshold = max(8.0, min(25.0, head_hip_distance * 0.15))
         return adaptive_threshold
     
-    return 15.0  # Final fallback
+    return None  # No fallback values - show actual result
 
 
 def calculate_smoothed_hip_width(pose_data, swing_phases, window_size=5):
@@ -601,305 +735,90 @@ def calculate_smoothed_hip_width(pose_data, swing_phases, window_size=5):
     return np.median(hip_widths)
 
 
-def calculate_hip_depth_early_extension(pose_data, swing_phases):
-    """Calculate hip depth/early extension: distance from pelvis to butt line at address vs impact
-    
-    Enhanced implementation with three-layer robustness:
-    1. Scale-aware thresholding based on body proportions
-    2. Temporal smoothing across frames for stability
-    3. Graceful degradation with confidence scoring instead of hard failure
+# Hip depth/early extension metric removed per user request
+def early_extension_pct(pose_data, swing_phases, frame_w, frame_h, camera_side="trail"):
+    """Calculate early extension percentage using posterior hip method with unit conversion
     
     Args:
         pose_data (dict): Dictionary mapping frame indices to pose keypoints
         swing_phases (dict): Dictionary mapping phase names to lists of frame indices
+        frame_w (int): Frame width in pixels
+        frame_h (int): Frame height in pixels
+        camera_side (str): "trail" or "lead" - which side camera is on
         
     Returns:
-        dict: Hip depth data with value as percentage of hip width and confidence
+        float: Early extension percentage (0-100%)
     """
     setup_frames = swing_phases.get("setup", [])
     impact_frames = swing_phases.get("impact", [])
     
     if not setup_frames or not impact_frames:
-        return {'error': 'No setup or impact frames', 'setup_frames': len(setup_frames), 'impact_frames': len(impact_frames)}
+        return None
     
     address_idx = setup_frames[0]
     impact_idx = impact_frames[0]
     
     if (address_idx not in pose_data or impact_idx not in pose_data or 
         pose_data[address_idx] is None or pose_data[impact_idx] is None):
-        return {'error': 'Missing pose data', 'address_idx': address_idx, 'impact_idx': impact_idx, 'address_in_data': address_idx in pose_data, 'impact_in_data': impact_idx in pose_data}
+        return None
     
     addr_kp = pose_data[address_idx]
     impact_kp = pose_data[impact_idx]
     
-    # Need hip keypoints (23=left hip, 24=right hip)
-    if (len(addr_kp) < 25 or len(impact_kp) < 25 or
-        not all(addr_kp[i][2] > 0.3 for i in [23, 24]) or
-        not all(impact_kp[i][2] > 0.3 for i in [23, 24])):
-        return {'error': 'Insufficient hip keypoints', 'addr_kp_len': len(addr_kp), 'impact_kp_len': len(impact_kp), 'addr_hip_vis': [addr_kp[i][2] if i < len(addr_kp) else 0 for i in [23, 24]], 'impact_hip_vis': [impact_kp[i][2] if i < len(impact_kp) else 0 for i in [23, 24]]}
-    
-    try:
-        # Layer 1: Scale-aware thresholding
-        adaptive_threshold = calculate_scale_aware_hip_width_threshold(pose_data, swing_phases)
-        
-        # Layer 2: Temporal smoothing for hip width
-        smoothed_hip_width = calculate_smoothed_hip_width(pose_data, swing_phases)
-        if smoothed_hip_width is None:
-            # Fallback to single-frame measurement
-            hip_width = np.linalg.norm(np.array(addr_kp[24][:2]) - np.array(addr_kp[23][:2]))
-        else:
-            hip_width = smoothed_hip_width
-        
-        # Layer 3: Graceful degradation with confidence scoring
-        confidence = 1.0
-        if hip_width < adaptive_threshold:
-            # Calculate confidence based on how far below threshold we are
-            confidence = max(0.1, hip_width / adaptive_threshold)
-            
-            # For very narrow measurements, use a fallback normalization
-            if hip_width < adaptive_threshold * 0.5:
-                # Use shoulder width as fallback normalization
-                if (len(addr_kp) >= 25 and addr_kp[11][2] > 0.3 and addr_kp[12][2] > 0.3):
-                    fallback_width = np.linalg.norm(np.array(addr_kp[12][:2]) - np.array(addr_kp[11][:2]))
-                    # Scale hip width proportionally to shoulder width
-                    hip_width = fallback_width * 0.7  # Typical hip-to-shoulder ratio
-                    confidence = 0.3  # Low confidence for fallback
-                else:
-                    # Last resort: use a reasonable default
-                    hip_width = 30.0  # Reasonable default hip width
-                    confidence = 0.1  # Very low confidence
-        
-        # Calculate hip centers at address and impact
-        addr_hip_center = np.array([(addr_kp[23][0] + addr_kp[24][0]) / 2, 
-                                   (addr_kp[23][1] + addr_kp[24][1]) / 2])
-        impact_hip_center = np.array([(impact_kp[23][0] + impact_kp[24][0]) / 2, 
-                                     (impact_kp[23][1] + impact_kp[24][1]) / 2])
-        
-        # Butt line = posterior-most x at address (if camera sees trail side)
-        # Use the maximum x-coordinate of the hips as the butt line reference
-        butt_line_x = max(addr_kp[23][0], addr_kp[24][0])
-        
-        # Calculate depth loss: positive = pelvis moved TOWARD the ball (deeper into screen)
-        # Note: x+ direction depends on camera orientation; adjust if needed
-        depth_loss_px = max(0.0, butt_line_x - impact_hip_center[0])
-        depth_loss_pct = 100.0 * depth_loss_px / hip_width
-        
-        return {
-            'depth_loss_pixels': round(depth_loss_px, 2),
-            'depth_loss_pct': round(depth_loss_pct, 1),
-            'hip_width_ref': round(hip_width, 2),
-            'butt_line_x': round(butt_line_x, 2),
-            'addr_hip_x': round(addr_hip_center[0], 2),
-            'impact_hip_x': round(impact_hip_center[0], 2),
-            'confidence': round(confidence, 2),
-            'adaptive_threshold': round(adaptive_threshold, 2),
-            'smoothed_measurement': smoothed_hip_width is not None
-        }
-    
-    except (ZeroDivisionError, ValueError, IndexError):
+    if len(addr_kp) < 25 or len(impact_kp) < 25:
         return None
-
-
-def calculate_shaft_angle_at_address(pose_data, swing_phases, frames=None):
-    """Calculate shaft angle at address using actual shaft detection vs ground
     
-    Fixed implementation:
-    - ROI built from hands and ball positions
-    - Hough filtering tailored to tilted line (40°-70°)
-    - Clean fallback (never return 90° silently)
-    - Returns NaN with clear message if no valid line found
+    # Ensure pixels
+    addr_kp = to_pixels_if_needed(addr_kp, frame_w, frame_h)
+    impact_kp = to_pixels_if_needed(impact_kp, frame_w, frame_h)
     
-    Args:
-        pose_data (dict): Dictionary mapping frame indices to pose keypoints
-        swing_phases (dict): Dictionary mapping phase names to lists of frame indices
-        frames (list, optional): Video frames for Hough line detection
-        
-    Returns:
-        float: Shaft angle at address in degrees (None if calculation fails)
-    """
-    setup_frames = swing_phases.get("setup", [])
-    if not setup_frames:
+    # Check hip keypoint validity - be more lenient
+    if (not addr_kp[23] or not addr_kp[24] or not impact_kp[23] or not impact_kp[24] or
+        len(addr_kp[23]) < 2 or len(addr_kp[24]) < 2 or
+        len(impact_kp[23]) < 2 or len(impact_kp[24]) < 2):
         return None
     
-    # Use improved address frame detection for true address position
-    address_idx = find_stable_address_frame(pose_data, swing_phases)
-    if address_idx is None:
-        address_idx = setup_frames[0]  # Fallback to first frame
+    # Posterior-most hip x at address/impact
+    hips_addr = [addr_kp[23][0], addr_kp[24][0]]
+    hips_impact = [impact_kp[23][0], impact_kp[24][0]]
     
-    if address_idx not in pose_data or pose_data[address_idx] is None:
-        return None
-    
-    kp = pose_data[address_idx]
+    if camera_side == "trail":
+        butt_addr = max(hips_addr)
+        butt_impact = max(hips_impact)
+    else:
+        butt_addr = min(hips_addr)
+        butt_impact = min(hips_impact)
     
-    # Check required keypoints visibility - need grip
-    if len(kp) < 16 or kp[16][2] < 0.3:  # Right wrist (grip)
+    # Hip width at address (pixels) - more lenient threshold
+    hip_width = abs(hips_addr[1] - hips_addr[0])
+    if hip_width < 5:  # Very lenient sanity check
         return None
     
-    try:
-        # Get grip position (use both hands if available for better accuracy)
-        grip_pos = np.array(kp[16][:2])  # Right wrist
-        
-        # Try to use both hands for more accurate grip center
-        if len(kp) > 15 and kp[15][2] > 0.3:  # Left wrist
-            left_grip = np.array(kp[15][:2])
-            grip_pos = (grip_pos + left_grip) / 2
-        
-        # Try to detect actual shaft using improved Hough line detection
-        shaft_angle = None
-        if frames is not None and address_idx < len(frames):
-            shaft_angle = detect_shaft_line_hough(frames[address_idx], grip_pos, kp)
-        
-        # Clean fallback - never return 90° silently
-        if shaft_angle is None:
-            # Try fallback estimation using body proportions
-            shaft_angle = estimate_shaft_angle_fallback(grip_pos, kp, None)
-            if shaft_angle is None:
-                # Return None with clear indication that shaft was not detected
-                return None  # UI should show "Not detected — check ROI/lighting"
-        
-        # Calculate shaft angle vs horizontal (not vs ground)
-        # The shaft_angle from Hough detection is already the line direction angle
-        # We need to convert this to angle vs horizontal
-        
-        # Convert shaft line direction to angle vs horizontal
-        shaft_line_angle = math.radians(shaft_angle)
-        
-        # Calculate angle vs horizontal (0° = horizontal, 90° = vertical)
-        # For a line going from grip down to clubhead, we want the acute angle
-        shaft_angle_vs_horizontal = abs(math.degrees(shaft_line_angle))
-        
-        # Ensure we get the acute angle (shaft should be 50-70° from horizontal at address)
-        if shaft_angle_vs_horizontal > 90:
-            shaft_angle_vs_horizontal = 180 - shaft_angle_vs_horizontal
-        
-        # Clamp to reasonable range
-        shaft_angle_vs_horizontal = max(0.0, min(shaft_angle_vs_horizontal, 90.0))
-        
-        # Note: Not rejecting any values - let UI display all measurements
-        # Even unusual values might be valid for certain clubs or setups
-        
-        return shaft_angle_vs_horizontal
-        
-    except (ZeroDivisionError, ValueError, IndexError):
-        return None
+    # Hip depth/early extension metric removed per user request
+    return None
 
 
-def detect_shaft_line_hough(frame, grip_pos, keypoints):
-    """Detect shaft line using Hough line detection with proper line direction filtering
+def calculate_hip_depth_early_extension(pose_data, swing_phases, frame_w=None, frame_h=None):
+    """Calculate hip depth/early extension - DEPRECATED, use early_extension_pct instead
     
-    Fixed implementation:
-    - Uses HoughLinesP to get actual line segments
-    - Converts θ (normal angle) to φ (line direction angle)
-    - Filters lines by 40°-70° range (typical shaft angle at address)
-    - Weights by actual segment length
-    
-    Args:
-        frame: Video frame (numpy array)
-        grip_pos: Grip position (numpy array)
-        keypoints: Pose keypoints for the frame
-        
-    Returns:
-        float: Shaft angle in degrees (None if detection fails)
+    This function is kept for backward compatibility but will use the new implementation.
     """
-    try:
-        # Convert to grayscale
-        if len(frame.shape) == 3:
-            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
-        else:
-            gray = frame
-        
-        H, W = gray.shape
-        gx, gy = map(int, grip_pos)
-        
-        # ROI: around hands, extend downward toward ball
-        x1 = max(0, gx - 80)
-        x2 = min(W, gx + 120)
-        y1 = max(0, gy - 80)
-        y2 = min(H, gy + 240)
-        roi = gray[y1:y2, x1:x2]
-        
-        if roi.size == 0:
-            return None
-        
-        # Apply edge detection
-        edges = cv2.Canny(roi, 50, 150, apertureSize=3)
-        
-        # Use probabilistic Hough to get actual line segments
-        lines = cv2.HoughLinesP(edges, 1, np.pi/180, threshold=35,
-                                minLineLength=max(20, (x2-x1)//5), maxLineGap=8)
-        
-        if lines is not None:
-            shaft_candidates = []
-            for xA, yA, xB, yB in lines[:, 0]:
-                # Convert ROI coordinates back to full-frame
-                XA, YA = xA + x1, yA + y1
-                XB, YB = xB + x1, yB + y1
-                
-                # Calculate line DIRECTION angle (not normal angle)
-                phi_deg = wrap180_deg(math.degrees(math.atan2(YB - YA, XB - XA)))
-                
-                # Filter for typical shaft line direction at address
-                # Shaft line direction should be roughly 55-65° from horizontal
-                # But we need to check the actual angle vs horizontal, not line direction
-                if 40.0 <= abs(phi_deg) <= 70.0:
-                    # Calculate actual segment length
-                    length = math.hypot(XB - XA, YB - YA)
-                    shaft_candidates.append((phi_deg, length))
-            
-            if shaft_candidates:
-                # Sort by length and use median of top candidates
-                shaft_candidates.sort(key=lambda t: -t[1])
-                top_angles = [ang for ang, _ in shaft_candidates[:3]]
-                median_phi_deg = float(np.median(top_angles))
-                
-                return median_phi_deg  # Return line direction angle in degrees
-        
-        return None  # No valid shaft line found
-        
-    except Exception:
-        return None
+    # Try to get frame dimensions from first available frame if not provided
+    if frame_w is None or frame_h is None:
+        for frame_data in pose_data.values():
+            if frame_data:
+                # Default frame size - this is a fallback and may not be accurate
+                frame_w = frame_w or 1920
+                frame_h = frame_h or 1080
+                break
+    
+    # Hip depth/early extension metric removed per user request
+    return None
 
 
-def estimate_shaft_angle_fallback(grip_pos, keypoints, ground_angle=None):
-    """Fallback shaft angle estimation using body proportions
-    
-    Args:
-        grip_pos: Grip position (numpy array)
-        keypoints: Pose keypoints for the frame
-        ground_angle: Ground line angle in radians (unused, kept for compatibility)
-        
-    Returns:
-        float: Estimated shaft angle in degrees (None if estimation fails)
-    """
-    try:
-        # Use body proportions for shaft length estimation
-        body_height = None
-        if (len(keypoints) > 28 and keypoints[12][2] > 0.3 and keypoints[28][2] > 0.3):  # Shoulder to ankle
-            shoulder_pos = np.array(keypoints[12][:2])
-            ankle_pos = np.array(keypoints[28][:2])
-            body_height = np.linalg.norm(shoulder_pos - ankle_pos)
-        
-        if body_height and body_height > 50:
-            # Typical driver length is ~0.6x body height
-            club_length = body_height * 0.6
-            # At address, club points down and slightly forward (~60° from horizontal)
-            typical_shaft_angle = math.radians(60)
-            
-            # Calculate clubhead position (down and slightly forward)
-            shaft_dx = club_length * math.cos(typical_shaft_angle)
-            shaft_dy = club_length * math.sin(typical_shaft_angle)
-            clubhead_pos = grip_pos + np.array([shaft_dx, shaft_dy])
-            
-            # Calculate shaft vector and angle
-            shaft_vec = clubhead_pos - grip_pos
-            shaft_angle = math.degrees(math.atan2(shaft_vec[1], shaft_vec[0]))
-            
-            return shaft_angle
-        
-        return None
-        
-    except Exception:
-        return None
+# Note: Shaft angle functions removed - not part of the 5 core DTL metrics
+# calculate_shaft_angle_at_address, detect_shaft_line_hough, estimate_shaft_angle_fallback
+# These functions were not in the target 5 DTL metrics and can be moved to a separate FO module if needed later
 
 
 def validate_angle_calculations(pose_data, swing_phases, frames=None):
@@ -1133,105 +1052,439 @@ def find_stable_address_frame(pose_data, swing_phases, min_frames=5):
     return setup_frames[0]  # Ultimate fallback
 
 
-def calculate_head_vertical_displacement(pose_data, swing_phases):
-    """Calculate head vertical displacement from address to impact as percentage of body height
+# Note: Head vertical displacement removed - not part of the 5 core DTL metrics
+# This function was not in the target 5 DTL metrics
+
+
+def calculate_shoulder_tilt_swing_plane_at_top(pose_data, swing_phases, top_idx, frames=None, frame_w=None, frame_h=None):
+    """Calculate shoulder tilt/swing plane angle at top using yaw-corrected width-ratio method
     
-    Fixed implementation:
-    - Percent should be Δy / body-height-at-setup (or head–ankle distance)
-    - Confirms and documents the denominator (body height reference)
-    - Ensures y-axis sign is handled (image origin top-left)
-    - Verifies roll correction didn't leak into vertical
+    Target values: Professional = 36°, 30 handicap = 29°
     
     Args:
         pose_data (dict): Dictionary mapping frame indices to pose keypoints
         swing_phases (dict): Dictionary mapping phase names to lists of frame indices
+        top_idx (int): Frame index for top of backswing
+        frames (list, optional): Video frames for analysis
+        frame_w (int, optional): Frame width in pixels
+        frame_h (int, optional): Frame height in pixels
         
     Returns:
-        dict: Head displacement data with value in percentage of body height
+        float: Shoulder tilt/swing plane angle in degrees (None if calculation fails)
     """
+    if top_idx not in pose_data or pose_data[top_idx] is None:
+        return None
+    
+    # Get address frame for baseline width
     setup_frames = swing_phases.get("setup", [])
-    impact_frames = swing_phases.get("impact", [])
+    if not setup_frames:
+        return None
+        
+    address_idx = setup_frames[0]
+    if address_idx not in pose_data or pose_data[address_idx] is None:
+        return None
+        
+    kp_top = pose_data[top_idx]
+    kp_addr = pose_data[address_idx]
     
-    if not setup_frames or not impact_frames:
+    if len(kp_top) < 13 or len(kp_addr) < 13:  # Need shoulder keypoints
         return None
     
-    # Use median filtering around address and impact for stability
-    address_range = setup_frames[:min(3, len(setup_frames))]
-    impact_range = impact_frames[:min(3, len(impact_frames))]
+    # Try to get frame dimensions if not provided
+    if frame_w is None or frame_h is None:
+        frame_w = frame_w or 1920
+        frame_h = frame_h or 1080
     
-    # Get head positions over multiple frames for stability
-    addr_head_positions = []
-    impact_head_positions = []
+    try:
+        # Ensure pixels
+        kp_top = to_pixels_if_needed(kp_top, frame_w, frame_h)
+        kp_addr = to_pixels_if_needed(kp_addr, frame_w, frame_h)
+        
+        # Get shoulder positions
+        LS_top = np.array(kp_top[11][:2])  # Left shoulder at top
+        RS_top = np.array(kp_top[12][:2])  # Right shoulder at top
+        LS_addr = np.array(kp_addr[11][:2])  # Left shoulder at address
+        RS_addr = np.array(kp_addr[12][:2])  # Right shoulder at address
+        
+        # Calculate shoulder widths
+        dx_top = abs(RS_top[0] - LS_top[0])
+        dy_top = abs(RS_top[1] - LS_top[1])
+        dx_addr = max(1e-3, abs(RS_addr[0] - LS_addr[0]))  # baseline width, avoid division by zero
+        
+        # Scale-aware guard - don't block computation for small values
+        min_baseline = 20 if frame_w is None else max(0.02 * frame_w, 20)
+        if dx_addr < min_baseline:
+            # Allow computation to proceed with warning rather than blocking
+            pass
+        
+        # Estimate yaw using width ratio: yaw ≈ acos(dx_top / dx_addr)
+        # Correct horizontal component by removing cos(yaw) effect
+        yaw_cos = np.clip(dx_top / dx_addr, 0.0, 1.0)
+        dx_corrected = dx_top / max(yaw_cos, 1e-3)  # "unskew" the horizontal component
+        
+        # Now calculate the tilt angle using corrected dx
+        angle = math.degrees(math.atan2(dy_top, dx_corrected))
+        
+        # Return the shoulder plane angle (clamped to reasonable range)
+        swing_plane_angle = max(0.0, min(abs(angle), 90.0))
+        
+        return round(swing_plane_angle, 1)
+        
+    except (ZeroDivisionError, ValueError, IndexError):
+        return None
+
+
+def _median_width(pose_data, center_idx, idx_a, idx_b, window=5, min_vis=0.35, frame_w=None, frame_h=None):
+    """Median horizontal width between two keypoints over a window, in *pixels*.
+       More lenient about visibility so we don't drop valid geometry."""
+    half = window // 2
+    vals, vis_vals = [], []
+
+    for f in range(center_idx - half, center_idx + half + 1):
+        kp = pose_data.get(f)
+        if kp is None or len(kp) <= max(idx_a, idx_b):
+            continue
+
+        # Per-frame pixel conversion (handles normalized coords)
+        kp = to_pixels_if_needed(kp, frame_w, frame_h)
+
+        va, vb = kp[idx_a], kp[idx_b]
+        if va is None or vb is None or len(va) < 2 or len(vb) < 2:
+            continue
+
+        # Use real vis if present; otherwise assume a reasonable default
+        vis_a = (va[2] if len(va) >= 3 and va[2] is not None else 0.6)
+        vis_b = (vb[2] if len(vb) >= 3 and vb[2] is not None else 0.6)
+
+        # Accept based on geometry only; vis is too flaky for hips/shoulders
+        if len(va) >= 2 and len(vb) >= 2:
+            w = abs(vb[0] - va[0])
+            if w > 1.0:  # ignore tiny/degenerate values
+                vals.append(w)
+
+                # keep vis if available, but don't gate on it
+                vis_vals.append(0.5 * (vis_a + vis_b))
+
+    if not vals:
+        return None, 0.0
+    return float(np.median(vals)), (float(np.median(vis_vals)) if vis_vals else 0.0)
+
+
+def _line_angle(kp, i, j):
+    """Calculate angle of line between two keypoints"""
+    if kp is None or len(kp) <= max(i,j) or kp[i] is None or kp[j] is None:
+        return None
+    xi, yi = kp[i][:2]
+    xj, yj = kp[j][:2]
+    return math.atan2(yj - yi, xj - xi)
+
+
+def _pelvis_width_at(pose_data, frame_idx, frame_w, frame_h):
+    """Get pelvis width at a specific frame, or None if unavailable"""
+    kp = pose_data.get(frame_idx)
+    if not kp or len(kp) <= 24: 
+        return None
+    kp = to_pixels_if_needed(kp, frame_w, frame_h)
+    a, b = kp[23], kp[24]
+    if not a or not b or len(a) < 2 or len(b) < 2:
+        return None
+    w = abs(b[0] - a[0])
+    return w if w > 1.0 else None
+
+
+def _median_pelvis_angle_deg(pose_data, center_idx, frame_w, frame_h, window=7, min_width_px=12.0):
+    """Median pelvis line angle over a window, ignoring frames with collapsed hip width."""
+    half = window // 2
+    angles = []
+    for f in range(center_idx - half, center_idx + half + 1):
+        kp = pose_data.get(f)
+        if not kp:
+            continue
+        kp = to_pixels_if_needed(kp, frame_w, frame_h)
+
+        # Require a minimally wide pelvis in this frame
+        a = kp[23] if len(kp) > 23 else None
+        b = kp[24] if len(kp) > 24 else None
+        if not a or not b or len(a) < 2 or len(b) < 2:
+            continue
+        w = abs(b[0] - a[0])
+        if w < min_width_px:
+            continue
+
+        ang = _line_angle(kp, 23, 24)  # radians
+        if ang is not None:
+            angles.append(wrap180_deg(math.degrees(ang)))
+
+    return (float(np.median(angles)) if angles else None)
+
+
+def _find_addr_baseline(pose_data, swing_phases, frame_w, frame_h, max_scan=20):
+    """Choose a robust address baseline: largest valid pelvis width in early setup,
+       with a dynamic minimum tied to shoulder width to avoid collapsed baselines."""
+    setup = swing_phases.get("setup", [])
+    if not setup:
+        return None, None
+
+    # Estimate shoulder width scale across early setup
+    sh_ws = []
+    for f in setup[:max_scan]:
+        kp = pose_data.get(f)
+        if not kp or len(kp) <= 12: 
+            continue
+        kp = to_pixels_if_needed(kp, frame_w, frame_h)
+        a, b = kp[11], kp[12]
+        if a and b and len(a) >= 2 and len(b) >= 2:
+            w = abs(b[0] - a[0])
+            if w > 1.0:
+                sh_ws.append(w)
+    sh_med = float(np.median(sh_ws)) if sh_ws else None
+
+    # Dynamic pelvis min width: at least 12 px, or 25% of shoulder width if known
+    MIN_W = 12.0
+    if sh_med is not None:
+        MIN_W = max(MIN_W, 0.25 * sh_med)
+
+    # Collect pelvis widths and pick the largest valid one
+    cands = []
+    for f in setup[:max_scan]:
+        w = _pelvis_width_at(pose_data, f, frame_w, frame_h)
+        if w is not None and w >= MIN_W:
+            cands.append((f, w))
+    if not cands:
+        return None, None
+
+    best = max(cands, key=lambda t: t[1])  # <- widest pelvis = best baseline
+    return best  # (addr_idx_used, dx_addr_used)
+
+
+# Hip turn calculation function removed per user request
+
+
+# Hip turn calculation function removed per user request
+
+
+def clamp_or_none(val, lo, hi):
+    """Clamp value to range or return None if outside bounds"""
+    if val is None:
+        return None
+    return val if lo <= val <= hi else None
+
+
+def validate_pixel_coordinates(pose_data, frame_w=1920, frame_h=1080):
+    """Validate that keypoints appear to be in pixel coordinates with reasonable scales
     
-    for frame_idx in address_range:
-        if frame_idx in pose_data and pose_data[frame_idx] is not None:
-            head_pos = calculate_head_center(pose_data[frame_idx])
-            if head_pos is not None:
-                addr_head_positions.append(head_pos)
+    This function can be used to verify the hip turn fix is working correctly.
+    If hip_width values are still <1 (e.g. '0.6px'), it means coordinates are still normalized.
+    After the fix, hip widths should be in the 30-400px range.
     
-    for frame_idx in impact_range:
-        if frame_idx in pose_data and pose_data[frame_idx] is not None:
-            head_pos = calculate_head_center(pose_data[frame_idx])
-            if head_pos is not None:
-                impact_head_positions.append(head_pos)
+    Args:
+        pose_data (dict): Dictionary mapping frame indices to pose keypoints
+        frame_w (int): Expected frame width
+        frame_h (int): Expected frame height
+        
+    Returns:
+        dict: Validation results with scale estimates
+    """
+    if not pose_data:
+        return {'valid': False, 'reason': 'no_data'}
     
-    if not addr_head_positions or not impact_head_positions:
-        return None
+    # Sample a few frames for analysis
+    sample_frames = list(pose_data.keys())[:min(5, len(pose_data))]
     
-    # Use median position for robustness
-    addr_head = np.median(addr_head_positions, axis=0)
-    impact_head = np.median(impact_head_positions, axis=0)
+    scale_issues = []
+    hip_widths = []
+    shoulder_widths = []
     
-    try:
-        # Calculate body height reference from head to ankle at address
-        # Documented denominator: body-height-at-setup (head–ankle distance)
-        addr_kp = pose_data[setup_frames[0]]
-        body_height = None
-        height_reference_method = None
-        
-        # Try multiple body height references (documented)
-        if (len(addr_kp) > 28 and addr_kp[28][2] > 0.3):  # Head to right ankle
-            ankle_pos = np.array(addr_kp[28][:2])
-            body_height = abs(addr_head[1] - ankle_pos[1])
-            height_reference_method = "head_to_right_ankle"
-        elif (len(addr_kp) > 27 and addr_kp[27][2] > 0.3):  # Head to left ankle
-            ankle_pos = np.array(addr_kp[27][:2])
-            body_height = abs(addr_head[1] - ankle_pos[1])
-            height_reference_method = "head_to_left_ankle"
-        elif (len(addr_kp) > 24 and addr_kp[24][2] > 0.3):  # Head to hip as fallback
-            hip_pos = np.array(addr_kp[24][:2])
-            body_height = abs(addr_head[1] - hip_pos[1]) * 1.8  # Approximate full body
-            height_reference_method = "head_to_hip_scaled"
-        
-        if body_height is None or body_height < 50:
-            return None
-        
-        # Calculate vertical displacement 
-        # Note: In image coordinates, y increases downward (image origin top-left)
-        # Positive displacement = head moved down, negative = head moved up
-        vertical_displacement = impact_head[1] - addr_head[1]
-        
-        # Convert to percentage of body height (documented formula: Δy / body-height-at-setup)
-        displacement_pct = (abs(vertical_displacement) / body_height) * 100
-        
-        # Always return the calculated value - let the UI handle display warnings
-        # Sanity check: typical head drop is 2-10% of body height
-        # Values outside typical range will be flagged in the UI but still displayed
-        
-        displacement_data = {
-            'displacement_pixels': round(vertical_displacement, 2),
-            'displacement_direction': 'down' if vertical_displacement > 0 else 'up',
-            'displacement_abs': round(abs(vertical_displacement), 2),
-            'displacement_pct': round(displacement_pct, 1),
-            'body_height_ref': round(body_height, 2),
-            'height_reference_method': height_reference_method,  # Document the denominator
-            'denominator_documented': True  # Confirms denominator is documented
-        }
+    for frame_idx in sample_frames:
+        kp = pose_data[frame_idx]
+        if not kp or len(kp) < 25:
+            continue
+            
+        # Convert to pixels if needed
+        kp = to_pixels_if_needed(kp, frame_w, frame_h)
+        
+        # Check hip width
+        if kp[23] and kp[24]:
+            hip_width = abs(kp[24][0] - kp[23][0])
+            hip_widths.append(hip_width)
+            if not (30 <= hip_width <= 400):
+                scale_issues.append(f'hip_width={hip_width:.1f}px (expected 30-400px)')
+        
+        # Check shoulder width
+        if kp[11] and kp[12]:
+            shoulder_width = abs(kp[12][0] - kp[11][0])
+            shoulder_widths.append(shoulder_width)
+            if not (50 <= shoulder_width <= 500):
+                scale_issues.append(f'shoulder_width={shoulder_width:.1f}px (expected 50-500px)')
+    
+    result = {
+        'valid': len(scale_issues) == 0,
+        'scale_issues': scale_issues,
+        'hip_width_median': np.median(hip_widths) if hip_widths else None,
+        'shoulder_width_median': np.median(shoulder_widths) if shoulder_widths else None,
+        'frame_dimensions': (frame_w, frame_h)
+    }
+    
+    # Add diagnostic message for hip turn fix verification
+    if result['hip_width_median'] is not None:
+        if result['hip_width_median'] < 5:
+            result['coordinate_status'] = 'likely_normalized'
+            result['hip_turn_fix_needed'] = True
+        else:
+            result['coordinate_status'] = 'likely_pixels'
+            result['hip_turn_fix_needed'] = False
+    
+    return result
+
+
+def validate_metric_ranges(metrics):
+    """Validate that computed metrics fall within realistic golf ranges
+    
+    Args:
+        metrics (dict): Dictionary of computed metrics
         
-        return displacement_data
+    Returns:
+        dict: Validation results with range checks
+    """
+    validations = {}
+    
+    # Define realistic ranges for golf metrics
+    ranges = {
+        'shoulder_plane_top_deg': (10, 70),
+        'back_tilt_setup_deg': (15, 60),
+        'knee_flexion_deg': (5, 45),
+        'head_height_change_in': (-3, 3),  # Address → Impact: within ±1″ of address is great; 1–2.5″ = caution; > 2.5″ = likely EE/low-point issues
+        # Hip depth and hip turn metrics removed
+    }
+    
+    for metric_name, (min_val, max_val) in ranges.items():
+        if metric_name in metrics:
+            value = metrics[metric_name]
+            if value is not None:
+                in_range = min_val <= value <= max_val
+                validations[metric_name] = {
+                    'value': value,
+                    'range': (min_val, max_val),
+                    'valid': in_range,
+                    'reason': 'ok' if in_range else f'outside_range_{min_val}-{max_val}'
+                }
+            else:
+                validations[metric_name] = {
+                    'value': None,
+                    'valid': False,
+                    'reason': 'null_value'
+                }
+    
+    overall_valid = all(v['valid'] for v in validations.values())
+    
+    return {
+        'overall_valid': overall_valid,
+        'metric_validations': validations
+    }
+
+
+def compute_dtl_three(pose_data, swing_phases, frame_w, frame_h, frames=None, camera_side="trail"):
+    """Compute DTL metrics with proper unit handling including head height change
+    
+    Metrics included:
+    - Shoulder plane at top (degrees)
+    - Back tilt at address (degrees) 
+    - Knee flexion at address (degrees)
+    - Head height change: drop at top and change at impact (inches)
+    
+    Args:
+        pose_data (dict): Dictionary mapping frame indices to pose keypoints
+        swing_phases (dict): Dictionary mapping phase names to lists of frame indices
+        frame_w (int): Frame width in pixels
+        frame_h (int): Frame height in pixels
+        frames (list, optional): Video frames for analysis
+        camera_side (str): "trail" or "lead" - which side camera is on
         
-    except (ZeroDivisionError, ValueError, IndexError):
+        Returns:
+        dict: DTL metrics including head height change (replaces hip turn)
+    """
+    setup_frames = swing_phases.get("setup", [])
+    backswing_frames = swing_phases.get("backswing", [])
+    impact_frames = swing_phases.get("impact", [])
+    
+    if not setup_frames:
+        return None
+    
+    addr_idx = setup_frames[0]
+    top_idx = backswing_frames[-1] if backswing_frames else addr_idx
+    impact_idx = impact_frames[0] if impact_frames else addr_idx
+    
+    if None in (addr_idx, top_idx, impact_idx):
+        return None
+    
+    # Calculate each metric
+    shoulder_top = calculate_shoulder_tilt_swing_plane_at_top(pose_data, swing_phases, top_idx, frames)
+    back_tilt = calculate_back_tilt_degree(pose_data, swing_phases, address_idx=addr_idx, frames=frames)
+    
+    knee_data = calculate_knee_bend_degree(pose_data, addr_idx)
+    knee_avg = knee_data.get("average_flexion") if knee_data else None
+    
+    # Calculate head height change (replacing hip turn metric)
+    # Get inch scale using shoulder width or fallback
+    inch_scale = calculate_inch_scale_from_shoulders(pose_data, addr_idx, frame_w, frame_h)
+    head_height_change_in = None
+    if inch_scale is not None:
+        head_height_change_in = head_height_change(
+            pose_data, addr_idx, top_idx, impact_idx, inch_scale
+        )
+    
+    # Hip depth/early extension metric removed per user request
+    ee_pct = None
+    # Hip turn metric removed per user request
+    # All confidence calculations removed per user request
+    
+    metrics = {
+        "shoulder_plane_top_deg": shoulder_top,
+        "back_tilt_setup_deg": back_tilt,
+        "knee_flexion_deg": knee_avg,
+        "head_height_change_in": round(head_height_change_in, 2) if head_height_change_in is not None else None,
+        "inch_scale": round(inch_scale, 3) if inch_scale is not None else None,
+        # Hip depth and hip turn metrics removed per user request
+        # All confidence calculations removed per user request
+    }
+    
+    # Validate coordinate scales
+    coord_validation = validate_pixel_coordinates(pose_data, frame_w, frame_h)
+    
+    # Validate metric ranges
+    metric_validation = validate_metric_ranges(metrics)
+    
+    # Add validation info to result
+    metrics['_validation'] = {
+        'coordinates': coord_validation,
+        'metrics': metric_validation
+    }
+    
+    return metrics
+
+
+def compute_dtl_five_metrics(pose_data, swing_phases, frames=None, frame_w=None, frame_h=None):
+    """DEPRECATED - use compute_dtl_three instead (hip depth and hip turn removed)
+    
+    This function is kept for backward compatibility.
+    """
+    # Try to get frame dimensions if not provided
+    if frame_w is None or frame_h is None:
+        frame_w = frame_w or 1920
+        frame_h = frame_h or 1080
+    
+    result = compute_dtl_three(pose_data, swing_phases, frame_w, frame_h, frames)
+    
+    if result is None:
         return None
+    
+    # Apply clamp_or_none for backward compatibility
+    return {
+        "shoulder_plane_top_deg": clamp_or_none(result.get("shoulder_plane_top_deg"), 20, 50),
+        "back_tilt_setup_deg": clamp_or_none(result.get("back_tilt_setup_deg"), 25, 50),
+        "knee_flexion_deg": clamp_or_none(result.get("knee_flexion_deg"), 15, 45),
+        # Hip depth and hip turn metrics removed per user request
+    }
 
 
 def generate_diagnostic_overlay(pose_data, swing_phases, frames=None):
@@ -1359,4 +1612,4 @@ def generate_diagnostic_overlay(pose_data, swing_phases, frames=None):
         return diagnostic_data
         
     except Exception as e:
-        return {'error': str(e)}
+        return {'error': str(e)}

app/models/pose_estimator.py

@@ -26,23 +26,37 @@ class PoseEstimator:
 
         if results.pose_landmarks:
             keypoints = []
+            world_landmarks = []
             total_visibility = 0
+            
+            # Extract 2D keypoints
             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
             
+            # Extract 3D world landmarks if available
+            if results.pose_world_landmarks:
+                for landmark in results.pose_world_landmarks.landmark:
+                    # World landmarks are in meters relative to hip center
+                    world_landmarks.append([landmark.x, landmark.y, landmark.z])
+            else:
+                world_landmarks = None
+            
             # 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
+                return keypoints, world_landmarks
             else:
                 # Poor quality detection, return fallback
-                return [[w//2, h//2, 0.05] for _ in range(33)]
+                fallback_2d = [[w//2, h//2, 0.05] for _ in range(33)]
+                fallback_3d = [[0.0, 0.0, 0.0] for _ in range(33)] if world_landmarks else None
+                return fallback_2d, fallback_3d
         else:
             # No pose detected, return very low confidence markers
-            return [[w//2, h//2, 0.05] for _ in range(33)]
+            fallback_2d = [[w//2, h//2, 0.05] for _ in range(33)]
+            return fallback_2d, None
 
     def close(self):
         self.pose.close()
@@ -55,18 +69,23 @@ def analyze_pose(frames):
         frames (list): List of video frames
         
     Returns:
-        dict: Dictionary mapping frame indices to pose keypoints
+        tuple: (pose_data, world_landmarks) where:
+            - pose_data: Dictionary mapping frame indices to 2D pose keypoints
+            - world_landmarks: Dictionary mapping frame indices to 3D world landmarks
     """
     pose_estimator = PoseEstimator()
     pose_data = {}
+    world_landmarks = {}
 
     for i, frame in enumerate(tqdm(frames, desc="Analyzing pose")):
-        keypoints = pose_estimator.process_frame(frame)
+        keypoints, world_lm = pose_estimator.process_frame(frame)
         # Always store keypoints (never None due to fallback in process_frame)
         pose_data[i] = keypoints
+        if world_lm is not None:
+            world_landmarks[i] = world_lm
 
     pose_estimator.close()
-    return pose_data
+    return pose_data, world_landmarks
 
 
 # Deprecated - joint angle calculations removed (not part of 5 core metrics)

app/models/swing_analyzer.py

@@ -149,10 +149,7 @@ def calculate_shaft_angle_at_top(pose_data, top_frame, target_line_vec=None):
     while angle_deg < -90:
         angle_deg += 180
         
-    # Enhanced QC check: if |angle| > 60°, mark as unstable (sanity gate per feedback)
-    if abs(angle_deg) > 60:
-        return None  # Unstable measurement - shaft angle magnitude >60° rejected
-        
+    # Always return the calculated angle - no hiding based on magnitude
     return angle_deg
 
 

app/streamlit_app.py

@@ -193,7 +193,7 @@ def format_metric_value(metric_data, unit=""):
 def get_shaft_angle_grading(value, confidence):
     """Grade shaft angle at top with sign-aware labels"""
     if value is None:
-        return None  # Hide if not available
+        return {'display_value': 'n/a', 'badge': '⚪', 'status': 'No data available'}
     
     # Note: Not hiding any values - display all measurements
     # Even extreme values might be valid for certain swings or camera angles
@@ -238,7 +238,7 @@ def get_shaft_angle_grading(value, confidence):
 def get_head_sway_grading(value, confidence):
     """Grade head sway with percentage of pelvis/shoulder width"""
     if value is None:
-        return None  # Hide if not available
+        return {'display_value': 'n/a', 'badge': '⚪', 'status': 'No data available'}
     
     # Note: Not hiding any values - display all measurements
     # Even high values might be valid for certain swings or camera setups
@@ -270,7 +270,7 @@ def get_head_sway_grading(value, confidence):
 def get_back_tilt_grading(value, confidence, camera_roll=0):
     """Grade back tilt at setup"""
     if value is None:
-        return None  # Hide if not available
+        return {'value': None, 'display_value': 'n/a', 'badge': '⚪', 'status': 'No data available'}
     # Note: Not hiding based on camera roll - display all measurements
     
     # Determine grading
@@ -288,10 +288,12 @@ def get_back_tilt_grading(value, confidence, camera_roll=0):
         label = "Likely problematic"
     
     return {
+        'value': value,  # Raw value for display logic
         'display_value': f"{value:.1f}°",
         'badge': badge,
         'label': label,
         'confidence': confidence,
+        'status': label,  # Use label as status for legacy compatibility
         'tip': "Typical tour range ≈30–40°." if badge != "🟢" else None
     }
 
@@ -299,7 +301,7 @@ def get_back_tilt_grading(value, confidence, camera_roll=0):
 def get_knee_flexion_grading(value, confidence):
     """Grade knee flexion at setup"""
     if value is None:
-        return None
+        return {'display_value': 'n/a', 'badge': '⚪', 'status': 'No data available'}
     
     # Determine grading
     if 15 <= value <= 30:
@@ -573,10 +575,12 @@ def get_hip_depth_grading(hip_depth_data, confidence):
         tip += f"\n\nTechnical: Hip width {hip_depth_data.get('hip_width_ref', 0):.1f}px, threshold {adaptive_threshold:.1f}px"
     
     return {
+        'value': depth_loss_pct,  # Raw value for display logic
         'display_value': f'{depth_loss_pct:.1f}% loss{confidence_note}',
         'badge': badge,
         'label': label,
         'confidence': confidence,
+        'status': label,  # Use label as status for legacy compatibility
         'tip': tip,
         'calculation_confidence': calculation_confidence,
         'adaptive_threshold': adaptive_threshold
@@ -586,7 +590,7 @@ def get_hip_depth_grading(hip_depth_data, confidence):
 def get_shaft_address_grading(angle_value, confidence):
     """Generate grading for shaft angle at address"""
     if angle_value is None:
-        return None
+        return {'display_value': 'n/a', 'badge': '⚪', 'status': 'No data available'}
     
     if 45 <= angle_value <= 65:
         badge = '🟢'
@@ -646,7 +650,7 @@ def get_head_displacement_grading(displacement_data, confidence):
 def get_shoulder_rotation_grading(value, confidence, position="top"):
     """Grade shoulder rotation angle"""
     if value is None:
-        return None
+        return {'display_value': 'n/a', 'badge': '⚪', 'status': 'No data available'}
     
     # Professional ranges: Top ~90-110°, Impact ~30-50°
     if position == "top":
@@ -688,7 +692,7 @@ def get_shoulder_rotation_grading(value, confidence, position="top"):
 def get_hip_rotation_grading(value, confidence, position="top"):
     """Grade hip rotation angle"""
     if value is None:
-        return None
+        return {'display_value': 'n/a', 'badge': '⚪', 'status': 'No data available'}
     
     # Professional ranges: Top ~45-60°, Impact ~40-60°
     if position == "top":
@@ -727,52 +731,114 @@ def get_hip_rotation_grading(value, confidence, position="top"):
     }
 
 
-def get_x_factor_grading(value, confidence, position="top"):
-    """Grade X-Factor (shoulder-hip separation)"""
+
+def get_shoulder_tilt_swing_plane_grading(value, confidence):
+    """Grade shoulder tilt/swing plane at top - professional = 36°, 30 handicap = 29°"""
     if value is None:
-        return None
+        return {'value': None, 'display_value': 'n/a', 'badge': '⚪', 'status': 'No data available'}
+    
+    # Professional = 36°, 30 handicap = 29°
+    if 30 <= value <= 40:
+        badge = '🟢'
+        label = 'Excellent plane'
+        tip = 'Great shoulder tilt creating proper swing plane'
+    elif 25 <= value < 30 or 40 < value <= 45:
+        badge = '🟠'
+        label = 'Good plane'
+        tip = 'Solid shoulder tilt with room for optimization'
+    else:
+        badge = '🔴'
+        label = 'Needs adjustment'
+        tip = 'Work on shoulder tilt for better swing plane'
+    
+    return {
+        'value': value,  # Raw value for display logic
+        'display_value': f'{value:.1f}°',
+        'badge': badge,
+        'label': label,
+        'tip': tip,
+        'confidence': confidence,
+        'status': label  # Use label as status for legacy compatibility
+    }
+
+
+def get_shoulder_tilt_impact_grading(value, confidence):
+    """Grade shoulder tilt at impact - professional = 39°, 30 handicap = 27°"""
+    if value is None:
+        return {'display_value': 'n/a', 'badge': '⚪', 'status': 'No data available'}
     
-    # Professional ranges: Top ~45-60°, Impact ~10-25°
+    # Professional = 39°, 30 handicap = 27°
+    if 35 <= value <= 45:
+        badge = '🟢'
+        label = 'Excellent tilt'
+        tip = 'Great shoulder tilt creating proper impact position'
+    elif 25 <= value < 35 or 45 < value <= 55:
+        badge = '🟠'
+        label = 'Good tilt'
+        tip = 'Solid shoulder tilt with room for optimization'
+    else:
+        badge = '🔴'
+        label = 'Needs improvement'
+        tip = 'Work on shoulder tilt for better impact position'
+    
+    return {
+        'display_value': f'{value:.1f}°',
+        'badge': badge,
+        'label': label,
+        'tip': tip,
+        'confidence': confidence
+    }
+
+
+# Hip turn grading function removed per user request
+
+
+def get_hip_sway_grading(value, confidence, position="top"):
+    """Grade hip sway - professional = 3.9" towards target, 30 handicap = 2.5" towards target"""
+    if value is None:
+        return {'display_value': 'n/a', 'badge': '⚪', 'status': 'No data available'}
+    
+    # Professional = 3.9" towards target, 30 handicap = 2.5" towards target
     if position == "top":
-        if 40 <= value <= 65:
+        if 3.0 <= value <= 5.0:
             badge = '🟢'
-            label = 'Excellent separation'
-            tip = 'Great coil between shoulders and hips for power'
-        elif 30 <= value < 40 or 65 < value <= 75:
+            label = 'Excellent sway'
+            tip = 'Great hip movement creating proper coil'
+        elif 2.0 <= value < 3.0 or 5.0 < value <= 6.0:
             badge = '🟠'
-            label = 'Good separation'
-            tip = 'Solid differential with room for improvement'
+            label = 'Good sway'
+            tip = 'Solid hip movement with room for optimization'
         else:
             badge = '🔴'
             label = 'Needs improvement'
-            tip = 'Work on creating more separation for power'
+            tip = 'Work on hip movement for better coil and power'
     else:  # impact
-        if 10 <= value <= 30:
+        if 2.0 <= value <= 4.0:
             badge = '🟢'
-            label = 'Excellent timing'
-            tip = 'Great sequence of unwinding through impact'
-        elif 5 <= value < 10 or 30 < value <= 40:
+            label = 'Excellent sway'
+            tip = 'Great hip movement through impact'
+        elif 1.0 <= value < 2.0 or 4.0 < value <= 5.0:
             badge = '🟠'
-            label = 'Good timing'
-            tip = 'Solid sequence with room for optimization'
+            label = 'Good sway'
+            tip = 'Solid hip movement with room for optimization'
         else:
             badge = '🔴'
             label = 'Needs improvement'
-            tip = 'Focus on proper kinematic sequence timing'
+            tip = 'Work on hip movement for better impact position'
     
     return {
-        'display_value': f"{value:.1f}°",
+        'display_value': f'{value:.1f}"',
         'badge': badge,
         'label': label,
-        'confidence': confidence,
-        'tip': tip
+        'tip': tip,
+        'confidence': confidence
     }
 
 
 def get_wrist_hinge_grading(value, confidence, position="top"):
     """Grade wrist hinge angle"""
     if value is None:
-        return None
+        return {'display_value': 'n/a', 'badge': '⚪', 'status': 'No data available'}
     
     # Professional ranges: Top ~90-120°, Impact ~15-35°
     if position == "top":
@@ -812,26 +878,30 @@ def get_wrist_hinge_grading(value, confidence, position="top"):
 
 
 def get_head_lateral_sway_grading(value, confidence):
-    """Grade head lateral sway in centimeters"""
+    """Grade head lateral sway as percentage of shoulder width"""
     if value is None:
-        return None
+        return {'display_value': 'n/a', 'badge': '⚪', 'status': 'No data available'}
     
-    # Professional ranges: <3cm excellent, 3-6cm good, >6cm needs work
-    if value <= 3:
+    # Grade based on percentage of shoulder width
+    if abs(value) <= 5.0:  # <= 5% of shoulder width
         badge = '🟢'
         label = 'Excellent stability'
         tip = 'Outstanding head stability throughout swing'
-    elif value <= 6:
-        badge = '🟠'
+    elif abs(value) <= 10.0:  # <= 10% of shoulder width
+        badge = '🟡'
         label = 'Good stability'
         tip = 'Solid head control with minor movement'
-    else:
+    elif abs(value) <= 15.0:  # <= 15% of shoulder width
+        badge = '🟠'
+        label = 'Moderate sway'
+        tip = 'Some head movement - focus on stability'
+    else:  # > 15% of shoulder width
         badge = '🔴'
         label = 'Excessive sway'
         tip = 'Work on keeping head stable for consistent contact'
     
     return {
-        'display_value': f"{value:.1f}cm",
+        'display_value': f"{value:.1f}%",
         'badge': badge,
         'label': label,
         'confidence': confidence,
@@ -842,28 +912,24 @@ def get_head_lateral_sway_grading(value, confidence):
 def display_new_grading_scheme(core_metrics):
     """Display the swing analysis with badges and confidence indicators"""
     # Check if we have front-facing metrics
+    # Front-facing metrics have unique keys that DTL doesn't have
     has_front_facing_metrics = any(key in core_metrics for key in [
-        'shoulder_rotation_top_deg', 'hip_rotation_top_deg', 'x_factor_top_deg', 
-        'wrist_hinge_top_deg', 'head_lateral_sway_cm'
+        'shoulder_tilt_impact_deg', 'hip_sway_top_inches', 'wrist_hinge_top_deg'
     ])
+    # Hip turn check removed per user request
     
     if has_front_facing_metrics:
-        st.subheader("Front-Facing Swing Analysis - Enhanced Metrics")
-        st.info("🎯 **Front-Facing View Detected**: You're getting the full 5-metric analysis with precise angular measurements!")
+        st.subheader("Swing Analysis")
     else:
         st.subheader("Down-the-Line Swing Analysis")
     
     # Extract raw values and calculate confidence (simplified for now)
-    shaft_angle_data = core_metrics.get("shaft_angle_top", {})
-    head_sway_data = core_metrics.get("head_sway_pct", {})
-    back_tilt_data = core_metrics.get("back_tilt_deg", {})
-    knee_flexion_data = core_metrics.get("knee_bend_deg", {})
-    wrist_pattern_data = core_metrics.get("wrist_pattern", {})
-    shoulder_turn_data = core_metrics.get("shoulder_turn_quality", {})
     # New DTL metrics
+    shoulder_tilt_swing_plane_data = core_metrics.get("shoulder_tilt_swing_plane_top_deg", {})
+    back_tilt_data = core_metrics.get("back_tilt_deg", {})
+    knee_flexion_data = core_metrics.get("knee_flexion_deg", {})
     hip_depth_data = core_metrics.get("hip_depth_early_extension", {})
-    shaft_address_data = core_metrics.get("shaft_angle_address", {})
-    head_displacement_data = core_metrics.get("head_vertical_displacement", {})
+    # Hip turn data removed per user request
     
     # Calculate confidence with QC penalties as per feedback
     def get_confidence(data, metric_type='general'):
@@ -943,26 +1009,17 @@ def display_new_grading_scheme(core_metrics):
     # Process each metric
     metrics_to_display = []
     
-    # 1. Shaft Plane @ Top (Qualitative)
-    shaft_value = shaft_angle_data.get('value')
-    # Always try to show qualitative assessment, even if raw number was rejected
-    if shaft_value is not None or shaft_angle_data.get('status') in ['approximate', 'club_not_visible']:
-        # For qualitative assessment, use any available value or status info
-        raw_shaft = shaft_value if shaft_value is not None else 0  # Default for status-only cases
-        shaft_confidence = get_confidence(shaft_angle_data, 'shaft_angle')
-        shaft_grading = get_qualitative_shaft_angle_grading(raw_shaft, shaft_confidence)
-        if shaft_grading:
-            metrics_to_display.append(("Shaft Plane @ Top", shaft_grading))
-    
-    # 2. Head Sway
-    sway_value = head_sway_data.get('value')
-    if sway_value is not None:
-        sway_confidence = get_confidence(head_sway_data, 'head_sway')
-        # Hide if confidence is 0 (indicates unstable scale)
-        if sway_confidence > 0:
-            sway_grading = get_head_sway_grading(sway_value, sway_confidence)
-            if sway_grading:
-                metrics_to_display.append(("Head Sway", sway_grading))
+    # Old metrics removed - now using new 5-metric system
+    
+    # DTL Metrics - All 5 new metrics
+    if not has_front_facing_metrics:
+        # 1. Shoulder Tilt/Swing Plane @ Top
+        shoulder_tilt_swing_plane_value = shoulder_tilt_swing_plane_data.get('value')
+        if shoulder_tilt_swing_plane_value is not None:
+            confidence = get_confidence(shoulder_tilt_swing_plane_data, 'shoulder_tilt_swing_plane')
+            grading = get_shoulder_tilt_swing_plane_grading(shoulder_tilt_swing_plane_value, confidence)
+            if grading:
+                metrics_to_display.append(("Shoulder Tilt/Swing Plane @ Top", grading))
     
     # 3. Back Tilt @ Setup
     tilt_value = back_tilt_data.get('value')
@@ -1011,75 +1068,35 @@ def display_new_grading_scheme(core_metrics):
         }
         metrics_to_display.append(("Hip Depth / Early Extension", error_grading))
     else:
-        # Debug: Check why hip depth value is None
-        st.caption(f"Debug: Hip depth data: {hip_depth_data}")
-    
-    # 9. Shaft Angle at Address (New DTL metric)
-    shaft_address_value = shaft_address_data.get('value')
-    if shaft_address_value is not None:
-        shaft_address_confidence = get_confidence(shaft_address_data, 'shaft_address')
-        shaft_address_grading = get_shaft_address_grading(shaft_address_value, shaft_address_confidence)
-        if shaft_address_grading:
-            metrics_to_display.append(("Shaft Angle @ Address", shaft_address_grading))
-    
-    # 10. Head Vertical Displacement (New DTL metric)
-    if head_displacement_data.get('value') is not None:
-        head_displacement_confidence = get_confidence(head_displacement_data, 'head_displacement')
-        # Pass the detailed_data (full dictionary) instead of just the value
-        detailed_data = head_displacement_data.get('detailed_data', {})
-        head_displacement_grading = get_head_displacement_grading(detailed_data, head_displacement_confidence)
-        if head_displacement_grading:
-            metrics_to_display.append(("Head Vertical Displacement", head_displacement_grading))
+        pass  # Hip depth calculation succeeded but no special handling needed
     
-    # Front-facing metrics (only displayed when available)
+    # Hip Turn @ Impact metric removed per user request
+    
+    # Additional old metrics removed - focusing on new 4-metric system
+    
+    # Front-facing metrics (only displayed when available) - 4 required metrics only
     if has_front_facing_metrics:
-        # Shoulder Rotation at Top
-        shoulder_rotation_top_data = core_metrics.get("shoulder_rotation_top_deg", {})
-        if shoulder_rotation_top_data.get('value') is not None:
-            confidence = 0.9  # High confidence for front-facing measurements
-            grading = get_shoulder_rotation_grading(shoulder_rotation_top_data['value'], confidence, "top")
-            if grading:
-                metrics_to_display.append(("Shoulder Rotation @ Top", grading))
-        
-        # Shoulder Rotation at Impact
-        shoulder_rotation_impact_data = core_metrics.get("shoulder_rotation_impact_deg", {})
-        if shoulder_rotation_impact_data.get('value') is not None:
-            confidence = 0.9
-            grading = get_shoulder_rotation_grading(shoulder_rotation_impact_data['value'], confidence, "impact")
-            if grading:
-                metrics_to_display.append(("Shoulder Rotation @ Impact", grading))
+        # Front-facing metrics are now always calculated
+        pass
         
-        # Hip Rotation at Top
-        hip_rotation_top_data = core_metrics.get("hip_rotation_top_deg", {})
-        if hip_rotation_top_data.get('value') is not None:
-            confidence = 0.9
-            grading = get_hip_rotation_grading(hip_rotation_top_data['value'], confidence, "top")
+        # Shoulder Tilt at Impact
+        shoulder_tilt_impact_data = core_metrics.get("shoulder_tilt_impact_deg", {})
+        if shoulder_tilt_impact_data.get('value') is not None:
+            confidence = 0.9  # High confidence for front-facing measurements
+            grading = get_shoulder_tilt_impact_grading(shoulder_tilt_impact_data['value'], confidence)
             if grading:
-                metrics_to_display.append(("Hip Rotation @ Top", grading))
+                metrics_to_display.append(("Shoulder Tilt @ Impact", grading))
         
-        # Hip Rotation at Impact
-        hip_rotation_impact_data = core_metrics.get("hip_rotation_impact_deg", {})
-        if hip_rotation_impact_data.get('value') is not None:
-            confidence = 0.9
-            grading = get_hip_rotation_grading(hip_rotation_impact_data['value'], confidence, "impact")
-            if grading:
-                metrics_to_display.append(("Hip Rotation @ Impact", grading))
+        # Hip Turn at Impact metric removed per user request
         
-        # X-Factor at Top
-        x_factor_top_data = core_metrics.get("x_factor_top_deg", {})
-        if x_factor_top_data.get('value') is not None:
-            confidence = 0.85  # Slightly lower as it's a derived metric
-            grading = get_x_factor_grading(x_factor_top_data['value'], confidence, "top")
+        # Hip Sway at Top
+        hip_sway_top_data = core_metrics.get("hip_sway_top_inches", {})
+        if hip_sway_top_data.get('value') is not None:
+            confidence = 0.8
+            grading = get_hip_sway_grading(hip_sway_top_data['value'], confidence, "top")
             if grading:
-                metrics_to_display.append(("X-Factor @ Top", grading))
+                metrics_to_display.append(("Hip Sway @ Top", grading))
         
-        # X-Factor at Impact
-        x_factor_impact_data = core_metrics.get("x_factor_impact_deg", {})
-        if x_factor_impact_data.get('value') is not None:
-            confidence = 0.85
-            grading = get_x_factor_grading(x_factor_impact_data['value'], confidence, "impact")
-            if grading:
-                metrics_to_display.append(("X-Factor @ Impact", grading))
         
         # Wrist Hinge at Top
         wrist_hinge_top_data = core_metrics.get("wrist_hinge_top_deg", {})
@@ -1088,22 +1105,6 @@ def display_new_grading_scheme(core_metrics):
             grading = get_wrist_hinge_grading(wrist_hinge_top_data['value'], confidence, "top")
             if grading:
                 metrics_to_display.append(("Wrist Hinge @ Top", grading))
-        
-        # Wrist Hinge at Impact
-        wrist_hinge_impact_data = core_metrics.get("wrist_hinge_impact_deg", {})
-        if wrist_hinge_impact_data.get('value') is not None:
-            confidence = 0.8
-            grading = get_wrist_hinge_grading(wrist_hinge_impact_data['value'], confidence, "impact")
-            if grading:
-                metrics_to_display.append(("Wrist Hinge @ Impact", grading))
-        
-        # Head Lateral Sway
-        head_lateral_sway_data = core_metrics.get("head_lateral_sway_cm", {})
-        if head_lateral_sway_data.get('value') is not None:
-            confidence = 0.85
-            grading = get_head_lateral_sway_grading(head_lateral_sway_data['value'], confidence)
-            if grading:
-                metrics_to_display.append(("Head Lateral Sway", grading))
     
     # Display each metric
     for metric_name, grading in metrics_to_display:
@@ -1121,6 +1122,11 @@ def display_metric_card(metric_name, grading):
         # Metric header
         st.subheader(metric_name)
         
+        # Add definition
+        definition = get_metric_definition(metric_name)
+        if definition:
+            st.caption(definition)
+        
         # Result line with badge and label
         result_line = f"**{grading['display_value']}** — {grading['badge']} {grading.get('label', '')}"
         st.markdown(result_line)
@@ -1145,18 +1151,41 @@ def display_metric_card(metric_name, grading):
         
         # Add tip if available using info box
         if grading.get('tip'):
-            st.info(f"💡 **Tip:** {grading['tip']}")
+            st.info(f"💡 {grading['tip']}")
         
         # Add spacing
         st.write("")
 
 
+def get_metric_definition(metric_name):
+    """Get a short definition for each metric"""
+    definitions = {
+        "Shoulder Tilt/Swing Plane @ Top": "Measures shoulder swing plane angle at the top of backswing.",
+        "Back Tilt @ Setup": "Measures spine angle from vertical at address position.",
+        "Knee Flexion": "Measures knee bend angle at address position.",
+        "Hip Depth / Early Extension": "Tracks loss of hip flexion through impact.",
+        "Hip Turn @ Impact": "Measures hip rotation at ball contact.",
+        "Shoulder Tilt @ Impact": "Measures shoulder angle at ball contact.",
+        "Hip Sway @ Top": "Measures lateral hip movement at the top of backswing.",
+        "Wrist Hinge @ Top": "Measures wrist hinge angle at the top of backswing."
+    }
+    return definitions.get(metric_name, "")
+
 def get_metric_evaluation(metric_name, grading):
     """Generate detailed evaluation text for each metric"""
     value = grading.get('display_value', 'Unknown')
     badge = grading.get('badge', '')
     
-    if metric_name == "Back Tilt @ Setup":
+    # DTL METRICS (5 current metrics)
+    if metric_name == "Shoulder Tilt/Swing Plane @ Top":
+        if "🟢" in badge:
+            return f"Your shoulder tilt/swing plane of **{value}** at the top shows excellent position. This optimal swing plane angle promotes powerful, on-plane delivery and consistent ball striking. Professional golfers typically maintain 36° while 30-handicappers average 29°. Your measurement indicates proper shoulder turn and swing plane control."
+        elif "🟠" in badge:
+            return f"Your shoulder tilt/swing plane of **{value}** at the top is good with room for improvement. This measurement affects your swing plane consistency and power generation. Refining your shoulder turn and spine angle can enhance ball striking and distance control."
+        else:
+            return f"Your shoulder tilt/swing plane of **{value}** at the top needs attention. This metric is crucial for swing plane consistency and power generation. Work on proper shoulder rotation and maintaining spine angle throughout the backswing for better results."
+    
+    elif metric_name == "Back Tilt @ Setup":
         if "🟢" in badge:
             return f"Your back tilt of **{value}** shows excellent posture setup. This forward spine angle is crucial for creating the proper swing plane and generating power through impact. Good back tilt promotes consistent contact, optimal launch conditions, and prevents early extension during the downswing."
         elif "🟠" in badge:
@@ -1172,84 +1201,41 @@ def get_metric_evaluation(metric_name, grading):
         else:
             return f"Your knee flexion of **{value}** may be limiting your swing potential. Proper knee bend is essential for balance, power generation, and maintaining spine angle. Too little or too much knee flexion can cause balance issues and inconsistent contact."
     
-    # Removed evaluation text for: Wrist Pattern, Kinematic Sequence, and Shoulder Turn Quality
-    
-    elif "Shaft Plane" in metric_name or "Shaft Angle" in metric_name:
-        if grading.get('value') is None or str(value) == "None" or "unavailable" in str(value).lower():
-            return f"Shaft angle analysis is **unavailable due to insufficient data**. This metric measures the club shaft angle at address relative to the ground, affecting swing plane and setup position. Proper shaft angle promotes consistent ball striking and accuracy."
-        elif "🟢" in badge:
-            return f"Your shaft angle of **{value}** shows excellent setup position. This optimal shaft angle at address promotes proper swing plane, consistent ball striking, and accuracy. Good shaft positioning contributes to repeatable swing mechanics and shot control."
-        elif "🟠" in badge:
-            return f"Your shaft angle of **{value}** is workable but could be optimized. Shaft angle at address affects swing plane, ball flight direction, and contact quality. Minor adjustments to your setup could enhance consistency and shot quality."
-        else:
-            return f"Your shaft angle of **{value}** needs attention for better performance. Proper shaft angle at address is crucial for swing plane, ball flight control, and consistency. Improving shaft positioning will enhance accuracy and overall shot quality."
-    
-    elif "Head Sway" in metric_name:
+    elif metric_name == "Hip Depth / Early Extension":
         if "🟢" in badge:
-            return f"Your head movement of **{value}** shows excellent stability. Minimal head sway maintains consistent swing center, promoting solid contact and accuracy. Good head stability is crucial for distance control, precision, and repeatable ball striking."
+            return f"Your hip depth of **{value}** shows excellent posture maintenance. This indicates you're maintaining proper spine angle and avoiding early extension through impact. Good hip depth promotes solid contact, power transfer, and consistent ball striking patterns."
         elif "🟠" in badge:
-            return f"Your head movement of **{value}** is acceptable but could be improved. Some head movement affects swing center consistency and can influence contact quality. Reducing sway will enhance accuracy, distance control, and strike consistency."
+            return f"Your hip depth of **{value}** is acceptable but could be improved. This measurement indicates some early extension tendencies. Working on maintaining spine angle and hip position through impact can enhance consistency and power transfer."
         else:
-            return f"Your head movement of **{value}** indicates excessive sway. Too much head movement disrupts swing center, leading to inconsistent contact and accuracy issues. Improving head stability will enhance precision, distance control, and overall consistency."
+            return f"Your hip depth of **{value}** indicates early extension issues. This movement pattern reduces power transfer and can cause inconsistent contact. Focus on maintaining spine angle and proper hip position throughout the downswing and impact."
     
-    elif "Shoulder Rotation" in metric_name:
-        position = "top" if "Top" in metric_name else "impact"
-        if "🟢" in badge:
-            if position == "top":
-                return f"Your shoulder rotation of **{value}** at the top shows excellent turn. This full shoulder rotation creates proper swing width and sets up powerful clubhead speed generation. Great shoulder mobility contributes significantly to distance and consistency."
-            else:
-                return f"Your shoulder rotation of **{value}** at impact shows excellent unwinding. This proper rotation through impact promotes square contact, accuracy, and efficient power transfer to the ball."
-        elif "🟠" in badge:
-            return f"Your shoulder rotation of **{value}** is adequate but has room for improvement. Better shoulder rotation enhances swing width, power potential, and timing consistency."
-        else:
-            return f"Your shoulder rotation of **{value}** needs attention. Limited shoulder rotation restricts power generation and can affect swing plane consistency. Work on shoulder mobility and turn."
+    # Hip Turn @ Impact metric removed per user request
     
-    elif "Hip Rotation" in metric_name:
-        position = "top" if "Top" in metric_name else "impact"
+    # FRONT-FACING METRICS (4 current metrics)
+    elif metric_name == "Shoulder Tilt @ Impact":
         if "🟢" in badge:
-            if position == "top":
-                return f"Your hip rotation of **{value}** at the top shows excellent coil. This hip turn creates the foundation for powerful unwinding and proper kinematic sequencing from the ground up."
-            else:
-                return f"Your hip rotation of **{value}** at impact shows excellent clearing. This hip action leads the downswing sequence, creating space for the arms and promoting consistent ball striking."
+            return f"Your shoulder tilt of **{value}** at impact shows excellent position. This proper shoulder angle indicates ideal impact dynamics and power transfer. Good shoulder tilt at impact promotes solid contact, optimal ball flight, and consistent distance control."
         elif "🟠" in badge:
-            return f"Your hip rotation of **{value}** is solid with room for optimization. Improved hip rotation enhances power generation and sequence timing."
+            return f"Your shoulder tilt of **{value}** at impact is acceptable with room for improvement. Shoulder position at impact affects power transfer and ball flight characteristics. Refining your impact position can enhance consistency and distance."
         else:
-            return f"Your hip rotation of **{value}** needs development. Limited hip rotation restricts power potential and can disrupt proper swing sequence. Focus on hip mobility and turn."
+            return f"Your shoulder tilt of **{value}** at impact needs attention. Proper shoulder angle at impact is crucial for power transfer and ball flight control. Work on impact position for better contact and consistency."
     
-    elif "X-Factor" in metric_name:
-        position = "top" if "Top" in metric_name else "impact"
+    elif metric_name == "Hip Sway @ Top":
         if "🟢" in badge:
-            if position == "top":
-                return f"Your X-Factor of **{value}** at the top shows excellent separation. This differential between shoulder and hip rotation creates powerful coil energy that translates to clubhead speed and distance."
-            else:
-                return f"Your X-Factor of **{value}** at impact shows excellent sequence timing. This separation indicates proper unwinding sequence from hips to shoulders, optimizing power transfer and accuracy."
+            return f"Your hip sway of **{value}** at the top shows excellent stability. Minimal lateral movement maintains proper balance and swing center, promoting consistent contact and accuracy. This stable foundation supports powerful, controlled swings."
         elif "🟠" in badge:
-            return f"Your X-Factor of **{value}** is good with room for improvement. Better separation between shoulders and hips can enhance power generation and sequence efficiency."
+            return f"Your hip sway of **{value}** at the top shows moderate movement. Some lateral sway can affect balance and consistency. Working on stability and weight transfer can improve ball striking and accuracy."
         else:
-            return f"Your X-Factor of **{value}** needs attention. Limited separation reduces power potential and may indicate sequence timing issues. Work on creating more differential between hip and shoulder rotation."
+            return f"Your hip sway of **{value}** at the top indicates excessive lateral movement. Too much sway disrupts balance and swing center, leading to inconsistent contact. Focus on stability and proper weight transfer for better results."
     
-    elif "Wrist Hinge" in metric_name:
-        position = "top" if "Top" in metric_name else "impact"
+    elif metric_name == "Wrist Hinge @ Top":
         if "🟢" in badge:
-            if position == "top":
-                return f"Your wrist hinge of **{value}** at the top shows excellent set. This proper wrist angle stores energy and sets up lag for powerful release through impact."
-            else:
-                return f"Your wrist hinge of **{value}** at impact shows excellent lag retention. This delayed release maximizes clubhead speed and promotes solid ball compression."
+            return f"Your wrist hinge of **{value}** at the top shows excellent set. This proper wrist angle stores energy effectively and sets up lag for powerful release through impact. Good wrist hinge contributes significantly to clubhead speed and distance."
         elif "🟠" in badge:
-            return f"Your wrist hinge of **{value}** is adequate but could be optimized. Better wrist action enhances lag, power, and strike consistency."
+            return f"Your wrist hinge of **{value}** at the top is adequate but could be optimized. Better wrist action can enhance lag, power generation, and strike consistency. Work on wrist mobility and proper hinge timing."
         else:
-            if position == "top":
-                return f"Your wrist hinge of **{value}** at the top needs improvement. Proper wrist set is crucial for creating lag and power. Work on wrist mobility and hinge timing."
-            else:
-                return f"Your wrist hinge of **{value}** at impact suggests early release. Focus on maintaining lag longer through the downswing for more power and better ball compression."
+            return f"Your wrist hinge of **{value}** at the top needs improvement. Proper wrist set is crucial for creating lag and power. Limited wrist hinge reduces potential clubhead speed and distance. Focus on wrist mobility and hinge mechanics."
     
-    elif "Head Lateral Sway" in metric_name:
-        if "🟢" in badge:
-            return f"Your head lateral sway of **{value}** shows outstanding stability. Minimal head movement maintains consistent swing center and promotes precise ball contact, distance control, and accuracy."
-        elif "🟠" in badge:
-            return f"Your head lateral sway of **{value}** shows good control with minor movement. This level of head stability supports consistent contact while allowing natural body rotation."
-        else:
-            return f"Your head lateral sway of **{value}** indicates excessive movement. Too much head sway disrupts swing center consistency, leading to contact issues and directional problems. Focus on head stability."
     
     else:
         # Default evaluation for any other metrics
@@ -1345,19 +1331,21 @@ Swing Phases:
 Timing Metrics:
 - Total Swing Time: {structured_analysis.get('timing_metrics', {}).get('total_swing_time_ms', 'N/A')} ms
 
-=== DTL-RELIABLE CORE METRICS ===
-- Shaft Angle @ Top: {format_metric_value(core_metrics.get('shaft_angle_top', {}), '°')}
-- Head Sway: {format_metric_value(core_metrics.get('head_sway_pct', {}), '% shoulder width')}
+=== DTL METRICS ===
+- Shoulder Tilt/Swing Plane @ Top: {format_metric_value(core_metrics.get('shoulder_tilt_swing_plane_top_deg', {}), '°')}
 - Back Tilt @ Setup: {format_metric_value(core_metrics.get('back_tilt_deg', {}), '°')}
-- Knee Bend @ Setup: {format_metric_value(core_metrics.get('knee_bend_deg', {}), '°')}
-- Wrist Pattern: {format_metric_value(core_metrics.get('wrist_pattern', {}))}
+- Knee Flexion @ Setup: {format_metric_value(core_metrics.get('knee_flexion_deg', {}), '°')}
+- Hip Depth / Early Extension: {format_metric_value(core_metrics.get('hip_depth_early_extension', {}), '%')}
+# Hip Turn @ Impact metric removed per user request
 
 === DTL-LIMITED METRICS (Approximate) ===
 - Shoulder Turn Quality: {format_metric_value(core_metrics.get('shoulder_turn_quality', {}))}
 
-=== REQUIRES FACE-ON VIEW ===
-- 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', {}), '°')}
+=== FRONT-FACING METRICS ===
+- Shoulder Tilt @ Impact: {format_metric_value(core_metrics.get('shoulder_tilt_impact_deg', {}), '°')}
+# Hip Turn @ Impact metric removed per user request
+- Hip Sway @ Top: {format_metric_value(core_metrics.get('hip_sway_top_inches', {}), '"')}
+- Wrist Hinge @ Top: {format_metric_value(core_metrics.get('wrist_hinge_top_deg', {}), '°')}
 """
             
             # Removed success message
@@ -1591,17 +1579,7 @@ def generate_enhanced_fallback_response(query, context_chunks, user_swing_contex
                         found_relevant_measurement = True
                         break
                         
-        elif "hip" in question_lower and ("rotation" in question_lower or "turn" in question_lower):
-            # Look for hip rotation measurements (only if asking about hip rotation/turn)
-            lines = analysis_content.split('\n')
-            for line in lines:
-                if 'hip rotation' in line.lower() and '°' in line:
-                    import re
-                    user_hip_match = re.search(r'-\s*hip rotation[:\s]*(\d+\.?\d*°)', line.lower())
-                    if user_hip_match:
-                        response_parts.append(f"I notice that your hip rotation is {user_hip_match.group(1)} during your swing.")
-                        found_relevant_measurement = True
-                        break
+        # Hip rotation question handling removed per user request
                         
         elif "weight" in question_lower and ("transfer" in question_lower or "shift" in question_lower):
             # Look for weight transfer measurements (only if asking about weight transfer/shift)
@@ -1725,14 +1703,6 @@ def main():
         font-weight: bold;
     }
     
-
-    
-
-    
-
-    
-
-    
     /* Fix text color visibility for mobile and all devices - EXCEPT buttons */
     .stMarkdown, .stMarkdown p, .stMarkdown h1, .stMarkdown h2, .stMarkdown h3, .stMarkdown h4 {
         color: #0B3B0B !important;
@@ -1919,20 +1889,37 @@ def render_step_1():
     st.markdown('<h2 style="color: #0B3B0B; font-family: Georgia, serif;">Step 1: Upload Your Video</h2>', unsafe_allow_html=True)
     
     # Camera view selection
-    st.markdown("### 📹 Select Camera View")
+    st.markdown("### 📹 Select Camera View <span style='color: red;'>*</span>", unsafe_allow_html=True)
     camera_view = st.radio(
         "Choose the camera angle of your video:",
-        options=["Down the Line (DTL)", "Front Facing (Face-On)"],
-        index=0,  # Default to DTL
+        options=["", "Down the Line (DTL)", "Front Facing (Face-On)"],
+        index=0,  # Default to empty selection
         key="camera_view",
         horizontal=True,
         help="DTL: Camera positioned behind/in front of golfer along target line. Face-On: Camera positioned to the side of golfer."
     )
     
+    # Show validation message if no camera view selected
+    if not camera_view or camera_view == "":
+        st.warning("⚠️ Please select a camera view to continue.")
+    
+    # Club selection (always show)
+    st.markdown("### ⛳ Club Type")
+    club_type = st.radio(
+        "Select club type for accurate grading:",
+        options=["iron", "driver"],
+        index=0,  # Default to iron
+        key="club_type_selector",
+        horizontal=True,
+        help="Driver allows more hip rotation than irons. This affects grading thresholds for optimal swing metrics."
+    )
+    # Store in session state
+    st.session_state.club_type = club_type
+    
     st.markdown("**Choose your input method below.**")
     st.markdown("💡 **Tips:**")
     st.markdown("- Aim for a video of 5 seconds or less")
-    st.markdown("- Make sure the video is in a down the line view, not face forward")
+    st.markdown("- Select the correct camera view above for accurate analysis")
     
     col1, col2 = st.columns(2)
     
@@ -1948,6 +1935,11 @@ def render_step_1():
     
     # Analyze button
     if st.button("🏌️ Start Analysis", key="start_analysis", use_container_width=True):
+        # Validate camera view selection
+        if not camera_view or camera_view == "":
+            st.error("⚠️ Please select a camera view before starting analysis.")
+            return
+            
         video_path = None
         
         if uploaded_file is not None:
@@ -1996,7 +1988,7 @@ def render_step_2():
                 st.success("✅ Video processing complete!")
 
             with st.spinner("Analyzing golfer's pose..."):
-                pose_data = analyze_pose(frames)
+                pose_data, world_landmarks = analyze_pose(frames)
                 st.success("✅ Pose analysis complete!")
 
             with st.spinner("Segmenting swing phases..."):
@@ -2022,6 +2014,7 @@ def render_step_2():
                 'frames': frames,
                 'detections': detections,
                 'pose_data': pose_data,
+                'world_landmarks': world_landmarks,
                 'swing_phases': swing_phases,
                 'trajectory_data': trajectory_data,
                 'sample_rate': 1,
@@ -2116,9 +2109,12 @@ def render_step_4():
         camera_view = st.session_state.analysis_data.get('camera_view', 'Down the Line (DTL)')
         is_front_facing = camera_view == "Front Facing (Face-On)"
         
+        # Get club selection from session state (set in Step 1)
+        club_selection = st.session_state.get('club_type', 'iron')
+        
         # Force recomputation with new validation logic  
         # This ensures the latest fixes are applied
-        core_metrics = compute_core_metrics(pose_data, swing_phases, is_front_facing=is_front_facing, frames=data.get('frames'))
+        core_metrics = compute_core_metrics(pose_data, swing_phases, is_front_facing=is_front_facing, frames=data.get('frames'), world_landmarks=data.get('world_landmarks'), club=club_selection)
         
         # Update the cached analysis data with new metrics
         if 'analysis_data' in data:
@@ -2190,29 +2186,27 @@ def render_step_4():
                     st.caption("Raw values for qualitative assessments:")
                     
                     # Shaft angle raw value
-                    shaft_raw = core_metrics.get("shaft_angle_top", {}).get('value')
-                    shaft_status = core_metrics.get("shaft_angle_top", {}).get('status', 'n/a')
-                    st.caption(f"Shaft Angle @ Top: {shaft_raw}° ({shaft_status})")
-                    
-                    # Hip rotation raw value  
-                    hip_raw = core_metrics.get("hip_rotation_impact_deg", {}).get('value')
-                    hip_status = core_metrics.get("hip_rotation_impact_deg", {}).get('status', 'n/a')
-                    st.caption(f"Hip Rotation @ Impact: {hip_raw}° ({hip_status})")
-                    
-                    # X-factor raw value (bonus)
-                    xfactor_raw = core_metrics.get("x_factor_top_deg", {}).get('value')
-                    xfactor_status = core_metrics.get("x_factor_top_deg", {}).get('status', 'n/a')
-                    st.caption(f"X-Factor @ Top: {xfactor_raw}° ({xfactor_status})")
+                    shoulder_swing_plane_raw = core_metrics.get("shoulder_tilt_swing_plane_top_deg", {}).get('value')
+                    shoulder_swing_plane_status = core_metrics.get("shoulder_tilt_swing_plane_top_deg", {}).get('status', 'n/a')
+                    st.caption(f"Shoulder Tilt/Swing Plane @ Top: {shoulder_swing_plane_raw}° ({shoulder_swing_plane_status})")
                     
                     # Shoulder rotation raw value
-                    shoulder_raw = core_metrics.get("shoulder_rotation_top_deg", {}).get('value')
-                    shoulder_status = core_metrics.get("shoulder_rotation_top_deg", {}).get('status', 'n/a')
-                    st.caption(f"Shoulder Rotation @ Top: {shoulder_raw}° ({shoulder_status})")
+                    shoulder_tilt_raw = core_metrics.get("shoulder_tilt_impact_deg", {}).get('value')
+                    shoulder_tilt_status = core_metrics.get("shoulder_tilt_impact_deg", {}).get('status', 'n/a')
+                    st.caption(f"Shoulder Tilt @ Impact: {shoulder_tilt_raw}° ({shoulder_tilt_status})")
+                    
+                    # Hip turn data removed per user request
                     
                     # Hip depth raw value
                     hip_depth_raw = core_metrics.get("hip_depth_early_extension", {}).get('value')
                     hip_depth_status = core_metrics.get("hip_depth_early_extension", {}).get('status', 'n/a')
                     st.caption(f"Hip Depth / Early Extension: {hip_depth_raw} ({hip_depth_status})")
+                    
+                    # Hip turn debug info removed per user request
+                    if has_front_facing_metrics:
+                        st.caption("Front-facing metrics detected")
+                    else:
+                        st.caption("DTL metrics detected")
         
         with dev_col3:
             if st.button("🔍 Prompt", key="show_prompt_btn", help="View LLM prompt"):
@@ -2235,7 +2229,7 @@ def render_step_5():
     has_analysis = st.session_state.get('video_analyzed', False) and 'analysis_data' in st.session_state
     
     if not has_analysis:
-        st.info("💡 **Tip**: For personalized answers about your swing, complete the video analysis first. You can still ask general golf questions!")
+        st.info("💡 For personalized answers about your swing, complete the video analysis first. You can still ask general golf questions!")
     
     if RAG_AVAILABLE:
         render_rag_interface()