sports2d 0.7.0__py3-none-any.whl → 0.7.3__py3-none-any.whl

Sports2D/Demo/Config_demo.toml

@@ -89,7 +89,7 @@ det_frequency = 4       # Run person detection only every N frames, and inbetwee
                         # Equal to or greater than 1, can be as high as you want in simple uncrowded cases. Much faster, but might be less accurate. 
 device = 'auto' # 'auto', 'CPU', 'CUDA', 'MPS', 'ROCM'
 backend = 'auto' # 'auto', 'openvino', 'onnxruntime', 'opencv'
-tracking_mode = 'sports2d' # 'sports2d' or 'deepsort'. 'deepsort' is slower but more robust in difficult configurations
+tracking_mode = 'sports2d' # 'sports2d' or 'deepsort'. 'deepsort' is slower, harder to parametrize but can be more robust if correctly tuned
 # deepsort_params = """{'max_age':30, 'n_init':3, 'max_cosine_distance':0.3, 'max_iou_distance':0.8, 'embedder_gpu': True, embedder':'torchreid'}""" # """{dictionary between 3 double quotes}"""
                   # More robust in crowded scenes but tricky to parametrize. More information there: https://github.com/levan92/deep_sort_realtime/blob/master/deep_sort_realtime/deepsort_tracker.py#L51
                   # Requires `pip install torch torchvision torchreid gdown tensorboard`
@@ -151,8 +151,8 @@ filter_type = 'butterworth'   # butterworth, gaussian, LOESS, median
 
 
 [kinematics]
-do_ik = true # Do scaling and inverse kinematics?
-use_augmentation = true  # true or false (lowercase) # Set to true if you want to use the model with augmented markers
+do_ik = false # Do scaling and inverse kinematics?
+use_augmentation = false  # true or false (lowercase) # Set to true if you want to use the model with augmented markers
 use_contacts_muscles = true # true or false (lowercase) # If true, contact spheres and muscles are added to the model
 participant_mass = [67.0, 55.0] # kg # defaults to 70 if not provided. No influence on kinematics (motion), only on kinetics (forces)
 right_left_symmetry = true # true or false (lowercase) # Set to false only if you have good reasons to think the participant is not symmetrical (e.g. prosthetic limb)

Sports2D/Sports2D.py

@@ -109,6 +109,7 @@
 
 
 ## INIT
+from importlib.metadata import version
 import argparse
 import toml
 from datetime import datetime
@@ -261,7 +262,7 @@ CONFIG_HELP =   {'config': ["C", "path to a toml configuration file"],
                 'participant_mass': ["", "mass of the participant in kg or none. Defaults to 70 if not provided. No influence on kinematics (motion), only on kinetics (forces)"],
                 'close_to_zero_speed_m': ["","Sum for all keypoints: about 50 px/frame or 0.2 m/frame"], 
                 'multiperson': ["", "multiperson involves tracking: will be faster if set to false. true if not specified"],
-                'tracking_mode': ["", "sports2d or rtmlib. sports2d is generally much more accurate and comparable in speed. sports2d if not specified"],
+                'tracking_mode': ["", "'sports2d' or 'deepsort'. 'deepsort' is slower, harder to parametrize but can be more robust if correctly tuned"],
                 'deepsort_params': ["", 'Deepsort tracking parameters: """{dictionary between 3 double quotes}""". \n\
                                     Default: max_age:30, n_init:3, nms_max_overlap:0.8, max_cosine_distance:0.3, nn_budget:200, max_iou_distance:0.8, embedder_gpu: True\n\
                                     More information there: https://github.com/levan92/deep_sort_realtime/blob/master/deep_sort_realtime/deepsort_tracker.py#L51'],
@@ -301,7 +302,7 @@ __author__ = "David Pagnon"
 __copyright__ = "Copyright 2023, Sports2D"
 __credits__ = ["David Pagnon"]
 __license__ = "BSD 3-Clause License"
-__version__ = "0.4.0"
+__version__ = version("sports2d")
 __maintainer__ = "David Pagnon"
 __email__ = "contact@david-pagnon.com"
 __status__ = "Development"

Sports2D/Utilities/__init__.py

@@ -2,6 +2,7 @@
 # -*- coding: utf-8 -*-
 
 import sys
+from importlib.metadata import version
 
-__version__ = "0.4.0"
+__version__ = version("sports2d")
 VERSION = __version__

Sports2D/Utilities/common.py

@@ -15,27 +15,14 @@
 
 
 ## INIT
-import re
 import sys
-import toml
+from importlib.metadata import version
 import subprocess
 from pathlib import Path
-import itertools as it
 import logging
 from collections import defaultdict
-from anytree import PreOrderIter
-
 import numpy as np
-import pandas as pd
-from scipy import interpolate
 import imageio_ffmpeg as ffmpeg
-import cv2
-import c3d
-
-import matplotlib.pyplot as plt
-from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
-from matplotlib.backends.backend_qt5agg import NavigationToolbar2QT as NavigationToolbar
-from PyQt5.QtWidgets import QMainWindow, QApplication, QWidget, QTabWidget, QVBoxLayout
 
 
 ## AUTHORSHIP INFORMATION
@@ -43,7 +30,7 @@ __author__ = "David Pagnon"
 __copyright__ = "Copyright 2023, Sports2D"
 __credits__ = ["David Pagnon"]
 __license__ = "BSD 3-Clause License"
-__version__ = "0.4.0"
+__version__ = version("sports2d")
 __maintainer__ = "David Pagnon"
 __email__ = "contact@david-pagnon.com"
 __status__ = "Development"
@@ -118,58 +105,6 @@ colors = [(255, 0, 0), (0, 0, 255), (255, 255, 0), (255, 0, 255), (0, 255, 255),
             (255, 0, 125), (255, 125, 0), (0, 125, 255), (0, 255, 125), (125, 0, 255), (125, 255, 0), (0, 255, 0)]
 thickness = 1
 
-## CLASSES
-class plotWindow():
-    '''
-    Display several figures in tabs
-    Taken from https://github.com/superjax/plotWindow/blob/master/plotWindow.py
-
-    USAGE:
-    pw = plotWindow()
-    f = plt.figure()
-    plt.plot(x1, y1)
-    pw.addPlot("1", f)
-    f = plt.figure()
-    plt.plot(x2, y2)
-    pw.addPlot("2", f)
-    '''
-    def __init__(self, parent=None):
-        self.app = QApplication.instance()
-        if not self.app:
-            self.app = QApplication(sys.argv)
-        self.MainWindow = QMainWindow()
-        self.MainWindow.setWindowTitle("Multitabs figure")
-        self.canvases = []
-        self.figure_handles = []
-        self.toolbar_handles = []
-        self.tab_handles = []
-        self.current_window = -1
-        self.tabs = QTabWidget()
-        self.MainWindow.setCentralWidget(self.tabs)
-        self.MainWindow.resize(1280, 720)
-        self.MainWindow.show()
-
-    def addPlot(self, title, figure):
-        new_tab = QWidget()
-        layout = QVBoxLayout()
-        new_tab.setLayout(layout)
-
-        figure.subplots_adjust(left=0.1, right=0.99, bottom=0.1, top=0.91, wspace=0.2, hspace=0.2)
-        new_canvas = FigureCanvas(figure)
-        new_toolbar = NavigationToolbar(new_canvas, new_tab)
-
-        layout.addWidget(new_canvas)
-        layout.addWidget(new_toolbar)
-        self.tabs.addTab(new_tab, title)
-
-        self.toolbar_handles.append(new_toolbar)
-        self.canvases.append(new_canvas)
-        self.figure_handles.append(figure)
-        self.tab_handles.append(new_tab)
-
-    def show(self):
-        self.app.exec_()
-        
 ## FUNCTIONS
 def to_dict(d):
     '''
@@ -180,164 +115,6 @@ def to_dict(d):
     return d
 
 
-def read_trc(trc_path):
-    '''
-    Read a TRC file and extract its contents.
-
-    INPUTS:
-    - trc_path (str): The path to the TRC file.
-
-    OUTPUTS:
-    - tuple: A tuple containing the Q coordinates, frames column, time column, marker names, and header.
-    '''
-
-    try:
-        with open(trc_path, 'r') as trc_file:
-            header = [next(trc_file) for _ in range(5)]
-        markers = header[3].split('\t')[2::3]
-        markers = [m.strip() for m in markers if m.strip()] # remove last \n character
-       
-        trc_df = pd.read_csv(trc_path, sep="\t", skiprows=4, encoding='utf-8')
-        frames_col, time_col = trc_df.iloc[:, 0], trc_df.iloc[:, 1]
-        Q_coords = trc_df.drop(trc_df.columns[[0, 1]], axis=1)
-        Q_coords = Q_coords.loc[:, ~Q_coords.columns.str.startswith('Unnamed')] # remove unnamed columns
-        Q_coords.columns = np.array([[m,m,m] for m in markers]).ravel().tolist()
-
-        return Q_coords, frames_col, time_col, markers, header
-    
-    except Exception as e:
-        raise ValueError(f"Error reading TRC file at {trc_path}: {e}")
-
-
-def extract_trc_data(trc_path):
-    '''
-    Extract marker names and coordinates from a trc file.
-
-    INPUTS:
-    - trc_path: Path to the trc file
-
-    OUTPUTS:
-    - marker_names: List of marker names
-    - marker_coords: Array of marker coordinates (n_frames, t+3*n_markers)
-    '''
-
-    # marker names
-    with open(trc_path, 'r') as file:
-        lines = file.readlines()
-        marker_names_line = lines[3]
-        marker_names = marker_names_line.strip().split('\t')[2::3]
-
-    # time and marker coordinates
-    trc_data_np = np.genfromtxt(trc_path, skip_header=5, delimiter = '\t')[:,1:] 
-
-    return marker_names, trc_data_np
-
-
-def create_c3d_file(c3d_path, marker_names, trc_data_np):
-    '''
-    Create a c3d file from the data extracted from a trc file.
-
-    INPUTS:
-    - c3d_path: Path to the c3d file
-    - marker_names: List of marker names
-    - trc_data_np: Array of marker coordinates (n_frames, t+3*n_markers)
-
-    OUTPUTS:
-    - c3d file
-    '''
-
-    # retrieve frame rate
-    times = trc_data_np[:,0]
-    frame_rate = round((len(times)-1) / (times[-1] - times[0]))
-
-    # write c3d file
-    writer = c3d.Writer(point_rate=frame_rate, analog_rate=0, point_scale=1.0, point_units='mm', gen_scale=-1.0)
-    writer.set_point_labels(marker_names)
-    writer.set_screen_axis(X='+Z', Y='+Y')
-    
-    for frame in trc_data_np:
-        residuals = np.full((len(marker_names), 1), 0.0)
-        cameras = np.zeros((len(marker_names), 1))
-        coords = frame[1:].reshape(-1,3)*1000
-        points = np.hstack((coords, residuals, cameras))
-        writer.add_frames([(points, np.array([]))])
-
-    writer.set_start_frame(0)
-    writer._set_last_frame(len(trc_data_np)-1)
-
-    with open(c3d_path, 'wb') as handle:
-        writer.write(handle)
-
-
-def convert_to_c3d(trc_path):
-    '''
-    Make Visual3D compatible c3d files from a trc path
-
-    INPUT:
-    - trc_path: string, trc file to convert
-
-    OUTPUT:
-    - c3d file
-    '''
-
-    trc_path = str(trc_path)
-    c3d_path = trc_path.replace('.trc', '.c3d')
-    marker_names, trc_data_np = extract_trc_data(trc_path)
-    create_c3d_file(c3d_path, marker_names, trc_data_np)
-
-    return c3d_path
-
-
-def interpolate_zeros_nans(col, *args):
-    '''
-    Interpolate missing points (of value zero),
-    unless more than N contiguous values are missing.
-
-    INPUTS:
-    - col: pandas column of coordinates
-    - args[0] = N: max number of contiguous bad values, above which they won't be interpolated
-    - args[1] = kind: 'linear', 'slinear', 'quadratic', 'cubic'. Default: 'cubic'
-
-    OUTPUT:
-    - col_interp: interpolated pandas column
-    '''
-
-    if len(args)==2:
-        N, kind = args
-    if len(args)==1:
-        N = np.inf
-        kind = args[0]
-    if not args:
-        N = np.inf
-    
-    # Interpolate nans
-    mask = ~(np.isnan(col) | col.eq(0)) # true where nans or zeros
-    idx_good = np.where(mask)[0]
-    if len(idx_good) <= 4:
-        return col
-    
-    if 'kind' not in locals(): # 'linear', 'slinear', 'quadratic', 'cubic'
-        f_interp = interpolate.interp1d(idx_good, col[idx_good], kind="linear", bounds_error=False)
-    else:
-        f_interp = interpolate.interp1d(idx_good, col[idx_good], kind=kind, fill_value='extrapolate', bounds_error=False)
-    col_interp = np.where(mask, col, f_interp(col.index)) #replace at false index with interpolated values
-    
-    # Reintroduce nans if length of sequence > N
-    idx_notgood = np.where(~mask)[0]
-    gaps = np.where(np.diff(idx_notgood) > 1)[0] + 1 # where the indices of true are not contiguous
-    sequences = np.split(idx_notgood, gaps)
-    if sequences[0].size>0:
-        for seq in sequences:
-            if len(seq) > N: # values to exclude from interpolation are set to false when they are too long 
-                col_interp[seq] = np.nan
-    
-    return col_interp
-
-
-def natural_sort_key(s):
-    return [int(c) if c.isdigit() else c.lower() for c in re.split(r'(\d+)', s)]
-
-
 def make_homogeneous(list_of_arrays):
     '''
     Make a list of arrays (or a list of lists) homogeneous by padding with nans
@@ -428,374 +205,6 @@ def resample_video(vid_output_path, fps, desired_framerate):
     new_vid_path.rename(vid_output_path)
 
 
-def points_to_angles(points_list):
-    '''
-    If len(points_list)==2, computes clockwise angle of ab vector w.r.t. horizontal (e.g. RBigToe, RHeel) 
-    If len(points_list)==3, computes clockwise angle from a to c around b (e.g. Neck, Hip, Knee) 
-    If len(points_list)==4, computes clockwise angle between vectors ab and cd (e.g. Neck Hip, RKnee RHip)
-    
-    Points can be 2D or 3D.
-    If parameters are float, returns a float between 0.0 and 360.0
-    If parameters are arrays, returns an array of floats between 0.0 and 360.0
-
-    INPUTS:
-    - points_list: list of arrays of points
-
-    OUTPUTS:
-    - ang_deg: float or array of floats. The angle(s) in degrees.
-    '''
-
-    if len(points_list) < 2: # if not enough points, return None
-        return np.nan
-    
-    points_array = np.array(points_list)
-    dimensions = points_array.shape[-1]
-
-    if len(points_list) == 2:
-        vector_u = points_array[0] - points_array[1]
-        if len(points_array.shape)==2:
-            vector_v = np.array([1, 0, 0]) # Here vector X, could be any horizontal vector
-        else:
-            vector_v = np.array([[1, 0, 0],] * points_array.shape[1]) 
-
-    elif len(points_list) == 3:
-        vector_u = points_array[0] - points_array[1]
-        vector_v = points_array[2] - points_array[1]
-
-    elif len(points_list) == 4:
-        vector_u = points_array[1] - points_array[0]
-        vector_v = points_array[3] - points_array[2]
-        
-    else:
-        return np.nan
-
-    if dimensions == 2: 
-        vector_u = vector_u[:2]
-        vector_v = vector_v[:2]
-        ang = np.arctan2(vector_u[1], vector_u[0]) - np.arctan2(vector_v[1], vector_v[0])
-    else:
-        cross_product = np.cross(vector_u, vector_v)
-        dot_product = np.einsum('ij,ij->i', vector_u, vector_v) # np.dot(vector_u, vector_v) # does not work with time series
-        ang = np.arctan2(np.linalg.norm(cross_product, axis=1), dot_product)
-
-    ang_deg = np.degrees(ang)
-    # ang_deg = np.array(np.degrees(np.unwrap(ang*2)/2))
-    
-    return ang_deg
-
-
-def fixed_angles(points_list, ang_name):
-    '''
-    Add offset and multiplying factor to angles
-
-    INPUTS:
-    - points_list: list of arrays of points
-    - ang_name: str. The name of the angle to consider.
-
-    OUTPUTS:
-    - ang: float. The angle in degrees.
-    '''
-
-    ang_params = angle_dict[ang_name]
-    ang = points_to_angles(points_list)
-    ang += ang_params[2]
-    ang *= ang_params[3]
-    if ang_name in ['pelvis', 'shoulders']:
-        ang = np.where(ang>90, ang-180, ang)
-        ang = np.where(ang<-90, ang+180, ang)
-    else:
-        ang = np.where(ang>180, ang-360, ang)
-        ang = np.where(ang<-180, ang+360, ang)
-
-    return ang
-
-
-def mean_angles(trc_data, ang_to_consider = ['right knee', 'left knee', 'right hip', 'left hip']):
-    '''
-    Compute the mean angle time series from 3D points for a given list of angles.
-
-    INPUTS:
-    - trc_data (DataFrame): The triangulated coordinates of the markers.
-    - ang_to_consider (list): The list of angles to consider (requires angle_dict).
-
-    OUTPUTS:
-    - ang_mean: The mean angle time series.
-    '''
-
-    ang_to_consider = ['right knee', 'left knee', 'right hip', 'left hip']
-
-    angs = []
-    for ang_name in ang_to_consider:
-        ang_params = angle_dict[ang_name]
-        ang_mk = ang_params[0]
-        if 'Neck' not in trc_data.columns:
-            df_MidShoulder = pd.DataFrame((trc_data['RShoulder'].values + trc_data['LShoulder'].values) /2)
-            df_MidShoulder.columns = ['Neck']*3
-            trc_data = pd.concat((trc_data.reset_index(drop=True), df_MidShoulder), axis=1)
-
-        pts_for_angles = []
-        for pt in ang_mk:
-            # pts_for_angles.append(trc_data.iloc[:,markers.index(pt)*3:markers.index(pt)*3+3])
-            pts_for_angles.append(trc_data[pt])
-
-        ang = fixed_angles(pts_for_angles, ang_name)
-        ang = np.abs(ang)
-        angs.append(ang)
-
-    ang_mean = np.mean(angs, axis=0)
-
-    return ang_mean
-
-
-def add_neck_hip_coords(kpt_name, p_X, p_Y, p_scores, kpt_ids, kpt_names):
-    '''
-    Add neck (midshoulder) and hip (midhip) coordinates if neck and hip are not available
-    
-    INPUTS:
-    - kpt_name: name of the keypoint to add (neck, hip)
-    - p_X: list of x coordinates after flipping if needed
-    - p_Y: list of y coordinates
-    - p_scores: list of confidence scores
-    - kpt_ids: list of keypoint ids (see skeletons.py)
-    - kpt_names: list of keypoint names (see skeletons.py)
-    
-    OUTPUTS:
-    - p_X: list of x coordinates with added missing coordinate
-    - p_Y: list of y coordinates with added missing coordinate
-    - p_scores: list of confidence scores with added missing score
-    '''
-
-    names, ids = kpt_names.copy(), kpt_ids.copy()
-    names.append(kpt_name)
-    ids.append(len(p_X))
-    if kpt_name == 'Neck':
-        mid_X = (np.abs(p_X[ids[names.index('LShoulder')]]) + np.abs(p_X[ids[names.index('RShoulder')]])) /2
-        mid_Y = (p_Y[ids[names.index('LShoulder')]] + p_Y[ids[names.index('RShoulder')]])/2
-        mid_score = (p_scores[ids[names.index('LShoulder')]] + p_scores[ids[names.index('RShoulder')]])/2
-    elif kpt_name == 'Hip':
-        mid_X = (np.abs(p_X[ids[names.index('LHip')]]) + np.abs(p_X[ids[names.index('RHip')]]) ) /2
-        mid_Y = (p_Y[ids[names.index('LHip')]] + p_Y[ids[names.index('RHip')]])/2
-        mid_score = (p_scores[ids[names.index('LHip')]] + p_scores[ids[names.index('RHip')]])/2
-    else:
-        raise ValueError("kpt_name must be 'Neck' or 'Hip'")
-    p_X = np.append(p_X, mid_X)
-    p_Y = np.append(p_Y, mid_Y)
-    p_scores = np.append(p_scores, mid_score)
-
-    return p_X, p_Y, p_scores
-
-
-def best_coords_for_measurements(Q_coords, keypoints_names, beginning_frames_to_remove_percent=0.2, end_frames_to_remove_percent=0.2, fastest_frames_to_remove_percent=0.2, close_to_zero_speed=0.2, large_hip_knee_angles=45):
-    '''
-    Compute the best coordinates for measurements, after removing:
-    - 20% fastest frames (may be outliers)
-    - frames when speed is close to zero (person is out of frame): 0.2 m/frame, or 50 px/frame
-    - frames when hip and knee angle below 45° (imprecise coordinates when person is crouching)
-    
-    INPUTS:
-    - Q_coords: pd.DataFrame. The XYZ coordinates of each marker
-    - keypoints_names: list. The list of marker names
-    - beginning_frames_to_remove_percent: float
-    - end_frames_to_remove_percent: float
-    - fastest_frames_to_remove_percent: float
-    - close_to_zero_speed: float (sum for all keypoints: about 50 px/frame or 0.2 m/frame)
-    - large_hip_knee_angles: int
-    - trimmed_extrema_percent
-
-    OUTPUT:
-    - Q_coords_low_speeds_low_angles: pd.DataFrame. The best coordinates for measurements
-    '''
-
-    # Add MidShoulder column
-    df_MidShoulder = pd.DataFrame((Q_coords['RShoulder'].values + Q_coords['LShoulder'].values) /2)
-    df_MidShoulder.columns = ['MidShoulder']*3
-    Q_coords = pd.concat((Q_coords.reset_index(drop=True), df_MidShoulder), axis=1)
-
-    # Add Hip column if not present
-    n_markers_init = len(keypoints_names)
-    if 'Hip' not in keypoints_names:
-        df_Hip = pd.DataFrame((Q_coords['RHip'].values + Q_coords['LHip'].values) /2)
-        df_Hip.columns = ['Hip']*3
-        Q_coords = pd.concat((Q_coords.reset_index(drop=True), df_Hip), axis=1)
-    n_markers = len(keypoints_names)
-
-    # Removing first and last frames
-    # Q_coords = Q_coords.iloc[int(len(Q_coords) * beginning_frames_to_remove_percent):int(len(Q_coords) * (1-end_frames_to_remove_percent))]
-
-    # Using 80% slowest frames
-    sum_speeds = pd.Series(np.nansum([np.linalg.norm(Q_coords.iloc[:,kpt:kpt+3].diff(), axis=1) for kpt in range(n_markers)], axis=0))
-    sum_speeds = sum_speeds[sum_speeds>close_to_zero_speed] # Removing when speeds close to zero (out of frame)
-    if len(sum_speeds)==0:
-        logging.warning('All frames have speed close to zero. Make sure the person is moving and correctly detected, or change close_to_zero_speed to a lower value. Not restricting the speeds to be above any threshold.')
-        Q_coords_low_speeds = Q_coords
-    else:
-        min_speed_indices = sum_speeds.abs().nsmallest(int(len(sum_speeds) * (1-fastest_frames_to_remove_percent))).index
-        Q_coords_low_speeds = Q_coords.iloc[min_speed_indices].reset_index(drop=True)
-    
-    # Only keep frames with hip and knee flexion angles below 45% 
-    # (if more than 50 of them, else take 50 smallest values)
-    try:
-        ang_mean = mean_angles(Q_coords_low_speeds, ang_to_consider = ['right knee', 'left knee', 'right hip', 'left hip'])
-        Q_coords_low_speeds_low_angles = Q_coords_low_speeds[ang_mean < large_hip_knee_angles]
-        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]
-    except:
-        logging.warning(f"At least one among the RAnkle, RKnee, RHip, RShoulder, LAnkle, LKnee, LHip, LShoulder markers is missing for computing the knee and hip angles. Not restricting these angles to be below {large_hip_knee_angles}°.")
-
-    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
-
-
-def compute_height(trc_data, keypoints_names, fastest_frames_to_remove_percent=0.1, close_to_zero_speed=50, large_hip_knee_angles=45, trimmed_extrema_percent=0.5):
-    '''
-    Compute the height of the person from the trc data.
-
-    INPUTS:
-    - trc_data: pd.DataFrame. The XYZ coordinates of each marker
-    - keypoints_names: list. The list of marker names
-    - fastest_frames_to_remove_percent: float. Frames with high speed are considered as outliers
-    - close_to_zero_speed: float. Sum for all keypoints: about 50 px/frame or 0.2 m/frame
-    - large_hip_knee_angles5: float. Hip and knee angles below this value are considered as imprecise
-    - trimmed_extrema_percent: float. Proportion of the most extreme segment values to remove before calculating their mean)
-    
-    OUTPUT:
-    - height: float. The estimated height of the person
-    '''
-    
-    # Retrieve most reliable coordinates, adding MidShoulder and Hip columns if not present
-    trc_data_low_speeds_low_angles = best_coords_for_measurements(trc_data, keypoints_names, 
-                                                                  fastest_frames_to_remove_percent=fastest_frames_to_remove_percent, close_to_zero_speed=close_to_zero_speed, large_hip_knee_angles=large_hip_knee_angles)
-
-    # Automatically compute the height of the person
-    feet_pairs = [['RHeel', 'RAnkle'], ['LHeel', 'LAnkle']]
-    try:
-        rfoot, lfoot = [euclidean_distance(trc_data_low_speeds_low_angles[pair[0]],trc_data_low_speeds_low_angles[pair[1]]) for pair in feet_pairs]
-    except:
-        rfoot, lfoot = 0.10, 0.10
-        logging.warning('The Heel marker is missing from your model. Considering Foot to Heel size as 10 cm.')
-
-    ankle_to_shoulder_pairs =  [['RAnkle', 'RKnee'], ['RKnee', 'RHip'], ['RHip', 'RShoulder'],
-                                ['LAnkle', 'LKnee'], ['LKnee', 'LHip'], ['LHip', 'LShoulder']]
-    try:
-        rshank, rfemur, rback, lshank, lfemur, lback = [euclidean_distance(trc_data_low_speeds_low_angles[pair[0]],trc_data_low_speeds_low_angles[pair[1]]) for pair in ankle_to_shoulder_pairs]
-    except:
-        logging.error('At least one of the following markers is missing for computing the height of the person:\
-                            RAnkle, RKnee, RHip, RShoulder, LAnkle, LKnee, LHip, LShoulder.\n\
-                            Make sure that the person is entirely visible, or use a calibration file instead, or set "to_meters=false".')
-        raise ValueError('At least one of the following markers is missing for computing the height of the person:\
-                         RAnkle, RKnee, RHip, RShoulder, LAnkle, LKnee, LHip, LShoulder.\
-                         Make sure that the person is entirely visible, or use a calibration file instead, or set "to_meters=false".')
-
-    try:
-        head_pair = [['MidShoulder', 'Head']]
-        head = [euclidean_distance(trc_data_low_speeds_low_angles[pair[0]],trc_data_low_speeds_low_angles[pair[1]]) for pair in head_pair][0]
-    except:
-        head_pair = [['MidShoulder', 'Nose']]
-        head = [euclidean_distance(trc_data_low_speeds_low_angles[pair[0]],trc_data_low_speeds_low_angles[pair[1]]) for pair in head_pair][0]\
-                *1.33
-        logging.warning('The Head marker is missing from your model. Considering Neck to Head size as 1.33 times Neck to MidShoulder size.')
-    
-    heights = (rfoot + lfoot)/2 + (rshank + lshank)/2 + (rfemur + lfemur)/2 + (rback + lback)/2 + head
-    
-    # Remove the 20% most extreme values
-    height = trimmed_mean(heights, trimmed_extrema_percent=trimmed_extrema_percent)
-
-    return height
-
-
-def euclidean_distance(q1, q2):
-    '''
-    Euclidean distance between 2 points (N-dim).
-    
-    INPUTS:
-    - q1: list of N_dimensional coordinates of point
-         or list of N points of N_dimensional coordinates
-    - q2: idem
-
-    OUTPUTS:
-    - euc_dist: float. Euclidian distance between q1 and q2
-    '''
-    
-    q1 = np.array(q1)
-    q2 = np.array(q2)
-    dist = q2 - q1
-    if np.isnan(dist).all():
-        dist =  np.empty_like(dist)
-        dist[...] = np.inf
-    
-    if len(dist.shape)==1:
-        euc_dist = np.sqrt(np.nansum( [d**2 for d in dist]))
-    else:
-        euc_dist = np.sqrt(np.nansum( [d**2 for d in dist], axis=1))
-    
-    return euc_dist
-
-
-def trimmed_mean(arr, trimmed_extrema_percent=0.5):
-    '''
-    Trimmed mean calculation for an array.
-
-    INPUTS:
-    - arr (np.array): The input array.
-    - trimmed_extrema_percent (float): The percentage of values to be trimmed from both ends.
-
-    OUTPUTS:
-    - float: The trimmed mean of the array.
-    '''
-
-    # Sort the array
-    sorted_arr = np.sort(arr)
-    
-    # Determine the indices for the 25th and 75th percentiles (if trimmed_percent = 0.5)
-    lower_idx = int(len(sorted_arr) * (trimmed_extrema_percent/2))
-    upper_idx = int(len(sorted_arr) * (1 - trimmed_extrema_percent/2))
-    
-    # Slice the array to exclude the 25% lowest and highest values
-    trimmed_arr = sorted_arr[lower_idx:upper_idx]
-    
-    # Return the mean of the remaining values
-    return np.mean(trimmed_arr)
-
-
-def retrieve_calib_params(calib_file):
-    '''
-    Compute projection matrices from toml calibration file.
-    
-    INPUT:
-    - calib_file: calibration .toml file.
-    
-    OUTPUT:
-    - S: (h,w) vectors as list of 2x1 arrays
-    - K: intrinsic matrices as list of 3x3 arrays
-    - dist: distortion vectors as list of 4x1 arrays
-    - inv_K: inverse intrinsic matrices as list of 3x3 arrays
-    - optim_K: intrinsic matrices for undistorting points as list of 3x3 arrays
-    - R: rotation rodrigue vectors as list of 3x1 arrays
-    - T: translation vectors as list of 3x1 arrays
-    '''
-    
-    calib = toml.load(calib_file)
-
-    cal_keys = [c for c in calib.keys() 
-                if c not in ['metadata', 'capture_volume', 'charuco', 'checkerboard'] 
-                and isinstance(calib[c],dict)]
-    S, K, dist, optim_K, inv_K, R, R_mat, T = [], [], [], [], [], [], [], []
-    for c, cam in enumerate(cal_keys):
-        S.append(np.array(calib[cam]['size']))
-        K.append(np.array(calib[cam]['matrix']))
-        dist.append(np.array(calib[cam]['distortions']))
-        optim_K.append(cv2.getOptimalNewCameraMatrix(K[c], dist[c], [int(s) for s in S[c]], 1, [int(s) for s in S[c]])[0])
-        inv_K.append(np.linalg.inv(K[c]))
-        R.append(np.array(calib[cam]['rotation']))
-        R_mat.append(cv2.Rodrigues(R[c])[0])
-        T.append(np.array(calib[cam]['translation']))
-    calib_params_dict = {'S': S, 'K': K, 'dist': dist, 'inv_K': inv_K, 'optim_K': optim_K, 'R': R, 'R_mat': R_mat, 'T': T}
-            
-    return calib_params_dict
-
-
 def write_calibration(calib_params, toml_path):
     '''
     Write calibration file from calibration parameters
@@ -815,349 +224,3 @@ def write_calibration(calib_params, toml_path):
             cal_f.write(cam_str + name_str + size_str + mat_str + dist_str + rot_str + tran_str + fish_str)
         meta = '[metadata]\nadjusted = false\nerror = 0.0\n'
         cal_f.write(meta)
-
-    
-def pad_shape(arr, target_len, fill_value=np.nan):
-    '''
-    Pads an array to the target length with specified fill values
-    
-    INPUTS:
-    - arr: Input array to be padded.
-    - target_len: The target length of the first dimension after padding.
-    - fill_value: The value to use for padding (default: np.nan).
-    
-    OUTPUTS:
-    - Padded array with shape (target_len, ...) matching the input dimensions.
-    '''
-
-    if len(arr) < target_len:
-        pad_shape = (target_len - len(arr),) + arr.shape[1:]
-        padding = np.full(pad_shape, fill_value)
-        return np.concatenate((arr, padding))
-    
-    return arr
-
-
-def min_with_single_indices(L, T):
-    '''
-    Let L be a list (size s) with T associated tuple indices (size s).
-    Select the smallest values of L, considering that 
-    the next smallest value cannot have the same numbers 
-    in the associated tuple as any of the previous ones.
-
-    Example:
-    L = [  20,   27,  51,    33,   43,   23,   37,   24,   4,   68,   84,    3  ]
-    T = list(it.product(range(2),range(3)))
-      = [(0,0),(0,1),(0,2),(0,3),(1,0),(1,1),(1,2),(1,3),(2,0),(2,1),(2,2),(2,3)]
-
-    - 1st smallest value: 3 with tuple (2,3), index 11
-    - 2nd smallest value when excluding indices (2,.) and (.,3), i.e. [(0,0),(0,1),(0,2),X,(1,0),(1,1),(1,2),X,X,X,X,X]:
-    20 with tuple (0,0), index 0
-    - 3rd smallest value when excluding [X,X,X,X,X,(1,1),(1,2),X,X,X,X,X]:
-    23 with tuple (1,1), index 5
-    
-    INPUTS:
-    - L: list (size s)
-    - T: T associated tuple indices (size s)
-
-    OUTPUTS: 
-    - minL: list of smallest values of L, considering constraints on tuple indices
-    - argminL: list of indices of smallest values of L (indices of best combinations)
-    - T_minL: list of tuples associated with smallest values of L
-    '''
-
-    minL = [np.nanmin(L)]
-    argminL = [np.nanargmin(L)]
-    T_minL = [T[argminL[0]]]
-    
-    mask_tokeep = np.array([True for t in T])
-    i=0
-    while mask_tokeep.any()==True:
-        mask_tokeep = mask_tokeep & np.array([t[0]!=T_minL[i][0] and t[1]!=T_minL[i][1] for t in T])
-        if mask_tokeep.any()==True:
-            indicesL_tokeep = np.where(mask_tokeep)[0]
-            minL += [np.nanmin(np.array(L)[indicesL_tokeep]) if not np.isnan(np.array(L)[indicesL_tokeep]).all() else np.nan]
-            argminL += [indicesL_tokeep[np.nanargmin(np.array(L)[indicesL_tokeep])] if not np.isnan(minL[-1]) else indicesL_tokeep[0]]
-            T_minL += (T[argminL[i+1]],)
-            i+=1
-    
-    return np.array(minL), np.array(argminL), np.array(T_minL)
-    
-
-def sort_people_sports2d(keyptpre, keypt, scores=None):
-    '''
-    Associate persons across frames (Sports2D method)
-    Persons' indices are sometimes swapped when changing frame
-    A person is associated to another in the next frame when they are at a small distance
-    
-    N.B.: Requires min_with_single_indices and euclidian_distance function (see common.py)
-
-    INPUTS:
-    - keyptpre: (K, L, M) array of 2D coordinates for K persons in the previous frame, L keypoints, M 2D coordinates
-    - keypt: idem keyptpre, for current frame
-    - score: (K, L) array of confidence scores for K persons, L keypoints (optional) 
-    
-    OUTPUTS:
-    - sorted_prev_keypoints: array with reordered persons with values of previous frame if current is empty
-    - sorted_keypoints: array with reordered persons --> if scores is not None
-    - sorted_scores: array with reordered scores     --> if scores is not None
-    - associated_tuples: list of tuples with correspondences between persons across frames --> if scores is None (for Pose2Sim.triangulation())
-    '''
-    
-    # Generate possible person correspondences across frames
-    max_len = max(len(keyptpre), len(keypt))
-    keyptpre = pad_shape(keyptpre, max_len, fill_value=np.nan)
-    keypt = pad_shape(keypt, max_len, fill_value=np.nan)
-    if scores is not None:
-        scores = pad_shape(scores, max_len, fill_value=np.nan)
-    
-    # Compute distance between persons from one frame to another
-    personsIDs_comb = sorted(list(it.product(range(len(keyptpre)), range(len(keypt)))))
-    frame_by_frame_dist = [euclidean_distance(keyptpre[comb[0]],keypt[comb[1]]) for comb in personsIDs_comb]
-    frame_by_frame_dist = np.mean(frame_by_frame_dist, axis=1)
-    
-    # Sort correspondences by distance
-    _, _, associated_tuples = min_with_single_indices(frame_by_frame_dist, personsIDs_comb)
-    
-    # Associate points to same index across frames, nan if no correspondence
-    sorted_keypoints = []
-    for i in range(len(keyptpre)):
-        id_in_old =  associated_tuples[:,1][associated_tuples[:,0] == i].tolist()
-        if len(id_in_old) > 0:      sorted_keypoints += [keypt[id_in_old[0]]]
-        else:                       sorted_keypoints += [keypt[i]]
-    sorted_keypoints = np.array(sorted_keypoints)
-
-    if scores is not None:
-        sorted_scores = []
-        for i in range(len(keyptpre)):
-            id_in_old =  associated_tuples[:,1][associated_tuples[:,0] == i].tolist()
-            if len(id_in_old) > 0:  sorted_scores += [scores[id_in_old[0]]]
-            else:                   sorted_scores += [scores[i]]
-        sorted_scores = np.array(sorted_scores)
-
-    # Keep track of previous values even when missing for more than one frame
-    sorted_prev_keypoints = np.where(np.isnan(sorted_keypoints) & ~np.isnan(keyptpre), keyptpre, sorted_keypoints)
-    
-    if scores is not None:
-        return sorted_prev_keypoints, sorted_keypoints, sorted_scores
-    else: # For Pose2Sim.triangulation()
-        return sorted_keypoints, associated_tuples
-
-
-def sort_people_rtmlib(pose_tracker, keypoints, scores):
-    '''
-    Associate persons across frames (RTMLib method)
-
-    INPUTS:
-    - pose_tracker: PoseTracker. The initialized RTMLib pose tracker object
-    - keypoints: array of shape K, L, M with K the number of detected persons,
-    L the number of detected keypoints, M their 2D coordinates
-    - scores: array of shape K, L with K the number of detected persons,
-    L the confidence of detected keypoints
-
-    OUTPUT:
-    - sorted_keypoints: array with reordered persons
-    - sorted_scores: array with reordered scores
-    '''
-    
-    try:
-        desired_size = max(pose_tracker.track_ids_last_frame)+1
-        sorted_keypoints = np.full((desired_size, keypoints.shape[1], 2), np.nan)
-        sorted_keypoints[pose_tracker.track_ids_last_frame] = keypoints[:len(pose_tracker.track_ids_last_frame), :, :]
-        sorted_scores = np.full((desired_size, scores.shape[1]), np.nan)
-        sorted_scores[pose_tracker.track_ids_last_frame] = scores[:len(pose_tracker.track_ids_last_frame), :]
-    except:
-        sorted_keypoints, sorted_scores = keypoints, scores
-
-    return sorted_keypoints, sorted_scores
-
-
-def sort_people_deepsort(keypoints, scores, deepsort_tracker, frame,frame_count):
-    '''
-    Associate persons across frames (DeepSort method)
-
-    INPUTS:
-    - keypoints: array of shape K, L, M with K the number of detected persons,
-    L the number of detected keypoints, M their 2D coordinates
-    - scores: array of shape K, L with K the number of detected persons,
-    L the confidence of detected keypoints
-    - deepsort_tracker: The initialized DeepSort tracker object
-    - frame: np.array. The current image opened with cv2.imread
-
-    OUTPUT:
-    - sorted_keypoints: array with reordered persons
-    - sorted_scores: array with reordered scores
-    '''
-
-    try:
-        # Compute bboxes from keypoints and create detections (bboxes, scores, class_ids)
-        bboxes_ltwh = bbox_ltwh_compute(keypoints, padding=20)
-        bbox_scores = np.mean(scores, axis=1)
-        class_ids = np.array(['person']*len(bboxes_ltwh))
-        detections = list(zip(bboxes_ltwh, bbox_scores, class_ids))
-
-        # Estimates the tracks and retrieve indexes of the original detections
-        det_ids = [i for i in range(len(detections))]
-        tracks = deepsort_tracker.update_tracks(detections, frame=frame, others=det_ids)
-        track_ids_frame, orig_det_ids = [], []
-        for track in tracks:
-            if not track.is_confirmed():
-                continue
-            track_ids_frame.append(int(track.track_id)-1)       # ID of people
-            orig_det_ids.append(track.get_det_supplementary())  # ID of detections
-
-        # Correspondence between person IDs and original detection IDs
-        desired_size = max(track_ids_frame) + 1
-        sorted_keypoints = np.full((desired_size, keypoints.shape[1], 2), np.nan)
-        sorted_scores = np.full((desired_size, scores.shape[1]), np.nan)
-        for i,v in enumerate(track_ids_frame):
-            if orig_det_ids[i] is not None:    
-                sorted_keypoints[v] = keypoints[orig_det_ids[i]]
-                sorted_scores[v] = scores[orig_det_ids[i]]
-
-    except Exception as e:
-        sorted_keypoints, sorted_scores = keypoints, scores
-        if frame_count > deepsort_tracker.tracker.n_init:
-            logging.warning(f"Tracking error: {e}. Sorting persons with DeepSort method failed for this frame.")
-
-    return sorted_keypoints, sorted_scores
-
-
-def bbox_ltwh_compute(keypoints, padding=0):
-    '''
-    Compute bounding boxes in (x_min, y_min, width, height) format
-    Optionally add padding to the bounding boxes 
-    as a percentage of the bounding box size (+padding% horizontally, +padding/2% vertically)
-
-    INPUTS:
-    - keypoints: array of shape K, L, M with K the number of detected persons,
-                    L the number of detected keypoints, M their 2D coordinates
-    - padding: int. The padding to add to the bounding boxes, in perceptage
-    '''
-
-    x_coords = keypoints[:, :, 0]
-    y_coords = keypoints[:, :, 1]
-
-    x_min, x_max = np.min(x_coords, axis=1), np.max(x_coords, axis=1)
-    y_min, y_max = np.min(y_coords, axis=1), np.max(y_coords, axis=1)
-    width = x_max - x_min
-    height = y_max - y_min
-
-    if padding > 0:
-        x_min = x_min - width*padding/100
-        y_min = y_min - height/2*padding/100
-        width = width + 2*width*padding/100
-        height = height + height*padding/100
-
-    bbox_ltwh = np.stack((x_min, y_min, width, height), axis=1)
-
-    return bbox_ltwh
-
-
-def draw_bounding_box(img, X, Y, colors=[(255, 0, 0), (0, 255, 0), (0, 0, 255)], fontSize=0.3, thickness=1):
-    '''
-    Draw bounding boxes and person ID around list of lists of X and Y coordinates.
-    Bounding boxes have a different color for each person.
-    
-    INPUTS:
-    - img: opencv image
-    - X: list of list of x coordinates
-    - Y: list of list of y coordinates
-    - colors: list of colors to cycle through
-    
-    OUTPUT:
-    - img: image with rectangles and person IDs
-    '''
-   
-    color_cycle = it.cycle(colors)
-
-    for i,(x,y) in enumerate(zip(X,Y)):
-        color = next(color_cycle)
-        if not np.isnan(x).all():
-            x_min, y_min = np.nanmin(x).astype(int), np.nanmin(y).astype(int)
-            x_max, y_max = np.nanmax(x).astype(int), np.nanmax(y).astype(int)
-            if x_min < 0: x_min = 0
-            if x_max > img.shape[1]: x_max = img.shape[1]
-            if y_min < 0: y_min = 0
-            if y_max > img.shape[0]: y_max = img.shape[0]
-
-            # Draw rectangles
-            cv2.rectangle(img, (x_min-25, y_min-25), (x_max+25, y_max+25), color, thickness) 
-        
-            # Write person ID
-            cv2.putText(img, str(i), (x_min-30, y_min-30), cv2.FONT_HERSHEY_SIMPLEX, fontSize, color, 2, cv2.LINE_AA) 
-    
-    return img
-
-
-def draw_skel(img, X, Y, model):
-    '''
-    Draws keypoints and skeleton for each person.
-    Skeletons have a different color for each person.
-
-    INPUTS:
-    - img: opencv image
-    - X: list of list of x coordinates
-    - Y: list of list of y coordinates
-    - model: skeleton model (from skeletons.py)
-    - colors: list of colors to cycle through
-    
-    OUTPUT:
-    - img: image with keypoints and skeleton
-    '''
-    
-    # Get (unique) pairs between which to draw a line
-    id_pairs, name_pairs = [], []
-    for data_i in PreOrderIter(model.root, filter_=lambda node: node.is_leaf):
-        node_branch_ids = [node_i.id for node_i in data_i.path]
-        node_branch_names = [node_i.name for node_i in data_i.path]
-        id_pairs += [[node_branch_ids[i],node_branch_ids[i+1]] for i in range(len(node_branch_ids)-1)]
-        name_pairs += [[node_branch_names[i],node_branch_names[i+1]] for i in range(len(node_branch_names)-1)]
-    node_pairs = {tuple(name_pair): id_pair for (name_pair,id_pair) in zip(name_pairs,id_pairs)}
-
-    
-    # Draw lines
-    for (x,y) in zip(X,Y):
-        if not np.isnan(x).all():
-            for names, ids in node_pairs.items():
-                if not None in ids and not (np.isnan(x[ids[0]]) or np.isnan(y[ids[0]]) or np.isnan(x[ids[1]]) or np.isnan(y[ids[1]])):
-                    if any(n.startswith('R') for n in names) and not any(n.startswith('L') for n in names):
-                        c = (255,128,0)
-                    elif any(n.startswith('L') for n in names) and not any(n.startswith('R') for n in names):
-                        c = (0,255,0)
-                    else:
-                        c = (51, 153, 255)
-                    cv2.line(img, (int(x[ids[0]]), int(y[ids[0]])), (int(x[ids[1]]), int(y[ids[1]])), c, thickness)
-
-    return img
-
-
-def draw_keypts(img, X, Y, scores, cmap_str='RdYlGn'):
-    '''
-    Draws keypoints and skeleton for each person.
-    Keypoints' colors depend on their score.
-
-    INPUTS:
-    - img: opencv image
-    - X: list of list of x coordinates
-    - Y: list of list of y coordinates
-    - scores: list of list of scores
-    - cmap_str: colormap name
-    
-    OUTPUT:
-    - img: image with keypoints and skeleton
-    '''
-    
-    scores = np.where(np.isnan(scores), 0, scores)
-    # scores = (scores - 0.4) / (1-0.4) # to get a red color for scores lower than 0.4
-    scores = np.where(scores>0.99, 0.99, scores)
-    scores = np.where(scores<0, 0, scores)
-    
-    cmap = plt.get_cmap(cmap_str)
-    for (x,y,s) in zip(X,Y,scores):
-        c_k = np.array(cmap(s))[:,:-1]*255
-        [cv2.circle(img, (int(x[i]), int(y[i])), thickness+4, c_k[i][::-1], -1)
-            for i in range(len(x))
-            if not (np.isnan(x[i]) or np.isnan(y[i]))]
-
-    return img

Sports2D/Utilities/filter.py

@@ -19,6 +19,7 @@
 
 
 ## INIT
+from importlib.metadata import version
 import numpy as np
 from scipy import signal
 from scipy.ndimage import gaussian_filter1d
@@ -30,7 +31,7 @@ __author__ = "David Pagnon"
 __copyright__ = "Copyright 2021, Pose2Sim"
 __credits__ = ["David Pagnon"]
 __license__ = "BSD 3-Clause License"
-__version__ = "0.4.0"
+__version__ = version("sports2d")
 __maintainer__ = "David Pagnon"
 __email__ = "contact@david-pagnon.com"
 __status__ = "Development"

Sports2D/Utilities/tests.py

@@ -13,6 +13,7 @@
 
 
 ## INIT
+from importlib.metadata import version
 import toml
 import subprocess
 from pathlib import Path
@@ -23,7 +24,7 @@ __author__ = "David Pagnon"
 __copyright__ = "Copyright 2023, Sports2D"
 __credits__ = ["David Pagnon"]
 __license__ = "BSD 3-Clause License"
-__version__ = "0.4.0"
+__version__ = version("sports2d")
 __maintainer__ = "David Pagnon"
 __email__ = "contact@david-pagnon.com"
 __status__ = "Development"
@@ -58,12 +59,14 @@ def test_workflow():
     demo_cmd = ["sports2d", "--show_realtime_results", "False", "--show_graphs", "False"]
     subprocess.run(demo_cmd, check=True, capture_output=True, text=True, encoding='utf-8')
 
-    # With no pixels to meters conversion, no multiperson, lightweight mode, detection frequency, time range and slowmo factor
+    # With no pixels to meters conversion, no multiperson, lightweight mode, detection frequency, slowmo factor, gaussian filter, RTMO body pose model
     demo_cmd2 = ["sports2d", "--show_realtime_results", "False", "--show_graphs", "False", 
                  "--to_meters", "False", 
                  "--multiperson", "False", 
                  "--mode", "lightweight", "--det_frequency", "50", 
-                 "--time_range", "1.2", "2.7",  "--slowmo_factor", "4"]
+                 "--slowmo_factor", "4",
+                 "--filter_type", "gaussian",
+                 "--pose_model", "body", "--mode", """{'pose_class':'RTMO', 'pose_model':'https://download.openmmlab.com/mmpose/v1/projects/rtmo/onnx_sdk/rtmo-m_16xb16-600e_body7-640x640-39e78cc4_20231211.zip', 'pose_input_size':[640, 640]}"""]
     subprocess.run(demo_cmd2, check=True, capture_output=True, text=True, encoding='utf-8')
     
     # With a time range, inverse kinematics, marker augmentation, body pose_model and custom RTMO mode
@@ -71,9 +74,8 @@ def test_workflow():
                  "--time_range", "1.2", "2.7",
                  "--do_ik", "True", "--use_augmentation", "True", 
                  "--px_to_m_from_person_id", "1", "--px_to_m_person_height", "1.65",
-                 "--visible_side", "left", "front", "--participant_mass", "55.0", "67.0",
-                 "--pose_model", "body", "--mode", """{'pose_class':'RTMO', 'pose_model':'https://download.openmmlab.com/mmpose/v1/projects/rtmo/onnx_sdk/rtmo-m_16xb16-600e_body7-640x640-39e78cc4_20231211.zip', 'pose_input_size':[640, 640]}"""]
-    subprocess.run(demo_cmd3, check=True, capture_output=True, text=True)
+                 "--visible_side", "front", "auto", "--participant_mass", "55.0", "67.0"]
+    subprocess.run(demo_cmd3, check=True, capture_output=True, text=True, encoding='utf-8')
     
     # From config file
     cli_config_path = Path(__file__).resolve().parent.parent / 'Demo' / 'Config_demo.toml'

Sports2D/__init__.py

@@ -2,6 +2,7 @@
 # -*- coding: utf-8 -*-
 
 import sys
+from importlib.metadata import version
 
-__version__ = "0.4.0"
+__version__ = version("sports2d")
 VERSION = __version__

Sports2D/process.py

@@ -58,6 +58,7 @@ import json
 import ast
 import shutil
 import os
+from importlib.metadata import version
 from functools import partial
 from datetime import datetime
 import itertools as it
@@ -72,11 +73,11 @@ import matplotlib as mpl
 import matplotlib.pyplot as plt
 from rtmlib import PoseTracker, BodyWithFeet, Wholebody, Body, Custom
 from deep_sort_realtime.deepsort_tracker import DeepSort
-import opensim as osim
 
 from Sports2D.Utilities import filter
 from Sports2D.Utilities.common import *
 from Sports2D.Utilities.skeletons import *
+from Pose2Sim.common import *
 
 DEFAULT_MASS = 70
 DEFAULT_HEIGHT = 1.7
@@ -86,7 +87,7 @@ __author__ = "David Pagnon, HunMin Kim"
 __copyright__ = "Copyright 2023, Sports2D"
 __credits__ = ["David Pagnon"]
 __license__ = "BSD 3-Clause License"
-__version__ = "0.4.0"
+__version__ = version("sports2d")
 __maintainer__ = "David Pagnon"
 __email__ = "contact@david-pagnon.com"
 __status__ = "Development"
@@ -625,7 +626,7 @@ def trc_data_from_XYZtime(X, Y, Z, time):
     '''
 
     trc_data = pd.concat([pd.concat([X.iloc[:,kpt], Y.iloc[:,kpt], Z.iloc[:,kpt]], axis=1) for kpt in range(len(X.columns))], axis=1)
-    trc_data.insert(0, 't', time)
+    trc_data.insert(0, 'time', time)
 
     return trc_data
 
@@ -928,6 +929,7 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
     px_to_m_from_person_id = int(config_dict.get('project').get('px_to_m_from_person_id'))
     px_to_m_person_height_m = config_dict.get('project').get('px_to_m_person_height')
     visible_side = config_dict.get('project').get('visible_side')
+    if isinstance(visible_side, str): visible_side = [visible_side]
     # Pose from file
     load_trc_px = config_dict.get('project').get('load_trc_px')
     if load_trc_px == '': load_trc_px = None
@@ -1040,7 +1042,8 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
     close_to_zero_speed_px = config_dict.get('kinematics').get('close_to_zero_speed_px')
     close_to_zero_speed_m = config_dict.get('kinematics').get('close_to_zero_speed_m')
     if do_ik:
-        from Pose2Sim.markerAugmentation import augment_markers_all
+        if use_augmentation:
+            from Pose2Sim.markerAugmentation import augment_markers_all
         from Pose2Sim.kinematics import kinematics_all
         # Create a Pose2Sim dictionary and fill in missing keys
         recursivedict = lambda: defaultdict(recursivedict)
@@ -1127,12 +1130,18 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
             logging.error(f'\n{load_trc_px} file needs to be in px, not in meters.')
         logging.info(f'\nUsing a pose file instead of running pose estimation and tracking: {load_trc_px}.')
         # Load pose file in px
-        Q_coords, _, _, keypoints_names, _ = read_trc(load_trc_px)
+        Q_coords, _, time_col, keypoints_names, _ = read_trc(load_trc_px)
+
         keypoints_ids = [i for i in range(len(keypoints_names))]
         keypoints_all, scores_all = load_pose_file(Q_coords)
         for pre, _, node in RenderTree(pose_model):
             if node.name in keypoints_names:
                 node.id = keypoints_names.index(node.name)
+        if time_range:
+            frame_range = [abs(time_col - time_range[0]).idxmin(), abs(time_col - time_range[1]).idxmin()+1]
+        else:
+            frame_range = [0, len(Q_coords)]
+        frame_iterator = tqdm(range(*frame_range))
     
     else:
         # Retrieve keypoint names from model
@@ -1336,7 +1345,10 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
     all_frames_scores = make_homogeneous(all_frames_scores)
 
     frame_range = [0,frame_count] if video_file == 'webcam' else frame_range
-    all_frames_time = pd.Series(np.linspace(frame_range[0]/fps, frame_range[1]/fps, frame_count+1), name='time')
+    if not load_trc_px:
+        all_frames_time = pd.Series(np.linspace(frame_range[0]/fps, frame_range[1]/fps, frame_count-frame_range[0]+1), name='time')
+    else:
+        all_frames_time = time_col
     if not multiperson:
         px_to_m_from_person_id = get_personID_with_highest_scores(all_frames_scores)
         detected_persons = [px_to_m_from_person_id]
@@ -1475,7 +1487,6 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                 if not np.array(trc_data[i].iloc[:,1:] ==0).all():
                     # Automatically determine visible side
                     visible_side_i = visible_side[i] if len(visible_side)>i else 'auto' # set to 'auto' if list too short
-                    
                     # Set to 'front' if slope of X values between [-5,5]
                     if visible_side_i == 'auto':
                         try:
@@ -1512,7 +1523,7 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
                     pose_path_person_m_i = (pose_output_path.parent / (pose_output_path_m.stem + f'_person{idx_path:02d}.trc'))
                     make_trc_with_trc_data(trc_data_m_i, pose_path_person_m_i, fps=fps)
                     if make_c3d:
-                        c3d_path = convert_to_c3d(pose_path_person_m_i)
+                        c3d_path = convert_to_c3d(str(pose_path_person_m_i))
                     logging.info(f'Pose in meters saved to {pose_path_person_m_i.resolve()}. {"Also saved in c3d format." if make_c3d else ""}')
                     
                 
@@ -1643,12 +1654,17 @@ def process_fun(config_dict, video_file, time_range, frame_rate, result_dir):
 
     # OpenSim inverse kinematics (and optional marker augmentation)
     if do_ik or use_augmentation:
+        import opensim as osim
         logging.info('\nPost-processing angles (with inverse kinematics):')
         if not to_meters:
             logging.warning('Skipping marker augmentation and inverse kinematics as to_meters was set to False.')
         else:
             # move all trc files containing _m_ string to pose3d_dir
-            for trc_file in output_dir.glob('*_m_*.trc'):
+            if not load_trc_px: 
+                trc_list = output_dir.glob('*_m_*.trc')
+            else:
+                trc_list = [pose_path_person_m_i]
+            for trc_file in trc_list:
                 if (pose3d_dir/trc_file.name).exists():
                     os.remove(pose3d_dir/trc_file.name)
                 shutil.move(trc_file, pose3d_dir)

{sports2d-0.7.0.dist-info → sports2d-0.7.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: sports2d
-Version: 0.7.0
+Version: 0.7.3
 Summary: Detect pose and compute 2D joint angles from a video.
 Home-page: https://github.com/davidpagnon/Sports2D
 Author: David Pagnon
@@ -40,6 +40,7 @@ Requires-Dist: tqdm
 Requires-Dist: imageio_ffmpeg
 Requires-Dist: deep-sort-realtime
 Requires-Dist: Pose2Sim
+Dynamic: license-file
 
 
 [![Continuous integration](https://github.com/davidpagnon/sports2d/actions/workflows/continuous-integration.yml/badge.svg?branch=main)](https://github.com/davidpagnon/sports2d/actions/workflows/continuous-integration.yml)
@@ -81,7 +82,10 @@ Works on any smartphone!**\
 
 </br>
 
-https://github.com/user-attachments/assets/1c6e2d6b-d0cf-4165-864e-d9f01c0b8a0e
+
+https://github.com/user-attachments/assets/6a444474-4df1-4134-af0c-e9746fa433ad
+
+<!-- https://github.com/user-attachments/assets/1c6e2d6b-d0cf-4165-864e-d9f01c0b8a0e -->
 
 `Warning:` Angle estimation is only as good as the pose estimation algorithm, i.e., it is not perfect.\
 `Warning:` Results are acceptable only if the persons move in the 2D plane (sagittal or frontal plane). The persons need to be filmed as parallel as possible to the motion plane.\
@@ -465,7 +469,7 @@ sports2d --help
 'participant_mass': ["", "mass of the participant in kg or none. Defaults to 70 if not provided. No influence on kinematics (motion), only on kinetics (forces)"],
 'close_to_zero_speed_m': ["","Sum for all keypoints: about 50 px/frame or 0.2 m/frame"], 
 'multiperson': ["", "multiperson involves tracking: will be faster if set to false. true if not specified"],
-'tracking_mode': ["", "sports2d or rtmlib. sports2d is generally much more accurate and comparable in speed. sports2d if not specified"],
+'tracking_mode': ["", "'sports2d' or 'deepsort'. 'deepsort' is slower, harder to parametrize but can be more robust if correctly tuned"],
 'deepsort_params': ["", 'Deepsort tracking parameters: """{dictionary between 3 double quotes}""". \n\
                     Default: max_age:30, n_init:3, nms_max_overlap:0.8, max_cosine_distance:0.3, nn_budget:200, max_iou_distance:0.8, embedder_gpu: True\n\
                     More information there: https://github.com/levan92/deep_sort_realtime/blob/master/deep_sort_realtime/deepsort_tracker.py#L51'],

sports2d-0.7.3.dist-info/RECORD

@@ -0,0 +1,16 @@
+Sports2D/Sports2D.py,sha256=AiH2D2IJ9odxqvPkhDQSv6Kyj1Bn6wNFtlmGB7YbHC0,29770
+Sports2D/__init__.py,sha256=BuUkPEdItxlkeqz4dmoiPwZLkgAfABJK3KWQ1ujTGwE,153
+Sports2D/process.py,sha256=4OFI2BlfMQ0Vm1g59HLOzBRAmEiXkawa-f5AVPsYXp0,88043
+Sports2D/Demo/Config_demo.toml,sha256=TeIaqpbnPDO2jyOOH0IUAMRxiqdpoeHN_ZDE3P5Nrfo,13877
+Sports2D/Demo/demo.mp4,sha256=2aZkFxhWR7ESMEtXCT8MGA83p2jmoU2sp1ylQfO3gDk,3968304
+Sports2D/Utilities/__init__.py,sha256=BuUkPEdItxlkeqz4dmoiPwZLkgAfABJK3KWQ1ujTGwE,153
+Sports2D/Utilities/common.py,sha256=eq-UR8ZJLLRwpXtN4drurmuypuTuxsiiU2ZYd-R3Zqw,11196
+Sports2D/Utilities/filter.py,sha256=rfZcqofjllKI_5ovZTKEAmyjOZpB_PzbAJ0P874T8Ak,4973
+Sports2D/Utilities/skeletons.py,sha256=WObRPHpCj5Q2WpspzFRy1gvAX-EZD9WyA9K-kqL4YRo,40076
+Sports2D/Utilities/tests.py,sha256=gUIyOxujSTvyzHkOmuexIBqd3BApLcshPBcXuNfGCZ0,3624
+sports2d-0.7.3.dist-info/licenses/LICENSE,sha256=f4qe3nE0Y7ltJho5w-xAR0jI5PUox5Xl-MsYiY7ZRM8,1521
+sports2d-0.7.3.dist-info/METADATA,sha256=6aje5qwCEgLaFZch4gHya4-Bh-5SwsNAPp5ZBM6bW1M,38631
+sports2d-0.7.3.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+sports2d-0.7.3.dist-info/entry_points.txt,sha256=h2CJTuydtNf8JyaLoWxWl5HTSIxx5Ra_FSiSGQsf7Sk,52
+sports2d-0.7.3.dist-info/top_level.txt,sha256=DoURf9UDB8lQ_9lMUPQMQqhXCvWPFFjJco9NzPlHJ6I,9
+sports2d-0.7.3.dist-info/RECORD,,

{sports2d-0.7.0.dist-info → sports2d-0.7.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.2)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

sports2d-0.7.0.dist-info/RECORD

@@ -1,16 +0,0 @@
-Sports2D/Sports2D.py,sha256=eWOz-7HQiwRu7Xl0_bPTlg9meOW635x197WL9QrKfoU,29719
-Sports2D/__init__.py,sha256=TyCP7Uuuy6CNklhPf8W84MbYoO1_-1dxowSYAJyk_OI,102
-Sports2D/process.py,sha256=nuNOwNJCF8dduUOOuoOYxjDpO2J5T9dEjrLYPLuuz5Q,87391
-Sports2D/Demo/Config_demo.toml,sha256=S7cBtdob9zxA6deicPY1ZEQicTYeaByet5gSvRmkG00,13854
-Sports2D/Demo/demo.mp4,sha256=2aZkFxhWR7ESMEtXCT8MGA83p2jmoU2sp1ylQfO3gDk,3968304
-Sports2D/Utilities/__init__.py,sha256=TyCP7Uuuy6CNklhPf8W84MbYoO1_-1dxowSYAJyk_OI,102
-Sports2D/Utilities/common.py,sha256=OKyjBuXoZK0O34vuGeXzVrWpsyx6DI219L-yuS-iQTU,48254
-Sports2D/Utilities/filter.py,sha256=8mVefMjDzxmh9a30eNtIrUuK_mUKoOJ2Nr-OzcQKkKM,4922
-Sports2D/Utilities/skeletons.py,sha256=WObRPHpCj5Q2WpspzFRy1gvAX-EZD9WyA9K-kqL4YRo,40076
-Sports2D/Utilities/tests.py,sha256=mE05fRL2hGGI0VD4kb_GmLsucCvyVPfOxohUK3I96RE,3516
-sports2d-0.7.0.dist-info/LICENSE,sha256=f4qe3nE0Y7ltJho5w-xAR0jI5PUox5Xl-MsYiY7ZRM8,1521
-sports2d-0.7.0.dist-info/METADATA,sha256=ywXZgpFzd2T2LTD8TmSDtIMv9uJQfAH3RpUgRAwMY68,38518
-sports2d-0.7.0.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-sports2d-0.7.0.dist-info/entry_points.txt,sha256=h2CJTuydtNf8JyaLoWxWl5HTSIxx5Ra_FSiSGQsf7Sk,52
-sports2d-0.7.0.dist-info/top_level.txt,sha256=DoURf9UDB8lQ_9lMUPQMQqhXCvWPFFjJco9NzPlHJ6I,9
-sports2d-0.7.0.dist-info/RECORD,,