python script

# manuscript-code-

import os
import pandas as pd
import numpy as np

# Paramètres
fps = 25
dt = 1 / fps
dossier_entree = r"PATH OF THE FOLDER"
dossier_sortie = os.path.join(dossier_entree, "OUTPUT")
os.makedirs(dossier_sortie, exist_ok=True)

# Fonction pour calculer la longueur de la trajectoire
def calc_trajectory_length(x, y):
    mask = ~np.isnan(x) & ~np.isnan(y)
    dx, dy = np.diff(x[mask]), np.diff(y[mask])
    return np.sum(np.sqrt(dx**2 + dy**2))

# Fonction pour calculer le NJS
def calculate_njs(jerk, time, duration, length):
    integral_jerk_squared = np.trapz(jerk**2, time)
    njs = np.sqrt(0.5 * integral_jerk_squared * (duration**5) / (length**2))
    return njs

# Liste des fichiers CSV à traiter
fichiers_csv = [f for f in os.listdir(dossier_entree) if f.lower().endswith('.csv')]

# Liste pour stocker les résultats
tous_les_resultats = []

for nom_fichier in fichiers_csv:
    print(f"\n--- Traitement de {nom_fichier} ---")
    chemin_fichier = os.path.join(dossier_entree, nom_fichier)

    try:
        # Chargement et préparation du fichier
        df = pd.read_csv(chemin_fichier, header=None)
        header = df.iloc[:3]
        df = df.iloc[3:].copy().reset_index(drop=True)

        # Création des noms de colonnes
        columns = []
        for i in range(df.shape[1]):
            part = str(header.iloc[1, i]).strip() if len(header) > 1 else ""
            coord = str(header.iloc[2, i]).strip() if len(header) > 2 else ""
            if not part or part.lower() in ["nan", ""] or not coord or coord.lower() in ["nan", ""]:
                columns.append(f"frame_{i}")
            else:
                columns.append(f"{part}_{coord}")
        df.columns = columns

        # Conversion en float
        df = df.apply(pd.to_numeric, errors='coerce')

        # Nettoyage des données
        bodyparts = ["Paw", "Elbow", "Shoulder"]
        threshold = 0.10
        conditions = pd.Series(True, index=df.index)
        for bp in bodyparts:
            conditions &= (df[f"{bp}_likelihood"].gt(threshold) & df[f"{bp}_x"].notna() & df[f"{bp}_y"].notna())
        df_clean = df[conditions].copy().reset_index(drop=True)

        # Calcul des vitesses, accélérations et à-coups (jerk)
        for bp in bodyparts:
            df_clean[f"{bp}_vx"] = df_clean[f"{bp}_x"].diff() / dt
            df_clean[f"{bp}_vy"] = df_clean[f"{bp}_y"].diff() / dt
            df_clean[f"{bp}_ax"] = df_clean[f"{bp}_vx"].diff() / dt
            df_clean[f"{bp}_ay"] = df_clean[f"{bp}_vy"].diff() / dt
            df_clean[f"{bp}_jerk_x"] = df_clean[f"{bp}_ax"].diff() / dt
            df_clean[f"{bp}_jerk_y"] = df_clean[f"{bp}_ay"].diff() / dt
            df_clean[f"{bp}_jerk"] = np.sqrt(df_clean[f"{bp}_jerk_x"]**2 + df_clean[f"{bp}_jerk_y"]**2)

        # Calcul des synergies
        delta_paw_y = df_clean["Paw_y"].diff()
        delta_angle = df_clean["Elbow_angle"] = np.degrees(
            np.arctan2(df_clean['Paw_y'] - df_clean['Elbow_y'], df_clean['Paw_x'] - df_clean['Elbow_x']) -
            np.arctan2(df_clean['Shoulder_y'] - df_clean['Elbow_y'], df_clean['Shoulder_x'] - df_clean['Elbow_x'])
        )
        delta_angle = df_clean["Elbow_angle"].diff()
        synergy = (np.sign(delta_paw_y) == np.sign(delta_angle)).astype(int)
        synergy_percent = 100 * synergy.sum() / len(synergy.dropna()) if len(synergy.dropna()) > 0 else np.nan

        # Synergies par phase
        df_clean["delta_paw_x"] = df_clean["Paw_x"].diff()
        df_clean["delta_paw_y"] = df_clean["Paw_y"].diff()
        df_clean["delta_angle"] = df_clean["Elbow_angle"].diff()

        advance_idx = df_clean[df_clean["delta_paw_x"] > 0].index
        lift_idx = df_clean[df_clean["delta_paw_y"] < 0].index
        drop_idx = df_clean[df_clean["delta_paw_y"] > 0].index
        back_idx = df_clean[df_clean["delta_paw_x"] < 0].index

        def compute_synergy(indexes):
            valid = indexes.intersection(df_clean.dropna(subset=["delta_paw_y", "delta_angle"]).index)
            if len(valid) > 0:
                same_dir = (np.sign(df_clean.loc[valid, "delta_paw_y"]) == np.sign(df_clean.loc[valid, "delta_angle"])).sum()
                return 100 * same_dir / len(valid)
            else:
                return np.nan

        synergy_advance = compute_synergy(advance_idx)
        synergy_lift = compute_synergy(lift_idx)
        synergy_drop = compute_synergy(drop_idx)
        synergy_back = compute_synergy(back_idx)

        # Calcul des longueurs de trajectoire
        trajectory_lengths = {bp: calc_trajectory_length(df_clean[f"{bp}_x"], df_clean[f"{bp}_y"]) for bp in bodyparts}

        # Calcul du NJS pour chaque partie du corps
        njs_results = {}
        for bp in bodyparts:
            time = np.arange(len(df_clean)) * dt
            length = trajectory_lengths[bp]
            duration = len(df_clean) * dt
            jerk = df_clean[f"{bp}_jerk"].dropna().values
            time_jerk = np.arange(len(jerk)) * dt
            if len(jerk) > 0 and length > 0:
                njs_results[bp] = calculate_njs(jerk, time_jerk, duration, length)
            else:
                njs_results[bp] = np.nan

        # Sauvegarde des résultats
        data = [
            {"Fichier": nom_fichier, "Métrique": "Synergie globale", "Résultat": synergy_percent, "Unité": "%"},
            {"Fichier": nom_fichier, "Métrique": "Synergie Advance", "Résultat": synergy_advance, "Unité": "%"},
            {"Fichier": nom_fichier, "Métrique": "Synergie Lift", "Résultat": synergy_lift, "Unité": "%"},
            {"Fichier": nom_fichier, "Métrique": "Synergie Drop", "Résultat": synergy_drop, "Unité": "%"},
            {"Fichier": nom_fichier, "Métrique": "Synergie Back", "Résultat": synergy_back, "Unité": "%"},
        ]

        for bp in bodyparts:
            data.append({"Fichier": nom_fichier, "Métrique": f"Longueur de trajectoire de {bp}", "Résultat": trajectory_lengths[bp], "Unité": "pixels"})
            data.append({"Fichier": nom_fichier, "Métrique": f"NJS de {bp}", "Résultat": njs_results[bp], "Unité": ""})

        tous_les_resultats.extend(data)

    except Exception as e:
        print(f"Erreur avec {nom_fichier} : {e}")

# Sauvegarde des résultats dans un fichier Excel
if tous_les_resultats:
    df_resultats_globaux = pd.DataFrame(tous_les_resultats)
    df_resultats_globaux.to_excel(os.path.join(dossier_sortie, "Results.xlsx"), index=False, sheet_name="Résultats")
    print("Tous les résultats ont été sauvegardés dans 'Results.xlsx'.")
else:
    print("Aucun résultat à sauvegarder.")