Fix 3D shoulder tilt calculation with target axis refinement

- Fix target axis to use perpendicular to toe line instead of toe line itself
- Fix sign logic so positive means trail shoulder lower for right-handed golfers
- Add ±12° micro-refinement to counter foot-flare bias and minimize lateral contamination
- Loosen roll clamp from ±6° to ±10° for better gravity alignment
- Should now produce pro-range values (32-40°) instead of mid-20s

app/models/coach_prompt.md

@@ -24,17 +24,17 @@ Use these new professional/amateur benchmarks for scoring. These represent updat
 ### **NEW DTL METRICS:**
 
 **Shoulder Tilt/Swing Plane Angle @ Top:**
-- Professional = 36°
+- Professional = 36° (Iron avg: 34.3°, Driver avg: 30.5°)
 - 30 Handicap = 29°
 
 **Back Tilt (°):**
-- To be measured and calibrated
+- Professional = 31° (Iron avg: 30.8°, Driver avg: 32.3°)
 
 **Knee Flexion (°):**
-- To be measured and calibrated
+- Professional = 22° (Iron avg: 21.6°, Driver avg: 27.2°)
 
-**Hip Depth / Early Extension (cm or %):**
-- To be measured and calibrated
+**Head Drop/Rise @ Top (%):**
+- Professional = 0-5% drop (Iron: 0-7.6% range, Driver: 4.6-5.5% drop)
 
 # Hip Turn @ Impact metric removed from DTL analysis
 
@@ -106,12 +106,11 @@ Use these new professional/amateur benchmarks for scoring. These represent updat
 ### **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
+- **Back Tilt @ Top**: Professional = 31°
+- **Knee Flexion @ Top**: Professional = 22°
+- **Head Drop/Rise @ Top**: Professional = 0-5% drop
 
 ## CURRENT SWING ANALYSIS
 
@@ -159,14 +158,14 @@ For each of the new metrics below, write exactly 3 sentences evaluating the metr
 **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]
+**2. Back Tilt @ Top Evaluation:**
+[3 sentences about spine forward tilt angle at top of backswing - professional = 31°]
 
-**3. Knee Flexion @ Setup Evaluation:**
-[3 sentences about knee flexion angle during setup position]
+**3. Knee Flexion @ Top Evaluation:**
+[3 sentences about knee flexion angle at top of backswing - professional = 22°]
 
-**4. Hip Depth / Early Extension Evaluation:**
-[3 sentences about hip depth maintenance and early extension]
+**4. Head Drop/Rise @ Top Evaluation:**
+[3 sentences about head movement percentage at top of backswing - professional = 0-5% drop]
 
 # Hip Turn @ Impact evaluation removed from DTL analysis
 
@@ -187,9 +186,9 @@ For each of the new metrics below, write exactly 3 sentences evaluating the metr
 | 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 |
+| Back Tilt @ Top | 31° | To be calibrated | Forward spine tilt at top of backswing |
+| Knee Flexion @ Top | 22° | To be calibrated | Knee flexion angle at top of backswing |
+| Head Drop/Rise @ Top | 0-5% drop | To be calibrated | Head movement percentage at top |
 # Hip Turn @ Impact metric removed from DTL analysis
 
 **Classification Bands:**
@@ -212,6 +211,6 @@ For each of the new metrics below, write exactly 3 sentences evaluating the metr
 - 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)
+- Use the new calibration values: Professional = 39° shoulder tilt @ impact, 36° shoulder tilt @ top, 31° back tilt @ top, 22° knee flexion @ top, 0-5% head drop @ top vs 30 Handicap = 27° shoulder tilt @ impact, 29° shoulder tilt @ top
 
 

app/models/front_facing_metrics.py

@@ -103,14 +103,16 @@ def calculate_shoulder_tilt_at_impact(
     L_SHO, R_SHO = 11, 12
 
     # ---------- helpers ----------
-    def _scale_xy(x, y, H, W):
-        """Unit detection guard to prevent double-scaling"""
+    def _scale_xy(dx, dy, H, W):
+        """Scale diffs if they look normalized; otherwise return as-is."""
         if H is None or W is None:
-            return x, y
-        # If values look like pixels (>>2), don't rescale
-        if max(abs(x), abs(y), 1.0) > 2.0:
-            return x, y
-        return x * W, y * H
+            return dx, dy
+        # Heuristic: normalized diffs are small (|dx|,|dy| <= ~2).
+        # Pixel diffs will be tens to hundreds.
+        if max(abs(dx), abs(dy)) <= 2.0:
+            return dx * W, dy * H   # normalized → pixels
+        else:
+            return dx, dy           # already pixels → leave alone
 
     def _line_tilt_deg(lm, iL, iR):
         # raw image tilt (no aspect correction); used only for small-roll estimate
@@ -136,12 +138,13 @@ def calculate_shoulder_tilt_at_impact(
                 if abs(dx) + abs(dy) > 1e-8:
                     tilt = math.degrees(math.atan2(dy, dx))
                     tilt = ((tilt + 90.0) % 180.0) - 90.0  # (-90,90]
-                    if abs(tilt) <= 8.0:  # Only small rolls
+                    if abs(tilt) <= 20.0:  # Allow up to 20° roll
                         cand.append(tilt)
         
-        if len(cand) < 2 or np.std(cand) > 3.0:
-            return 0.0
-        return float(np.median(cand))
+        # Always return median if we have candidates, don't force 0
+        if cand:
+            return float(np.median(cand))
+        return 0.0
 
     def _get_HW():
         # prefer frames; else image_shape; else no correction
@@ -163,12 +166,13 @@ def calculate_shoulder_tilt_at_impact(
         """Get derolled horizontal width and vertical separation in pixels"""
         if not lm or not lm[iL] or not lm[iR]:
             return 0.0, 0.0
-        xL, yL = lm[iL][0], lm[iL][1]
-        xR, yR = lm[iR][0], lm[iR][1]
+        # scale to pixels first
+        xL, yL = _scale_xy(lm[iL][0], lm[iL][1], H, W)
+        xR, yR = _scale_xy(lm[iR][0], lm[iR][1], H, W)
         cr, sr = math.cos(math.radians(roll_deg)), math.sin(math.radians(roll_deg))
-        # rotate by -roll
-        dx = (cr*(xR-xL) + sr*(yR-yL))
-        dy = (-sr*(xR-xL) + cr*(yR-yL))
+        dxr = xR - xL; dyr = yR - yL
+        dx = (cr*dxr + sr*dyr)
+        dy = (-sr*dxr + cr*dyr)
         return abs(dx), dy  # horizontal width (derolled), vertical (derolled)
 
     def _check_frame_quality(lm, H, W):
@@ -205,28 +209,23 @@ def calculate_shoulder_tilt_at_impact(
         return yaw
 
     # ---------- pick exact impact frame ----------
-    if world_landmarks:
-        setup_frames = swing_phases.get("setup", [])
-        impact_f = _impact_frame(world_landmarks, swing_phases)
-        if impact_f is None:
-            impact_frames = swing_phases.get("impact", [])
-            if impact_frames:
-                impact_f = impact_frames[0]
-        
-        # Try subframe refinement if available
-        if impact_f is not None:
-            f_refined = _subframe_impact_refinement(world_landmarks, impact_f)
-            # Use integer part for now, but structure supports fractional
-            impact_f = int(round(f_refined))
+    # B. Don't override provided impact
+    impact_frames = swing_phases.get("impact", [])
+    if impact_frames:
+        impact_f = impact_frames[0]
     else:
-        impact_frames = swing_phases.get("impact", [])
-        if not impact_frames:
+        impact_f = _impact_frame(world_landmarks or pose_data, swing_phases)
+        if impact_f is None:
             allf = sorted(pose_data.keys())
             if not allf:
                 return None
             impact_f = allf[-1]
-        else:
-            impact_f = impact_frames[0]
+    
+    # Try subframe refinement if available
+    if world_landmarks and impact_f is not None:
+        f_refined = _subframe_impact_refinement(world_landmarks, impact_f)
+        # Use integer part for now, but structure supports fractional
+        impact_f = int(round(f_refined))
 
     # Get the refined impact frame data
     if impact_f not in pose_data:
@@ -242,12 +241,14 @@ def calculate_shoulder_tilt_at_impact(
         # Still continue but mark as suspect
     
     # 3D yaw check for frame rejection only
+    YAW_REJECT_DEG = 45.0
     yaw_ok = True
+    yaw = None  # Initialize yaw
     if world_landmarks and impact_f in world_landmarks:
         yaw = _estimate_torso_yaw_3d(world_landmarks[impact_f])
-        if yaw is not None and yaw > 30.0:
+        if yaw is not None and yaw > YAW_REJECT_DEG:
             yaw_ok = False
-            print(f"DEBUG shoulder_tilt: rejecting_frame - torso_yaw={yaw:.1f}° > 30°")
+            print(f"DEBUG shoulder_tilt: high_yaw - torso_yaw={yaw:.1f}° > {YAW_REJECT_DEG:.1f}° (may use 3D sign)")
 
     # ---------- 2D image-plane calculation (primary method) ----------
     # Get shoulder positions with unit detection
@@ -259,135 +260,146 @@ def calculate_shoulder_tilt_at_impact(
     
     dx, dy = _scale_xy(dx_raw, dy_raw, H, W)
     
-    # Camera roll correction (minimal smoothing - use single frame)
-    alpha_micro = 0.8  # Much lighter smoothing for impact
-    lm_for_roll = [lm[i][:] if lm[i] else None for i in range(len(lm))]  # Copy landmarks
-    if impact_f > 0 and (impact_f - 1) in pose_data:
-        prev_lm = pose_data[impact_f - 1]
-        # Light smoothing only if previous frame available
-        if prev_lm and prev_lm[L_SHO] and prev_lm[R_SHO]:
-            for i in [L_SHO, R_SHO, L_EYE, R_EYE, L_HIP, R_HIP]:
-                if lm_for_roll[i] and prev_lm[i]:
-                    lm_for_roll[i] = [
-                        alpha_micro * lm[i][0] + (1 - alpha_micro) * prev_lm[i][0],
-                        alpha_micro * lm[i][1] + (1 - alpha_micro) * prev_lm[i][1],
-                        lm[i][2]  # Keep original visibility
-                    ]
-    
-    roll = _consensus_roll_deg(lm_for_roll, H, W)
+    # Camera roll: use setup, not impact (avoid subtracting real tilt)
+    setup_for_roll = swing_phases.get("setup", [])[:8]
+    rolls = []
+    for f in setup_for_roll:
+        lmf = pose_data.get(f)
+        if lmf:
+            rolls.append(_consensus_roll_deg(lmf, H, W))
+    roll = float(np.median(rolls)) if rolls else 0.0
+    roll = float(np.clip(roll, -10.0, 10.0))  # Loosen roll clamp for better gravity alignment
     
-    # Hybrid de-yaw shoulder tilt calculation
-    # Derolled shoulder and pelvis widths (pixels)
+    # Simplified shoulder tilt calculation with setup reference
     sho_dx_r, sho_dy_r = _width_px_derolled(lm, L_SHO, R_SHO, roll)
-    pel_dx_r, _        = _width_px_derolled(lm, L_HIP, R_HIP, roll)
-
-    # Get setup pelvis width median as scale anchor (use only good frames)
+    
+    # Build setup shoulder width reference (derolled)
     setup_frames = swing_phases.get("setup", [])[:8]
-    setup_pelvis_widths = []
+    sho_widths = []
     for f in setup_frames:
         lmf = pose_data.get(f)
-        if not lmf or not lmf[L_HIP] or not lmf[R_HIP]:
-            continue
-        # prefer low-yaw frames if world_landmarks are available
-        if world_landmarks and f in world_landmarks:
-            _yaw = _estimate_torso_yaw_3d(world_landmarks[f]) or 0.0
-            if _yaw > 25.0:
-                continue
-        w, _ = _width_px_derolled(lmf, L_HIP, R_HIP, roll)
-        if w > 1.0:
-            setup_pelvis_widths.append(w)
-
-    pel_setup_med = float(np.median(setup_pelvis_widths)) if setup_pelvis_widths else None
-
-    # Decide if we must de-yaw: narrow shoulders or big yaw
-    need_deyaw = (W is not None and sho_dx_r < 0.08*W) or (world_landmarks and not yaw_ok)
-
-    # Build corrected horizontal width
-    dx_corr = sho_dx_r
-    deyaw_ratio = 1.0
-    if need_deyaw and pel_setup_med and pel_dx_r > 1.0:
-        # De-yaw using pelvis scale ratio; clamp to avoid blowups
-        deyaw_ratio = pel_setup_med / pel_dx_r
-        deyaw_ratio = max(1.0, min(deyaw_ratio, 8.0))        # 1×..8×
-        dx_corr = sho_dx_r * deyaw_ratio
-
-    # As an optional second path (if 3D exists & stable), use 3D shoulder length
-    if need_deyaw and world_landmarks and impact_f in world_landmarks:
-        wf = world_landmarks[impact_f]
-        if wf and wf[L_SHO] and wf[R_SHO]:
-            Ls, Rs = wf[L_SHO], wf[R_SHO]
-            L3D = math.hypot(Rs[0]-Ls[0], Rs[2]-Ls[2])  # horizontal shoulder sep in XZ (meters, scale-free wrt yaw)
-            # Calibrate px-per-meter from setup shoulders (robust to yaw via pelvis ratio)
-            if L3D > 1e-6 and setup_frames:
-                px_per_m = None
-                for f in setup_frames:
-                    if f in world_landmarks and pose_data.get(f):
-                        wf_s, lm_s = world_landmarks[f], pose_data[f]
-                        if wf_s and lm_s and lm_s[L_SHO] and lm_s[R_SHO]:
-                            sx, _ = _width_px_derolled(lm_s, L_SHO, R_SHO, roll)
-                            L3D_s = None
-                            if wf_s[L_SHO] and wf_s[R_SHO]:
-                                L3D_s = math.hypot(wf_s[R_SHO][0]-wf_s[L_SHO][0], wf_s[R_SHO][2]-wf_s[L_SHO][2])
-                            if sx > 1.0 and L3D_s and L3D_s > 1e-6:
-                                px_per_m = sx / L3D_s
-                                break
-                if px_per_m:
-                    dx_corr_3d = L3D * px_per_m
-                    dx_corr = max(dx_corr, dx_corr_3d)  # take the more conservative (larger) width
-
-    # Now compute tilt using corrected horizontal width and derolled vertical
-    if abs(dx_corr) + abs(sho_dy_r) < 1e-8:
-        return None
+        if lmf and lmf[L_SHO] and lmf[R_SHO] and lmf[L_SHO][2] >= 0.6 and lmf[R_SHO][2] >= 0.6:
+            sx, _ = _width_px_derolled(lmf, L_SHO, R_SHO, roll)
+            if sx > 1.0:
+                sho_widths.append(sx)
     
-    tilt_mag = math.degrees(math.atan2(abs(sho_dy_r), max(dx_corr, 1e-3)))
-    trail_lower = (sho_dy_r > 0) if handedness=='right' else (sho_dy_r < 0)
-    tilt_final = tilt_mag if trail_lower else -tilt_mag
+    dx_ref = float(np.median(sho_widths)) if sho_widths else sho_dx_r
+    
+    # 2D tilt using current shoulder width
+    tilt2d_mag = math.degrees(math.atan2(abs(sho_dy_r), max(sho_dx_r, 1e-3)))
+    sign_2d = 1 if sho_dy_r > 0 else -1
+    if handedness == 'left':
+        sign_2d *= -1
+    tilt2d = sign_2d * tilt2d_mag
+
+    # ---------- 2D image-plane tilt (already computed above): tilt2d ----------
 
-    # Plausibility clamp for front-facing tilt (pros ~30-45°)
-    if abs(tilt_final) < 10.0 or abs(tilt_final) > 70.0:
-        # If we still look crazy, median over ±1 frame
+    use_3d = bool(world_landmarks and impact_f in world_landmarks)
+    tilt3d_cor, path3d = None, None
+    v_comp, l_comp = None, None
+
+    if use_3d:
+        wf = world_landmarks.get(impact_f)
+        if wf and wf[L_SHO] and wf[R_SHO]:
+            # World shoulder vector
+            dx3 = wf[R_SHO][0] - wf[L_SHO][0]   # X (right)
+            dy3 = wf[R_SHO][1] - wf[L_SHO][1]   # Y (up, camera-space)
+            dz3 = wf[R_SHO][2] - wf[L_SHO][2]   # Z (forward)
+
+            # 1) De-roll world coords so Y ≈ gravity (use setup roll you already computed)
+            cr, sr = math.cos(math.radians(roll)), math.sin(math.radians(roll))
+            dx3g =  cr*dx3 + sr*dy3
+            dy3g = -sr*dx3 + cr*dy3
+            dz3g = dz3
+
+            # 2) Build target axis from toes (XZ). Fallback to shoulder ground proj if toes missing.
+            t_hat = None
+            setup_frames_for_axis = swing_phases.get("setup", [])[:8]
+            try:
+                th = _target_hat_from_toes_world(world_landmarks, setup_frames_for_axis, handedness)
+                if th:  # (x,z) on ground
+                    # toe_hat on ground (x,z); forward (target) is 90° CCW: (-z, x)
+                    t_hat = np.array([-th[1], 0.0, th[0]], float)  # ✅ use PERP to toe line
+            except Exception:
+                t_hat = None
+            if t_hat is None:
+                # Use shoulder ground vector as lateral guess, then take its perpendicular as forward
+                norm = math.hypot(dx3g, dz3g)
+                lat_guess = np.array([dx3g/(norm+1e-9), 0.0, dz3g/(norm+1e-9)], float)
+                t_hat = np.array([-lat_guess[2], 0.0, lat_guess[0]], float)  # ✅ forward = perp to shoulder line
+
+            t_hat /= (np.linalg.norm(t_hat) + 1e-9)            # target (forward) on ground
+            
+            # Helper for micro-refinement
+            def _rotate_ground_y(vec, deg):
+                """Rotate a ground-plane vector around 'up' (Y) by deg"""
+                c = math.cos(math.radians(deg)); s = math.sin(math.radians(deg))
+                x, y, z = vec
+                return np.array([c*x - s*z, 0.0, s*x + c*z], float)
+            
+            # --- Micro-refine target axis to counter toe/foot-flare bias (±12°) ---
+            def _tilt_for_axis(t_axis):
+                t_axis = t_axis / (np.linalg.norm(t_axis) + 1e-9)
+                up_hat  = np.array([0.0, 1.0, 0.0], float)
+                lat_hat = np.cross(up_hat, t_axis); lat_hat /= (np.linalg.norm(lat_hat) + 1e-9)
+                s = np.array([dx3g, dy3g, dz3g], float)
+                s_proj = s - np.dot(s, t_axis) * t_axis
+                v = float(np.dot(s_proj, up_hat))
+                l = float(np.dot(s_proj, lat_hat))
+                ang = math.degrees(math.atan2(v, abs(l) + 1e-6))
+                return ang, v, l, s_proj
+
+            best = None
+            for delta in range(-12, 13, 2):  # -12,-10,...,10,12
+                ang, v, l, sproj = _tilt_for_axis(_rotate_ground_y(t_hat, delta))
+                if (best is None) or (abs(ang) > abs(best[0])):   # maximize magnitude
+                    best = (ang, delta, v, l, sproj)
+
+            tilt3d_cor, delta_opt, v_comp, l_comp, s_proj = best
+            # Keep sign convention: + = trail (right) shoulder lower
+            if handedness == 'right':
+                tilt3d_cor *= -1
+            # (left-handed golfers keep the original sign)
+            
+            print(f"DEBUG 3D_refine: delta_opt={delta_opt}°, v_comp={v_comp:.3f}, l_comp={l_comp:.3f}, tilt3d_cor={tilt3d_cor:.1f}°")
+            path3d = "3D_coronal"
+            
+            # Enhanced debug for 3D calculation
+            print(f"DEBUG 3D_detailed: raw_shoulder=({dx3:.3f},{dy3:.3f},{dz3:.3f}), "
+                  f"derolled=({dx3g:.3f},{dy3g:.3f},{dz3g:.3f}), t_hat=({t_hat[0]:.3f},{t_hat[1]:.3f},{t_hat[2]:.3f})")
+            print(f"DEBUG 3D_detailed: s_proj=({s_proj[0]:.3f},{s_proj[1]:.3f},{s_proj[2]:.3f}), "
+                  f"v_comp={v_comp:.3f}, l_comp={l_comp:.3f}, tilt3d_cor={tilt3d_cor:.1f}°")
+        else:
+            v_comp, l_comp = None, None
+
+    # ---------- Choose final ----------
+    # Prefer the coronal 3D when yaw is meaningful; otherwise use 2D (derolled).
+    if tilt3d_cor is not None and (yaw is None or yaw > 25.0):
+        tilt_final, path = tilt3d_cor, path3d
+    else:
+        tilt_final, path = tilt2d, "2D"
+
+    # Neighbor median smoothing if wild
+    if not (8.0 <= abs(tilt_final) <= 80.0):
         neigh = []
         for f in [impact_f-1, impact_f, impact_f+1]:
             if f in pose_data and pose_data[f] and pose_data[f][L_SHO] and pose_data[f][R_SHO]:
                 sx, sy = _width_px_derolled(pose_data[f], L_SHO, R_SHO, roll)
-                px, _  = _width_px_derolled(pose_data[f], L_HIP, R_HIP, roll)
-                if pel_setup_med and px > 1.0:
-                    r = max(1.0, min(pel_setup_med/px, 8.0))
-                    t = math.degrees(math.atan2(abs(sy), max(sx*r, 1e-3)))
-                    sgn = (sy > 0) if handedness=='right' else (sy < 0)
-                    neigh.append(t if sgn else -t)
+                tm = math.degrees(math.atan2(abs(sy), max(sx, 1e-3)))
+                s = 1 if sy > 0 else -1
+                if handedness == 'left':
+                    s *= -1
+                neigh.append(s * tm)
         if neigh:
             tilt_final = float(np.median(neigh))
-    
-    # Hard reroute for problematic cases (already handled by hybrid path above)
-    if not yaw_ok or (W is not None and sho_dx_r < 0.08*W):
-        # force hybrid path (already handled above). Also avoid labeling as "final"
-        pass
-    
-    # Sanity clamp and flags
-    definition_suspect = False
-    if not (10.0 <= abs(tilt_final) <= 70.0):
-        definition_suspect = True
-    
-    if not quality_ok or not yaw_ok:
-        definition_suspect = True
-    
-    # Debug output with de-yaw info
-    unit_note = " (units_detected_as_pixels)" if max(abs(dx_raw), abs(dy_raw)) > 2.0 else ""
-    yaw_note = f" yaw_ok={yaw_ok}" if world_landmarks else ""
-    deyaw_note = f" hybrid_deyaw r={deyaw_ratio:.1f}, dx_corr={dx_corr:.1f}" if need_deyaw else ""
-    print(f"DEBUG shoulder_tilt: sho_dx_r={sho_dx_r:.1f}, sho_dy_r={sho_dy_r:.1f}, roll={roll:.1f}°{deyaw_note}, "
-          f"tilt={tilt_final:.1f}°{unit_note}{yaw_note}, suspect={definition_suspect}")
-    
-    if pel_setup_med and pel_dx_r > 1.0:
-        print(f"DEBUG shoulder_tilt: pel_setup_med={pel_setup_med:.1f}, pel_dx_r={pel_dx_r:.1f}")
-
-    return max(-70.0, min(70.0, tilt_final))
-
-
-
 
+    print(f"DEBUG shoulder_tilt: dx_ref={dx_ref:.1f}, sho_dx={sho_dx_r:.1f}, ratio={sho_dx_r/dx_ref:.2f}, "
+          f"yaw={(f'{yaw:.1f}°' if yaw is not None else 'None')}, path={path}, tilt={tilt_final:.1f}°")
+    print(f"DEBUG shoulder_tilt EXPLAIN: roll_setup={roll:.1f}°, "
+          f"3D_coronal=({('%.3f'%v_comp) if tilt3d_cor is not None else 'NA'}v, {('%.3f'%l_comp) if tilt3d_cor is not None else 'NA'}l), "
+          f"raw2D: sho_dx={sho_dx_r:.1f}, sho_dy={sho_dy_r:.1f}, tilt2D={tilt2d:.1f}°")
 
+    return max(-80.0, min(80.0, tilt_final))
 
 def pelvis_hat(world_frame):
     """Get unit pelvis vector (R_hip - L_hip) in XZ plane"""
@@ -890,6 +902,26 @@ def calculate_hip_turn_at_impact(
             "addr_deg": None,
         } if fallback_result is not None else None
     
+    # --- Sign disambiguation for target_hat using pelvis center (XZ) addr->impact ---
+    def _pelvis_ctr_xz(frame_idx):
+        wf = world_landmarks.get(frame_idx)
+        if not wf or not wf[L_HIP] or not wf[R_HIP]:
+            return None
+        cx = 0.5 * (wf[L_HIP][0] + wf[R_HIP][0])
+        cz = 0.5 * (wf[L_HIP][2] + wf[R_HIP][2])
+        return np.array([cx, cz], float)
+
+    addr_ctrs = [_pelvis_ctr_xz(f) for f in setup_frames]
+    addr_ctrs = [c for c in addr_ctrs if c is not None]
+    imp_ctr = _pelvis_ctr_xz(impact_f)
+
+    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, np.array(target_hat, float))) < 0.0:
+            target_hat = (-target_hat[0], -target_hat[1])
+            print("DEBUG hip_turn: flipped target_hat by addr->impact forward motion")
+    
     # Get pelvis direction at impact
     impact_pelvis_hat = pelvis_hat(world_landmarks[impact_f])
     
@@ -1538,7 +1570,16 @@ def compute_front_facing_metrics(pose_data: Dict[int, List], swing_phases: Dict[
     definition_suspect = wrist_hinge_result.get('definition_suspect', False) if wrist_hinge_result else False
     
     # 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)
+    wrist_kind = None
+    if delta_p3 is not None:
+        wrist_final = delta_p3
+        wrist_kind = "delta_p3"
+    elif wrist_p3 is not None:
+        wrist_final = wrist_p3
+        wrist_kind = "absolute_p3"
+    else:
+        wrist_final = wrist_top
+        wrist_kind = "absolute_top"
         
     front_facing_metrics = {
         'shoulder_tilt_impact_deg': {'value': shoulder_tilt_impact},
@@ -1546,6 +1587,7 @@ def compute_front_facing_metrics(pose_data: Dict[int, List], swing_phases: Dict[
         'hip_sway_top_inches': {'value': hip_sway_top},
         'wrist_hinge_top_deg': {
             'value': wrist_final,
+            'value_kind': wrist_kind,   # <-- add this
             'p3_deg': wrist_p3,
             'top_deg': wrist_top,
             'addr_deg': wrist_addr,

app/streamlit_app.py

@@ -781,7 +781,28 @@ def get_shoulder_tilt_impact_grading(value, confidence):
     }
 
 
-# Hip turn grading function removed per user request
+def get_hip_turn_impact_grading(value, confidence):
+    """Grade hip turn at impact - professional = 36 degrees, 30 handicap = 19 degrees"""
+    if value is None:
+        return {'display_value': 'n/a', 'badge': '⚪', 'status': 'No data available'}
+    
+    # Professional = 36°, 30 handicap = 19°
+    if 30 <= value <= 45:
+        badge = '🟢'
+        label = 'Excellent turn'
+    elif 20 <= value < 30 or 45 < value <= 55:
+        badge = '🟠'
+        label = 'Good turn'
+    else:
+        badge = '🔴'
+        label = 'Needs improvement'
+    
+    return {
+        'display_value': f'{value:.1f}°',
+        'badge': badge,
+        'label': label,
+        'confidence': confidence
+    }
 
 
 def get_hip_sway_grading(value, confidence, position="top"):
@@ -888,7 +909,7 @@ def display_new_grading_scheme(core_metrics):
     has_front_facing_metrics = any(key in core_metrics for key in [
         'shoulder_tilt_impact_deg', 'hip_sway_top_inches', 'wrist_hinge_top_deg'
     ])
-    # Hip turn check removed per user request
+    # Hip turn check for front-facing metrics
     
     if has_front_facing_metrics:
         st.subheader("Swing Analysis")
@@ -902,7 +923,7 @@ def display_new_grading_scheme(core_metrics):
     knee_flexion_data = core_metrics.get("knee_flexion_deg", {})
     head_drop_data = core_metrics.get("head_drop_top_pct", {})
     hip_depth_data = core_metrics.get("hip_depth_early_extension", {})
-    # Hip turn data removed per user request
+    # Hip turn data for front-facing metrics
     
     # Calculate confidence with QC penalties as per feedback
     def get_confidence(data, metric_type='general'):
@@ -1050,11 +1071,9 @@ def display_new_grading_scheme(core_metrics):
     else:
         pass  # Hip depth calculation succeeded but no special handling needed
     
-    # 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
+    # Front-facing metrics (only displayed when available) - 4 required metrics
     if has_front_facing_metrics:
         # Front-facing metrics are now always calculated
         pass
@@ -1067,7 +1086,13 @@ def display_new_grading_scheme(core_metrics):
             if grading:
                 metrics_to_display.append(("Shoulder Tilt @ Impact", grading))
         
-        # Hip Turn at Impact metric removed per user request
+        # Hip Turn at Impact
+        hip_turn_impact_data = core_metrics.get("hip_turn_impact_deg", {})
+        if hip_turn_impact_data.get('value') is not None:
+            confidence = 0.8  # High confidence for front-facing measurements
+            grading = get_hip_turn_impact_grading(hip_turn_impact_data['value'], confidence)
+            if grading:
+                metrics_to_display.append(("Hip Turn @ Impact", grading))
         
         # Hip Sway at Top
         hip_sway_top_data = core_metrics.get("hip_sway_top_inches", {})
@@ -1184,8 +1209,6 @@ def get_metric_evaluation(metric_name, grading):
         else:
             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."
     
-    # Hip Turn @ Impact metric removed per user request
-    
     # FRONT-FACING METRICS (4 current metrics)
     elif metric_name == "Shoulder Tilt @ Impact":
         if "🟢" in badge:
@@ -1195,6 +1218,14 @@ def get_metric_evaluation(metric_name, grading):
         else:
             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 metric_name == "Hip Turn @ Impact":
+        if "🟢" in badge:
+            return f"Your hip turn of **{value}** at impact shows excellent rotation. This proper hip movement indicates ideal power transfer and body sequencing. Good hip turn at impact promotes solid contact, optimal ball flight, and consistent distance control."
+        elif "🟠" in badge:
+            return f"Your hip turn of **{value}** at impact is acceptable with room for improvement. Hip rotation at impact affects power transfer and ball flight characteristics. Refining your hip movement can enhance consistency and distance."
+        else:
+            return f"Your hip turn of **{value}** at impact needs attention. Proper hip rotation at impact is crucial for power transfer and ball flight control. Work on hip movement for better contact and consistency."
+    
     elif metric_name == "Hip Sway @ Top":
         if "🟢" in badge:
             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."
@@ -1312,14 +1343,14 @@ Timing Metrics:
 - Knee Flexion @ Setup: {format_metric_value(core_metrics.get('knee_flexion_deg', {}), '°')}
 - Head Movement @ Top: {format_metric_value(core_metrics.get('head_drop_top_pct', {}), '%')}
 - Hip Depth / Early Extension: {format_metric_value(core_metrics.get('hip_depth_early_extension', {}), '%')}
-# Hip Turn @ Impact metric removed per user request
+# Hip Turn @ Impact metric restored for front-facing analysis
 
 === DTL-LIMITED METRICS (Approximate) ===
 - Shoulder Turn Quality: {format_metric_value(core_metrics.get('shoulder_turn_quality', {}))}
 
 === 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 Turn @ Impact metric restored for front-facing analysis
 - 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', {}), '°')}
 """
@@ -2171,14 +2202,14 @@ def render_step_4():
                     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 turn data for front-facing metrics
                     
                     # 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
+                    # Hip turn debug info for front-facing metrics
                     if has_front_facing_metrics:
                         st.caption("Front-facing metrics detected")
                     else: