kinemotion 0.26.0__py3-none-any.whl → 0.26.1__py3-none-any.whl

kinemotion/api.py

@@ -244,6 +244,20 @@ def _apply_smoothing(
         )
 
 
+def _calculate_foot_visibility(frame_landmarks: dict) -> float:
+    """Calculate average visibility of foot landmarks.
+
+    Args:
+        frame_landmarks: Dictionary of landmarks for a frame
+
+    Returns:
+        Average visibility value (0-1)
+    """
+    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]
+    return float(np.mean(foot_vis)) if foot_vis else 0.0
+
+
 def _extract_vertical_positions(
     smoothed_landmarks: list,
 ) -> tuple[np.ndarray, np.ndarray]:
@@ -262,13 +276,7 @@ def _extract_vertical_positions(
         if frame_landmarks:
             _, foot_y = compute_average_foot_position(frame_landmarks)
             position_list.append(foot_y)
-
-            # Average visibility of foot landmarks
-            foot_vis = []
-            for key in ["left_ankle", "right_ankle", "left_heel", "right_heel"]:
-                if key in frame_landmarks:
-                    foot_vis.append(frame_landmarks[key][2])
-            visibilities_list.append(float(np.mean(foot_vis)) if foot_vis else 0.0)
+            visibilities_list.append(_calculate_foot_visibility(frame_landmarks))
         else:
             position_list.append(position_list[-1] if position_list else 0.5)
             visibilities_list.append(0.0)

kinemotion/dropjump/analysis.py

@@ -235,6 +235,86 @@ def detect_drop_start(
     )
 
 
+def _filter_stationary_with_visibility(
+    is_stationary: np.ndarray,
+    visibilities: np.ndarray | None,
+    visibility_threshold: float,
+) -> np.ndarray:
+    """Apply visibility filter to stationary flags.
+
+    Args:
+        is_stationary: Boolean array indicating stationary frames
+        visibilities: Optional visibility scores for each frame
+        visibility_threshold: Minimum visibility to trust landmark
+
+    Returns:
+        Filtered is_stationary array
+    """
+    if visibilities is not None:
+        is_visible = visibilities > visibility_threshold
+        return is_stationary & is_visible
+    return is_stationary
+
+
+def _find_contact_frames(
+    is_stationary: np.ndarray,
+    min_contact_frames: int,
+) -> set[int]:
+    """Find frames with sustained contact using minimum duration filter.
+
+    Args:
+        is_stationary: Boolean array indicating stationary frames
+        min_contact_frames: Minimum consecutive frames to confirm contact
+
+    Returns:
+        Set of frame indices that meet minimum contact duration
+    """
+    contact_frames: set[int] = set()
+    current_run = []
+
+    for i, stationary in enumerate(is_stationary):
+        if stationary:
+            current_run.append(i)
+        else:
+            if len(current_run) >= min_contact_frames:
+                contact_frames.update(current_run)
+            current_run = []
+
+    # Handle last run
+    if len(current_run) >= min_contact_frames:
+        contact_frames.update(current_run)
+
+    return contact_frames
+
+
+def _assign_contact_states(
+    n_frames: int,
+    contact_frames: set[int],
+    visibilities: np.ndarray | None,
+    visibility_threshold: float,
+) -> list[ContactState]:
+    """Assign contact states based on contact frames and visibility.
+
+    Args:
+        n_frames: Total number of frames
+        contact_frames: Set of frames with confirmed contact
+        visibilities: Optional visibility scores for each frame
+        visibility_threshold: Minimum visibility to trust landmark
+
+    Returns:
+        List of ContactState for each frame
+    """
+    states = []
+    for i in range(n_frames):
+        if visibilities is not None and visibilities[i] < visibility_threshold:
+            states.append(ContactState.UNKNOWN)
+        elif i in contact_frames:
+            states.append(ContactState.ON_GROUND)
+        else:
+            states.append(ContactState.IN_AIR)
+    return states
+
+
 def detect_ground_contact(
     foot_positions: np.ndarray,
     velocity_threshold: float = 0.02,
@@ -247,7 +327,7 @@ def detect_ground_contact(
     """
     Detect when feet are in contact with ground based on vertical motion.
 
-    Uses derivative-based velocity calculation via Savitzky-Golay filter for smooth,
+    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.
 
@@ -264,52 +344,30 @@ def detect_ground_contact(
         List of ContactState for each frame
     """
     n_frames = len(foot_positions)
-    states = [ContactState.UNKNOWN] * n_frames
 
     if n_frames < 2:
-        return states
+        return [ContactState.UNKNOWN] * n_frames
 
     # Compute vertical velocity using derivative-based method
-    # This provides smoother, more accurate velocity estimates than frame-to-frame differences
-    # and is consistent with the velocity calculation used for sub-frame interpolation
     velocities = compute_velocity_from_derivative(
         foot_positions, window_length=window_length, polyorder=polyorder
     )
 
-    # Detect potential contact frames based on low velocity
+    # Detect stationary frames based on velocity threshold
     is_stationary = np.abs(velocities) < velocity_threshold
 
     # Apply visibility filter
-    if visibilities is not None:
-        is_visible = visibilities > visibility_threshold
-        is_stationary = is_stationary & is_visible
-
-    # Apply minimum contact duration filter
-    contact_frames = []
-    current_run = []
-
-    for i, stationary in enumerate(is_stationary):
-        if stationary:
-            current_run.append(i)
-        else:
-            if len(current_run) >= min_contact_frames:
-                contact_frames.extend(current_run)
-            current_run = []
-
-    # Don't forget the last run
-    if len(current_run) >= min_contact_frames:
-        contact_frames.extend(current_run)
+    is_stationary = _filter_stationary_with_visibility(
+        is_stationary, visibilities, visibility_threshold
+    )
 
-    # Set states
-    for i in range(n_frames):
-        if visibilities is not None and visibilities[i] < visibility_threshold:
-            states[i] = ContactState.UNKNOWN
-        elif i in contact_frames:
-            states[i] = ContactState.ON_GROUND
-        else:
-            states[i] = ContactState.IN_AIR
+    # Find frames with sustained contact
+    contact_frames = _find_contact_frames(is_stationary, min_contact_frames)
 
-    return states
+    # Assign states
+    return _assign_contact_states(
+        n_frames, contact_frames, visibilities, visibility_threshold
+    )
 
 
 def find_contact_phases(

{kinemotion-0.26.0.dist-info → kinemotion-0.26.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinemotion
-Version: 0.26.0
+Version: 0.26.1
 Summary: Video-based kinematic analysis for athletic performance
 Project-URL: Homepage, https://github.com/feniix/kinemotion
 Project-URL: Repository, https://github.com/feniix/kinemotion

{kinemotion-0.26.0.dist-info → kinemotion-0.26.1.dist-info}/RECORD

@@ -1,5 +1,5 @@
 kinemotion/__init__.py,sha256=vAEIg-oDX1ZkQMnWgXd__tekaA5KUcEvdJSAGWS8VUY,722
-kinemotion/api.py,sha256=3oLJEjtHweG85t_BG1nCWnZ-8yl3tGW_6ZoBAILMfJw,38006
+kinemotion/api.py,sha256=ELkAk0xq2MaafVwSAahXIf1KP9am8rpxHibqcnId6pg,38213
 kinemotion/cli.py,sha256=cqYV_7URH0JUDy1VQ_EDLv63FmNO4Ns20m6s1XAjiP4,464
 kinemotion/cmj/__init__.py,sha256=Ynv0-Oco4I3Y1Ubj25m3h9h2XFqeNwpAewXmAYOmwfU,127
 kinemotion/cmj/analysis.py,sha256=4HYGn4VDIB6oExAees-VcPfpNgWOltpgwjyNTU7YAb4,18263
@@ -18,13 +18,13 @@ kinemotion/core/quality.py,sha256=OC9nuf5IrQ9xURf3eA50VoNWOqkGwbjJpS90q2FDQzA,13
 kinemotion/core/smoothing.py,sha256=x4o3BnG6k8OaV3emgpoJDF84CE9k5RYR7BeSYH_-8Es,14092
 kinemotion/core/video_io.py,sha256=0bJTheYidEqxGP5Y2dSO2x6sbOrnBDBu2TEiV8gT23A,7285
 kinemotion/dropjump/__init__.py,sha256=yc1XiZ9vfo5h_n7PKVSiX2TTgaIfGL7Y7SkQtiDZj_E,838
-kinemotion/dropjump/analysis.py,sha256=1AsIsgWg5wuwJo7poFK7aMCFr93yHVms-fEvaOGQQWs,27448
+kinemotion/dropjump/analysis.py,sha256=BQ5NqSPNJjFQOb-W4bXSLvjCgWd-nvqx5NElyeqZJC4,29067
 kinemotion/dropjump/cli.py,sha256=ZyroaYPwz8TgfL39Wcaj6m68Awl6lYXC75ttaflU-c0,16236
 kinemotion/dropjump/debug_overlay.py,sha256=LkPw6ucb7beoYWS4L-Lvjs1KLCm5wAWDAfiznUeV2IQ,5668
 kinemotion/dropjump/kinematics.py,sha256=Ig9TqXr-OEUm19gqIvUjQkqrCuw1csYt1f4ZfwG8oGc,17464
 kinemotion/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kinemotion-0.26.0.dist-info/METADATA,sha256=8v4nga4_2u750MvPwawuPG4DdqGce2NY4jtVBZ69UK4,23244
-kinemotion-0.26.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-kinemotion-0.26.0.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
-kinemotion-0.26.0.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
-kinemotion-0.26.0.dist-info/RECORD,,
+kinemotion-0.26.1.dist-info/METADATA,sha256=4Ads7Gis9jvPj3qOXQBwyGB6c3wJr8kkVWpX-kKwI1Q,23244
+kinemotion-0.26.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+kinemotion-0.26.1.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
+kinemotion-0.26.1.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
+kinemotion-0.26.1.dist-info/RECORD,,