worklab 2.0.0__tar.gz → 2.1.0__tar.gz

{worklab-2.0.0 → worklab-2.1.0}/LICENSE

@@ -632,7 +632,7 @@ state the exclusion of warranty; and each file should have at least
 the "copyright" line and a pointer to where the full notice is found.
 
     Analysis
-    Copyright (C) 2018  Rick de Klerk
+    Copyright (C) 2018  Sophie de Klerk
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -652,7 +652,7 @@ Also add information on how to contact you by electronic and paper mail.
   If the program does terminal interaction, make it output a short
 notice like this when it starts in an interactive mode:
 
-    Analysis  Copyright (C) 2018  Rick de Klerk
+    Analysis  Copyright (C) 2018  Sophie de Klerk
     This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
     This is free software, and you are welcome to redistribute it
     under certain conditions; type `show c' for details.

{worklab-2.0.0 → worklab-2.1.0}/PKG-INFO

@@ -1,8 +1,8 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: worklab
-Version: 2.0.0
+Version: 2.1.0
 Summary: Basic scripts for worklab devices
-Author-email: Rick de Klerk <r.de.klerk@pl.hanze.nl>, Thomas Rietveld <t.rietveld@lboro.ac.uk>, Rowie Janssen <r.j.f.janssen@umcg.nl>, Jelmer Braaksma <j.braaksma01@umcg.nl>
+Author-email: Sophie de Klerk <r.de.klerk@pl.hanze.nl>, Thomas Rietveld <t.rietveld@lboro.ac.uk>, Rowie Janssen <r.j.f.janssen@umcg.nl>, Jelmer Braaksma <j.braaksma01@umcg.nl>
 License:                     GNU GENERAL PUBLIC LICENSE
                                Version 3, 29 June 2007
         
@@ -637,7 +637,7 @@ License:                     GNU GENERAL PUBLIC LICENSE
         the "copyright" line and a pointer to where the full notice is found.
         
             Analysis
-            Copyright (C) 2018  Rick de Klerk
+            Copyright (C) 2018  Sophie de Klerk
         
             This program is free software: you can redistribute it and/or modify
             it under the terms of the GNU General Public License as published by
@@ -657,7 +657,7 @@ License:                     GNU GENERAL PUBLIC LICENSE
           If the program does terminal interaction, make it output a short
         notice like this when it starts in an interactive mode:
         
-            Analysis  Copyright (C) 2018  Rick de Klerk
+            Analysis  Copyright (C) 2018  Sophie de Klerk
             This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
             This is free software, and you are welcome to redistribute it
             under certain conditions; type `show c' for details.
@@ -678,8 +678,8 @@ License:                     GNU GENERAL PUBLIC LICENSE
         Public License instead of this License.  But first, please read
         <http://www.gnu.org/philosophy/why-not-lgpl.html>.
         
-Project-URL: Homepage, https://github.com/rickdkk/worklab
-Project-URL: Bug Reports, https://github.com/rickdkk/worklab/issues
+Project-URL: Homepage, https://github.com/sophiedkk/worklab
+Project-URL: Bug Reports, https://github.com/sophiedkk/worklab/issues
 Keywords: biomechanics,ergometry,physiology
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
@@ -693,16 +693,20 @@ Requires-Dist: numpy
 Requires-Dist: pandas
 Requires-Dist: matplotlib
 Requires-Dist: xlrd
+Requires-Dist: scikit-learn
+Requires-Dist: seaborn
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: Flake8-pyproject; extra == "dev"
 Requires-Dist: black; extra == "dev"
 Requires-Dist: jupyter-book; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Dynamic: license-file
 
 # Worklab: a wheelchair biomechanics mini-package
 
 [![image](https://zenodo.org/badge/DOI/10.5281/zenodo.8362962.svg)](https://doi.org/10.5281/zenodo.8362962)
-[![image](https://badge.fury.io/py/worklab.svg)](https://badge.fury.io/py/worklab) [![image](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gitlab.com/Rickdkk/worklab/tree/master/LICENCE)
+[![image](https://badge.fury.io/py/worklab.svg)](https://badge.fury.io/py/worklab) [![image](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://github.com/sophiedkk/worklab/blob/main/LICENSE)
 
 Essential data analysis and (pre-)processing scripts used in projects
 researching the Lode
@@ -722,7 +726,7 @@ the worklab, which means:
 # Documentation
 
 For more detailed documentation you can look at the
-[docs](https://rickdkk.github.io/worklab/).
+[docs](https://sophiedkk.github.io/worklab/).
 
 # Prerequisites
 
@@ -739,7 +743,7 @@ You can install this package with pip:
 # Examples
 
 You can find some Jupyter Notebook examples
-[here](https://rickdkk.github.io/worklab/chapters/examples.html).
+[here](https://sophiedkk.github.io/worklab/chapters/examples.html).
 
 # Reporting errors
 
@@ -751,4 +755,4 @@ me or submit an issue through this page.
 If you want to refer to this package please use this DOI:
 10.5281/zenodo.8362962, or cite:
 
-Rick de Klerk, Thomas Rietveld, Rowie Janssen, & Jelmer Braaksma. (2023). Worklab: a wheelchair biomechanics mini-package. Zenodo. https://doi.org/10.5281/zenodo.8362963
+Sophie de Klerk, Thomas Rietveld, Rowie Janssen, & Jelmer Braaksma. (2023). Worklab: a wheelchair biomechanics mini-package. Zenodo. https://doi.org/10.5281/zenodo.8362963

{worklab-2.0.0 → worklab-2.1.0}/README.md

@@ -1,7 +1,7 @@
 # Worklab: a wheelchair biomechanics mini-package
 
 [![image](https://zenodo.org/badge/DOI/10.5281/zenodo.8362962.svg)](https://doi.org/10.5281/zenodo.8362962)
-[![image](https://badge.fury.io/py/worklab.svg)](https://badge.fury.io/py/worklab) [![image](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gitlab.com/Rickdkk/worklab/tree/master/LICENCE)
+[![image](https://badge.fury.io/py/worklab.svg)](https://badge.fury.io/py/worklab) [![image](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://github.com/sophiedkk/worklab/blob/main/LICENSE)
 
 Essential data analysis and (pre-)processing scripts used in projects
 researching the Lode
@@ -21,7 +21,7 @@ the worklab, which means:
 # Documentation
 
 For more detailed documentation you can look at the
-[docs](https://rickdkk.github.io/worklab/).
+[docs](https://sophiedkk.github.io/worklab/).
 
 # Prerequisites
 
@@ -38,7 +38,7 @@ You can install this package with pip:
 # Examples
 
 You can find some Jupyter Notebook examples
-[here](https://rickdkk.github.io/worklab/chapters/examples.html).
+[here](https://sophiedkk.github.io/worklab/chapters/examples.html).
 
 # Reporting errors
 
@@ -50,4 +50,4 @@ me or submit an issue through this page.
 If you want to refer to this package please use this DOI:
 10.5281/zenodo.8362962, or cite:
 
-Rick de Klerk, Thomas Rietveld, Rowie Janssen, & Jelmer Braaksma. (2023). Worklab: a wheelchair biomechanics mini-package. Zenodo. https://doi.org/10.5281/zenodo.8362963
+Sophie de Klerk, Thomas Rietveld, Rowie Janssen, & Jelmer Braaksma. (2023). Worklab: a wheelchair biomechanics mini-package. Zenodo. https://doi.org/10.5281/zenodo.8362963

{worklab-2.0.0 → worklab-2.1.0}/pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "worklab"
-version = "2.0.0"
+version = "2.1.0"
 description = "Basic scripts for worklab devices"
 readme = "README.md"
 requires-python = ">=3.7"
 license = {file = "LICENSE"}
 keywords = ["biomechanics", "ergometry", "physiology"]
 authors = [
-  {name = "Rick de Klerk", email = "r.de.klerk@pl.hanze.nl"},
+  {name = "Sophie de Klerk", email = "r.de.klerk@pl.hanze.nl"},
   {name = "Thomas Rietveld", email = "t.rietveld@lboro.ac.uk"},
   {name = "Rowie Janssen", email = "r.j.f.janssen@umcg.nl"},
   {name = "Jelmer Braaksma", email = "j.braaksma01@umcg.nl"}
@@ -23,7 +23,9 @@ dependencies = [
   "numpy",
   "pandas",
   "matplotlib",
-  "xlrd"
+  "xlrd",
+  "scikit-learn",
+  "seaborn"
 ]
 
 [project.optional-dependencies]
@@ -31,12 +33,13 @@ dev = [
     "pytest",
     "Flake8-pyproject",
     "black",
-    "jupyter-book"
+    "jupyter-book",
+    "build"
 ]
 
 [project.urls]
-"Homepage" = "https://github.com/rickdkk/worklab"
-"Bug Reports" = "https://github.com/rickdkk/worklab/issues"
+"Homepage" = "https://github.com/sophiedkk/worklab"
+"Bug Reports" = "https://github.com/sophiedkk/worklab/issues"
 
 [build-system]
 requires = ["setuptools>=43.0.0", "wheel"]

{worklab-2.0.0 → worklab-2.1.0}/worklab/ana.py

@@ -4,6 +4,9 @@ import copy
 import math
 import pandas as pd
 import matplotlib.pyplot as plt
+import numpy as np
+import sklearn
+import seaborn as sns
 
 from .plots import plot_power_speed_dist
 from .physio import calc_weighted_average
@@ -58,7 +61,7 @@ def cut_data(data, start, end, distance=True):
         data[side] = data[side][(data[side]["time"] > start) & (data[side]["time"] < end)]
         data[side]["time"] = data[side]["time"] - start
         if distance:
-            data[side]["dist"] = data[side]["dist"] - data[side]["dist"].iloc[0]
+            data[side]["dist"] -= data[side]["dist"].iloc[0]
         data[side].reset_index(drop=True, inplace=True)
 
     return data
@@ -592,3 +595,93 @@ def ana_submax(data_ergo, data_pbp, data_spiro):
     outcomes = pd.concat([mean_ergo, mean_spiro], axis=1)
     outcomes["me"] = (outcomes["meanpower"] / outcomes["EE"]) * 100
     return outcomes
+
+
+def force_velocity_curve(data_pbp, upper_lim=800, var='max'):
+    """
+    Creates force-velocity curves for wheelchair sports
+
+    Parameters
+    ----------
+    data_pbp : pd.DataFrame
+        processed push-by-push ergometer dataframe with output for all 6 sprints
+    upper_lim : int
+        upper limit recommendations for LP (800) and HP (1400)
+    var : str
+        'max' force and velocity or 'mean' force and velocity
+
+    Returns
+    -------
+    fig : figure
+        force-velocity plot
+    variables : pd.DataFrame
+        r2, optimal velocity/power, x/y coordinates and coefficient
+
+    """
+    if var == 'max':
+        speed = 'maxspeed'
+        force = 'maxuforce'
+    else:
+        speed = 'meanspeed'
+        force = 'meanuforce'
+
+    data_pbp = data_pbp[data_pbp.index > 0]
+    x = np.array(data_pbp[speed]).reshape((-1, 1))
+    y = np.array(data_pbp[force])
+    data_pbp['x'] = np.array(data_pbp[speed]).reshape((-1, 1))
+    data_pbp['y'] = np.array(data_pbp[force])
+    model = sklearn.LinearRegression()
+    model.fit(x, y)
+    model = sklearn.LinearRegression().fit(x, y)
+    r_sq = model.score(x, y)
+    x1 = np.linspace(0, float(abs(model.intercept_ / model.coef_)), 100)
+    xx = np.linspace(x.min(), x.max(), 100)
+
+    pred_y = model.intercept_ + model.coef_ * x
+    pred_y1 = model.intercept_ + model.coef_ * x1
+    pred_y2 = model.intercept_ + model.coef_ * xx
+    power = xx * pred_y2
+    power1 = x1 * pred_y1
+    parabola = pd.DataFrame({'POmax': power1, 'vmax': x1})
+    pomax_pos = parabola['POmax'].idxmax()
+    pomax_opt = parabola['POmax'].max()
+    vmax_opt = parabola['vmax'][pomax_pos]
+
+    variables = pd.DataFrame([])
+    variables['R2'] = [r_sq]
+    variables['opt_vel'] = vmax_opt
+    variables['opt_pow'] = pomax_opt
+    variables['y_cor'] = model.intercept_
+    variables['x_cor'] = x1[-1]
+    variables['coef'] = model.coef_
+    variables = round(variables, 2)
+
+    sns.set_style('darkgrid')
+    col_pal = sns.color_palette("dark:#5A9_r")
+    sns.set_palette(col_pal)
+    fig, ax = plt.subplots(1, 1, figsize=(14, 8))
+    ax.set_ylabel('Force [N]', fontsize=14)
+    ax.set_ylim(0, upper_lim)
+    ax.set_xlabel('Velocity [ms]', fontsize=14)
+    ax.set_xlim(0, 6)
+    ax.tick_params(axis='both', labelsize=12)
+    ax = sns.scatterplot(data=data_pbp, x='x', y='y', hue='Resistance')
+    ax.plot(x1, pred_y1, color='k', linestyle='--')
+    ax.plot(x, pred_y, color='k')
+    ax.annotate('R2 = ' + str(round(r_sq, 2)), xy=(0.75, 0.90), xycoords='axes fraction')
+    ax.annotate('y = ' + str(round(model.intercept_, 1)) + ' ' + str(round(model.coef_[0], 1)) + ' * x',
+                xy=(0.75, 0.85), xycoords='axes fraction')
+
+    ax1 = ax.twinx()
+    ax1.grid(False)
+    ax1.plot(x1, power1, color='grey', linestyle='--')
+    ax1.plot(xx, power, color='grey')
+    ax1.set_ylim(0, upper_lim)
+    ax1.set_ylabel('Power [W]', color='grey', fontsize=14)
+    ax1.yaxis.label.set_color('grey')
+    ax1.spines['right'].set_color('grey')
+    ax1.tick_params(axis='y', colors='grey')
+    ax1.tick_params(axis='both', labelsize=12)
+    ax1.annotate('Optimal velocity (' + str(round(vmax_opt, 1)) + ' ms)', xy=(0.75, 0.95), xycoords='axes fraction')
+
+    return fig, variables

{worklab-2.0.0 → worklab-2.1.0}/worklab/com.py

@@ -87,7 +87,7 @@ def load_spiro(filename):
 
     Loads spirometer data to a pandas DataFrame, converts time to seconds (not datetime), computes energy expenditure,
     computes weights from the time difference between samples, if no heart rate data is available it fills
-    the column with np.NaNs. Returns a DataFrame with:
+    the column with nans. Returns a DataFrame with:
 
     +------------+----------------------------+-----------+
     | Column     | Data                       | Unit      |
@@ -139,7 +139,7 @@ def load_spiro(filename):
     data["VO2"] = data["VO2"] / 1000  # to l/min
     data["VCO2"] = data["VCO2"] / 1000  # to l/min
     data["RER"] = data["VCO2"] / data["VO2"]
-    data["HR"] = np.NaN if "HR" not in data else data["HR"]  # missing when sensor is not detected
+    data["HR"] = np.nan if "HR" not in data else data["HR"]  # missing when sensor is not detected
     data["O2pulse"] = data["VO2"] / data["HR"]
     data["VE/VO2"] = data["VE"] / data["VO2"]
     data["VE/VCO2"] = data["VE"] / data["VCO2"]
@@ -165,7 +165,7 @@ def load_spiro(filename):
     ]
 
 
-def load_spiro_metamax(filename):
+def load_spiro_metamax(filename, sheet_name=0):
     """
     Loads metamax 3B spirometer data from Excel file.
 
@@ -209,6 +209,8 @@ def load_spiro_metamax(filename):
     ----------
     filename : str
         full file path or file in existing path from metamax 3B spirometer
+    sheet_name : str or int
+        sheet name, default = 0
 
     Returns
     -------
@@ -217,11 +219,19 @@ def load_spiro_metamax(filename):
 
 
     """
-    data = pd.read_excel(filename, skiprows=[*range(0, 124, 1)])
+    excel_data = pd.ExcelFile(filename)
+
+    # Loop through rows to find the one containing 't' in the first row
+    for index, row in enumerate(excel_data.parse(sheet_name=sheet_name, header=None).itertuples(index=False)):
+        if 't' in row:
+            skip_until = index
+            break
+
+    data = pd.read_excel(filename, skiprows=[*range(0, skip_until, 1)], sheet_name=sheet_name)
     # units = data.iloc[0, :]
     data.drop(0, inplace=True)
 
-    data.replace("-", np.NaN, inplace=True)
+    data.replace("-", np.nan, inplace=True)
 
     data.rename(columns={"t": "time", "V'O2": "VO2", "V'E": "VE"}, inplace=True)
     data["VCO2"] = data["V'E/V'CO2"] * (data["VE"])
@@ -233,7 +243,7 @@ def load_spiro_metamax(filename):
     data["VO2"] = data["VO2"].astype(float)
     data["EE"] = ((4.94 * data["RER"] + 16.04) * (1000 * data["VO2"])) / 60
     data["weights"] = np.insert(np.diff(data["time"]), 0, 0)  # used for calculating weighted average
-    data["HR"] = (np.NaN if "HR" not in data else data["HR"]).astype(int)  # missing when sensor is not detected
+    data["HR"] = (np.nan if "HR" not in data else data["HR"]).astype(int)  # missing when sensor is not detected
     data["O2pulse"] = data["VO2"] / data["HR"]
     data["VCO2"].replace(0, 0.01, inplace=True)
     data["VO2"].replace(0, 0.01, inplace=True)
@@ -946,26 +956,39 @@ def load_ximu3(root_dir, filenames=None, inplace=False):
 
     if 'right' in sessiondata.keys():
         sessiondata["right"] = sessiondata["right"]["Inertial"]
-        sessiondata["right"]["timestamp"] -= sessiondata["right"]["timestamp"][0]
     else:
         print('No right sensor imported')
     if 'frame' in sessiondata.keys():
         sessiondata["frame"] = sessiondata["frame"]["Inertial"]
-        sessiondata["frame"]["timestamp"] -= sessiondata["frame"]["timestamp"][0]
     else:
         print('No frame sensor imported')
     if 'left' in sessiondata.keys():
         sessiondata["left"] = sessiondata["left"]["Inertial"]
-        sessiondata["left"]["timestamp"] -= sessiondata["left"]["timestamp"][0]
     else:
         print('No left sensor imported')
     if 'trunk' in sessiondata.keys():
         sessiondata["trunk"] = sessiondata["trunk"]["Inertial"]
-        sessiondata["trunk"]["timestamp"] -= sessiondata["trunk"]["timestamp"][0]
     else:
         print('No trunk sensor imported')
 
+    start_time = np.max([sessiondata['frame']['timestamp'].min(), sessiondata['left']['timestamp'].min(),
+                         sessiondata['right']['timestamp'].min()])
+    stop_time = np.min([sessiondata['frame']['timestamp'].max(), sessiondata['left']['timestamp'].max(),
+                        sessiondata['right']['timestamp'].max()])
+
+    for sensor in sessiondata:
+        sessiondata[sensor] = sessiondata[sensor][sessiondata[sensor]['timestamp'] >= start_time]
+        sessiondata[sensor] = sessiondata[sensor][sessiondata[sensor]['timestamp'] <= stop_time]
+
+    start_time = np.max([sessiondata['frame']['timestamp'].min(), sessiondata['left']['timestamp'].min(),
+                         sessiondata['right']['timestamp'].min()])
+    stop_time = np.min([sessiondata['frame']['timestamp'].max(), sessiondata['left']['timestamp'].max(),
+                        sessiondata['right']['timestamp'].max()])
+
     for sensor in sessiondata:
+        sessiondata[sensor] = sessiondata[sensor][sessiondata[sensor]['timestamp'] >= start_time]
+        sessiondata[sensor] = sessiondata[sensor][sessiondata[sensor]['timestamp'] <= stop_time]
+        sessiondata[sensor] = sessiondata[sensor].reset_index(drop=True)
         sessiondata[sensor]['time'] = pd.to_datetime(sessiondata[sensor]['timestamp'], unit='us')
         sessiondata[sensor]['time'] -= sessiondata[sensor]['time'][0]
         sessiondata[sensor]['time'] = sessiondata[sensor]['time'].dt.total_seconds()

{worklab-2.0.0 → worklab-2.1.0}/worklab/imu.py

@@ -2,8 +2,8 @@ import copy
 from warnings import warn
 
 import numpy as np
-from scipy.integrate import cumtrapz
-from scipy.signal import periodogram, find_peaks
+from scipy.integrate import cumulative_trapezoid
+from scipy.signal import periodogram, find_peaks, savgol_filter
 
 from .utils import lowpass_butter, pd_interp
 
@@ -32,10 +32,10 @@ def resample_imu(sessiondata, sfreq=400.0):
     https://github.com/xioTechnologies/NGIMU-MATLAB-Import-Logged-Data-Example
 
     """
-    end_time = 0
+    end_time = np.inf
     for device in sessiondata:
         max_time = sessiondata[device]["time"].max()
-        end_time = max_time if max_time > end_time else end_time
+        end_time = max_time if max_time < end_time else end_time
 
     new_time = np.arange(0, end_time, 1 / sfreq)
 
@@ -85,6 +85,7 @@ def process_imu(sessiondata, camber=18, wsize=0.32, wbase=0.80, n_sensors=3, sen
 
     sfreq = 1 / frame["time"].diff().mean()
     frame["rot_vel"] = lowpass_butter(frame["gyroscope_z"], sfreq=sfreq, cutoff=6)
+    frame['rot_vel'] = savgol_filter(frame['rot_vel'], window_length=100, polyorder=3)
     right['gyroscope_y'] = lowpass_butter(right['gyroscope_y'], sfreq=sfreq, cutoff=10)
 
     # Wheelchair camber correction
@@ -101,16 +102,16 @@ def process_imu(sessiondata, camber=18, wsize=0.32, wbase=0.80, n_sensors=3, sen
         frame["gyro_cor"] = right["gyro_cor"]
 
     # Calculation of rotations, rotational velocity and rotational acceleration
-    frame["rot"] = cumtrapz(abs(frame["rot_vel"]) / sfreq, initial=0.0)
+    frame["rot"] = cumulative_trapezoid(abs(frame["rot_vel"]) / sfreq, initial=0.0)
     frame["rot_acc"] = np.gradient(frame["rot_vel"]) * sfreq
 
     # Calculation of velocity, acceleration and distance
     right["vel"] = right["gyro_cor"] * wsize * deg2rad  # angular velocity to linear velocity
-    right["dist"] = cumtrapz(right["vel"] / sfreq, initial=0.0)  # integral of velocity gives distance
+    right["dist"] = cumulative_trapezoid(right["vel"] / sfreq, initial=0.0)  # integral of velocity gives distance
 
     if n_sensors == 3:
         left["vel"] = left["gyro_cor"] * wsize * deg2rad
-        left["dist"] = cumtrapz(left["vel"] / sfreq, initial=0.0)
+        left["dist"] = cumulative_trapezoid(left["vel"] / sfreq, initial=0.0)
         frame["vel_wheel"] = (right["vel"] + left["vel"]) / 2  # mean velocity both sides
         frame["dist_wheel"] = (right["dist"] + left["dist"]) / 2  # mean distance
     else:
@@ -148,17 +149,17 @@ def process_imu(sessiondata, camber=18, wsize=0.32, wbase=0.80, n_sensors=3, sen
         comb_ratio = np.clip(comb_ratio, 0, 1)  # clamp Combine ratio values, not in df
         frame["skid_vel"] = (frame["vel_right"] * comb_ratio) + (frame["vel_left"] * (1 - comb_ratio))
         frame["vel"] = (frame["vel_right"] + frame["vel_left"]) / 2
-        frame['dist'] = cumtrapz(frame["skid_vel"], initial=0.0) / sfreq
+        frame['dist'] = cumulative_trapezoid(frame["skid_vel"], initial=0.0) / sfreq
     else:
         frame["vel"] = frame["vel_right"]
-        frame["dist"] = cumtrapz(frame["vel"], initial=0.0) / sfreq  # Combined distance
+        frame["dist"] = cumulative_trapezoid(frame["vel"], initial=0.0) / sfreq  # Combined distance
 
     # distance in the x and y direction
-    frame["dist_y"] = cumtrapz(
-        np.gradient(frame["dist"]) * np.sin(np.deg2rad(cumtrapz(frame["rot_vel"] / sfreq, initial=0.0))),
+    frame["dist_y"] = cumulative_trapezoid(
+        frame['vel'] / sfreq * np.sin(np.deg2rad(cumulative_trapezoid(frame["rot_vel"] / sfreq, initial=0.0))),
         initial=0.0)
-    frame["dist_x"] = cumtrapz(
-        np.gradient(frame["dist"]) * np.cos(np.deg2rad(cumtrapz(frame["rot_vel"] / sfreq, initial=0.0))),
+    frame["dist_x"] = cumulative_trapezoid(
+        frame['vel'] / sfreq * np.cos(np.deg2rad(cumulative_trapezoid(frame["rot_vel"] / sfreq, initial=0.0))),
         initial=0.0)
 
     return sessiondata
@@ -200,7 +201,8 @@ def process_imu_left(sessiondata, camber=18, wsize=0.32, wbase=0.80,
     # Calculation of rotations, rotational velocity and acceleration
     frame["rot_vel"] = lowpass_butter(frame["gyroscope_z"],
                                       sfreq=sfreq, cutoff=10)
-    frame["rot"] = cumtrapz(abs(frame["rot_vel"]) / sfreq, initial=0.0)
+    frame['rot_vel'] = savgol_filter(frame['rot_vel'], window_length=100, polyorder=3)
+    frame["rot"] = cumulative_trapezoid(abs(frame["rot_vel"]) / sfreq, initial=0.0)
     frame["rot_acc"] = np.gradient(frame["rot_vel"]) * sfreq
 
     # Wheelchair camber correction
@@ -211,10 +213,10 @@ def process_imu_left(sessiondata, camber=18, wsize=0.32, wbase=0.80,
     frame["gyro_cor"] = left["gyro_cor"]
 
     left["vel"] = left["gyro_cor"] * wsize * deg2rad
-    left["dist"] = cumtrapz(left["vel"] / sfreq, initial=0.0)
+    left["dist"] = cumulative_trapezoid(left["vel"] / sfreq, initial=0.0)
     frame["vel_wheel"] = left["vel"]
     frame["vel_wheel"] = lowpass_butter(frame["vel_wheel"], sfreq=sfreq, cutoff=10)
-    frame["dist_wheel"] = cumtrapz(frame["vel_wheel"] / sfreq, initial=0.0)
+    frame["dist_wheel"] = cumulative_trapezoid(frame["vel_wheel"] / sfreq, initial=0.0)
 
     frame["acc_wheel"] = np.gradient(frame["vel_wheel"]) * sfreq
     frame['acc_wheel'] = lowpass_butter(frame['acc_wheel'],
@@ -228,14 +230,14 @@ def process_imu_left(sessiondata, camber=18, wsize=0.32, wbase=0.80,
     frame["vel_left"] = left["vel"]
     frame["vel_left"] += np.tan(np.deg2rad(frame["rot_vel"] / sfreq)) * wbase / 2 * sfreq
     frame["vel"] = frame["vel_left"]
-    frame["dist"] = cumtrapz(frame["vel"], initial=0.0) / sfreq
+    frame["dist"] = cumulative_trapezoid(frame["vel"], initial=0.0) / sfreq
 
     # distance in the x and y direction
-    frame["dist_y"] = cumtrapz(
-        np.gradient(frame["dist"]) * np.sin(np.deg2rad(cumtrapz(frame["rot_vel"] / sfreq, initial=0.0))),
+    frame["dist_y"] = cumulative_trapezoid(
+        frame['vel'] / sfreq * np.sin(np.deg2rad(cumulative_trapezoid(frame["rot_vel"] / sfreq, initial=0.0))),
         initial=0.0)
-    frame["dist_x"] = cumtrapz(
-        np.gradient(frame["dist"]) * np.cos(np.deg2rad(cumtrapz(frame["rot_vel"] / sfreq, initial=0.0))),
+    frame["dist_x"] = cumulative_trapezoid(
+        frame['vel'] / sfreq * np.cos(np.deg2rad(cumulative_trapezoid(frame["rot_vel"] / sfreq, initial=0.0))),
         initial=0.0)
 
     return sessiondata
@@ -311,7 +313,7 @@ def push_imu(acceleration, sfreq=400.0):
     return push_idx, acc_filt, n_pushes, cycle_time, push_freq
 
 
-def movesense_offset(sessiondata, n_sensors=2, right_wheel=True):
+def movesense_offset(sessiondata, n_sensors=2, right_wheel=True, gyro_offset=False):
     """
     Remove offset MoveSense sensors
 
@@ -324,6 +326,8 @@ def movesense_offset(sessiondata, n_sensors=2, right_wheel=True):
     n_sensors: float
         number of sensors used, 2: right wheel and frame,
         3: right, left wheel and frame
+    gyro_offset: boolean
+        if set to True, an additional gyroscope offset will be used
 
     Returns
     -------
@@ -363,5 +367,10 @@ def movesense_offset(sessiondata, n_sensors=2, right_wheel=True):
             sessiondata['left']['gyroscope_x'] -= offset_left_x
     else:
         print('No offset corrected')
+    if gyro_offset is True:
+        sessiondata['frame']['gyroscope_z'] = np.sign(
+            sessiondata['frame']['gyroscope_z']) * np.sqrt(sessiondata['frame']['gyroscope_x']**2
+                                                           + sessiondata['frame']['gyroscope_y']**2
+                                                           + sessiondata['frame']['gyroscope_z']**2)
 
     return sessiondata

{worklab-2.0.0 → worklab-2.1.0}/worklab/kin.py

@@ -1,6 +1,6 @@
 import numpy as np
 import pandas as pd
-from scipy.integrate import cumtrapz
+from scipy.integrate import cumulative_trapezoid
 from scipy.signal import savgol_filter
 from .utils import lowpass_butter, find_peaks
 from .move import rotate_matrix
@@ -220,7 +220,7 @@ def process_mw(data, wheelsize=0.31, rimsize=0.275, sfreq=200):
     """
     data["aspeed"] = np.gradient(data["angle"]) * sfreq
     data["speed"] = data["aspeed"] * wheelsize
-    data["dist"] = cumtrapz(data["speed"], initial=0.0) / sfreq
+    data["dist"] = cumulative_trapezoid(data["speed"], initial=0.0) / sfreq
     data["acc"] = np.gradient(data["speed"]) * sfreq
     data["ftot"] = (data["fx"] ** 2 + data["fy"] ** 2 + data["fz"] ** 2) ** 0.5
     data["uforce"] = data["torque"] / rimsize
@@ -231,31 +231,37 @@ def process_mw(data, wheelsize=0.31, rimsize=0.275, sfreq=200):
     return data
 
 
-def process_ergo(data, wheelsize=0.31, rimsize=0.275):
+def process_ergo(data, wheelsize=0.31, rimsize=0.275, unit="ms"):
     """
     Basic processing for ergometer data.
 
     Basic processing for ergometer data (e.g. speed to distance). Should be performed after filtering.
-    Added columns:
+    Returned columns:
 
     +------------+----------------------+-----------+
     | Column     | Data                 | Unit      |
     +============+======================+===========+
-    | angle      | angle                | rad       |
+    | time       | time                 | s         |
     +------------+----------------------+-----------+
-    | aspeed     | angular velocity     | rad/s     |
+    | force      | force (on wheel)     | N         |
+    +------------+----------------------+-----------+
+    | speed      | speed                | m/s       |
     +------------+----------------------+-----------+
     | acc        | acceleration         | m/s^2     |
     +------------+----------------------+-----------+
+    | aspeed     | angular velocity     | rad/s     |
+    +------------+----------------------+-----------+
+    | angle      | angle                | rad       |
+    +------------+----------------------+-----------+
     | dist       | cumulative distance  | m         |
     +------------+----------------------+-----------+
     | power      | power                | W         |
     +------------+----------------------+-----------+
-    | work       | instantaneous work   | J         |
+    | torque     | torque around wheel  | Nm        |
     +------------+----------------------+-----------+
     | uforce     | effective force      | N         |
     +------------+----------------------+-----------+
-    | torque     | torque around wheel  | Nm        |
+    | work       | instantaneous work   | J         |
     +------------+----------------------+-----------+
 
     .. note:: the force column contains force on the wheels, uforce (user force) is force on the handrim
@@ -268,6 +274,8 @@ def process_ergo(data, wheelsize=0.31, rimsize=0.275):
         wheel radius [m]
     rimsize : float
         handrim radius [m]
+    unit : str
+        unit of measured 'speed' column; ms, kmh or mph
 
     Returns
     -------
@@ -280,14 +288,23 @@ def process_ergo(data, wheelsize=0.31, rimsize=0.275):
     """
     sfreq = 100  # ergometer is always 100Hz
     for side in data:
-        data[side]["aspeed"] = data[side]["speed"] / wheelsize
-        data[side]["angle"] = cumtrapz(data[side]["aspeed"], initial=0.0) / sfreq
-        data[side]["torque"] = data[side]["force"] * wheelsize
+        if unit == "kmh":
+            data[side]["speed"] /= 3.6
+        elif unit == "mph":
+            data[side]["speed"] /= 2.23694
+        elif unit == "ms":
+            data[side]["speed"] = data[side]["speed"]
+        else:
+            raise Exception("Please specify either 'ms', 'kmh' or 'mph', data not processed!")
+
         data[side]["acc"] = np.gradient(data[side]["speed"]) * sfreq
+        data[side]["aspeed"] = data[side]["speed"] / wheelsize
+        data[side]["angle"] = cumulative_trapezoid(data[side]["aspeed"], initial=0.0) / sfreq
+        data[side]["dist"] = cumulative_trapezoid(data[side]["speed"], initial=0.0) / sfreq
         data[side]["power"] = data[side]["speed"] * data[side]["force"]
-        data[side]["dist"] = cumtrapz(data[side]["speed"], initial=0.0) / sfreq
-        data[side]["work"] = data[side]["power"] / sfreq
+        data[side]["torque"] = data[side]["force"] * wheelsize
         data[side]["uforce"] = data[side]["force"] * (wheelsize / rimsize)
+        data[side]["work"] = data[side]["power"] / sfreq
     return data
 
 
@@ -389,7 +406,7 @@ def push_by_push_mw(data, variable="torque", cutoff=0.0, minpeak=5.0, mindist=5,
         "cwork",
         "negwork",
     ]
-    pbp = pd.DataFrame(data=np.full((len(peaks["start"]), len(keys)), np.NaN), columns=keys)  # preallocate dataframe
+    pbp = pd.DataFrame(data=np.full((len(peaks["start"]), len(keys)), np.nan), columns=keys)  # preallocate dataframe
 
     pbp["start"] = peaks["start"]
     pbp["peak"] = peaks["peak"]
@@ -421,7 +438,7 @@ def push_by_push_mw(data, variable="torque", cutoff=0.0, minpeak=5.0, mindist=5,
     negative_work = data["work"].copy()
     negative_work[negative_work >= 0] = 0
     pbp["negwork"] = negative_work.groupby(cycle_bins).sum()[1:].reset_index(drop=True)
-    pbp.loc[len(pbp) - 1, ["cwork", "negwork"]] = np.NaN
+    pbp.loc[len(pbp) - 1, ["cwork", "negwork"]] = np.nan
 
     if verbose:
         print("\n" + "=" * 80 + f"\nFound {len(pbp)} pushes!\n" + "=" * 80 + "\n")
@@ -434,43 +451,51 @@ def push_by_push_ergo(data, variable="power", cutoff=0.0, minpeak=50.0, mindist=
 
     Push detection and push-by-push analysis for ergometer data. Returns a pandas DataFrame with:
 
-    +--------------------+----------------------+-----------+
-    | Column             | Data                 | Unit      |
-    +====================+======================+===========+
-    | start/stop/peak    | respective indices   |           |
-    +--------------------+----------------------+-----------+
-    | tstart/tstop/tpeak | respective samples   | s         |
-    +--------------------+----------------------+-----------+
-    | cangle             | contact angle        | rad       |
-    +--------------------+----------------------+-----------+
-    | cangle_deg         | contact angle        | degrees   |
-    +--------------------+----------------------+-----------+
-    | mean/maxpower      | power per push       | W         |
-    +--------------------+----------------------+-----------+
-    | mean/maxtorque     | torque per push      | Nm        |
-    +--------------------+----------------------+-----------+
-    | mean/maxforce      | force per push       | N         |
-    +--------------------+----------------------+-----------+
-    | mean/maxuforce     | (rim) force per push | N         |
-    +--------------------+----------------------+-----------+
-    | mean/maxspeed      | velocity per push    | ms        |
-    +--------------------+----------------------+-----------+
-    | work               | work per push        | J         |
-    +--------------------+----------------------+-----------+
-    | cwork              | work per cycle       | J         |
-    +--------------------+----------------------+-----------+
-    | negwork            | negative work/cycle  | J         |
-    +--------------------+----------------------+-----------+
-    | slope              | slope onset to peak  | Nm/s      |
-    +--------------------+----------------------+-----------+
-    | smoothness         | mean/peak force      |           |
-    +--------------------+----------------------+-----------+
-    | ptime              | push time            | s         |
-    +--------------------+----------------------+-----------+
-    | ctime              | cycle time           | s         |
-    +--------------------+----------------------+-----------+
-    | reltime            | relative push/cycle  | %         |
-    +--------------------+----------------------+-----------+
+    +--------------------+-----------------------+-----------+
+    | Column             | Data                  | Unit      |
+    +====================+=======================+===========+
+    | start/stop/peak    | respective indices    |           |
+    +--------------------+-----------------------+-----------+
+    | tstart/tstop/tpeak | respective samples    | s         |
+    +--------------------+-----------------------+-----------+
+    | cangle             | contact angle         | rad       |
+    +--------------------+-----------------------+-----------+
+    | cangle_deg         | contact angle         | degrees   |
+    +--------------------+-----------------------+-----------+
+    | mean/maxpower      | power per push        | W         |
+    +--------------------+-----------------------+-----------+
+    | mean/maxtorque     | torque per push       | Nm        |
+    +--------------------+-----------------------+-----------+
+    | mean/maxforce      | force per push        | N         |
+    +--------------------+-----------------------+-----------+
+    | mean/maxuforce     | (rim) force per push  | N         |
+    +--------------------+-----------------------+-----------+
+    | mean/maxspeed      | velocity per push     | ms        |
+    +--------------------+-----------------------+-----------+
+    | work               | work per push         | J         |
+    +--------------------+-----------------------+-----------+
+    | cwork              | work per cycle        | J         |
+    +--------------------+-----------------------+-----------+
+    | negwork            | negative work/cycle   | J         |
+    +--------------------+-----------------------+-----------+
+    | slope              | slope onset to peak   | Nm/s      |
+    +--------------------+-----------------------+-----------+
+    | smoothness         | mean/peak force       | N         |
+    +--------------------+-----------------------+-----------+
+    | ptime              | push time             | s         |
+    +--------------------+-----------------------+-----------+
+    | ctime              | cycle time            | s         |
+    +--------------------+-----------------------+-----------+
+    | reltime            | relative push/cycle   | %         |
+    +--------------------+-----------------------+-----------+
+    | pnegpos            | neg power start push  | index    |
+    +--------------------+-----------------------+-----------+
+    | negpos             | neg power start push  | W        |
+    +--------------------+-----------------------+-----------+
+    | pnegpoe            | neg power end push    | index    |
+    +--------------------+-----------------------+-----------+
+    | negpoe             | neg power end push    | W        |
+    +--------------------+-----------------------+-----------+
 
     Parameters
     ----------
@@ -520,6 +545,10 @@ def push_by_push_ergo(data, variable="power", cutoff=0.0, minpeak=50.0, mindist=
         "reltime",
         "cwork",
         "negwork",
+        "pnegpos",
+        "negpos",
+        "pnegpoe",
+        "negpoe",
     ]
 
     for side in data:
@@ -527,7 +556,7 @@ def push_by_push_ergo(data, variable="power", cutoff=0.0, minpeak=50.0, mindist=
             peaks = find_peaks(data[side][variable], cutoff, minpeak, mindist)
         else:
             peaks = find_peaks(data[side][variable], cutoff, (minpeak * 2), mindist)
-        pbp = pd.DataFrame(data=np.full((len(peaks["start"]), len(keys)), np.NaN), columns=keys)  # preallocate
+        pbp = pd.DataFrame(data=np.full((len(peaks["start"]), len(keys)), np.nan), columns=keys)  # preallocate
 
         pbp["start"] = peaks["start"]
         pbp["peak"] = peaks["peak"]
@@ -559,7 +588,24 @@ def push_by_push_ergo(data, variable="power", cutoff=0.0, minpeak=50.0, mindist=
         negative_work = data[side]["work"].copy()
         negative_work[negative_work >= 0] = 0
         pbp["negwork"] = negative_work.groupby(cycle_bins).sum()[1:].reset_index(drop=True)
-        pbp.loc[len(pbp) - 1, ["cwork", "negwork"]] = np.NaN
+        pbp.loc[len(pbp) - 1, ["cwork", "negwork"]] = np.nan
+
+        neg_before_all = []
+        neg_after_all = []
+
+        for sample, sample2 in zip(pbp['start'], pbp['stop']):
+            neg_before = data['mean'].loc[sample - 10:sample]
+            neg_before_min = neg_before[neg_before['power'] == min(neg_before['power'])]
+            neg_before_all.append(neg_before_min)
+            neg_after = data['mean'].loc[sample2:sample2 + 10]
+            neg_after_min = neg_after[neg_after['power'] == min(neg_after['power'])]
+            neg_after_all.append(neg_after_min)
+
+        for push in range(0, len(pbp)):
+            pbp.loc[push, "pnegpos"] = neg_before_all[push].index.item()
+            pbp.loc[push, "negpos"] = neg_before_all[push]['power'].item()
+            pbp.loc[push, "pnegpoe"] = neg_after_all[push].index.item()
+            pbp.loc[push, "negpoe"] = neg_after_all[push]['power'].item()
 
         pbp_sides[side] = pd.DataFrame(pbp)
 

{worklab-2.0.0 → worklab-2.1.0}/worklab/plots.py

@@ -33,7 +33,7 @@ def plot_pushes(data, pushes, var="torque", start=True, stop=True, peak=True, ax
     ax : axis object
 
     """
-    with plt.style.context("seaborn-white"):
+    with plt.style.context("seaborn-v0_8-white"):
         if not ax:
             _, ax = plt.subplots(1, 1)
         ax.plot(data["time"], data[var])
@@ -120,7 +120,7 @@ def bland_altman_plot(data1, data2, ax=None, condition=None):
     md = np.mean(diff)  # Mean of the difference
     sd = np.std(diff, axis=0)  # Standard deviation of the difference
 
-    with plt.style.context("seaborn-white"):
+    with plt.style.context("seaborn-v0_8-white"):
         ax.scatter(mean, diff)
         ax.axhline(0, color="dimgray", linestyle="-")
         ax.axhline(md, color="darkgray", linestyle="--")
@@ -152,7 +152,7 @@ def vel_plot(time, vel, name=""):
     ax: axis object
 
     """
-    plt.style.use("seaborn-darkgrid")
+    plt.style.use("seaborn-v0_8-darkgrid")
     fig, ax = plt.subplots(1, 1, figsize=[10, 6])
     ax.plot(time, vel, "r")
     ax.set_xlabel("Time [s]", fontsize=12)
@@ -190,7 +190,7 @@ def vel_peak_plot(time, vel, name=""):
     y_max_vel_value = np.max(vel)
 
     # Create time vs. velocity figure with vel_peak
-    plt.style.use("seaborn-darkgrid")
+    plt.style.use("seaborn-v0_8-darkgrid")
     fig, ax = plt.subplots(1, 1, figsize=[10, 6])
     ax.plot(time, vel, "r")
     ax.plot(time[y_max_vel], vel[y_max_vel], "ko", label="Vel$_{peak}$: " + str(round(y_max_vel_value, 2)) + " m/s")
@@ -232,7 +232,7 @@ def vel_peak_dist_plot(time, vel, dist, name=""):
     y_max_vel_value = np.max(vel)
 
     # Create time vs. velocity figure with vel_peak
-    plt.style.use("seaborn-darkgrid")
+    plt.style.use("seaborn-v0_8-darkgrid")
     fig, ax1 = plt.subplots(1, 1, figsize=[10, 6])
     ax1.set_ylim(0, y_max_vel_value + 0.5)
     ax1.plot(time, vel, "r")
@@ -278,7 +278,7 @@ def acc_plot(time, acc, name=""):
 
     """
     # Create time vs. acceleration figure
-    plt.style.use("seaborn-darkgrid")
+    plt.style.use("seaborn-v0_8-darkgrid")
     fig, ax = plt.subplots(1, 1, figsize=[10, 6])
     ax.plot(time, acc, "g")
     ax.set_xlabel("Time [s]", fontsize=12)
@@ -316,7 +316,7 @@ def acc_peak_plot(time, acc, name=""):
     y_max_acc = acc.idxmax()
 
     # Create time vs. acceleration figure with acc_peak
-    plt.style.use("seaborn-darkgrid")
+    plt.style.use("seaborn-v0_8-darkgrid")
     fig, ax = plt.subplots(1, 1, figsize=[10, 6])
     ax.plot(time, acc, "g")
     ax.plot(time[y_max_acc], acc[y_max_acc], "k.", label="Acc$_{peak}$: " + str(round(y_max_acc_value, 2)) + " m/$s^2$")
@@ -358,7 +358,7 @@ def acc_peak_dist_plot(time, acc, dist, name=""):
     y_max_acc = acc.idxmax()
 
     # Create time vs. acceleration figure with acc_peak
-    plt.style.use("seaborn-darkgrid")
+    plt.style.use("seaborn-v0_8-darkgrid")
     fig, ax1 = plt.subplots(1, 1, figsize=[10, 6])
     ax1.set_ylim(np.min(acc) - 1, y_max_acc_value + 1)
     ax1.plot(time, acc, "g")
@@ -406,7 +406,7 @@ def rot_vel_plot(time, rot_vel, name=""):
 
     """
     # Create time vs. rotational velocity figure
-    plt.style.use("seaborn-darkgrid")
+    plt.style.use("seaborn-v0_8-darkgrid")
     fig, ax = plt.subplots(1, 1, figsize=[10, 6])
     ax.plot(time, rot_vel, "b")
     ax.set_xlabel("Time [s]", fontsize=12)
@@ -477,7 +477,7 @@ def imu_push_plot(sessiondata, acc_frame=True, name='', dec=False):
     push_idx, acc_filt, n_pushes, cycle_time, push_freq = push_imu(acc, sfreq)
 
     # Create time vs. velocity with push detection figure
-    plt.style.use("seaborn-darkgrid")
+    plt.style.use("seaborn-v0_8-darkgrid")
     fig, ax1 = plt.subplots(1, 1, figsize=[10, 6])
     ax1.set_ylim(-2, np.max(sessiondata['vel']) + 0.5)
     ax1.plot(sessiondata['time'], sessiondata['vel'], 'r')
@@ -532,7 +532,7 @@ def plot_power_speed_dist(data, title="", ylim_power=None, ylim_speed=None, ylim
         the three axes objects
 
     """
-    plt.style.use("seaborn-ticks")
+    plt.style.use("seaborn-v0_8-ticks")
     fig = plt.figure()
 
     # Generate three axes

{worklab-2.0.0 → worklab-2.1.0}/worklab/utils.py

@@ -558,7 +558,7 @@ def binned_stats(array, bins=10, pad=True, func=np.mean, nan_func=np.nanmean):
     """
     array = np.array(array, dtype=float)  # make sure we have an array
     if pad:
-        array = np.pad(array, (0, bins - array.size % bins), mode="constant", constant_values=np.NaN)
+        array = np.pad(array, (0, bins - array.size % bins), mode="constant", constant_values=np.nan)
         means = nan_func(array.reshape(-1, bins), axis=1)
     else:
         means = func(array[: (len(array) // bins) * bins].reshape(-1, bins), axis=1)

{worklab-2.0.0 → worklab-2.1.0}/worklab.egg-info/PKG-INFO

@@ -1,8 +1,8 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: worklab
-Version: 2.0.0
+Version: 2.1.0
 Summary: Basic scripts for worklab devices
-Author-email: Rick de Klerk <r.de.klerk@pl.hanze.nl>, Thomas Rietveld <t.rietveld@lboro.ac.uk>, Rowie Janssen <r.j.f.janssen@umcg.nl>, Jelmer Braaksma <j.braaksma01@umcg.nl>
+Author-email: Sophie de Klerk <r.de.klerk@pl.hanze.nl>, Thomas Rietveld <t.rietveld@lboro.ac.uk>, Rowie Janssen <r.j.f.janssen@umcg.nl>, Jelmer Braaksma <j.braaksma01@umcg.nl>
 License:                     GNU GENERAL PUBLIC LICENSE
                                Version 3, 29 June 2007
         
@@ -637,7 +637,7 @@ License:                     GNU GENERAL PUBLIC LICENSE
         the "copyright" line and a pointer to where the full notice is found.
         
             Analysis
-            Copyright (C) 2018  Rick de Klerk
+            Copyright (C) 2018  Sophie de Klerk
         
             This program is free software: you can redistribute it and/or modify
             it under the terms of the GNU General Public License as published by
@@ -657,7 +657,7 @@ License:                     GNU GENERAL PUBLIC LICENSE
           If the program does terminal interaction, make it output a short
         notice like this when it starts in an interactive mode:
         
-            Analysis  Copyright (C) 2018  Rick de Klerk
+            Analysis  Copyright (C) 2018  Sophie de Klerk
             This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
             This is free software, and you are welcome to redistribute it
             under certain conditions; type `show c' for details.
@@ -678,8 +678,8 @@ License:                     GNU GENERAL PUBLIC LICENSE
         Public License instead of this License.  But first, please read
         <http://www.gnu.org/philosophy/why-not-lgpl.html>.
         
-Project-URL: Homepage, https://github.com/rickdkk/worklab
-Project-URL: Bug Reports, https://github.com/rickdkk/worklab/issues
+Project-URL: Homepage, https://github.com/sophiedkk/worklab
+Project-URL: Bug Reports, https://github.com/sophiedkk/worklab/issues
 Keywords: biomechanics,ergometry,physiology
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
@@ -693,16 +693,20 @@ Requires-Dist: numpy
 Requires-Dist: pandas
 Requires-Dist: matplotlib
 Requires-Dist: xlrd
+Requires-Dist: scikit-learn
+Requires-Dist: seaborn
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: Flake8-pyproject; extra == "dev"
 Requires-Dist: black; extra == "dev"
 Requires-Dist: jupyter-book; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Dynamic: license-file
 
 # Worklab: a wheelchair biomechanics mini-package
 
 [![image](https://zenodo.org/badge/DOI/10.5281/zenodo.8362962.svg)](https://doi.org/10.5281/zenodo.8362962)
-[![image](https://badge.fury.io/py/worklab.svg)](https://badge.fury.io/py/worklab) [![image](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gitlab.com/Rickdkk/worklab/tree/master/LICENCE)
+[![image](https://badge.fury.io/py/worklab.svg)](https://badge.fury.io/py/worklab) [![image](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://github.com/sophiedkk/worklab/blob/main/LICENSE)
 
 Essential data analysis and (pre-)processing scripts used in projects
 researching the Lode
@@ -722,7 +726,7 @@ the worklab, which means:
 # Documentation
 
 For more detailed documentation you can look at the
-[docs](https://rickdkk.github.io/worklab/).
+[docs](https://sophiedkk.github.io/worklab/).
 
 # Prerequisites
 
@@ -739,7 +743,7 @@ You can install this package with pip:
 # Examples
 
 You can find some Jupyter Notebook examples
-[here](https://rickdkk.github.io/worklab/chapters/examples.html).
+[here](https://sophiedkk.github.io/worklab/chapters/examples.html).
 
 # Reporting errors
 
@@ -751,4 +755,4 @@ me or submit an issue through this page.
 If you want to refer to this package please use this DOI:
 10.5281/zenodo.8362962, or cite:
 
-Rick de Klerk, Thomas Rietveld, Rowie Janssen, & Jelmer Braaksma. (2023). Worklab: a wheelchair biomechanics mini-package. Zenodo. https://doi.org/10.5281/zenodo.8362963
+Sophie de Klerk, Thomas Rietveld, Rowie Janssen, & Jelmer Braaksma. (2023). Worklab: a wheelchair biomechanics mini-package. Zenodo. https://doi.org/10.5281/zenodo.8362963

{worklab-2.0.0 → worklab-2.1.0}/worklab.egg-info/requires.txt

@@ -3,9 +3,12 @@ numpy
 pandas
 matplotlib
 xlrd
+scikit-learn
+seaborn
 
 [dev]
 pytest
 Flake8-pyproject
 black
 jupyter-book
+build