sports2d 0.8.21__tar.gz → 0.8.23__tar.gz

{sports2d-0.8.21 → sports2d-0.8.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sports2d
-Version: 0.8.21
+Version: 0.8.23
 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
 
 

{sports2d-0.8.21 → sports2d-0.8.23}/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 = false
+save_calib = true
 
 # 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)
@@ -111,7 +111,9 @@ xy_origin = ['auto']    # ['auto'] or [px_x,px_y]. N.B.: px_y points downwards.
 
 # If conversion from a calibration file
 calib_file = ''         # Calibration in the Pose2Sim format. 'calib_demo.toml', or '' if not available
-
+# subject_distance
+# focal_distance
+# recalculate_extrinsics
 
 [angles]
 display_angle_values_on = ['body', 'list'] # 'body', 'list', ['body', 'list'], 'none'. Display angle values on the body, as a list in the upper left of the image, both, or do not display them.
@@ -131,11 +133,12 @@ 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

{sports2d-0.8.21 → sports2d-0.8.23}/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': False
+                                'save_calib': True
                                 },
                     'angles':   {'display_angle_values_on': ['body', 'list'],
                                 'fontSize': 0.3,
@@ -233,6 +234,7 @@ 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,
@@ -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"],

{sports2d-0.8.21 → sports2d-0.8.23}/Sports2D/process.py

@@ -78,21 +78,24 @@ from matplotlib import patheffects
 
 from rtmlib import PoseTracker, BodyWithFeet, Wholebody, Body, Hand, Custom
 from rtmlib.tools.object_detection.post_processings import nms
-from deep_sort_realtime.deepsort_tracker import DeepSort
 
 from Sports2D.Utilities.common import *
 from Pose2Sim.common import *
 from Pose2Sim.skeletons import *
+from Pose2Sim.calibration import toml_write
 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)
 
-        low_speed_frames = trc_data[speeds<toe_speed_below].index
-        low_speeds_coords = trc_data[kpt].loc[low_speed_frames]
+        # Remove speeds with low confidence
+        speeds = np.where(score_data_kpt_trim>score_threshold, speeds, np.nan)
+
+        # 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,7 +1456,9 @@ 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':
+        from deep_sort_realtime.deepsort_tracker import DeepSort
         deepsort_params = config_dict.get('pose').get('deepsort_params')
         try:
             deepsort_params = ast.literal_eval(deepsort_params)
@@ -1464,8 +1477,12 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
     save_calib = config_dict.get('px_to_meters_conversion').get('save_calib')
     # Calibration from file
     calib_file = config_dict.get('px_to_meters_conversion').get('calib_file')
-    if calib_file == '': calib_file = None
-    else: calib_file = Path(calib_file).resolve()
+    if calib_file == '': 
+        calib_file = None
+    else: 
+        calib_file = video_dir / calib_file
+        if not calib_file.is_file():
+            raise FileNotFoundError(f'Error: Could not find calibration file {calib_file}. Check that the file exists.')
     # Calibration from person height
     floor_angle = config_dict.get('px_to_meters_conversion').get('floor_angle') # 'auto' or float
     floor_angle = np.radians(float(floor_angle)) if floor_angle != 'auto' else floor_angle
@@ -1492,7 +1509,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 +1531,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 +1641,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 +1659,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 +1672,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 +1709,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 +1736,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 +1751,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 +1825,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 +1981,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,121 +2020,139 @@ 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
         trc_data_m = []
         if to_meters and save_pose:
             logging.info('\nConverting pose to meters:')
+
+            # Compute height in px of the first person
+            height_px = compute_height(trc_data[0].iloc[:,1:], new_keypoints_names,
+                                        fastest_frames_to_remove_percent=fastest_frames_to_remove_percent, close_to_zero_speed=close_to_zero_speed_px, large_hip_knee_angles=large_hip_knee_angles, trimmed_extrema_percent=trimmed_extrema_percent)
+
+            if calib_file or save_calib:
+                dist_to_cam = 10.0 # arbitrary distance between the camera and the person (m)
+                R90z = np.array([[0.0, -1.0, 0.0],
+                                [1.0, 0.0, 0.0],
+                                [0.0, 0.0, 1.0]])
+                R270x = np.array([[1.0, 0.0, 0.0],
+                                [0.0, 0.0, 1.0],
+                                [0.0, -1.0, 0.0]])
+
+            # Compute px to meter parameters from calibration file
             if calib_file:
-                logging.info(f'Using calibration file to convert coordinates in meters: {calib_file}.')
                 calib_params_dict = retrieve_calib_params(calib_file)
-                # TODO
 
-            else:
-                # Compute calibration parameters
-                height_px = compute_height(trc_data[0].iloc[:,1:], new_keypoints_names,
-                                            fastest_frames_to_remove_percent=fastest_frames_to_remove_percent, close_to_zero_speed=close_to_zero_speed_px, large_hip_knee_angles=large_hip_knee_angles, trimmed_extrema_percent=trimmed_extrema_percent)
+                f = calib_params_dict['K'][0][0][0]
+                first_person_height = height_px / f * dist_to_cam
 
+                R_cam = cv2.Rodrigues(calib_params_dict['R'][0])[0]
+                T_cam = np.array(calib_params_dict['T'][0])
+                R_world, T_world = world_to_camera_persp(R_cam, T_cam)
+                Rfloory = R90z.T @ R_world @ R270x.T
+                T_world = R90z.T @ T_world
+                floor_angle_estim = np.arctan2(Rfloory[0,2], Rfloory[0,0])
+                
+                cu = calib_params_dict['K'][0][0][2]
+                cv = calib_params_dict['K'][0][1][2]
+                cx = 0.0
+                cy = cv + T_world[2]*f/dist_to_cam
+                xy_origin_estim = [cx, cy]
+
+                logging.info(f'Using calibration file to convert coordinates in meters: {calib_file}.\n'
+                             f'Floor angle: {np.degrees(floor_angle_estim):.2f}°, '
+                             f'xy_origin: [{cx:.2f}, {cy:.2f}] px.')
+
+                
+            # Compute px to meter parameters from scene
+            else:
                 toe_speed_below = 1 # m/s (below which the foot is considered to be stationary)
                 px_per_m = height_px/first_person_height
                 toe_speed_below_px_frame = toe_speed_below * px_per_m / fps
@@ -2054,11 +2160,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,9 +2175,40 @@ 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.')
+                
+                # Save calibration file
+                if save_calib:
+                    calib_file_path = output_dir / f'{video_file_stem}_Sports2D_calib.toml'
+                    
+                    # name, size, distortions
+                    N = [video_file_stem]
+                    S = [[cam_width, cam_height]]
+                    D = [[0.0, 0.0, 0.0, 0.0]]
+
+                    # Intrinsics
+                    f = height_px / first_person_height * dist_to_cam
+                    cu = cam_width/2
+                    cv = cam_height/2
+                    K = np.array([[[f, 0.0, cu], [0.0, f, cv], [0.0, 0.0, 1.0]]])
+
+                    # Extrinsics
+                    Rfloory = np.array([[np.cos(floor_angle_estim), 0.0, np.sin(floor_angle_estim)],
+                                        [0.0, 1.0, 0.0],
+                                        [-np.sin(floor_angle_estim), 0.0, np.cos(floor_angle_estim)]])
+                    R_world = R90z @ Rfloory @ R270x
+                    T_world = R90z @ np.array([-(cx-cu)/f*dist_to_cam, -dist_to_cam, (cy-cv)/f*dist_to_cam])
+                    
+                    R_cam, T_cam = world_to_camera_persp(R_world, T_world)
+                    Tvec_cam = T_cam.reshape(1,3).tolist()
+                    Rvec_cam = cv2.Rodrigues(R_cam)[0].reshape(1,3).tolist()
+
+                    # Write calibration file
+                    toml_write(calib_file_path, N, S, D, K, Rvec_cam, Tvec_cam)
+                    logging.info(f'Calibration saved to {calib_file_path}.')
+
 
             # Coordinates in m
             new_visible_side = []
@@ -2083,9 +2220,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 +2240,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()
@@ -2136,48 +2273,6 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                 new_visible_side += [visible_side_i]
         else:
             new_visible_side = visible_side.copy()
-                
-            
-
-
-
-
-                # # plt.plot(trc_data_m.iloc[:,0], trc_data_m.iloc[:,1])
-                # # plt.ylim([0,2])
-                # # plt.show()
-
-
-
-                # z = 3.0 # distance between the camera and the person. Required in the calibration file but simplified in the equations
-                # f = height_px / first_person_height * z
-
-
-                # # Name
-                # N = [video_file]
-
-                # # Size
-                # S = [[cam_width, cam_height]]
-
-                # # Distortions
-                # D = [[0.0, 0.0, 0.0, 0.0]]
-                        
-                # # Camera matrix
-                # K = [[[f, 0.0, cx], [0.0, f, cy], [0.0, 0.0, 1.0]]] # f and Z do not matter in 2D
-                
-                # # Rot, Trans
-                # R = 
-                # T = 
-
-                # # Save calibration file
-
-                # # Convert to meters
-                # trc_data = 
-
-
-
-
-
-
 
 
     #%% ==================================================
@@ -2205,86 +2300,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 +2496,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.21 → sports2d-0.8.23}/pyproject.toml

@@ -49,7 +49,7 @@ dependencies = [
     "opencv-python<4.12", # otherwise forces numpy>=2.0, which is incompatible with some opensim/python combinations
     "imageio_ffmpeg",
     "deep-sort-realtime",
-    "Pose2Sim>=0.10.36"
+    "Pose2Sim>=0.10.38"
 ]
 
 [tool.setuptools_scm]

{sports2d-0.8.21 → sports2d-0.8.23}/sports2d.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sports2d
-Version: 0.8.21
+Version: 0.8.23
 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
 
 

{sports2d-0.8.21 → sports2d-0.8.23}/sports2d.egg-info/requires.txt

@@ -14,4 +14,4 @@ openvino
 opencv-python<4.12
 imageio_ffmpeg
 deep-sort-realtime
-Pose2Sim>=0.10.36
+Pose2Sim>=0.10.38