kinemotion 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

kinemotion/core/pose.py

@@ -0,0 +1,221 @@
+"""Pose tracking using MediaPipe Pose."""
+
+
+import cv2
+import mediapipe as mp
+import numpy as np
+
+
+class PoseTracker:
+    """Tracks human pose landmarks in video frames using MediaPipe."""
+
+    def __init__(
+        self,
+        min_detection_confidence: float = 0.5,
+        min_tracking_confidence: float = 0.5,
+    ):
+        """
+        Initialize the pose tracker.
+
+        Args:
+            min_detection_confidence: Minimum confidence for pose detection
+            min_tracking_confidence: Minimum confidence for pose tracking
+        """
+        self.mp_pose = mp.solutions.pose
+        self.pose = self.mp_pose.Pose(
+            min_detection_confidence=min_detection_confidence,
+            min_tracking_confidence=min_tracking_confidence,
+            model_complexity=1,
+        )
+
+    def process_frame(
+        self, frame: np.ndarray
+    ) -> dict[str, tuple[float, float, float]] | None:
+        """
+        Process a single frame and extract pose landmarks.
+
+        Args:
+            frame: BGR image frame
+
+        Returns:
+            Dictionary mapping landmark names to (x, y, visibility) tuples,
+            or None if no pose detected. Coordinates are normalized (0-1).
+        """
+        # Convert BGR to RGB
+        rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+
+        # Process the frame
+        results = self.pose.process(rgb_frame)
+
+        if not results.pose_landmarks:
+            return None
+
+        # Extract key landmarks for feet tracking and CoM estimation
+        landmarks = {}
+        landmark_names = {
+            # Feet landmarks
+            self.mp_pose.PoseLandmark.LEFT_ANKLE: "left_ankle",
+            self.mp_pose.PoseLandmark.RIGHT_ANKLE: "right_ankle",
+            self.mp_pose.PoseLandmark.LEFT_HEEL: "left_heel",
+            self.mp_pose.PoseLandmark.RIGHT_HEEL: "right_heel",
+            self.mp_pose.PoseLandmark.LEFT_FOOT_INDEX: "left_foot_index",
+            self.mp_pose.PoseLandmark.RIGHT_FOOT_INDEX: "right_foot_index",
+            # Torso landmarks for CoM estimation
+            self.mp_pose.PoseLandmark.LEFT_HIP: "left_hip",
+            self.mp_pose.PoseLandmark.RIGHT_HIP: "right_hip",
+            self.mp_pose.PoseLandmark.LEFT_SHOULDER: "left_shoulder",
+            self.mp_pose.PoseLandmark.RIGHT_SHOULDER: "right_shoulder",
+            # Additional landmarks for better CoM estimation
+            self.mp_pose.PoseLandmark.NOSE: "nose",
+            self.mp_pose.PoseLandmark.LEFT_KNEE: "left_knee",
+            self.mp_pose.PoseLandmark.RIGHT_KNEE: "right_knee",
+        }
+
+        for landmark_id, name in landmark_names.items():
+            lm = results.pose_landmarks.landmark[landmark_id]
+            landmarks[name] = (lm.x, lm.y, lm.visibility)
+
+        return landmarks
+
+    def close(self) -> None:
+        """Release resources."""
+        self.pose.close()
+
+
+def compute_center_of_mass(
+    landmarks: dict[str, tuple[float, float, float]],
+    visibility_threshold: float = 0.5,
+) -> tuple[float, float, float]:
+    """
+    Compute approximate center of mass (CoM) from body landmarks.
+
+    Uses biomechanical segment weights based on Dempster's body segment parameters:
+    - Head: 8% of body mass (represented by nose)
+    - Trunk (shoulders to hips): 50% of body mass
+    - Thighs: 2 × 10% = 20% of body mass
+    - Legs (knees to ankles): 2 × 5% = 10% of body mass
+    - Feet: 2 × 1.5% = 3% of body mass
+
+    The CoM is estimated as a weighted average of these segments, with
+    weights corresponding to their proportion of total body mass.
+
+    Args:
+        landmarks: Dictionary of landmark positions (x, y, visibility)
+        visibility_threshold: Minimum visibility to include landmark in calculation
+
+    Returns:
+        (x, y, visibility) tuple for estimated CoM position
+        visibility = average visibility of all segments used
+    """
+    # Define segment representatives and their weights (as fraction of body mass)
+    # Each segment uses midpoint or average of its bounding landmarks
+    segments = []
+    segment_weights = []
+    visibilities = []
+
+    # Head segment: 8% (use nose as proxy)
+    if "nose" in landmarks:
+        x, y, vis = landmarks["nose"]
+        if vis > visibility_threshold:
+            segments.append((x, y))
+            segment_weights.append(0.08)
+            visibilities.append(vis)
+
+    # Trunk segment: 50% (midpoint between shoulders and hips)
+    trunk_landmarks = ["left_shoulder", "right_shoulder", "left_hip", "right_hip"]
+    trunk_positions = [
+        (x, y, vis)
+        for key in trunk_landmarks
+        if key in landmarks
+        for x, y, vis in [landmarks[key]]
+        if vis > visibility_threshold
+    ]
+    if len(trunk_positions) >= 2:
+        trunk_x = float(np.mean([pos[0] for pos in trunk_positions]))
+        trunk_y = float(np.mean([pos[1] for pos in trunk_positions]))
+        trunk_vis = float(np.mean([pos[2] for pos in trunk_positions]))
+        segments.append((trunk_x, trunk_y))
+        segment_weights.append(0.50)
+        visibilities.append(trunk_vis)
+
+    # Thigh segment: 20% total (midpoint hip to knee for each leg)
+    for side in ["left", "right"]:
+        hip_key = f"{side}_hip"
+        knee_key = f"{side}_knee"
+        if hip_key in landmarks and knee_key in landmarks:
+            hip_x, hip_y, hip_vis = landmarks[hip_key]
+            knee_x, knee_y, knee_vis = landmarks[knee_key]
+            if hip_vis > visibility_threshold and knee_vis > visibility_threshold:
+                thigh_x = (hip_x + knee_x) / 2
+                thigh_y = (hip_y + knee_y) / 2
+                thigh_vis = (hip_vis + knee_vis) / 2
+                segments.append((thigh_x, thigh_y))
+                segment_weights.append(0.10)  # 10% per leg
+                visibilities.append(thigh_vis)
+
+    # Lower leg segment: 10% total (midpoint knee to ankle for each leg)
+    for side in ["left", "right"]:
+        knee_key = f"{side}_knee"
+        ankle_key = f"{side}_ankle"
+        if knee_key in landmarks and ankle_key in landmarks:
+            knee_x, knee_y, knee_vis = landmarks[knee_key]
+            ankle_x, ankle_y, ankle_vis = landmarks[ankle_key]
+            if knee_vis > visibility_threshold and ankle_vis > visibility_threshold:
+                leg_x = (knee_x + ankle_x) / 2
+                leg_y = (knee_y + ankle_y) / 2
+                leg_vis = (knee_vis + ankle_vis) / 2
+                segments.append((leg_x, leg_y))
+                segment_weights.append(0.05)  # 5% per leg
+                visibilities.append(leg_vis)
+
+    # Foot segment: 3% total (average of ankle, heel, foot_index)
+    for side in ["left", "right"]:
+        foot_keys = [f"{side}_ankle", f"{side}_heel", f"{side}_foot_index"]
+        foot_positions = [
+            (x, y, vis)
+            for key in foot_keys
+            if key in landmarks
+            for x, y, vis in [landmarks[key]]
+            if vis > visibility_threshold
+        ]
+        if foot_positions:
+            foot_x = float(np.mean([pos[0] for pos in foot_positions]))
+            foot_y = float(np.mean([pos[1] for pos in foot_positions]))
+            foot_vis = float(np.mean([pos[2] for pos in foot_positions]))
+            segments.append((foot_x, foot_y))
+            segment_weights.append(0.015)  # 1.5% per foot
+            visibilities.append(foot_vis)
+
+    # If no segments found, fall back to hip average
+    if not segments:
+        if "left_hip" in landmarks and "right_hip" in landmarks:
+            lh_x, lh_y, lh_vis = landmarks["left_hip"]
+            rh_x, rh_y, rh_vis = landmarks["right_hip"]
+            return (
+                (lh_x + rh_x) / 2,
+                (lh_y + rh_y) / 2,
+                (lh_vis + rh_vis) / 2,
+            )
+        # Ultimate fallback: center of frame
+        return (0.5, 0.5, 0.0)
+
+    # Normalize weights to sum to 1.0
+    total_weight = sum(segment_weights)
+    normalized_weights = [w / total_weight for w in segment_weights]
+
+    # Compute weighted average of segment positions
+    com_x = float(
+        sum(
+            pos[0] * weight
+            for pos, weight in zip(segments, normalized_weights, strict=True)
+        )
+    )
+    com_y = float(
+        sum(
+            pos[1] * weight
+            for pos, weight in zip(segments, normalized_weights, strict=True)
+        )
+    )
+    com_visibility = float(np.mean(visibilities)) if visibilities else 0.0
+
+    return (com_x, com_y, com_visibility)

{dropjump → kinemotion/core}/smoothing.py

@@ -4,6 +4,11 @@
 import numpy as np
 from scipy.signal import savgol_filter
 
+from .filtering import (
+    bilateral_temporal_filter,
+    reject_outliers,
+)
+
 
 def smooth_landmarks(
     landmark_sequence: list[dict[str, tuple[float, float, float]] | None],
@@ -221,3 +226,142 @@ def compute_acceleration_from_derivative(
     )
 
     return acceleration  # type: ignore[no-any-return]
+
+
+def smooth_landmarks_advanced(
+    landmark_sequence: list[dict[str, tuple[float, float, float]] | None],
+    window_length: int = 5,
+    polyorder: int = 2,
+    use_outlier_rejection: bool = True,
+    use_bilateral: bool = False,
+    ransac_threshold: float = 0.02,
+    bilateral_sigma_spatial: float = 3.0,
+    bilateral_sigma_intensity: float = 0.02,
+) -> list[dict[str, tuple[float, float, float]] | None]:
+    """
+    Advanced landmark smoothing with outlier rejection and bilateral filtering.
+
+    Combines multiple techniques for robust smoothing:
+    1. Outlier rejection (RANSAC + median filtering)
+    2. Optional bilateral filtering (edge-preserving)
+    3. Savitzky-Golay smoothing
+
+    Args:
+        landmark_sequence: List of landmark dictionaries from each frame
+        window_length: Length of filter window (must be odd, >= polyorder + 2)
+        polyorder: Order of polynomial used to fit samples
+        use_outlier_rejection: Apply outlier detection and removal
+        use_bilateral: Use bilateral filter instead of Savitzky-Golay
+        ransac_threshold: Threshold for RANSAC outlier detection
+        bilateral_sigma_spatial: Spatial sigma for bilateral filter
+        bilateral_sigma_intensity: Intensity sigma for bilateral filter
+
+    Returns:
+        Smoothed landmark sequence with same structure as input
+    """
+    if len(landmark_sequence) < window_length:
+        # Not enough frames to smooth effectively
+        return landmark_sequence
+
+    # Ensure window_length is odd
+    if window_length % 2 == 0:
+        window_length += 1
+
+    # Extract landmark names from first valid frame
+    landmark_names = None
+    for frame_landmarks in landmark_sequence:
+        if frame_landmarks is not None:
+            landmark_names = list(frame_landmarks.keys())
+            break
+
+    if landmark_names is None:
+        return landmark_sequence
+
+    # Build arrays for each landmark coordinate
+    smoothed_sequence: list[dict[str, tuple[float, float, float]] | None] = []
+
+    for landmark_name in landmark_names:
+        # Extract x, y coordinates for this landmark across all frames
+        x_coords = []
+        y_coords = []
+        valid_frames = []
+
+        for i, frame_landmarks in enumerate(landmark_sequence):
+            if frame_landmarks is not None and landmark_name in frame_landmarks:
+                x, y, vis = frame_landmarks[landmark_name]
+                x_coords.append(x)
+                y_coords.append(y)
+                valid_frames.append(i)
+
+        if len(x_coords) < window_length:
+            continue
+
+        x_array = np.array(x_coords)
+        y_array = np.array(y_coords)
+
+        # Step 1: Outlier rejection
+        if use_outlier_rejection:
+            x_array, _ = reject_outliers(
+                x_array,
+                use_ransac=True,
+                use_median=True,
+                ransac_threshold=ransac_threshold,
+            )
+            y_array, _ = reject_outliers(
+                y_array,
+                use_ransac=True,
+                use_median=True,
+                ransac_threshold=ransac_threshold,
+            )
+
+        # Step 2: Smoothing (bilateral or Savitzky-Golay)
+        if use_bilateral:
+            x_smooth = bilateral_temporal_filter(
+                x_array,
+                window_size=window_length,
+                sigma_spatial=bilateral_sigma_spatial,
+                sigma_intensity=bilateral_sigma_intensity,
+            )
+            y_smooth = bilateral_temporal_filter(
+                y_array,
+                window_size=window_length,
+                sigma_spatial=bilateral_sigma_spatial,
+                sigma_intensity=bilateral_sigma_intensity,
+            )
+        else:
+            # Standard Savitzky-Golay
+            x_smooth = savgol_filter(x_array, window_length, polyorder)
+            y_smooth = savgol_filter(y_array, window_length, polyorder)
+
+        # Store smoothed values back
+        for idx, frame_idx in enumerate(valid_frames):
+            if frame_idx >= len(smoothed_sequence):
+                smoothed_sequence.extend(
+                    [{}] * (frame_idx - len(smoothed_sequence) + 1)
+                )
+
+            # Ensure smoothed_sequence[frame_idx] is a dict, not None
+            if smoothed_sequence[frame_idx] is None:
+                smoothed_sequence[frame_idx] = {}
+
+            if (
+                landmark_name not in smoothed_sequence[frame_idx]  # type: ignore[operator]
+                and landmark_sequence[frame_idx] is not None
+            ):
+                # Keep original visibility
+                orig_vis = landmark_sequence[frame_idx][landmark_name][2]  # type: ignore[index]
+                smoothed_sequence[frame_idx][landmark_name] = (  # type: ignore[index]
+                    float(x_smooth[idx]),
+                    float(y_smooth[idx]),
+                    orig_vis,
+                )
+
+    # Fill in any missing frames with original data
+    for i in range(len(landmark_sequence)):
+        if i >= len(smoothed_sequence) or not smoothed_sequence[i]:
+            if i < len(smoothed_sequence):
+                smoothed_sequence[i] = landmark_sequence[i]
+            else:
+                smoothed_sequence.append(landmark_sequence[i])
+
+    return smoothed_sequence

kinemotion/core/video_io.py

@@ -0,0 +1,122 @@
+"""Generic video I/O functionality for all jump analysis types."""
+
+import json
+import subprocess
+
+import cv2
+import numpy as np
+
+
+class VideoProcessor:
+    """
+    Handles video reading and processing.
+
+    IMPORTANT: This class preserves the exact aspect ratio of the source video.
+    No dimensions are hardcoded - all dimensions are extracted from actual frame data.
+    """
+
+    def __init__(self, video_path: str):
+        """
+        Initialize video processor.
+
+        Args:
+            video_path: Path to input video file
+        """
+        self.video_path = video_path
+        self.cap = cv2.VideoCapture(video_path)
+
+        if not self.cap.isOpened():
+            raise ValueError(f"Could not open video: {video_path}")
+
+        self.fps = self.cap.get(cv2.CAP_PROP_FPS)
+        self.frame_count = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))
+
+        # Read first frame to get actual dimensions
+        # This is critical for preserving aspect ratio, especially with mobile videos
+        # that have rotation metadata. OpenCV properties (CAP_PROP_FRAME_WIDTH/HEIGHT)
+        # may return incorrect dimensions, so we read the actual frame data.
+        ret, first_frame = self.cap.read()
+        if ret:
+            # frame.shape is (height, width, channels) - extract actual dimensions
+            self.height, self.width = first_frame.shape[:2]
+            self.cap.set(cv2.CAP_PROP_POS_FRAMES, 0)  # Reset to beginning
+        else:
+            # Fallback to video properties if can't read frame
+            self.width = int(self.cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+            self.height = int(self.cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+
+        # Calculate display dimensions considering SAR (Sample Aspect Ratio)
+        # Mobile videos often have non-square pixels encoded in SAR metadata
+        # OpenCV doesn't directly expose SAR, but we need to handle display correctly
+        self.display_width = self.width
+        self.display_height = self.height
+        self._calculate_display_dimensions()
+
+    def _calculate_display_dimensions(self) -> None:
+        """
+        Calculate display dimensions by reading SAR metadata from video file.
+
+        Many mobile videos use non-square pixels (SAR != 1:1), which means
+        the encoded dimensions differ from how the video should be displayed.
+        We use ffprobe to extract this metadata.
+        """
+        try:
+            # Use ffprobe to get SAR metadata
+            result = subprocess.run(
+                [
+                    "ffprobe",
+                    "-v",
+                    "quiet",
+                    "-print_format",
+                    "json",
+                    "-show_streams",
+                    "-select_streams",
+                    "v:0",
+                    self.video_path,
+                ],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+
+            if result.returncode == 0:
+                data = json.loads(result.stdout)
+                if "streams" in data and len(data["streams"]) > 0:
+                    stream = data["streams"][0]
+                    sar_str = stream.get("sample_aspect_ratio", "1:1")
+
+                    # Parse SAR (e.g., "270:473")
+                    if sar_str and ":" in sar_str:
+                        sar_parts = sar_str.split(":")
+                        sar_width = int(sar_parts[0])
+                        sar_height = int(sar_parts[1])
+
+                        # Calculate display dimensions
+                        # DAR = (width * SAR_width) / (height * SAR_height)
+                        if sar_width != sar_height:
+                            self.display_width = int(
+                                self.width * sar_width / sar_height
+                            )
+                            self.display_height = self.height
+        except (subprocess.TimeoutExpired, FileNotFoundError, json.JSONDecodeError):
+            # If ffprobe fails, keep original dimensions (square pixels)
+            pass
+
+    def read_frame(self) -> np.ndarray | None:
+        """Read next frame from video."""
+        ret, frame = self.cap.read()
+        return frame if ret else None
+
+    def reset(self) -> None:
+        """Reset video to beginning."""
+        self.cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
+
+    def close(self) -> None:
+        """Release video capture."""
+        self.cap.release()
+
+    def __enter__(self) -> "VideoProcessor":
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:  # type: ignore[no-untyped-def]
+        self.close()

kinemotion/dropjump/__init__.py

@@ -0,0 +1,29 @@
+"""Drop jump analysis module."""
+
+from .analysis import (
+    ContactState,
+    calculate_adaptive_threshold,
+    compute_average_foot_position,
+    detect_ground_contact,
+    find_interpolated_phase_transitions_with_curvature,
+    interpolate_threshold_crossing,
+    refine_transition_with_curvature,
+)
+from .debug_overlay import DebugOverlayRenderer
+from .kinematics import DropJumpMetrics, calculate_drop_jump_metrics
+
+__all__ = [
+    # Contact detection
+    "ContactState",
+    "detect_ground_contact",
+    "compute_average_foot_position",
+    "calculate_adaptive_threshold",
+    "interpolate_threshold_crossing",
+    "refine_transition_with_curvature",
+    "find_interpolated_phase_transitions_with_curvature",
+    # Metrics
+    "DropJumpMetrics",
+    "calculate_drop_jump_metrics",
+    # Debug overlay
+    "DebugOverlayRenderer",
+]

dropjump/contact_detection.py → kinemotion/dropjump/analysis.py

@@ -4,7 +4,7 @@ from enum import Enum
 
 import numpy as np
 
-from .smoothing import (
+from ..core.smoothing import (
     compute_acceleration_from_derivative,
     compute_velocity_from_derivative,
 )
@@ -18,6 +18,77 @@ class ContactState(Enum):
     UNKNOWN = "unknown"
 
 
+def calculate_adaptive_threshold(
+    positions: np.ndarray,
+    fps: float,
+    baseline_duration: float = 3.0,
+    multiplier: float = 1.5,
+    smoothing_window: int = 5,
+    polyorder: int = 2,
+) -> float:
+    """
+    Calculate adaptive velocity threshold based on baseline motion characteristics.
+
+    Analyzes the first few seconds of video (assumed to be relatively stationary,
+    e.g., athlete standing on box) to determine the noise floor, then sets threshold
+    as a multiple of this baseline noise.
+
+    This adapts to:
+    - Different camera distances (closer = more pixel movement)
+    - Different lighting conditions (affects tracking quality)
+    - Different frame rates (higher fps = smoother motion)
+    - Video compression artifacts
+
+    Args:
+        positions: Array of vertical positions (0-1 normalized)
+        fps: Video frame rate
+        baseline_duration: Duration in seconds to analyze for baseline (default: 3.0s)
+        multiplier: Factor above baseline noise to set threshold (default: 1.5x)
+        smoothing_window: Window size for velocity computation
+        polyorder: Polynomial order for Savitzky-Golay filter (default: 2)
+
+    Returns:
+        Adaptive velocity threshold value
+
+    Example:
+        At 30fps with 3s baseline:
+        - Analyzes first 90 frames
+        - Computes velocity for this "stationary" period
+        - 95th percentile velocity = 0.012 (noise level)
+        - Threshold = 0.012 × 1.5 = 0.018
+    """
+    if len(positions) < 2:
+        return 0.02  # Fallback to default
+
+    # Calculate number of frames for baseline analysis
+    baseline_frames = int(fps * baseline_duration)
+    baseline_frames = min(baseline_frames, len(positions))
+
+    if baseline_frames < smoothing_window:
+        return 0.02  # Not enough data, use default
+
+    # Extract baseline period (assumed relatively stationary)
+    baseline_positions = positions[:baseline_frames]
+
+    # Compute velocity for baseline period using derivative
+    baseline_velocities = compute_velocity_from_derivative(
+        baseline_positions, window_length=smoothing_window, polyorder=polyorder
+    )
+
+    # Calculate noise floor as 95th percentile of baseline velocities
+    # Using 95th percentile instead of max to be robust against outliers
+    noise_floor = float(np.percentile(np.abs(baseline_velocities), 95))
+
+    # Set threshold as multiplier of noise floor
+    # Minimum threshold to avoid being too sensitive
+    adaptive_threshold = max(noise_floor * multiplier, 0.005)
+
+    # Maximum threshold to ensure we still detect contact
+    adaptive_threshold = min(adaptive_threshold, 0.05)
+
+    return adaptive_threshold
+
+
 def detect_ground_contact(
     foot_positions: np.ndarray,
     velocity_threshold: float = 0.02,
@@ -245,6 +316,7 @@ def refine_transition_with_curvature(
     transition_type: str,
     search_window: int = 3,
     smoothing_window: int = 5,
+    polyorder: int = 2,
 ) -> float:
     """
     Refine phase transition timing using trajectory curvature analysis.
@@ -259,6 +331,7 @@ def refine_transition_with_curvature(
         transition_type: Type of transition ("landing" or "takeoff")
         search_window: Number of frames to search around estimate
         smoothing_window: Window size for acceleration computation
+        polyorder: Polynomial order for Savitzky-Golay filter (default: 2)
 
     Returns:
         Refined fractional frame index
@@ -268,7 +341,7 @@ def refine_transition_with_curvature(
 
     # Compute acceleration (second derivative)
     acceleration = compute_acceleration_from_derivative(
-        foot_positions, window_length=smoothing_window, polyorder=2
+        foot_positions, window_length=smoothing_window, polyorder=polyorder
     )
 
     # Define search range around estimated transition
@@ -319,6 +392,7 @@ def find_interpolated_phase_transitions_with_curvature(
     contact_states: list[ContactState],
     velocity_threshold: float,
     smoothing_window: int = 5,
+    polyorder: int = 2,
     use_curvature: bool = True,
 ) -> list[tuple[float, float, ContactState]]:
     """
@@ -334,6 +408,7 @@ def find_interpolated_phase_transitions_with_curvature(
         contact_states: List of ContactState for each frame
         velocity_threshold: Threshold used for contact detection
         smoothing_window: Window size for velocity/acceleration smoothing
+        polyorder: Polynomial order for Savitzky-Golay filter (default: 2)
         use_curvature: Whether to apply curvature-based refinement
 
     Returns:
@@ -362,6 +437,7 @@ def find_interpolated_phase_transitions_with_curvature(
                 "landing",
                 search_window=3,
                 smoothing_window=smoothing_window,
+                polyorder=polyorder,
             )
             # Refine takeoff (end of ground contact)
             refined_end = refine_transition_with_curvature(
@@ -370,6 +446,7 @@ def find_interpolated_phase_transitions_with_curvature(
                 "takeoff",
                 search_window=3,
                 smoothing_window=smoothing_window,
+                polyorder=polyorder,
             )
 
         elif state == ContactState.IN_AIR:
@@ -380,6 +457,7 @@ def find_interpolated_phase_transitions_with_curvature(
                 "takeoff",
                 search_window=3,
                 smoothing_window=smoothing_window,
+                polyorder=polyorder,
             )
             refined_end = refine_transition_with_curvature(
                 foot_positions,
@@ -387,6 +465,7 @@ def find_interpolated_phase_transitions_with_curvature(
                 "landing",
                 search_window=3,
                 smoothing_window=smoothing_window,
+                polyorder=polyorder,
             )
 
         refined_phases.append((refined_start, refined_end, state))