kinemotion 0.38.1__py3-none-any.whl → 0.39.0__py3-none-any.whl

kinemotion/api.py

@@ -8,7 +8,7 @@ from pathlib import Path
 
 import numpy as np
 
-from .cmj.analysis import detect_cmj_phases
+from .cmj.analysis import compute_average_hip_position, detect_cmj_phases
 from .cmj.debug_overlay import CMJDebugOverlayRenderer
 from .cmj.kinematics import CMJMetrics, calculate_cmj_metrics
 from .cmj.metrics_validator import CMJMetricsValidator
@@ -263,11 +263,13 @@ def _calculate_foot_visibility(frame_landmarks: dict) -> float:
 
 def _extract_vertical_positions(
     smoothed_landmarks: list,
+    target: str = "foot",
 ) -> tuple[np.ndarray, np.ndarray]:
-    """Extract vertical foot positions and visibilities from smoothed landmarks.
+    """Extract vertical positions and visibilities from smoothed landmarks.
 
     Args:
         smoothed_landmarks: Smoothed landmark sequence
+        target: Tracking target "foot" or "hip" (default: "foot")
 
     Returns:
         Tuple of (vertical_positions, visibilities) as numpy arrays
@@ -277,9 +279,23 @@ def _extract_vertical_positions(
 
     for frame_landmarks in smoothed_landmarks:
         if frame_landmarks:
-            _, foot_y = compute_average_foot_position(frame_landmarks)
-            position_list.append(foot_y)
-            visibilities_list.append(_calculate_foot_visibility(frame_landmarks))
+            if target == "hip":
+                _, y = compute_average_hip_position(frame_landmarks)
+                # For hips, we can use average visibility of hips if needed,
+                # but currently _calculate_foot_visibility is specific to feet.
+                # We'll stick to foot visibility for now as it indicates
+                # overall leg tracking quality, or we could implement
+                # _calculate_hip_visibility. For simplicity, we'll use foot
+                # visibility as a proxy for "body visibility" or just use 1.0
+                # since hips are usually visible if feet are. Actually, let's
+                # just use foot visibility for consistency in quality checks.
+                vis = _calculate_foot_visibility(frame_landmarks)
+            else:
+                _, y = compute_average_foot_position(frame_landmarks)
+                vis = _calculate_foot_visibility(frame_landmarks)
+
+            position_list.append(y)
+            visibilities_list.append(vis)
         else:
             position_list.append(position_list[-1] if position_list else 0.5)
             visibilities_list.append(0.0)
@@ -915,13 +931,21 @@ def process_cmj_video(
         # Apply smoothing
         smoothed_landmarks = _apply_smoothing(landmarks_sequence, params, verbose)
 
-        # Extract foot positions
+        # Extract vertical positions
         if verbose:
-            print("Extracting foot positions...")
+            print("Extracting vertical positions (Hip and Foot)...")
+
+        # Primary: Hips (for depth, velocity, general phases)
         vertical_positions, visibilities = _extract_vertical_positions(
-            smoothed_landmarks
+            smoothed_landmarks, target="hip"
         )
-        tracking_method = "foot"
+
+        # Secondary: Feet (for precise landing detection)
+        foot_positions, _ = _extract_vertical_positions(
+            smoothed_landmarks, target="foot"
+        )
+
+        tracking_method = "hip_hybrid"
 
         # Detect CMJ phases
         if verbose:
@@ -932,6 +956,7 @@ def process_cmj_video(
             video.fps,
             window_length=params.smoothing_window,
             polyorder=params.polyorder,
+            landing_positions=foot_positions,  # Use feet for landing
         )
 
         if phases is None:

kinemotion/cmj/analysis.py

@@ -390,36 +390,90 @@ def find_lowest_frame(
 
 
 def find_landing_frame(
-    accelerations: np.ndarray, peak_height_frame: int, fps: float
+    accelerations: np.ndarray,
+    velocities: np.ndarray,
+    peak_height_frame: int,
+    fps: float,
 ) -> float:
-    """Find landing frame after peak height after takeoff.
+    """Find landing frame after peak height.
+
+    Robust detection strategy:
+    1. Find peak downward velocity (maximum positive velocity) after peak height.
+       This corresponds to the moment just before or at initial ground contact.
+    2. Look for maximum deceleration (impact) *after* the peak velocity.
+       This filters out mid-air tracking noise/flutter that can cause false
+       deceleration spikes while the athlete is still accelerating downward.
 
-    Detects landing by finding the minimum acceleration (impact) in a search
-    window after peak height. The window is extended to 1.0s to ensure all
-    realistic flight times are captured.
+    Args:
+        accelerations: Vertical acceleration array (deriv=2)
+        velocities: Vertical velocity array (deriv=1)
+        peak_height_frame: Frame index of peak jump height
+        fps: Video frame rate
 
-    Robust detection: When accelerations are nearly flat, skips the impact
-    frames near peak height and looks for the actual landing signal.
+    Returns:
+        Frame index of landing impact.
     """
-    landing_search_start = peak_height_frame
     # Search window extended to 1.0s to accommodate all realistic flight times
-    # (recreational: 0.25-0.65s, elite: 0.65-0.95s, max: 1.1s)
-    landing_search_end = min(len(accelerations), peak_height_frame + int(fps * 1.0))
+    search_end = min(len(accelerations), peak_height_frame + int(fps * 1.0))
+
+    # 1. Find peak downward velocity (max positive value)
+    # Search from peak height to end of window
+    vel_search_window = velocities[peak_height_frame:search_end]
+
+    if len(vel_search_window) == 0:
+        return float(peak_height_frame + int(fps * 0.3))
+
+    # Index relative to peak_height_frame
+    peak_vel_rel_idx = int(np.argmax(vel_search_window))
+    peak_vel_frame = peak_height_frame + peak_vel_rel_idx
+
+    # 2. Search for impact (min acceleration) starting from peak velocity
+    # We allow a small buffer (e.g., 1-2 frames) before peak velocity just in case
+    # peak velocity coincides with impact start due to smoothing
+    landing_search_start = max(peak_height_frame, peak_vel_frame - 2)
+    landing_search_end = search_end
+
     landing_accelerations = accelerations[landing_search_start:landing_search_end]
 
     if len(landing_accelerations) == 0:
+        # Fallback if window is empty
         return float(peak_height_frame + int(fps * 0.3))
 
-    # Skip the first 2 frames after peak (often have unreliable acceleration)
-    # This avoids locking onto peak height acceleration instead of impact
-    skip_frames = 2
-    if len(landing_accelerations) > skip_frames:
-        landing_accelerations_filtered = landing_accelerations[skip_frames:]
-        landing_idx = int(np.argmin(landing_accelerations_filtered)) + skip_frames
-    else:
-        landing_idx = int(np.argmin(landing_accelerations))
+    # Find minimum acceleration (maximum deceleration spike)
+    landing_rel_idx = int(np.argmin(landing_accelerations))
+    landing_frame = landing_search_start + landing_rel_idx
+
+    return float(landing_frame)
 
-    return float(landing_search_start + landing_idx)
+
+def compute_average_hip_position(
+    landmarks: dict[str, tuple[float, float, float]],
+) -> tuple[float, float]:
+    """
+    Compute average hip position from hip landmarks.
+
+    Args:
+        landmarks: Dictionary of landmark positions
+
+    Returns:
+        (x, y) average hip position in normalized coordinates
+    """
+    hip_keys = ["left_hip", "right_hip"]
+
+    x_positions = []
+    y_positions = []
+
+    for key in hip_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)
+
+    if not x_positions:
+        return (0.5, 0.5)  # Default to center if no visible hips
+
+    return (float(np.mean(x_positions)), float(np.mean(y_positions)))
 
 
 def find_standing_end(
@@ -490,6 +544,7 @@ def detect_cmj_phases(
     fps: float,
     window_length: int = 5,
     polyorder: int = 2,
+    landing_positions: np.ndarray | None = None,
 ) -> tuple[float | None, float, float, float] | None:
     """
     Detect all phases of a counter movement jump using a simplified, robust approach.
@@ -501,16 +556,18 @@ def detect_cmj_phases(
     4. Find landing (impact after peak height)
 
     Args:
-        positions: Array of vertical positions (normalized 0-1)
+        positions: Array of vertical positions (normalized 0-1). Typically Hips/CoM.
         fps: Video frame rate
         window_length: Window size for derivative calculations
         polyorder: Polynomial order for Savitzky-Golay filter
+        landing_positions: Optional array of positions for landing detection
+            (e.g., Feet). If None, uses `positions` (Hips) for landing too.
 
     Returns:
         Tuple of (standing_end_frame, lowest_point_frame, takeoff_frame, landing_frame)
         with fractional precision, or None if phases cannot be detected.
     """
-    # Compute SIGNED velocities and accelerations
+    # Compute SIGNED velocities and accelerations for primary signal (Hips)
     velocities = compute_signed_velocity(
         positions, window_length=window_length, polyorder=polyorder
     )
@@ -526,7 +583,32 @@ def detect_cmj_phases(
     # Step 2-4: Find all phases using helper functions
     takeoff_frame = find_takeoff_frame(velocities, peak_height_frame, fps)
     lowest_point = find_lowest_frame(velocities, positions, takeoff_frame, fps)
-    landing_frame = find_landing_frame(accelerations, peak_height_frame, fps)
-    standing_end = find_standing_end(velocities, lowest_point, positions, accelerations)
 
+    # Determine landing frame
+    if landing_positions is not None:
+        # Use specific landing signal (Feet) for landing detection
+        landing_velocities = compute_signed_velocity(
+            landing_positions, window_length=window_length, polyorder=polyorder
+        )
+        landing_accelerations = compute_acceleration_from_derivative(
+            landing_positions, window_length=window_length, polyorder=polyorder
+        )
+        # We still reference peak_height_frame from Hips, as Feet peak
+        # might be different/noisy but generally they align in time.
+        landing_frame = find_landing_frame(
+            landing_accelerations,
+            landing_velocities,
+            peak_height_frame,
+            fps,
+        )
+    else:
+        # Use primary signal (Hips)
+        landing_frame = find_landing_frame(
+            accelerations,
+            velocities,
+            peak_height_frame,
+            fps,
+        )
+
+    standing_end = find_standing_end(velocities, lowest_point, positions, accelerations)
     return (standing_end, lowest_point, takeoff_frame, landing_frame)

kinemotion/cmj/kinematics.py

@@ -180,6 +180,24 @@ def calculate_cmj_metrics(
     g = 9.81  # gravity in m/s^2
     jump_height = (g * flight_time**2) / 8
 
+    # Determine scaling factor (meters per normalized unit)
+    # We use the flight phase displacement in normalized units compared to
+    # kinematic jump height
+    flight_start_idx = int(takeoff_frame)
+    flight_end_idx = int(landing_frame)
+    flight_positions = positions[flight_start_idx:flight_end_idx]
+
+    scale_factor = 0.0
+    if len(flight_positions) > 0:
+        # Peak height is minimum y value (highest point in frame)
+        peak_flight_pos = np.min(flight_positions)
+        takeoff_pos = positions[flight_start_idx]
+        # Displacement is upward (takeoff_pos - peak_pos) because y decreases upward
+        flight_displacement = takeoff_pos - peak_flight_pos
+
+        if flight_displacement > 0.001:  # Avoid division by zero or noise
+            scale_factor = jump_height / flight_displacement
+
     # Calculate countermovement depth
     if standing_start_frame is not None:
         standing_position = positions[int(standing_start_frame)]
@@ -188,7 +206,10 @@ def calculate_cmj_metrics(
         standing_position = positions[0]
 
     lowest_position = positions[int(lowest_point_frame)]
-    countermovement_depth = abs(standing_position - lowest_position)
+    # Depth in normalized units
+    depth_normalized = abs(standing_position - lowest_position)
+    # Convert to meters
+    countermovement_depth = depth_normalized * scale_factor
 
     # Calculate phase durations
     if standing_start_frame is not None:
@@ -201,8 +222,12 @@ def calculate_cmj_metrics(
 
     concentric_duration = (takeoff_frame - lowest_point_frame) / fps
 
+    # Velocity scaling factor: units/frame -> meters/second
+    # v_m_s = v_units_frame * fps * scale_factor
+    velocity_scale = scale_factor * fps
+
     # Calculate peak velocities
-    # Eccentric phase: negative velocities (downward)
+    # Eccentric phase: Downward motion = Positive velocity in image coords
     if standing_start_frame is not None:
         eccentric_start_idx = int(standing_start_frame)
     else:
@@ -212,18 +237,26 @@ def calculate_cmj_metrics(
     eccentric_velocities = velocities[eccentric_start_idx:eccentric_end_idx]
 
     if len(eccentric_velocities) > 0:
-        # Peak eccentric velocity is most negative value
-        peak_eccentric_velocity = float(np.min(eccentric_velocities))
+        # Peak eccentric velocity is maximum positive value (fastest downward)
+        # We take max and ensure it's positive (it should be)
+        peak_eccentric_velocity = float(np.max(eccentric_velocities)) * velocity_scale
+        # If max is negative (weird), it means no downward motion detected
+        if peak_eccentric_velocity < 0:
+            peak_eccentric_velocity = 0.0
     else:
         peak_eccentric_velocity = 0.0
 
-    # Concentric phase: positive velocities (upward)
+    # Concentric phase: Upward motion = Negative velocity in image coords
     concentric_start_idx = int(lowest_point_frame)
     concentric_end_idx = int(takeoff_frame)
     concentric_velocities = velocities[concentric_start_idx:concentric_end_idx]
 
     if len(concentric_velocities) > 0:
-        peak_concentric_velocity = float(np.max(concentric_velocities))
+        # Peak concentric velocity is minimum value (most negative = fastest upward)
+        # We take abs to report magnitude
+        peak_concentric_velocity = (
+            abs(float(np.min(concentric_velocities))) * velocity_scale
+        )
     else:
         peak_concentric_velocity = 0.0
 

kinemotion/dropjump/analysis.py

@@ -704,8 +704,8 @@ def find_landing_from_acceleration(
     """
     Find landing frame by detecting impact acceleration after takeoff.
 
-    Similar to CMJ landing detection, looks for maximum positive acceleration
-    (deceleration on ground impact) after the jump peak.
+    Detects the moment of initial ground contact, characterized by a sharp
+    deceleration (positive acceleration spike) as downward velocity is arrested.
 
     Args:
         positions: Array of vertical positions (normalized 0-1)
@@ -736,29 +736,11 @@ def find_landing_from_acceleration(
     if landing_search_end <= landing_search_start:
         return min(len(positions) - 1, peak_frame + int(fps * 0.2))
 
-    # Find impact: maximum positive acceleration after peak
+    # 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.argmax(landing_accelerations))
-    impact_frame = landing_search_start + impact_idx
-
-    # After acceleration peak, look for position stabilization (full ground contact)
-    # Check where vertical position stops decreasing (athlete stops compressing)
-    stabilization_search_start = impact_frame
-    stabilization_search_end = min(len(positions), impact_frame + int(fps * 0.2))
-
-    landing_frame = impact_frame
-    if stabilization_search_end > stabilization_search_start + 3:
-        # Find where position reaches maximum (lowest point) and starts stabilizing
-        search_positions = positions[
-            stabilization_search_start:stabilization_search_end
-        ]
-
-        # Look for the frame where position reaches its maximum (deepest landing)
-        max_pos_idx = int(np.argmax(search_positions))
-
-        # Landing is just after max position (athlete at deepest landing compression)
-        landing_frame = stabilization_search_start + max_pos_idx
-        landing_frame = min(len(positions) - 1, landing_frame)
+    impact_idx = int(np.argmin(landing_accelerations))
+    landing_frame = landing_search_start + impact_idx
 
     return landing_frame
 

kinemotion/dropjump/kinematics.py

@@ -28,6 +28,7 @@ class DropJumpDataDict(TypedDict, total=False):
     flight_time_ms: float | None
     jump_height_m: float | None
     jump_height_kinematic_m: float | None
+    jump_height_trajectory_m: float | None
     jump_height_trajectory_normalized: float | None
     contact_start_frame: int | None
     contact_end_frame: int | None
@@ -56,7 +57,10 @@ class DropJumpMetrics:
         self.flight_time: float | None = None
         self.jump_height: float | None = None
         self.jump_height_kinematic: float | None = None  # From flight time
-        self.jump_height_trajectory: float | None = None  # From position tracking
+        # From position tracking (normalized)
+        self.jump_height_trajectory: float | None = None
+        # From position tracking (meters)
+        self.jump_height_trajectory_m: float | None = None
         self.drop_start_frame: int | None = None  # Frame when athlete leaves box
         self.contact_start_frame: int | None = None
         self.contact_end_frame: int | None = None
@@ -90,6 +94,9 @@ class DropJumpMetrics:
             "jump_height_kinematic_m": format_float_metric(
                 self.jump_height_kinematic, 1, 3
             ),
+            "jump_height_trajectory_m": format_float_metric(
+                self.jump_height_trajectory_m, 1, 3
+            ),
             "jump_height_trajectory_normalized": format_float_metric(
                 self.jump_height_trajectory, 1, 4
             ),
@@ -408,6 +415,14 @@ def _analyze_flight_phase(
         height_normalized = float(takeoff_position - peak_position)
         metrics.jump_height_trajectory = height_normalized
 
+        # Calculate scale factor and metric height
+        # Scale factor = kinematic height / normalized height
+        if height_normalized > 0.001:
+            scale_factor = metrics.jump_height_kinematic / height_normalized
+            metrics.jump_height_trajectory_m = height_normalized * scale_factor
+        else:
+            metrics.jump_height_trajectory_m = 0.0
+
 
 def calculate_drop_jump_metrics(
     contact_states: list[ContactState],

kinemotion/dropjump/metrics_validator.py

@@ -83,7 +83,7 @@ class DropJumpMetricsValidator(MetricsValidator):
         flight_time_ms = data.get("flight_time_ms")
         jump_height_m = data.get("jump_height_m")
         jump_height_kinematic_m = data.get("jump_height_kinematic_m")
-        jump_height_trajectory_m = data.get("jump_height_trajectory_normalized")
+        jump_height_trajectory_m = data.get("jump_height_trajectory_m")
 
         # Validate individual metrics
         if contact_time_ms is not None:

{kinemotion-0.38.1.dist-info → kinemotion-0.39.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinemotion
-Version: 0.38.1
+Version: 0.39.0
 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.38.1.dist-info → kinemotion-0.39.0.dist-info}/RECORD

@@ -1,12 +1,12 @@
 kinemotion/__init__.py,sha256=wPItmyGJUOFM6GPRVhAEvRz0-ErI7e2qiUREYJ9EfPQ,943
-kinemotion/api.py,sha256=HdbdPxc6MTJO6lldYgfKGaF7SZuroKcWITS7rjhL8PA,39764
+kinemotion/api.py,sha256=1MsBvkznlP_OaBZ37a0hG9uMTESv2iJMHR01tnPv5sA,41046
 kinemotion/cli.py,sha256=cqYV_7URH0JUDy1VQ_EDLv63FmNO4Ns20m6s1XAjiP4,464
 kinemotion/cmj/__init__.py,sha256=Ynv0-Oco4I3Y1Ubj25m3h9h2XFqeNwpAewXmAYOmwfU,127
-kinemotion/cmj/analysis.py,sha256=OfNTMLPwZIRYbX-Yd8jgZ-7pqnHRz7L2bWAHVYFsQ60,18955
+kinemotion/cmj/analysis.py,sha256=qtULzp9uYzm5M0_Qu5YGJpuwjg9fz1VKAg6xg4NJxvM,21639
 kinemotion/cmj/cli.py,sha256=Mj2h9It1jVjAauvtCxfLWTRijj7zbYhxZuebhw2Zz6w,10828
 kinemotion/cmj/debug_overlay.py,sha256=fXmWoHhqMLGo4vTtB6Ezs3yLUDOLw63zLIgU2gFlJQU,15892
 kinemotion/cmj/joint_angles.py,sha256=HmheIEiKcQz39cRezk4h-htorOhGNPsqKIR9RsAEKts,9960
-kinemotion/cmj/kinematics.py,sha256=qRBe87NkX-7HQTQ8RoF-EpvfcffgP5vycJJRrxpHboc,10307
+kinemotion/cmj/kinematics.py,sha256=Lq9m9MNQxnXv31VhKmXVrlM7rRkhi8PxW50N_CC8_8Y,11860
 kinemotion/cmj/metrics_validator.py,sha256=V_fmlczYH06SBtwqESv-IfGi3wDsIy3RQbd7VwOyNo0,31359
 kinemotion/cmj/validation_bounds.py,sha256=9ZTo68fl3ooyWjXXyTMRLpK9tFANa_rQf3oHhq7iQGE,11995
 kinemotion/core/__init__.py,sha256=HsqolRa60cW3vrG8F9Lvr9WvWcs5hCmsTzSgo7imi-4,1278
@@ -24,15 +24,15 @@ kinemotion/core/smoothing.py,sha256=GAfC-jxu1eqNyDjsUXqUBicKx9um5hrk49wz1FxfRNM,
 kinemotion/core/validation.py,sha256=LmKfSl4Ayw3DgwKD9IrhsPdzp5ia4drLsHA2UuU1SCM,6310
 kinemotion/core/video_io.py,sha256=fDdyYVIKqUSgCjBJa8l_S0SrDPDAhrWYfsDBNRuz1oM,7549
 kinemotion/dropjump/__init__.py,sha256=tC3H3BrCg8Oj-db-Vrtx4PH_llR1Ppkd5jwaOjhQcLg,862
-kinemotion/dropjump/analysis.py,sha256=B_N_51WoChyQ8I7yaeKeqj3vw7NufgV_3QL-FBZEtW4,28752
+kinemotion/dropjump/analysis.py,sha256=MjxO-vps0nz_hXlnGk7cgq3jFenJYzsM0VVpHwnHXsM,27935
 kinemotion/dropjump/cli.py,sha256=n_Wfv3AC6YIgRPYhO3F2nTSai0NR7fh95nAoWjryQeY,16250
 kinemotion/dropjump/debug_overlay.py,sha256=LkPw6ucb7beoYWS4L-Lvjs1KLCm5wAWDAfiznUeV2IQ,5668
-kinemotion/dropjump/kinematics.py,sha256=GhCyXPjVcs7uNt7N9NbTlWzzmoOoMQ0EUdW4j2pomcw,18738
-kinemotion/dropjump/metrics_validator.py,sha256=sx4RodHpeiW8_PRB0GUJvkUWto1Ard1Dvrc9z8eKk7M,9351
+kinemotion/dropjump/kinematics.py,sha256=kH-XM66wlOCYMpjvyb6_Qh5ZebyOfFZ47rmhgE1Tww4,19404
+kinemotion/dropjump/metrics_validator.py,sha256=CrTlGup8q2kyPXtA6HNwm7_yq0AsBaDllG7RVZdXmYA,9342
 kinemotion/dropjump/validation_bounds.py,sha256=5b4I3CKPybuvrbn-nP5yCcGF_sH4Vtyw3a5AWWvWnBk,4645
 kinemotion/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kinemotion-0.38.1.dist-info/METADATA,sha256=TSCrEkzEwuhfVd9h0OHi4bHEJVwm5PAKQC3YBAdmYh4,26020
-kinemotion-0.38.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-kinemotion-0.38.1.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
-kinemotion-0.38.1.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
-kinemotion-0.38.1.dist-info/RECORD,,
+kinemotion-0.39.0.dist-info/METADATA,sha256=ytvO76fvfntV_Vpjkc-4BezahvOO91a2I6X3PUM0eAk,26020
+kinemotion-0.39.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+kinemotion-0.39.0.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
+kinemotion-0.39.0.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
+kinemotion-0.39.0.dist-info/RECORD,,