Create app.py

app.py

@@ -0,0 +1,719 @@
+import io
+import re
+import numpy as np
+import pandas as pd
+import streamlit as st
+import matplotlib.pyplot as plt
+import pdfplumber
+
+from zebris_extractor import extract_zebris_csv
+
+st.set_page_config(page_title="Zebris — Profil biomécanique complet", layout="wide")
+
+st.title("Zebris — Profil biomécanique complet")
+st.caption("Import CSV + PDF Zebris → fiche biomécanique enrichie + seuils individualisés")
+
+
+with st.sidebar:
+    st.header("Imports CSV")
+    uploaded_csvs = st.file_uploader(
+        "Importer un ou plusieurs CSV Zebris",
+        type=["csv"],
+        accept_multiple_files=True,
+        key="csvs",
+    )
+
+    st.header("Imports PDF")
+    uploaded_pdfs = st.file_uploader(
+        "Importer un ou plusieurs PDF Zebris",
+        type=["pdf"],
+        accept_multiple_files=True,
+        key="pdfs",
+    )
+
+    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_csvs:
+    st.info("Importe au moins un CSV Zebris.")
+    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 normalize_name(name: str) -> str:
+    if not name:
+        return ""
+    return (
+        str(name)
+        .strip()
+        .lower()
+        .replace("é", "e")
+        .replace("è", "e")
+        .replace("ê", "e")
+        .replace("à", "a")
+        .replace("ù", "u")
+        .replace("ç", "c")
+    )
+
+
+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,
+    }
+
+
+def estimate_attack_from_csv(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"
+        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"
+    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_csv = estimate_attack_from_csv(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,
+        "contraintes": contraintes,
+        "dynamique": dynamique,
+        "symetrie": symetrie,
+        "deroule": deroule,
+        "attaque_csv": attaque_csv,
+    }
+
+
+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 extract_text_from_pdf(uploaded_pdf) -> str:
+    uploaded_pdf.seek(0)
+    raw = uploaded_pdf.read()
+    uploaded_pdf.seek(0)
+
+    text_parts = []
+    with pdfplumber.open(io.BytesIO(raw)) as pdf:
+        for page in pdf.pages:
+            txt = page.extract_text() or ""
+            if txt:
+                text_parts.append(txt)
+    return "\n".join(text_parts)
+
+
+def find_float_after_label(text: str, label: str, max_numbers: int = 2):
+    idx = text.lower().find(label.lower())
+    if idx == -1:
+        return []
+    snippet = text[idx: idx + 500]
+    nums = re.findall(r"(\d+,\d+|\d+\.\d+|\d+)", snippet)
+    out = []
+    for n in nums[:max_numbers]:
+        out.append(float(n.replace(",", ".")))
+    return out
+
+
+def extract_pdf_name(text: str):
+    m = re.search(r"Personne:\s*([A-Za-zÀ-ÿ\- ]+),\s*\d{2}/\d{2}/\d{4}", text)
+    if m:
+        return m.group(1).strip()
+    return None
+
+
+def estimate_attack_from_pdf(pdf_data: dict):
+    heel_peak_t = avg(pdf_data.get("heel_peak_time_pct_g"), pdf_data.get("heel_peak_time_pct_d"))
+    fore_peak_t = avg(pdf_data.get("fore_peak_time_pct_g"), pdf_data.get("fore_peak_time_pct_d"))
+    heel_force = avg(pdf_data.get("heel_force_g"), pdf_data.get("heel_force_d"))
+    fore_force = avg(pdf_data.get("fore_force_g"), pdf_data.get("fore_force_d"))
+    transition = avg(pdf_data.get("transition_g"), pdf_data.get("transition_d"))
+
+    if pd.notna(heel_peak_t) and pd.notna(fore_peak_t):
+        if heel_peak_t <= 12 and pd.notna(transition) and transition >= 0.055:
+            return "attaque talon"
+        if heel_peak_t > 15 and fore_peak_t < 50:
+            return "attaque avant-pied"
+
+    if pd.notna(heel_force) and pd.notna(fore_force) and fore_force != 0:
+        ratio = heel_force / fore_force
+        if ratio > 1.05 and pd.notna(transition) and transition >= 0.055:
+            return "attaque talon"
+        if ratio < 0.90 and pd.notna(transition) and transition <= 0.055:
+            return "attaque avant-pied"
+        return "attaque médio-pied"
+
+    return "indéterminée"
+
+
+def parse_zebris_pdf(uploaded_pdf):
+    text = extract_text_from_pdf(uploaded_pdf)
+    athlete_name = extract_pdf_name(text)
+
+    data = {
+        "athlete_name": athlete_name,
+        "source_pdf": uploaded_pdf.name,
+        "transition_g": np.nan,
+        "transition_d": np.nan,
+        "heel_force_g": np.nan,
+        "heel_force_d": np.nan,
+        "mid_force_g": np.nan,
+        "mid_force_d": np.nan,
+        "fore_force_g": np.nan,
+        "fore_force_d": np.nan,
+        "heel_pressure_g": np.nan,
+        "heel_pressure_d": np.nan,
+        "mid_pressure_g": np.nan,
+        "mid_pressure_d": np.nan,
+        "fore_pressure_g": np.nan,
+        "fore_pressure_d": np.nan,
+        "heel_peak_time_pct_g": np.nan,
+        "heel_peak_time_pct_d": np.nan,
+        "mid_peak_time_pct_g": np.nan,
+        "mid_peak_time_pct_d": np.nan,
+        "fore_peak_time_pct_g": np.nan,
+        "fore_peak_time_pct_d": np.nan,
+    }
+
+    vals = find_float_after_label(text, "Instant du passage du talon vers\nl'avant-pied, s", 2)
+    if len(vals) >= 2:
+        data["transition_g"], data["transition_d"] = vals[0], vals[1]
+
+    vals = find_float_after_label(text, "Force maximale, N\nForefoot (Three zones)", 2)
+    if len(vals) >= 2:
+        data["fore_force_g"], data["fore_force_d"] = vals[0], vals[1]
+
+    vals = find_float_after_label(text, "Midfoot (Three zones)", 2)
+    if len(vals) >= 2:
+        # attention : la première occurrence de Midfoot peut venir de la force ou d'une autre section
+        if pd.isna(data["mid_force_g"]):
+            data["mid_force_g"], data["mid_force_d"] = vals[0], vals[1]
+
+    vals = find_float_after_label(text, "Heel (Three zones)", 2)
+    if len(vals) >= 2:
+        if pd.isna(data["heel_force_g"]):
+            data["heel_force_g"], data["heel_force_d"] = vals[0], vals[1]
+
+    vals = find_float_after_label(text, "Pression maximale, N/cm²\nForefoot (Three zones)", 2)
+    if len(vals) >= 2:
+        data["fore_pressure_g"], data["fore_pressure_d"] = vals[0], vals[1]
+
+    vals = find_float_after_label(text, "Pression maximale, N/cm²\nMidfoot (Three zones)", 2)
+    if len(vals) >= 2:
+        data["mid_pressure_g"], data["mid_pressure_d"] = vals[0], vals[1]
+
+    vals = find_float_after_label(text, "Pression maximale, N/cm²\nHeel (Three zones)", 2)
+    if len(vals) >= 2:
+        data["heel_pressure_g"], data["heel_pressure_d"] = vals[0], vals[1]
+
+    vals = find_float_after_label(text, "Instant pic de force, % de phase d'appui\nForefoot (Three zones)", 2)
+    if len(vals) >= 2:
+        data["fore_peak_time_pct_g"], data["fore_peak_time_pct_d"] = vals[0], vals[1]
+
+    vals = find_float_after_label(text, "Instant pic de force, % de phase d'appui\nMidfoot (Three zones)", 2)
+    if len(vals) >= 2:
+        data["mid_peak_time_pct_g"], data["mid_peak_time_pct_d"] = vals[0], vals[1]
+
+    vals = find_float_after_label(text, "Instant pic de force, % de phase d'appui\nHeel (Three zones)", 2)
+    if len(vals) >= 2:
+        data["heel_peak_time_pct_g"], data["heel_peak_time_pct_d"] = vals[0], vals[1]
+
+    data["attaque_pdf"] = estimate_attack_from_pdf(data)
+    return data
+
+
+def match_pdf_to_athlete(pdfs_data, athlete_name):
+    target = normalize_name(athlete_name)
+    for pdf in pdfs_data:
+        if normalize_name(pdf.get("athlete_name")) == target:
+            return pdf
+    return None
+
+
+# Charge CSV
+dfs = []
+load_errors = []
+
+for f in uploaded_csvs:
+    try:
+        df_one, _ = extract_zebris_csv(f)
+        if not df_one.empty:
+            df_one["Source fichier CSV"] = 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 CSV exploitable n’a pu être importé.")
+    st.stop()
+
+df_std = pd.concat(dfs, ignore_index=True)
+
+# Charge PDF
+pdfs_data = []
+if uploaded_pdfs:
+    for pdf in uploaded_pdfs:
+        try:
+            pdfs_data.append(parse_zebris_pdf(pdf))
+        except Exception as e:
+            st.warning(f"{pdf.name} : erreur lecture PDF ({e})")
+
+# Sélection athlète
+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 CSV"].dropna().unique().tolist())
+if len(sources) > 1:
+    selected_source = st.selectbox("Fichier CSV source", sources)
+    sub_df = sub_df[sub_df["Source fichier CSV"] == 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)
+thresholds = compute_external_thresholds(poids_kg, volume_horaire)
+matched_pdf = match_pdf_to_athlete(pdfs_data, selected_athlete)
+
+attaque_finale = metrics["attaque_csv"]
+if matched_pdf and matched_pdf.get("attaque_pdf") and matched_pdf["attaque_pdf"] != "indéterminée":
+    attaque_finale = matched_pdf["attaque_pdf"]
+
+
+def build_summary(row, metrics, attaque_finale):
+    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é : {attaque_finale}, "
+        f"des contraintes mécaniques {contraintes_txt}, une dynamique {dyn_txt}, une symétrie {sym_txt} "
+        f"et un déroulé {der_txt}."
+    )
+
+
+summary = build_summary(row, metrics, attaque_finale)
+
+tab_profil, tab_seuils, tab_pdf = st.tabs(
+    ["Profil biomécanique", "Seuils individualisés", "Apports du PDF Zebris"]
+)
+
+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 CSV source",
+                    "Poids",
+                    "Cadence",
+                    "Contact",
+                    "Flight",
+                    "Force talon moyenne",
+                    "Force avant-pied moyenne",
+                    "Pression talon moyenne",
+                    "Asymétrie talon",
+                    "COP moyen",
+                    "Différence rotation",
+                    "Type d’attaque estimé",
+                    "Source attaque",
+                ],
+                "Valeur": [
+                    row.get("Source fichier CSV", "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['force_avant_moy']:.1f} N" if pd.notna(metrics["force_avant_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",
+                    attaque_finale,
+                    matched_pdf["source_pdf"] if matched_pdf else "CSV seulement",
+                ],
+            }
+        )
+        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)
+
+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)
+
+with tab_pdf:
+    if not matched_pdf:
+        st.info("Aucun PDF Zebris associé à cet athlète n’a été trouvé.")
+    else:
+        st.subheader("Données extraites du PDF")
+        pdf_df = pd.DataFrame(
+            {
+                "Indicateur": [
+                    "PDF source",
+                    "Type d’attaque estimé",
+                    "Transition talon→avant-pied G",
+                    "Transition talon→avant-pied D",
+                    "Pic force talon G",
+                    "Pic force talon D",
+                    "Pic force médio-pied G",
+                    "Pic force médio-pied D",
+                    "Pic force avant-pied G",
+                    "Pic force avant-pied D",
+                    "Timing pic talon G",
+                    "Timing pic talon D",
+                    "Timing pic médio-pied G",
+                    "Timing pic médio-pied D",
+                    "Timing pic avant-pied G",
+                    "Timing pic avant-pied D",
+                ],
+                "Valeur": [
+                    matched_pdf["source_pdf"],
+                    matched_pdf["attaque_pdf"],
+                    f"{matched_pdf['transition_g']:.3f} s" if pd.notna(matched_pdf["transition_g"]) else "N/A",
+                    f"{matched_pdf['transition_d']:.3f} s" if pd.notna(matched_pdf["transition_d"]) else "N/A",
+                    f"{matched_pdf['heel_force_g']:.1f} N" if pd.notna(matched_pdf["heel_force_g"]) else "N/A",
+                    f"{matched_pdf['heel_force_d']:.1f} N" if pd.notna(matched_pdf["heel_force_d"]) else "N/A",
+                    f"{matched_pdf['mid_force_g']:.1f} N" if pd.notna(matched_pdf["mid_force_g"]) else "N/A",
+                    f"{matched_pdf['mid_force_d']:.1f} N" if pd.notna(matched_pdf["mid_force_d"]) else "N/A",
+                    f"{matched_pdf['fore_force_g']:.1f} N" if pd.notna(matched_pdf["fore_force_g"]) else "N/A",
+                    f"{matched_pdf['fore_force_d']:.1f} N" if pd.notna(matched_pdf["fore_force_d"]) else "N/A",
+                    f"{matched_pdf['heel_peak_time_pct_g']:.1f} %" if pd.notna(matched_pdf["heel_peak_time_pct_g"]) else "N/A",
+                    f"{matched_pdf['heel_peak_time_pct_d']:.1f} %" if pd.notna(matched_pdf["heel_peak_time_pct_d"]) else "N/A",
+                    f"{matched_pdf['mid_peak_time_pct_g']:.1f} %" if pd.notna(matched_pdf["mid_peak_time_pct_g"]) else "N/A",
+                    f"{matched_pdf['mid_peak_time_pct_d']:.1f} %" if pd.notna(matched_pdf["mid_peak_time_pct_d"]) else "N/A",
+                    f"{matched_pdf['fore_peak_time_pct_g']:.1f} %" if pd.notna(matched_pdf["fore_peak_time_pct_g"]) else "N/A",
+                    f"{matched_pdf['fore_peak_time_pct_d']:.1f} %" if pd.notna(matched_pdf["fore_peak_time_pct_d"]) else "N/A",
+                ],
+            }
+        )
+        st.dataframe(pdf_df, hide_index=True, use_container_width=True)
+
+        st.write(
+            "Le PDF apporte surtout des informations temporelles et zonales plus fines, "
+            "notamment pour l’estimation du type d’attaque."
+        )