sports2d 0.5.2__py3-none-any.whl → 0.5.4__py3-none-any.whl

Sports2D/Demo/Config_demo.toml

@@ -102,7 +102,7 @@ show_graphs = true            # Show plots of raw and processed results
 filter_type = 'butterworth'   # butterworth, gaussian, LOESS, median
    [post-processing.butterworth]
    order = 4 
-   cut_off_frequency = 3 # Hz
+   cut_off_frequency = 6 # Hz # Will be divided by slowmo_factor to be equivalent to non slowed-down video
    [post-processing.gaussian]
    sigma_kernel = 1 #px
    [post-processing.loess]
@@ -119,4 +119,7 @@ person_orientation = ['front', 'none', 'left'] # Choose among 'auto', 'none', 'f
                      # Example with one person on one video: ['front']
                      # Or ['front', 'none', 'left'] with 3 persons on one video
 osim_setup_path = '../OpenSim_setup' # Path to the OpenSim setup folder
-close_to_zero_speed_m = 0.2 # Sum for all keypoints: about 50 px/frame or 0.2 m/frame 
+close_to_zero_speed_m = 0.2 # Sum for all keypoints: about 50 px/frame or 0.2 m/frame 
+
+[logging]
+use_custom_logging = false # if integrated in an API that already has logging

Sports2D/Sports2D.py

@@ -194,7 +194,7 @@ DEFAULT_CONFIG =   {'project': {'video_input': ['demo.mp4'],
                                         'filter': True,
                                         'show_graphs': True,
                                         'filter_type': 'butterworth',
-                                        'butterworth': {'order': 4, 'cut_off_frequency': 3},
+                                        'butterworth': {'order': 4, 'cut_off_frequency': 6},
                                         'gaussian': {'sigma_kernel': 1},
                                         'loess': {'nb_values_used': 5},
                                         'median': {'kernel_size': 3}
@@ -203,7 +203,8 @@ DEFAULT_CONFIG =   {'project': {'video_input': ['demo.mp4'],
                                           'person_orientation': ['front', '', 'left'],
                                           'osim_setup_path': '../OpenSim_setup',
                                           'close_to_zero_speed_m': 0.2
-                                          }
+                                          },
+                    'logging': {'use_custom_logging': False}
                     }
 
 CONFIG_HELP =   {'config': ["C", "path to a toml configuration file"],
@@ -260,7 +261,8 @@ CONFIG_HELP =   {'config': ["C", "path to a toml configuration file"],
                 'cut_off_frequency': ["", "cut-off frequency of the Butterworth filter. 3 if not specified"],
                 'sigma_kernel': ["", "sigma of the gaussian filter. 1 if not specified"],
                 'nb_values_used': ["", "number of values used for the loess filter. 5 if not specified"],
-                'kernel_size': ["", "kernel size of the median filter. 3 if not specified"]
+                'kernel_size': ["", "kernel size of the median filter. 3 if not specified"],
+                'use_custom_logging': ["", "use custom logging. false if not specified"]
                 }
 
 
@@ -414,11 +416,13 @@ def process(config='Config_demo.toml'):
     else:
         config_dict = read_config_file(config)
     video_dir, video_files, frame_rates, time_ranges, result_dir = base_params(config_dict)
+    use_custom_logging = config_dict.get('logging').get('use_custom_logging')
         
     result_dir.mkdir(parents=True, exist_ok=True)
-    with open(result_dir / 'logs.txt', 'a+') as log_f: pass
-    logging.basicConfig(format='%(message)s', level=logging.INFO, force=True, 
-        handlers = [logging.handlers.TimedRotatingFileHandler(result_dir / 'logs.txt', when='D', interval=7), logging.StreamHandler()]) 
+    if not use_custom_logging: 
+        with open(result_dir / 'logs.txt', 'a+') as log_f: pass
+        logging.basicConfig(format='%(message)s', level=logging.INFO, force=True, 
+            handlers = [logging.handlers.TimedRotatingFileHandler(result_dir / 'logs.txt', when='D', interval=7), logging.StreamHandler()]) 
     
     for video_file, time_range, frame_rate in zip(video_files, time_ranges, frame_rates):
         currentDateAndTime = datetime.now()

Sports2D/Utilities/common.py

@@ -20,6 +20,7 @@ import sys
 import toml
 import subprocess
 from pathlib import Path
+import logging
 
 import numpy as np
 from scipy import interpolate
@@ -164,21 +165,31 @@ def make_homogeneous(list_of_arrays):
     '''
     
     def get_max_shape(list_of_arrays):
+        '''
+        Recursively determine the maximum shape of a list of arrays.
+        '''
         if isinstance(list_of_arrays[0], list):
             # Maximum length at the current level plus the max shape at the next level
             return [max(len(arr) for arr in list_of_arrays)] + get_max_shape(
                 [item for sublist in list_of_arrays for item in sublist])
         else:
             # Determine the maximum shape across all list_of_arrays at this level
-            return [len(list_of_arrays)] + [max(arr.shape[i] for arr in list_of_arrays) for i in range(list_of_arrays[0].ndim)]
+            return [len(list_of_arrays)] + [max(arr.shape[i] for arr in list_of_arrays if arr.size > 0) for i in range(list_of_arrays[0].ndim)]
 
     def pad_with_nans(list_of_arrays, target_shape):
         '''
         Recursively pad list_of_arrays with nans to match the target shape.
         '''
-        if isinstance(list_of_arrays, np.ndarray):
-            # Pad the current array to the target shape
-            pad_width = [(0, max_dim - curr_dim) for curr_dim, max_dim in zip(list_of_arrays.shape, target_shape)]
+        if isinstance(list_of_arrays, np.ndarray):        
+            # Pad the current array to the target shape        
+            pad_width = []        
+            for dim_index in range(0, len(target_shape)):
+                if dim_index == len(list_of_arrays.shape) or dim_index > len(list_of_arrays.shape):
+                    list_of_arrays = np.expand_dims(list_of_arrays, 0)
+            for dim_index in range(0, len(target_shape)):
+                max_dim = target_shape[dim_index]
+                curr_dim = list_of_arrays.shape[dim_index]
+                pad_width.append((0, max_dim - curr_dim))
             return np.pad(list_of_arrays.astype(float), pad_width, constant_values=np.nan)
         # Recursively pad each array in the list
         return [pad_with_nans(array, target_shape[1:]) for array in list_of_arrays]
@@ -191,6 +202,28 @@ def make_homogeneous(list_of_arrays):
     return np.array(list_of_arrays)
 
 
+def get_start_time_ffmpeg(video_path):
+    '''
+    Get the start time of a video using FFmpeg.
+    '''
+
+    try:
+        ffmpeg_path = ffmpeg.get_ffmpeg_exe()
+    except Exception as e:
+        logging.warning(f"No ffmpeg exe could be found. Starting time set to 0.0. Error: {e}")
+        return 0.0
+    
+    cmd = [ffmpeg_path, "-i", video_path]
+    result = subprocess.run(cmd, stderr=subprocess.PIPE, stdout=subprocess.DEVNULL, text=True)
+    for line in result.stderr.splitlines():
+        if "start:" in line:
+            parts = line.split("start:")
+            if len(parts) > 1:
+                start_time = parts[1].split(",")[0].strip()
+                return float(start_time)
+    return 0.0  # Default to 0 if not found
+
+
 def resample_video(vid_output_path, fps, desired_framerate):
     '''
     Resample video to the desired fps using ffmpeg.

Sports2D/process.py

@@ -195,7 +195,7 @@ def setup_video(video_file_path, save_vid, vid_output_path):
     if video_file_path.name == video_file_path.stem:
         raise ValueError("Please set video_input to 'webcam' or to a video file (with extension) in Config.toml")
     try:
-        cap = cv2.VideoCapture(video_file_path)
+        cap = cv2.VideoCapture(str(video_file_path.absolute()))
         if not cap.isOpened():
             raise
     except:
@@ -210,12 +210,12 @@ def setup_video(video_file_path, save_vid, vid_output_path):
     if save_vid:
         # try:
         #     fourcc = cv2.VideoWriter_fourcc(*'avc1') # =h264. better compression and quality but may fail on some systems
-        #     out_vid = cv2.VideoWriter(vid_output_path, fourcc, fps, (cam_width, cam_height))
+        #     out_vid = cv2.VideoWriter(str(vid_output_path.absolute()), fourcc, fps, (cam_width, cam_height))
         #     if not out_vid.isOpened():
         #         raise ValueError("Failed to open video writer with 'avc1' (h264)")
         # except Exception:
         fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-        out_vid = cv2.VideoWriter(vid_output_path, fourcc, fps, (cam_width, cam_height))
+        out_vid = cv2.VideoWriter(str(vid_output_path.absolute()), fourcc, fps, (cam_width, cam_height))
             # logging.info("Failed to open video writer with 'avc1' (h264). Using 'mp4v' instead.")
     
     return cap, out_vid, cam_width, cam_height, fps
@@ -1195,6 +1195,15 @@ def best_coords_for_measurements(Q_coords, keypoints_names, fastest_frames_to_re
     - Q_coords_low_speeds_low_angles: pd.DataFrame. The best coordinates for measurements
     '''
 
+    # Add Hip column if not present
+    n_markers_init = len(keypoints_names)
+    if 'Hip' not in keypoints_names:
+        RHip_df = Q_coords.iloc[:,keypoints_names.index('RHip')*3:keypoints_names.index('RHip')*3+3]
+        LHip_df = Q_coords.iloc[:,keypoints_names.index('LHip')*3:keypoints_names.index('RHip')*3+3]
+        Hip_df = RHip_df.add(LHip_df, fill_value=0) /2
+        Hip_df.columns = [col+ str(int(Q_coords.columns[-1][1:])+1) for col in ['X','Y','Z']]
+        keypoints_names += ['Hip']
+        Q_coords = pd.concat([Q_coords, Hip_df], axis=1)
     n_markers = len(keypoints_names)
 
     # Using 80% slowest frames
@@ -1210,6 +1219,9 @@ def best_coords_for_measurements(Q_coords, keypoints_names, fastest_frames_to_re
     if len(Q_coords_low_speeds_low_angles) < 50:
         Q_coords_low_speeds_low_angles = Q_coords_low_speeds.iloc[pd.Series(ang_mean).nsmallest(50).index]
 
+    if n_markers_init < n_markers:
+        Q_coords_low_speeds_low_angles = Q_coords_low_speeds_low_angles.iloc[:,:-3]
+
     return Q_coords_low_speeds_low_angles
 
 
@@ -1404,6 +1416,7 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
     gaussian_filter_kernel = config_dict.get('post-processing').get('gaussian').get('sigma_kernel')
     loess_filter_kernel = config_dict.get('post-processing').get('loess').get('nb_values_used')
     median_filter_kernel = config_dict.get('post-processing').get('median').get('kernel_size')
+    butterworth_filter_cutoff /= slowmo_factor
     filter_options = [do_filter, filter_type,
                            butterworth_filter_order, butterworth_filter_cutoff, frame_rate,
                            gaussian_filter_kernel, loess_filter_kernel, median_filter_kernel]
@@ -1440,7 +1453,8 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
         logging.warning('Webcam input: the framerate may vary. If results are filtered, Sports2D will use the average framerate as input.')
     else:
         cap, out_vid, cam_width, cam_height, fps = setup_video(video_file_path, save_vid, vid_output_path)
-        frame_range = [int(time_range[0] * frame_rate), int(time_range[1] * frame_rate)] if time_range else [0, int(cap.get(cv2.CAP_PROP_FRAME_COUNT))]
+        start_time = get_start_time_ffmpeg(video_file_path)
+        frame_range = [int((time_range[0]-start_time) * frame_rate), int((time_range[1]-start_time) * frame_rate)] if time_range else [0, int(cap.get(cv2.CAP_PROP_FRAME_COUNT))]
         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)
@@ -1486,6 +1500,7 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
     frame_processing_times = []
     frame_count = 0
     while cap.isOpened():
+        # Skip to the starting frame
         if frame_count < frame_range[0]:
             cap.read()
             frame_count += 1

{sports2d-0.5.2.dist-info → sports2d-0.5.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sports2d
-Version: 0.5.2
+Version: 0.5.4
 Summary: Detect pose and compute 2D joint angles from a video.
 Home-page: https://github.com/davidpagnon/Sports2D
 Author: David Pagnon

sports2d-0.5.4.dist-info/RECORD

@@ -0,0 +1,16 @@
+Sports2D/Sports2D.py,sha256=dZv4xglguFJZDu9Zv0AZKAGu1TQIW9ynmY8pMsNHw14,26377
+Sports2D/__init__.py,sha256=TyCP7Uuuy6CNklhPf8W84MbYoO1_-1dxowSYAJyk_OI,102
+Sports2D/process.py,sha256=6rFjME0pSJXZpYD9t7Ai8P5Ly2MVpmKgZAo912j24kM,87663
+Sports2D/Demo/Config_demo.toml,sha256=kp2iqohOLlN3vzFBDgz69BB8kpaYqcGXDQpchlxeO9w,6769
+Sports2D/Demo/demo.mp4,sha256=2aZkFxhWR7ESMEtXCT8MGA83p2jmoU2sp1ylQfO3gDk,3968304
+Sports2D/Utilities/__init__.py,sha256=TyCP7Uuuy6CNklhPf8W84MbYoO1_-1dxowSYAJyk_OI,102
+Sports2D/Utilities/common.py,sha256=FEWmlq9HNlHzA2ioV5MPPOeC-5Py4JaDbIIxQgq9hGE,14128
+Sports2D/Utilities/filter.py,sha256=8mVefMjDzxmh9a30eNtIrUuK_mUKoOJ2Nr-OzcQKkKM,4922
+Sports2D/Utilities/skeletons.py,sha256=44IWpz47zjh_6YDqkwaJnSysaGi7ovgYE25ji-hC-Kw,15660
+Sports2D/Utilities/tests.py,sha256=g06HBExGkvZrhZpNXN19G9Shisfgp1cqjAp0kFxiKEc,2574
+sports2d-0.5.4.dist-info/LICENSE,sha256=f4qe3nE0Y7ltJho5w-xAR0jI5PUox5Xl-MsYiY7ZRM8,1521
+sports2d-0.5.4.dist-info/METADATA,sha256=0EOJSFWnNfbndViXV-gYWglHkzkTeYvg5CIpBEK4pVs,23067
+sports2d-0.5.4.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+sports2d-0.5.4.dist-info/entry_points.txt,sha256=h2CJTuydtNf8JyaLoWxWl5HTSIxx5Ra_FSiSGQsf7Sk,52
+sports2d-0.5.4.dist-info/top_level.txt,sha256=DoURf9UDB8lQ_9lMUPQMQqhXCvWPFFjJco9NzPlHJ6I,9
+sports2d-0.5.4.dist-info/RECORD,,

sports2d-0.5.2.dist-info/RECORD

@@ -1,16 +0,0 @@
-Sports2D/Sports2D.py,sha256=toqCATE3D3JDYKp_SnCUdQekW45F_KsIHK1vurDS6n8,26103
-Sports2D/__init__.py,sha256=TyCP7Uuuy6CNklhPf8W84MbYoO1_-1dxowSYAJyk_OI,102
-Sports2D/process.py,sha256=EQcLyjxyn-oKysZ3iCZ1eSvY8LITTuxXDKmfVTKRNZ4,86767
-Sports2D/Demo/Config_demo.toml,sha256=03HL-4nMRVrSzL_NFRA6rjzSqirP6GfHjb1bAt8VeKU,6603
-Sports2D/Demo/demo.mp4,sha256=2aZkFxhWR7ESMEtXCT8MGA83p2jmoU2sp1ylQfO3gDk,3968304
-Sports2D/Utilities/__init__.py,sha256=TyCP7Uuuy6CNklhPf8W84MbYoO1_-1dxowSYAJyk_OI,102
-Sports2D/Utilities/common.py,sha256=-LoJGs_nyNPcj6cQfVQI9X5mQmv7ibTcYUfaEwFN2uU,12880
-Sports2D/Utilities/filter.py,sha256=8mVefMjDzxmh9a30eNtIrUuK_mUKoOJ2Nr-OzcQKkKM,4922
-Sports2D/Utilities/skeletons.py,sha256=44IWpz47zjh_6YDqkwaJnSysaGi7ovgYE25ji-hC-Kw,15660
-Sports2D/Utilities/tests.py,sha256=g06HBExGkvZrhZpNXN19G9Shisfgp1cqjAp0kFxiKEc,2574
-sports2d-0.5.2.dist-info/LICENSE,sha256=f4qe3nE0Y7ltJho5w-xAR0jI5PUox5Xl-MsYiY7ZRM8,1521
-sports2d-0.5.2.dist-info/METADATA,sha256=46UdMkJj9kmxHjsLaxBhyBo_ubE1cRZ8FDD0lFimfeA,23067
-sports2d-0.5.2.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-sports2d-0.5.2.dist-info/entry_points.txt,sha256=h2CJTuydtNf8JyaLoWxWl5HTSIxx5Ra_FSiSGQsf7Sk,52
-sports2d-0.5.2.dist-info/top_level.txt,sha256=DoURf9UDB8lQ_9lMUPQMQqhXCvWPFFjJco9NzPlHJ6I,9
-sports2d-0.5.2.dist-info/RECORD,,