sports2d 0.8.25__py3-none-any.whl → 0.8.27__py3-none-any.whl

Sports2D/process.py

@@ -75,29 +75,32 @@ import matplotlib as mpl
 import matplotlib.pyplot as plt
 from matplotlib.widgets import Slider, Button
 from matplotlib import patheffects
-
-from rtmlib import PoseTracker, BodyWithFeet, Wholebody, Body, Hand, Custom
 from rtmlib.tools.object_detection.post_processings import nms
 
 from Sports2D.Utilities.common import *
 from Pose2Sim.common import *
 from Pose2Sim.skeletons import *
 from Pose2Sim.calibration import toml_write
+from Pose2Sim.poseEstimation import setup_model_class_mode, setup_backend_device, setup_pose_tracker
 from Pose2Sim.triangulation import indices_of_first_last_non_nan_chunks
 from Pose2Sim.personAssociation import *
 from Pose2Sim.filtering import *
 
-# Silence numpy "RuntimeWarning: Mean of empty slice"
-import warnings
+os.environ['KMP_DUPLICATE_LIB_OK'] = 'TRUE'
+np.set_printoptions(legacy='1.21') # otherwise prints np.float64(3.0) rather than 3.0
+import warnings # Silence numpy and CoreML 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")
+warnings.filterwarnings("ignore", message=".*Input.*has a dynamic shape.*but the runtime shape.*has zero elements.*")
+
 
 # Not safe, but to be used until OpenMMLab/RTMlib's SSL certificates are updated
 import ssl
 ssl._create_default_https_context = ssl._create_unverified_context
 
 
+CORRECTION_2D_TO_3D = 1.063  # Corrective factor for height calculation: segments do not perfectly lie in the 2D plane and look shorter than in 3D
 DEFAULT_MASS = 70
 DEFAULT_HEIGHT = 1.7
 
@@ -206,165 +209,6 @@ def setup_video(video_file_path, vid_output_path, save_vid):
     return cap, out_vid, cam_width, cam_height, fps
 
 
-def setup_model_class_mode(pose_model, mode, config_dict={}):
-    '''
-    Set up the pose model class and mode for the pose tracker.
-    '''
-
-    if pose_model.upper() in ('HALPE_26', 'BODY_WITH_FEET'):
-        model_name = 'HALPE_26'
-        ModelClass = BodyWithFeet # 26 keypoints(halpe26)
-        logging.info(f"Using HALPE_26 model (body and feet) for pose estimation in {mode} mode.")
-    elif pose_model.upper() in ('COCO_133', 'WHOLE_BODY', 'WHOLE_BODY_WRIST'):
-        model_name = 'COCO_133'
-        ModelClass = Wholebody
-        logging.info(f"Using COCO_133 model (body, feet, hands, and face) for pose estimation in {mode} mode.")
-    elif pose_model.upper() in ('COCO_17', 'BODY'):
-        model_name = 'COCO_17'
-        ModelClass = Body
-        logging.info(f"Using COCO_17 model (body) for pose estimation in {mode} mode.")
-    elif pose_model.upper() =='HAND':
-        model_name = 'HAND_21'
-        ModelClass = Hand
-        logging.info(f"Using HAND_21 model for pose estimation in {mode} mode.")
-    elif pose_model.upper() =='FACE':
-        model_name = 'FACE_106'
-        logging.info(f"Using FACE_106 model for pose estimation in {mode} mode.")
-    elif pose_model.upper() =='ANIMAL':
-        model_name = 'ANIMAL2D_17'
-        logging.info(f"Using ANIMAL2D_17 model for pose estimation in {mode} mode.")
-    else:
-        model_name = pose_model.upper()
-        logging.info(f"Using model {model_name} for pose estimation in {mode} mode.")
-    try:
-        pose_model = eval(model_name)
-    except:
-        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))
-            if pose_model.id == 'None':
-                pose_model.id = None
-            logging.info(f"Using model {model_name} for pose estimation.")
-        except:
-            raise NameError(f'{pose_model} not found in skeletons.py nor in Config.toml')
-
-    # Manually select the models if mode is a dictionary rather than 'lightweight', 'balanced', or 'performance'
-    if not mode in ['lightweight', 'balanced', 'performance'] or 'ModelClass' not in locals():
-        try:
-            from functools import partial
-            try:
-                mode = ast.literal_eval(mode)
-            except: # if within single quotes instead of double quotes when run with sports2d --mode """{dictionary}"""
-                mode = mode.strip("'").replace('\n', '').replace(" ", "").replace(",", '", "').replace(":", '":"').replace("{", '{"').replace("}", '"}').replace('":"/',':/').replace('":"\\',':\\')
-                mode = re.sub(r'"\[([^"]+)",\s?"([^"]+)\]"', r'[\1,\2]', mode) # changes "[640", "640]" to [640,640]
-                mode = json.loads(mode)
-            det_class = mode.get('det_class')
-            det = mode.get('det_model')
-            det_input_size = mode.get('det_input_size')
-            pose_class = mode.get('pose_class')
-            pose = mode.get('pose_model')
-            pose_input_size = mode.get('pose_input_size')
-
-            ModelClass = partial(Custom,
-                        det_class=det_class, det=det, det_input_size=det_input_size,
-                        pose_class=pose_class, pose=pose, pose_input_size=pose_input_size)
-            logging.info(f"Using model {model_name} with the following custom parameters: {mode}.")
-
-            if pose_class == 'RTMO' and model_name != 'COCO_17':
-                logging.warning("RTMO currently only supports 'Body' pose_model. Switching to 'Body'.")
-                pose_model = eval('COCO_17')
-            
-        except (json.JSONDecodeError, TypeError):
-            logging.warning("Invalid mode. Must be 'lightweight', 'balanced', 'performance', or '''{dictionary}''' of parameters within triple quotes. Make sure input_sizes are within square brackets.")
-            logging.warning('Using the default "balanced" mode.')
-            mode = 'balanced'
-
-    return pose_model, ModelClass, mode
-
-
-def setup_backend_device(backend='auto', device='auto'):
-    '''
-    Set up the backend and device for the pose tracker based on the availability of hardware acceleration.
-    TensorRT is not supported by RTMLib yet: https://github.com/Tau-J/rtmlib/issues/12
-
-    If device and backend are not specified, they are automatically set up in the following order of priority:
-    1. GPU with CUDA and ONNXRuntime backend (if CUDAExecutionProvider is available)
-    2. GPU with ROCm and ONNXRuntime backend (if ROCMExecutionProvider is available, for AMD GPUs)
-    3. GPU with MPS or CoreML and ONNXRuntime backend (for macOS systems)
-    4. CPU with OpenVINO backend (default fallback)
-    '''
-
-    if device!='auto' and backend!='auto':
-        device = device.lower()
-        backend = backend.lower()
-
-    if device=='auto' or backend=='auto':
-        if device=='auto' and backend!='auto' or device!='auto' and backend=='auto':
-            logging.warning(f"If you set device or backend to 'auto', you must set the other to 'auto' as well. Both device and backend will be determined automatically.")
-
-        try:
-            import torch
-            import onnxruntime as ort
-            if torch.cuda.is_available() == True and 'CUDAExecutionProvider' in ort.get_available_providers():
-                device = 'cuda'
-                backend = 'onnxruntime'
-                logging.info(f"\nValid CUDA installation found: using ONNXRuntime backend with GPU.")
-            elif torch.cuda.is_available() == True and 'ROCMExecutionProvider' in ort.get_available_providers():
-                device = 'rocm'
-                backend = 'onnxruntime'
-                logging.info(f"\nValid ROCM installation found: using ONNXRuntime backend with GPU.")
-            else:
-                raise 
-        except:
-            try:
-                import onnxruntime as ort
-                if 'MPSExecutionProvider' in ort.get_available_providers() or 'CoreMLExecutionProvider' in ort.get_available_providers():
-                    device = 'mps'
-                    backend = 'onnxruntime'
-                    logging.info(f"\nValid MPS installation found: using ONNXRuntime backend with GPU.")
-                else:
-                    raise
-            except:
-                device = 'cpu'
-                backend = 'openvino'
-                logging.info(f"\nNo valid CUDA installation found: using OpenVINO backend with CPU.")
-        
-    return backend, device
-
-
-def setup_pose_tracker(ModelClass, det_frequency, mode, tracking, backend, device):
-    '''
-    Set up the RTMLib pose tracker with the appropriate model and backend.
-    If CUDA is available, use it with ONNXRuntime backend; else use CPU with openvino
-
-    INPUTS:
-    - ModelClass: class. The RTMlib model class to use for pose detection (Body, BodyWithFeet, Wholebody)
-    - det_frequency: int. The frequency of pose detection (every N frames)
-    - mode: str. The mode of the pose tracker ('lightweight', 'balanced', 'performance')
-    - tracking: bool. Whether to track persons across frames with RTMlib tracker
-    - backend: str. The backend to use for pose detection (onnxruntime, openvino, opencv)
-    - device: str. The device to use for pose detection (cpu, cuda, rocm, mps)
-
-    OUTPUTS:
-    - pose_tracker: PoseTracker. The initialized pose tracker object    
-    '''
-
-    backend, device = setup_backend_device(backend=backend, device=device)
-
-    # Initialize the pose tracker with Halpe26 model
-    pose_tracker = PoseTracker(
-        ModelClass,
-        det_frequency=det_frequency,
-        mode=mode,
-        backend=backend,
-        device=device,
-        tracking=tracking,
-        to_openpose=False)
-        
-    return pose_tracker
-
-
 def flip_left_right_direction(person_X, L_R_direction_idx, keypoints_names, keypoints_ids):
     '''
     Flip the points to the right or left for more consistent angle calculation 
@@ -798,7 +642,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
@@ -809,23 +652,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')
@@ -840,18 +686,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
@@ -862,21 +711,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')
@@ -886,12 +738,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):
@@ -1306,7 +1162,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
@@ -1450,7 +1306,8 @@ def get_floor_params(floor_angle='auto', xy_origin=['auto'],
     except:
         floor_angle_kin = 0
         xy_origin_kin = 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.')
+        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':
@@ -1578,7 +1435,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:
@@ -1825,6 +1682,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:
@@ -1913,60 +1771,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 = [], [], []
@@ -2058,6 +1920,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))
@@ -2260,12 +2126,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
@@ -2278,8 +2152,8 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
         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,
+            # Compute height of the first person in pixels
+            height_px = CORRECTION_2D_TO_3D * 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)
 
             # Compute distance from camera to compensate for perspective effects
@@ -2334,41 +2208,40 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
             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()
 
             # Save calibration file
             if save_calib and not 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]])
-                
-                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}.')
 
@@ -2417,12 +2290,20 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                     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
@@ -2553,12 +2434,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}.')