Biomechanics R&D Engineer & Lecturer

🎯 Context and goals

• The provided scope shows biomechanics R&D focused on running and movement analysis, with a recurring constraint: exploit acquisitions coming from several measurement systems, compare conditions or profiles, and then deliver results in a format that is actionable either for non-developer partners or for students building technical maturity. The observable goals range from designing an experimental protocol and reproducible processing chains to delivering a user-facing analysis interface and teaching data-analysis methods to second-year undergraduate students.

🧪 Work carried out

Projects

• Runner classification and Toutes foulées pipeline — #project-chaire3
• Python Running Analysis interface — #project-chaire4
• Biomechanics course for L2 students and experimental supervision — #project-cours-fss

🧭 Scientific framing and protocol

• Chaire3: I framed a study aimed at identifying runner families from continuous and discrete variables, with a pre-study specifically designed to compare several unsupervised classification methods before scaling them to a larger sample. The visible protocol combines participants, instrumentation, force filtering, stance detection, interpolation, and variable structuring for clustering. Source: Presentation_Projet Toute foulees Pre manip.tex

\begin{frame}\setlength{\parindent}{0.5cm}
L'objectif de l'étude est d'établir des familles de coureurs à partir d'un grand panel de participants (N=200) sur la base de variables temporelles continues et discrètes ("Time Series" type angle d'eversion-inversion au cours du temps et variables ponctuelles type angle Pied-Sol à l'impact). Il s'agira donc de réaliser des classifications dites "non supervisées".\\~\\

Pour la réalisation des futurs clustering, une pré étude est réalisée pour tester les différentes méthodes de clustering utilisées dans la littérature. Cette présentation portera sur la réalisation de la pré étude.\\~\\
\end{frame}

\begin{frame}
\begin{itemize}
\item \underline{Participants} : 50 (actuellement : 47)

• Chaire4: I structured an interface meant to save time on data organization, loading Qualisys and Visual3D files, detecting running events, filtering, interpolation, and saving outputs. The documentation clearly shows an intent to industrialize an analysis chain that had previously been script-based so it could be used by people who are not coding specialists. Source: User_Guide_Interface_Running_Analysis.tex

The purpose of this document is to describe  :
\begin{itemize}
\item Why that interface can help you and can save you time in your data processing
\item How to organize Biomechanic Project Folder with subfolder and files stem from Qualisys \logoQTM{} and Visual3D \logoVisual{}
\item How to loading files in order to process data thanks to this interface
\end{itemize}

This interface will help you to save time thanks to a bunch of processing data  such as :
\begin{itemize}
\item Loading txt files from Visual3D
\item Loading tsv files from Qualisys

• Cours_FSS: I framed the teaching sequence as training in an engineering-study mindset, where students had to define a topic, build a protocol, handle several devices, and write an argued report. The course milestones show progressive autonomy on Qualisys, force-platform, and EMG handling. Source: Slides_Cours_Biomeca_L2.tex

L'objectif du cours est de réussir à mettre en place un protocole de mesure en précisant toute la démarche (les étapes à réaliser, consignes à respecter, notes , précautions à prendre).
Il vous sera demandé d'établir un sujet d'étude que vous aurez défini en groupe et si possible de présenter brièvement les résultats de cette étude.

\begin{itemize}
	\item Travailler en groupe de 2 ou 3
	\item Adopter une démarche d'ingénieur d'étude
	\item Répondre à une éventuelle demande de réalisation d'étude (...) de manière autonome.
	\item Manipuler 2 à 3 appareils
	\item Établir un rapport de 5 pages sur la mise en place d'un protocole

📊 Data analysis

• Matlab / R / Python : I built in Chaire3 a Matlab processing chain that sequences stride detection, filtering, moving average, turn removal, interpolation to 200 points, and the creation of qualitative, quantitative, and time-series tables for downstream analysis. The same project is extended by R scripts that automate normality checks, variance-homogeneity checks, and ANOVA workflows on the groups produced by clustering methods. In Chaire4, I translated this logic into Python by orchestrating Visual3D and Qualisys loading, running-event detection, phase extraction, and export to .mat, .pkl, and .csv, which demonstrates the ability to migrate a scientific-analysis workflow toward a more accessible tool. Source: Traitement_Signaux_IMU.m

[DataFoulee,Event]=Detection_Foulee2(Data);
fe=500;
Fcl=5;
Fch=40;
[Data,DataFilt]=Signaux_Filtre(Data,fe,Fch,Fcl);
move=3000;
DataMeanMove=Signaux_MoveMean(Data,move);
[DataLigneDroite,Data2,RawData]=Detection_Virage(Data,DataMeanMove,DataFoulee,Event,SeuilMin,SeuilMax);
[DataInterp,DataInterpNan,MaxNan,Var0d,Ev,Mean_Ev]= Interpolation(DataLigneDroite,NbInterp,Var0d,Event_GaitCycle0,fe);
[TimeFoulee,Quali_Table,Quanti_Table,Quanti_Table15F,TimeSeries_Table,TimeSeriesNan_Table,~]=Create_Base_SsTable(...)

Source: Script_R_ANOVA.R

model <- lm(JDD2[[Name_Var_Anova[i]]] ~ groups , data=JDD2)
Normality=shapiro.test(residuals(model))
Homogeneity=bartlett.test(JDD2[[Name_Var_Anova[i]]], JDD2$groups)
if (Homogeneity_Var$Homogeneite[i]=='Homogeneite des variances' & LoiNormal_Var$Normalite[i]=='Normal'){
  model_aovsum[[i]] <- AovSum(JDD2[[Name_Var_Anova[i]]]~ groups,data=JDD2)
  model_aov[[i]] <- aov(JDD2[[Name_Var_Anova[i]]]~ groups,data=JDD2)
  model_ezanov= ezANOVA(data = JDD2, wid = Sujet, dv = Cadence, between = .(groups), return_aov = TRUE, detailed = TRUE)
}

• Processing, statistics, visualizations : I industrialized in Python a workflow that closely matches applied biomechanics practice, with multi-format loading, heel-strike, mid-stance, heel-rise, and toe-off detection, parameterized filtering, interpolation, and phase-wise concatenation. On the teaching side, the slides and grading rubric show that I also made the expectations explicit for data analysis, filtering choices, EMG processing, force-platform interpretation, and statistics, which confirms the ability to teach the analytical chain rather than only execute it. Source: Code_Python_Tsv.py

from Packages.Interpolation import interp
from Packages.Get_idx_hs_toeoff import Get_idx_ToeOFF, Get_idx_HS, Get_idx_HRise, Get_idx_MidStance
from Packages.Open_BiomecFiles_Qualisys import Open_Files_Qualisys
from Packages.Filter_Signal import Filter_Signal
from Packages.Open_TxtFiles_Visual3D import Open_TxtFiles_Visual3D
from Packages.Concatenation_Data import Concatenation_Data
from Packages.Concatenation_Phase import Concatenation_Phase
from Packages.Get_Stride import Get_Stride
from Packages.Get_Stance import Get_Stance
from Packages.Get_Flight import Get_Flight

Source: Grille_Notation.xlsx

Grille de notation
Objectif étude
Méthode
Protocole
Synchronisation outils
Analyse des données
Filtre (30 Hz)
Filtre Passe bande
Rectification du signal (valeur absolue)
Analyse statistique
Discussion/Conclusion

🧠 Interpretation and scientific communication

• In Chaire3, I connected signal processing and clustering methods to a question that is understandable for non-specialists: how to identify runner families and compare locomotor strategies from continuous and discrete variables. The LaTeX reports, clustering figures, and presentations show a real effort of scientific communication beyond raw computation.
• In Chaire4, I turned a potentially opaque biomechanics-analysis chain into a documented interface with folder organization, import settings, data visualization, and output export. This is as much an industrialization effort as it is technical communication, because it makes the workflow reusable for people who are less familiar with Matlab or Python.
• In Cours_FSS, I adapted the level and expectations to second-year undergraduates by structuring the sessions around progressive goals, explicit instructions, autonomous handling of the tools, and a grading rubric centered on protocol design, analysis, and discussion. The teaching material also reuses figures produced in the R&D clustering work, showing a strong continuity between applied research and pedagogy.

🧾 Deliverables

• Chaire3: Matlab scripts for IMU processing and table structuring, R scripts for ANOVA and clustering-method comparisons, LaTeX/PDF reports and presentations around the Toutes foulées project, plus protocol and classification figures.
• Chaire4: a Python codebase dedicated to Running Analysis, the interface distributed for Windows and MacOS, a script-only version, a user guide, a Conda environment, example datasets, and save/export logic toward .mat, .pkl, and .csv.
• Cours_FSS: Beamer slides for the Biomechanics - L2 course, protocol and clustering graphics, a detailed grading rubric, and three final student reports, which together document supervision, evaluation, and the progressive empowerment of the student groups.

📈 Results

• I delivered here three complementary projects that cover the full value chain of applied biomechanics work: frame a protocol, process and interpret data, package the workflow into software, and then transfer the method to students. The artifacts show a strong continuity between R&D, software industrialization, and scientific pedagogy, with outputs that are reusable both for technical partners and for learners. The overall benefit is a more direct path from acquisition to analysis and restitution, together with better uptake of the methods by non-expert audiences.

Project Chaire3

• Commit count: unavailable, because the provided folder does not include usable Git history.
• Period: November 2018 to July 2019, based on the pre-study presentations, LaTeX/PDF reports, and article versions visible in the folder.
• Deliverables / outputs: Matlab detection, filtering, interpolation, and tabulation pipeline, R statistics scripts, Toutes foulées presentations and reports, protocol figures, and clustering visuals. Benefit: I structured a reusable analysis chain that moves from raw signals and subject variables to interpretable runner families.

Project Chaire4

• Commit count: unavailable, because the provided folder does not include usable Git history.
• Period: February 2019 to October 2019, based on design files, Python code, user-guide versions, and distributed builds, with environment files updated again in January 2022.
• Deliverables / outputs: Running Analysis interface, scripted version, filtering and event-detection packages, user documentation, Windows executable, and Windows/MacOS project structures. Benefit: I turned an expert biomechanics workflow into a more directly usable tool, which aims to reduce manual post-processing and speed up analytical delivery.

Project Cours FSS

• Commit count: unavailable, because the provided folder does not include usable Git history.
• Period: February 2019 to May 2019 for the course sequence and student submissions, with analytical figures reused from November 2017 to January 2018.
• Deliverables / outputs: L2 teaching slides, session sequencing for February 26, March 12, and March 19, a grading rubric, and final reports from three student groups. Benefit: I connected biomechanics theory, instrumentation, and data analysis in a teaching setup that pushes students toward methodological autonomy and scientific formalization.

🔧 Technical environment

• Matlab for signal processing, interpolation, dataset structuring, and visualizations; R for normality checks, Bartlett tests, ANOVA, and group comparisons; Python for the industrialized analysis workflow. Instrumentation and ecosystem visible in the artifacts include IMUs, Qualisys, Visual3D, Delsys EMG, force platforms, LaTeX/Beamer, PDF outputs, and Excel files. Source: Filter_Signal.py

import numpy as np
import scipy
import matplotlib.pyplot as plt
import pandas as pd

from Class_object.ProgressBar_perso2 import Ui_progressbar_window

def Filter_Signal(data0,
                  datatype=('Kinem'),
                  variable_choosen={'Kinem':['rmt1_z']},