C

Jumps Metrics

C

Short Video

E

GitHub Repo

E

Check this App

Jump Metrics for the purpose of research of School of Physical Education and Sports Science of Athens. For this purpose a force platform by PLUX Biosignals has been used to test varius jumps trials and collects the raw data of athletes.

The main scope of this research is to collect raw data, transform and processing them into usable data, calculate and measure varius indicators and export final results to create useful conclusions depending of the needs.

For this reason i choose to use Streamlit App Framework to create a nice and clean web app let the users to navigate very easy into the functionalities. At this point, we should mention that we check various jumps, specifically: Counter Jump, Drop Jump, Isometric, Squad Jump. The plux dyno platform is square in shape, it has four sensors one in each corner. The trial is done as follows:

Jump attempt execution procedure:

– At first we activate the platform.
– Then we find the tare of the platform and mark it down (for the next step).
– Next we tell the athlete to get on the platform and then we are ready to press start the measurement.
– The athlete then begins the jump test procedure.
– As soon as they complete their effort in a few seconds, we press end of recording the values ​​and we are ready to receive the exported file with the raw data.
The App contains a vertical menu (as seen in the photo below) with four main sections.

Prepare File | Insert New Entry | Calculate Results | Statistics

Prepare File:

To use this data to our advantage we first need some kind of pre-processing and cleaning.

 

Short description about the first steps:

In this section we will do that. So far all we have are current data type values.
The processing we need at this stage concerns the following actions:
– To convert these values ​​into weight,
– To remove the weight of the platform
– Calculate the total mass
– To display the total mass in a graph, so that we have the option to keep the interval we want as a final file.

 

The Frontend Area – Using Streamlit App:

The Front Part

In the front part of the application in the “Prepare File” section, the user sees a form where he enters their file with raw data exported from Plux Biosignals hardware, because he is asked to fill in the weight, and then the mass graph is generated. A slider above that gives him the ability to take all the values ​​or to choose the ones he wants along the x-axis. After completing these steps, it is ready to export the final file to csv, which we will use later for further processing.

Behind the scenes:

-After the user insert the file through a form, a new dataframe is created.

– It is checked how many columns the dataframe contains and define the names of the columns, (Mass_1, Mass_2, Mass_2, Mass_4).

– Calculations are made to convert the raw data, from each sensor, into a processed form. Specifically, we want to convert the values ​​of each column into weight, so according to the plux guide we use the equation ( df_raw_data[‘Mass_1’] = df_raw_data[‘Mass_1’] * C / (Vfs_1 * ((2**resolution) – 1 )) ) and some constants (see table).

– We create a new column in the dataframe, the sum of the total weights by subtracting the weight of the platform,  (Mass_Sum).

– We display the graph of the total mass and we create a slider that let the user to get as many interval values ​​as he wishes.

Below following code snippet of this process.

 



Some code..
def get_data():
    if uploaded_file:
        df_raw_data = pd.read_csv(uploaded_file, sep='\s+', skiprows=10, index_col = None)
        #Define Header columns
        columns_count = len(df_raw_data.axes[1])
        if columns_count == 6:
            df_raw_data.columns = ['Time', 'Col_2', 'Mass_1', 'Mass_2', 'Mass_3', 'Mass_4']
        C = 406.831
        #sr = 1000
        resolution = 16
        # Calculate for A Sensor Mass
        Vfs_1 = 2.00016
        df_raw_data['Mass_1'] = df_raw_data['Mass_1'] * C / (Vfs_1 * ((2**resolution) - 1 ))
        # Calculate for B Sensor Mass
        Vfs_2 = 2.00002
        df_raw_data['Mass_2'] = df_raw_data['Mass_2'] * C / (Vfs_2 * ((2**resolution) - 1 ))
        # Calculate for C Sensor Mass
        Vfs_3 = 2.00057
        df_raw_data['Mass_3'] = df_raw_data['Mass_3'] * C / (Vfs_3 * ((2**resolution) - 1 ))
        # Calculate for D Sensor Mass
        Vfs_4 = 2.00024
        df_raw_data['Mass_4'] = df_raw_data['Mass_4'] * C / (Vfs_4 * ((2**resolution) - 1 ))
        # Calculate the sum of all sensors Mass
        df_raw_data['Mass_Sum'] = (df_raw_data['Mass_1'] + df_raw_data['Mass_2'] + 
	df_raw_data['Mass_3'] + df_raw_data['Mass_4']) - platform_mass
        df_raw_data['Rows_Count'] = df_raw_data.index
        return df_raw_data

Insert New Entry

The Frontend Area - Using Streamlit App:

 

 

In this section the user is able to add a new athlete's effort to the database.

First, he needs to fill in all the fields of the athlete and then import the file he prepared in the previous step "File Preparations".

If the same athlete is already in the database, the user has the possibility to select him from the drop down menu and the fields with his data will be written automatically by the system, then all he needs is to put the jump attempt file which he did.

Behind the scenes:

In this section, we first collect all the data from the user-attempts table of the database, in order to give the possibility to the user to find any existing entry.

Then we create a form with the necessary input fields in the base that the user will need to make the registration.

Then we create the code that will take these values from the fields and insert them as a new entry in the table in the database.

Below are small code snippets.



Some code..
def select_all_from_balance_table():
    query=con.table("balance_table").select("*").execute()
    return query
query = select_all_from_balance_table()
df_balance_table = pd.DataFrame(query.data)
df_balance_table_unique_values = df_balance_table.copy()
fullname_input = st.selectbox("Select a person from the database or fill in the fields below. " , (df_balance_table_unique_values['fullname']))
row_index = df_balance_table_unique_values.index[df_balance_table_unique_values['fullname']==fullname_input].tolist()
st.markdown("""---""")
 



#Some code..
#Create the Form to submit data to database:
with st.form("Create a new entry", clear_on_submit=False):
    fullname = st.text_input("Fullname", value = df_balance_table_unique_values.loc[row_index[0]]['fullname'])
    age = st.number_input("Age", value = int(df_balance_table_unique_values.loc[row_index[0]]['age']), min_value=0, max_value=100, step=1)
    height = st.number_input("Height in cm", value = df_balance_table_unique_values.loc[row_index[0]]['height'])
    weight = st.number_input("Weight in kg", value = df_balance_table_unique_values.loc[row_index[0]]['weight'])
    email = st.text_input("Email address")
    occupy = st.text_input("Occupy", value = df_balance_table_unique_values.loc[row_index[0]]['occupy'])
    #type_of_trial = st.selectbox("Kind of Trial", ('-','CMJ', 'SJ','DJ','ISO' ))
    filepath = st.file_uploader("Choose a file")
    #checkbox_val = st.checkbox("Form checkbox")
    submitted = st.form_submit_button("Submit values")
    
    if submitted:
    
#Some code..
def add_entries_to_jumps_table(supabase):
                value = {'fullname': fullname, 'email': email, 'occupy': occupy, 'type_of_trial': type_of_trial,
                        'filename': filename, "filepath": filepath, "height": height, "weight": weight, "age": age }
                data = supabase.table('jumps_table').insert(value).execute()
            def main():
                new_entry = add_entries_to_jumps_table(con)
            main()
            st.success('Thank you! A new entry has been inserted to database!')
            st.write(list)
        else:
            st.error("One of the field values is missing")

Calculate Results

The Frontend Area - Using Streamlit App:

In this section, most of the calculation steps of the application are done. In the front part, as we can see in the image, the table with all the athletes' trial registrations with their details appears.

In the left menu the user has the possibility to delete an entry and from below to run an entry.
After he writes the name of the effort he wants and clicks calculate results, then the system automatically runs the code and all the information appears on the central screen.

As can be seen in the next image, first the central graph appears with the acceleration, speed and the corresponding iemtzi of the effort. Then some effort times are calculated which are a reference point for other calculations, such as the jump.

Below we also see the table with all the data of this effort, the user can define time points in the fields and the corresponding interval will appear.

The only thing the user has to do is write down the time points in the fields, and the system will calculate all the variables needed, such as the jump, the three breaks.

Parallel to this, the table will be updated to display the corresponding values ​​in this interval.

Finally, the user can export a file to csv all the values ​​needed.

 

Behind the scenes:

 

 

 

 

Below are small code snippets.

B

scroll on top

Python 3.10 V

Packages used:
-altair
-biosignalsnotebooks
-numpy
-pandas
-plotly
-streamlit
-supabase
-sympy
-bokeh

Service used:
- Hosted at Streamlit Cloud
- Supabase platform database

Feutures:
- Multi-pages
- Preprocessing raw data
- Calculate many indicators
- Insert/Delete Data
- Display tables/charts
- Export data