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

Sports2D/Demo/Calib_demo.toml

@@ -0,0 +1,12 @@
+[demo]
+name = "demo"
+size = [ 1768, 994]
+matrix = [ [ 2520.0897058227038, 0.0, 884.0], [ 0.0, 2520.0897058227038, 497.0], [ 0.0, 0.0, 1.0]]
+distortions = [ 0.0, 0.0, 0.0, 0.0]
+rotation = [ 1.2082126924727719, 1.2098328575850605, -1.2082126924727719]
+translation = [ -3.510103521992233, 1.7079310029359385, 10.0]
+fisheye = false
+
+[metadata]
+adjusted = false
+error = 0.0

Sports2D/Demo/Config_demo.toml

@@ -97,13 +97,13 @@ tracking_mode = 'sports2d' # 'sports2d' or 'deepsort'. 'deepsort' is slower, har
 keypoint_likelihood_threshold = 0.3 # Keypoints whose likelihood is lower will not be taken into account
 average_likelihood_threshold = 0.5  # Person will be ignored if average likelihood of good keypoints is lower than this value
 keypoint_number_threshold = 0.3     # Person will be ignored if the number of good keypoints (above keypoint_likelihood_threshold) is less than this fraction
-
+max_distance = 100  # in px or None # If a person is detected further than max_distance from its position on the previous frame, it will be considered as a new one
 
 [px_to_meters_conversion]
 # Pixel to meters conversion
 to_meters = true
 make_c3d = true
-save_calib = true # Coming soon!
+save_calib = false
 
 # If conversion from first_person_height
 floor_angle = 'auto'    # 'auto' or a value in degrees, eg 2.3. If 'auto', estimated from the line formed by the toes when they are on the ground (where speed = 0)
@@ -131,15 +131,16 @@ correct_segment_angles_with_floor_angle = true # If the camera is tilted, correc
 
 [post-processing]
 interpolate = true
-interp_gap_smaller_than = 10        # do not interpolate bigger gaps
+interp_gap_smaller_than = 10        # Do not interpolate larger 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.
+                        # 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
+min_chunk_size = 10     # Minimum number of valid frames in a row to keep a chunk of data for a person
+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
-save_graphs = false        # Save position and angle plots of raw and processed results
+save_graphs = true         # 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

@@ -152,6 +152,7 @@ DEFAULT_CONFIG =   {'base': {'video_input': ['demo.mp4'],
                                 'keypoint_likelihood_threshold': 0.3,
                                 'average_likelihood_threshold': 0.5,
                                 'keypoint_number_threshold': 0.3,
+                                'max_distance': 100,
                                 'CUSTOM': { 'name': 'Hip',
                                             'id': 19,
                                             'children': [{'name': 'RHip',
@@ -196,7 +197,7 @@ DEFAULT_CONFIG =   {'base': {'video_input': ['demo.mp4'],
                                 'calib_file': '',
                                 'floor_angle': 'auto',
                                 'xy_origin': ['auto'],
-                                'save_calib': True
+                                'save_calib': False
                                 },
                     'angles':   {'display_angle_values_on': ['body', 'list'],
                                 'fontSize': 0.3,
@@ -233,10 +234,11 @@ DEFAULT_CONFIG =   {'base': {'video_input': ['demo.mp4'],
                                         'interp_gap_smaller_than': 10,
                                         'fill_large_gaps_with': 'last_value',
                                         'sections_to_keep':'all',
+                                        'min_chunk_size': 10,
                                         'reject_outliers': True,
                                         'filter': True,
                                         'show_graphs': True,
-                                        'save_graphs': False,
+                                        'save_graphs': True,
                                         'filter_type': 'butterworth',
                                         'butterworth': {'order': 4, 'cut_off_frequency': 6.0},
                                         'kalman': {'trust_ratio': 500.0, 'smooth':True},
@@ -280,7 +282,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"],
+                'save_graphs': ["", "save position and angle plots of raw and processed results. true 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"],
@@ -315,6 +317,7 @@ CONFIG_HELP =   {'config': ["C", "path to a toml configuration file"],
                 'keypoint_likelihood_threshold': ["", "detected keypoints are not retained if likelihood is below this threshold. 0.3 if not specified"],
                 'average_likelihood_threshold': ["", "detected persons are not retained if average keypoint likelihood is below this threshold. 0.5 if not specified"],
                 'keypoint_number_threshold': ["", "detected persons are not retained if number of detected keypoints is below this threshold. 0.3 if not specified, i.e., i.e., 30 percent"],
+                'max_distance': ["", "If a person is detected further than max_distance from its position on the previous frame, it will be considered as a new one. in px or None, 100 by default."],
                 'fastest_frames_to_remove_percent': ["", "Frames with high speed are considered as outliers. Defaults to 0.1"],
                 'close_to_zero_speed_px': ["", "Sum for all keypoints: about 50 px/frame or 0.2 m/frame. Defaults to 50"],
                 'large_hip_knee_angles': ["", "Hip and knee angles below this value are considered as imprecise. Defaults to 45"],
@@ -326,6 +329,7 @@ CONFIG_HELP =   {'config': ["C", "path to a toml configuration file"],
                 '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"],
+                'min_chunk_size': ["", "Minimum number of valid frames in a row to keep a chunk of data for a person.  10 if not specified"],
                 '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"],
@@ -473,6 +477,14 @@ def set_nested_value(config, flat_key, value):
     d[keys[-1]] = value
 
 
+def merge_dicts(original, overrides):
+    for key, value in overrides.items():
+        if isinstance(value, dict) and isinstance(original.get(key), dict):
+            merge_dicts(original[key], value)
+        else:
+            original[key] = value
+            
+
 def str2bool(v):
     '''
     Convert a string to a boolean value.
@@ -500,7 +512,8 @@ def process(config='Config_demo.toml'):
     from Sports2D.process import process_fun
     
     if type(config) == dict:
-        config_dict = config
+        config_dict = DEFAULT_CONFIG.copy()
+        merge_dicts(config_dict, config)
     else:
         config_dict = read_config_file(config)
     video_dir, video_files, frame_rates, time_ranges, result_dir = base_params(config_dict)

Sports2D/Utilities/tests.py

@@ -45,7 +45,7 @@ def test_workflow():
     ## From Python             ##
     #############################
 
-    # Default
+    # Default from the demo config file
     config_path = Path(__file__).resolve().parent.parent / 'Demo' / 'Config_demo.toml'
     config_dict = toml.load(config_path)
     video_dir = Path(__file__).resolve().parent.parent / 'Demo'
@@ -53,6 +53,28 @@ def test_workflow():
     config_dict.get("base").update({"person_ordering_method": "highest_likelihood"})
     config_dict.get("base").update({"show_realtime_results":False})
     config_dict.get("post-processing").update({"show_graphs":False})
+    config_dict.get("post-processing").update({"save_graphs":False})
+    
+    Sports2D.process(config_dict)
+
+
+    # Only passing the updated values
+    video_dir = Path(__file__).resolve().parent.parent / 'Demo'
+    config_dict = {
+      'base': {
+        'nb_persons_to_detect': 1,
+        'person_ordering_method': 'greatest_displacement',
+        "show_realtime_results":False
+        },
+      'pose': {
+        'mode': 'lightweight', 
+        'det_frequency': 50
+        },
+      'post-processing': {
+        'show_graphs':False,
+        'save_graphs':False
+        }
+    }
     
     Sports2D.process(config_dict)
 
@@ -62,28 +84,28 @@ def test_workflow():
     #############################
 
     # Default
-    demo_cmd = ["sports2d", "--person_ordering_method", "highest_likelihood", "--show_realtime_results", "False", "--show_graphs", "False"]
+    demo_cmd = ["sports2d", "--person_ordering_method", "highest_likelihood", "--show_realtime_results", "False", "--show_graphs", "False", "--save_graphs", "False"]
     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",
+    demo_cmd2 = ["sports2d", "--show_realtime_results", "False", "--show_graphs", "False", "--save_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', 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", 
-                 "--to_meters", "False", 
+    demo_cmd3 = ["sports2d", "--show_realtime_results", "False", "--show_graphs", "False", "--save_graphs", "False",
+                #  "--calib_file", "calib_demo.toml", 
                  "--nb_persons_to_detect", "1", "--person_ordering_method", "greatest_displacement", 
                  "--mode", "lightweight", "--det_frequency", "50", 
                  "--slowmo_factor", "4",
-                 "--filter_type", "gaussian",
+                 "--filter_type", "gaussian", "--use_augmentation", "False",
                  "--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', 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",
+    demo_cmd4 = ["sports2d", "--person_ordering_method", "greatest_displacement", "--show_realtime_results", "False", "--show_graphs", "False", "--save_graphs", "False",
                  "--time_range", "1.2", "2.7",
                  "--do_ik", "True", "--use_augmentation", "True", 
                  "--nb_persons_to_detect", "all", "--first_person_height", "1.65",
@@ -97,7 +119,7 @@ def test_workflow():
     config_dict.get("base").update({"video_dir": str(video_dir)})
     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"]
+    demo_cmd5 = ["sports2d", "--config", str(config_path), "--show_realtime_results", "False", "--show_graphs", "False", "--save_graphs", "False",]
     subprocess.run(demo_cmd5, check=True, capture_output=True, text=True, encoding='utf-8', errors='replace')
 
 

Sports2D/process.py

@@ -87,12 +87,15 @@ from Pose2Sim.triangulation import indices_of_first_last_non_nan_chunks
 from Pose2Sim.personAssociation import *
 from Pose2Sim.filtering import *
 
+# Silence numpy "RuntimeWarning: Mean of empty slice"
+import warnings
+warnings.filterwarnings("ignore", category=RuntimeWarning, message="Mean of empty slice")
+
 # 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
 
@@ -798,6 +801,8 @@ def pose_plots(trc_data_unfiltered, trc_data, person_id, show=True):
     INPUTS:
     - trc_data_unfiltered: pd.DataFrame. The unfiltered trc data
     - trc_data: pd.DataFrame. The filtered trc data
+    - person_id: int. The ID of the person
+    - show: bool. Whether to show the plots
 
     OUTPUT:
     - matplotlib window with tabbed figures for each keypoint
@@ -806,7 +811,6 @@ def pose_plots(trc_data_unfiltered, trc_data, person_id, show=True):
     os_name = platform.system()
     if os_name == 'Windows':
         mpl.use('qt5agg') # windows
-
     mpl.rc('figure', max_open_warning=0)
 
     keypoints_names = trc_data.columns[1::3]
@@ -1142,6 +1146,8 @@ def select_persons_on_vid(video_file_path, frame_range, all_pose_coords):
 
         # Change color on hover
         for person_idx, bbox in enumerate(all_bboxes[frame_idx]):
+            if person_idx >= len(rects):  # Skip if rect doesn't exist
+                continue
             if ~np.isnan(bbox).any():
                 x_min, y_min, x_max, y_max = bbox.astype(int)
                 if x_min <= x <= x_max and y_min <= y <= y_max:
@@ -1269,7 +1275,7 @@ def select_persons_on_vid(video_file_path, frame_range, all_pose_coords):
     return selected_persons
 
 
-def compute_floor_line(trc_data, keypoint_names = ['LBigToe', 'RBigToe'], toe_speed_below = 7, tot_speed_above=2.0):
+def compute_floor_line(trc_data, score_data, keypoint_names = ['LBigToe', 'RBigToe'], toe_speed_below = 7, score_threshold=0.5):
     '''
     Compute the floor line equation, angle, and direction
     from the feet keypoints when they have zero speed.
@@ -1287,20 +1293,25 @@ def compute_floor_line(trc_data, keypoint_names = ['LBigToe', 'RBigToe'], toe_sp
     - gait_direction: float. Left if < 0, 'right' otherwise
     '''
 
-    # Remove frames where the person is mostly not moving (outlier)
-    speeds_kpts = np.array([np.insert(np.linalg.norm(trc_data[kpt].diff(), axis=1)[1:],0,0) 
-                        for kpt in trc_data.columns.unique()[1:]]).T
-    av_speeds = np.array([np.nanmean(speed_kpt) if not np.isnan(speed_kpt).all() else 0 for speed_kpt in speeds_kpts])
-    trc_data = trc_data[av_speeds>tot_speed_above]
-
     # Retrieve zero-speed coordinates for the foot
     low_speeds_X, low_speeds_Y = [], []
     gait_direction_val = []
     for kpt in keypoint_names:
-        speeds = np.linalg.norm(trc_data[kpt].diff(), axis=1)
+        # Remove frames without data
+        trc_data_kpt = trc_data[kpt].iloc[:,:2]
+        score_data_kpt = score_data[kpt]
+        start, end = indices_of_first_last_non_nan_chunks(score_data_kpt, chunk_choice_method='all')
+        trc_data_kpt_trim = trc_data_kpt.iloc[start:end].reset_index(drop=True)
+        score_data_kpt_trim = score_data_kpt.iloc[start:end].reset_index(drop=True)
+
+        # Compute speeds
+        speeds = np.linalg.norm(trc_data_kpt_trim.diff(), axis=1)
+
+        # Remove speeds with low confidence
+        speeds = np.where(score_data_kpt_trim>score_threshold, speeds, np.nan)
 
-        low_speed_frames = trc_data[speeds<toe_speed_below].index
-        low_speeds_coords = trc_data[kpt].loc[low_speed_frames]
+        # Get coordinates with low speeds, high
+        low_speeds_coords = trc_data_kpt_trim[speeds<toe_speed_below]
         low_speeds_coords = low_speeds_coords[low_speeds_coords!=0]
 
         low_speeds_X_kpt = low_speeds_coords.iloc[:,0].tolist()
@@ -1445,6 +1456,7 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
     mode = config_dict.get('pose').get('mode')
     det_frequency = config_dict.get('pose').get('det_frequency')
     tracking_mode = config_dict.get('pose').get('tracking_mode')
+    max_distance = config_dict.get('pose').get('max_distance', None)
     if tracking_mode == 'deepsort':
         deepsort_params = config_dict.get('pose').get('deepsort_params')
         try:
@@ -1492,7 +1504,7 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
     interp_gap_smaller_than = config_dict.get('post-processing').get('interp_gap_smaller_than')
     fill_large_gaps_with = config_dict.get('post-processing').get('fill_large_gaps_with')
     sections_to_keep = config_dict.get('post-processing').get('sections_to_keep')
-
+    min_chunk_size = config_dict.get('post-processing').get('min_chunk_size')
     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)
@@ -1514,7 +1526,8 @@ 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}_Sports2D'
+        video_file_stem = f'webcam_{current_date}'
+        output_dir_name = f'{video_file_stem}_Sports2D'
         video_file_path = result_dir / output_dir_name / f'webcam_{current_date}_raw.mp4'
     else:
         video_file_stem = video_file.stem
@@ -1623,6 +1636,7 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
         # Load pose file in px
         Q_coords, _, time_col, keypoints_names, _ = read_trc(load_trc_px)
         t0 = time_col[0]
+        tf = time_col.iloc[-1]
         keypoints_ids = [i for i in range(len(keypoints_names))]
         keypoints_all, scores_all = load_pose_file(Q_coords)
 
@@ -1640,6 +1654,7 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
         keypoints_ids = [node.id for _, _, node in RenderTree(pose_model) if node.id!=None]
         keypoints_names = [node.name for _, _, node in RenderTree(pose_model) if node.id!=None]
         t0 = 0
+        tf = (cap.get(cv2.CAP_PROP_FRAME_COUNT)-1) / fps if cap.get(cv2.CAP_PROP_FRAME_COUNT)>0 else float('inf')
 
         # Set up pose tracker
         try:
@@ -1652,14 +1667,12 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
             except:
                 logging.error('Error: Pose estimation failed. Check in Config.toml that pose_model and mode are valid.')
                 raise ValueError('Error: Pose estimation failed. Check in Config.toml that pose_model and mode are valid.')
-        
-        # 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'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}.')
+        
+        if tracking_mode == 'deepsort': 
+            logging.info(f'Deepsort parameters: {deepsort_params}.')
+        if tracking_mode not in ['deepsort', 'sports2d']:
+            logging.warning(f"Tracking mode {tracking_mode} is not implemented. 'sports2d' is recommended.")
         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}.')
         logging.info(f"{keypoint_likelihood_threshold=}, {average_likelihood_threshold=}, {keypoint_number_threshold=}")
 
@@ -1691,7 +1704,11 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
     frame_processing_times = []
     frame_count = 0
     first_frame = max(int(t0 * fps), frame_range[0])
-    # frames = []
+    last_frame = min(int(tf * fps), frame_range[1]-1)
+    if first_frame >= last_frame:
+        logging.error('Error: No frames to process. Check that your time_range is coherent with the video duration.')
+        raise ValueError('Error: No frames to process. Check that your time_range is coherent with the video duration.')
+    
     while cap.isOpened():
         # Skip to the starting frame
         if frame_count < first_frame:
@@ -1714,9 +1731,6 @@ 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())
 
             # Retrieve pose or Estimate pose and track people
             if load_trc_px: 
@@ -1732,22 +1746,57 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                 # Detect poses
                 keypoints, scores = pose_tracker(frame)
 
-                # Non maximum suppression (at pose level, not detection)
+                # Non maximum suppression (at pose level, not detection, and only using likely keypoints)
                 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]
-                
+                mask_scores = np.mean(scores, axis=1) > 0.2
+
+                likely_keypoints = np.where(mask_scores[:, np.newaxis, np.newaxis], keypoints, np.nan)
+                likely_scores = np.where(mask_scores[:, np.newaxis], scores, np.nan)
+                likely_bboxes = bbox_xyxy_compute(frame_shape, likely_keypoints, padding=0)
+                score_likely_bboxes = np.nanmean(likely_scores, axis=1)
+
+                valid_indices = np.where(~np.isnan(score_likely_bboxes))[0]
+                if len(valid_indices) > 0:
+                    valid_bboxes = likely_bboxes[valid_indices]
+                    valid_scores = score_likely_bboxes[valid_indices]
+                    keep_valid = nms(valid_bboxes, valid_scores, nms_thr=0.45)
+                    keep = valid_indices[keep_valid]
+                else:
+                    keep = []
+                keypoints, scores = likely_keypoints[keep], likely_scores[keep]
+
+                # # Debugging: display detected keypoints on the frame
+                # colors = [(255,0,0), (0,255,0), (0,0,255), (255,255,0), (255,0,255), (0,255,255), (128,0,0), (0,128,0), (0,0,128), (128,128,0), (128,0,128), (0,128,128)]
+                # bboxes = likely_bboxes[keep]
+                # for person_idx in range(len(keypoints)):
+                #     for kpt_idx, kpt in enumerate(keypoints[person_idx]):
+                #         if not np.isnan(kpt).any():
+                #             cv2.circle(frame, (int(kpt[0]), int(kpt[1])), 3, colors[person_idx%len(colors)], -1)
+                #     if not np.isnan(bboxes[person_idx]).any():
+                #         cv2.rectangle(frame, (int(bboxes[person_idx][0]), int(bboxes[person_idx][1])), (int(bboxes[person_idx][2]), int(bboxes[person_idx][3])), colors[person_idx%len(colors)], 1)
+                #     cv2.imshow(f'{video_file} Sports2D', frame)
+
                 # Track poses across frames
                 if tracking_mode == 'deepsort':
                     keypoints, scores = sort_people_deepsort(keypoints, scores, deepsort_tracker, frame, frame_count)
                 if tracking_mode == 'sports2d': 
                     if 'prev_keypoints' not in locals(): prev_keypoints = keypoints
-                    prev_keypoints, keypoints, scores = sort_people_sports2d(prev_keypoints, keypoints, scores=scores)
+                    prev_keypoints, keypoints, scores = sort_people_sports2d(prev_keypoints, keypoints, scores=scores, max_dist=max_distance)
                 else:
                     pass
-
+                
+                # # Debugging: display detected keypoints on the frame
+                # colors = [(255,0,0), (0,255,0), (0,0,255), (255,255,0), (255,0,255), (0,255,255), (128,0,0), (0,128,0), (0,0,128), (128,128,0), (128,0,128), (0,128,128)]
+                # for person_idx in range(len(keypoints)):
+                #     for kpt_idx, kpt in enumerate(keypoints[person_idx]):
+                #         if not np.isnan(kpt).any():
+                #             cv2.circle(frame, (int(kpt[0]), int(kpt[1])), 3, colors[person_idx%len(colors)], -1)
+                #         # if not np.isnan(bboxes[person_idx]).any():
+                #         #     cv2.rectangle(frame, (int(bboxes[person_idx][0]), int(bboxes[person_idx][1])), (int(bboxes[person_idx][2]), int(bboxes[person_idx][3])), colors[person_idx%len(colors)], 1)
+                #     cv2.imshow(f'{video_file} Sports2D', frame)
+                # # if (cv2.waitKey(1) & 0xFF) == ord('q') or (cv2.waitKey(1) & 0xFF) == 27:
+                # #     break
+                # # input()
             
             # Process coordinates and compute angles
             valid_X, valid_Y, valid_scores = [], [], []
@@ -1771,6 +1820,18 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                         person_Y = np.full_like(person_Y, np.nan)
                         person_scores = np.full_like(person_scores, np.nan)
 
+                    
+                    
+                    ## RECREATE KEYPOINTS, SCORES
+
+
+
+
+
+
+
+
+
                 # Check whether the person is looking to the left or right
                 if flip_left_right:
                     person_X_flipped = flip_left_right_direction(person_X, L_R_direction_idx, keypoints_names, keypoints_ids)
@@ -1915,16 +1976,38 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
     if save_pose:
         logging.info('\nPost-processing pose:')
         # Process pose for each person
-        trc_data, trc_data_unfiltered = [], []
+        trc_data, trc_data_unfiltered, score_data = [], [], []
+        first_run_starts_everyone, last_run_ends_everyone = [], []
         for i, idx_person in enumerate(selected_persons):
             pose_path_person = pose_output_path.parent / (pose_output_path.stem + f'_person{i:02d}.trc')
             all_frames_X_person = pd.DataFrame(all_frames_X_processed[:,idx_person,:], columns=new_keypoints_names)
             all_frames_Y_person = pd.DataFrame(all_frames_Y_processed[:,idx_person,:], columns=new_keypoints_names)
+            score_data.append(pd.DataFrame(all_frames_scores_processed[:,idx_person,:], columns=new_keypoints_names))
             if calculate_angles or save_angles:
                 all_frames_X_flipped_person = pd.DataFrame(all_frames_X_flipped_processed[:,idx_person,:], columns=new_keypoints_names)
-            # Delete person if less than 10 valid frames
-            pose_nan_count = len(np.where(all_frames_X_person.sum(axis=1)==0)[0])
-            if frame_count - frame_range[0] - pose_nan_count <= 10:
+
+            # Interpolate
+            if not interpolate:
+                logging.info(f'- Person {i}: No interpolation.')
+                all_frames_X_person_interp = all_frames_X_person
+                all_frames_Y_person_interp = all_frames_Y_person
+            else:
+                logging.info(f'- Person {i}: Interpolating missing sequences if they are smaller than {interp_gap_smaller_than} frames. Large gaps filled with {fill_large_gaps_with}.')
+                all_frames_X_person_interp = all_frames_X_person.apply(interpolate_zeros_nans, axis=0, args = [interp_gap_smaller_than, 'linear'])
+                all_frames_Y_person_interp = all_frames_Y_person.apply(interpolate_zeros_nans, axis=0, args = [interp_gap_smaller_than, 'linear'])
+
+            # Find the first and last valid chunks of data
+            first_run_starts, last_run_ends = [], []
+            for col in all_frames_X_person.columns:
+                first_run_start, last_run_end = indices_of_first_last_non_nan_chunks(all_frames_X_person_interp[col], min_chunk_size=min_chunk_size, chunk_choice_method=sections_to_keep)
+                first_run_starts += [first_run_start]
+                last_run_ends += [last_run_end]
+            first_run_start_min, last_run_end_max = min(first_run_starts), max(last_run_ends)
+            first_run_starts_everyone += [first_run_starts]
+            last_run_ends_everyone += [last_run_ends]
+
+            # Do not process person if no section of min_chunk_size valid frames in a row
+            if (first_run_start_min, last_run_end_max) == (0,0):
                 all_frames_X_processed[:,idx_person,:], all_frames_X_flipped_processed[:,idx_person,:], all_frames_Y_processed[:,idx_person,:] = np.nan, np.nan, np.nan
                 columns=np.array([[c]*3 for c in all_frames_X_person.columns]).flatten()
                 trc_data_i = pd.DataFrame(0, index=all_frames_X_person.index, columns=['time']+list(columns))
@@ -1932,105 +2015,92 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                 trc_data.append(trc_data_i)
                 trc_data_unfiltered_i = trc_data_i.copy()
                 trc_data_unfiltered.append(trc_data_unfiltered_i)
-                
-                logging.info(f'- Person {i}: Less than 10 valid frames. Deleting person.')
+                logging.info(f'  Person {i}: Less than {min_chunk_size} valid frames in a row. Deleting person.')
+                continue
 
+            # Fill remaining gaps
+            if fill_large_gaps_with.lower() == 'last_value':
+                for col_id, col in enumerate(all_frames_X_person_interp.columns):
+                    first_run_start, last_run_end = first_run_starts[col_id], last_run_ends[col_id]
+                    for coord_df in [all_frames_X_person_interp, all_frames_Y_person_interp, all_frames_Z_homog]:
+                        coord_df.loc[:first_run_start, col] = np.nan
+                        coord_df.loc[last_run_end:, col] = np.nan
+                        coord_df.loc[first_run_start:last_run_end, col] = coord_df.loc[first_run_start:last_run_end, col].ffill().bfill()
+            elif fill_large_gaps_with.lower() == 'zeros':
+                all_frames_X_person_interp.replace(np.nan, 0, inplace=True)
+                all_frames_Y_person_interp.replace(np.nan, 0, inplace=True)
+
+            # 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 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])
+
+            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:
-                # Interpolate
-                if not interpolate:
-                    logging.info(f'- Person {i}: No interpolation.')
-                    all_frames_X_person_interp = all_frames_X_person
-                    all_frames_Y_person_interp = all_frames_Y_person
+                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.'
+                            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.info(f'- Person {i}: Interpolating missing sequences if they are smaller than {interp_gap_smaller_than} frames. Large gaps filled with {fill_large_gaps_with}.')
-                    all_frames_X_person_interp = all_frames_X_person.apply(interpolate_zeros_nans, axis=0, args = [interp_gap_smaller_than, 'linear'])
-                    all_frames_Y_person_interp = all_frames_Y_person.apply(interpolate_zeros_nans, axis=0, args = [interp_gap_smaller_than, 'linear'])
-
-                    if fill_large_gaps_with.lower() == 'last_value':
-                        for col in all_frames_X_person_interp.columns:
-                            first_run_start, last_run_end = indices_of_first_last_non_nan_chunks(all_frames_Y_person_interp[col], min_chunk_size=interp_gap_smaller_than, chunk_choice_method=sections_to_keep)
-                            for coord_df in [all_frames_X_person_interp, all_frames_Y_person_interp, all_frames_Z_homog]:
-                                coord_df.loc[:first_run_start, col] = np.nan
-                                coord_df.loc[last_run_end:, col] = np.nan
-                                coord_df.loc[first_run_start:last_run_end, col] = coord_df.loc[first_run_start:last_run_end, col].ffill().bfill()
-
-                    elif fill_large_gaps_with.lower() == 'zeros':
-                        all_frames_X_person_interp.replace(np.nan, 0, inplace=True)
-                        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 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])
-
-                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:
-                    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.'
-                                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(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)
-                trc_data.append(trc_data_i)
-                if not load_trc_px:
-                    make_trc_with_trc_data(trc_data_i, str(pose_path_person), fps=fps)
-                    logging.info(f'Pose in pixels saved to {pose_path_person.resolve()}.')
-
-                # Plotting coordinates before and after interpolation and filtering
-                columns_to_concat = []
-                for kpt in range(len(all_frames_X_person.columns)):
-                    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 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
+                    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(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)
+            trc_data.append(trc_data_i)
+            if not load_trc_px:
+                make_trc_with_trc_data(trc_data_i, str(pose_path_person), fps=fps)
+                logging.info(f'Pose in pixels saved to {pose_path_person.resolve()}.')
+
+            # Plotting coordinates before and after interpolation and filtering
+            columns_to_concat = []
+            for kpt in range(len(all_frames_X_person.columns)):
+                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 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
                 
 
         #%% Convert px to meters
@@ -2054,11 +2124,11 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                     # estimated from the line formed by the toes when they are on the ground (where speed = 0)
                     try:
                         if all(key in trc_data[0] for key in ['LBigToe', 'RBigToe']):
-                            floor_angle_estim, xy_origin_estim, _ = compute_floor_line(trc_data[0], keypoint_names=['LBigToe', 'RBigToe'], toe_speed_below=toe_speed_below_px_frame)
+                            floor_angle_estim, xy_origin_estim, _ = compute_floor_line(trc_data[0], score_data[0], keypoint_names=['LBigToe', 'RBigToe'], toe_speed_below=toe_speed_below_px_frame, score_threshold=average_likelihood_threshold)
                         else:
-                            floor_angle_estim, xy_origin_estim, _ = compute_floor_line(trc_data[0], keypoint_names=['LAnkle', 'RAnkle'], toe_speed_below=toe_speed_below_px_frame)
-                            xy_origin_estim[0] = xy_origin_estim[0]-0.13
-                            logging.warning(f'The RBigToe and LBigToe are missing from your model. Using ankles - 13 cm to compute the floor line.')
+                            floor_angle_estim, xy_origin_estim, _ = compute_floor_line(trc_data[0], score_data[0], keypoint_names=['LAnkle', 'RAnkle'], toe_speed_below=toe_speed_below_px_frame, score_threshold=average_likelihood_threshold)
+                            xy_origin_estim[1] = xy_origin_estim[1] + 0.13*px_per_m # approx. height of the ankle above the floor
+                            logging.warning(f'The RBigToe and LBigToe are missing from your pose estimation model. Using ankles - 13 cm to compute the floor line.')
                     except:
                         floor_angle_estim = 0
                         xy_origin_estim = cam_width/2, cam_height/2
@@ -2069,7 +2139,7 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                     cx, cy = xy_origin_estim
                 else:
                     cx, cy = xy_origin
-                logging.info(f'Using height of person #0 ({first_person_height}m) to convert coordinates in meters. '
+                logging.info(f'Using height of person #0 ({first_person_height}m) to convert coordinates in meters.\n'
                              f'Floor angle: {np.degrees(floor_angle_estim) if not floor_angle=="auto" else f"auto (estimation: {round(np.degrees(floor_angle_estim),2)}°)"}, '
                              f'xy_origin: {xy_origin if not xy_origin=="auto" else f"auto (estimation: {[round(c) for c in xy_origin_estim]})"} px.')
 
@@ -2083,9 +2153,9 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                     if visible_side_i == 'auto':
                         try:
                             if all(key in trc_data[i] for key in ['LBigToe', 'RBigToe']):
-                                _, _, gait_direction = compute_floor_line(trc_data[i], keypoint_names=['LBigToe', 'RBigToe'], toe_speed_below=toe_speed_below_px_frame)
+                                _, _, gait_direction = compute_floor_line(trc_data[i], score_data[0], keypoint_names=['LBigToe', 'RBigToe'], toe_speed_below=toe_speed_below_px_frame, score_threshold=average_likelihood_threshold)
                             else:
-                                _, _, gait_direction = compute_floor_line(trc_data[i], keypoint_names=['LAnkle', 'RAnkle'], toe_speed_below=toe_speed_below_px_frame)
+                                _, _, gait_direction = compute_floor_line(trc_data[i], score_data[0], keypoint_names=['LAnkle', 'RAnkle'], toe_speed_below=toe_speed_below_px_frame, score_threshold=average_likelihood_threshold)
                                 logging.warning(f'The RBigToe and LBigToe are missing from your model. Gait direction will be determined from the ankle points.')
                             visible_side_i = 'right' if gait_direction > 0.3 \
                                                 else 'left' if gait_direction < -0.3 \
@@ -2103,8 +2173,8 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                     # Convert to meters
                     px_to_m_i = [convert_px_to_meters(trc_data[i][kpt_name], first_person_height, height_px, cx, cy, -floor_angle_estim, visible_side=visible_side_i) for kpt_name in new_keypoints_names]
                     trc_data_m_i = pd.concat([all_frames_time.rename('time')]+px_to_m_i, axis=1)
-                    for c in 3*np.arange(len(trc_data_m_i.columns[3::3]))+1: # only X coordinates
-                        first_run_start, last_run_end = indices_of_first_last_non_nan_chunks(trc_data_m_i.iloc[:,c], min_chunk_size=interp_gap_smaller_than, chunk_choice_method=sections_to_keep)
+                    for c_id, c in enumerate(3*np.arange(len(trc_data_m_i.columns[3::3]))+1): # only X coordinates
+                        first_run_start, last_run_end = first_run_starts_everyone[i][c_id], last_run_ends_everyone[i][c_id]
                         trc_data_m_i.iloc[:first_run_start,c+2] = np.nan
                         trc_data_m_i.iloc[last_run_end:,c+2] = np.nan
                         trc_data_m_i.iloc[first_run_start:last_run_end,c+2] = trc_data_m_i.iloc[first_run_start:last_run_end,c+2].ffill().bfill()
@@ -2205,86 +2275,95 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
             if new_visible_side[i] == 'left' and not flip_left_right: 
                 all_frames_angles_homog[:, idx_person, :] = -all_frames_angles_homog[:, idx_person, :]
 
-            # Delete person if less than 4 valid frames
-            angle_nan_count = len(np.where(all_frames_angles_person.sum(axis=1)==0)[0])
-            if frame_count - frame_range[0] - angle_nan_count <= 4:
-                all_frames_angles_processed[:,idx_person,:] = np.nan
-                logging.info(f'- Person {i}: Less than 4 valid frames. Deleting person.')
-
+            if not interpolate:
+                logging.info(f'- Person {i}: No interpolation.')
+                all_frames_angles_person_interp = all_frames_angles_person
             else:
-                # Interpolate
-                if not interpolate:
-                    logging.info(f'- Person {i}: No interpolation.')
-                    all_frames_angles_person_interp = all_frames_angles_person
-                else:
-                    logging.info(f'- Person {i}: Interpolating missing sequences if they are smaller than {interp_gap_smaller_than} frames. Large gaps filled with {fill_large_gaps_with}.')
-                    all_frames_angles_person_interp = all_frames_angles_person.apply(interpolate_zeros_nans, axis=0, args = [interp_gap_smaller_than, 'linear'])
-                    if fill_large_gaps_with == 'last_value':
-                        for col in all_frames_angles_person_interp.columns:
-                            first_run_start, last_run_end = indices_of_first_last_non_nan_chunks(all_frames_angles_person_interp[col], min_chunk_size=interp_gap_smaller_than, chunk_choice_method=sections_to_keep)
-                            all_frames_angles_person_interp.loc[:first_run_start, col] = np.nan
-                            all_frames_angles_person_interp.loc[last_run_end:, col] = np.nan
-                            all_frames_angles_person_interp.loc[first_run_start:last_run_end, col] = all_frames_angles_person_interp.loc[first_run_start:last_run_end, col].ffill().bfill()
-                    elif fill_large_gaps_with == 'zeros':
-                        all_frames_angles_person_interp.replace(np.nan, 0, inplace=True)
+                logging.info(f'- Person {i}: Interpolating missing sequences if they are smaller than {interp_gap_smaller_than} frames. Large gaps filled with {fill_large_gaps_with}.')
+                all_frames_angles_person_interp = all_frames_angles_person.apply(interpolate_zeros_nans, axis=0, args = [interp_gap_smaller_than, 'linear'])
+
+            # Find the first and last valid chunks of data
+            first_run_starts, last_run_ends = [], []
+            for col in all_frames_angles_person.columns:
+                first_run_start, last_run_end = indices_of_first_last_non_nan_chunks(all_frames_angles_person_interp[col], min_chunk_size=min_chunk_size, chunk_choice_method=sections_to_keep)
+                first_run_starts += [first_run_start]
+                last_run_ends += [last_run_end]
+            first_run_start_min, last_run_end_max = min(first_run_starts), max(last_run_ends)
+
+            # Do not process person if no section of min_chunk_size valid frames in a row
+            if (first_run_start_min, last_run_end_max) == (0,0):
+                all_frames_angles_processed[:,idx_person,:]= np.nan
+                logging.info(f'  Person {i}: Less than {min_chunk_size} valid frames in a row. Deleting person.')
+                continue
+
+            # Fill remaining gaps
+            if fill_large_gaps_with == 'last_value':
+                for col_id, col in enumerate(all_frames_angles_person_interp.columns):
+                    first_run_start, last_run_end = first_run_starts[col_id], last_run_ends[col_id]
+                    all_frames_angles_person_interp.loc[:first_run_start, col] = np.nan
+                    all_frames_angles_person_interp.loc[last_run_end:, col] = np.nan
+                    all_frames_angles_person_interp.loc[first_run_start:last_run_end, col] = all_frames_angles_person_interp.loc[first_run_start:last_run_end, col].ffill().bfill()
+            elif fill_large_gaps_with == 'zeros':
+                all_frames_angles_person_interp.replace(np.nan, 0, inplace=True)
                 
-                # Filter
-                if reject_outliers:
-                    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:
-                    logging.info(f'No filtering.')
-                    all_frames_angles_person_filt = all_frames_angles_person_interp
+            # Filter
+            if reject_outliers:
+                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:
+                logging.info(f'No filtering.')
+                all_frames_angles_person_filt = all_frames_angles_person_interp
+            else:
+                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.'
+                            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:
-                    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.'
-                                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:
-                    logging.info(f'Correcting segment angles by removing the {round(np.degrees(floor_angle_estim),2)}° floor angle.')
-                    for ang_name in all_frames_angles_person_filt.columns:
-                        if 'horizontal' in angle_dict[ang_name][1]:
-                            all_frames_angles_person_filt[ang_name] -= np.degrees(floor_angle_estim)
-
-                # Remove columns with all nan values
-                all_frames_angles_processed[:,idx_person,:] = all_frames_angles_person_filt
-                all_frames_angles_person_filt.dropna(axis=1, how='all', inplace=True)
-                all_frames_angles_person = all_frames_angles_person[all_frames_angles_person_filt.columns]
-
-                # Build mot file
-                angle_data = make_mot_with_angles(all_frames_angles_person_filt, all_frames_time, str(angles_path_person))
-                logging.info(f'Angles saved to {angles_path_person.resolve()}.')
-
-                # Plotting angles before and after interpolation and filtering
-                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
+                    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:
+                logging.info(f'Correcting segment angles by removing the {round(np.degrees(floor_angle_estim),2)}° floor angle.')
+                for ang_name in all_frames_angles_person_filt.columns:
+                    if 'horizontal' in angle_dict[ang_name][1]:
+                        all_frames_angles_person_filt[ang_name] -= np.degrees(floor_angle_estim)
+
+            # Remove columns with all nan values
+            all_frames_angles_processed[:,idx_person,:] = all_frames_angles_person_filt
+            all_frames_angles_person_filt.dropna(axis=1, how='all', inplace=True)
+            all_frames_angles_person = all_frames_angles_person[all_frames_angles_person_filt.columns]
+
+            # Build mot file
+            angle_data = make_mot_with_angles(all_frames_angles_person_filt, all_frames_time, str(angles_path_person))
+            logging.info(f'Angles saved to {angles_path_person.resolve()}.')
+
+            # Plotting angles before and after interpolation and filtering
+            all_frames_angles_person.insert(0, 'time', all_frames_time)
+            if show_plots or save_plots:
+                pw = angle_plots(all_frames_angles_person, angle_data, i, show=show_plots) # i = current person
+                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)
@@ -2392,25 +2471,17 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                 # Delete person if less than 4 valid frames
                 pose_path_person = pose_output_path.parent / (pose_output_path.stem + f'_person{i:02d}.trc')
                 all_frames_X_person = pd.DataFrame(all_frames_X_homog[:,i,:], columns=new_keypoints_names)
-                pose_nan_count = len(np.where(all_frames_X_person.sum(axis=1)==0)[0])
-                if frame_count - frame_range[0] - pose_nan_count <= 4:
-                    # heights_m.append(DEFAULT_HEIGHT)
-                    # masses.append(DEFAULT_MASS)
-                    logging.info(f'Less than 4 valid frames. Deleting person.')
+                if new_visible_side[i] == 'none':
+                    logging.info(f'Skipping marker augmentation and inverse kinematics because visible_side is "none".')
                 else:
-                    if new_visible_side[i] == 'none':
-                        logging.info(f'Skipping marker augmentation and inverse kinematics because visible_side is "none".')
-                        # heights_m.append(DEFAULT_HEIGHT)
-                        # masses.append(DEFAULT_MASS)
-                    else:
-                        # Provide missing data to Pose2Sim_config_dict
-                        height_m_i = compute_height(trc_data_m_i.iloc[:,1:], keypoints_names,
-                            fastest_frames_to_remove_percent=fastest_frames_to_remove_percent, close_to_zero_speed=close_to_zero_speed_m, large_hip_knee_angles=large_hip_knee_angles, trimmed_extrema_percent=trimmed_extrema_percent)
-                        mass_i = participant_masses[i] if len(participant_masses)>i else 70
-                        if len(participant_masses)<=i:
-                            logging.warning(f'No mass provided. Using 70 kg as default.')
-                        heights_m.append(height_m_i)
-                        masses.append(mass_i)
+                    # Provide missing data to Pose2Sim_config_dict
+                    height_m_i = compute_height(trc_data_m_i.iloc[:,1:], keypoints_names,
+                        fastest_frames_to_remove_percent=fastest_frames_to_remove_percent, close_to_zero_speed=close_to_zero_speed_m, large_hip_knee_angles=large_hip_knee_angles, trimmed_extrema_percent=trimmed_extrema_percent)
+                    mass_i = participant_masses[i] if len(participant_masses)>i else DEFAULT_MASS
+                    if len(participant_masses)<=i:
+                        logging.warning(f'No mass provided. Using {DEFAULT_MASS} kg as default.')
+                    heights_m.append(height_m_i)
+                    masses.append(mass_i)
                 
             Pose2Sim_config_dict['project']['participant_height'] = heights_m
             Pose2Sim_config_dict['project']['participant_mass'] = masses

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sports2d
-Version: 0.8.20
+Version: 0.8.22
 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<4.12
 Requires-Dist: imageio_ffmpeg
 Requires-Dist: deep-sort-realtime
-Requires-Dist: Pose2Sim>=0.10.36
+Requires-Dist: Pose2Sim>=0.10.38
 Dynamic: license-file
 
 
@@ -67,6 +67,7 @@ Dynamic: license-file
 </br>
 
 > **`Announcements:`**
+> - Generate or import a calibration file, OpenSim skeleton overlay **New in v0.9!** 
 > - Select only the persons you want to analyze **New in v0.8!** 
 > - MarkerAugmentation and Inverse Kinematics for accurate 3D motion with OpenSim. **New in v0.7!** 
 > - Any detector and pose estimation model can be used. **New in v0.6!**
@@ -218,16 +219,19 @@ The Demo video is voluntarily challenging to demonstrate the robustness of the p
 
 1. **Install the Pose2Sim_Blender add-on.**\
    Follow instructions on the [Pose2Sim_Blender](https://github.com/davidpagnon/Pose2Sim_Blender) add-on page.
+2. **Import the camera and video.**
+    - **Cameras -> Import**: Open your `demo_calib.toml` file from your `result_dir` folder.
+    - **Images/Videos -> Show**: open your video file (e.g., `demo_Sports2D.mp4`).\
+    -> **Other tools -> See through camera**
 2. **Open your point coordinates.**\
-   **Add Markers**: open your trc file(e.g., `coords_m.trc`) from your `result_dir` folder.
-   
+   **OpenSim data -> Markers**: Open your trc file(e.g., `demo_Sports2D_m_person00.trc`) from your `result_dir` folder.\
    This will optionally create **an animated rig** based on the motion of the captured person.
 3. **Open your animated skeleton:**\
    Make sure you first set `--do_ik True` ([full install](#full-install) required). See [inverse kinematics](#run-inverse-kinematics) section for more details.
-   - **Add Model**: Open your scaled model (e.g., `Model_Pose2Sim_LSTM.osim`). 
-   - **Add Motion**: Open your motion file (e.g., `angles.mot`). Make sure the skeleton is selected in the outliner.
+   - **OpenSim data -> Model**: Open your scaled model (e.g., `demo_Sports2D_m_person00_LSTM.osim`). 
+   - **OpenSim data -> Motion**: Open your motion file (e.g., `demo_Sports2D_m_person00_LSTM_ik.mot`). 
 
-   The OpenSim skeleton is not rigged yet. **[Feel free to contribute!](https://github.com/perfanalytics/pose2sim/issues/40)**
+   The OpenSim skeleton is not rigged yet. **[Feel free to contribute!](https://github.com/perfanalytics/pose2sim/issues/40)** [![Discord](https://img.shields.io/discord/1183750225471492206?logo=Discord&label=Discord%20community)](https://discord.com/invite/4mXUdSFjmt)
 
 <img src="Content/sports2d_blender.gif" width="760">
 
@@ -284,7 +288,7 @@ If you only want to analyze a subset of the detected persons, you can use the `-
 sports2d --nb_persons_to_detect 2 --person_ordering_method highest_likelihood
 ```
 
-We recommend to use the `on_click` method if you can afford a manual input. This lets the user handle both the person number and their order in the same stage. When prompted, select the persons you are interested in in the desired order. In our case, lets slide to a frame where both people are visible, and select the woman first, then the man.
+We recommend using the `on_click` method if you can afford a manual input. This lets the user handle both the person number and their order in the same stage. When prompted, select the persons you are interested in in the desired order. In our case, lets slide to a frame where both people are visible, and select the woman first, then the man.
 
 Otherwise, if you want to run Sports2D automatically for example, you can choose other ordering methods such as 'highest_likelihood', 'largest_size', 'smallest_size',  'greatest_displacement', 'least_displacement', 'first_detected', or 'last_detected'.
 
@@ -301,28 +305,32 @@ sports2d --person_ordering_method on_click
 
 
 #### Get coordinates in meters: 
-> **N.B.:** Depth is estimated from a neutral pose. 
+> **N.B.:** The Z coordinate (depth) should not be overly trusted. 
 
-<!-- You either need to provide a calibration file, or simply the height of a person (Note that the latter will not take distortions into account, and that it will be less accurate for motion in the frontal plane).\-->
-You may need to convert pixel coordinates to meters.\
-Just provide the height of the reference person (and their ID in case of multiple person detection).
+You may want coordinates in meters rather than pixels. 2 options to do so:
 
-You can also specify whether the visible side of the person is left, right, front, or back. Set it to 'auto' if you do not want to find it automatically (only works for motion in the sagittal plane), or to 'none' if you want to keep 2D instead of 3D coordinates (if the person goes right, and then left for example).
+1. **Just provide the height of a reference person**:
+   - Their height in meters is be compared with their height in pixels to get a pixel-to-meter conversion factor.
+   - To estimate the depth coordinates, specify which side of the person is visible: `left`, `right`, `front`, or `back`. Use `auto` if you want it to be automatically determined (only works for motions in the sagittal plane), or `none` if you want to keep 2D coordinates instead of 3D (if the person turns around, for example).
+   - The floor angle is automatically estimated from gait, as well as the origin of the xy axis. The person trajectory is corrected accordingly. You can use the `--floor_angle` and `--xy_origin` parameters to manually specify them if your subject is not travelling horizontally or if you want the origin not to be under their feet (note that the `y` axis points down).
+   
+   **N.B.: A calibration file will be generated.** By convention, the camera-to-subject distance is set to 10 meters.
 
-The floor angle and the origin of the xy axis are computed automatically from gait. If you analyze another type of motion, you can manually specify them. Note that `y` points down.\
-Also note that distortions are not taken into account, and that results will be less accurate for motions in the frontal plane.
+   ``` cmd
+   sports2d --first_person_height 1.65 --visible_side auto front none
+   ```
+   ``` cmd
+   sports2d --first_person_height 1.65 --visible_side auto front none `
+            --person_ordering_method on_click `
+            --floor_angle 0 --xy_origin 0 940
+   ```
 
-<!-- ``` cmd
-sports2d --to_meters True --calib_file calib_demo.toml
-``` -->
-``` cmd
-sports2d --to_meters True --first_person_height 1.65 --visible_side auto front none
-```
-``` cmd
-sports2d --to_meters True --first_person_height 1.65 --visible_side auto front none `
-         --person_ordering_method on_click `
-         --floor_angle 0 --xy_origin 0 940
-```
+2. **Or use a calibration file**:\
+  It can either be a `.toml` calibration file previously generated by Sports2D, or a more accurate one coming from another system. For example, [Pose2Sim](https://github.com/perfanalytics/pose2sim) can be used to accurately calculate calibration, or to convert calibration files from Qualisys, Vicon, OpenCap, FreeMoCap, etc.
+
+   ``` cmd
+   sports2d --calib_file Calib_demo.toml --visible_side auto front none
+   ```
 
 <br>
 
@@ -337,18 +345,22 @@ OpenSim inverse kinematics allows you to set joint constraints, joint angle limi
 This is done via [Pose2Sim](https://github.com/perfanalytics/pose2sim).\
 Model scaling is done according to the mean of the segment lengths, across a subset of frames. We remove the 10% fastest frames (potential outliers), the frames where the speed is 0 (person probably out of frame), the frames where the average knee and hip flexion angles are above 45° (pose estimation is not precise when the person is crouching) and the 20% most extreme segment values after the previous operations (potential outliers). All these parameters can be edited in your Config.toml file.
 
+**N.B.: This will not work on sections where the person is not moving in a single plane. You can split your video into several time ranges if needed.**
+
 ```cmd
 sports2d --time_range 1.2 2.7 `
          --do_ik true --first_person_height 1.65 --visible_side auto front
 ```
 
 You can optionally use the LSTM marker augmentation to improve the quality of the output motion.\
-You can also optionally give the participants proper masses. Mass has no influence on motion, only on forces (if you decide to further pursue kinetics analysis).
+You can also optionally give the participants proper masses. Mass has no influence on motion, only on forces (if you decide to further pursue kinetics analysis).\
+Optionally again, you can [visualize the overlaid results in Blender](#visualize-in-blender). The automatic calibration won't be accurate with such a small time range, so you need to use the provided calibration file (or one that has been generated from the full walk).
 
 ```cmd
 sports2d --time_range 1.2 2.7 `
          --do_ik true --first_person_height 1.65 --visible_side left front `
-         --use_augmentation True --participant_mass 55.0 67.0
+         --use_augmentation True --participant_mass 55.0 67.0 `
+         --calib_file Calib_demo.toml
 ```
 
 <br>
@@ -376,14 +388,31 @@ sports2d --video_input demo.mp4 other_video.mp4 --time_range 1.2 2.7 0 3.5
   ``` cmd
   sports2d --config Config_demo.toml
   ```
-- Run within Python: 
-  ``` python
-  from Sports2D import Sports2D; Sports2D.process('Config_demo.toml')
-  ```
-- Run within Python with a dictionary (for example, `config_dict = toml.load('Config_demo.toml')`):
-  ``` python
-  from Sports2D import Sports2D; Sports2D.process(config_dict)
-  ```
+- Run within Python, for example:\
+  - Edit `Demo/Config_demo.toml` and run:
+    ```python
+    from Sports2D import Sports2D
+    from pathlib import Path
+    import toml
+
+    config_path = Path(Sports2D.__file__).parent / 'Demo'/'Config_demo.toml'
+    config_dict = toml.load(config_path)
+    Sports2D.process(config_dict)
+    ```
+  - Or you can pass the non default values only: 
+    ```python
+    from Sports2D import Sports2D
+    config_dict = {
+      'base': {
+        'nb_persons_to_detect': 1,
+        'person_ordering_method': 'greatest_displacement'
+        },
+      'pose': {
+        'mode': 'lightweight', 
+        'det_frequency': 50
+        }}
+    Sports2D.process(config_dict)
+    ```
 
 <br>
 
@@ -407,7 +436,7 @@ sports2d --video_input demo.mp4 other_video.mp4 --time_range 1.2 2.7 0 3.5
   ```cmd
   sports2d --flip_left_right true # Default
   ```
-- Correct segment angles according to the estimated camera tild angle.\
+- Correct segment angles according to the estimated camera tilt angle.\
   **N.B.:** *The camera tilt angle is automatically estimated. Set to false if it is actually the floor which is tilted rather than the camera.*
   ```cmd
   sports2d --correct_segment_angles_with_floor_angle true # Default
@@ -477,6 +506,7 @@ sports2d --help
 '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"],

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

@@ -9,17 +9,18 @@ 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=aCx3Hy1XltgBS7kuQ52b653hQtL_9sjvpQ0xGoPuoOw,35572
+Sports2D/Sports2D.py,sha256=mV46Gh6I5OSjkFkfoQl5K2-RQIT4M-cAwWEQl7TSsXA,36346
 Sports2D/__init__.py,sha256=BuUkPEdItxlkeqz4dmoiPwZLkgAfABJK3KWQ1ujTGwE,153
-Sports2D/process.py,sha256=VrN8ZQimznjPAk_-1r9NpZnBCzDz9z0lV-E4wNJMCq0,125549
-Sports2D/Demo/Config_demo.toml,sha256=GXlj4tuGvnEpzQm0FFOS2BWVHcGSHGxuudAAHhzsTQc,15665
+Sports2D/process.py,sha256=aIqyGOa1AZUOkiuq0IiHDVM6DYQMBECgHHZycSFudr0,129389
+Sports2D/Demo/Calib_demo.toml,sha256=d6myoOkhhz3c5LOwCEJQBWT9eyqr6RSYoaPbFjBMizc,369
+Sports2D/Demo/Config_demo.toml,sha256=fq9j-KKAm6rnVGkA38PydBu2ZyZfihx0LBp5QM1U-e8,15913
 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=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,,
+Sports2D/Utilities/tests.py,sha256=BcZ02nVcX04PpTQ2t0g5dPGHbAXY_028Y2lxn_3udjQ,5570
+sports2d-0.8.22.dist-info/licenses/LICENSE,sha256=f4qe3nE0Y7ltJho5w-xAR0jI5PUox5Xl-MsYiY7ZRM8,1521
+sports2d-0.8.22.dist-info/METADATA,sha256=xdNcXme_pKvpQ8FTbMgeGhPw4wi-i2KHTUv6G1LRPgg,43216
+sports2d-0.8.22.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sports2d-0.8.22.dist-info/entry_points.txt,sha256=V8dFDIXatz9VvoGgoHzb2wE71C9-f85K6_OjnEQlxww,108
+sports2d-0.8.22.dist-info/top_level.txt,sha256=cWWBiDD2WbQXMoIoN6-9et9U2t2c_ZKo2JtBqO5uN-k,17
+sports2d-0.8.22.dist-info/RECORD,,