Create app.py

app.py

@@ -0,0 +1,504 @@
+import numpy as np
+import pandas as pd
+import streamlit as st
+import matplotlib.pyplot as plt
+
+from zebris_extractor import extract_zebris_csv
+
+st.set_page_config(page_title="Zebris — Profil & Seuils", layout="wide")
+
+st.title("Zebris — Profil biomécanique & seuils individualisés")
+st.caption("Import de plusieurs CSV Zebris → choix d’un athlète → fiche profil + seuils personnalisés")
+
+
+with st.sidebar:
+    st.header("Import")
+    uploaded_files = st.file_uploader(
+        "Importer un ou plusieurs fichiers CSV Zebris",
+        type=["csv"],
+        accept_multiple_files=True,
+    )
+
+    if uploaded_files:
+        total_size = sum(f.size for f in uploaded_files)
+        if total_size > 100 * 1024 * 1024:
+            st.error("Volume total de fichiers trop important (>100 MB)")
+            st.stop()
+
+    st.header("Contexte")
+    volume_horaire = st.number_input(
+        "Volume horaire / semaine",
+        min_value=0.5,
+        max_value=40.0,
+        value=5.0,
+        step=0.5,
+    )
+
+if not uploaded_files:
+    st.info("Importe un ou plusieurs CSV Zebris pour afficher la fiche profil et les seuils.")
+    st.stop()
+
+
+def avg(a, b):
+    if pd.isna(a) and pd.isna(b):
+        return np.nan
+    if pd.isna(a):
+        return float(b)
+    if pd.isna(b):
+        return float(a)
+    return (float(a) + float(b)) / 2
+
+
+def asym(a, b):
+    m = avg(a, b)
+    if pd.isna(m) or m == 0 or pd.isna(a) or pd.isna(b):
+        return np.nan
+    return abs(float(a) - float(b)) / m * 100
+
+
+def clamp_score(value, low, high, reverse=False):
+    if pd.isna(value):
+        return np.nan
+    score = (value - low) / (high - low) * 100
+    score = max(0, min(100, score))
+    return 100 - score if reverse else score
+
+
+def safe_mean(values):
+    vals = [v for v in values if pd.notna(v)]
+    if not vals:
+        return np.nan
+    return float(np.mean(vals))
+
+
+def estimate_attack_type(force_talon_moy, force_avant_moy, transition_moy):
+    if pd.isna(force_talon_moy) or pd.isna(force_avant_moy) or force_avant_moy == 0:
+        return "indéterminée"
+
+    ratio = force_talon_moy / force_avant_moy
+
+    if pd.isna(transition_moy):
+        if ratio > 1.10:
+            return "attaque talon"
+        elif ratio < 0.90:
+            return "attaque avant-pied"
+        else:
+            return "attaque médio-pied"
+
+    if ratio > 1.10 and transition_moy >= 0.070:
+        return "attaque talon"
+    elif ratio < 0.90 and transition_moy <= 0.055:
+        return "attaque avant-pied"
+    else:
+        return "attaque médio-pied"
+
+
+def compute_profile_metrics(row, poids_kg):
+    poids_n = poids_kg * 9.81
+
+    force_talon_moy = avg(row["Force talon G (N)"], row["Force talon D (N)"])
+    force_avant_moy = avg(row["Force avant-pied G (N)"], row["Force avant-pied D (N)"])
+    pression_talon_moy = avg(row["Pression talon G (N/cm²)"], row["Pression talon D (N/cm²)"])
+    cop_moy = avg(row["COP G (mm)"], row["COP D (mm)"])
+    transition_moy = avg(row["Transition G (s)"], row["Transition D (s)"])
+
+    asym_talon = asym(row["Force talon G (N)"], row["Force talon D (N)"])
+    asym_avant = asym(row["Force avant-pied G (N)"], row["Force avant-pied D (N)"])
+    asym_cop = asym(row["COP G (mm)"], row["COP D (mm)"])
+
+    diff_rotation = (
+        abs(float(row["Rotation G (°)"]) - float(row["Rotation D (°)"]))
+        if pd.notna(row["Rotation G (°)"]) and pd.notna(row["Rotation D (°)"])
+        else np.nan
+    )
+
+    force_talon_bw = force_talon_moy / poids_n if pd.notna(force_talon_moy) and poids_n else np.nan
+
+    contraintes_force_score = clamp_score(force_talon_bw, 0.15, 0.45)
+    contraintes_pressure_score = clamp_score(pression_talon_moy, 3, 10)
+
+    contraintes = safe_mean([
+        0.6 * contraintes_force_score if pd.notna(contraintes_force_score) else np.nan,
+        0.4 * contraintes_pressure_score if pd.notna(contraintes_pressure_score) else np.nan,
+    ])
+    contraintes = round(contraintes) if pd.notna(contraintes) else np.nan
+
+    dynamique = safe_mean([
+        0.6 * clamp_score(row["Cadence (pas/min)"], 150, 185),
+        0.4 * clamp_score(row["Contact (%)"], 68, 76, reverse=True),
+    ])
+    dynamique = round(dynamique) if pd.notna(dynamique) else np.nan
+
+    sym_components = [x for x in [asym_talon, asym_avant, asym_cop, diff_rotation] if pd.notna(x)]
+    symetrie = round(100 - min(100, np.mean(sym_components) * 2.5)) if sym_components else np.nan
+
+    deroule = safe_mean([
+        0.5 * clamp_score(cop_moy, 210, 260),
+        0.5 * clamp_score(transition_moy, 0.05, 0.09, reverse=True),
+    ])
+    deroule = round(deroule) if pd.notna(deroule) else np.nan
+
+    attaque = estimate_attack_type(force_talon_moy, force_avant_moy, transition_moy)
+
+    return {
+        "force_talon_moy": force_talon_moy,
+        "force_avant_moy": force_avant_moy,
+        "pression_talon_moy": pression_talon_moy,
+        "cop_moy": cop_moy,
+        "transition_moy": transition_moy,
+        "asym_talon": asym_talon,
+        "asym_avant": asym_avant,
+        "asym_cop": asym_cop,
+        "diff_rotation": diff_rotation,
+        "force_talon_bw": force_talon_bw,
+        "contraintes": contraintes,
+        "dynamique": dynamique,
+        "symetrie": symetrie,
+        "deroule": deroule,
+        "attaque": attaque,
+    }
+
+
+def build_summary(row, metrics):
+    contraintes_txt = (
+        "élevées" if pd.notna(metrics["contraintes"]) and metrics["contraintes"] >= 70
+        else "modérées" if pd.notna(metrics["contraintes"]) and metrics["contraintes"] >= 45
+        else "faibles"
+    )
+    dyn_txt = (
+        "bonne" if pd.notna(metrics["dynamique"]) and metrics["dynamique"] >= 70
+        else "moyenne" if pd.notna(metrics["dynamique"]) and metrics["dynamique"] >= 45
+        else "faible"
+    )
+    sym_txt = "satisfaisante" if pd.notna(metrics["symetrie"]) and metrics["symetrie"] >= 70 else "perfectible"
+    der_txt = (
+        "favorable" if pd.notna(metrics["deroule"]) and metrics["deroule"] >= 70
+        else "intermédiaire" if pd.notna(metrics["deroule"]) and metrics["deroule"] >= 45
+        else "à surveiller"
+    )
+
+    return (
+        f"À {row['Vitesse (km/h)']} km/h, {row['Nom']} présente un type d’attaque estimé : {metrics['attaque']}, "
+        f"des contraintes mécaniques {contraintes_txt}, une dynamique {dyn_txt}, une symétrie {sym_txt} "
+        f"et un déroulé {der_txt}."
+    )
+
+
+def draw_radar(metrics):
+    labels = ["Contraintes", "Dynamique", "Symétrie", "Déroulé"]
+    values = [
+        metrics["contraintes"] if pd.notna(metrics["contraintes"]) else 0,
+        metrics["dynamique"] if pd.notna(metrics["dynamique"]) else 0,
+        metrics["symetrie"] if pd.notna(metrics["symetrie"]) else 0,
+        metrics["deroule"] if pd.notna(metrics["deroule"]) else 0,
+    ]
+    values += values[:1]
+    angles = np.linspace(0, 2 * np.pi, len(labels), endpoint=False).tolist()
+    angles += angles[:1]
+
+    fig = plt.figure(figsize=(5, 5))
+    ax = plt.subplot(111, polar=True)
+    ax.plot(angles, values, linewidth=2)
+    ax.fill(angles, values, alpha=0.25)
+    ax.set_xticks(angles[:-1])
+    ax.set_xticklabels(labels)
+    ax.set_ylim(0, 100)
+    ax.set_yticks([25, 50, 75, 100])
+    ax.set_title("Radar biomécanique", pad=20)
+    return fig
+
+
+def draw_evolution(df, poids_kg):
+    data = []
+    for _, r in df.sort_values("Vitesse (km/h)").iterrows():
+        m = compute_profile_metrics(r, poids_kg)
+        data.append({
+            "Vitesse": r["Vitesse (km/h)"],
+            "Contraintes": m["contraintes"],
+            "Dynamique": m["dynamique"],
+            "Symétrie": m["symetrie"],
+            "Déroulé": m["deroule"],
+        })
+
+    evo = pd.DataFrame(data)
+    fig, ax = plt.subplots(figsize=(8, 4))
+    for col in ["Contraintes", "Dynamique", "Symétrie", "Déroulé"]:
+        ax.plot(evo["Vitesse"], evo[col], marker="o", label=col)
+    ax.set_ylim(0, 100)
+    ax.set_xlabel("Vitesse (km/h)")
+    ax.set_ylabel("Score /100")
+    ax.set_title("Évolution avec l’allure")
+    ax.legend()
+    ax.grid(True, alpha=0.3)
+    return fig
+
+
+def compute_external_thresholds(poids_kg, volume_horaire):
+    poids_n = poids_kg * 9.81
+
+    if volume_horaire <= 3:
+        charge = "faible"
+        force_bw_low, force_bw_high = 0.25, 0.40
+        pression_low, pression_high = 4.0, 8.0
+        cadence_low, cadence_high = 160, 172
+        contact_low, contact_high = 69, 74
+        flight_low, flight_high = 26, 30
+        asym_low, asym_high = 6, 10
+        rotation_low, rotation_high = 6, 10
+
+    elif volume_horaire <= 6:
+        charge = "modérée"
+        force_bw_low, force_bw_high = 0.22, 0.37
+        pression_low, pression_high = 4.0, 7.5
+        cadence_low, cadence_high = 164, 176
+        contact_low, contact_high = 68, 73
+        flight_low, flight_high = 27, 31
+        asym_low, asym_high = 5, 9
+        rotation_low, rotation_high = 5, 9
+
+    else:
+        charge = "élevée"
+        force_bw_low, force_bw_high = 0.20, 0.35
+        pression_low, pression_high = 4.0, 7.0
+        cadence_low, cadence_high = 168, 180
+        contact_low, contact_high = 67, 72
+        flight_low, flight_high = 28, 32
+        asym_low, asym_high = 4, 8
+        rotation_low, rotation_high = 4, 8
+
+    return {
+        "charge": charge,
+        "poids_n": poids_n,
+        "force_n_low": force_bw_low * poids_n,
+        "force_n_high": force_bw_high * poids_n,
+        "pression_low": pression_low,
+        "pression_high": pression_high,
+        "cadence_low": cadence_low,
+        "cadence_high": cadence_high,
+        "contact_low": contact_low,
+        "contact_high": contact_high,
+        "flight_low": flight_low,
+        "flight_high": flight_high,
+        "asym_low": asym_low,
+        "asym_high": asym_high,
+        "rotation_low": rotation_low,
+        "rotation_high": rotation_high,
+    }
+
+
+dfs = []
+load_errors = []
+
+for f in uploaded_files:
+    try:
+        df_one, debug = extract_zebris_csv(f)
+        if not df_one.empty:
+            df_one["Source fichier"] = f.name
+            dfs.append(df_one)
+        else:
+            load_errors.append(f"{f.name} : aucune ligne exploitable")
+    except Exception as e:
+        load_errors.append(f"{f.name} : {e}")
+
+if load_errors:
+    for err in load_errors:
+        st.warning(err)
+
+if not dfs:
+    st.error("Aucun fichier exploitable n’a pu être importé.")
+    st.stop()
+
+df_std = pd.concat(dfs, ignore_index=True)
+
+all_athletes = sorted(df_std["Nom"].dropna().unique().tolist())
+selected_athlete = st.selectbox("Athlète", all_athletes)
+
+sub_df = df_std[df_std["Nom"] == selected_athlete].copy()
+if sub_df.empty:
+    st.error("Aucune donnée trouvée pour cet athlète.")
+    st.stop()
+
+sources = sorted(sub_df["Source fichier"].dropna().unique().tolist())
+if len(sources) > 1:
+    selected_source = st.selectbox("Fichier source", sources)
+    sub_df = sub_df[sub_df["Source fichier"] == selected_source].copy()
+
+sub_df = sub_df.sort_values("Vitesse (km/h)")
+speeds = sub_df["Vitesse (km/h)"].dropna().tolist()
+selected_speed = st.selectbox("Allure analysée (km/h)", speeds)
+row = sub_df[sub_df["Vitesse (km/h)"] == selected_speed].iloc[0]
+
+poids_csv = row["Poids (kg)"] if pd.notna(row["Poids (kg)"]) else np.nan
+poids_kg = st.number_input(
+    "Poids du sportif (kg)",
+    min_value=30.0,
+    max_value=150.0,
+    value=float(poids_csv) if pd.notna(poids_csv) else 70.0,
+    step=0.1,
+)
+
+metrics = compute_profile_metrics(row, poids_kg)
+summary = build_summary(row, metrics)
+thresholds = compute_external_thresholds(poids_kg, volume_horaire)
+
+tab_profil, tab_seuils = st.tabs(["Profil biomécanique", "Seuils individualisés"])
+
+with tab_profil:
+    c1, c2, c3, c4 = st.columns(4)
+    with c1:
+        st.metric("Contraintes", f"{metrics['contraintes']}/100" if pd.notna(metrics["contraintes"]) else "N/A")
+    with c2:
+        st.metric("Dynamique", f"{metrics['dynamique']}/100" if pd.notna(metrics["dynamique"]) else "N/A")
+    with c3:
+        st.metric("Symétrie", f"{metrics['symetrie']}/100" if pd.notna(metrics["symetrie"]) else "N/A")
+    with c4:
+        st.metric("Déroulé", f"{metrics['deroule']}/100" if pd.notna(metrics["deroule"]) else "N/A")
+
+    left, right = st.columns([1.2, 1])
+
+    with left:
+        st.subheader("Carte d’identité biomécanique")
+        st.write(summary)
+
+        indicators = pd.DataFrame(
+            {
+                "Indicateur": [
+                    "Fichier source",
+                    "Poids",
+                    "Cadence",
+                    "Contact",
+                    "Flight",
+                    "Force talon moyenne",
+                    "Pression talon moyenne",
+                    "Asymétrie talon",
+                    "COP moyen",
+                    "Différence rotation",
+                    "Type d’attaque estimé",
+                ],
+                "Valeur": [
+                    row.get("Source fichier", "N/A"),
+                    f"{poids_kg:.1f} kg",
+                    f"{row['Cadence (pas/min)']:.1f} pas/min" if pd.notna(row["Cadence (pas/min)"]) else "N/A",
+                    f"{row['Contact (%)']:.1f} %" if pd.notna(row["Contact (%)"]) else "N/A",
+                    f"{row['Flight (%)']:.1f} %" if pd.notna(row["Flight (%)"]) else "N/A",
+                    f"{metrics['force_talon_moy']:.1f} N" if pd.notna(metrics["force_talon_moy"]) else "N/A",
+                    f"{metrics['pression_talon_moy']:.1f} N/cm²" if pd.notna(metrics["pression_talon_moy"]) else "N/A",
+                    f"{metrics['asym_talon']:.1f} %" if pd.notna(metrics["asym_talon"]) else "N/A",
+                    f"{metrics['cop_moy']:.1f} mm" if pd.notna(metrics["cop_moy"]) else "N/A",
+                    f"{metrics['diff_rotation']:.1f}°" if pd.notna(metrics["diff_rotation"]) else "N/A",
+                    metrics["attaque"],
+                ],
+            }
+        )
+        st.dataframe(indicators, hide_index=True, use_container_width=True)
+
+    with right:
+        st.subheader("Radar biomécanique")
+        st.pyplot(draw_radar(metrics), use_container_width=True)
+
+    st.subheader("Évolution avec l’allure")
+    st.pyplot(draw_evolution(sub_df, poids_kg), use_container_width=True)
+
+    st.subheader("Type d’attaque estimé selon l’allure")
+    attaque_rows = []
+    for _, r in sub_df.iterrows():
+        m = compute_profile_metrics(r, poids_kg)
+        attaque_rows.append({
+            "Allure (km/h)": r["Vitesse (km/h)"],
+            "Type d’attaque estimé": m["attaque"],
+            "Transition moyenne (s)": round(m["transition_moy"], 3) if pd.notna(m["transition_moy"]) else np.nan,
+            "Force talon moyenne (N)": round(m["force_talon_moy"], 1) if pd.notna(m["force_talon_moy"]) else np.nan,
+            "Force avant-pied moyenne (N)": round(m["force_avant_moy"], 1) if pd.notna(m["force_avant_moy"]) else np.nan,
+        })
+    st.dataframe(pd.DataFrame(attaque_rows), hide_index=True, use_container_width=True)
+
+with tab_seuils:
+    r1, r2, r3 = st.columns(3)
+    with r1:
+        st.metric("Poids", f"{poids_kg:.1f} kg")
+    with r2:
+        st.metric("Poids en Newton", f"{thresholds['poids_n']:.1f} N")
+    with r3:
+        st.metric("Charge", thresholds["charge"])
+
+    impact_df = pd.DataFrame({
+        "Variable": [
+            "Force talon",
+            "Pression talon",
+        ],
+        "Zone basse / faible": [
+            f"< {thresholds['force_n_low']:.1f} N",
+            f"< {thresholds['pression_low']:.1f} N/cm²",
+        ],
+        "Zone attendue": [
+            f"{thresholds['force_n_low']:.1f} à {thresholds['force_n_high']:.1f} N",
+            f"{thresholds['pression_low']:.1f} à {thresholds['pression_high']:.1f} N/cm²",
+        ],
+        "Zone haute / élevée": [
+            f"> {thresholds['force_n_high']:.1f} N",
+            f"> {thresholds['pression_high']:.1f} N/cm²",
+        ],
+    })
+
+    dynamique_df = pd.DataFrame({
+        "Variable": [
+            "Cadence",
+            "Temps de contact",
+            "Temps de vol",
+        ],
+        "Zone basse / faible": [
+            f"< {thresholds['cadence_low']} pas/min",
+            f"< {thresholds['contact_low']} %",
+            f"< {thresholds['flight_low']} %",
+        ],
+        "Zone attendue": [
+            f"{thresholds['cadence_low']} à {thresholds['cadence_high']} pas/min",
+            f"{thresholds['contact_low']} à {thresholds['contact_high']} %",
+            f"{thresholds['flight_low']} à {thresholds['flight_high']} %",
+        ],
+        "Zone haute / élevée": [
+            f"> {thresholds['cadence_high']} pas/min",
+            f"> {thresholds['contact_high']} %",
+            f"> {thresholds['flight_high']} %",
+        ],
+    })
+
+    symetrie_df = pd.DataFrame({
+        "Variable": [
+            "Asymétrie force talon",
+            "Asymétrie force avant-pied",
+            "Asymétrie COP",
+            "Différence rotation G/D",
+        ],
+        "Zone faible": [
+            f"< {thresholds['asym_low']} %",
+            f"< {thresholds['asym_low']} %",
+            f"< {thresholds['asym_low']} %",
+            f"< {thresholds['rotation_low']}°",
+        ],
+        "Zone modérée": [
+            f"{thresholds['asym_low']} à {thresholds['asym_high']} %",
+            f"{thresholds['asym_low']} à {thresholds['asym_high']} %",
+            f"{thresholds['asym_low']} à {thresholds['asym_high']} %",
+            f"{thresholds['rotation_low']} à {thresholds['rotation_high']}°",
+        ],
+        "Zone marquée": [
+            f"> {thresholds['asym_high']} %",
+            f"> {thresholds['asym_high']} %",
+            f"> {thresholds['asym_high']} %",
+            f"> {thresholds['rotation_high']}°",
+        ],
+    })
+
+    s1, s2, s3 = st.tabs(["Impact", "Dynamique", "Symétrie"])
+    with s1:
+        st.dataframe(impact_df, hide_index=True, use_container_width=True)
+    with s2:
+        st.dataframe(dynamique_df, hide_index=True, use_container_width=True)
+    with s3:
+        st.dataframe(symetrie_df, hide_index=True, use_container_width=True)
+
+    st.write(
+        "Ces seuils sont individualisés à partir du poids et du volume horaire hebdomadaire. "
+        "Les données biomécaniques Zebris ne servent pas à fabriquer les seuils, mais à être comparées à eux."
+    )