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

Sports2D/Demo/Config_demo.toml

@@ -125,8 +125,8 @@ joint_angles = ['Right ankle', 'Left ankle', 'Right knee', 'Left knee', 'Right h
 segment_angles = ['Right foot', 'Left foot', 'Right shank', 'Left shank', 'Right thigh', 'Left thigh', 'Pelvis', 'Trunk', 'Shoulders', 'Head', 'Right arm', 'Left arm', 'Right forearm', 'Left forearm']
 
 # Processing parameters
-flip_left_right = true  # Same angles whether the participant faces left/right. Set it to false if you want timeseries to be continuous even when the participent switches their stance.
-correct_segment_angles_with_floor_angle = true # If the camera is tilted, corrects segment angles as regards to the floor angle. Set to false is the floor is tilted instead
+flip_left_right = true  # Same angles whether the participant faces left/right. Set it to false if you want timeseries to be continuous even when the participant switches their stance.
+correct_segment_angles_with_floor_angle = true # If the camera is tilted, corrects segment angles as regards to the floor angle. Set to false if it is the floor which is actually tilted
 
 
 [post-processing]
@@ -135,25 +135,44 @@ interp_gap_smaller_than = 10        # do not interpolate bigger gaps
 fill_large_gaps_with = 'last_value' # 'last_value', 'nan', or 'zeros' 
 sections_to_keep = 'all' # 'all', 'largest', 'first', 'last'
                         # keep 'all' valid sections even when they are interspersed with undetected chunks, or the 'largest' valid section, or the 'first' one, or the 'last' one
+reject_outliers = true      # Hampel filter for outlier rejection before other filtering methods. Rejects outliers that are outside of a 95% confidence interal from the median in a sliding window of size 7.
+
 filter = true
-show_graphs = true            # Show plots of raw and processed results
-filter_type = 'butterworth'   # butterworth, gaussian, LOESS, median
+show_graphs = true         # Show 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
    [post-processing.butterworth]
-   order = 4 
    cut_off_frequency = 6 # Hz # Will be divided by slowmo_factor to be equivalent to non slowed-down video
-   [post-processing.gaussian]
-   sigma_kernel = 1 #px
+   order = 4 
+
+   # Used in countless applications, this one is a simplified Kalman filter 
+   [post-processing.kalman]
+   # How much more do you trust triangulation results (measurements), than the assumption of constant acceleration(process)?
+   trust_ratio = 500 # = measurement_trust/process_trust ~= process_noise/measurement_noise
+   smooth = true # should be true, unless you need real-time filtering
+
+   # Automatically determines optimal parameters for each point, which is good when some move faster than others (eg fingers vs hips).
+   [post-processing.gcv_spline]
+   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
+   [post-processing.gaussian]
+   sigma_kernel = 1 #px
    [post-processing.median]
    kernel_size = 3
+   [post-processing.butterworth_on_speed]
+   order = 4 
+   cut_off_frequency = 10 # Hz
 
 
 [kinematics]
 do_ik = false # Do scaling and inverse kinematics?
 use_augmentation = false  # true or false (lowercase) # Set to true if you want to use the model with augmented markers
 feet_on_floor = false # true or false (lowercase) # Set to false if you want to use the model with feet not on the floor (e.g. running, jumping, etc.)
-use_simple_model = false # true or false # >10 times faster IK if true. No muscles, no constraints (eg stiff spine and shoulders, no patella)
+use_simple_model = false # true or false # IK 10+ times faster, but no muscles or flexible spine, no patella
 participant_mass = [55.0, 67.0] # kg # defaults to 70 if not provided. No influence on kinematics (motion), only on kinetics (forces)
 right_left_symmetry = true # true or false (lowercase) # Set to false only if you have good reasons to think the participant is not symmetrical (e.g. prosthetic limb)
 

Sports2D/Sports2D.py

@@ -141,7 +141,7 @@ DEFAULT_CONFIG =   {'base': {'video_input': ['demo.mp4'],
                                 'save_angles': True,
                                 'result_dir': ''
                                 },
-                    'pose':     {'slowmo_factor': 1,
+                    'pose':     {'slowmo_factor': 1.0,
                                 'pose_model': 'body_with_feet',
                                 'mode': 'balanced',
                                 'det_frequency': 4,
@@ -233,13 +233,17 @@ DEFAULT_CONFIG =   {'base': {'video_input': ['demo.mp4'],
                                         'interp_gap_smaller_than': 10,
                                         'fill_large_gaps_with': 'last_value',
                                         'sections_to_keep':'all',
+                                        'reject_outliers': True,
                                         'filter': True,
                                         'show_graphs': True,
                                         'filter_type': 'butterworth',
-                                        'butterworth': {'order': 4, 'cut_off_frequency': 6},
+                                        'butterworth': {'order': 4, 'cut_off_frequency': 6.0},
+                                        'kalman': {'trust_ratio': 500.0, 'smooth':True},
+                                        '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}
+                                        'median': {'kernel_size': 3},
+                                        'butterworth_on_speed': {'butterspeed_order': 4, 'butterspeed_cut_off_frequency': 6.0},
                                         },
                     'kinematics':{'do_ik': False,
                                           'use_augmentation': False,
@@ -251,9 +255,9 @@ DEFAULT_CONFIG =   {'base': {'video_input': ['demo.mp4'],
                                           'remove_individual_scaling_setup': True,
                                           'remove_individual_ik_setup': True,
                                           'fastest_frames_to_remove_percent': 0.1,
-                                          'close_to_zero_speed_px': 50,
+                                          'close_to_zero_speed_px': 50.0,
                                           'close_to_zero_speed_m': 0.2,
-                                          'large_hip_knee_angles': 45,
+                                          'large_hip_knee_angles': 45.0,
                                           'trimmed_extrema_percent': 0.5,
                                           'osim_setup_path': '../OpenSim_setup'
                                           },
@@ -298,7 +302,7 @@ CONFIG_HELP =   {'config': ["C", "path to a toml configuration file"],
                 'do_ik': ["", "do inverse kinematics. false if not specified"],
                 'use_augmentation': ["", "Use LSTM marker augmentation. false if not specified"],
                 'feet_on_floor': ["", "offset marker augmentation results so that feet are at floor level. true if not specified"],
-                'use_simple_model': ["", ">10 times faster IK if true. No muscles, no constraints (eg stiff spine and shoulders, no patella). false if not specified"],
+                'use_simple_model': ["", "IK 10+ times faster, but no muscles or flexible spine, no patella. false if not specified"],
                 'participant_mass': ["", "mass of the participant in kg or none. Defaults to 70 if not provided. No influence on kinematics (motion), only on kinetics (forces)"],
                 'close_to_zero_speed_m': ["","Sum for all keypoints: about 50 px/frame or 0.2 m/frame"], 
                 'tracking_mode': ["", "'sports2d' or 'deepsort'. 'deepsort' is slower, harder to parametrize but can be more robust if correctly tuned"],
@@ -314,19 +318,26 @@ CONFIG_HELP =   {'config': ["C", "path to a toml configuration file"],
                 'large_hip_knee_angles': ["", "Hip and knee angles below this value are considered as imprecise. Defaults to 45"],
                 'trimmed_extrema_percent': ["", "Proportion of the most extreme segment values to remove before calculating their mean. Defaults to 50"],
                 'fontSize': ["", "font size for angle values. 0.3 if not specified"],
-                'flip_left_right': ["", "true or false. Flips angles when the person faces the other side. The person looks to the right if their toe keypoint is to the right of their heel. Set it to false if the person is sprinting or if you want timeseries to be continuous even when the participent switches their stance. true if not specified"],
-                'correct_segment_angles_with_floor_angle': ["", "true or false. If the camera is tilted, corrects segment angles as regards to the floor angle. Set to false is the floor is tilted instead. True if not specified"],
+                'flip_left_right': ["", "true or false. Flips angles when the person faces the other side. The person looks to the right if their toe keypoint is to the right of their heel. Set it to false if the person is sprinting or if you want timeseries to be continuous even when the participant switches their stance. true if not specified"],
+                'correct_segment_angles_with_floor_angle': ["", "true or false. If the camera is tilted, corrects segment angles as regards to the floor angle. Set to false if it is actually the floor which is tilted, not the camera. True if not specified"],
                 'interpolate': ["", "interpolate missing data. true if not specified"],
                 'interp_gap_smaller_than': ["", "interpolate sequences of missing data if they are less than N frames long. 10 if not specified"],
                 'fill_large_gaps_with': ["", "last_value, nan, or zeros. last_value if not specified"],
                 'sections_to_keep': ["", "all, largest, first, or last.  Keep 'all' valid sections even when they are interspersed with undetected chunks, or the 'largest' valid section, or the 'first' one, or the 'last' one"],
+                '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, gaussian, median, or loess. butterworth 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"],
                 '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"],
+                'butterspeed_order': ["", "order of the Butterworth filter on speed. 4 if not specified"],
+                'butterspeed_cut_off_frequency': ["", "cut-off frequency of the Butterworth filter on speed. 6 if not specified"],
                 'osim_setup_path': ["", "path to OpenSim setup. '../OpenSim_setup' if not specified"],
                 'right_left_symmetry': ["", "right left symmetry. true if not specified"],
                 'default_height': ["", "default height for scaling. 1.70 if not specified"],

Sports2D/process.py

@@ -79,11 +79,17 @@ from matplotlib import patheffects
 from rtmlib import PoseTracker, BodyWithFeet, Wholebody, Body, Hand, Custom
 from deep_sort_realtime.deepsort_tracker import DeepSort
 
-from Sports2D.Utilities import filter
 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.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
@@ -196,7 +202,7 @@ def setup_video(video_file_path, save_vid, vid_output_path):
 
 def setup_model_class_mode(pose_model, mode, config_dict={}):
     '''
-    
+    Set up the pose model class and mode for the pose tracker.
     '''
 
     if pose_model.upper() in ('HALPE_26', 'BODY_WITH_FEET'):
@@ -258,6 +264,10 @@ def setup_model_class_mode(pose_model, mode, config_dict={}):
                         det_class=det_class, det=det, det_input_size=det_input_size,
                         pose_class=pose_class, pose=pose, pose_input_size=pose_input_size)
             logging.info(f"Using model {model_name} with the following custom parameters: {mode}.")
+
+            if pose_class == 'RTMO' and model_name != 'COCO_17':
+                logging.warning("RTMO currently only supports 'Body' pose_model. Switching to 'Body'.")
+                pose_model = eval('COCO_17')
             
         except (json.JSONDecodeError, TypeError):
             logging.warning("Invalid mode. Must be 'lightweight', 'balanced', 'performance', or '''{dictionary}''' of parameters within triple quotes. Make sure input_sizes are within square brackets.")
@@ -1436,16 +1446,21 @@ 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')
-    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')
-    filter_options = [do_filter, filter_type,
-                           butterworth_filter_order, butterworth_filter_cutoff, frame_rate,
-                           gaussian_filter_kernel, loess_filter_kernel, median_filter_kernel]
+    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":
@@ -1476,7 +1491,7 @@ 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:
+    if do_ik or use_augmentation or do_filter:
         try:
             if use_augmentation:
                 from Pose2Sim.markerAugmentation import augment_markers_all
@@ -1498,6 +1513,23 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
         pose3d_dir.mkdir(parents=True, exist_ok=True)
         kinematics_dir = Path(output_dir) / 'kinematics'
         kinematics_dir.mkdir(parents=True, exist_ok=True)
+    
+    if do_filter:
+        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']['gcv_spline']['cut_off_frequency'] = gcv_filter_cutoff
+        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
+        Pose2Sim_config_dict['filtering']['loess']['nb_values_used'] = loess_filter_kernel
+        Pose2Sim_config_dict['filtering']['median']['kernel_size'] = median_filter_kernel
+        Pose2Sim_config_dict['filtering']['butterworth_on_speed']['order'] = butterworthspeed_filter_order
+        Pose2Sim_config_dict['filtering']['butterworth_on_speed']['cut_off_frequency'] = butterworthspeed_filter_cutoff
 
 
     # Set up video capture
@@ -1570,8 +1602,8 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
         # if tracking_mode not in ['deepsort', 'sports2d']:
         #     logging.warning(f"Tracking mode {tracking_mode} not recognized. Using sports2d method.")
         #     tracking_mode = 'sports2d'
-        logging.info(f'Pose tracking set up for "{pose_model_name}" model.')
-        logging.info(f'Mode: {mode}.\n')
+        # logging.info(f'Pose tracking set up for "{pose_model_name}" model.')
+        # logging.info(f'Mode: {mode}.\n')
         logging.info(f'Persons are detected every {det_frequency} frames and tracked inbetween. Tracking is done with {tracking_mode}.')
         if tracking_mode == 'deepsort': logging.info(f'Deepsort parameters: {deepsort_params}.')
         logging.info(f'{"All persons are" if nb_persons_to_detect=="all" else f"{nb_persons_to_detect} persons are" if nb_persons_to_detect>1 else "1 person is"} analyzed. Person ordering method is {person_ordering_method}.')
@@ -1593,7 +1625,7 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
             ang_params = angle_dict.get(ang_name)
             kpts = ang_params[0]
             if any(item not in keypoints_names+['Neck', 'Hip'] for item in kpts):
-                logging.warning(f"Skipping {ang_name} angle computation because at least one of the following keypoints is not provided by the model: {ang_params[0]}.")
+                logging.warning(f"Skipping {ang_name} angle computation because at least one of the following keypoints is not provided by the pose estimation model: {ang_params[0]}.")
 
 
     #%% ==================================================
@@ -1724,7 +1756,6 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                 img = draw_keypts(img, valid_X, valid_Y, valid_scores, cmap_str='RdYlGn')
                 img = draw_skel(img, valid_X, valid_Y, pose_model)
                 if calculate_angles:
-
                     img = draw_angles(img, valid_X, valid_Y, valid_angles_flipped, 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)
                 cv2.imshow(f'{video_file} Sports2D', img)
                 if (cv2.waitKey(1) & 0xFF) == ord('q') or (cv2.waitKey(1) & 0xFF) == 27:
@@ -1859,31 +1890,45 @@ 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 not filter_options[0]:
+                if reject_outliers:
+                    logging.info('Rejecting outliers with 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])
+
+                if not do_filter:
                     logging.info(f'No filtering.')
                     all_frames_X_person_filt = all_frames_X_person_interp
                     all_frames_Y_person_filt = all_frames_Y_person_interp
                 else:
-                    filter_type = filter_options[1]
-                    if filter_type == 'butterworth':
-                        cutoff = filter_options[3]
+                    if filter_type == ('butterworth' or 'butterworth_on_speed'):
+                        cutoff = butterworth_filter_cutoff
                         if video_file == 'webcam':
                             if cutoff / (fps / 2) >= 1:
                                 cutoff_old = cutoff
                                 cutoff = fps/(2+0.001)
                                 args = f'\n{cutoff_old:.1f} Hz cut-off framerate too large for a real-time framerate of {fps:.1f} Hz. Using a cut-off framerate of {cutoff:.1f} Hz instead.'
-                                filter_options[3] = cutoff
-                        args = f'Butterworth filter, {filter_options[2]}th order, {filter_options[3]} Hz.'
-                        filter_options[4] = fps
-                    if filter_type == 'gaussian':
-                        args = f'Gaussian filter, Sigma kernel {filter_options[5]}.'
-                    if filter_type == 'loess':
-                        args = f'LOESS filter, window size of {filter_options[6]} frames.'
-                    if filter_type == 'median':
-                        args = f'Median filter, kernel of {filter_options[7]}.'
+                                butterworth_filter_cutoff = cutoff
+                        filt_type = 'Butterworth' if filter_type == 'butterworth' else 'Butterworth on speed'
+                        args = f'{filt_type} filter, {butterworth_filter_order}th order, {butterworth_filter_cutoff} Hz.'
+                        frame_rate = fps
+                    elif filter_type == 'gcv_spline':
+                        args = f'GVC Spline filter, which automatically evaluates the best trade-off between smoothness and fidelity to data.'
+                    elif filter_type == 'kalman':
+                        args = f'Kalman filter, trusting measurement {kalman_filter_trust_ratio} times more than the process matrix.'
+                    elif filter_type == 'gaussian':
+                        args = f'Gaussian filter, Sigma kernel {gaussian_filter_kernel}.'
+                    elif filter_type == 'loess':
+                        args = f'LOESS filter, window size of {loess_filter_kernel} frames.'
+                    elif filter_type == 'median':
+                        args = f'Median filter, kernel of {median_filter_kernel}.'
+                    else:
+                        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}')
-                    all_frames_X_person_filt = all_frames_X_person_interp.apply(filter.filter1d, axis=0, args=filter_options)
-                    all_frames_Y_person_filt = all_frames_Y_person_interp.apply(filter.filter1d, axis=0, args=filter_options)
+                    all_frames_X_person_filt = all_frames_X_person_interp.apply(filter1d, axis=0, args = [Pose2Sim_config_dict, filter_type, frame_rate])
+                    all_frames_Y_person_filt = all_frames_Y_person_interp.apply(filter1d, axis=0, args = [Pose2Sim_config_dict, filter_type, frame_rate])
+
 
                 # Build TRC file
                 trc_data_i = trc_data_from_XYZtime(all_frames_X_person_filt, all_frames_Y_person_filt, all_frames_Z_homog, all_frames_time)
@@ -2094,29 +2139,41 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                         all_frames_angles_person_interp.replace(np.nan, 0, inplace=True)
                 
                 # Filter
-                if not filter_options[0]:
+                if reject_outliers:
+                    logging.info(f'Rejecting outliers with Hampel filter.')
+                    all_frames_angles_person_interp = all_frames_angles_person_interp.apply(hampel_filter, axis=0)
+
+                if not do_filter:
                     logging.info(f'No filtering.')
                     all_frames_angles_person_filt = all_frames_angles_person_interp
                 else:
-                    filter_type = filter_options[1]
-                    if filter_type == 'butterworth':
-                        cutoff = filter_options[3]
+                    if filter_type == ('butterworth' or 'butterworth_on_speed'):
+                        cutoff = butterworth_filter_cutoff
                         if video_file == 'webcam':
                             if cutoff / (fps / 2) >= 1:
                                 cutoff_old = cutoff
                                 cutoff = fps/(2+0.001)
                                 args = f'\n{cutoff_old:.1f} Hz cut-off framerate too large for a real-time framerate of {fps:.1f} Hz. Using a cut-off framerate of {cutoff:.1f} Hz instead.'
-                                filter_options[3] = cutoff
-                        args = f'Butterworth filter, {filter_options[2]}th order, {filter_options[3]} Hz.'
-                        filter_options[4] = fps
-                    if filter_type == 'gaussian':
-                        args = f'Gaussian filter, Sigma kernel {filter_options[5]}.'
-                    if filter_type == 'loess':
-                        args = f'LOESS filter, window size of {filter_options[6]} frames.'
-                    if filter_type == 'median':
-                        args = f'Median filter, kernel of {filter_options[7]}.'
-                    logging.info(f'Filtering with {args}')
-                    all_frames_angles_person_filt = all_frames_angles_person_interp.apply(filter.filter1d, axis=0, args=filter_options)
+                                butterworth_filter_cutoff = cutoff
+                        filt_type = 'Butterworth' if filter_type == 'butterworth' else 'Butterworth on speed'
+                        args = f'{filt_type} filter, {butterworth_filter_order}th order, {butterworth_filter_cutoff} Hz.'
+                        frame_rate = fps
+                    elif filter_type == 'gcv_spline':
+                        args = f'GVC Spline filter, which automatically evaluates the best trade-off between smoothness and fidelity to data.'
+                    elif filter_type == 'kalman':
+                        args = f'Kalman filter, trusting measurement {kalman_filter_trust_ratio} times more than the process matrix.'
+                    elif filter_type == 'gaussian':
+                        args = f'Gaussian filter, Sigma kernel {gaussian_filter_kernel}.'
+                    elif filter_type == 'loess':
+                        args = f'LOESS filter, window size of {loess_filter_kernel} frames.'
+                    elif filter_type == 'median':
+                        args = f'Median filter, kernel of {median_filter_kernel}.'
+                    else:
+                        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}.')
+                    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
                 if correct_segment_angles_with_floor_angle and to_meters:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sports2d
-Version: 0.8.16
+Version: 0.8.18
 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>
@@ -38,7 +38,7 @@ Requires-Dist: openvino
 Requires-Dist: opencv-python
 Requires-Dist: imageio_ffmpeg
 Requires-Dist: deep-sort-realtime
-Requires-Dist: Pose2Sim
+Requires-Dist: Pose2Sim>=0.10.33
 Dynamic: license-file
 
 
@@ -521,13 +521,21 @@ sports2d --help
 'interpolate': ["", "interpolate missing data. true if not specified"],
 'interp_gap_smaller_than': ["", "interpolate sequences of missing data if they are less than N frames long. 10 if not specified"],
 'fill_large_gaps_with': ["", "last_value, nan, or zeros. last_value if not specified"],
+'sections_to_keep': ["", "all, largest, first, or last.  Keep 'all' valid sections even when they are interspersed with undetected chunks, or the 'largest' valid section, or the 'first' one, or the 'last' one"],
+'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, gaussian, median, or loess. butterworth if not specified"],
+'filter_type': ["", "butterworth, kalman, gcv_spline, gaussian, median, or loess. butterworth 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"],
+'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"],
+'butterspeed_order': ["", "order of the Butterworth filter on speed. 4 if not specified"],
+'butterspeed_cut_off_frequency': ["", "cut-off frequency of the Butterworth filter on speed. 6 if not specified"],
 'osim_setup_path': ["", "path to OpenSim setup. '../OpenSim_setup' if not specified"],
 'right_left_symmetry': ["", "right left symmetry. true if not specified"],
 'default_height': ["", "default height for scaling. 1.70 if not specified"],
@@ -644,7 +652,7 @@ 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. Results are filtered according to the selected filter (among `Butterworth`, `Gaussian`, `LOESS`, or `Median`) and their parameters
+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))
 
 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\

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

@@ -9,18 +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=Cq8UEKtwyNGWyaWjHAaVUTU8nwbmPuohAWmGbXb-hZM,33815
+Sports2D/Sports2D.py,sha256=3Mcc_jFaD5Zv4ArB-jKYhgpMlFT0XBifTlSe70volzk,35385
 Sports2D/__init__.py,sha256=BuUkPEdItxlkeqz4dmoiPwZLkgAfABJK3KWQ1ujTGwE,153
-Sports2D/process.py,sha256=_9rFaPP6eRiRYlrQ99hjtBPNrDktHL38bXDveyAJPzk,115750
-Sports2D/Demo/Config_demo.toml,sha256=skeMUqEyfWSrCF8Va8O0eiHsZRBLZooTZ1w-4-gm6Zc,14265
+Sports2D/process.py,sha256=bDKhKftfDQucuwnVnoXrtHYrMe8qrOP33B6P1wy2wLE,120632
+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/filter.py,sha256=rfZcqofjllKI_5ovZTKEAmyjOZpB_PzbAJ0P874T8Ak,4973
 Sports2D/Utilities/tests.py,sha256=Ec504-4iuAvw5TDNT7upyoPRcs09EIe4Dteph3ybFJA,4702
-sports2d-0.8.16.dist-info/licenses/LICENSE,sha256=f4qe3nE0Y7ltJho5w-xAR0jI5PUox5Xl-MsYiY7ZRM8,1521
-sports2d-0.8.16.dist-info/METADATA,sha256=uA1npoK1Uqbi_Bn7oeMVFX2F44VaXhWLJUGsCzbXc7U,39189
-sports2d-0.8.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sports2d-0.8.16.dist-info/entry_points.txt,sha256=V8dFDIXatz9VvoGgoHzb2wE71C9-f85K6_OjnEQlxww,108
-sports2d-0.8.16.dist-info/top_level.txt,sha256=cWWBiDD2WbQXMoIoN6-9et9U2t2c_ZKo2JtBqO5uN-k,17
-sports2d-0.8.16.dist-info/RECORD,,
+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/filter.py

@@ -1,176 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-
-'''
-    ##################################################
-    ## Filter TRC files                             ##
-    ##################################################
-    
-    Filters pandans columns or numpy arrays.
-    Available filters: Butterworth, Gaussian, LOESS, Median.
-    
-    Usage: 
-    col_filtered = filter1d(col, *filter_options)
-    filter_options = (do_filter, filter_type, butterworth_filter_order, butterworth_filter_cutoff, frame_rate, gaussian_filter_kernel, loess_filter_kernel, median_filter_kernel)
-                        bool        str             int                         int                    int         int                     int                 int
-    
-'''
-
-
-## INIT
-from importlib.metadata import version
-import numpy as np
-from scipy import signal
-from scipy.ndimage import gaussian_filter1d
-from statsmodels.nonparametric.smoothers_lowess import lowess
-
-
-## AUTHORSHIP INFORMATION
-__author__ = "David Pagnon"
-__copyright__ = "Copyright 2021, Pose2Sim"
-__credits__ = ["David Pagnon"]
-__license__ = "BSD 3-Clause License"
-__version__ = version("sports2d")
-__maintainer__ = "David Pagnon"
-__email__ = "contact@david-pagnon.com"
-__status__ = "Development"
-
-
-
-## FUNCTIONS
-def butterworth_filter_1d(col, args):
-    '''
-    1D Zero-phase Butterworth filter (dual pass)
-    Deals with nans
-
-    INPUT:
-    - col: numpy array
-    - order: int
-    - cutoff: int
-    - framerate: int
-
-    OUTPUT
-    - col_filtered: Filtered pandas dataframe column
-    '''
-
-    order, cutoff, framerate = args
-
-    # Filter
-    b, a = signal.butter(order/2, cutoff/(framerate/2), 'low', analog = False)
-    padlen = 3 * max(len(a), len(b))
-    
-    # split into sequences of not nans
-    col_filtered = col.copy()
-    mask = np.isnan(col_filtered) | col_filtered.eq(0)
-    falsemask_indices = np.where(~mask)[0]
-    gaps = np.where(np.diff(falsemask_indices) > 1)[0] + 1 
-    idx_sequences = np.split(falsemask_indices, gaps)
-    if idx_sequences[0].size > 0:
-        idx_sequences_to_filter = [seq for seq in idx_sequences if len(seq) > padlen]
-    
-        # Filter each of the selected sequences
-        for seq_f in idx_sequences_to_filter:
-            col_filtered[seq_f] = signal.filtfilt(b, a, col_filtered[seq_f])
-    
-    return col_filtered
-
-
-def gaussian_filter_1d(col, kernel):
-    '''
-    1D Gaussian filter
-
-    INPUT:
-    - col: numpy array
-    - kernel: Sigma kernel value (int)
-
-    OUTPUT
-    - col_filtered: Filtered pandas dataframe column
-    '''
-
-    col_filtered = gaussian_filter1d(col, kernel)
-
-    return col_filtered
-    
-
-def loess_filter_1d(col, kernel):
-    '''
-    1D LOWESS filter (Locally Weighted Scatterplot Smoothing)
-
-    INPUT:
-    - col: numpy array
-    - kernel: Kernel value: window length used for smoothing (int)
-    NB: frac = kernel / frames_number
-
-    OUTPUT
-    - col_filtered: Filtered pandas dataframe column
-    '''
-    
-    # split into sequences of not nans
-    col_filtered = col.copy()
-    mask = np.isnan(col_filtered) 
-    falsemask_indices = np.where(~mask)[0]
-    gaps = np.where(np.diff(falsemask_indices) > 1)[0] + 1 
-    idx_sequences = np.split(falsemask_indices, gaps)
-    if idx_sequences[0].size > 0:
-        idx_sequences_to_filter = [seq for seq in idx_sequences if len(seq) > kernel]
-    
-        # Filter each of the selected sequences
-        for seq_f in idx_sequences_to_filter:
-            col_filtered[seq_f] = lowess(col_filtered[seq_f], seq_f, is_sorted=True, frac=kernel/len(seq_f), it=0)[:,1]
-    
-    return col_filtered
-    
-
-def median_filter_1d(col, kernel):
-    '''
-    1D median filter
-
-    INPUT:
-    - col: numpy array
-    - kernel: window size (int)
-    
-    OUTPUT
-    - col_filtered: Filtered pandas dataframe column
-    '''
-    
-    col_filtered = signal.medfilt(col, kernel_size=kernel)
-
-    return col_filtered
-    
-
-def filter1d(col, *filter_options):
-    '''
-    Choose filter type and filter column
-
-    INPUT:
-    - col: Pandas dataframe column
-    - filter_options = (do_filter, filter_type, butterworth_filter_order, butterworth_filter_cutoff, frame_rate, gaussian_filter_kernel, loess_filter_kernel, median_filter_kernel)
-    
-    OUTPUT
-    - col_filtered: Filtered pandas dataframe column
-    '''
-    
-    filter_type = filter_options[1]
-    if filter_type == 'butterworth':
-        args = (filter_options[2], filter_options[3], filter_options[4])
-    if filter_type == 'gaussian':
-        args = (filter_options[5])
-    if filter_type == 'loess':
-        args = (filter_options[6])
-    if filter_type == 'median':
-        args = (filter_options[7])
-        
-    # Choose filter
-    filter_mapping = {
-        'butterworth': butterworth_filter_1d, 
-        'gaussian': gaussian_filter_1d, 
-        'loess': loess_filter_1d, 
-        'median': median_filter_1d
-        }
-    filter_fun = filter_mapping[filter_type]
-    
-    # Filter column
-    col_filtered = filter_fun(col, args)
-
-    return col_filtered