sports2d 0.8.17__py3-none-any.whl → 0.8.19__py3-none-any.whl

Sports2D/Demo/Config_demo.toml

@@ -139,11 +139,12 @@ reject_outliers = true      # Hampel filter for outlier rejection before other f
 
 filter = true
 show_graphs = true         # Show plots of raw and processed results
-filter_type = 'butterworth'     # butterworth, gcv_spline, kalman, gaussian, loess, median, butterworth_on_speed
+filter_type = 'butterworth'     # butterworth, kalman, gcv_spline, gaussian, loess, median, butterworth_on_speed
+   
    # Most intuitive and standard filter in biomechanics
    [post-processing.butterworth]
-   order = 4 
    cut_off_frequency = 6 # Hz # Will be divided by slowmo_factor to be equivalent to non slowed-down video
+   order = 4 
 
    # Used in countless applications, this one is a simplified Kalman filter 
    [post-processing.kalman]
@@ -153,8 +154,8 @@ filter_type = 'butterworth'     # butterworth, gcv_spline, kalman, gaussian, loe
 
    # Automatically determines optimal parameters for each point, which is good when some move faster than others (eg fingers vs hips).
    [post-processing.gcv_spline]
-   cut_off_frequency = 'auto' # 'auto' or int # If int, behaves like a Butterworth filter. 'auto' is sometimes unstable
-   smoothing_factor = 0.1 # >=0, ignored if cut_off_frequency != 'auto'. Biases results towards more smoothing (>1) or more fidelity to data (<1) 
+   gcv_cut_off_frequency = 'auto' # 'auto' or int # If int, behaves like a Butterworth filter. 'auto' is usually better, unless the signal is too short (noise can then be considered as signal -> trajectories not filtered)
+   gcv_smoothing_factor = 0.1 # >=0, ignored if cut_off_frequency != 'auto'. Biases results towards more smoothing (>1) or more fidelity to data (<1) 
 
    [post-processing.loess]
    nb_values_used = 5 # = fraction of data used * nb frames

Sports2D/Sports2D.py

@@ -239,7 +239,7 @@ DEFAULT_CONFIG =   {'base': {'video_input': ['demo.mp4'],
                                         'filter_type': 'butterworth',
                                         'butterworth': {'order': 4, 'cut_off_frequency': 6.0},
                                         'kalman': {'trust_ratio': 500.0, 'smooth':True},
-                                        'gcv_spline': {'gcv_cut_off_frequency': 'auto', 'smoothing_factor': 0.1},
+                                        'gcv_spline': {'gcv_cut_off_frequency': 'auto', 'gcv_smoothing_factor': 1.0},
                                         'gaussian': {'sigma_kernel': 1},
                                         'loess': {'nb_values_used': 5},
                                         'median': {'kernel_size': 3},
@@ -327,12 +327,12 @@ CONFIG_HELP =   {'config': ["C", "path to a toml configuration file"],
                 'reject_outliers': ["", "reject outliers with Hampel filter before other filtering methods. true if not specified"],
                 'filter': ["", "filter results. true if not specified"],
                 'filter_type': ["", "butterworth, kalman, gcv_spline, gaussian, median, or loess. butterworth if not specified"],
+                'cut_off_frequency': ["", "cut-off frequency of the Butterworth filter. 6 if not specified"],
                 'order': ["", "order of the Butterworth filter. 4 if not specified"],
-                'cut_off_frequency': ["", "cut-off frequency of the Butterworth filter. 3 if not specified"],
+                'gcv_cut_off_frequency': ["", "cut-off frequency of the GCV spline filter. 'auto' is usually better, unless the signal is too short (noise can then be considered as signal -> trajectories not filtered). 'auto' if not specified"],
+                'gcv_smoothing_factor': ["", "smoothing factor of the GCV spline filter (>=0). Ignored if cut_off_frequency != 'auto'. Biases results towards more smoothing (>1) or more fidelity to data (<1). 1.0 if not specified"],
                 'trust_ratio': ["", "trust ratio of the Kalman filter: How much more do you trust triangulation results (measurements), than the assumption of constant acceleration(process)? 500 if not specified"],
                 'smooth': ["", "dual Kalman smoothing. true if not specified"],
-                'gcv_cut_off_frequency': ["", "cut-off frequency of the GCV spline filter. 'auto' if not specified"],
-                'smoothing_factor': ["", "smoothing factor of the GCV spline filter (>=0). Ignored if cut_off_frequency != 'auto'. Biases results towards more smoothing (>1) or more fidelity to data (<1). 0.1 if not specified"],
                 'sigma_kernel': ["", "sigma of the gaussian filter. 1 if not specified"],
                 'nb_values_used': ["", "number of values used for the loess filter. 5 if not specified"],
                 'kernel_size': ["", "kernel size of the median filter. 3 if not specified"],

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

@@ -83,8 +83,14 @@ 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
+import ssl
+ssl._create_default_https_context = ssl._create_unverified_context
+
+
 
 DEFAULT_MASS = 70
 DEFAULT_HEIGHT = 1.7
@@ -101,7 +107,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.
 
@@ -127,29 +133,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.
 
@@ -980,12 +985,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)
 
@@ -996,23 +1002,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:
@@ -1026,93 +1028,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]:
@@ -1205,6 +1156,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)
@@ -1441,29 +1487,31 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
     sections_to_keep = config_dict.get('post-processing').get('sections_to_keep')
 
     do_filter = config_dict.get('post-processing').get('filter')
+    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')
     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')
-    gcv_filter_cutoff = config_dict.get('post-processing').get('gcv_spline').get('cut_off_frequency')
-    gcv_filter_smoothingfactor = config_dict.get('post-processing').get('gcv_spline').get('smoothing_factor')
-    kalman_filter_trust_ratio = config_dict.get('post-processing').get('kalman').get('trust_ratio')
-    kalman_filter_smooth = config_dict.get('post-processing').get('kalman').get('smooth')
-    gaussian_filter_kernel = config_dict.get('post-processing').get('gaussian').get('sigma_kernel')
-    loess_filter_kernel = config_dict.get('post-processing').get('loess').get('nb_values_used')
-    median_filter_kernel = config_dict.get('post-processing').get('median').get('kernel_size')
-    butterworthspeed_filter_order = config_dict.get('post-processing').get('butterworth_on_speed').get('order')
-    butterworthspeed_filter_cutoff = config_dict.get('post-processing').get('butterworth_on_speed').get('cut_off_frequency')
+    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')
+    gcv_filter_cutoff = config_dict.get('post-processing').get('gcv_spline', {}).get('gcv_cut_off_frequency')
+    gcv_smoothing_factor = config_dict.get('post-processing').get('gcv_spline', {}).get('gcv_smoothing_factor')
+    kalman_filter_trust_ratio = config_dict.get('post-processing').get('kalman', {}).get('trust_ratio')
+    kalman_filter_smooth = config_dict.get('post-processing').get('kalman', {}).get('smooth')
+    gaussian_filter_kernel = config_dict.get('post-processing').get('gaussian', {}).get('sigma_kernel')
+    loess_filter_kernel = config_dict.get('post-processing').get('loess', {}).get('nb_values_used')
+    median_filter_kernel = config_dict.get('post-processing').get('median', {}).get('kernel_size')
+    butterworthspeed_filter_order = config_dict.get('post-processing').get('butterworth_on_speed', {}).get('order')
+    butterworthspeed_filter_cutoff = config_dict.get('post-processing').get('butterworth_on_speed', {}).get('cut_off_frequency')
 
     # 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
     img_output_dir = output_dir / f'{output_dir_name}_img'
     vid_output_path = output_dir / f'{output_dir_name}.mp4'
@@ -1485,21 +1533,19 @@ 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
             if do_ik:
                 from Pose2Sim.kinematics import kinematics_all
-            if do_filter:
-                from Pose2Sim.filtering import filter_all
         except ImportError:
             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
@@ -1511,14 +1557,14 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
         kinematics_dir.mkdir(parents=True, exist_ok=True)
     
     if do_filter:
-        print(filter_type)
+        Pose2Sim_config_dict['personAssociation']['handle_LR_swap'] = handle_LR_swap
         Pose2Sim_config_dict['filtering']['reject_outliers'] = reject_outliers
         Pose2Sim_config_dict['filtering']['filter'] = do_filter
         Pose2Sim_config_dict['filtering']['type'] = filter_type
-        Pose2Sim_config_dict['filtering']['butterworth']['order'] = butterworth_filter_order
-        Pose2Sim_config_dict['filtering']['butterworth']['cut_off_frequency'] = butterworth_filter_cutoff
         Pose2Sim_config_dict['filtering']['gcv_spline']['cut_off_frequency'] = gcv_filter_cutoff
-        Pose2Sim_config_dict['filtering']['gcv_spline']['smoothing_factor'] = gcv_filter_smoothingfactor
+        Pose2Sim_config_dict['filtering']['gcv_spline']['smoothing_factor'] = gcv_smoothing_factor
+        Pose2Sim_config_dict['filtering']['butterworth']['cut_off_frequency'] = butterworth_filter_cutoff
+        Pose2Sim_config_dict['filtering']['butterworth']['order'] = butterworth_filter_order
         Pose2Sim_config_dict['filtering']['kalman']['trust_ratio'] = kalman_filter_trust_ratio
         Pose2Sim_config_dict['filtering']['kalman']['smooth'] = kalman_filter_smooth
         Pose2Sim_config_dict['filtering']['gaussian']['sigma_kernel'] = gaussian_filter_kernel
@@ -1530,12 +1576,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))]
@@ -1632,10 +1679,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
@@ -1655,9 +1703,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: 
@@ -1666,6 +1714,10 @@ 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)
 
@@ -1771,8 +1823,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()
 
@@ -1809,7 +1864,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))
@@ -1886,8 +1941,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])
 
@@ -2136,7 +2196,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:
@@ -2168,7 +2228,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
@@ -2224,22 +2284,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.17.dist-info → sports2d-0.8.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sports2d
-Version: 0.8.17
+Version: 0.8.19
 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,7 +35,7 @@ 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
@@ -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. You can reject outliers with a Hampel filter): `--reject_outliers True`. Results are filtered according to the selected filter (among `Butterworth`, `Kalman`, `GCV_spline`, `Gaussian`, `LOESS`, `Median`, or `Butterworth_on_speed`) and their parameters, or not filtered at all if `--filter False`.\
+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.17.dist-info → sports2d-0.8.19.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=6uL8wvkRDAQ0Y2EigP5SamOBV2cLZTtqgtfwNT4MwNg,35249
+Sports2D/Sports2D.py,sha256=3Mcc_jFaD5Zv4ArB-jKYhgpMlFT0XBifTlSe70volzk,35385
 Sports2D/__init__.py,sha256=BuUkPEdItxlkeqz4dmoiPwZLkgAfABJK3KWQ1ujTGwE,153
-Sports2D/process.py,sha256=N4SnBGqOBDEtyAdDS0yUi_EuSVUO2yIoG8p8yzmoAA0,120372
-Sports2D/Demo/Config_demo.toml,sha256=PSSY722ymsBMXrrgIMcmJpf0acT4SriLKdWNQd0yZ-8,15467
+Sports2D/process.py,sha256=hw9En4j6ROPmow0YmPK8Ohuc8Li8CoEEUXdtUTN_5zg,122898
+Sports2D/Demo/Config_demo.toml,sha256=YescEgeQq3ojGqEAFWgXN142HL-YaVcRty9LbJgScoM,15577
 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.17.dist-info/licenses/LICENSE,sha256=f4qe3nE0Y7ltJho5w-xAR0jI5PUox5Xl-MsYiY7ZRM8,1521
-sports2d-0.8.17.dist-info/METADATA,sha256=uNvpOHxPoDGclpbj2ap0z98qCWsL_F2t2vwnHaDnVzQ,40498
-sports2d-0.8.17.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sports2d-0.8.17.dist-info/entry_points.txt,sha256=V8dFDIXatz9VvoGgoHzb2wE71C9-f85K6_OjnEQlxww,108
-sports2d-0.8.17.dist-info/top_level.txt,sha256=cWWBiDD2WbQXMoIoN6-9et9U2t2c_ZKo2JtBqO5uN-k,17
-sports2d-0.8.17.dist-info/RECORD,,
+Sports2D/Utilities/tests.py,sha256=bUcPoaIwa6ur13Njup5MjGY3N060Ropl_MCdAbCAbTc,4792
+sports2d-0.8.19.dist-info/licenses/LICENSE,sha256=f4qe3nE0Y7ltJho5w-xAR0jI5PUox5Xl-MsYiY7ZRM8,1521
+sports2d-0.8.19.dist-info/METADATA,sha256=F5rmn0eQhNwzk_6IYmY8nrtPZv7NHFCqgcnGeAdYHhI,41277
+sports2d-0.8.19.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sports2d-0.8.19.dist-info/entry_points.txt,sha256=V8dFDIXatz9VvoGgoHzb2wE71C9-f85K6_OjnEQlxww,108
+sports2d-0.8.19.dist-info/top_level.txt,sha256=cWWBiDD2WbQXMoIoN6-9et9U2t2c_ZKo2JtBqO5uN-k,17
+sports2d-0.8.19.dist-info/RECORD,,