sports2d 0.8.13__tar.gz → 0.8.15__tar.gz

{sports2d-0.8.13 → sports2d-0.8.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sports2d
-Version: 0.8.13
+Version: 0.8.15
 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>
@@ -402,6 +402,17 @@ sports2d --video_input demo.mp4 other_video.mp4 --time_range 1.2 2.7 0 3.5
   ```cmd
   sports2d --calculate_angles false
   ```
+- Flip angles when the person faces the other side.\
+  **N.B.:** *We consider that the person looks to the right if their toe keypoint is to the right of their heel. This is not always true when the person is sprinting, especially in the swing phase. Set it to false if you want timeseries to be continuous even when the participant switches their stance.*
+  ```cmd
+  sports2d --flip_left_right true # Default
+  ```
+- Correct segment angles according to the estimated camera tild 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
+  ```
+
 - To run **inverse kinematics with OpenSim**, check [this section](#run-inverse-kinematics)
 
 <br>
@@ -505,8 +516,8 @@ sports2d --help
 'large_hip_knee_angles': ["", "Hip and knee angles below this value are considered as imprecise. Defaults to 45"],
 'trimmed_extrema_percent': ["", "Proportion of the most extreme segment values to remove before calculating their mean. Defaults to 50"],
 'fontSize': ["", "font size for angle values. 0.3 if not specified"],
-'flip_left_right': ["", "true or false. Flips angles when the person faces the other side. The person looks to the right if their toe keypoint is to the right of their heel. Set it to false if the person is sprinting or if you want timeseries to be continuous even when the participent switches their stance. true if not specified"],
-'correct_segment_angles_with_floor_angle': ["", "true or false. If the camera is tilted, corrects segment angles as regards to the floor angle. Set to false is the floor is tilted instead. True if not specified"],
+'flip_left_right': ["", "true or false. Flips angles when the person faces the other side. The person looks to the right if their toe keypoint is to the right of their heel. Set it to false if the person is sprinting or if you want timeseries to be continuous even when the participant switches their stance. true if not specified"],
+'correct_segment_angles_with_floor_angle': ["", "true or false. If the camera is tilted, corrects segment angles as regards to the floor angle. Set to false if it is actually the floor which is tilted, not the camera. True if not specified"],
 'interpolate': ["", "interpolate missing data. true if not specified"],
 'interp_gap_smaller_than': ["", "interpolate sequences of missing data if they are less than N frames long. 10 if not specified"],
 'fill_large_gaps_with': ["", "last_value, nan, or zeros. last_value if not specified"],

{sports2d-0.8.13 → sports2d-0.8.15}/README.md

@@ -359,6 +359,17 @@ sports2d --video_input demo.mp4 other_video.mp4 --time_range 1.2 2.7 0 3.5
   ```cmd
   sports2d --calculate_angles false
   ```
+- Flip angles when the person faces the other side.\
+  **N.B.:** *We consider that the person looks to the right if their toe keypoint is to the right of their heel. This is not always true when the person is sprinting, especially in the swing phase. Set it to false if you want timeseries to be continuous even when the participant switches their stance.*
+  ```cmd
+  sports2d --flip_left_right true # Default
+  ```
+- Correct segment angles according to the estimated camera tild 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
+  ```
+
 - To run **inverse kinematics with OpenSim**, check [this section](#run-inverse-kinematics)
 
 <br>
@@ -462,8 +473,8 @@ sports2d --help
 'large_hip_knee_angles': ["", "Hip and knee angles below this value are considered as imprecise. Defaults to 45"],
 'trimmed_extrema_percent': ["", "Proportion of the most extreme segment values to remove before calculating their mean. Defaults to 50"],
 'fontSize': ["", "font size for angle values. 0.3 if not specified"],
-'flip_left_right': ["", "true or false. Flips angles when the person faces the other side. The person looks to the right if their toe keypoint is to the right of their heel. Set it to false if the person is sprinting or if you want timeseries to be continuous even when the participent switches their stance. true if not specified"],
-'correct_segment_angles_with_floor_angle': ["", "true or false. If the camera is tilted, corrects segment angles as regards to the floor angle. Set to false is the floor is tilted instead. True if not specified"],
+'flip_left_right': ["", "true or false. Flips angles when the person faces the other side. The person looks to the right if their toe keypoint is to the right of their heel. Set it to false if the person is sprinting or if you want timeseries to be continuous even when the participant switches their stance. true if not specified"],
+'correct_segment_angles_with_floor_angle': ["", "true or false. If the camera is tilted, corrects segment angles as regards to the floor angle. Set to false if it is actually the floor which is tilted, not the camera. True if not specified"],
 'interpolate': ["", "interpolate missing data. true if not specified"],
 'interp_gap_smaller_than': ["", "interpolate sequences of missing data if they are less than N frames long. 10 if not specified"],
 'fill_large_gaps_with': ["", "last_value, nan, or zeros. last_value if not specified"],

{sports2d-0.8.13 → sports2d-0.8.15}/Sports2D/Demo/Config_demo.toml

@@ -133,7 +133,8 @@ correct_segment_angles_with_floor_angle = true # If the camera is tilted, correc
 interpolate = true
 interp_gap_smaller_than = 10        # do not interpolate bigger gaps
 fill_large_gaps_with = 'last_value' # 'last_value', 'nan', or 'zeros' 
-
+sections_to_keep = 'all' # 'all', 'largest', 'first', 'last'
+                        # keep 'all' valid sections even when they are interspersed with undetected chunks, or the 'largest' valid section, or the 'first' one, or the 'last' one
 filter = true
 show_graphs = true            # Show plots of raw and processed results
 filter_type = 'butterworth'   # butterworth, gaussian, LOESS, median

{sports2d-0.8.13 → sports2d-0.8.15}/Sports2D/Sports2D.py

@@ -232,6 +232,7 @@ DEFAULT_CONFIG =   {'base': {'video_input': ['demo.mp4'],
                     'post-processing': {'interpolate': True,
                                         'interp_gap_smaller_than': 10,
                                         'fill_large_gaps_with': 'last_value',
+                                        'sections_to_keep':'all',
                                         'filter': True,
                                         'show_graphs': True,
                                         'filter_type': 'butterworth',
@@ -318,6 +319,7 @@ CONFIG_HELP =   {'config': ["C", "path to a toml configuration file"],
                 'interpolate': ["", "interpolate missing data. true if not specified"],
                 'interp_gap_smaller_than': ["", "interpolate sequences of missing data if they are less than N frames long. 10 if not specified"],
                 'fill_large_gaps_with': ["", "last_value, nan, or zeros. last_value if not specified"],
+                'sections_to_keep': ["", "all, largest, first, or last.  Keep 'all' valid sections even when they are interspersed with undetected chunks, or the 'largest' valid section, or the 'first' one, or the 'last' one"],
                 'filter': ["", "filter results. true if not specified"],
                 'filter_type': ["", "butterworth, gaussian, median, or loess. butterworth if not specified"],
                 'order': ["", "order of the Butterworth filter. 4 if not specified"],

{sports2d-0.8.13 → sports2d-0.8.15}/Sports2D/process.py

@@ -1074,6 +1074,7 @@ def select_persons_on_vid(frames, all_pose_coords):
                 bbox=dict(facecolor=UNSELECTED_COLOR, edgecolor=LINE_UNSELECTED_COLOR, boxstyle='square,pad=0.3', path_effects=[patheffects.withSimplePatchShadow()]), zorder=3
             )
             rects.append(rect)
+            annotations.append(annotation)
     img_plot = ax_video.imshow(frame_rgb)
 
     # Slider
@@ -1432,6 +1433,7 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
     interpolate = config_dict.get('post-processing').get('interpolate')    
     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')
 
     do_filter = config_dict.get('post-processing').get('filter')
     show_plots = config_dict.get('post-processing').get('show_graphs')
@@ -1511,9 +1513,13 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
         frame_range = [int((time_range[0]-start_time) * frame_rate), int((time_range[1]-start_time) * frame_rate)] if time_range else [0, int(cap.get(cv2.CAP_PROP_FRAME_COUNT))]
         frame_iterator = tqdm(range(*frame_range)) # use a progress bar
     if show_realtime_results:
-        cv2.namedWindow(f'{video_file} Sports2D', cv2.WINDOW_NORMAL + cv2.WINDOW_KEEPRATIO)
-        cv2.setWindowProperty(f'{video_file} Sports2D', cv2.WND_PROP_ASPECT_RATIO, cv2.WINDOW_FULLSCREEN)
-
+        try: 
+            screen_width, screen_height = get_screen_size()
+            display_width, display_height = calculate_display_size(cam_width, cam_height, screen_width, screen_height, margin=50)
+            cv2.namedWindow(f'{video_file} Sports2D', cv2.WINDOW_NORMAL)
+            cv2.resizeWindow(f'{video_file} Sports2D', display_width, display_height)
+        except: # if Pose2Sim < v0.10.29
+            cv2.namedWindow(f'{video_file} Sports2D', cv2.WINDOW_NORMAL + cv2.WINDOW_KEEPRATIO)
 
     # Select the appropriate model based on the model_type
     logging.info('\nEstimating pose...')
@@ -1561,9 +1567,9 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                 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'
+        # 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}.')
@@ -1641,11 +1647,13 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                 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)
+                else:
+                    pass
 
             
             # Process coordinates and compute angles
             valid_X, valid_Y, valid_scores = [], [], []
-            valid_X_flipped, valid_angles = [], []
+            valid_X_flipped, valid_angles_flipped, valid_angles = [], [], []
             for person_idx in range(len(keypoints)):
                 if load_trc_px:
                     person_X = keypoints[person_idx][:,0]
@@ -1691,7 +1699,17 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                         else:
                             ang = np.nan
                         person_angles.append(ang)
+                    
+                    # flip angles on the left side if flip_left_right false
+                    if len(visible_side) <= person_idx:
+                        visible_side += ['auto'] # set to 'auto' if list too short
+                    if visible_side[person_idx] == 'left' and not flip_left_right:
+                        person_angles_flipped = list(-np.array(person_angles))
+                    else:
+                        person_angles_flipped = person_angles.copy()
+
                     valid_angles.append(person_angles)
+                    valid_angles_flipped.append(person_angles_flipped)
                     valid_X_flipped.append(person_X_flipped)
                 valid_X.append(person_X)
                 valid_Y.append(person_Y)
@@ -1706,7 +1724,8 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                 img = draw_keypts(img, valid_X, valid_Y, valid_scores, cmap_str='RdYlGn')
                 img = draw_skel(img, valid_X, valid_Y, pose_model)
                 if calculate_angles:
-                    img = draw_angles(img, valid_X, valid_Y, valid_angles, valid_X_flipped, new_keypoints_ids, new_keypoints_names, angle_names, display_angle_values_on=display_angle_values_on, colors=colors, fontSize=fontSize, thickness=thickness)
+
+                    img = draw_angles(img, valid_X, valid_Y, valid_angles_flipped, valid_X_flipped, new_keypoints_ids, new_keypoints_names, angle_names, display_angle_values_on=display_angle_values_on, colors=colors, fontSize=fontSize, thickness=thickness)
                 cv2.imshow(f'{video_file} Sports2D', img)
                 if (cv2.waitKey(1) & 0xFF) == ord('q') or (cv2.waitKey(1) & 0xFF) == 27:
                     break
@@ -1829,7 +1848,7 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
 
                     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])
+                            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
@@ -1928,6 +1947,7 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                              f'xy_origin: {xy_origin if not xy_origin=="auto" else f"auto (estimation: {[round(c) for c in xy_origin_estim]})"} px.')
 
             # Coordinates in m
+            new_visible_side = []
             for i in range(len(trc_data)):
                 if not np.array(trc_data[i].iloc[:,1:] ==0).all():
                     # Automatically determine visible side
@@ -1957,7 +1977,7 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                     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])
+                        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)
                         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()
@@ -1976,7 +1996,9 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                     if make_c3d:
                         c3d_path = convert_to_c3d(str(pose_path_person_m_i))
                     logging.info(f'Pose in meters saved to {pose_path_person_m_i.resolve()}. {"Also saved in c3d format." if make_c3d else ""}')
-                    
+                else:
+                    visible_side_i = 'none'
+                new_visible_side += [visible_side_i]
                 
             
 
@@ -2032,13 +2054,20 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
         for i in range(all_frames_angles_homog.shape[1]):  # for each person
             for j in range(all_frames_angles_homog.shape[2]):  # for each angle
                 valid_mask = ~np.isnan(all_frames_angles_homog[:, i, j])
-                all_frames_angles_homog[valid_mask, i, j] = np.unwrap(all_frames_angles_homog[valid_mask, i, j], period=180)
-
+                ang = np.unwrap(all_frames_angles_homog[valid_mask, i, j], period=180)
+                ang = ang-360 if ang.mean()> 180 else ang
+                ang = ang+360 if ang.mean()<-180 else ang
+                all_frames_angles_homog[valid_mask, i, j] = ang
+                
         # Process angles for each person
         for i, idx_person in enumerate(selected_persons):
             angles_path_person = angles_output_path.parent / (angles_output_path.stem + f'_person{i:02d}.mot')
             all_frames_angles_person = pd.DataFrame(all_frames_angles_homog[:,idx_person,:], columns=angle_names)
             
+            # Flip angles for left side when flip_left_right false
+            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:
@@ -2055,7 +2084,7 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                     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])
+                            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()
@@ -2152,7 +2181,7 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
             if save_vid:
                 out_vid.write(img)
             if save_img:
-                cv2.imwrite(str((img_output_dir / f'{output_dir_name}_{(frame_count-1):06d}.png')), img)
+                cv2.imwrite(str((img_output_dir / f'{output_dir_name}_{(frame_count):06d}.png')), img)
 
         if save_vid:
             out_vid.release()
@@ -2204,7 +2233,7 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                     # masses.append(DEFAULT_MASS)
                     logging.info(f'Less than 4 valid frames. Deleting person.')
                 else:
-                    if visible_side[i] == 'none':
+                    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)

{sports2d-0.8.13 → sports2d-0.8.15}/sports2d.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sports2d
-Version: 0.8.13
+Version: 0.8.15
 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>
@@ -402,6 +402,17 @@ sports2d --video_input demo.mp4 other_video.mp4 --time_range 1.2 2.7 0 3.5
   ```cmd
   sports2d --calculate_angles false
   ```
+- Flip angles when the person faces the other side.\
+  **N.B.:** *We consider that the person looks to the right if their toe keypoint is to the right of their heel. This is not always true when the person is sprinting, especially in the swing phase. Set it to false if you want timeseries to be continuous even when the participant switches their stance.*
+  ```cmd
+  sports2d --flip_left_right true # Default
+  ```
+- Correct segment angles according to the estimated camera tild 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
+  ```
+
 - To run **inverse kinematics with OpenSim**, check [this section](#run-inverse-kinematics)
 
 <br>
@@ -505,8 +516,8 @@ sports2d --help
 'large_hip_knee_angles': ["", "Hip and knee angles below this value are considered as imprecise. Defaults to 45"],
 'trimmed_extrema_percent': ["", "Proportion of the most extreme segment values to remove before calculating their mean. Defaults to 50"],
 'fontSize': ["", "font size for angle values. 0.3 if not specified"],
-'flip_left_right': ["", "true or false. Flips angles when the person faces the other side. The person looks to the right if their toe keypoint is to the right of their heel. Set it to false if the person is sprinting or if you want timeseries to be continuous even when the participent switches their stance. true if not specified"],
-'correct_segment_angles_with_floor_angle': ["", "true or false. If the camera is tilted, corrects segment angles as regards to the floor angle. Set to false is the floor is tilted instead. True if not specified"],
+'flip_left_right': ["", "true or false. Flips angles when the person faces the other side. The person looks to the right if their toe keypoint is to the right of their heel. Set it to false if the person is sprinting or if you want timeseries to be continuous even when the participant switches their stance. true if not specified"],
+'correct_segment_angles_with_floor_angle': ["", "true or false. If the camera is tilted, corrects segment angles as regards to the floor angle. Set to false if it is actually the floor which is tilted, not the camera. True if not specified"],
 'interpolate': ["", "interpolate missing data. true if not specified"],
 'interp_gap_smaller_than': ["", "interpolate sequences of missing data if they are less than N frames long. 10 if not specified"],
 'fill_large_gaps_with': ["", "last_value, nan, or zeros. last_value if not specified"],