sports2d 0.8.18__py3-none-any.whl → 0.8.20__py3-none-any.whl

Sports2D/Demo/Config_demo.toml

@@ -60,8 +60,8 @@ pose_model = 'Body_with_feet'  #With RTMLib:
                          # - Hand (HAND_21, only lightweight mode. Potentially better results with Whole_body), 
                          # - Face (FACE_106), 
                          # - Animal (ANIMAL2D_17)
-                         # /!\ Only RTMPose is natively embeded in Pose2Sim. For all other pose estimation methods, you will have to run them yourself, and then refer to the documentation to convert the output files if needed
-                         # /!\ For Face and Animal, use mode="""{dictionary}""", and find the corresponding .onnx model there https://github.com/open-mmlab/mmpose/tree/main/projects/rtmpose
+                         # ⚠ Only RTMPose is natively embeded in Pose2Sim. For all other pose estimation methods, you will have to run them yourself, and then refer to the documentation to convert the output files if needed
+                         # ⚠ For Face and Animal, use mode="""{dictionary}""", and find the corresponding .onnx model there https://github.com/open-mmlab/mmpose/tree/main/projects/rtmpose
 mode = 'balanced' # 'lightweight', 'balanced', 'performance', or """{dictionary}""" (see below)
 
 # A dictionary (WITHIN THREE DOUBLE QUOTES) allows you to manually select the person detection (if top_down approach) and/or pose estimation models (see https://github.com/Tau-J/rtmlib). 
@@ -139,6 +139,7 @@ reject_outliers = true      # Hampel filter for outlier rejection before other f
 
 filter = true
 show_graphs = true         # Show plots of raw and processed results
+save_graphs = false        # Save position and angle plots of raw and processed results
 filter_type = 'butterworth'     # butterworth, kalman, gcv_spline, gaussian, loess, median, butterworth_on_speed
    
    # Most intuitive and standard filter in biomechanics

Sports2D/Sports2D.py

@@ -28,7 +28,7 @@
     - Run on webcam with default parameters: 
         sports2d --video_input webcam
     - Run with custom parameters (all non specified are set to default): 
-        sports2d --show_plots False --time_range 0 2.1 --result_dir path_to_result_dir
+        sports2d --show_graphs False --time_range 0 2.1 --result_dir path_to_result_dir
         sports2d --person_detection_method highest_likelihood --mode lightweight --det_frequency 50
     - Run with a toml configuration file: 
         sports2d --config path_to_config.toml
@@ -44,7 +44,7 @@
     pip install .
     
     -----
-    /!\ Warning /!\
+    ⚠ Warning ⚠
     -----
     - The angle estimation is only as good as the pose estimation algorithm, i.e., it is not perfect.
     - It will only lead to acceptable results if the persons move in the 2D plane (sagittal plane).
@@ -236,6 +236,7 @@ DEFAULT_CONFIG =   {'base': {'video_input': ['demo.mp4'],
                                         'reject_outliers': True,
                                         'filter': True,
                                         'show_graphs': True,
+                                        'save_graphs': False,
                                         'filter_type': 'butterworth',
                                         'butterworth': {'order': 4, 'cut_off_frequency': 6.0},
                                         'kalman': {'trust_ratio': 500.0, 'smooth':True},
@@ -279,6 +280,7 @@ CONFIG_HELP =   {'config': ["C", "path to a toml configuration file"],
                 'show_realtime_results': ["R", "show results in real-time. true if not specified"],
                 'display_angle_values_on': ["a", '"body", "list", "body" "list", or "none". body list if not specified'],
                 'show_graphs': ["G", "show plots of raw and processed results. true if not specified"],
+                'save_graphs': ["", "save position and angle plots of raw and processed results. false if not specified"],
                 'joint_angles': ["j", '"Right ankle" "Left ankle" "Right knee" "Left knee" "Right hip" "Left hip" "Right shoulder" "Left shoulder" "Right elbow" "Left elbow" if not specified'],
                 'segment_angles': ["s", '"Right foot" "Left foot" "Right shank" "Left shank" "Right thigh" "Left thigh" "Pelvis" "Trunk" "Shoulders" "Head" "Right arm" "Left arm" "Right forearm" "Left forearm" if not specified'],
                 'save_vid': ["V", "save processed video. true if not specified"],
@@ -546,7 +548,7 @@ def main():
     - Run on webcam with default parameters: 
         sports2d --video_input webcam
     - Run with custom parameters (all non specified are set to default): 
-        sports2d --show_plots False --time_range 0 2.1 --result_dir path_to_result_dir
+        sports2d --show_graphs False --time_range 0 2.1 --result_dir path_to_result_dir
         sports2d --mode lightweight --det_frequency 50
     - Run with a toml configuration file: 
         sports2d --config path_to_config.toml

Sports2D/Utilities/tests.py

@@ -63,14 +63,14 @@ def test_workflow():
 
     # Default
     demo_cmd = ["sports2d", "--person_ordering_method", "highest_likelihood", "--show_realtime_results", "False", "--show_graphs", "False"]
-    subprocess.run(demo_cmd, check=True, capture_output=True, text=True, encoding='utf-8')
+    subprocess.run(demo_cmd, check=True, capture_output=True, text=True, encoding='utf-8', errors='replace')
 
     # With loading a trc file, visible_side 'front', first_person_height '1.76", floor_angle 0, xy_origin [0, 928]
     demo_cmd2 = ["sports2d", "--show_realtime_results", "False", "--show_graphs", "False",
                  "--load_trc_px", os.path.join(root_dir, "demo_Sports2D", "demo_Sports2D_px_person01.trc"),
                  "--visible_side", "front", "--first_person_height", "1.76", "--time_range", "1.2", "2.7",
                  "--floor_angle", "0", "--xy_origin", "0", "928"]
-    subprocess.run(demo_cmd2, check=True, capture_output=True, text=True, encoding='utf-8')
+    subprocess.run(demo_cmd2, check=True, capture_output=True, text=True, encoding='utf-8', errors='replace')
 
     # With no pixels to meters conversion, one person to select, lightweight mode, detection frequency, slowmo factor, gaussian filter, RTMO body pose model
     demo_cmd3 = ["sports2d", "--show_realtime_results", "False", "--show_graphs", "False", 
@@ -80,7 +80,7 @@ def test_workflow():
                  "--slowmo_factor", "4",
                  "--filter_type", "gaussian",
                  "--pose_model", "body", "--mode", """{'pose_class':'RTMO', 'pose_model':'https://download.openmmlab.com/mmpose/v1/projects/rtmo/onnx_sdk/rtmo-m_16xb16-600e_body7-640x640-39e78cc4_20231211.zip', 'pose_input_size':[640, 640]}"""]
-    subprocess.run(demo_cmd3, check=True, capture_output=True, text=True, encoding='utf-8')
+    subprocess.run(demo_cmd3, check=True, capture_output=True, text=True, encoding='utf-8', errors='replace')
     
     # With a time range, inverse kinematics, marker augmentation
     demo_cmd4 = ["sports2d", "--person_ordering_method", "greatest_displacement", "--show_realtime_results", "False", "--show_graphs", "False",
@@ -88,7 +88,7 @@ def test_workflow():
                  "--do_ik", "True", "--use_augmentation", "True", 
                  "--nb_persons_to_detect", "all", "--first_person_height", "1.65",
                  "--visible_side", "auto", "front", "--participant_mass", "55.0", "67.0"]
-    subprocess.run(demo_cmd4, check=True, capture_output=True, text=True, encoding='utf-8')
+    subprocess.run(demo_cmd4, check=True, capture_output=True, text=True, encoding='utf-8', errors='replace')
     
     # From config file
     config_path = Path(__file__).resolve().parent.parent / 'Demo' / 'Config_demo.toml'
@@ -98,7 +98,7 @@ def test_workflow():
     config_dict.get("base").update({"person_ordering_method": "highest_likelihood"})
     with open(config_path, 'w') as f: toml.dump(config_dict, f)
     demo_cmd5 = ["sports2d", "--config", str(config_path), "--show_realtime_results", "False", "--show_graphs", "False"]
-    subprocess.run(demo_cmd5, check=True, capture_output=True, text=True, encoding='utf-8')
+    subprocess.run(demo_cmd5, check=True, capture_output=True, text=True, encoding='utf-8', errors='replace')
 
 
 if __name__ == "__main__":

Sports2D/process.py

@@ -29,7 +29,7 @@
     - optionally plots pose and angle data before and after processing for comparison
     - optionally saves poses for each person as a trc file, and angles as a mot file
         
-    /!\ Warning /!\
+    ⚠ Warning ⚠ 
     - The pose detection is only as good as the pose estimation algorithm, i.e., it is not perfect.
     - It will lead to reliable results only if the persons move in the 2D plane (sagittal or frontal plane).
     - The persons need to be filmed as perpendicularly as possible from their side.
@@ -77,12 +77,14 @@ from matplotlib.widgets import Slider, Button
 from matplotlib import patheffects
 
 from rtmlib import PoseTracker, BodyWithFeet, Wholebody, Body, Hand, Custom
+from rtmlib.tools.object_detection.post_processings import nms
 from deep_sort_realtime.deepsort_tracker import DeepSort
 
 from Sports2D.Utilities.common import *
 from Pose2Sim.common import *
 from Pose2Sim.skeletons import *
 from Pose2Sim.triangulation import indices_of_first_last_non_nan_chunks
+from Pose2Sim.personAssociation import *
 from Pose2Sim.filtering import *
 
 # Not safe, but to be used until OpenMMLab/RTMlib's SSL certificates are updated
@@ -106,7 +108,7 @@ __status__ = "Development"
 
 
 # FUNCTIONS
-def setup_webcam(webcam_id, save_vid, vid_output_path, input_size):
+def setup_webcam(webcam_id, vid_output_path, input_size):
     '''
     Set up webcam capture with OpenCV.
 
@@ -132,29 +134,28 @@ def setup_webcam(webcam_id, save_vid, vid_output_path, input_size):
     cap.set(cv2.CAP_PROP_FRAME_HEIGHT, input_size[1])
     cam_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
     cam_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    cap.set(cv2.CAP_PROP_BUFFERSIZE, 1)
     fps = round(cap.get(cv2.CAP_PROP_FPS))
     if fps == 0: fps = 30
     
     if cam_width != input_size[0] or cam_height != input_size[1]:
         logging.warning(f"Warning: Your webcam does not support {input_size[0]}x{input_size[1]} resolution. Resolution set to the closest supported one: {cam_width}x{cam_height}.")
     
-    out_vid = None
-    if save_vid:
-        # fourcc MJPG produces very large files but is faster. If it is too slow, consider using it and then converting the video to h264
-        # try:
-        #     fourcc = cv2.VideoWriter_fourcc(*'avc1') # =h264. better compression and quality but may fail on some systems
-        #     out_vid = cv2.VideoWriter(vid_output_path, fourcc, fps, (cam_width, cam_height))
-        #     if not out_vid.isOpened():
-        #         raise ValueError("Failed to open video writer with 'avc1' (h264)")
-        # except Exception:
-        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-        out_vid = cv2.VideoWriter(vid_output_path, fourcc, fps, (cam_width, cam_height))
-            # logging.info("Failed to open video writer with 'avc1' (h264). Using 'mp4v' instead.")
+    # fourcc MJPG produces very large files but is faster. If it is too slow, consider using it and then converting the video to h264
+    # try:
+    #     fourcc = cv2.VideoWriter_fourcc(*'avc1') # =h264. better compression and quality but may fail on some systems
+    #     out_vid = cv2.VideoWriter(vid_output_path, fourcc, fps, (cam_width, cam_height))
+    #     if not out_vid.isOpened():
+    #         raise ValueError("Failed to open video writer with 'avc1' (h264)")
+    # except Exception:
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    out_vid = cv2.VideoWriter(vid_output_path, fourcc, fps, (cam_width, cam_height))
+        # logging.info("Failed to open video writer with 'avc1' (h264). Using 'mp4v' instead.")
 
     return cap, out_vid, cam_width, cam_height, fps
 
 
-def setup_video(video_file_path, save_vid, vid_output_path):
+def setup_video(video_file_path, vid_output_path, save_vid):
     '''
     Set up video capture with OpenCV.
 
@@ -789,10 +790,10 @@ def make_mot_with_angles(angles, time, mot_path):
     return angles
 
 
-def pose_plots(trc_data_unfiltered, trc_data, person_id):
+def pose_plots(trc_data_unfiltered, trc_data, person_id, show=True):
     '''
     Displays trc filtered and unfiltered data for comparison
-    /!\ Often crashes on the third window...
+    ⚠ Often crashes on the third window...
 
     INPUTS:
     - trc_data_unfiltered: pd.DataFrame. The unfiltered trc data
@@ -835,13 +836,16 @@ def pose_plots(trc_data_unfiltered, trc_data, person_id):
 
         pw.addPlot(keypoint, f)
     
-    pw.show()
+    if show:
+        pw.show()
+
+    return pw
 
 
-def angle_plots(angle_data_unfiltered, angle_data, person_id):
+def angle_plots(angle_data_unfiltered, angle_data, person_id, show=True):
     '''
     Displays angle filtered and unfiltered data for comparison
-    /!\ Often crashes on the third window...
+    ⚠ Often crashes on the third window...
 
     INPUTS:
     - angle_data_unfiltered: pd.DataFrame. The unfiltered angle data
@@ -878,7 +882,10 @@ def angle_plots(angle_data_unfiltered, angle_data, person_id):
 
         pw.addPlot(angle, f)
 
-    pw.show()
+    if show:
+        pw.show()
+
+    return pw
 
 
 def get_personIDs_with_highest_scores(all_frames_scores, nb_persons_to_detect):
@@ -985,12 +992,13 @@ def get_personIDs_with_greatest_displacement(all_frames_X_homog, all_frames_Y_ho
     return selected_persons
 
 
-def get_personIDs_on_click(frames, all_frames_X_homog, all_frames_Y_homog):
+def get_personIDs_on_click(video_file_path, frame_range, all_frames_X_homog, all_frames_Y_homog):
     '''
     Get the person IDs on click in the image
 
     INPUTS:
-    - frames: list of images read by cv2.imread. shape (Nframes, H, W, 3)
+    - video_file_path: path to video file
+    - frame_range: tuple (start_frame, end_frame)
     - all_frames_X_homog: shape (Nframes, Npersons, Nkpts)
     - all_frames_Y_homog: shape (Nframes, Npersons, Nkpts)
 
@@ -1001,23 +1009,19 @@ def get_personIDs_on_click(frames, all_frames_X_homog, all_frames_Y_homog):
     # Reorganize the coordinates to shape (Nframes, Npersons, Nkpts, Ndims)
     all_pose_coords = np.stack((all_frames_X_homog, all_frames_Y_homog), axis=-1)
 
-    # Trim all_pose_coords and frames to the same size
-    min_frames = min(all_pose_coords.shape[0], len(frames))
-    all_pose_coords = all_pose_coords[:min_frames]
-    frames = frames[:min_frames]
-    
     # Select person IDs on click on video/image
-    selected_persons = select_persons_on_vid(frames, all_pose_coords)
+    selected_persons = select_persons_on_vid(video_file_path, frame_range, all_pose_coords)
 
     return selected_persons
 
 
-def select_persons_on_vid(frames, all_pose_coords):
+def select_persons_on_vid(video_file_path, frame_range, all_pose_coords):
     '''
     Interactive UI to select persons from a video by clicking on their bounding boxes.
     
     INPUTS:
-    - frames: list of images read by cv2.imread. shape (Nframes, H, W, 3)
+    - video_file_path: path to video file
+    - frame_range: tuple (start_frame, end_frame)
     - all_pose_coords: keypoints coordinates. shape (Nframes, Npersons, Nkpts, Ndims)
         
     OUTPUT:
@@ -1031,93 +1035,42 @@ def select_persons_on_vid(frames, all_pose_coords):
     LINE_UNSELECTED_COLOR = 'white'
     LINE_SELECTED_COLOR = 'darkorange'
 
-    selected_persons = []
-
-    # Calculate bounding boxes for each person in each frame
-    n_frames, n_persons = all_pose_coords.shape[0], all_pose_coords.shape[1]
-    all_bboxes = []
-    for frame_idx in range(n_frames):
-        frame_bboxes = []
-        for person_idx in range(n_persons):
-            # Get keypoints for current person
-            keypoints = all_pose_coords[frame_idx, person_idx]
-            valid_keypoints = keypoints[~np.isnan(keypoints).all(axis=1)]
-            if len(valid_keypoints) > 0:
-                # Calculate bounding box
-                x_min, y_min = np.min(valid_keypoints, axis=0)
-                x_max, y_max = np.max(valid_keypoints, axis=0)
-                frame_bboxes.append((x_min, y_min, x_max, y_max))
-            else:
-                frame_bboxes.append((np.nan, np.nan, np.nan, np.nan))  # No valid bounding box for this person
-        all_bboxes.append(frame_bboxes)
-    all_bboxes = np.array(all_bboxes)  # Shape: (Nframes, Npersons, 4)
-    
-    # Create figure, axes, and slider
-    frame_height, frame_width = frames[0].shape[:2]
-    is_vertical = frame_height > frame_width
-    if is_vertical:
-        fig_height = frame_height / 250  # For vertical videos
-    else:
-        fig_height = max(frame_height / 300, 6)  # For horizontal videos
-    fig = plt.figure(figsize=(8, fig_height), num=f'Select the persons to analyze in the desired order')
-    fig.patch.set_facecolor(BACKGROUND_COLOR)
-
-    video_axes_height = 0.7 if is_vertical else 0.6
-    ax_video = plt.axes([0.1, 0.2, 0.8, video_axes_height])
-    ax_video.axis('off')
-    ax_video.set_facecolor(BACKGROUND_COLOR)    
-
-    # First image
-    frame_rgb = cv2.cvtColor(frames[0], cv2.COLOR_BGR2RGB)
-    rects, annotations = [], []
-    for person_idx, bbox in enumerate(all_bboxes[0]):
-        if ~np.isnan(bbox).any():
-            x_min, y_min, x_max, y_max = bbox.astype(int)
-            rect = plt.Rectangle(
-                (x_min, y_min), x_max - x_min, y_max - y_min,
-                linewidth=1, edgecolor=LINE_UNSELECTED_COLOR, facecolor=UNSELECTED_COLOR,
-                linestyle='-', path_effects=[patheffects.withSimplePatchShadow()], zorder=2
-            ) 
-            ax_video.add_patch(rect)
-            annotation = ax_video.text(
-                x_min, y_min - 10, f'{person_idx}', color=LINE_UNSELECTED_COLOR, fontsize=7, fontweight='normal',
-                bbox=dict(facecolor=UNSELECTED_COLOR, edgecolor=LINE_UNSELECTED_COLOR, boxstyle='square,pad=0.3', path_effects=[patheffects.withSimplePatchShadow()]), zorder=3
-            )
-            rects.append(rect)
-            annotations.append(annotation)
-    img_plot = ax_video.imshow(frame_rgb)
-
-    # Slider
-    ax_slider = plt.axes([ax_video.get_position().x0, ax_video.get_position().y0-0.05, ax_video.get_position().width, 0.04])
-    ax_slider.set_facecolor(BACKGROUND_COLOR)
-    frame_slider = Slider(
-        ax=ax_slider,
-        label='',
-        valmin=0,
-        valmax=len(all_pose_coords)-1,
-        valinit=0,
-        valstep=1,
-        valfmt=None 
-    )
-    frame_slider.poly.set_edgecolor(SLIDER_EDGE_COLOR)
-    frame_slider.poly.set_facecolor(SLIDER_COLOR)
-    frame_slider.poly.set_linewidth(1)
-    frame_slider.valtext.set_visible(False)
-
-
-    # Status text and OK button
-    ax_status = plt.axes([ax_video.get_position().x0, ax_video.get_position().y0-0.1, 2*ax_video.get_position().width/3, 0.04])
-    ax_status.axis('off')
-    status_text = ax_status.text(0.0, 0.5, f"Selected: None", color='black', fontsize=10)
 
-    ax_button = plt.axes([ax_video.get_position().x0 + 3*ax_video.get_position().width/4, ax_video.get_position().y0-0.1, ax_video.get_position().width/4, 0.04])
-    ok_button = Button(ax_button, 'OK', color=BACKGROUND_COLOR)
+    def get_frame(frame_idx):
+        """Get frame with caching"""
+        actual_frame_idx = start_frame + frame_idx
+        
+        # Check cache first
+        if actual_frame_idx in frame_cache:
+            # Move to end of cache order (recently used)
+            cache_order.remove(actual_frame_idx)
+            cache_order.append(actual_frame_idx)
+            return frame_cache[actual_frame_idx]
+        
+        # Load from video
+        cap.set(cv2.CAP_PROP_POS_FRAMES, actual_frame_idx)
+        success, frame = cap.read()
+        if not success:
+            raise ValueError(f"Could not read frame {actual_frame_idx}")
+        
+        # Add to cache
+        frame_cache[actual_frame_idx] = frame.copy()
+        cache_order.append(actual_frame_idx)
+        
+        # Remove old frames if cache too large
+        while len(frame_cache) > cache_size:
+            oldest_frame = cache_order.pop(0)
+            if oldest_frame in frame_cache:
+                del frame_cache[oldest_frame]
+        
+        return frame
     
 
     def update_frame(val):
         # Update image
         frame_idx = int(frame_slider.val)
-        frame_rgb = cv2.cvtColor(frames[frame_idx], cv2.COLOR_BGR2RGB)
+        frame = get_frame(frame_idx)
+        frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
 
         # Update bboxes and annotations
         for items in [rects, annotations]:
@@ -1210,6 +1163,101 @@ def select_persons_on_vid(frames, all_pose_coords):
         plt.close(fig)
 
 
+    # Open video
+    cap = cv2.VideoCapture(video_file_path)
+    if not cap.isOpened():
+        raise ValueError(f"Could not open video: {video_file_path}")
+    start_frame, end_frame = frame_range
+    
+
+    # Frame cache for efficiency - only keep recently accessed frames
+    frame_cache = {}
+    cache_size = 20  # Keep last 20 frames in memory
+    cache_order = []
+
+    # Calculate bounding boxes for each person in each frame
+    selected_persons = []
+    n_frames, n_persons = all_pose_coords.shape[0], all_pose_coords.shape[1]
+    all_bboxes = []
+    for frame_idx in range(n_frames):
+        frame_bboxes = []
+        for person_idx in range(n_persons):
+            # Get keypoints for current person
+            keypoints = all_pose_coords[frame_idx, person_idx]
+            valid_keypoints = keypoints[~np.isnan(keypoints).all(axis=1)]
+            if len(valid_keypoints) > 0:
+                # Calculate bounding box
+                x_min, y_min = np.min(valid_keypoints, axis=0)
+                x_max, y_max = np.max(valid_keypoints, axis=0)
+                frame_bboxes.append((x_min, y_min, x_max, y_max))
+            else:
+                frame_bboxes.append((np.nan, np.nan, np.nan, np.nan))  # No valid bounding box for this person
+        all_bboxes.append(frame_bboxes)
+    all_bboxes = np.array(all_bboxes)  # Shape: (Nframes, Npersons, 4)
+    
+    # Create figure, axes, and slider
+    first_frame = get_frame(0)
+    frame_height, frame_width = first_frame.shape[:2]
+    is_vertical = frame_height > frame_width
+    if is_vertical:
+        fig_height = frame_height / 250  # For vertical videos
+    else:
+        fig_height = max(frame_height / 300, 6)  # For horizontal videos
+    fig = plt.figure(figsize=(8, fig_height), num=f'Select the persons to analyze in the desired order')
+    fig.patch.set_facecolor(BACKGROUND_COLOR)
+
+    video_axes_height = 0.7 if is_vertical else 0.6
+    ax_video = plt.axes([0.1, 0.2, 0.8, video_axes_height])
+    ax_video.axis('off')
+    ax_video.set_facecolor(BACKGROUND_COLOR)    
+
+    # First image
+    frame_rgb = cv2.cvtColor(first_frame, cv2.COLOR_BGR2RGB)
+    rects, annotations = [], []
+    for person_idx, bbox in enumerate(all_bboxes[0]):
+        if ~np.isnan(bbox).any():
+            x_min, y_min, x_max, y_max = bbox.astype(int)
+            rect = plt.Rectangle(
+                (x_min, y_min), x_max - x_min, y_max - y_min,
+                linewidth=1, edgecolor=LINE_UNSELECTED_COLOR, facecolor=UNSELECTED_COLOR,
+                linestyle='-', path_effects=[patheffects.withSimplePatchShadow()], zorder=2
+            ) 
+            ax_video.add_patch(rect)
+            annotation = ax_video.text(
+                x_min, y_min - 10, f'{person_idx}', color=LINE_UNSELECTED_COLOR, fontsize=7, fontweight='normal',
+                bbox=dict(facecolor=UNSELECTED_COLOR, edgecolor=LINE_UNSELECTED_COLOR, boxstyle='square,pad=0.3', path_effects=[patheffects.withSimplePatchShadow()]), zorder=3
+            )
+            rects.append(rect)
+            annotations.append(annotation)
+    img_plot = ax_video.imshow(frame_rgb)
+
+    # Slider
+    ax_slider = plt.axes([ax_video.get_position().x0, ax_video.get_position().y0-0.05, ax_video.get_position().width, 0.04])
+    ax_slider.set_facecolor(BACKGROUND_COLOR)
+    frame_slider = Slider(
+        ax=ax_slider,
+        label='',
+        valmin=0,
+        valmax=len(all_pose_coords)-1,
+        valinit=0,
+        valstep=1,
+        valfmt=None 
+    )
+    frame_slider.poly.set_edgecolor(SLIDER_EDGE_COLOR)
+    frame_slider.poly.set_facecolor(SLIDER_COLOR)
+    frame_slider.poly.set_linewidth(1)
+    frame_slider.valtext.set_visible(False)
+
+
+    # Status text and OK button
+    ax_status = plt.axes([ax_video.get_position().x0, ax_video.get_position().y0-0.1, 2*ax_video.get_position().width/3, 0.04])
+    ax_status.axis('off')
+    status_text = ax_status.text(0.0, 0.5, f"Selected: None", color='black', fontsize=10)
+
+    ax_button = plt.axes([ax_video.get_position().x0 + 3*ax_video.get_position().width/4, ax_video.get_position().y0-0.1, ax_video.get_position().width/4, 0.04])
+    ok_button = Button(ax_button, 'OK', color=BACKGROUND_COLOR)
+    
+
     # Connect events
     frame_slider.on_changed(update_frame)
     fig.canvas.mpl_connect('button_press_event', on_click)
@@ -1333,7 +1381,7 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
     - optionally plots pose and angle data before and after processing for comparison
     - optionally saves poses for each person as a trc file, and angles as a mot file
         
-    /!\ Warning /!\d
+    ⚠ Warning ⚠ 
     - The pose detection is only as good as the pose estimation algorithm, i.e., it is not perfect.
     - It will lead to reliable results only if the persons move in the 2D plane (sagittal or frontal plane).
     - The persons need to be filmed as perpendicularly as possible from their side.
@@ -1449,6 +1497,7 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
     handle_LR_swap = config_dict.get('post-processing').get('handle_LR_swap', False)
     reject_outliers = config_dict.get('post-processing').get('reject_outliers', False)
     show_plots = config_dict.get('post-processing').get('show_graphs')
+    save_plots = config_dict.get('post-processing').get('save_graphs')
     filter_type = config_dict.get('post-processing').get('filter_type')
     butterworth_filter_order = config_dict.get('post-processing').get('butterworth', {}).get('order')
     butterworth_filter_cutoff = config_dict.get('post-processing').get('butterworth', {}).get('cut_off_frequency')
@@ -1465,12 +1514,14 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
     # Create output directories
     if video_file == "webcam":
         current_date = datetime.now().strftime("%Y%m%d_%H%M%S")
-        output_dir_name = f'webcam_{current_date}'
+        output_dir_name = f'webcam_{current_date}_Sports2D'
+        video_file_path = result_dir / output_dir_name / f'webcam_{current_date}_raw.mp4'
     else:
-        video_file_path = video_dir / video_file
         video_file_stem = video_file.stem
         output_dir_name = f'{video_file_stem}_Sports2D'    
+        video_file_path = video_dir / video_file
     output_dir = result_dir / output_dir_name
+    plots_output_dir = output_dir / f'{output_dir_name}_graphs'
     img_output_dir = output_dir / f'{output_dir_name}_img'
     vid_output_path = output_dir / f'{output_dir_name}.mp4'
     pose_output_path = output_dir / f'{output_dir_name}_px.trc'
@@ -1479,6 +1530,8 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
     output_dir.mkdir(parents=True, exist_ok=True)
     if save_img:
         img_output_dir.mkdir(parents=True, exist_ok=True)
+    if save_plots:
+        plots_output_dir.mkdir(parents=True, exist_ok=True)
 
     # Inverse kinematics settings
     do_ik = config_dict.get('kinematics').get('do_ik')
@@ -1491,7 +1544,10 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
     trimmed_extrema_percent = config_dict.get('kinematics').get('trimmed_extrema_percent')
     close_to_zero_speed_px = config_dict.get('kinematics').get('close_to_zero_speed_px')
     close_to_zero_speed_m = config_dict.get('kinematics').get('close_to_zero_speed_m')
-    if do_ik or use_augmentation or do_filter:
+    # Create a Pose2Sim dictionary and fill in missing keys
+    recursivedict = lambda: defaultdict(recursivedict)
+    Pose2Sim_config_dict = recursivedict()
+    if do_ik or use_augmentation:
         try:
             if use_augmentation:
                 from Pose2Sim.markerAugmentation import augment_markers_all
@@ -1501,9 +1557,6 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
             logging.error("OpenSim package is not installed. Please install it to use inverse kinematics or marker augmentation features (see 'Full install' section of the documentation).")
             raise ImportError("OpenSim package is not installed. Please install it to use inverse kinematics or marker augmentation features (see 'Full install' section of the documentation).")
         
-        # Create a Pose2Sim dictionary and fill in missing keys
-        recursivedict = lambda: defaultdict(recursivedict)
-        Pose2Sim_config_dict = recursivedict()
         # Fill Pose2Sim dictionary (height and mass will be filled later)
         Pose2Sim_config_dict['project']['project_dir'] = str(output_dir)
         Pose2Sim_config_dict['markerAugmentation']['make_c3d'] = make_c3d
@@ -1534,12 +1587,13 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
 
     # Set up video capture
     if video_file == "webcam":
-        cap, out_vid, cam_width, cam_height, fps = setup_webcam(webcam_id, save_vid, vid_output_path, input_size)
+        cap, out_vid, cam_width, cam_height, fps = setup_webcam(webcam_id, vid_output_path, input_size)
+        frame_rate = fps
         frame_range = [0,sys.maxsize]
         frame_iterator = range(*frame_range)
         logging.warning('Webcam input: the framerate may vary. If results are filtered, Sports2D will use the average framerate as input.')
     else:
-        cap, out_vid, cam_width, cam_height, fps = setup_video(video_file_path, save_vid, vid_output_path)
+        cap, out_vid, cam_width, cam_height, fps = setup_video(video_file_path, vid_output_path, save_vid)
         fps *= slowmo_factor
         start_time = get_start_time_ffmpeg(video_file_path)
         frame_range = [int((time_range[0]-start_time) * frame_rate), int((time_range[1]-start_time) * frame_rate)] if time_range else [0, int(cap.get(cv2.CAP_PROP_FRAME_COUNT))]
@@ -1636,10 +1690,11 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
     all_frames_X, all_frames_X_flipped, all_frames_Y, all_frames_scores, all_frames_angles = [], [], [], [], []
     frame_processing_times = []
     frame_count = 0
-    frames = []
+    first_frame = max(int(t0 * fps), frame_range[0])
+    # frames = []
     while cap.isOpened():
         # Skip to the starting frame
-        if frame_count <= int(t0 * fps) or frame_count < frame_range[0]:
+        if frame_count < first_frame:
             cap.read()
             frame_count += 1
             continue
@@ -1659,9 +1714,9 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                 if save_angles:
                     all_frames_angles.append([])
                 continue
-            else: # does not store all frames in memory if they are not saved or used for ordering
-                if save_img or save_vid or person_ordering_method == 'on_click':
-                    frames.append(frame.copy())
+            # else: # does not store all frames in memory if they are not saved or used for ordering
+            #     if save_img or save_vid or person_ordering_method == 'on_click':
+            #         frames.append(frame.copy())
 
             # Retrieve pose or Estimate pose and track people
             if load_trc_px: 
@@ -1670,9 +1725,20 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                 keypoints = keypoints_all[frame_nb]
                 scores = scores_all[frame_nb]
             else: 
+                # Save video on the fly if the input is a webcam
+                if video_file == "webcam":
+                    out_vid.write(frame)
+
                 # Detect poses
                 keypoints, scores = pose_tracker(frame)
 
+                # Non maximum suppression (at pose level, not detection)
+                frame_shape = frame.shape
+                bboxes = bbox_xyxy_compute(frame_shape, keypoints, padding=0)
+                score_bboxes = np.array([np.mean(s) for s in scores])
+                keep = nms(bboxes, score_bboxes, nms_thr=0.45)
+                keypoints, scores = keypoints[keep], scores[keep]
+                
                 # Track poses across frames
                 if tracking_mode == 'deepsort':
                     keypoints, scores = sort_people_deepsort(keypoints, scores, deepsort_tracker, frame, frame_count)
@@ -1775,8 +1841,11 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
         # End of the video is reached
         cap.release()
         logging.info(f"Video processing completed.")
-        if save_vid:
+        if save_vid or video_file == "webcam":
             out_vid.release()
+            if video_file == "webcam":
+                vid_output_path.absolute().rename(video_file_path)
+
         if show_realtime_results:
             cv2.destroyAllWindows()
 
@@ -1813,7 +1882,7 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
             nb_persons_to_detect = nb_detected_persons
 
         if person_ordering_method == 'on_click':
-            selected_persons = get_personIDs_on_click(frames, all_frames_X_homog, all_frames_Y_homog)
+            selected_persons = get_personIDs_on_click(video_file_path, frame_range, all_frames_X_homog, all_frames_Y_homog)
             if len(selected_persons) == 0:
                 logging.warning('No persons selected. Analyzing all detected persons.')
                 selected_persons = list(range(nb_detected_persons))
@@ -1890,8 +1959,13 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                         all_frames_Y_person_interp.replace(np.nan, 0, inplace=True)
 
                 # Filter
+                # if handle_LR_swap:
+                #     logging.info(f'Handling left-right swaps.')
+                #     all_frames_X_person_interp = all_frames_X_person_interp.apply(LR_unswap, axis=0)
+                #     all_frames_Y_person_interp = all_frames_Y_person_interp.apply(LR_unswap, axis=0)
+
                 if reject_outliers:
-                    logging.info('Rejecting outliers with Hampel filter.')
+                    logging.info('Rejecting outliers with a Hampel filter.')
                     all_frames_X_person_interp = all_frames_X_person_interp.apply(hampel_filter, axis=0, args = [round(7*frame_rate/30), 2])
                     all_frames_Y_person_interp = all_frames_Y_person_interp.apply(hampel_filter, axis=0, args = [round(7*frame_rate/30), 2])
 
@@ -1943,9 +2017,17 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                     columns_to_concat.extend([all_frames_X_person.iloc[:,kpt], all_frames_Y_person.iloc[:,kpt], all_frames_Z_homog.iloc[:,kpt]])
                 trc_data_unfiltered_i = pd.concat([all_frames_time] + columns_to_concat, axis=1)
                 trc_data_unfiltered.append(trc_data_unfiltered_i)
-                if show_plots and not to_meters:
-                    pose_plots(trc_data_unfiltered_i, trc_data_i, i)
-                
+                if not to_meters and (show_plots or save_plots):
+                    pw = pose_plots(trc_data_unfiltered_i, trc_data_i, i, show=show_plots)
+                    if save_plots:
+                        for n, f in enumerate(pw.figure_handles):
+                            dpi = pw.canvases[i].figure.dpi
+                            f.set_size_inches(1280/dpi, 720/dpi)
+                            title = pw.tabs.tabText(n)
+                            plot_path = plots_output_dir / (pose_output_path.stem + f'_person{i:02d}_px_{title.replace(" ","_").replace("/","_")}.png')
+                            f.savefig(plot_path, dpi=dpi, bbox_inches='tight')
+                        logging.info(f'Pose plots (px) saved in {plots_output_dir}.')
+                        
                 all_frames_X_processed[:,idx_person,:], all_frames_Y_processed[:,idx_person,:] = all_frames_X_person_filt, all_frames_Y_person_filt
                 if calculate_angles or save_angles:
                     all_frames_X_flipped_processed[:,idx_person,:] = all_frames_X_flipped_person
@@ -2031,9 +2113,17 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                     px_to_m_unfiltered_i = [convert_px_to_meters(trc_data_unfiltered[i][kpt_name], first_person_height, height_px, cx, cy, -floor_angle_estim) for kpt_name in new_keypoints_names]
                     trc_data_unfiltered_m_i = pd.concat([all_frames_time.rename('time')]+px_to_m_unfiltered_i, axis=1)
 
-                    if to_meters and show_plots:
-                        pose_plots(trc_data_unfiltered_m_i, trc_data_m_i, i)
-                    
+                    if to_meters and (show_plots or save_plots):
+                        pw = pose_plots(trc_data_unfiltered_m_i, trc_data_m_i, i, show=show_plots)
+                        if save_plots:
+                            for n, f in enumerate(pw.figure_handles):
+                                dpi = pw.canvases[i].figure.dpi
+                                f.set_size_inches(1280/dpi, 720/dpi)
+                                title = pw.tabs.tabText(n)
+                                plot_path = plots_output_dir / (pose_output_path_m.stem + f'_person{i:02d}_m_{title.replace(" ","_").replace("/","_")}.png')
+                                f.savefig(plot_path, dpi=dpi, bbox_inches='tight')
+                            logging.info(f'Pose plots (m) saved in {plots_output_dir}.')
+
                     # Write to trc file
                     trc_data_m.append(trc_data_m_i)
                     pose_path_person_m_i = (pose_output_path.parent / (pose_output_path_m.stem + f'_person{i:02d}.trc'))
@@ -2140,7 +2230,7 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                 
                 # Filter
                 if reject_outliers:
-                    logging.info(f'Rejecting outliers with Hampel filter.')
+                    logging.info(f'Rejecting outliers with a Hampel filter.')
                     all_frames_angles_person_interp = all_frames_angles_person_interp.apply(hampel_filter, axis=0)
 
                 if not do_filter:
@@ -2172,7 +2262,7 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                         logging.error(f"Invalid filter_type: {filter_type}. Must be 'butterworth', 'gcv_spline', 'kalman', 'gaussian', 'loess', or 'median'.")
                         raise ValueError(f"Invalid filter_type: {filter_type}. Must be 'butterworth', 'gcv_spline', 'kalman', 'gaussian', 'loess', or 'median'.")
 
-                    logging.info(f'Filtering with {args}.')
+                    logging.info(f'Filtering with {args}')
                     all_frames_angles_person_filt = all_frames_angles_person_interp.apply(filter1d, axis=0, args = [Pose2Sim_config_dict, filter_type, frame_rate])
 
                 # Add floor_angle_estim to segment angles
@@ -2192,9 +2282,16 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                 logging.info(f'Angles saved to {angles_path_person.resolve()}.')
 
                 # Plotting angles before and after interpolation and filtering
-                if show_plots:
-                    all_frames_angles_person.insert(0, 'time', all_frames_time)
-                    angle_plots(all_frames_angles_person, angle_data, i) # i = current person
+                all_frames_angles_person.insert(0, 'time', all_frames_time)
+                if save_plots and (show_plots or save_plots):
+                    pw = angle_plots(all_frames_angles_person, angle_data, i, show=show_plots) # i = current person
+                    for n, f in enumerate(pw.figure_handles):
+                        dpi = pw.canvases[i].figure.dpi
+                        f.set_size_inches(1280/dpi, 720/dpi)
+                        title = pw.tabs.tabText(n)
+                        plot_path = plots_output_dir / (pose_output_path_m.stem + f'_person{i:02d}_ang_{title.replace(" ","_").replace("/","_")}.png')
+                        f.savefig(plot_path, dpi=dpi, bbox_inches='tight')
+                    logging.info(f'Pose plots (m) saved in {plots_output_dir}.')
 
 
     #%% ==================================================
@@ -2228,22 +2325,28 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
         new_keypoints_ids = list(range(len(new_keypoints_ids)))
 
         # Draw pose and angles
+        first_frame, last_frame = frame_range
         if 'first_trim' not in locals():
-            first_trim, last_trim = 0, frame_count-1
-        for frame_count, (frame, valid_X, valid_X_flipped, valid_Y, valid_scores, valid_angles) in enumerate(zip(frames, all_frames_X_processed, all_frames_X_flipped_processed, all_frames_Y_processed, all_frames_scores_processed, all_frames_angles_processed)):
-            if frame_count >= first_trim and frame_count <= last_trim:
-                img = frame.copy()
-                img = draw_bounding_box(img, valid_X, valid_Y, colors=colors, fontSize=fontSize, thickness=thickness)
-                img = draw_keypts(img, valid_X, valid_Y, valid_scores, cmap_str='RdYlGn')
-                img = draw_skel(img, valid_X, valid_Y, pose_model_with_new_ids)
-                if calculate_angles:
-                    img = draw_angles(img, valid_X, valid_Y, valid_angles, valid_X_flipped, new_keypoints_ids, new_keypoints_names, angle_names, display_angle_values_on=display_angle_values_on, colors=colors, fontSize=fontSize, thickness=thickness)
-
-                # Save video or images
-                if save_vid:
-                    out_vid.write(img)
-                if save_img:
-                    cv2.imwrite(str((img_output_dir / f'{output_dir_name}_{(frame_count+frame_range[0]):06d}.png')), img)
+            first_trim, last_trim = first_frame, last_frame
+        cap = cv2.VideoCapture(video_file_path)
+        cap.set(cv2.CAP_PROP_POS_FRAMES, first_frame+first_trim)
+        for i in range(first_trim, last_trim):
+            success, frame = cap.read()
+            if not success:
+                raise ValueError(f"Could not read frame {i}")
+            img = frame.copy()
+            img = draw_bounding_box(img, all_frames_X_processed[i], all_frames_Y_processed[i], colors=colors, fontSize=fontSize, thickness=thickness)
+            img = draw_keypts(img, all_frames_X_processed[i], all_frames_Y_processed[i], all_frames_scores_processed[i], cmap_str='RdYlGn')
+            img = draw_skel(img, all_frames_X_processed[i], all_frames_Y_processed[i], pose_model_with_new_ids)
+            if calculate_angles:
+                img = draw_angles(img, all_frames_X_processed[i], all_frames_Y_processed[i], all_frames_angles_processed[i], all_frames_X_flipped_processed[i], new_keypoints_ids, new_keypoints_names, angle_names, display_angle_values_on=display_angle_values_on, colors=colors, fontSize=fontSize, thickness=thickness)
+
+            # Save video or images
+            if save_vid:
+                out_vid.write(img)
+            if save_img:
+                cv2.imwrite(str((img_output_dir / f'{output_dir_name}_{(i+frame_range[0]):06d}.png')), img)
+        cap.release()
 
         if save_vid:
             out_vid.release()

{sports2d-0.8.18.dist-info → sports2d-0.8.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sports2d
-Version: 0.8.18
+Version: 0.8.20
 Summary: Compute 2D human pose and angles from a video or a webcam.
 Author-email: David Pagnon <contact@david-pagnon.com>
 Maintainer-email: David Pagnon <contact@david-pagnon.com>
@@ -35,10 +35,10 @@ Requires-Dist: ipython
 Requires-Dist: c3d
 Requires-Dist: rtmlib
 Requires-Dist: openvino
-Requires-Dist: opencv-python
+Requires-Dist: opencv-python<4.12
 Requires-Dist: imageio_ffmpeg
 Requires-Dist: deep-sort-realtime
-Requires-Dist: Pose2Sim>=0.10.33
+Requires-Dist: Pose2Sim>=0.10.36
 Dynamic: license-file
 
 
@@ -145,7 +145,7 @@ If you need 3D research-grade markerless joint kinematics, consider using severa
 
 > N.B.: Full install is required for OpenSim inverse kinematics.
 
-Open a terminal. Type `python -V` to make sure python >=3.10 <=3.11 is installed. If not, install it [from there](https://www.python.org/downloads/). 
+Open a terminal. Type `python -V` to make sure python >=3.10 <=3.12 is installed. If not, install it [from there](https://www.python.org/downloads/). 
 
 Run:
 ``` cmd
@@ -169,7 +169,7 @@ pip install .
 - Install Anaconda or [Miniconda](https://docs.conda.io/en/latest/miniconda.html):\
   Open an Anaconda prompt and create a virtual environment:
   ``` cmd
-  conda create -n Sports2D python=3.10 -y
+  conda create -n Sports2D python=3.12 -y
   conda activate Sports2D
   ```
 - **Install OpenSim**:\
@@ -568,7 +568,7 @@ Note that any detection and pose models can be used (first [deploy them with MMP
           'pose_model':'https://download.openmmlab.com/mmpose/v1/projects/rtmposev1/onnx_sdk/rtmpose-t_simcc-body7_pt-body7_420e-256x192-026a1439_20230504.zip',
           'pose_input_size':[192,256]}"""
   ```
-- Use `--det_frequency 50`: Will detect poses only every 50 frames, and track keypoints in between, which is faster.
+- Use `--det_frequency 50`: Rtmlib is (by default) a top-down method: detects bounding boxes for every person in the frame, and then detects keypoints inside of each box. The person detection stage is much slower. You can choose to detect persons only every 50 frames (for example), and track bounding boxes inbetween, which is much faster.
 - Use `--load_trc_px <path_to_file_px.trc>`: Will use pose estimation results from a file. Useful if you want to use different parameters for pixel to meter conversion or angle calculation without running detection and pose estimation all over.
 - Make sure you use `--tracking_mode sports2d`: Will use the default Sports2D tracker. Unlike DeepSort, it is faster, does not require any parametrization, and is as good in non-crowded scenes. 
 
@@ -637,13 +637,13 @@ Sports2D:
 
 1. **Reads stream from a webcam, from one video, or from a list of videos**. Selects the specified time range to process.
 
-2. **Sets up pose estimation with RTMLib.** It can be run in lightweight, balanced, or performance mode, and for faster inference, keypoints can be tracked instead of detected for a certain number of frames. Any RTMPose model can be used. 
+2. **Sets up pose estimation with RTMLib.** It can be run in lightweight, balanced, or performance mode, and for faster inference, the person bounding boxes can be tracked instead of detected every frame. Any RTMPose model can be used. 
 
 3. **Tracks people** so that their IDs are consistent across frames. A person is associated to another in the next frame when they are at a small distance. IDs remain consistent even if the person disappears from a few frames. We crafted a 'sports2D' tracker which gives good results and runs in real time, but it is also possible to use `deepsort` in particularly challenging situations. 
 
-4. **Chooses the right persons to keep.** In single-person mode, only keeps the person with the highest average scores over the sequence. In multi-person mode, only retrieves the keypoints with high enough confidence, and only keeps the persons with high enough average confidence over each frame.
+4. **Chooses which persons to analyze.** In single-person mode, only keeps the person with the highest average scores over the sequence. In multi-person mode, you can choose the number of persons to analyze (`nb_persons_to_detect`), and how to order them (`person_ordering_method`). The ordering method can be 'on_click', 'highest_likelihood', 'largest_size', 'smallest_size', 'greatest_displacement', 'least_displacement', 'first_detected', or 'last_detected'. `on_click` is default and lets the user click on the persons they are interested in, in the desired order.
 
-4. **Converts the pixel coordinates to meters.** The user can provide a calibration file, or simply the size of a specified person. The floor angle and the coordinate origin can either be detected automatically from the gait sequence, or be manually specified. The depth coordinates are set to normative values, depending on whether the person is going left, right, facing the camera, or looking away.
+4. **Converts the pixel coordinates to meters.** The user can provide the size of a specified person to scale results accordingly. The floor angle and the coordinate origin can either be detected automatically from the gait sequence, or be manually specified. The depth coordinates are set to normative values, depending on whether the person is going left, right, facing the camera, or looking away.
 
 5. **Computes the selected joint and segment angles**, and flips them on the left/right side if the respective foot is pointing to the left/right. 
 
@@ -652,12 +652,14 @@ Sports2D:
   Draws the skeleton and the keypoints, with a green to red color scale to account for their confidence\
   Draws joint and segment angles on the body, and writes the values either near the joint/segment, or on the upper-left of the image with a progress bar
 
-6. **Interpolates and filters results:** Missing pose and angle sequences are interpolated unless gaps are too large. Outliers are rejected with a Hampel filter. Results are filtered with a 6 Hz Butterworth filter. Many other filters are available, and all of the above can be configured or deactivated (see [Config_Demo.toml](https://github.com/davidpagnon/Sports2D/blob/main/Sports2D/Demo/Config_demo.toml))
+6. **Interpolates and filters results:** (1) Swaps between right and left limbs are corrected, (2) Missing pose and angle sequences are interpolated unless gaps are too large, (3) Outliers are rejected with a Hampel filter, and finally (4) Results are filtered, by default with a 6 Hz Butterworth filter. All of the above can be configured or deactivated, and other filters such as Kalman, GCV, Gaussian, LOESS, Median, and Butterworth on speeds are also available (see [Config_Demo.toml](https://github.com/davidpagnon/Sports2D/blob/main/Sports2D/Demo/Config_demo.toml))
 
 7. **Optionally show** processed images, saves them, or saves them as a video\
   **Optionally plots** pose and angle data before and after processing for comparison\
   **Optionally saves** poses for each person as a TRC file in pixels and meters, angles as a MOT file, and calibration data as a [Pose2Sim](https://github.com/perfanalytics/pose2sim) TOML file 
 
+8. **Optionally runs scaling and inverse kinematics** with OpenSim via [Pose2Sim](https://github.com/perfanalytics/pose2sim).
+
 <br>
 
 **Joint angle conventions:**

{sports2d-0.8.18.dist-info → sports2d-0.8.20.dist-info}/RECORD

@@ -9,17 +9,17 @@ Content/paper.md,sha256=8rWSOLrKTysloZv0Fz2lr3nayxtHi7GlFMqwdgDVggY,11333
 Content/sports2d_blender.gif,sha256=wgMuPRxhja3XtQn76_okGXsNnUT9Thp0pnD36GdW5_E,448786
 Content/sports2d_opensim.gif,sha256=XP1AcjqhbGcJknXUoNJjPWAwaM9ahZafbDgLWvzKJs4,376656
 Sports2D/Sports2D.ipynb,sha256=VnOVjIl6ndnCJTT13L4W5qTw4T-TQDF3jt3-wxnXDqM,2427047
-Sports2D/Sports2D.py,sha256=3Mcc_jFaD5Zv4ArB-jKYhgpMlFT0XBifTlSe70volzk,35385
+Sports2D/Sports2D.py,sha256=aCx3Hy1XltgBS7kuQ52b653hQtL_9sjvpQ0xGoPuoOw,35572
 Sports2D/__init__.py,sha256=BuUkPEdItxlkeqz4dmoiPwZLkgAfABJK3KWQ1ujTGwE,153
-Sports2D/process.py,sha256=bDKhKftfDQucuwnVnoXrtHYrMe8qrOP33B6P1wy2wLE,120632
-Sports2D/Demo/Config_demo.toml,sha256=YescEgeQq3ojGqEAFWgXN142HL-YaVcRty9LbJgScoM,15577
+Sports2D/process.py,sha256=VrN8ZQimznjPAk_-1r9NpZnBCzDz9z0lV-E4wNJMCq0,125549
+Sports2D/Demo/Config_demo.toml,sha256=GXlj4tuGvnEpzQm0FFOS2BWVHcGSHGxuudAAHhzsTQc,15665
 Sports2D/Demo/demo.mp4,sha256=2aZkFxhWR7ESMEtXCT8MGA83p2jmoU2sp1ylQfO3gDk,3968304
 Sports2D/Utilities/__init__.py,sha256=BuUkPEdItxlkeqz4dmoiPwZLkgAfABJK3KWQ1ujTGwE,153
 Sports2D/Utilities/common.py,sha256=idMRmesFv5BPX-5g3z5dOVa7SpS_8tNgijvGrOZlR-k,11185
-Sports2D/Utilities/tests.py,sha256=Ec504-4iuAvw5TDNT7upyoPRcs09EIe4Dteph3ybFJA,4702
-sports2d-0.8.18.dist-info/licenses/LICENSE,sha256=f4qe3nE0Y7ltJho5w-xAR0jI5PUox5Xl-MsYiY7ZRM8,1521
-sports2d-0.8.18.dist-info/METADATA,sha256=1X_RdFwHijFHWjOpFrmXkGTAnqCzVXnlAl-ZHnosNNQ,40492
-sports2d-0.8.18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sports2d-0.8.18.dist-info/entry_points.txt,sha256=V8dFDIXatz9VvoGgoHzb2wE71C9-f85K6_OjnEQlxww,108
-sports2d-0.8.18.dist-info/top_level.txt,sha256=cWWBiDD2WbQXMoIoN6-9et9U2t2c_ZKo2JtBqO5uN-k,17
-sports2d-0.8.18.dist-info/RECORD,,
+Sports2D/Utilities/tests.py,sha256=bUcPoaIwa6ur13Njup5MjGY3N060Ropl_MCdAbCAbTc,4792
+sports2d-0.8.20.dist-info/licenses/LICENSE,sha256=f4qe3nE0Y7ltJho5w-xAR0jI5PUox5Xl-MsYiY7ZRM8,1521
+sports2d-0.8.20.dist-info/METADATA,sha256=PX4DMmISr1ZnSSKNHFqGF6F97_SuZBAPV5OOe8tgTPU,41277
+sports2d-0.8.20.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sports2d-0.8.20.dist-info/entry_points.txt,sha256=V8dFDIXatz9VvoGgoHzb2wE71C9-f85K6_OjnEQlxww,108
+sports2d-0.8.20.dist-info/top_level.txt,sha256=cWWBiDD2WbQXMoIoN6-9et9U2t2c_ZKo2JtBqO5uN-k,17
+sports2d-0.8.20.dist-info/RECORD,,