Fix head drop DTL metric and clean up feedback interface

- Fix head drop DTL metric sign and labeling logic
- Change metric name from 'Head Drop @ Top' to 'Head Movement @ Top'
- Implement proper direction display (drop/rise) and absolute value grading
- Apply suggested rubric: ≤3% excellent, 3-6% good, 6-10% borderline, >10% excessive
- Remove tips and confidence percentages from feedback interface
- Clean up all grading functions to remove tip generation
- Simplify metric display to show only essential information

app/models/llm_analyzer.py

@@ -47,6 +47,23 @@ except ImportError:
         return {'value': value, 'status': 'n/a', 'badge': '⚪'}
     def get_wrist_hinge_grading(value, confidence, position):
         return {'value': value, 'status': 'n/a', 'badge': '⚪'}
+    def get_head_drop_grading(value, confidence):
+        """Grade head drop metric based on percentage of torso length
+        
+        Args:
+            value: percentage value (positive = head moved down)
+            confidence: confidence score (not used in current implementation)
+        """
+        if value is None:
+            return {'value': None, 'status': 'error', 'badge': '❌'}
+        
+        # Address → Top: ~2–6% typical; >8% = too much "sit"
+        if 2 <= value <= 6:
+            return {'value': f"{value:.1f}%", 'status': 'good', 'badge': '✅'}
+        elif 6 < value <= 8:
+            return {'value': f"{value:.1f}%", 'status': 'caution', 'badge': '⚠️'}
+        else:
+            return {'value': f"{value:.1f}%", 'status': 'poor', 'badge': '❌'}
 
 
 def safe_fmt_deg(v):
@@ -184,6 +201,7 @@ def compute_dtl_core_metrics(pose_data, swing_phases, frame_timestamps_ms=None,
             '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),
+            'head_drop_top_pct': ('head_drop_top_pct', get_head_drop_grading),
             # Hip turn mapping removed per user request
         }
         

app/models/metrics_calculator.py

@@ -14,15 +14,68 @@ L_EYE, R_EYE = 2, 5
 L_EAR, R_EAR = 7, 8
 NOSE = 0
 
+# Shoulder and hip landmark indices for torso length calculation
+L_SHO, R_SHO = 11, 12
+L_HIP, R_HIP = 23, 24
+
 # Enable debug output for head height calculations
 VERBOSE = True
 
+# Minimum pixels per inch threshold for reliable scale detection
+MIN_PX_PER_IN = 2.5  # anything below this is unreliable (DTL foreshortening, wide shot, etc.)
+
 def dbg(msg):
     """Debug print helper"""
     if VERBOSE:
         print(f"[DEBUG] {msg}")
 
 
+def _midy(lm, a, b): 
+    """Calculate midpoint y coordinate between two landmarks"""
+    if (lm is None or a >= len(lm) or b >= len(lm) or 
+        lm[a] is None or lm[b] is None or 
+        len(lm[a]) < 2 or len(lm[b]) < 2):
+        return None
+    return 0.5 * (lm[a][1] + lm[b][1])
+
+
+def _torso_len_px(lm):
+    """Calculate torso length in pixels from shoulder to hip midpoint"""
+    y_sho = _midy(lm, L_SHO, R_SHO)
+    y_hip = _midy(lm, L_HIP, R_HIP)
+    if y_sho is None or y_hip is None:
+        return None
+    return abs(y_sho - y_hip)
+
+
+def safe_inch_scale_from_shoulders(lm, assumed_shoulder_in=15.5):
+    """Calculate inch scale from shoulders with safety checks for DTL foreshortening
+    
+    Args:
+        lm: pose landmarks for a single frame
+        assumed_shoulder_in: assumed shoulder width in inches (default 15.5")
+        
+    Returns:
+        tuple: (px_per_in, error_reason) where error_reason is None if successful
+    """
+    # DTL shoulders are foreshortened → this often returns too small; guard with MIN_PX_PER_IN
+    try:
+        if (lm is None or R_SHO >= len(lm) or L_SHO >= len(lm) or 
+            lm[R_SHO] is None or lm[L_SHO] is None or
+            len(lm[R_SHO]) < 2 or len(lm[L_SHO]) < 2):
+            return None, "no-shoulders"
+        
+        sw_px = ((lm[R_SHO][0] - lm[L_SHO][0])**2 + (lm[R_SHO][1] - lm[L_SHO][1])**2) ** 0.5
+    except Exception:
+        return None, "no-shoulders"
+    if sw_px <= 0:
+        return None, "zero-width"
+    px_per_in = sw_px / float(assumed_shoulder_in)
+    if px_per_in < MIN_PX_PER_IN:
+        return None, f"foreshortened (px/in={px_per_in:.2f})"
+    return px_per_in, None
+
+
 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.
@@ -318,26 +371,23 @@ def _median_head_y(frames_lm, idx, k=5, vis_thr=0.5):
     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.
+def head_height_change_normalized(frames_lm, addr_idx, top_idx, 
+                                  assumed_shoulder_in=15.5, vis_thr=0.5):
+    """Calculate head drop at top using normalized DTL metrics (percentage of torso length)
     
-    This measures head stability during the swing - positive values mean head moved DOWN.
+    This measures head drop during the backswing using torso length as the scale,
+    which is stable in DTL view unlike shoulder width which suffers from foreshortening.
     
     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
+        top_idx: top of backswing frame index
+        assumed_shoulder_in: assumed shoulder width in inches for fallback inch calculation
         vis_thr: visibility threshold
         
     Returns:
-        float: head change from address to impact in inches (positive = moved DOWN)
+        dict: Head drop data with percentages and optional inches
     """
-    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
@@ -345,53 +395,57 @@ def head_height_change(frames_lm, addr_idx, top_idx, imp_idx, inch_scale, vis_th
         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)")
     
+    # Get median head y's (existing helpers)
     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_top):
+        return {"ok": False, "reason": "head-visibility"}
+
+    lm_addr = frames_lm[addr_idx]
+    tlen = _torso_len_px(lm_addr)
+    if tlen is None or tlen <= 1:
+        return {"ok": False, "reason": "torso-too-small"}
+
+    # Primary: percentage (DTL-safe)
+    drop_top_pct = 100.0 * (y_top - y_addr) / tlen
+
+    # Secondary: inches only if scale is safe
+    px_per_in, why = safe_inch_scale_from_shoulders(lm_addr, assumed_shoulder_in)
+    inches = None
+    if px_per_in:
+        drop_top_in = (y_top - y_addr) / px_per_in
+        inches = drop_top_in
 
-    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
+    return {
+        "ok": True,
+        "drop_top_pct": drop_top_pct,
+        "inches": inches  # may be None if scale is unsafe
+    }
+
+
+def head_height_change(frames_lm, addr_idx, top_idx, imp_idx, inch_scale, vis_thr=0.5):
+    """DEPRECATED - use head_height_change_normalized instead
     
-    # Also calculate top drop for debug info
-    drop_top_in = (y_top - y_addr) / inch_scale if y_top is not None else None
+    This function is kept for backward compatibility but will use the new normalized implementation.
+    Note: imp_idx parameter is ignored as we only calculate head drop at top now.
+    """
+    # Use the new normalized function (ignoring imp_idx)
+    result = head_height_change_normalized(frames_lm, addr_idx, top_idx, 
+                                         assumed_shoulder_in=15.5, vis_thr=vis_thr)
     
-    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)")
+    if not result["ok"]:
+        return None
     
-    # 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")
+    # Return the head drop in inches for backward compatibility
+    if result["inches"] is not None:
+        return result["inches"]  # drop_top_in
     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
+        # Fallback: convert percentage to approximate inches using torso length
+        # This is less accurate but maintains backward compatibility
+        return None
 
 
 def calculate_inch_scale_from_shoulders(pose_data, address_idx, frame_w=None, frame_h=None, assumed_shoulder_width_in=15.5):
@@ -1384,13 +1438,14 @@ def validate_metric_ranges(metrics):
 
 
 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
+    """Compute DTL metrics with normalized head drop using torso length scale
     
     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)
+    - Head drop at top (percentage of torso length)
+    - Legacy inch metrics (only when scale is reliable, otherwise None)
     
     Args:
         pose_data (dict): Dictionary mapping frame indices to pose keypoints
@@ -1401,7 +1456,7 @@ def compute_dtl_three(pose_data, swing_phases, frame_w, frame_h, frames=None, ca
         camera_side (str): "trail" or "lead" - which side camera is on
         
         Returns:
-        dict: DTL metrics including head height change (replaces hip turn)
+        dict: DTL metrics with normalized head drop (replaces hip turn)
     """
     setup_frames = swing_phases.get("setup", [])
     backswing_frames = swing_phases.get("backswing", [])
@@ -1424,14 +1479,27 @@ def compute_dtl_three(pose_data, swing_phases, frame_w, frame_h, frames=None, ca
     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)
+    # Calculate head drop using normalized DTL metrics
+    head_drop_data = head_height_change_normalized(
+        pose_data, addr_idx, top_idx
+    )
+    
+    # Extract metrics from normalized data
+    head_drop_top_pct = None
     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
-        )
+    inch_scale = None
+    
+    if head_drop_data["ok"]:
+        head_drop_top_pct = head_drop_data["drop_top_pct"]
+        
+        # Get inch values if available
+        if head_drop_data["inches"] is not None:
+            head_height_change_in = head_drop_data["inches"]  # drop_top_in
+            # Calculate inch scale from the data for backward compatibility
+            if head_drop_data["inches"] != 0:  # avoid division by zero
+                pixel_change = _median_head_y(pose_data, top_idx) - _median_head_y(pose_data, addr_idx)
+                if pixel_change != 0:
+                    inch_scale = abs(pixel_change / head_drop_data["inches"])
     
     # Hip depth/early extension metric removed per user request
     ee_pct = None
@@ -1442,6 +1510,9 @@ def compute_dtl_three(pose_data, swing_phases, frame_w, frame_h, frames=None, ca
         "shoulder_plane_top_deg": shoulder_top,
         "back_tilt_setup_deg": back_tilt,
         "knee_flexion_deg": knee_avg,
+        # New normalized head drop metric (primary)
+        "head_drop_top_pct": round(head_drop_top_pct, 2) if head_drop_top_pct is not None else None,
+        # Legacy inch metrics (secondary, may be None if scale is unsafe)
         "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

app/streamlit_app.py

@@ -231,7 +231,6 @@ def get_shaft_angle_grading(value, confidence):
         'badge': badge,
         'label': label,
         'confidence': confidence,
-        'tip': "Target: within ±10° of the target line at the top." if badge != "🟢" else None
     }
 
 
@@ -263,7 +262,6 @@ def get_head_sway_grading(value, confidence):
         'label': label,
         'confidence': confidence,
         'approx': True,  # DTL-limited
-        'tip': "Aim ≤25% for most players." if value > 25 else None
     }
 
 
@@ -294,7 +292,6 @@ def get_back_tilt_grading(value, confidence, camera_roll=0):
         'label': label,
         'confidence': confidence,
         'status': label,  # Use label as status for legacy compatibility
-        'tip': "Typical tour range ≈30–40°." if badge != "🟢" else None
     }
 
 
@@ -338,8 +335,7 @@ def get_wrist_pattern_grading(pattern_data, confidence):
             'display_value': "Unstable",
             'badge': "⚪",
             'label': "club not visible",
-            'confidence': 0,
-            'tip': None
+            'confidence': 0
         }
     
     # Interpret pattern - prioritize actual pattern value over status
@@ -350,30 +346,24 @@ def get_wrist_pattern_grading(pattern_data, confidence):
     if pattern_value == 'set_hold_release':
         badge = "🟢"
         label = "Set-Hold-Release — Excellent"
-        tip = None
     elif pattern_value == 'early_cast' or status == 'early_cast':
         badge = "🔴"
         label = "Early Cast — Needs work"
-        tip = "Feel more lag; try the pump drill."
     elif pattern_value == 'late_set' or (status == 'needs_work' and pattern_value != 'set_hold_release'):
         badge = "🟠"
         label = "Late Set — Caution"
-        tip = "Pump-drill (3 holds) before release."
     elif status == 'good_sequence':
         badge = "🟢"
         label = "Good Sequence"
-        tip = None
     else:
         badge = "🟠"
         label = "Inconsistent Pattern"
-        tip = "Work on consistent wrist angles."
     
     return {
         'display_value': label,
         'badge': badge,
         'label': "Needs work",  # Add descriptive text after badge
-        'confidence': confidence,
-        'tip': tip
+        'confidence': confidence
     }
 
 
@@ -412,7 +402,6 @@ def get_qualitative_shaft_angle_grading(raw_value, confidence):
         'badge': badge,
         'label': description,
         'confidence': confidence,
-        'tip': "Focus on plane consistency at the top" if badge == "🟠" else None
     }
 
 
@@ -434,39 +423,32 @@ def get_qualitative_hip_rotation_grading(raw_value, confidence):
             category = "High Hip Turn"
             badge = "🟢"
             description = "Strong hip rotation"
-            tip = "Excellent lower body engagement"
         elif raw_value >= 18:
             category = "Good Hip Turn"
             badge = "🟢"
             description = "Good hip rotation"
-            tip = None
         elif raw_value >= 12:
             category = "Moderate Hip Turn"
             badge = "🟠"
             description = "Moderate hip rotation"
-            tip = "Work on hip initiation"
         elif raw_value >= 8:
             category = "Limited Hip Turn"
             badge = "🟠"
             description = "Limited hip rotation"
-            tip = "Increase hip drive"
         else:
             category = "Minimal Hip Turn"
             badge = "🔴"
             description = "Minimal hip rotation"
-            tip = "Focus on lower body sequence"
     else:
         category = "Moderate"
         badge = "🟠"
         description = "Mixed rotation pattern"
-        tip = "Work on hip-arm sequence"
     
     return {
         'display_value': category,
         'badge': badge,
         'label': description,
         'confidence': confidence,
-        'tip': tip
     }
 
 
@@ -489,39 +471,32 @@ def get_shoulder_turn_grading(value):
             badge = "🟢"
             quality = "Excellent"
             description = "Complete shoulder rotation"
-            tip = None
         elif turn_desc == "normal":
             badge = "🟢"
             quality = "Good"
             description = "Adequate shoulder turn"
-            tip = None
         elif turn_desc == "small":
             badge = "🟠"
             quality = "Limited"
             description = "Restricted shoulder turn"
-            tip = "Work on better shoulder rotation"
         else:
             badge = "🟠"
             quality = turn_desc.title()
             description = "Mixed shoulder action"
-            tip = None
     else:
         # Numeric assessment
         if value >= 90:
             badge = "🟢"
             quality = "Excellent"
             description = "Complete shoulder rotation"
-            tip = None
         elif value >= 75:
             badge = "🟢"
             quality = "Good"
             description = "Adequate shoulder turn"
-            tip = None
         else:
             badge = "🟠"
             quality = "Limited"
             description = "Restricted shoulder turn"
-            tip = "Work on better shoulder rotation"
     
     return {
         'display_value': quality,
@@ -560,19 +535,14 @@ def get_hip_depth_grading(hip_depth_data, confidence):
     if depth_loss_pct < 5:
         badge = '🟢'
         label = 'Good depth maintenance'
-        tip = 'Excellent hip posture through impact'
     elif depth_loss_pct < 15:
         badge = '🟠'
         label = 'Some early extension'
-        tip = 'Work on maintaining hip flexion through impact'
     else:
         badge = '🔴'
         label = 'Early extension'
-        tip = 'Focus on maintaining hip depth through impact for better power'
     
-    # Add technical details to tip for low confidence cases
-    if confidence < 0.5:
-        tip += f"\n\nTechnical: Hip width {hip_depth_data.get('hip_width_ref', 0):.1f}px, threshold {adaptive_threshold:.1f}px"
+    # Technical details removed per user request
     
     return {
         'value': depth_loss_pct,  # Raw value for display logic
@@ -581,7 +551,6 @@ def get_hip_depth_grading(hip_depth_data, confidence):
         'label': label,
         'confidence': confidence,
         'status': label,  # Use label as status for legacy compatibility
-        'tip': tip,
         'calculation_confidence': calculation_confidence,
         'adaptive_threshold': adaptive_threshold
     }
@@ -595,22 +564,18 @@ def get_shaft_address_grading(angle_value, confidence):
     if 45 <= angle_value <= 65:
         badge = '🟢'
         label = 'Good setup angle'
-        tip = 'Excellent shaft plane at address'
     elif (35 <= angle_value < 45) or (65 < angle_value <= 75):
         badge = '🟠'
         label = 'Acceptable angle'
-        tip = 'Shaft plane is workable but could be optimized'
     else:
         badge = '🔴'
         label = 'Needs adjustment'
-        tip = 'Work on shaft angle at address for better swing plane'
     
     return {
         'display_value': f'{angle_value:.1f}°',
         'badge': badge,
         'label': label,
         'confidence': confidence,
-        'tip': tip
     }
 
 
@@ -626,15 +591,12 @@ def get_head_displacement_grading(displacement_data, confidence):
     if displacement_pct < 5:
         badge = '🟢'
         label = 'Very stable head'
-        tip = 'Excellent head stability throughout swing'
     elif displacement_pct < 15:
         badge = '🟠'
         label = 'Some movement'
-        tip = 'Good stability with minor movement'
     else:
         badge = '🔴'
         label = 'Excessive movement'
-        tip = 'Focus on keeping head stable during swing'
     
     display_text = f'{displacement_pct:.1f}% {direction}' if 'displacement_pct' in displacement_data else f'{displacement_abs:.1f}px {direction}'
     
@@ -643,7 +605,6 @@ def get_head_displacement_grading(displacement_data, confidence):
         'badge': badge,
         'label': label,
         'confidence': confidence,
-        'tip': tip
     }
 
 
@@ -657,35 +618,28 @@ def get_shoulder_rotation_grading(value, confidence, position="top"):
         if 85 <= value <= 115:
             badge = '🟢'
             label = 'Excellent rotation'
-            tip = 'Great shoulder turn creating power and width'
         elif 75 <= value < 85 or 115 < value <= 125:
             badge = '🟠'
             label = 'Good rotation'
-            tip = 'Solid shoulder turn with room for optimization'
         else:
             badge = '🔴'
             label = 'Needs improvement'
-            tip = 'Work on shoulder mobility and turn for more power'
     else:  # impact
         if 30 <= value <= 50:
             badge = '🟢'
             label = 'Excellent impact position'
-            tip = 'Great unwinding through impact'
         elif 20 <= value < 30 or 50 < value <= 60:
             badge = '🟠'
             label = 'Good impact position'
-            tip = 'Solid rotation with room for fine-tuning'
         else:
             badge = '🔴'
             label = 'Needs improvement'
-            tip = 'Focus on proper sequence and rotation timing'
     
     return {
         'display_value': f"{value:.1f}°",
         'badge': badge,
         'label': label,
         'confidence': confidence,
-        'tip': tip
     }
 
 
@@ -699,35 +653,28 @@ def get_hip_rotation_grading(value, confidence, position="top"):
         if 40 <= value <= 65:
             badge = '🟢'
             label = 'Excellent turn'
-            tip = 'Great hip turn creating coil and power'
         elif 30 <= value < 40 or 65 < value <= 75:
             badge = '🟠'
             label = 'Good turn'
-            tip = 'Solid hip turn with room for optimization'
         else:
             badge = '🔴'
             label = 'Needs improvement'
-            tip = 'Work on hip mobility and rotation range'
     else:  # impact
         if 35 <= value <= 65:
             badge = '🟢'
             label = 'Excellent impact position'
-            tip = 'Great hip clearing through impact'
         elif 25 <= value < 35 or 65 < value <= 75:
             badge = '🟠'
             label = 'Good impact position'
-            tip = 'Solid hip action with room for improvement'
         else:
             badge = '🔴'
             label = 'Needs improvement'
-            tip = 'Focus on proper hip sequence and timing'
     
     return {
         'display_value': f"{value:.1f}°",
         'badge': badge,
         'label': label,
         'confidence': confidence,
-        'tip': tip
     }
 
 
@@ -741,27 +688,75 @@ def get_shoulder_tilt_swing_plane_grading(value, confidence):
     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_head_drop_grading(value, confidence):
+    """Grade head movement at top based on percentage of torso length
+    
+    Convention: positive = moved DOWN (drop), negative = moved UP (rise)
+    Grades by absolute movement magnitude, shows direction in display.
+    """
+    if value is None:
+        return {'value': None, 'display_value': 'n/a', 'badge': '⚪', 'status': 'No data available'}
+    
+    # Convert string to float if needed
+    try:
+        if isinstance(value, str):
+            # Remove any non-numeric characters except decimal point and minus sign
+            import re
+            clean_value = re.sub(r'[^\d.-]', '', value)
+            if clean_value:
+                value = float(clean_value)
+            else:
+                return {'value': None, 'display_value': 'n/a', 'badge': '⚪', 'status': 'Invalid value'}
+        else:
+            value = float(value)
+    except (ValueError, TypeError):
+        return {'value': None, 'display_value': 'n/a', 'badge': '⚪', 'status': 'Invalid value'}
+    
+    # Determine direction and absolute magnitude
+    direction = "drop" if value >= 0 else "rise"
+    abs_movement = abs(value)
+    
+    # Grade by absolute movement magnitude (suggested rubric)
+    if abs_movement <= 3:
+        badge = '🟢'
+        grade = 'Excellent head stability'
+    elif abs_movement <= 6:
+        badge = '🟠'
+        grade = 'Good/typical'
+    elif abs_movement <= 10:
+        badge = '⚠️'
+        grade = 'Borderline (work on stability)'
+    else:  # abs_movement > 10
+        badge = '🔴'
+        grade = 'Excessive movement'
+    
+    return {
+        'value': value,  # Raw value for display logic
+        'display_value': f'{abs_movement:.1f}% {direction}',
+        'badge': badge,
+        'label': grade,
+        'confidence': confidence,
+        'status': grade  # Use grade 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:
@@ -771,21 +766,17 @@ def get_shoulder_tilt_impact_grading(value, confidence):
     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
     }
 
@@ -803,34 +794,27 @@ def get_hip_sway_grading(value, confidence, position="top"):
         if 3.0 <= value <= 5.0:
             badge = '🟢'
             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 sway'
-            tip = 'Solid hip movement with room for optimization'
         else:
             badge = '🔴'
             label = 'Needs improvement'
-            tip = 'Work on hip movement for better coil and power'
     else:  # impact
         if 2.0 <= value <= 4.0:
             badge = '🟢'
             label = 'Excellent sway'
-            tip = 'Great hip movement through impact'
         elif 1.0 <= value < 2.0 or 4.0 < value <= 5.0:
             badge = '🟠'
             label = 'Good sway'
-            tip = 'Solid hip movement with room for optimization'
         else:
             badge = '🔴'
             label = 'Needs improvement'
-            tip = 'Work on hip movement for better impact position'
     
     return {
         'display_value': f'{value:.1f}"',
         'badge': badge,
         'label': label,
-        'tip': tip,
         'confidence': confidence
     }
 
@@ -845,35 +829,28 @@ def get_wrist_hinge_grading(value, confidence, position="top"):
         if 85 <= value <= 125:
             badge = '🟢'
             label = 'Excellent hinge'
-            tip = 'Great wrist set for power and control'
         elif 70 <= value < 85 or 125 < value <= 140:
             badge = '🟠'
             label = 'Good hinge'
-            tip = 'Solid wrist position with room for optimization'
         else:
             badge = '🔴'
             label = 'Needs improvement'
-            tip = 'Work on proper wrist hinge for more lag and power'
     else:  # impact
         if 15 <= value <= 40:
             badge = '🟢'
             label = 'Excellent release'
-            tip = 'Great lag retention and release through impact'
         elif 10 <= value < 15 or 40 < value <= 50:
             badge = '🟠'
             label = 'Good release'
-            tip = 'Solid release timing with room for improvement'
         else:
             badge = '🔴'
             label = 'Needs improvement'
-            tip = 'Focus on maintaining lag longer through downswing'
     
     return {
         'display_value': f"{value:.1f}°",
         'badge': badge,
         'label': label,
         'confidence': confidence,
-        'tip': tip
     }
 
 
@@ -886,26 +863,21 @@ def get_head_lateral_sway_grading(value, confidence):
     if abs(value) <= 5.0:  # <= 5% of shoulder width
         badge = '🟢'
         label = 'Excellent stability'
-        tip = 'Outstanding head stability throughout swing'
     elif abs(value) <= 10.0:  # <= 10% of shoulder width
         badge = '🟡'
         label = 'Good stability'
-        tip = 'Solid head control with minor movement'
     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}%",
         'badge': badge,
         'label': label,
         'confidence': confidence,
-        'tip': tip
     }
 
 
@@ -928,6 +900,7 @@ def display_new_grading_scheme(core_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", {})
+    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
     
@@ -1041,6 +1014,14 @@ def display_new_grading_scheme(core_metrics):
         if knee_grading:
             metrics_to_display.append(("Knee Flexion", knee_grading))
     
+    # 5. Head Movement @ Top (New DTL metric)
+    head_drop_value = head_drop_data.get('value')
+    if head_drop_value is not None:
+        head_drop_confidence = get_confidence(head_drop_data, 'head_drop')
+        head_drop_grading = get_head_drop_grading(head_drop_value, head_drop_confidence)
+        if head_drop_grading:
+            metrics_to_display.append(("Head Movement @ Top", head_drop_grading))
+    
     # Removed: Wrist Pattern, Kinematic Sequence (DTL-approx), and Shoulder Turn Quality metrics
     
     # 8. Hip Depth / Early Extension (New DTL metric)
@@ -1064,7 +1045,6 @@ def display_new_grading_scheme(core_metrics):
             'badge': '🔴',
             'label': 'Calculation failed',
             'confidence': 0.0,
-            'tip': f'Debug info: {error_data}'
         }
         metrics_to_display.append(("Hip Depth / Early Extension", error_grading))
     else:
@@ -1131,27 +1111,13 @@ def display_metric_card(metric_name, grading):
         result_line = f"**{grading['display_value']}** — {grading['badge']} {grading.get('label', '')}"
         st.markdown(result_line)
         
-        # Confidence line with indicators
-        if grading.get('confidence'):
-            confidence_pct = int(grading['confidence'] * 100)
-            confidence_line = f"Confidence: ~{confidence_pct}%"
-            
-            # Add indicators as text
-            if grading.get('confidence') and grading['confidence'] <= 0.75:
-                confidence_line += " *approx.*"
-            
-            if grading.get('dtl_only') or 'DTL' in metric_name or 'approx' in str(grading.get('label', '')):
-                confidence_line += " *DTL-only*"
-                
-            st.caption(confidence_line)
+        # Confidence display removed per user request
         
         # Detailed evaluation text
         evaluation = get_metric_evaluation(metric_name, grading)
         st.write(evaluation)
         
-        # Add tip if available using info box
-        if grading.get('tip'):
-            st.info(f"💡 {grading['tip']}")
+        # Tips display removed per user request
         
         # Add spacing
         st.write("")
@@ -1163,6 +1129,7 @@ def get_metric_definition(metric_name):
         "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.",
+        "Head Movement @ Top": "Measures head movement during backswing as percentage of torso length.",
         "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.",
@@ -1201,6 +1168,14 @@ 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."
     
+    elif metric_name == "Head Movement @ Top":
+        if "🟢" in badge:
+            return f"Your head drop of **{value}** shows excellent head stability during the backswing. This minimal movement indicates proper head control and balance, which promotes consistent contact and accuracy. Good head stability is fundamental for reliable ball striking."
+        elif "🟠" in badge:
+            return f"Your head drop of **{value}** shows moderate movement during the backswing. Some head movement can affect balance and consistency. Working on head stability and maintaining your spine angle can improve ball striking and accuracy."
+        else:
+            return f"Your head drop of **{value}** indicates excessive head movement during the backswing. Too much head drop disrupts balance and swing center, leading to inconsistent contact. Focus on keeping your head stable and maintaining spine angle for better results."
+    
     elif metric_name == "Hip Depth / Early Extension":
         if "🟢" in badge:
             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."
@@ -1335,6 +1310,7 @@ Timing 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 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