kinemotion 0.41.2__py3-none-any.whl → 0.42.0__py3-none-any.whl

kinemotion/api.py

@@ -178,6 +178,7 @@ def _process_all_frames(
     tracker: PoseTracker,
     verbose: bool,
     timer: PerformanceTimer | None = None,
+    close_tracker: bool = True,
 ) -> tuple[list, list]:
     """Process all frames from video and extract pose landmarks.
 
@@ -186,6 +187,7 @@ def _process_all_frames(
         tracker: Pose tracker for landmark detection
         verbose: Print progress messages
         timer: Optional PerformanceTimer for measuring operations
+        close_tracker: Whether to close the tracker after processing (default: True)
 
     Returns:
         Tuple of (frames, landmarks_sequence)
@@ -219,7 +221,8 @@ def _process_all_frames(
             landmarks = tracker.process_frame(frame)
             landmarks_sequence.append(landmarks)
 
-    tracker.close()
+    if close_tracker:
+        tracker.close()
 
     if not landmarks_sequence:
         raise ValueError("No frames could be processed from video")
@@ -508,6 +511,7 @@ def process_dropjump_video(
     tracking_confidence: float | None = None,
     verbose: bool = False,
     timer: PerformanceTimer | None = None,
+    pose_tracker: "PoseTracker | None" = None,
 ) -> DropJumpMetrics:
     """
     Process a single drop jump video and return metrics.
@@ -528,6 +532,7 @@ def process_dropjump_video(
         tracking_confidence: Optional override for pose tracking confidence
         verbose: Print processing details
         timer: Optional PerformanceTimer for measuring operations
+        pose_tracker: Optional pre-initialized PoseTracker instance (reused if provided)
 
     Returns:
         DropJumpMetrics object containing analysis results
@@ -554,15 +559,9 @@ def process_dropjump_video(
     # Convert quality string to enum
     quality_preset = _parse_quality_preset(quality)
 
-    # Initialize video processor
+    # Load video
     with timer.measure("video_initialization"):
         with VideoProcessor(video_path, timer=timer) as video:
-            if verbose:
-                print(
-                    f"Video: {video.width}x{video.height} @ {video.fps:.2f} fps, "
-                    f"{video.frame_count} frames"
-                )
-
             # Determine detection/tracking confidence levels
             detection_conf, tracking_conf = _determine_confidence_levels(
                 quality_preset, detection_confidence, tracking_confidence
@@ -571,13 +570,21 @@ def process_dropjump_video(
             # Process all frames with pose tracking
             if verbose:
                 print("Processing all frames with MediaPipe pose tracking...")
-            tracker = PoseTracker(
-                min_detection_confidence=detection_conf,
-                min_tracking_confidence=tracking_conf,
-                timer=timer,
-            )
+
+            # Use provided tracker or create new one
+            tracker = pose_tracker
+            should_close_tracker = False
+
+            if tracker is None:
+                tracker = PoseTracker(
+                    min_detection_confidence=detection_conf,
+                    min_tracking_confidence=tracking_conf,
+                    timer=timer,
+                )
+                should_close_tracker = True
+
             frames, landmarks_sequence = _process_all_frames(
-                video, tracker, verbose, timer
+                video, tracker, verbose, timer, close_tracker=should_close_tracker
             )
 
             # Analyze video characteristics and auto-tune parameters
@@ -671,72 +678,47 @@ def process_dropjump_video(
                     phase_count=phase_count,
                 )
 
-            # Build complete metadata
-            with timer.measure("metadata_building"):
-                processing_time = time.time() - start_time
-
-                video_info = VideoInfo(
-                    source_path=video_path,
-                    fps=video.fps,
-                    width=video.width,
-                    height=video.height,
-                    duration_s=video.frame_count / video.fps,
-                    frame_count=video.frame_count,
-                    codec=video.codec,
-                )
-
-                # Check if drop start was auto-detected
-                drop_frame = None
-                if drop_start_frame is None and metrics.drop_start_frame is not None:
-                    # Auto-detected drop start from box
-                    drop_frame = metrics.drop_start_frame
-                elif drop_start_frame is not None:
-                    # Manual drop start provided
-                    drop_frame = drop_start_frame
-
-                algorithm_config = AlgorithmConfig(
-                    detection_method="forward_search",
-                    tracking_method="mediapipe_pose",
-                    model_complexity=1,
-                    smoothing=SmoothingConfig(
-                        window_size=params.smoothing_window,
-                        polynomial_order=params.polyorder,
-                        use_bilateral_filter=params.bilateral_filter,
-                        use_outlier_rejection=params.outlier_rejection,
-                    ),
-                    detection=DetectionConfig(
-                        velocity_threshold=params.velocity_threshold,
-                        min_contact_frames=params.min_contact_frames,
-                        visibility_threshold=params.visibility_threshold,
-                        use_curvature_refinement=params.use_curvature,
-                    ),
-                    drop_detection=DropDetectionConfig(
-                        auto_detect_drop_start=(drop_start_frame is None),
-                        detected_drop_frame=drop_frame,
-                        min_stationary_duration_s=0.5,
-                    ),
-                )
-
-                # Convert timer metrics to human-readable stage names
-                stage_times = _convert_timer_to_stage_names(timer.get_metrics())
-
-                processing_info = ProcessingInfo(
-                    version=get_kinemotion_version(),
-                    timestamp=create_timestamp(),
-                    quality_preset=quality_preset.value,
-                    processing_time_s=processing_time,
-                    timing_breakdown=stage_times,
-                )
-
-                result_metadata = ResultMetadata(
-                    quality=quality_result,
-                    video=video_info,
-                    processing=processing_info,
-                    algorithm=algorithm_config,
-                )
+            # Build algorithm configuration early (but attach metadata later)
+            drop_frame = None
+            if drop_start_frame is None and metrics.drop_start_frame is not None:
+                # Auto-detected drop start from box
+                drop_frame = metrics.drop_start_frame
+            elif drop_start_frame is not None:
+                # Manual drop start provided
+                drop_frame = drop_start_frame
+
+            algorithm_config = AlgorithmConfig(
+                detection_method="forward_search",
+                tracking_method="mediapipe_pose",
+                model_complexity=1,
+                smoothing=SmoothingConfig(
+                    window_size=params.smoothing_window,
+                    polynomial_order=params.polyorder,
+                    use_bilateral_filter=params.bilateral_filter,
+                    use_outlier_rejection=params.outlier_rejection,
+                ),
+                detection=DetectionConfig(
+                    velocity_threshold=params.velocity_threshold,
+                    min_contact_frames=params.min_contact_frames,
+                    visibility_threshold=params.visibility_threshold,
+                    use_curvature_refinement=params.use_curvature,
+                ),
+                drop_detection=DropDetectionConfig(
+                    auto_detect_drop_start=(drop_start_frame is None),
+                    detected_drop_frame=drop_frame,
+                    min_stationary_duration_s=0.5,
+                ),
+            )
 
-            # Attach complete metadata to metrics
-            metrics.result_metadata = result_metadata
+            video_info = VideoInfo(
+                source_path=video_path,
+                fps=video.fps,
+                width=video.width,
+                height=video.height,
+                duration_s=video.frame_count / video.fps,
+                frame_count=video.frame_count,
+                codec=video.codec,
+            )
 
             if verbose and quality_result.warnings:
                 print("\n⚠️  Quality Warnings:")
@@ -744,18 +726,56 @@ def process_dropjump_video(
                     print(f"  - {warning}")
                 print()
 
-            # Generate outputs (JSON and debug video)
-            _generate_dropjump_outputs(
-                metrics,
-                json_output,
-                output_video,
-                frames,
-                smoothed_landmarks,
-                contact_states,
-                video,
-                verbose,
-                timer,
-            )
+            # Generate debug video (but not JSON yet - we need to attach metadata first)
+            if output_video:
+                if verbose:
+                    print(f"Generating debug video: {output_video}")
+
+                if timer:
+                    with timer.measure("debug_video_generation"):
+                        with DebugOverlayRenderer(
+                            output_video,
+                            video.width,
+                            video.height,
+                            video.display_width,
+                            video.display_height,
+                            video.fps,
+                        ) as renderer:
+                            for i, frame in enumerate(frames):
+                                annotated = renderer.render_frame(
+                                    frame,
+                                    smoothed_landmarks[i],
+                                    contact_states[i],
+                                    i,
+                                    metrics,
+                                    use_com=False,
+                                )
+                                renderer.write_frame(annotated)
+                    # Capture re-encoding duration separately
+                    with timer.measure("debug_video_reencode"):
+                        pass  # Re-encoding happens in context manager __exit__
+                else:
+                    with DebugOverlayRenderer(
+                        output_video,
+                        video.width,
+                        video.height,
+                        video.display_width,
+                        video.display_height,
+                        video.fps,
+                    ) as renderer:
+                        for i, frame in enumerate(frames):
+                            annotated = renderer.render_frame(
+                                frame,
+                                smoothed_landmarks[i],
+                                contact_states[i],
+                                i,
+                                metrics,
+                                use_com=False,
+                            )
+                            renderer.write_frame(annotated)
+
+                if verbose:
+                    print(f"Debug video saved: {output_video}")
 
             # Validate metrics against physiological bounds
             with timer.measure("metrics_validation"):
@@ -768,13 +788,57 @@ def process_dropjump_video(
                 for issue in validation_result.issues:
                     print(f"  [{issue.severity.value}] {issue.metric}: {issue.message}")
 
+            # NOW create ProcessingInfo with complete timing breakdown
+            # (includes debug video generation timing)
+            processing_time = time.time() - start_time
+            stage_times = _convert_timer_to_stage_names(timer.get_metrics())
+
+            processing_info = ProcessingInfo(
+                version=get_kinemotion_version(),
+                timestamp=create_timestamp(),
+                quality_preset=quality_preset.value,
+                processing_time_s=processing_time,
+                timing_breakdown=stage_times,
+            )
+
+            result_metadata = ResultMetadata(
+                quality=quality_result,
+                video=video_info,
+                processing=processing_info,
+                algorithm=algorithm_config,
+            )
+
+            # Attach complete metadata to metrics
+            metrics.result_metadata = result_metadata
+
+            # NOW write JSON after metadata is attached
+            if json_output:
+                if timer:
+                    with timer.measure("json_serialization"):
+                        output_path = Path(json_output)
+                        metrics_dict = metrics.to_dict()
+                        import json
+
+                        json_str = json.dumps(metrics_dict, indent=2)
+                        output_path.write_text(json_str)
+                else:
+                    output_path = Path(json_output)
+                    metrics_dict = metrics.to_dict()
+                    import json
+
+                    json_str = json.dumps(metrics_dict, indent=2)
+                    output_path.write_text(json_str)
+
+                if verbose:
+                    print(f"Metrics written to: {json_output}")
+
             # Print timing summary if verbose
             if verbose:
                 total_time = time.time() - start_time
-                stage_times = _convert_timer_to_stage_names(timer.get_metrics())
+                stage_times_verbose = _convert_timer_to_stage_names(timer.get_metrics())
 
                 print("\n=== Timing Summary ===")
-                for stage, duration in stage_times.items():
+                for stage, duration in stage_times_verbose.items():
                     percentage = (duration / total_time) * 100
                     dur_ms = duration * 1000
                     print(f"{stage:.<40} {dur_ms:>6.0f}ms ({percentage:>5.1f}%)")
@@ -1032,6 +1096,7 @@ def process_cmj_video(
     tracking_confidence: float | None = None,
     verbose: bool = False,
     timer: PerformanceTimer | None = None,
+    pose_tracker: "PoseTracker | None" = None,
 ) -> CMJMetrics:
     """
     Process a single CMJ video and return metrics.
@@ -1053,6 +1118,7 @@ def process_cmj_video(
         tracking_confidence: Optional override for pose tracking confidence
         verbose: Print processing details
         timer: Optional PerformanceTimer for measuring operations
+        pose_tracker: Optional pre-initialized PoseTracker instance (reused if provided)
 
     Returns:
         CMJMetrics object containing analysis results
@@ -1098,13 +1164,21 @@ def process_cmj_video(
             # Track all frames
             if verbose:
                 print("Processing all frames with MediaPipe pose tracking...")
-            tracker = PoseTracker(
-                min_detection_confidence=det_conf,
-                min_tracking_confidence=track_conf,
-                timer=timer,
-            )
+
+            # Use provided tracker or create new one
+            tracker = pose_tracker
+            should_close_tracker = False
+
+            if tracker is None:
+                tracker = PoseTracker(
+                    min_detection_confidence=det_conf,
+                    min_tracking_confidence=track_conf,
+                    timer=timer,
+                )
+                should_close_tracker = True
+
             frames, landmarks_sequence = _process_all_frames(
-                video, tracker, verbose, timer
+                video, tracker, verbose, timer, close_tracker=should_close_tracker
             )
 
             # Auto-tune parameters
@@ -1216,59 +1290,35 @@ def process_cmj_video(
                     phase_count=phase_count,
                 )
 
-            # Build complete metadata
-            with timer.measure("metadata_building"):
-                processing_time = time.time() - start_time
-
-                video_info = VideoInfo(
-                    source_path=video_path,
-                    fps=video.fps,
-                    width=video.width,
-                    height=video.height,
-                    duration_s=video.frame_count / video.fps,
-                    frame_count=video.frame_count,
-                    codec=video.codec,
-                )
-
-                # Convert timer metrics to human-readable stage names
-                stage_times = _convert_timer_to_stage_names(timer.get_metrics())
-
-                processing_info = ProcessingInfo(
-                    version=get_kinemotion_version(),
-                    timestamp=create_timestamp(),
-                    quality_preset=quality_preset.value,
-                    processing_time_s=processing_time,
-                    timing_breakdown=stage_times,
-                )
-
-                algorithm_config = AlgorithmConfig(
-                    detection_method="backward_search",
-                    tracking_method="mediapipe_pose",
-                    model_complexity=1,
-                    smoothing=SmoothingConfig(
-                        window_size=params.smoothing_window,
-                        polynomial_order=params.polyorder,
-                        use_bilateral_filter=params.bilateral_filter,
-                        use_outlier_rejection=params.outlier_rejection,
-                    ),
-                    detection=DetectionConfig(
-                        velocity_threshold=params.velocity_threshold,
-                        min_contact_frames=params.min_contact_frames,
-                        visibility_threshold=params.visibility_threshold,
-                        use_curvature_refinement=params.use_curvature,
-                    ),
-                    drop_detection=None,  # CMJ doesn't have drop detection
-                )
-
-                result_metadata = ResultMetadata(
-                    quality=quality_result,
-                    video=video_info,
-                    processing=processing_info,
-                    algorithm=algorithm_config,
-                )
+            # Build algorithm config early (but attach metadata later)
+            algorithm_config = AlgorithmConfig(
+                detection_method="backward_search",
+                tracking_method="mediapipe_pose",
+                model_complexity=1,
+                smoothing=SmoothingConfig(
+                    window_size=params.smoothing_window,
+                    polynomial_order=params.polyorder,
+                    use_bilateral_filter=params.bilateral_filter,
+                    use_outlier_rejection=params.outlier_rejection,
+                ),
+                detection=DetectionConfig(
+                    velocity_threshold=params.velocity_threshold,
+                    min_contact_frames=params.min_contact_frames,
+                    visibility_threshold=params.visibility_threshold,
+                    use_curvature_refinement=params.use_curvature,
+                ),
+                drop_detection=None,  # CMJ doesn't have drop detection
+            )
 
-            # Attach complete metadata to metrics
-            metrics.result_metadata = result_metadata
+            video_info = VideoInfo(
+                source_path=video_path,
+                fps=video.fps,
+                width=video.width,
+                height=video.height,
+                duration_s=video.frame_count / video.fps,
+                frame_count=video.frame_count,
+                codec=video.codec,
+            )
 
             if verbose and quality_result.warnings:
                 print("\n⚠️  Quality Warnings:")
@@ -1276,21 +1326,46 @@ def process_cmj_video(
                     print(f"  - {warning}")
                 print()
 
-            # Generate outputs if requested
-            _generate_cmj_outputs(
-                output_video,
-                json_output,
-                metrics,
-                frames,
-                smoothed_landmarks,
-                video.width,
-                video.height,
-                video.display_width,
-                video.display_height,
-                video.fps,
-                verbose,
-                timer,
-            )
+            # Generate debug video (but not JSON yet - we need to attach metadata first)
+            if output_video:
+                if verbose:
+                    print(f"Generating debug video: {output_video}")
+
+                if timer:
+                    with timer.measure("debug_video_generation"):
+                        with CMJDebugOverlayRenderer(
+                            output_video,
+                            video.width,
+                            video.height,
+                            video.display_width,
+                            video.display_height,
+                            video.fps,
+                        ) as renderer:
+                            for i, frame in enumerate(frames):
+                                annotated = renderer.render_frame(
+                                    frame, smoothed_landmarks[i], i, metrics
+                                )
+                                renderer.write_frame(annotated)
+                    # Capture re-encoding duration separately
+                    with timer.measure("debug_video_reencode"):
+                        pass  # Re-encoding happens in context manager __exit__
+                else:
+                    with CMJDebugOverlayRenderer(
+                        output_video,
+                        video.width,
+                        video.height,
+                        video.display_width,
+                        video.display_height,
+                        video.fps,
+                    ) as renderer:
+                        for i, frame in enumerate(frames):
+                            annotated = renderer.render_frame(
+                                frame, smoothed_landmarks[i], i, metrics
+                            )
+                            renderer.write_frame(annotated)
+
+                if verbose:
+                    print(f"Debug video saved: {output_video}")
 
             # Validate metrics against physiological bounds
             with timer.measure("metrics_validation"):
@@ -1298,6 +1373,50 @@ def process_cmj_video(
                 validation_result = validator.validate(metrics.to_dict())  # type: ignore[arg-type]
                 metrics.validation_result = validation_result
 
+            # NOW create ProcessingInfo with complete timing breakdown
+            # (includes debug video generation timing)
+            processing_time = time.time() - start_time
+            stage_times = _convert_timer_to_stage_names(timer.get_metrics())
+
+            processing_info = ProcessingInfo(
+                version=get_kinemotion_version(),
+                timestamp=create_timestamp(),
+                quality_preset=quality_preset.value,
+                processing_time_s=processing_time,
+                timing_breakdown=stage_times,
+            )
+
+            result_metadata = ResultMetadata(
+                quality=quality_result,
+                video=video_info,
+                processing=processing_info,
+                algorithm=algorithm_config,
+            )
+
+            # Attach complete metadata to metrics
+            metrics.result_metadata = result_metadata
+
+            # NOW write JSON after metadata is attached
+            if json_output:
+                if timer:
+                    with timer.measure("json_serialization"):
+                        output_path = Path(json_output)
+                        metrics_dict = metrics.to_dict()
+                        import json
+
+                        json_str = json.dumps(metrics_dict, indent=2)
+                        output_path.write_text(json_str)
+                else:
+                    output_path = Path(json_output)
+                    metrics_dict = metrics.to_dict()
+                    import json
+
+                    json_str = json.dumps(metrics_dict, indent=2)
+                    output_path.write_text(json_str)
+
+                if verbose:
+                    print(f"Metrics written to: {json_output}")
+
             if verbose and validation_result.issues:
                 print("\n⚠️  Validation Results:")
                 for issue in validation_result.issues:

{kinemotion-0.41.2.dist-info → kinemotion-0.42.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kinemotion
-Version: 0.41.2
+Version: 0.42.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.41.2.dist-info → kinemotion-0.42.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 kinemotion/__init__.py,sha256=wPItmyGJUOFM6GPRVhAEvRz0-ErI7e2qiUREYJ9EfPQ,943
-kinemotion/api.py,sha256=B_orKAJ5KNsL5zse5B0s4pumT_4OcAVoxdSEa3N9qMY,52843
+kinemotion/api.py,sha256=plEUM5kuSvPJNgIg-iDFzwHCLU2w9YjUpDpBE7BHNWA,58273
 kinemotion/cli.py,sha256=cqYV_7URH0JUDy1VQ_EDLv63FmNO4Ns20m6s1XAjiP4,464
 kinemotion/cmj/__init__.py,sha256=Ynv0-Oco4I3Y1Ubj25m3h9h2XFqeNwpAewXmAYOmwfU,127
 kinemotion/cmj/analysis.py,sha256=qtULzp9uYzm5M0_Qu5YGJpuwjg9fz1VKAg6xg4NJxvM,21639
@@ -32,8 +32,8 @@ kinemotion/dropjump/kinematics.py,sha256=kH-XM66wlOCYMpjvyb6_Qh5ZebyOfFZ47rmhgE1
 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.41.2.dist-info/METADATA,sha256=mtVwKDoP30BmZsNgvVo-O-31-SexQq3XRh84XcQ83C0,26020
-kinemotion-0.41.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-kinemotion-0.41.2.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
-kinemotion-0.41.2.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
-kinemotion-0.41.2.dist-info/RECORD,,
+kinemotion-0.42.0.dist-info/METADATA,sha256=tPUkpNnzytbN0vxVda5Dcx8Q7M1edBJfStsU_MJGM7E,26020
+kinemotion-0.42.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+kinemotion-0.42.0.dist-info/entry_points.txt,sha256=zaqnAnjLvcdrk1Qvj5nvXZCZ2gp0prS7it1zTJygcIY,50
+kinemotion-0.42.0.dist-info/licenses/LICENSE,sha256=KZajvqsHw0NoOHOi2q0FZ4NBe9HdV6oey-IPYAtHXfg,1088
+kinemotion-0.42.0.dist-info/RECORD,,