sports2d 0.8.24__py3-none-any.whl → 0.8.26__py3-none-any.whl

Sports2D/process.py

@@ -90,6 +90,8 @@ from Pose2Sim.filtering import *
 # Silence numpy "RuntimeWarning: Mean of empty slice"
 import warnings
 warnings.filterwarnings("ignore", category=RuntimeWarning, message="Mean of empty slice")
+warnings.filterwarnings("ignore", category=RuntimeWarning, message="All-NaN slice encountered")
+warnings.filterwarnings("ignore", category=RuntimeWarning, message="invalid value encountered in scalar divide")
 
 # Not safe, but to be used until OpenMMLab/RTMlib's SSL certificates are updated
 import ssl
@@ -240,7 +242,7 @@ def setup_model_class_mode(pose_model, mode, config_dict={}):
         try: # from Config.toml
             from anytree.importer import DictImporter
             model_name = pose_model.upper()
-            pose_model = DictImporter().import_(config_dict.get('pose').get(pose_model))
+            pose_model = DictImporter().import_(config_dict.get('pose').get(pose_model)[0])
             if pose_model.id == 'None':
                 pose_model.id = None
             logging.info(f"Using model {model_name} for pose estimation.")
@@ -796,7 +798,6 @@ def make_mot_with_angles(angles, time, mot_path):
 def pose_plots(trc_data_unfiltered, trc_data, person_id, show=True):
     '''
     Displays trc filtered and unfiltered data for comparison
-    ⚠ Often crashes on the third window...
 
     INPUTS:
     - trc_data_unfiltered: pd.DataFrame. The unfiltered trc data
@@ -807,23 +808,26 @@ def pose_plots(trc_data_unfiltered, trc_data, person_id, show=True):
     OUTPUT:
     - matplotlib window with tabbed figures for each keypoint
     '''
-
+    
     os_name = platform.system()
-    if os_name == 'Windows':
-        mpl.use('qt5agg') # windows
     mpl.rc('figure', max_open_warning=0)
+    if show:
+        if os_name == 'Windows':
+            mpl.use('qt5agg') # windows
+        pw = plotWindow()
+        pw.MainWindow.setWindowTitle('Person'+ str(person_id) + ' coordinates')
+    else:
+        mpl.use('Agg') # Otherwise fails on Hugging-face
+        figures_list = []    
 
     keypoints_names = trc_data.columns[1::3]
-    
-    pw = plotWindow()
-    pw.MainWindow.setWindowTitle('Person'+ str(person_id) + ' coordinates') # Main title
-
     for id, keypoint in enumerate(keypoints_names):
         f = plt.figure()
-        if os_name == 'Windows':
-            f.canvas.manager.window.setWindowTitle(keypoint + ' Plot') # windows
-        elif os_name == 'Darwin':  # macOS
-            f.canvas.manager.set_window_title(keypoint + ' Plot') # mac
+        if show:
+            if os_name == 'Windows':
+                f.canvas.manager.window.setWindowTitle(keypoint + ' Plot')
+            elif os_name == 'Darwin':
+                f.canvas.manager.set_window_title(keypoint + ' Plot')
 
         axX = plt.subplot(211)
         plt.plot(trc_data_unfiltered.iloc[:,0], trc_data_unfiltered.iloc[:,id*3+1], label='unfiltered')
@@ -838,18 +842,21 @@ def pose_plots(trc_data_unfiltered, trc_data, person_id, show=True):
         axY.set_xlabel('Time (seconds)')
         axY.set_ylabel(keypoint+' Y')
 
-        pw.addPlot(keypoint, f)
+        if show:
+            pw.addPlot(keypoint, f)
+        else:
+            figures_list.append((keypoint, f))
     
     if show:
         pw.show()
-
-    return pw
-
+        return pw
+    else:
+        return figures_list
+    
 
 def angle_plots(angle_data_unfiltered, angle_data, person_id, show=True):
     '''
     Displays angle filtered and unfiltered data for comparison
-    ⚠ Often crashes on the third window...
 
     INPUTS:
     - angle_data_unfiltered: pd.DataFrame. The unfiltered angle data
@@ -860,21 +867,24 @@ def angle_plots(angle_data_unfiltered, angle_data, person_id, show=True):
     '''
 
     os_name = platform.system()
-    if os_name == 'Windows':
-        mpl.use('qt5agg') # windows
     mpl.rc('figure', max_open_warning=0)
+    if show:
+        if os_name == 'Windows':
+            mpl.use('qt5agg') # windows
+        pw = plotWindow()
+        pw.MainWindow.setWindowTitle('Person'+ str(person_id) + ' angles')
+    else:
+        mpl.use('Agg') # Otherwise fails on Hugging-face
+        figures_list = []
 
     angles_names = angle_data.columns[1:]
-    
-    pw = plotWindow()
-    pw.MainWindow.setWindowTitle('Person'+ str(person_id) + ' angles') # Main title
-
     for id, angle in enumerate(angles_names):
         f = plt.figure()
-        if os_name == 'Windows':
-            f.canvas.manager.window.setWindowTitle(angle + ' Plot') # windows
-        elif os_name == 'Darwin':  # macOS
-            f.canvas.manager.set_window_title(angle + ' Plot') # mac
+        if show:
+            if os_name == 'Windows':
+                f.canvas.manager.window.setWindowTitle(angle + ' Plot') # windows
+            elif os_name == 'Darwin':  # macOS
+                f.canvas.manager.set_window_title(angle + ' Plot') # mac
         
         ax = plt.subplot(111)
         plt.plot(angle_data_unfiltered.iloc[:,0], angle_data_unfiltered.iloc[:,id+1], label='unfiltered')
@@ -884,12 +894,16 @@ def angle_plots(angle_data_unfiltered, angle_data, person_id, show=True):
         ax.set_ylabel(angle+' (°)')
         plt.legend()
 
-        pw.addPlot(angle, f)
-
+        if show:
+            pw.addPlot(angle, f)
+        else:
+            figures_list.append((angle, f))
+    
     if show:
         pw.show()
-
-    return pw
+        return pw
+    else:
+        return figures_list
 
 
 def get_personIDs_with_highest_scores(all_frames_scores, nb_persons_to_detect):
@@ -1275,7 +1289,7 @@ def select_persons_on_vid(video_file_path, frame_range, all_pose_coords):
     return selected_persons
 
 
-def compute_floor_line(trc_data, score_data, keypoint_names = ['LBigToe', 'RBigToe'], toe_speed_below = 7, score_threshold=0.5):
+def compute_floor_line(trc_data, score_data, keypoint_names = ['LBigToe', 'RBigToe'], toe_speed_below = 7, score_threshold=0.3):
     '''
     Compute the floor line equation, angle, and direction
     from the feet keypoints when they have zero speed.
@@ -1304,7 +1318,7 @@ def compute_floor_line(trc_data, score_data, keypoint_names = ['LBigToe', 'RBigT
         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
+        # Compute euclidean speed
         speeds = np.linalg.norm(trc_data_kpt_trim.diff(), axis=1)
 
         # Remove speeds with low confidence
@@ -1325,7 +1339,7 @@ def compute_floor_line(trc_data, score_data, keypoint_names = ['LBigToe', 'RBigT
 
     # Fit a line to the zero-speed coordinates
     floor_line = np.polyfit(low_speeds_X, low_speeds_Y, 1) # (slope, intercept)
-    angle = -np.arctan(floor_line[0]) # angle of the floor line in degrees
+    angle = -np.arctan(floor_line[0]) # angle of the floor line in radians
     xy_origin = [0, floor_line[1]] # origin of the floor line
 
     # Gait direction
@@ -1334,14 +1348,160 @@ def compute_floor_line(trc_data, score_data, keypoint_names = ['LBigToe', 'RBigT
     return angle, xy_origin, gait_direction
 
 
-def convert_px_to_meters(Q_coords_kpt, first_person_height, height_px, cx, cy, floor_angle, visible_side='none'):
+def get_distance_from_camera(perspective_value=10, perspective_unit='distance_m', calib_file =None, height_px=1, height_m=1, cam_width=1, cam_height=1):
+    '''
+    Compute the distance between the camera and the person based on the chosen perspective unit.
+
+    INPUTS:
+    - perspective_value: Value associated with the chosen perspective unit.
+    - perspective_unit: Unit used to compute the distance. Can be 'distance_m', 'f_px', 'fov_rad', 'fov_deg', or 'from_calib'.
+    - calib_file: Path to the toml calibration file.
+    - height_px: Height of the person in pixels.
+    - height_m: Height of the first person in meters.
+    - cam_width: Width of the camera frame in pixels.
+    - cam_height: Height of the camera frame in pixels.
+    
+    OUTPUTS:
+    - distance_m: Distance between the camera and the person in meters.
+    '''
+
+    if perspective_unit == 'from_calib':
+        if not calib_file:
+            perspective_unit = 'distance_m'
+            distance_m = 10.0
+            logging.warning(f'No calibration file provided. Using a default distance of {distance_m} m between the camera and the person to convert px to meters.')
+        else:
+            calib_params_dict = retrieve_calib_params(calib_file)
+            f_px = calib_params_dict['K'][0][0][0]
+            distance_m = f_px / height_px * height_m
+    elif perspective_unit == 'distance_m':
+        distance_m = perspective_value
+    elif perspective_unit == 'f_px':
+        f_px = perspective_value
+        distance_m = f_px / height_px * height_m
+    elif perspective_unit == 'fov_rad':
+        fov_rad = perspective_value
+        f_px = max(cam_width, cam_height)/2 / np.tan(fov_rad / 2)
+        distance_m = f_px / height_px * height_m
+    elif perspective_unit == 'fov_deg':
+        fov_rad = np.radians(perspective_value)
+        f_px = max(cam_width, cam_height)/2 / np.tan(fov_rad / 2)
+        distance_m = f_px / height_px * height_m
+
+    return distance_m
+
+
+def get_floor_params(floor_angle='auto', xy_origin=['auto'], 
+                     calib_file=None, height_px=1, height_m=1, 
+                     fps=30, trc_data=pd.DataFrame(), score_data=pd.DataFrame(), toe_speed_below=1, score_threshold=0.5, 
+                     cam_width=1, cam_height=1):
+    '''
+    Compute the floor angle and the xy_origin based on calibration file, kinematics, or user input.
+
+    INPUTS:
+    - floor_angle: Method to compute the floor angle. Can be 'auto', 'from_calib', 'from_kinematics', or a numeric value in degrees.
+    - xy_origin: Method to compute the xy_origin. Can be ['auto'], ['from_calib'], ['from_kinematics'], or a list of two numeric values in pixels [cx, cy].
+    - calib_file: Path to a toml calibration file.
+    - height_px: Height of the person in pixels.
+    - height_m: Height of the first person in meters.
+    - fps: Framerate of the video in frames per second. Used if estimating floor line from kinematics.
+    - trc_data: DataFrame containing the pose data in pixels for one person. Used if estimating floor line from kinematics.
+    - score_data: DataFrame containing the keypoint scores for one person. Used if estimating floor line from kinematics.
+    - toe_speed_below: Speed below which the foot is considered to be stationary, in m/s. Used if estimating floor line from kinematics.
+    - score_threshold: Minimum average keypoint score to consider a frame for floor line estimation.
+    - cam_width: Width of the camera frame in pixels. Used if failed to estimate floor line from kinematics.
+    - cam_height: Height of the camera frame in pixels. Used if failed to estimate floor line from kinematics.
+
+    OUTPUTS:
+    - floor_angle_estim: Estimated floor angle in radians.
+    - xy_origin_estim: Estimated xy_origin as a list of two numeric values in pixels [cx, cy].
+    - gait_direction: Estimated gait direction. 'left' if < 0, 'right' otherwise.
+    '''
+    
+    # Estimate floor angle from the calibration file
+    if floor_angle == 'from_calib' or xy_origin == ['from_calib']:
+        if not calib_file:
+            if floor_angle == 'from_calib':
+                floor_angle = 'auto'
+            if  xy_origin == ['from_calib']:
+                xy_origin = ['auto']
+            logging.warning(f'No calibration file provided. Estimating floor angle and xy_origin from the pose of the first selected person.')
+        else:
+            calib_params_dict = retrieve_calib_params(calib_file)
+
+            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]])
+
+            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_calib = 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]* height_px / height_m
+            xy_origin_calib = [cx, cy]
+
+    # Estimate xy_origin from the line formed by the toes when they are on the ground (where speed = 0)
+    px_per_m = height_px/height_m
+    toe_speed_below_px_frame = toe_speed_below * px_per_m / fps # speed below which the foot is considered to be stationary
+    try:
+        if all(key in trc_data for key in ['LBigToe', 'RBigToe']):
+            floor_angle_kin, xy_origin_kin, gait_direction = compute_floor_line(trc_data, score_data, keypoint_names=['LBigToe', 'RBigToe'], toe_speed_below=toe_speed_below_px_frame, score_threshold=score_threshold)
+        else:
+            floor_angle_kin, xy_origin_estim, gait_direction = compute_floor_line(trc_data, score_data, keypoint_names=['LAnkle', 'RAnkle'], toe_speed_below=toe_speed_below_px_frame, score_threshold=score_threshold)
+            xy_origin_kin[1] = xy_origin_kin[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_kin = 0
+        xy_origin_kin = cam_width/2, cam_height/2
+        gait_direction = 1
+        logging.warning(f'Could not estimate the floor angle, xy_origin, and visible from person {0}. Make sure that the full body is visible. Using floor angle = 0°, xy_origin = [{cam_width/2}, {cam_height/2}] px, and visible_side = right.')
+
+    # Determine final floor angle estimation
+    if floor_angle == 'from_calib':
+        floor_angle_estim = floor_angle_calib
+    elif floor_angle in ['auto', 'from_kinematics']:
+        floor_angle_estim = floor_angle_kin
+    else:
+        try:
+            floor_angle_estim =  np.radians(float(floor_angle))
+        except:
+            raise ValueError(f'Invalid floor_angle: {floor_angle}. Must be "auto", "from_calib", "from_kinematics", or a numeric value in degrees.')
+
+    # Determine final xy_origin estimation
+    if xy_origin == ['from_calib']:
+        xy_origin_estim = xy_origin_calib
+    elif xy_origin in [['auto'], ['from_kinematics']]:
+        xy_origin_estim = xy_origin_kin
+    else:
+        try:
+            xy_origin_estim = [float(v) for v in xy_origin]
+        except:
+            raise ValueError(f'Invalid xy_origin: {xy_origin}. Must be "auto", "from_calib", "from_kinematics", or a list of two numeric values in pixels.')
+    
+    return floor_angle_estim, xy_origin_estim, gait_direction
+
+
+def convert_px_to_meters(Q_coords_kpt, first_person_height, height_px, distance_m, cam_width, cam_height, cx, cy, floor_angle, visible_side='none'):
     '''
     Convert pixel coordinates to meters.
+    Corrects for floor angle, floor level, and depth perspective errors.
 
     INPUTS:
     - Q_coords_kpt: pd.DataFrame. The xyz coordinates of a keypoint in pixels, with z filled with zeros
     - first_person_height: float. The height of the person in meters
     - height_px: float. The height of the person in pixels
+    - cam_width: float. The width of the camera frame in pixels
+    - cam_height: float. The height of the camera frame in pixels
+    - distance_m: float. The distance between the camera and the person in meters
     - cx, cy: float. The origin of the image in pixels
     - floor_angle: float. The angle of the floor in radians
     - visible_side: str. The side of the person that is visible ('right', 'left', 'front', 'back', 'none')
@@ -1350,19 +1510,36 @@ def convert_px_to_meters(Q_coords_kpt, first_person_height, height_px, cx, cy, f
     - Q_coords_kpt_m: pd.DataFrame. The XYZ coordinates of a keypoint in meters
     '''
 
+    # u,v coordinates
     u = Q_coords_kpt.iloc[:,0]
     v = Q_coords_kpt.iloc[:,1]
+    cu = cam_width / 2
+    cv = cam_height / 2
 
-    X = first_person_height / height_px * ((u-cx) + (v-cy)*np.sin(floor_angle))
-    Y = - first_person_height / height_px * np.cos(floor_angle) * (v-cy - np.tan(floor_angle)*(u-cx))
-
+    # Normative Z coordinates
     marker_name = Q_coords_kpt.columns[0]
     if 'marker_Z_positions' in globals() and visible_side!='none' and marker_name in marker_Z_positions[visible_side].keys():
-        Z = X.copy()
+        Z = u.copy()
         Z[:] = marker_Z_positions[visible_side][marker_name]
     else:
-        Z = np.zeros_like(X)
-
+        Z = np.zeros_like(u)
+
+    ## Compute X and Y coordinates in meters
+    # X =   first_person_height / height_px * (u-cu)
+    # Y = - first_person_height / height_px * (v-cv)
+    ## With floor angle and level correction:
+    # X =   first_person_height / height_px * ((u-cx)*np.cos(floor_angle) + (v-cy)*np.sin(floor_angle))
+    # Y = - first_person_height / height_px * ((v-cy)*np.cos(floor_angle) + (u-cx)*np.sin(floor_angle))
+    ## With floor angle and level correction, and depth perspective correction:
+    scaling_factor = first_person_height / height_px
+    X = scaling_factor * ( \
+            ((u-cx) - Z/distance_m * (u-cu)) * np.cos(floor_angle) + \
+            ((v-cy) - Z/distance_m * (v-cv)) * np.sin(floor_angle) )
+    Y = - scaling_factor * ( \
+            ((v-cy) - Z/distance_m * (v-cv)) * np.cos(floor_angle) - \
+            ((u-cx) - Z/distance_m * (u-cu)) * np.sin(floor_angle) )
+
+    # Assemble results
     Q_coords_kpt_m = pd.DataFrame(np.array([X, Y, Z]).T, columns=Q_coords_kpt.columns)
 
     return Q_coords_kpt_m
@@ -1414,7 +1591,7 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
     
     # Base parameters
     video_dir = Path(config_dict.get('base').get('video_dir'))
-
+    
     nb_persons_to_detect = config_dict.get('base').get('nb_persons_to_detect')
     if nb_persons_to_detect != 'all': 
         try:
@@ -1455,8 +1632,9 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
     pose_model = config_dict.get('pose').get('pose_model')
     mode = config_dict.get('pose').get('mode')
     det_frequency = config_dict.get('pose').get('det_frequency')
+    backend = config_dict.get('pose').get('backend')
+    device = config_dict.get('pose').get('device')
     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')
@@ -1468,39 +1646,39 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
             deepsort_params = json.loads(deepsort_params)
         deepsort_tracker = DeepSort(**deepsort_params)
         deepsort_tracker.tracker.tracks.clear()
-    backend = config_dict.get('pose').get('backend')
-    device = config_dict.get('pose').get('device')
-    
+
+    keypoint_likelihood_threshold = config_dict.get('pose').get('keypoint_likelihood_threshold')
+    average_likelihood_threshold = config_dict.get('pose').get('average_likelihood_threshold')
+    keypoint_number_threshold = config_dict.get('pose').get('keypoint_number_threshold')
+    max_distance = config_dict.get('pose').get('max_distance', None)
+
     # Pixel to meters conversion
     to_meters = config_dict.get('px_to_meters_conversion').get('to_meters')
     make_c3d = config_dict.get('px_to_meters_conversion').get('make_c3d')
     save_calib = config_dict.get('px_to_meters_conversion').get('save_calib')
+    # Correct perspective effects
+    perspective_value = config_dict.get('px_to_meters_conversion', {}).get('perspective_value', 10.0)
+    perspective_unit = config_dict.get('px_to_meters_conversion', {}).get('perspective_unit', 'distance_m')
+    # Calibration from person height
+    floor_angle = config_dict.get('px_to_meters_conversion').get('floor_angle', 'auto') # 'auto' or float
+    xy_origin = config_dict.get('px_to_meters_conversion').get('xy_origin', ['auto']) # ['auto'] or [x, y]    
     # Calibration from file
     calib_file = config_dict.get('px_to_meters_conversion').get('calib_file')
     if calib_file == '': 
         calib_file = None
     else: 
-        calib_file = video_dir / calib_file
+        calib_file = Path(calib_file).resolve()
         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
-    xy_origin = config_dict.get('px_to_meters_conversion').get('xy_origin') # ['auto'] or [x, y]    
-    xy_origin = [float(o) for o in xy_origin] if xy_origin != ['auto'] else 'auto'
-
-    keypoint_likelihood_threshold = config_dict.get('pose').get('keypoint_likelihood_threshold')
-    average_likelihood_threshold = config_dict.get('pose').get('average_likelihood_threshold')
-    keypoint_number_threshold = config_dict.get('pose').get('keypoint_number_threshold')
 
     # Angles advanced settings
+    display_angle_values_on = config_dict.get('angles').get('display_angle_values_on')
+    fontSize = config_dict.get('angles').get('fontSize')
+    thickness = 1 if fontSize < 0.8 else 2
     joint_angle_names = config_dict.get('angles').get('joint_angles')
     segment_angle_names = config_dict.get('angles').get('segment_angles')
     angle_names = joint_angle_names + segment_angle_names
     angle_names = [angle_name.lower() for angle_name in angle_names]
-    display_angle_values_on = config_dict.get('angles').get('display_angle_values_on')
-    fontSize = config_dict.get('angles').get('fontSize')
-    thickness = 1 if fontSize < 0.8 else 2
     flip_left_right = config_dict.get('angles').get('flip_left_right')
     correct_segment_angles_with_floor_angle = config_dict.get('angles').get('correct_segment_angles_with_floor_angle')
 
@@ -1660,6 +1838,7 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
         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')
+        kpt_id_max = max(keypoints_ids)+1
 
         # Set up pose tracker
         try:
@@ -1672,7 +1851,7 @@ 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.')
-        logging.info(f'Persons are detected every {det_frequency} frames and tracked inbetween. Tracking is done with {tracking_mode}.')
+        logging.info(f'Persons detection is run every {det_frequency} frames (pose estimation is run at every frame). Tracking is done with {tracking_mode}.')
         
         if tracking_mode == 'deepsort': 
             logging.info(f'Deepsort parameters: {deepsort_params}.')
@@ -1748,60 +1927,64 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                 if video_file == "webcam":
                     out_vid.write(frame)
 
-                # Detect poses
-                keypoints, scores = pose_tracker(frame)
-
-                # Non maximum suppression (at pose level, not detection, and only using likely keypoints)
-                frame_shape = frame.shape
-                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, 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()
+                try: # Frames with no detection cause errors on MacOS CoreMLExecutionProvider
+                    # Detect poses
+                    keypoints, scores = pose_tracker(frame)
+
+                    # Non maximum suppression (at pose level, not detection, and only using likely keypoints)
+                    frame_shape = frame.shape
+                    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, 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()
+                except:
+                    keypoints = np.full((1,kpt_id_max,2), fill_value=np.nan)
+                    scores = np.full((1,kpt_id_max), fill_value=np.nan)
             
             # Process coordinates and compute angles
             valid_X, valid_Y, valid_scores = [], [], []
@@ -1893,6 +2076,10 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                 if (cv2.waitKey(1) & 0xFF) == ord('q') or (cv2.waitKey(1) & 0xFF) == 27:
                     break
 
+                # # Debugging
+                # img_output_path = img_output_dir / f'{video_file_stem}_frame{frame_nb:06d}.png'
+                # cv2.imwrite(str(img_output_path), img)
+
             all_frames_X.append(np.array(valid_X))
             all_frames_X_flipped.append(np.array(valid_X_flipped))
             all_frames_Y.append(np.array(valid_Y))
@@ -2095,12 +2282,20 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
             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')
+                    if show_plots:
+                        for n, f in enumerate(pw.figure_handles):
+                            dpi = pw.canvases[n].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')
+                    else: # Tabbed plots not used
+                        for title, f in pw:
+                            dpi = f.dpi
+                            f.set_size_inches(1280/dpi, 720/dpi)
+                            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')
+                            plt.close(f)
                     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
@@ -2112,102 +2307,99 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
         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:
-                calib_params_dict = retrieve_calib_params(calib_file)
-
-                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
+            # Compute distance from camera to compensate for perspective effects
+            distance_m = get_distance_from_camera(perspective_value=perspective_value, perspective_unit=perspective_unit, 
+                                                  calib_file=calib_file, height_px=height_px, height_m=first_person_height, 
+                                                  cam_width=cam_width, cam_height=cam_height)
+
+            # Compute floor angle and xy_origin to compensate for camera horizon and person position
+            floor_angle_estim, xy_origin_estim, gait_direction = get_floor_params(floor_angle=floor_angle, xy_origin=xy_origin, 
+                                                    calib_file=calib_file, height_px=height_px, height_m=first_person_height, 
+                                                    fps=fps, trc_data=trc_data[0], score_data=score_data[0], toe_speed_below=1, score_threshold=average_likelihood_threshold, 
+                                                    cam_width=cam_width, cam_height=cam_height)
+            cx, cy = xy_origin_estim
+            direction_person0 = 'right' if gait_direction > 0.3 \
+                                else 'left' if gait_direction < -0.3 \
+                                else 'front'
+
+            logging.info(f'Converting from pixels to meters using a person height of {first_person_height:.2f} in meters (manual input), and of {height_px:.2f} in pixels (calculated).')
+
+            perspective_messages = {
+                "distance_m": f"(obtained from a manual input).",
+                "f_px": f"(calculated from a focal length of {perspective_value:.2f} m).",
+                "fov_deg": f"(calculated from a field of view of {perspective_value:.2f} deg).",
+                "fov_rad": f"(calculated from a field of view of {perspective_value:.2f} rad).",
+                "from_calib": f"(calculated from a calibration file: {calib_file}).",
+            }
+            message = perspective_messages.get(perspective_unit, "")
+            logging.info(f'Perspective effects corrected using a camera-to-person distance of {distance_m:.2f} m {message}')
+
+            floor_angle_messages = {
+                "manual": "manual input.",
+                "auto": "gait kinematics.",
+                "from_kinematics": "gait kinematics.",
+                "from_calib": "a calibration file.",
+            }
+            if isinstance(floor_angle, (int, float)):
+                key = "manual"
             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
-                if floor_angle == 'auto' or xy_origin == 'auto':
-                    # 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], 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], 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
-                        logging.warning(f'Could not estimate the floor angle and xy_origin from person {0}. Make sure that the full body is visible. Using floor angle = 0° and xy_origin = [{cam_width/2}, {cam_height/2}] px.')
-                if not floor_angle == 'auto':
-                    floor_angle_estim = floor_angle
-                if xy_origin == 'auto':
-                    cx, cy = xy_origin_estim
+                key = floor_angle
+            message = floor_angle_messages.get(key, "")
+            logging.info(f'Camera horizon: {np.degrees(floor_angle_estim):.2f}°, corrected using {message}')
+
+            def get_correction_message(xy_origin):
+                if all(isinstance(o, (int, float)) for o in xy_origin) and len(xy_origin) == 2:
+                    return "manual input."
+                elif xy_origin == ["auto"] or xy_origin == ["from_kinematics"]:
+                    return "gait kinematics."
+                elif xy_origin == ["from_calib"]:
+                    return "a calibration file."
                 else:
-                    cx, cy = xy_origin
-                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()
+                    return "."
+            message = get_correction_message(xy_origin)
+            logging.info(f'Floor level: {cy:.2f} px (from the top of the image), gait starting at {cx:.2f} px in the {direction_person0} direction for the first person. Corrected using {message}\n')
+
+            # Prepare calibration data
+            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]])
+            
+            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 * distance_m
+            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*distance_m, -distance_m, (cy-cv)/f*distance_m])
+            
+            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}.')
+            # Save calibration file
+            if save_calib and not calib_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
@@ -2220,9 +2412,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], score_data[0], keypoint_names=['LBigToe', 'RBigToe'], toe_speed_below=toe_speed_below_px_frame, score_threshold=average_likelihood_threshold)
+                                _, _, gait_direction = compute_floor_line(trc_data[i], score_data[i], keypoint_names=['LBigToe', 'RBigToe'], score_threshold=keypoint_likelihood_threshold) # toe_speed_below=1 bu default 
                             else:
-                                _, _, 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)
+                                _, _, gait_direction = compute_floor_line(trc_data[i], score_data[i], keypoint_names=['LAnkle', 'RAnkle'], score_threshold=keypoint_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 \
@@ -2237,8 +2429,9 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                     else:
                         logging.info(f'- Person {i}: Seen from the {visible_side_i}.')
                     
+
                     # 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]
+                    px_to_m_i = [convert_px_to_meters(trc_data[i][kpt_name], first_person_height, height_px, distance_m, cam_width, cam_height, 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_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]
@@ -2247,18 +2440,26 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                         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()
                     first_trim, last_trim = trc_data_m_i.isnull().any(axis=1).idxmin(), trc_data_m_i[::-1].isnull().any(axis=1).idxmin()
                     trc_data_m_i = trc_data_m_i.iloc[first_trim:last_trim+1,:]
-                    px_to_m_unfiltered_i = [convert_px_to_meters(trc_data_unfiltered[i][kpt_name], first_person_height, height_px, cx, cy, -floor_angle_estim) for kpt_name in new_keypoints_names]
+                    px_to_m_unfiltered_i = [convert_px_to_meters(trc_data_unfiltered[i][kpt_name], first_person_height, height_px, distance_m, cam_width, cam_height, cx, cy, -floor_angle_estim, visible_side=visible_side_i) for kpt_name in new_keypoints_names]
                     trc_data_unfiltered_m_i = pd.concat([all_frames_time.rename('time')]+px_to_m_unfiltered_i, axis=1)
 
                     if to_meters and (show_plots or save_plots):
                         pw = pose_plots(trc_data_unfiltered_m_i, trc_data_m_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_m.stem + f'_person{i:02d}_m_{title.replace(" ","_").replace("/","_")}.png')
-                                f.savefig(plot_path, dpi=dpi, bbox_inches='tight')
+                            if show_plots:
+                                for n, f in enumerate(pw.figure_handles):
+                                    dpi = pw.canvases[n].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}_m_{title.replace(" ","_").replace("/","_")}.png')
+                                    f.savefig(plot_path, dpi=dpi, bbox_inches='tight')
+                            else: # Tabbed plots not used
+                                for title, f in pw:
+                                    dpi = f.dpi
+                                    f.set_size_inches(1280/dpi, 720/dpi)
+                                    plot_path = plots_output_dir / (pose_output_path.stem + f'_person{i:02d}_m_{title.replace(" ","_").replace("/","_")}.png')
+                                    f.savefig(plot_path, dpi=dpi, bbox_inches='tight')
+                                    plt.close(f)
                             logging.info(f'Pose plots (m) saved in {plots_output_dir}.')
 
                     # Write to trc file
@@ -2389,12 +2590,20 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
             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)
-                        title = pw.tabs.tabText(n)
-                        plot_path = plots_output_dir / (pose_output_path_m.stem + f'_person{i:02d}_ang_{title.replace(" ","_").replace("/","_")}.png')
-                        f.savefig(plot_path, dpi=dpi, bbox_inches='tight')
+                    if show_plots:
+                        for n, f in enumerate(pw.figure_handles):
+                            dpi = pw.canvases[n].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}_ang_{title.replace(" ","_").replace("/","_")}.png')
+                            f.savefig(plot_path, dpi=dpi, bbox_inches='tight')
+                    else: # Tabbed plots not used
+                        for title, f in pw:
+                            dpi = f.dpi
+                            f.set_size_inches(1280/dpi, 720/dpi)
+                            plot_path = plots_output_dir / (pose_output_path.stem + f'_person{i:02d}_ang_{title.replace(" ","_").replace("/","_")}.png')
+                            f.savefig(plot_path, dpi=dpi, bbox_inches='tight')
+                            plt.close(f)
                     logging.info(f'Pose plots (m) saved in {plots_output_dir}.')
 
 
@@ -2531,7 +2740,7 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                         if (mot_file.parent/(mot_file.stem+'_ik.mot')).exists():
                             os.remove(mot_file.parent/(mot_file.stem+'_ik.mot'))
                         os.rename(mot_file, mot_file.parent/(mot_file.stem+'_ik.mot'))
-                    logging.info(f'.osim model and .mot motion file results saved to {kinematics_dir.resolve()}.\n')
+                    logging.info(f'.osim model and .mot motion file results saved to {kinematics_dir.resolve().parent}.\n')
                             
             # Move all files in pose-3d and kinematics to the output_dir
             osim.Logger.removeFileSink()