biomechzoo 0.5.9__py3-none-any.whl

biomechzoo/conversion/table2zoo_data.py

@@ -0,0 +1,114 @@
+import pandas as pd
+import os
+import re
+
+from biomechzoo.utils.set_zoosystem import set_zoosystem
+from biomechzoo.utils.compute_sampling_rate_from_time import compute_sampling_rate_from_time
+
+
+def table2zoo_data(fl, extension, skip_rows=0, freq=None):
+
+    if extension == 'csv':
+        df, metadata, freq = _csv2zoo(fl, skip_rows=skip_rows, freq=freq)
+
+    elif extension == 'parquet':
+        df, metadata, freq = _parquet2zoo(fl, skip_rows=skip_rows, freq=freq)
+    else:
+        raise ValueError('extension {} not implemented'.format(extension))
+
+    # assemble zoo data
+    data = {'zoosystem': set_zoosystem()}
+    for ch in df.columns:
+        data[ch] = {
+            'line': df[ch].values,
+            'event': []
+        }
+
+
+    # now try to calculate freq from a time column
+    if freq is None:
+        time_col = [col for col in df.columns if 'time' in col.lower()]
+        if time_col is not None and len(time_col) > 0:
+            time_data = df[time_col].to_numpy()[:, 0]
+            freq = compute_sampling_rate_from_time(time_data)
+        else:
+            raise ValueError('Unable to compute sampling rate for time column, please specify a sampling frequency'
+                             )
+    # add metadata
+    data['zoosystem']['Video']['Freq'] = freq
+    data['zoosystem']['Analog']['Freq'] = 'None'
+
+    if metadata is not None:
+        data['zoosystem']['Other'] = metadata
+
+    return data
+
+
+def _parquet2zoo(fl, skip_rows=0, freq=None):
+    df = pd.read_parquet(fl)
+    metadata = None
+    return df, metadata, freq
+
+def _csv2zoo(fl, skip_rows=0, freq=None):
+    header_lines = []
+    with open(fl, 'r') as f:
+        for line in f:
+            header_lines.append(line.strip())
+            if line.strip().lower() == 'endheader':
+                break
+    # Parse metadata
+    metadata = _parse_metadata(header_lines)
+
+    # try to find frequency in metadata
+    if freq is None:
+        if 'freq' in metadata:
+            freq = metadata['freq']
+        elif 'sampling_rate' in metadata:
+            freq = metadata['sampling_rate']
+        else:
+            freq = None  # or raise an error
+
+    # read csv
+    df = pd.read_csv(fl, skiprows=skip_rows)
+
+    return df, metadata, freq
+
+
+
+
+def _parse_metadata(header_lines):
+    metadata = {}
+    for line in header_lines:
+        if '=' in line:
+            key, val = line.split('=', 1)
+            key = key.strip()
+            val = val.strip()
+
+            # Strip trailing commas and whitespace explicitly
+            val = val.rstrip(',').strip()
+
+            # Extract first numeric token if any
+            match = re.search(r'[-+]?\d*\.?\d+', val)
+            if match:
+                num_str = match.group(0)
+                try:
+                    val_num = int(num_str)
+                except ValueError:
+                    val_num = float(num_str)
+            else:
+                # Now val should be clean of trailing commas, so just lower case it
+                val_num = val.lower()
+
+            metadata[key] = val_num
+    return metadata
+
+
+
+
+if __name__ == '__main__':
+    """ for unit testing"""
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    project_root = os.path.dirname(current_dir)
+    csv_file = os.path.join(project_root, 'data', 'other', 'opencap_walking1.csv')
+
+    data = table2zoo_data(csv_file)

biomechzoo/imu/tilt_algorithm.py

@@ -0,0 +1,112 @@
+import numpy as np
+import math
+import pandas as pd
+from biomechzoo.processing.addchannel_data import addchannel_data
+
+def tilt_algorithm_data(data,ch_vert, ch_medlat, ch_antpost, plot_or_not=None):
+
+    # extract channels from data
+    avert = data[ch_vert]['line']
+    amedlat = data[ch_medlat]['line']
+    aantpost = data[ch_antpost]['line']
+
+    _, avert_corr, amedlat_corr, aantpost_corr = tilt_algorithm_line(avert, amedlat, aantpost)
+
+    data = addchannel_data(data, ch_vert + '_tilt_corr', avert_corr)
+    data = addchannel_data(data, ch_medlat + '_tilt_corr', amedlat_corr)
+    data = addchannel_data(data, ch_antpost + '_tilt_corr', aantpost_corr)
+
+    return data
+
+
+def tilt_algorithm_line(avert, amedlat, aantpost, plot_or_not=None):
+    """
+    TiltAlgorithm - to account for gravity and improper tilt alignment of a tri-axial trunk accelerometer.
+    Step 1: Extract raw measured (mean) accelerations
+    Step 2: Calculate tilt angles
+    Step 3: Calculate horizontal dynamic accelerations vectors
+    Step 4: Calculate estimated provisional vertical vector
+    Step 5: Calculate vertical dynamic vector
+    step 6.1:  Calculate the contribution of static components
+    step 6.2 Transpose static component matrices
+    step 7: Remove the static components from the templates of pre and post
+
+    :param avert: signal predominantly in vertical direction
+    :param amedlat: signal predominantly in medio-lateral direction
+    :param aantpost: signal predominantly in anterior-posterior direction
+    :param plot_or_not: whether to plot the results
+    :return: dataframe of the tilt corrected and gravity subtracted vertical, medio-lateral and anterior-posterior
+    acceleration signals
+    """
+    #
+
+    a_vt = avert.mean()
+    a_ml = amedlat.mean()
+    a_ap = aantpost.mean()
+
+    # if avert is negative than turn the sensor around.
+    if a_vt < 0.5:
+        avert *= -1
+        amedlat *= -1
+        a_vt = avert.mean()
+        a_ml = amedlat.mean()
+
+    # Anterior tilt
+    TiltAngle_ap_rad = np.arcsin(a_ap)
+    TiltAngle_ap_deg = math.degrees(TiltAngle_ap_rad)
+
+    # mediolateral tilt
+    TiltAngle_ml_rad = np.arcsin(a_ml)
+    TiltAngle_ml_deg = math.degrees(TiltAngle_ml_rad)
+
+    # Anterior posterior
+    a_AP = (a_ap * np.cos(TiltAngle_ap_rad)) - (a_vt * np.sin(TiltAngle_ap_rad))
+    # AMediolateral
+    a_ML = (a_ml * np.cos(TiltAngle_ml_rad)) - (a_vt * np.sin(TiltAngle_ml_rad))
+
+    # a_vt_prov = a_ap*Sin(theta_ap) + a_vt*Cos(theta_ap)
+    a_vt_prov = (a_ap * np.sin(TiltAngle_ap_rad)) + (a_vt * np.cos(TiltAngle_ap_rad))
+
+    # a_VT = a_ml*sin(theta_ml) + a_vt_prov*cos(theta_ml) - 1
+    a_VT = (a_ml * np.sin(TiltAngle_ml_rad)) + (a_vt_prov * np.cos(TiltAngle_ml_rad)) - 1
+
+    a_AP_static = a_ap - a_AP
+    a_ML_static = a_ml - a_ML
+    a_VT_static = a_vt - a_VT
+
+    a_AP_static = np.transpose(a_AP_static)
+    a_ML_static = np.transpose(a_ML_static)
+    a_VT_static = np.transpose(a_VT_static)
+
+    amedlat2 = amedlat - a_ML_static
+    avert2 = avert - a_VT_static
+    aantpost2 = aantpost - a_AP_static
+
+    data = {'avert': avert2,
+            'amedlat': amedlat2,
+            'aantpost': aantpost2}
+    df_corrected = pd.DataFrame(data)
+
+    # if plot_or_not:
+    #     f, ax = plt.subplots(nrows=3, ncols=1, sharex=True, dpi=300)
+    #     sns.despine(offset=10)
+    #     f.tight_layout()
+    #     offset = 0.1
+    #     f.subplots_adjust(left=0.15, top=0.95)
+    #
+    #     sns.lineplot(avert, ax=ax[0], label='Raw')
+    #     sns.lineplot(avert2, ax=ax[0], label='tilt corrected')
+    #     ax[0].set_ylabel('vert acc (g)')
+    #     ax[0].set_title('Vertical acceleration corrected with {}'.format(np.round(a_VT_static, 2)))
+    #
+    #     sns.lineplot(amedlat, ax=ax[1], label='Raw')
+    #     sns.lineplot(amedlat2, ax=ax[1], label='Tilt corrected')
+    #     ax[1].set_ylabel('ml acc (g)')
+    #     ax[1].set_title('Medio-lateral tilt angle corrected with {} degrees'.format(np.round(TiltAngle_ml_deg, 2)))
+    #
+    #     sns.lineplot(aantpost, ax=ax[2], label='Raw')
+    #     sns.lineplot(aantpost2, ax=ax[2], label='Tilt corrected')
+    #     ax[2].set_ylabel('ap acc (g)')
+    #     ax[2].set_title('Anterior-posterior tilt angle corrected with {} degrees'.format(np.round(TiltAngle_ap_deg, 2)))
+
+    return df_corrected, avert2, amedlat2, aantpost2

biomechzoo/linear_algebra_ops/compute_magnitude_data.py

@@ -0,0 +1,43 @@
+import numpy as np
+from biomechzoo.processing.addchannel_data import addchannel_data
+def compute_magnitude_line(x,y,z):
+    magnitude = np.sqrt((x**2) + (y**2) + (z **2))
+    return magnitude
+
+def compute_magnitude_data(data, ch_x, ch_y, ch_z, ch_new_name=None):
+    """
+    Compute the magnitude of acceleration data from IMU channels (BiomechZoo format).
+
+    Returns the magnitude
+    """
+    # extract channels from data
+    x = data[ch_x]['line']
+    y = data[ch_y]['line']
+    z = data[ch_z]['line']
+
+    #calculate the magnitude of the data
+    magnitude_data = compute_magnitude_line(x,y,z)
+
+    # get name of new channel:
+    if ch_new_name is None:
+        ch_new_name = common_substring_or_concat(ch_x, ch_y, ch_z)
+
+    #add channels
+    data = addchannel_data(data, ch_new_name=ch_new_name + '_mag', ch_new_data=magnitude_data )
+
+    return data
+
+
+def common_substring_or_concat(str1, str2, str3):
+    common = ""
+    for i in range(len(str1)):
+        for j in range(i + 1, len(str1) + 1):
+            sub = str1[i:j]
+            if sub in str2 and sub in str3 and len(sub) > len(common):
+                common = sub
+
+    # If no common substring found, concatenate all three
+    if not common:
+        return str1 + str2 + str3
+    return common
+