kinemotion 0.71.0__py3-none-any.whl → 0.72.0__py3-none-any.whl

kinemotion/core/smoothing.py

@@ -181,6 +181,18 @@ def _smooth_landmarks_core(  # NOSONAR(S1172) - polyorder used via closure
     return smoothed_sequence
 
 
+def _ensure_odd_window_length(window_length: int) -> int:
+    """Ensure window_length is odd (required for Savitzky-Golay filter).
+
+    Args:
+        window_length: Desired window length
+
+    Returns:
+        Odd window length (increments by 1 if even)
+    """
+    return window_length + 1 if window_length % 2 == 0 else window_length
+
+
 def smooth_landmarks(
     landmark_sequence: LandmarkSequence,
     window_length: int = 5,
@@ -200,9 +212,7 @@ def smooth_landmarks(
     if len(landmark_sequence) < window_length:
         return landmark_sequence
 
-    # Ensure window_length is odd
-    if window_length % 2 == 0:
-        window_length += 1
+    window_length = _ensure_odd_window_length(window_length)
 
     def savgol_smoother(
         x_coords: list[float], y_coords: list[float], _valid_frames: list[int]
@@ -231,61 +241,87 @@ def compute_velocity(positions: np.ndarray, fps: float, smooth_window: int = 3)
 
     # Smooth velocity if we have enough data
     if len(velocity) >= smooth_window and smooth_window > 1:
-        if smooth_window % 2 == 0:
-            smooth_window += 1
+        smooth_window = _ensure_odd_window_length(smooth_window)
         for dim in range(velocity.shape[1]):
             velocity[:, dim] = savgol_filter(velocity[:, dim], smooth_window, 1)
 
     return velocity
 
 
-def compute_velocity_from_derivative(
+def _compute_derivative(
     positions: np.ndarray,
+    deriv_order: int,
     window_length: int = 5,
     polyorder: int = 2,
 ) -> np.ndarray:
     """
-    Compute velocity as derivative of smoothed position trajectory.
-
-    Uses Savitzky-Golay filter to compute the derivative directly, which provides
-    a much smoother and more accurate velocity estimate than frame-to-frame differences.
+    Compute nth derivative using Savitzky-Golay filter.
 
-    This method:
-    1. Fits a polynomial to the position data in a sliding window
-    2. Analytically computes the derivative of that polynomial
-    3. Returns smooth velocity values
+    This unified function handles both velocity (first derivative) and
+    acceleration (second derivative) computation with a single implementation.
 
     Args:
         positions: 1D array of position values (e.g., foot y-positions)
+        deriv_order: Order of derivative (1 for velocity, 2 for acceleration)
         window_length: Window size for smoothing (must be odd, >= polyorder + 2)
         polyorder: Polynomial order for Savitzky-Golay filter (typically 2 or 3)
 
     Returns:
-        Array of absolute velocity values (magnitude of derivative)
+        Array of derivative values
     """
     if len(positions) < window_length:
         # Fallback to simple differences for short sequences
-        return np.abs(np.diff(positions, prepend=positions[0]))
+        if deriv_order == 1:
+            return np.abs(np.diff(positions, prepend=positions[0]))
+        # Second derivative fallback
+        velocity = np.diff(positions, prepend=positions[0])
+        return np.diff(velocity, prepend=velocity[0])
 
-    # Ensure window_length is odd
-    if window_length % 2 == 0:
-        window_length += 1
+    window_length = _ensure_odd_window_length(window_length)
 
     # Compute derivative using Savitzky-Golay filter
-    # deriv=1: compute first derivative
-    # delta=1.0: frame spacing (velocity per frame)
+    # delta=1.0: frame spacing
     # mode='interp': interpolate at boundaries
-    velocity = savgol_filter(
+    result = savgol_filter(
         positions,
         window_length,
         polyorder,
-        deriv=1,  # First derivative
-        delta=1.0,  # Frame spacing
+        deriv=deriv_order,
+        delta=1.0,
         mode="interp",
     )
 
-    # Return absolute velocity (magnitude only)
-    return np.abs(velocity)
+    # Return absolute values for velocity (first derivative)
+    return np.abs(result) if deriv_order == 1 else result
+
+
+def compute_velocity_from_derivative(
+    positions: np.ndarray,
+    window_length: int = 5,
+    polyorder: int = 2,
+) -> np.ndarray:
+    """
+    Compute velocity as derivative of smoothed position trajectory.
+
+    Uses Savitzky-Golay filter to compute the derivative directly, which provides
+    a much smoother and more accurate velocity estimate than frame-to-frame differences.
+
+    This method:
+    1. Fits a polynomial to the position data in a sliding window
+    2. Analytically computes the derivative of that polynomial
+    3. Returns smooth velocity values
+
+    Args:
+        positions: 1D array of position values (e.g., foot y-positions)
+        window_length: Window size for smoothing (must be odd, >= polyorder + 2)
+        polyorder: Polynomial order for Savitzky-Golay filter (typically 2 or 3)
+
+    Returns:
+        Array of absolute velocity values (magnitude of derivative)
+    """
+    return _compute_derivative(
+        positions, deriv_order=1, window_length=window_length, polyorder=polyorder
+    )
 
 
 def compute_acceleration_from_derivative(
@@ -314,30 +350,10 @@ def compute_acceleration_from_derivative(
     Returns:
         Array of acceleration values (second derivative of position)
     """
-    if len(positions) < window_length:
-        # Fallback to simple second differences for short sequences
-        velocity = np.diff(positions, prepend=positions[0])
-        return np.diff(velocity, prepend=velocity[0])
-
-    # Ensure window_length is odd
-    if window_length % 2 == 0:
-        window_length += 1
-
-    # Compute second derivative using Savitzky-Golay filter
-    # deriv=2: compute second derivative (acceleration/curvature)
-    # delta=1.0: frame spacing
-    # mode='interp': interpolate at boundaries
-    acceleration = savgol_filter(
-        positions,
-        window_length,
-        polyorder,
-        deriv=2,  # Second derivative
-        delta=1.0,  # Frame spacing
-        mode="interp",
+    return _compute_derivative(
+        positions, deriv_order=2, window_length=window_length, polyorder=polyorder
     )
 
-    return acceleration
-
 
 def smooth_landmarks_advanced(
     landmark_sequence: LandmarkSequence,
@@ -376,9 +392,7 @@ def smooth_landmarks_advanced(
     if len(landmark_sequence) < window_length:
         return landmark_sequence
 
-    # Ensure window_length is odd
-    if window_length % 2 == 0:
-        window_length += 1
+    window_length = _ensure_odd_window_length(window_length)
 
     def advanced_smoother(
         x_coords: list[float], y_coords: list[float], _valid_frames: list[int]

kinemotion/core/types.py

@@ -29,6 +29,19 @@ LandmarkSequence: TypeAlias = list[LandmarkFrame]
 # - Wrapper structures: e.g. {"data": {...actual metrics...}}
 MetricsDict: TypeAlias = dict[str, Any]
 
+# MediaPipe foot landmark names used for position and visibility tracking
+FOOT_KEYS: tuple[str, ...] = (
+    "left_ankle",
+    "right_ankle",
+    "left_heel",
+    "right_heel",
+    "left_foot_index",
+    "right_foot_index",
+)
+
+# MediaPipe hip landmark names used for position tracking
+HIP_KEYS: tuple[str, ...] = ("left_hip", "right_hip")
+
 __all__ = [
     "FloatArray",
     "Float64Array",
@@ -39,4 +52,6 @@ __all__ = [
     "LandmarkFrame",
     "LandmarkSequence",
     "MetricsDict",
+    "FOOT_KEYS",
+    "HIP_KEYS",
 ]

kinemotion/core/validation.py

@@ -78,19 +78,18 @@ class MetricBounds:
 
     def contains(self, value: float, profile: AthleteProfile) -> bool:
         """Check if value is within bounds for athlete profile."""
-        if profile == AthleteProfile.ELDERLY:
+        # ELDERLY and UNTRAINED use same bounds (practical to recreational)
+        if profile in (AthleteProfile.ELDERLY, AthleteProfile.UNTRAINED):
             return self.practical_min <= value <= self.recreational_max
-        elif profile == AthleteProfile.UNTRAINED:
-            return self.practical_min <= value <= self.recreational_max
-        elif profile == AthleteProfile.RECREATIONAL:
+        if profile == AthleteProfile.RECREATIONAL:
             return self.recreational_min <= value <= self.recreational_max
-        elif profile == AthleteProfile.TRAINED:
+        if profile == AthleteProfile.ELITE:
+            return self.elite_min <= value <= self.elite_max
+        if profile == AthleteProfile.TRAINED:
             # Trained athletes: midpoint between recreational and elite
             trained_min = (self.recreational_min + self.elite_min) / 2
             trained_max = (self.recreational_max + self.elite_max) / 2
             return trained_min <= value <= trained_max
-        elif profile == AthleteProfile.ELITE:
-            return self.elite_min <= value <= self.elite_max
         return False
 
     def is_physically_possible(self, value: float) -> bool:

kinemotion/core/video_io.py

@@ -18,6 +18,17 @@ class VideoProcessor:
     No dimensions are hardcoded - all dimensions are extracted from actual frame data.
     """
 
+    # Mapping of rotation angles to OpenCV rotation operations
+    # Keys are normalized angles (equivalent angles grouped)
+    _ROTATION_OPS: dict[int, int] = {
+        -90: cv2.ROTATE_90_CLOCKWISE,
+        270: cv2.ROTATE_90_CLOCKWISE,
+        90: cv2.ROTATE_90_COUNTERCLOCKWISE,
+        -270: cv2.ROTATE_90_COUNTERCLOCKWISE,
+        180: cv2.ROTATE_180,
+        -180: cv2.ROTATE_180,
+    }
+
     def __init__(self, video_path: str, timer: Timer | None = None) -> None:
         """
         Initialize video processor.
@@ -216,15 +227,9 @@ class VideoProcessor:
 
         # Apply rotation if video has rotation metadata
         with self.timer.measure("frame_rotation"):
-            if self.rotation == -90 or self.rotation == 270:
-                # -90 degrees = rotate 90 degrees clockwise
-                frame = cv2.rotate(frame, cv2.ROTATE_90_CLOCKWISE)
-            elif self.rotation == 90 or self.rotation == -270:
-                # 90 degrees = rotate 90 degrees counter-clockwise
-                frame = cv2.rotate(frame, cv2.ROTATE_90_COUNTERCLOCKWISE)
-            elif self.rotation == 180 or self.rotation == -180:
-                # 180 degrees rotation
-                frame = cv2.rotate(frame, cv2.ROTATE_180)
+            rotation_op = self._ROTATION_OPS.get(self.rotation)
+            if rotation_op is not None:
+                frame = cv2.rotate(frame, rotation_op)
 
         self._frame_index += 1
         return frame

kinemotion/{dropjump → dj}/__init__.py

@@ -9,7 +9,7 @@ from .analysis import (
     find_interpolated_phase_transitions_with_curvature,
     refine_transition_with_curvature,
 )
-from .debug_overlay import DebugOverlayRenderer
+from .debug_overlay import DropJumpDebugOverlayRenderer
 from .kinematics import DropJumpMetrics, calculate_drop_jump_metrics
 
 __all__ = [
@@ -25,5 +25,5 @@ __all__ = [
     "DropJumpMetrics",
     "calculate_drop_jump_metrics",
     # Debug overlay
-    "DebugOverlayRenderer",
+    "DropJumpDebugOverlayRenderer",
 ]

kinemotion/{dropjump → dj}/analysis.py

@@ -11,7 +11,7 @@ from ..core.smoothing import (
     interpolate_threshold_crossing,
 )
 from ..core.timing import NULL_TIMER, Timer
-from ..core.types import BoolArray, FloatArray
+from ..core.types import FOOT_KEYS, BoolArray, FloatArray
 
 
 class ContactState(Enum):
@@ -334,6 +334,48 @@ def _assign_contact_states(
     return states
 
 
+def _compute_near_ground_mask(
+    foot_positions: FloatArray,
+    height_tolerance: float = 0.35,
+) -> BoolArray:
+    """Compute mask for frames where feet are near ground level.
+
+    Uses position-based filtering to identify frames near ground baseline.
+    In normalized coordinates: y=1 is bottom (ground), y=0 is top.
+
+    The ground baseline is established as the 90th percentile of positions,
+    which represents the typical ground level while handling outliers.
+
+    The tolerance is set at 35% of the position range by default, which is
+    generous enough to capture the full reactive contact phase (where athletes
+    maintain an athletic stance) while still filtering out the jump apex
+    (where y is much lower than ground level).
+
+    Args:
+        foot_positions: Array of foot y-positions (normalized, 0-1)
+        height_tolerance: Fraction of position range allowed above ground (default 35%)
+
+    Returns:
+        Boolean array where True indicates frame is near ground level
+    """
+    # Ground baseline: 90th percentile (where feet are typically on ground)
+    # Using 90th instead of 95th to be less sensitive to final landing positions
+    ground_baseline = float(np.percentile(foot_positions, 90))
+
+    # Compute position range for tolerance calculation
+    position_range = float(np.max(foot_positions) - np.min(foot_positions))
+
+    # Minimum absolute tolerance to handle small movements
+    min_tolerance = 0.03  # 3% of normalized range
+
+    # Height tolerance: percentage of position range or minimum
+    tolerance = max(position_range * height_tolerance, min_tolerance)
+
+    # Frames are near ground if y >= ground_baseline - tolerance
+    # (Remember: higher y = closer to ground in normalized coords)
+    return foot_positions >= (ground_baseline - tolerance)
+
+
 def detect_ground_contact(
     foot_positions: FloatArray,
     velocity_threshold: float = 0.02,
@@ -343,13 +385,14 @@ def detect_ground_contact(
     window_length: int = 5,
     polyorder: int = 2,
     timer: Timer | None = None,
+    height_tolerance: float = 0.35,
 ) -> list[ContactState]:
     """
-    Detect when feet are in contact with ground based on vertical motion.
+    Detect when feet are in contact with ground based on vertical motion AND position.
 
-    Uses derivative-based velocity calculation via Savitzky-Goyal filter for smooth,
-    accurate velocity estimates. This is consistent with the velocity calculation used
-    throughout the pipeline for sub-frame interpolation and curvature analysis.
+    Uses derivative-based velocity calculation via Savitzky-Golay filter for smooth,
+    accurate velocity estimates. Additionally uses position-based filtering to prevent
+    false ON_GROUND classification at jump apex where velocity approaches zero.
 
     Args:
         foot_positions: Array of foot y-positions (normalized, 0-1, where 1 is bottom)
@@ -360,6 +403,7 @@ def detect_ground_contact(
         window_length: Window size for velocity derivative calculation (must be odd)
         polyorder: Polynomial order for Savitzky-Golay filter (default: 2)
         timer: Optional Timer for measuring operations
+        height_tolerance: Fraction of position range to allow above ground baseline (default 35%)
 
     Returns:
         List of ContactState for each frame
@@ -379,6 +423,14 @@ def detect_ground_contact(
     # Detect stationary frames based on velocity threshold
     is_stationary = np.abs(velocities) < velocity_threshold
 
+    # Position-based filtering to prevent false ON_GROUND at jump apex
+    # In normalized coords: y=1 is bottom (ground), y=0 is top
+    # Ground baseline is the 95th percentile (handles outliers)
+    is_near_ground = _compute_near_ground_mask(foot_positions, height_tolerance)
+
+    # Both conditions must be true: low velocity AND near ground
+    is_stationary = is_stationary & is_near_ground
+
     # Apply visibility filter
     is_stationary = _filter_stationary_with_visibility(
         is_stationary, visibilities, visibility_threshold
@@ -424,6 +476,57 @@ def find_contact_phases(
     return phases
 
 
+def _interpolate_phase_boundary(
+    boundary_idx: int,
+    state: ContactState,
+    velocities: FloatArray,
+    velocity_threshold: float,
+    is_start: bool,
+) -> float:
+    """Interpolate phase boundary with sub-frame precision.
+
+    Args:
+        boundary_idx: Index of the boundary frame
+        state: Contact state of the phase
+        velocities: Velocity array
+        velocity_threshold: Threshold value for crossing detection
+        is_start: True for phase start, False for phase end
+
+    Returns:
+        Fractional frame index, or float(boundary_idx) if no interpolation.
+    """
+    n_velocities = len(velocities)
+
+    if is_start:
+        # For start boundary, look at velocity before and at the boundary
+        if boundary_idx <= 0 or boundary_idx >= n_velocities:
+            return float(boundary_idx)
+        vel_before = velocities[boundary_idx - 1]
+        vel_at = velocities[boundary_idx]
+        # Check threshold crossing based on state
+        is_crossing = (
+            state == ContactState.ON_GROUND and vel_before > velocity_threshold > vel_at
+        ) or (state == ContactState.IN_AIR and vel_before < velocity_threshold < vel_at)
+        if is_crossing:
+            offset = interpolate_threshold_crossing(vel_before, vel_at, velocity_threshold)
+            return (boundary_idx - 1) + offset
+        return float(boundary_idx)
+
+    # For end boundary, look at velocity at and after the boundary
+    if boundary_idx + 1 >= n_velocities:
+        return float(boundary_idx)
+    vel_at = velocities[boundary_idx]
+    vel_after = velocities[boundary_idx + 1]
+    # Check threshold crossing based on state
+    is_crossing = (
+        state == ContactState.ON_GROUND and vel_at < velocity_threshold < vel_after
+    ) or (state == ContactState.IN_AIR and vel_at > velocity_threshold > vel_after)
+    if is_crossing:
+        offset = interpolate_threshold_crossing(vel_at, vel_after, velocity_threshold)
+        return boundary_idx + offset
+    return float(boundary_idx)
+
+
 def _interpolate_phase_start(
     start_idx: int,
     state: ContactState,
@@ -435,21 +538,9 @@ def _interpolate_phase_start(
     Returns:
         Fractional start frame, or float(start_idx) if no interpolation.
     """
-    if start_idx <= 0 or start_idx >= len(velocities):
-        return float(start_idx)
-
-    vel_before = velocities[start_idx - 1]
-    vel_at = velocities[start_idx]
-
-    # Check threshold crossing based on state
-    is_landing = state == ContactState.ON_GROUND and vel_before > velocity_threshold > vel_at
-    is_takeoff = state == ContactState.IN_AIR and vel_before < velocity_threshold < vel_at
-
-    if is_landing or is_takeoff:
-        offset = interpolate_threshold_crossing(vel_before, vel_at, velocity_threshold)
-        return (start_idx - 1) + offset
-
-    return float(start_idx)
+    return _interpolate_phase_boundary(
+        start_idx, state, velocities, velocity_threshold, is_start=True
+    )
 
 
 def _interpolate_phase_end(
@@ -457,28 +548,16 @@ def _interpolate_phase_end(
     state: ContactState,
     velocities: FloatArray,
     velocity_threshold: float,
-    max_idx: int,
+    _max_idx: int,
 ) -> float:
     """Interpolate end boundary of a phase with sub-frame precision.
 
     Returns:
         Fractional end frame, or float(end_idx) if no interpolation.
     """
-    if end_idx >= max_idx - 1 or end_idx + 1 >= len(velocities):
-        return float(end_idx)
-
-    vel_at = velocities[end_idx]
-    vel_after = velocities[end_idx + 1]
-
-    # Check threshold crossing based on state
-    is_takeoff = state == ContactState.ON_GROUND and vel_at < velocity_threshold < vel_after
-    is_landing = state == ContactState.IN_AIR and vel_at > velocity_threshold > vel_after
-
-    if is_takeoff or is_landing:
-        offset = interpolate_threshold_crossing(vel_at, vel_after, velocity_threshold)
-        return end_idx + offset
-
-    return float(end_idx)
+    return _interpolate_phase_boundary(
+        end_idx, state, velocities, velocity_threshold, is_start=False
+    )
 
 
 def find_interpolated_phase_transitions(
@@ -689,25 +768,28 @@ def find_landing_from_acceleration(
     accelerations: FloatArray,
     takeoff_frame: int,
     fps: float,
-    search_duration: float = 0.7,
+    search_duration: float = 1.5,
 ) -> int:
     """
-    Find landing frame by detecting impact acceleration after takeoff.
+    Find landing frame using position-based detection with acceleration refinement.
+
+    Primary method: Find when feet return to near-takeoff level after peak.
+    Secondary: Refine with acceleration spike if present.
 
-    Detects the moment of initial ground contact, characterized by a sharp
-    deceleration (positive acceleration spike) as downward velocity is arrested.
+    For drop jumps, landing is defined as the first ground contact after the
+    reactive jump, when feet return to approximately the same level as takeoff.
 
     Args:
-        positions: Array of vertical positions (normalized 0-1)
+        positions: Array of vertical positions (normalized 0-1, where higher = closer to ground)
         accelerations: Array of accelerations (second derivative)
         takeoff_frame: Frame at takeoff (end of ground contact)
         fps: Video frame rate
-        search_duration: Duration in seconds to search for landing (default: 0.7s)
+        search_duration: Duration in seconds to search for landing (default: 1.5s)
 
     Returns:
         Landing frame index (integer)
     """
-    # Find peak height (minimum y value = highest point)
+    # Extended search window to capture full flight
     search_start = takeoff_frame
     search_end = min(len(positions), takeoff_frame + int(fps * search_duration))
 
@@ -715,61 +797,91 @@ def find_landing_from_acceleration(
         return min(len(positions) - 1, takeoff_frame + int(fps * 0.3))
 
     flight_positions = positions[search_start:search_end]
+
+    # Find peak height (minimum y value = highest point)
     peak_idx = int(np.argmin(flight_positions))
     peak_frame = search_start + peak_idx
 
-    # After peak, look for landing (impact with ground)
-    # Landing is detected by maximum positive acceleration (deceleration on impact)
-    landing_search_start = peak_frame + 2
-    landing_search_end = min(len(accelerations), landing_search_start + int(fps * 0.6))
+    # Get takeoff position as reference for landing detection
+    takeoff_position = positions[takeoff_frame]
+
+    # Position-based landing: find first frame after peak where position
+    # returns to within 5% of takeoff level (or 95% of the way back)
+    landing_threshold = takeoff_position - 0.05 * (takeoff_position - positions[peak_frame])
 
-    if landing_search_end <= landing_search_start:
-        return min(len(positions) - 1, peak_frame + int(fps * 0.2))
+    # Search for landing after peak
+    landing_frame = None
+    for i in range(peak_frame + 2, min(len(positions), search_end)):
+        if positions[i] >= landing_threshold:
+            landing_frame = i
+            break
 
-    # Find impact: maximum negative acceleration after peak (deceleration on impact)
-    # The impact creates a large upward force (negative acceleration in Y-down)
-    landing_accelerations = accelerations[landing_search_start:landing_search_end]
-    impact_idx = int(np.argmin(landing_accelerations))
-    landing_frame = landing_search_start + impact_idx
+    # If position-based detection fails, use end of search window
+    if landing_frame is None:
+        landing_frame = min(len(positions) - 1, search_end - 1)
+
+    # Refine with acceleration if there's a clear impact spike
+    # Look for significant acceleration in a small window around the position-based landing
+    refine_start = max(peak_frame + 2, landing_frame - int(fps * 0.1))
+    refine_end = min(len(accelerations), landing_frame + int(fps * 0.1))
+
+    if refine_end > refine_start:
+        window_accelerations = accelerations[refine_start:refine_end]
+        # Check if there's a significant acceleration spike (> 3x median)
+        median_acc = float(np.median(np.abs(window_accelerations)))
+        max_acc_idx = int(np.argmax(np.abs(window_accelerations)))
+        max_acc = float(np.abs(window_accelerations[max_acc_idx]))
+
+        if median_acc > 0 and max_acc > 3 * median_acc:
+            # Use acceleration-refined landing frame
+            landing_frame = refine_start + max_acc_idx
 
     return landing_frame
 
 
 def compute_average_foot_position(
     landmarks: dict[str, tuple[float, float, float]],
+    visibility_threshold: float = 0.5,
 ) -> tuple[float, float]:
     """
     Compute average foot position from ankle and foot landmarks.
 
+    Uses tiered visibility approach to avoid returning center (0.5, 0.5)
+    which can cause false phase transitions in contact detection.
+
     Args:
         landmarks: Dictionary of landmark positions
+        visibility_threshold: Minimum visibility to include landmark (default: 0.5)
 
     Returns:
         (x, y) average foot position in normalized coordinates
     """
-    foot_keys = [
-        "left_ankle",
-        "right_ankle",
-        "left_heel",
-        "right_heel",
-        "left_foot_index",
-        "right_foot_index",
-    ]
-
-    x_positions = []
-    y_positions = []
-
-    for key in foot_keys:
+    # Collect all foot landmarks with their visibility
+    foot_data: list[tuple[float, float, float]] = []
+    for key in FOOT_KEYS:
         if key in landmarks:
             x, y, visibility = landmarks[key]
-            if visibility > 0.5:  # Only use visible landmarks
-                x_positions.append(x)
-                y_positions.append(y)
+            foot_data.append((x, y, visibility))
 
-    if not x_positions:
-        return (0.5, 0.5)  # Default to center if no visible feet
+    if not foot_data:
+        # No foot landmarks at all - return center as last resort
+        return (0.5, 0.5)
 
-    return (float(np.mean(x_positions)), float(np.mean(y_positions)))
+    # Tier 1: Use landmarks above visibility threshold
+    high_vis = [(x, y) for x, y, v in foot_data if v > visibility_threshold]
+    if high_vis:
+        xs, ys = zip(*high_vis, strict=False)
+        return (float(np.mean(xs)), float(np.mean(ys)))
+
+    # Tier 2: Use landmarks with any reasonable visibility (> 0.1)
+    low_vis = [(x, y) for x, y, v in foot_data if v > 0.1]
+    if low_vis:
+        xs, ys = zip(*low_vis, strict=False)
+        return (float(np.mean(xs)), float(np.mean(ys)))
+
+    # Tier 3: Use highest visibility landmark regardless of threshold
+    best = max(foot_data, key=lambda t: t[2])
+    return (best[0], best[1])
 
 
 def _calculate_average_visibility(
@@ -783,8 +895,13 @@ def _calculate_average_visibility(
     Returns:
         Average visibility of foot landmarks (0.0 if none visible)
     """
-    foot_keys = ["left_ankle", "right_ankle", "left_heel", "right_heel"]
-    foot_vis = [frame_landmarks[key][2] for key in foot_keys if key in frame_landmarks]
+    # Only use ankles and heels for visibility (foot_index can be noisy)
+    visibility_keys = ("left_ankle", "right_ankle", "left_heel", "right_heel")
+    foot_vis = [
+        frame_landmarks[key][2]
+        for key in FOOT_KEYS
+        if key in frame_landmarks and key in visibility_keys
+    ]
     return float(np.mean(foot_vis)) if foot_vis else 0.0