biomechzoo 0.1.1__py3-none-any.whl

biomechzoo/biomechzoo.py

@@ -0,0 +1,349 @@
+import os
+from biomechzoo.utils.engine import engine  # assumes this returns .zoo files in folder
+from biomechzoo.utils.zload import zload
+from biomechzoo.utils.zsave import zsave
+from biomechzoo.utils.batchdisp import batchdisp
+from biomechzoo.utils.get_split_events import get_split_events
+from biomechzoo.utils.split_trial import split_trial
+from biomechzoo.conversion.c3d2zoo_data import c3d2zoo_data
+from biomechzoo.conversion.csv2zoo_data import csv2zoo_data
+from biomechzoo.conversion.mvnx2zoo_data import mvnx2zoo_data
+from biomechzoo.processing.removechannel_data import removechannel_data
+from biomechzoo.processing.renamechannel_data import renamechannel_data
+from biomechzoo.processing.explodechannel_data import explodechannel_data
+from biomechzoo.processing.addevent_data import addevent_data
+from biomechzoo.processing.partition_data import partition_data
+from biomechzoo.processing.renameevent_data import renameevent_data
+from biomechzoo.biomech_ops.normalize_data import normalize_data
+from biomechzoo.biomech_ops.phase_angle_data import phase_angle_data
+from biomechzoo.biomech_ops.continuous_relative_phase_data import continuous_relative_phase_data
+
+
+class BiomechZoo:
+    def __init__(self, in_folder, inplace=False, verbose=0):
+        self.verbose = verbose
+        self.in_folder = in_folder
+        self.verbose = verbose
+        self.inplace = inplace  # choice to save processed files to new folder
+
+        batchdisp('BiomechZoo initialized', level=1, verbose=verbose)
+        batchdisp('verbosity set to: {}'.format(verbose), level=1, verbose=verbose)
+        batchdisp('processing folder set to: {}'.format(self.in_folder), level=1, verbose=verbose)
+        if inplace:
+            batchdisp('Processing mode: overwrite (inplace=True) (each step will be applied to same folder)', level=1, verbose=verbose)
+        else:
+            batchdisp('Processing mode: backup (inplace=False)(each step will be applied to a new folder)', level=1, verbose=verbose)
+
+    def _update_folder(self, out_folder, inplace, in_folder):
+        """
+        Utility to update self.in_folder if not inplace.
+
+        Parameters:
+        - out_folder (str or None): The output folder provided by user
+        - inplace (bool): Whether processing is inplace
+        - in_folder (str): The current input folder
+        """
+        if not inplace:
+            # get full path for out_folder
+            in_folder_path = os.path.dirname(in_folder)
+            self.in_folder = os.path.join(in_folder_path, out_folder)
+
+    def mvnx2zoo(self, out_folder=None, inplace=False):
+        """ Converts all .mvnx files in the folder to .zoo format """
+        verbose = self.verbose
+        in_folder = self.in_folder
+        if inplace is None:
+            inplace = self.inplace
+
+        fl = engine(in_folder, extension='.mvnx')
+        for f in fl:
+            batchdisp('converting mvnx to zoo for {}'.format(f), level=2, verbose=verbose)
+            data = mvnx2zoo_data(f)
+            f_zoo = f.replace('.mvnx', '.zoo')
+            zsave(f_zoo, data, inplace=inplace, out_folder=out_folder, root_folder=in_folder)
+        batchdisp('mvnx to zoo conversion complete', level=1, verbose=verbose)
+
+        # Update self.folder after  processing
+        self._update_folder(out_folder, inplace, in_folder)
+
+    def c3d2zoo(self, out_folder=None, inplace=None):
+        """ Converts all .c3d files in the folder to .zoo format """
+        from ezc3d import c3d
+        verbose = self.verbose
+        in_folder = self.in_folder
+        if inplace is None:
+            inplace = self.inplace
+
+        fl = engine(in_folder, extension='.c3d')
+        for f in fl:
+            batchdisp('converting c3d to zoo for {}'.format(f), level=2, verbose=verbose)
+            c3d_obj = c3d(f)
+            data = c3d2zoo_data(c3d_obj)
+            f_zoo = f.replace('.c3d', '.zoo')
+            zsave(f_zoo, data, inplace=inplace, out_folder=out_folder, root_folder=in_folder)
+        batchdisp('c3d to zoo conversion complete', level=1, verbose=verbose)
+
+        # Update self.folder after  processing
+        self._update_folder(out_folder, inplace, in_folder)
+
+    def csv2zoo(self, out_folder=None, inplace=None):
+        """ Converts generic .csv file in the folder to .zoo format """
+        verbose = self.verbose
+        in_folder = self.in_folder
+        if inplace is None:
+            inplace = self.inplace
+
+        fl = engine(in_folder, extension='.csv')
+        for f in fl:
+            batchdisp('converting csv to zoo for {}'.format(f), level=2, verbose=verbose)
+            data = csv2zoo_data(f)
+            f_zoo = f.replace('.csv', '.zoo')
+            zsave(f_zoo, data, inplace=inplace, out_folder=out_folder, root_folder=in_folder)
+        batchdisp('csv to zoo conversion complete', level=1, verbose=verbose)
+
+        # Update self.folder after  processing
+        self._update_folder(out_folder, inplace, in_folder)
+
+    def xls2zoo(self, out_folder=None, inplace=None):
+        """ Converts generic .xls file in the folder to .zoo format """
+        raise NotImplementedError
+
+    def phase_angle(self, ch, out_folder=None, inplace=None):
+        """ computes phase angles"""
+        verbose = self.verbose
+        in_folder = self.in_folder
+        if inplace is None:
+            inplace = self.inplace
+
+        fl = engine(in_folder)
+        for f in fl:
+            if verbose:
+                batchdisp('computing phase angles for {}'.format(f), level=2, verbose=verbose)
+            data = zload(f)
+            data = phase_angle_data(data, ch)
+            zsave(f, data, inplace=inplace, root_folder=in_folder, out_folder=out_folder)
+        batchdisp('phase angle computation complete', level=1, verbose=verbose)
+
+        # Update self.folder after  processing
+        self._update_folder(out_folder, inplace, in_folder)
+
+    def continuous_relative_phase(self, ch_prox, ch_dist, out_folder=None, inplace=None):
+        """ computes CRP angles"""
+        verbose = self.verbose
+        in_folder = self.in_folder
+        if inplace is None:
+            inplace = self.inplace
+
+        fl = engine(in_folder)
+        for f in fl:
+            if verbose:
+                batchdisp('computing CRP angles between channel {} (prox) and {} (dist) for {}'.format(ch_prox, ch_dist, f), level=2, verbose=verbose)
+            data = zload(f)
+            data = continuous_relative_phase_data(data, ch_dist, ch_prox)
+            zsave(f, data, inplace=inplace, root_folder=in_folder, out_folder=out_folder)
+        batchdisp('CRP computation complete', level=1, verbose=verbose)
+
+        # Update self.folder after  processing
+        self._update_folder(out_folder, inplace, in_folder)
+
+    def split_trial_by_gait_cycle(self, first_event_name, out_folder=None, inplace=None):
+        """ split by gait cycle according to event_name"""
+        verbose = self.verbose
+        in_folder = self.in_folder
+        if inplace is None:
+            inplace = self.inplace
+
+        fl = engine(in_folder)
+        for f in fl:
+            f_name = os.path.splitext(os.path.basename(f))[0]
+            batchdisp('splitting by gait cycle  for {} by {}'.format(f, first_event_name), level=2, verbose=verbose)
+            data = zload(f)
+            split_events = get_split_events(data, first_event_name)
+            if split_events is None:
+                print('no event {} found, saving original file'.format(first_event_name))
+                zsave(f, data, inplace=inplace, root_folder=in_folder, out_folder=out_folder)
+            else:
+                for i, _ in enumerate(split_events[0:-1]):
+                    fl_new = f.replace(f_name, f_name + '_' + str(i + 1))
+                    start = split_events[i]
+                    end = split_events[i + 1]
+                    data_new = split_trial(data, start, end)
+                    zsave(fl_new, data_new, inplace=inplace, root_folder=in_folder, out_folder=out_folder)
+
+        batchdisp('splitting by gait cycle complete', level=1, verbose=verbose)
+
+        # Update self.folder after  processing
+        self._update_folder(out_folder, inplace, in_folder)
+
+
+    # def mean_absolute_relative_phase_deviation_phase(self, channels, out_folder=None, inplace=None):
+    #     verbose = self.verbose
+    #     in_folder = self.in_folder
+    #     if inplace is None:
+    #         inplace = self.inplace
+    #
+    #     fl = engine(in_folder)
+    #     for f in fl:
+    #         for channel in channels:
+    #             batchdisp('collecting trials for marp and dp for {}'.format(f), level=2, verbose=verbose)
+    #             data = zload(f)
+    #             data = removechannel_data(data, ch, mode)
+    #             zsave(f, data, inplace=inplace, root_folder=in_folder, out_folder=out_folder)
+    #             batchdisp('remove channel complete', level=1, verbose=verbose)
+    #
+    #     # Update self.folder after  processing
+    #     self._update_folder(out_folder, inplace, in_folder)
+    def renameevent(self, evt, nevt, out_folder=None, inplace=None):
+        """ renames event evt to nevt in all zoo files """
+        verbose = self.verbose
+        in_folder = self.in_folder
+        if inplace is None:
+            inplace = self.inplace
+
+        fl = engine(in_folder)
+        for f in fl:
+            batchdisp('renaming events from {} to {} for {}'.format(evt, nevt ,f), level=2, verbose=verbose)
+            data = zload(f)
+            data = renameevent_data(data, evt, nevt)
+            zsave(f, data, inplace=inplace, root_folder=in_folder, out_folder=out_folder)
+        batchdisp('rename event complete', level=1, verbose=verbose)
+
+        # Update self.folder after  processing
+        self._update_folder(out_folder, inplace, in_folder)
+
+    def renamechannnel(self, ch, ch_new, out_folder=None, inplace=None):
+        """ renames channels from ch to ch_new in all zoo files """
+        verbose = self.verbose
+        in_folder = self.in_folder
+        if inplace is None:
+            inplace = self.inplace
+
+        fl = engine(in_folder)
+        for f in fl:
+            batchdisp('renaming channels from {} to {} for {}'.format(ch, ch_new ,f), level=2, verbose=verbose)
+            data = zload(f)
+            data = renamechannel_data(data, ch, ch_new)
+            zsave(f, data, inplace=inplace, root_folder=in_folder, out_folder=out_folder)
+        batchdisp('rename channels complete', level=1, verbose=verbose)
+
+        # Update self.folder after  processing
+        self._update_folder(out_folder, inplace, in_folder)
+
+    def removechannel(self, ch, mode='remove', out_folder=None, inplace=None):
+        """ removes channels from zoo files """
+        verbose = self.verbose
+        in_folder = self.in_folder
+        if inplace is None:
+            inplace = self.inplace
+
+        fl = engine(in_folder)
+        for f in fl:
+            batchdisp('removing channels for {}'.format(f), level=2, verbose=verbose)
+            data = zload(f)
+            data = removechannel_data(data, ch, mode)
+            zsave(f, data, inplace=inplace, root_folder=in_folder, out_folder=out_folder)
+        batchdisp('remove channel complete', level=1, verbose=verbose)
+
+        # Update self.folder after  processing
+        self._update_folder(out_folder, inplace, in_folder)
+
+    def explodechannel(self, out_folder=None, inplace=None):
+        """ explodes all channels in a zoo file """
+        verbose = self.verbose
+        in_folder = self.in_folder
+        if inplace is None:
+            inplace = self.inplace
+
+        fl = engine(in_folder)
+        for f in fl:
+            if verbose:
+                batchdisp('removing channels for {}'.format(f), level=2, verbose=verbose)
+            data = zload(f)
+            data = explodechannel_data(data)
+            zsave(f, data, inplace=inplace, root_folder=in_folder, out_folder=out_folder)
+        batchdisp('explode channel complete', level=1, verbose=verbose)
+
+        # Update self.folder after  processing
+        self._update_folder(out_folder, inplace, in_folder)
+
+    def normalize(self, nlen=101, out_folder=None, inplace=None):
+        """ time normalizes all channels to length nlen """
+        verbose = self.verbose
+        in_folder = self.in_folder
+        if inplace is None:
+            inplace = self.inplace
+
+        fl = engine(in_folder)
+        for f in fl:
+            if verbose:
+                batchdisp('normalizing channels to length {} for {}'.format(nlen, f), level=2, verbose=verbose)
+            data = zload(f)
+            data = normalize_data(data, nlen)
+            zsave(f, data, inplace=inplace, root_folder=in_folder, out_folder=out_folder)
+        batchdisp('normalization complete', level=1, verbose=verbose)
+
+        # Update self.folder after  processing
+        self._update_folder(out_folder, inplace, in_folder)
+
+    def addevent(self, ch, evt_type, evt_name, out_folder=None, inplace=None):
+        """ adds events of type evt_type with name evt_name to channel ch """
+        verbose = self.verbose
+        in_folder = self.in_folder
+        if inplace is None:
+            inplace = self.inplace
+
+        fl = engine(in_folder)
+        for f in fl:
+            if verbose:
+                batchdisp('adding event {} to channel {} for {}'.format(evt_type, ch, f), level=2, verbose=verbose)
+            data = zload(f)
+            data = addevent_data(data, ch, evt_type, evt_name)
+            zsave(f, data, inplace=inplace, root_folder=in_folder, out_folder=out_folder)
+        batchdisp('add event complete', level=1, verbose=verbose)
+
+        # Update self.folder after  processing
+        self._update_folder(out_folder, inplace, in_folder)
+
+    def partition(self, evt_start, evt_end, out_folder=None, inplace=None):
+        """ partitions data between events evt_start and evt_end """
+        verbose = self.verbose
+        in_folder = self.in_folder
+        if inplace is None:
+            inplace = self.inplace
+
+        fl = engine(in_folder)
+        for f in fl:
+            if verbose:
+                batchdisp('partitioning data between events {} and {} for {}'.format(evt_start, evt_end, f), level=2, verbose=verbose)
+            data = zload(f)
+            data = partition_data(data, evt_start, evt_end)
+            zsave(f, data, inplace=inplace, root_folder=in_folder, out_folder=out_folder)
+        batchdisp('partition complete', level=1, verbose=verbose)
+        # Update self.folder after  processing
+        self._update_folder(out_folder, inplace, in_folder)
+
+    def filter(self, ch, filt=None, out_folder=None, inplace=None):
+        raise NotImplementedError
+        # verbose = self.verbose
+        # in_folder = self.in_folder
+        # if inplace is None:
+        #     inplace = self.inplace
+        #
+        # # set filter type
+        # if filt is None:
+        #     filt = {'type': 'butterworth',
+        #             'order': 3,
+        #             'pass': 'lowpass'}
+        #
+        # fl = engine(in_folder)
+        # for f in fl:
+        #     batchdisp('filtering data in channels {} for {}'.format(ch, f), level=2, verbose=verbose)
+        #     data = zload(f)
+        #     data = filter_data(data, ch, filt)
+        #     zsave(f, data, inplace=inplace, root_folder=in_folder, out_folder=out_folder)
+        # batchdisp('filter data complete', level=1, verbose=verbose)
+        #
+        # # Update self.folder after  processing
+        # self._update_folder(out_folder, inplace, in_folder)
+
+

biomechzoo/conversion/c3d2zoo_data.py

@@ -0,0 +1,65 @@
+def c3d2zoo_data(c3d_obj):
+    """
+    Converts an ezc3d C3D object to zoo format.
+
+    Returns:
+    - data (dict): Zoo dictionary with 'line' and 'event' fields per channel.
+    """
+    data = {}
+
+    if 'points' in c3d_obj['data']:
+        points = c3d_obj['data']['points']  # shape: (4, n_markers, n_frames)
+        labels = c3d_obj['parameters']['POINT']['LABELS']['value']
+        for i, label in enumerate(labels):
+            line_data = points[:3, i, :].T  # shape: (frames, 3)
+            data[label] = {
+                'line': line_data,
+                'event': {}  # empty for now
+            }
+
+        params = c3d_obj['parameters']
+        video_freq = c3d_obj['parameters']['POINT']['RATE']['value'][0]
+        if 'EVENT' in params and 'TIMES' in params['EVENT']:
+            times_array = params['EVENT']['TIMES']['value']
+            frames = times_array[1]  # second row = frames (or time, depending on C3D file)
+
+            # Extract sides, types, subjects
+            contexts = params['EVENT']['CONTEXTS']['value'] if 'CONTEXTS' in params['EVENT'] else ['']
+            labels = params['EVENT']['LABELS']['value']
+            subjects = params['EVENT']['SUBJECTS']['value'] if 'SUBJECTS' in params['EVENT'] else ['']
+
+            events = {}
+
+            for i in range(len(labels)):
+                side = contexts[i].strip()
+                label = labels[i].strip()
+                subject = subjects[i].strip()
+
+                # Event channel name: e.g. 'Right_FootStrike' -> 'RightFootStrike'
+                event_name = f"{side}_{label}".replace(' ', '')
+                event_name = ''.join(c for c in event_name if c.isalnum() or c == '_')  # make it a valid field name
+
+                if event_name not in events:
+                    events[event_name] = []
+
+                events[event_name].append(frames[i])  # This is in seconds or frame number?
+
+            original_start = 1
+
+            for event_name, time_list in events.items():
+                # Clean and sort times
+                valid_times = sorted([t for t in time_list if t != 0])
+                for j, time_val in enumerate(valid_times):
+                    frame = round(time_val * video_freq) - original_start + 1  # MATLAB logic
+                    key_name = f"{event_name}{j + 1}"
+
+                    # Place in correct channel
+                    if 'SACR' in data:
+                        data['SACR']['event'][key_name] = [frame, 0, 0]
+                    else:
+                        data[labels[0]]['event'][key_name] = [frame, 0, 0]
+
+    # todo add relevant meta data to zoosystem
+    data['zoosystem'] = params['EVENT']
+
+    return data

biomechzoo/conversion/csv2zoo_data.py

@@ -0,0 +1,78 @@
+import pandas as pd
+import os
+import re
+
+from biomechzoo.utils.compute_sampling_rate_from_time import compute_sampling_rate_from_time
+
+
+def csv2zoo_data(csv_path, header_len=10):
+
+    # Read header lines until 'endheader'
+    header_lines = []
+    with open(csv_path, '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)
+
+    # Step 3: Load data
+    df = pd.read_csv(csv_path, skiprows=header_len)
+    time = df.iloc[:, 0].values  # first column is Time
+    data = df.iloc[:, 1:]
+
+    # S Assemble zoo data
+    zoo_data = {}
+    for ch in data.columns:
+        zoo_data[ch] = {
+            'line': data[ch].values,
+            'event': []
+        }
+
+    # compute sampling rate
+    fsamp = compute_sampling_rate_from_time(time)
+
+    # add metadata
+    # todo update zoosystem to match biomechzoo requirements
+    zoo_data['zoosystem'] = metadata
+    zoo_data['zoosystem']['Freq'] = fsamp
+
+    return zoo_data
+
+
+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 = csv2zoo_data(csv_file)

biomechzoo/conversion/mvnx2zoo_data.py

@@ -0,0 +1,71 @@
+import numpy as np
+from biomechzoo.mvn.load_mvnx import load_mvnx
+
+
+def mvnx2zoo_data(fl):
+    """ loads mvnx file from xsens"""
+    #todo: needs to be updated for the new version of mvnx direcly loaded in biomechzoo
+    mvnx_file = load_mvnx(fl)
+
+    # create zoo data dict
+    data = {}
+
+    # Accessing joint data :
+    joint_angle_data = mvnx_file.get_joint_angle()
+    joint_names = mvnx_file.joints
+    for i, joint in enumerate(joint_names):
+        start = i * 3
+        stop = start + 3
+        angles = joint_angle_data[:, start:stop]  # shape: (n_frames, 3)
+
+        data[joint] = {
+            'line': angles,
+            'event': {}
+        }
+    # get foot strike events
+    # Index 0: Left Heel contact (1 for contact, 0 for no contact)
+    # Index 1: Left Toe contact (1 for contact, 0 for no contact)
+    # Index 2: Right Heel contact (1 for contact, 0 for no contact)
+    # Index 3: Right Toe contact (1 for contact, 0 for no contact)
+    left_heel_contacts = np.array(mvnx_file.footContacts[:, 0])
+    right_heel_contacts = np.array(mvnx_file.footContacts[:, 2])
+
+    # Detect transitions from no contact (0) to contact (1)
+    left_contact_start = (left_heel_contacts[:-1] == 0) & (left_heel_contacts[1:] == 1)
+    right_contact_start = (right_heel_contacts[:-1] == 0) & (right_heel_contacts[1:] == 1)
+
+    # Get indices where these transitions occur (add 1 because we're checking between frames)
+    left_contact_frames = np.where(left_contact_start)[0] + 1
+    right_contact_frames = np.where(right_contact_start)[0] + 1
+
+    # add to zoo
+    data['jL5S1']['event'] = {}
+    for i, right_contact_frame in enumerate(right_contact_frames):
+        data['jL5S1']['event']['R_FS'+str(i+1)] = [right_contact_frame, 0, 0]
+    for i, left_contact_frame in enumerate(left_contact_frames):
+        data['jL5S1']['event']['L_FS' + str(i + 1)] = [left_contact_frame, 0, 0]
+
+    # add meta information
+    # todo: add more, see mvnx_file object
+    data['zoosystem'] = {}
+    data['zoosystem']['Video'] = {}
+    data['zoosystem']['Video']['Freq'] = int(mvnx_file.frame_rate)
+    data['zoosystem']['Version'] = mvnx_file.version
+    data['zoosystem']['configuration'] = mvnx_file.configuration
+    data['zoosystem']['recording_date'] = mvnx_file.recording_date
+    data['zoosystem']['original_file_name'] = mvnx_file.original_file_name
+    data['zoosystem']['frame_count'] = mvnx_file.frame_count
+    data['zoosystem']['comments'] = mvnx_file.comments
+
+    return data
+
+
+if __name__ == '__main__':
+    """ testing """
+    import os
+    from src.biomechzoo.utils.zplot import zplot
+    # -------TESTING--------
+    project_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+    fl = os.path.join(project_root, 'data', 'other', 'Flat-001.mvnx')
+    data = mvnx2zoo_data(fl)
+    zplot(data, 'jRightKnee')

biomechzoo/conversion/opencap2zoo_data.py

@@ -0,0 +1,23 @@
+import os
+import pandas as pd
+
+#todo: review. do not use in current form
+
+def opencap2zoo_data(ik_file):
+    raise NotImplementedError
+    ik_data = pd.read_csv(ik_file, sep='\t', comment='#')  # OpenSim .mot format
+    a = 1
+
+def _compute_opencap_quantities():
+    b = 2
+
+
+if __name__ == '__main__':
+    """ for unit testing"""
+    # -------TESTING--------
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    project_root = os.path.dirname(current_dir)
+
+    fl = os.path.join(project_root, 'data', 'OpenCap', 'gait_3', 'OpenSimData', 'Kinematics', 'gait_3.mot')
+
+    data = opencap2zoo_data(fl)