biomechzoo 0.5.9__py3-none-any.whl

biomechzoo/biomechzoo.py

@@ -0,0 +1,447 @@
+import os
+import inspect
+import time
+
+from biomechzoo.imu.tilt_algorithm import tilt_algorithm_data
+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.processing.split_trial_data import split_trial_data
+from biomechzoo.conversion.c3d2zoo_data import c3d2zoo_data
+from biomechzoo.conversion.table2zoo_data import table2zoo_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.removeevent_data import removeevent_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
+from biomechzoo.biomech_ops.filter_data import filter_data
+from biomechzoo.linear_algebra_ops.compute_magnitude_data import compute_magnitude_data
+
+class BiomechZoo:
+    def __init__(self, in_folder, inplace=False, subfolders=None, name_contains=None, verbose=0):
+        self.verbose = verbose
+        self.in_folder = in_folder
+        self.verbose = verbose
+        self.inplace = inplace               # choice to save processed files to new folder
+        self.subfolders = subfolders         # only run processes on list in subfolder
+        self.name_contains = name_contains   # only run processes on files with name_contains in file name
+
+        batchdisp('BiomechZoo initialized', level=1, verbose=verbose)
+        batchdisp('verbosity set to: {}'.format(verbose), level=1, verbose=verbose)
+        batchdisp('root processing folder set to: {}'.format(self.in_folder), level=1, verbose=verbose)
+        if name_contains is not None:
+            batchdisp('only include files containing name_contains string: {}'.format(self.name_contains), level=1, verbose=verbose)
+        if subfolders is not None:
+            if type(subfolders) is list:
+                batchdisp('only process files in subfolder(s):', level=1, verbose=verbose)
+                for subfolder in self.subfolders:
+                    batchdisp('{}'.format(os.path.join(self.in_folder, subfolder)), level=1, verbose=verbose)
+            else:
+                batchdisp('only process files in subfolder(s): {}'.format(os.path.join(self.in_folder, self.subfolders)), 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)
+
+        batchdisp('all files saved to: {}'.format(self.in_folder ), level=1, verbose=self.verbose)
+
+    def mvnx2zoo(self, out_folder=None, inplace=False):
+        """ Converts all .mvnx files in the folder to .zoo format """
+        start_time = time.time()
+        verbose = self.verbose
+        in_folder = self.in_folder
+        if inplace is None:
+            inplace = self.inplace
+        fl = engine(in_folder, extension='.mvnx', name_contains=self.name_contains, subfolders=self.subfolders)
+        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)
+        method_name = inspect.currentframe().f_code.co_name
+        batchdisp('{} process complete for {} file(s) in {:.2f} secs'.format(method_name, len(fl), time.time() - start_time), 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 """
+        start_time = time.time()
+        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', name_contains=self.name_contains, subfolders=self.subfolders)
+        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)
+        method_name = inspect.currentframe().f_code.co_name
+        batchdisp('{} process complete for {} file(s) in {:.2f} secs'.format(method_name, len(fl), time.time() - start_time), level=1, verbose=verbose)
+        # Update self.folder after  processing
+        self._update_folder(out_folder, inplace, in_folder)
+
+    def table2zoo(self, extension, out_folder=None, inplace=None, skip_rows=0, freq=None):
+        """ Converts generic .csv file in the folder to .zoo format """
+        start_time = time.time()
+        verbose = self.verbose
+        in_folder = self.in_folder
+
+        if extension.startswith('.'):
+            extension = extension[1:]
+
+        if inplace is None:
+            inplace = self.inplace
+        fl = engine(in_folder, extension=extension, name_contains=self.name_contains, subfolders=self.subfolders)
+        for f in fl:
+            batchdisp('converting {} to zoo for {}'.format(extension, f), level=2, verbose=verbose)
+            data = table2zoo_data(f, extension=extension, skip_rows=skip_rows, freq=freq)
+            f_zoo = f.replace(extension, '.zoo')
+            zsave(f_zoo, data, inplace=inplace, out_folder=out_folder, root_folder=in_folder)
+        method_name = inspect.currentframe().f_code.co_name
+        batchdisp('{} process complete for {} file(s) in {:.2f} secs'.format(method_name, len(fl), time.time() - start_time), 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):
+        raise NotImplementedError('Use table2zoo instead')
+
+    def csv2zoo(self, out_folder=None, inplace=None):
+        raise NotImplementedError('Use table2zoo instead')
+
+    def parquet2zoo(self, out_folder=None, inplace=None):
+        raise NotImplementedError('Use table2zoo instead')
+
+    def rectify(self):
+        raise NotImplementedError
+    def tilt_algorithm(self, chname_avert, chname_medlat, chname_antpost, out_folder=None, inplace=False):
+        """ tilt correction for acceleration data """
+        start_time = time.time()
+        verbose = self.verbose
+        in_folder = self.in_folder
+        if inplace is None:
+            inplace = self.inplace
+        fl = engine(in_folder, name_contains=self.name_contains, subfolders=self.subfolders)
+        for f in fl:
+            batchdisp('tilt correction of acceleration channels for {}'.format(f), level=2, verbose=verbose)
+            data = zload(f)
+            data = tilt_algorithm_data(data, chname_avert, chname_medlat, chname_antpost)
+            zsave(f, data, inplace=inplace, out_folder=out_folder, root_folder=in_folder)
+        method_name = inspect.currentframe().f_code.co_name
+        batchdisp(
+            '{} process complete for {} file(s) in {:.2f} secs'.format(method_name, len(fl), time.time() - start_time),
+            level=1, verbose=verbose)
+        # Update self.folder after  processing
+        self._update_folder(out_folder, inplace, in_folder)
+
+    def compute_magnitude(self, chname1, chname2, chname3, out_folder=None, inplace=False):
+        """ tilt correction for acceleration data """
+        start_time = time.time()
+        verbose = self.verbose
+        in_folder = self.in_folder
+        if inplace is None:
+            inplace = self.inplace
+        fl = engine(in_folder, name_contains=self.name_contains, subfolders=self.subfolders)
+        for f in fl:
+            batchdisp('compute magnitude from channels {}, {}, {} for {}'.format(chname1, chname2, chname3, f), level=2, verbose=verbose)
+            data = zload(f)
+            data = compute_magnitude_data(data, chname1, chname2, chname3)
+            zsave(f, data, inplace=inplace, out_folder=out_folder, root_folder=in_folder)
+        method_name = inspect.currentframe().f_code.co_name
+        batchdisp(
+            '{} process complete for {} file(s) in {:.2f} secs'.format(method_name, len(fl), time.time() - start_time),
+            level=1, verbose=verbose)
+        # Update self.folder after  processing
+        self._update_folder(out_folder, inplace, in_folder)
+
+    def phase_angle(self, ch, out_folder=None, inplace=None):
+        """ computes phase angles"""
+        start_time = time.time()
+        verbose = self.verbose
+        in_folder = self.in_folder
+        if inplace is None:
+            inplace = self.inplace
+        fl = engine(in_folder, extension='.zoo', name_contains=self.name_contains, subfolders=self.subfolders)
+        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, out_folder=out_folder, root_folder=in_folder)
+        method_name = inspect.currentframe().f_code.co_name
+        batchdisp('{} process complete for {} file(s) in {:.2f} secs'.format(method_name, len(fl), time.time() - start_time), 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"""
+        start_time = time.time()
+        verbose = self.verbose
+        in_folder = self.in_folder
+        if inplace is None:
+            inplace = self.inplace
+        fl = engine(in_folder, extension='.zoo', name_contains=self.name_contains, subfolders=self.subfolders)
+        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, out_folder=out_folder, root_folder=in_folder)
+        method_name = inspect.currentframe().f_code.co_name
+        batchdisp('{} process complete for {} file(s) in {:.2f} secs'.format(method_name, len(fl), time.time() - start_time), 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"""
+        start_time = time.time()
+        verbose = self.verbose
+        in_folder = self.in_folder
+        if inplace is None:
+            inplace = self.inplace
+        fl = engine(in_folder, extension='.zoo', name_contains=self.name_contains, subfolders=self.subfolders)
+        for f in fl:
+            f_name = os.path.splitext(os.path.basename(f))[0]
+            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, out_folder=out_folder, root_folder=in_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]
+                    batchdisp('splitting by gait cycle from {} to {} for {}'.format(start, end, f), level=2,
+                              verbose=verbose)
+                    data_new = split_trial_data(data, start, end)
+                    if data_new is not None:
+                        zsave(fl_new, data_new, inplace=inplace, out_folder=out_folder, root_folder=in_folder)
+        method_name = inspect.currentframe().f_code.co_name
+        batchdisp('{} process complete for {} file(s) in {:.2f} secs'.format(method_name, len(fl), time.time() - start_time), 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 """
+        start_time = time.time()
+        verbose = self.verbose
+        in_folder = self.in_folder
+        if inplace is None:
+            inplace = self.inplace
+        fl = engine(in_folder, extension='.zoo', name_contains=self.name_contains, subfolders=self.subfolders)
+        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, out_folder=out_folder, root_folder=in_folder)
+        method_name = inspect.currentframe().f_code.co_name
+        batchdisp('{} process complete for {} file(s) in {:.2f} secs'.format(method_name, len(fl), time.time() - start_time), 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 """
+        start_time = time.time()
+        verbose = self.verbose
+        in_folder = self.in_folder
+        if inplace is None:
+            inplace = self.inplace
+        fl = engine(in_folder, extension='.zoo', name_contains=self.name_contains, subfolders=self.subfolders)
+        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, out_folder=out_folder, root_folder=in_folder)
+        method_name = inspect.currentframe().f_code.co_name
+        batchdisp('{} process complete for {} file(s) in {:.2f} secs'.format(method_name, len(fl), time.time() - start_time), 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 """
+        start_time = time.time()
+        verbose = self.verbose
+        in_folder = self.in_folder
+        if inplace is None:
+            inplace = self.inplace
+        fl = engine(in_folder, extension='.zoo', name_contains=self.name_contains, subfolders=self.subfolders)
+        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, out_folder=out_folder, root_folder=in_folder)
+        method_name = inspect.currentframe().f_code.co_name
+        batchdisp('{} process complete for {} file(s) in {:.2f} secs'.format(method_name, len(fl), time.time() - start_time), level=1, verbose=verbose)
+
+        # Update self.folder after  processing
+        self._update_folder(out_folder, inplace, in_folder)
+
+
+    def removeevent(self, events, mode='remove', out_folder=None, inplace=None):
+        """ removes channels from zoo files """
+        start_time = time.time()
+        verbose = self.verbose
+        in_folder = self.in_folder
+        if inplace is None:
+            inplace = self.inplace
+        fl = engine(in_folder, extension='.zoo', name_contains=self.name_contains, subfolders=self.subfolders)
+        for f in fl:
+            batchdisp('removing events {} for {}'.format(events, f), level=2, verbose=verbose)
+            data = zload(f)
+            data = removeevent_data(data, events, mode)
+            zsave(f, data, inplace=inplace, out_folder=out_folder, root_folder=in_folder)
+        method_name = inspect.currentframe().f_code.co_name
+        batchdisp('{} process complete for {} file(s) in {:.2f} secs'.format(method_name, len(fl), time.time() - start_time), 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 """
+        start_time = time.time()
+        verbose = self.verbose
+        in_folder = self.in_folder
+        if inplace is None:
+            inplace = self.inplace
+        fl = engine(in_folder, extension='.zoo', name_contains=self.name_contains, subfolders=self.subfolders)
+        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, out_folder=out_folder, root_folder=in_folder)
+        method_name = inspect.currentframe().f_code.co_name
+        batchdisp('{} process complete for {} file(s) in {:.2f} secs'.format(method_name, len(fl), time.time() - start_time), 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 """
+        start_time = time.time()
+        verbose = self.verbose
+        in_folder = self.in_folder
+        if inplace is None:
+            inplace = self.inplace
+        fl = engine(in_folder, extension='.zoo', name_contains=self.name_contains, subfolders=self.subfolders)
+        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, out_folder=out_folder, root_folder=in_folder)
+        method_name = inspect.currentframe().f_code.co_name
+        batchdisp('{} process complete for {} file(s) in {:.2f} secs'.format(method_name, len(fl), time.time() - start_time), level=1, verbose=verbose)
+
+        # Update self.folder after  processing
+        self._update_folder(out_folder, inplace, in_folder)
+
+    def addevent(self, ch, event_type, event_name, out_folder=None, inplace=None, constant=None):
+        """ adds events of type evt_type with name evt_name to channel ch """
+        start_time = time.time()
+        verbose = self.verbose
+        in_folder = self.in_folder
+        if inplace is None:
+            inplace = self.inplace
+        fl = engine(in_folder, extension='.zoo', name_contains=self.name_contains, subfolders=self.subfolders)
+        for f in fl:
+            if verbose:
+                batchdisp('adding event {} to channel {} for {}'.format(event_type, ch, f), level=2, verbose=verbose)
+            data = zload(f)
+            data = addevent_data(data, ch, event_type, event_name, constant)
+            zsave(f, data, inplace=inplace, out_folder=out_folder, root_folder=in_folder)
+        method_name = inspect.currentframe().f_code.co_name
+        batchdisp('{} process complete for {} file(s) in {:.2f} secs'.format(method_name, len(fl), time.time() - start_time), 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 """
+        start_time = time.time()
+        verbose = self.verbose
+        in_folder = self.in_folder
+        if inplace is None:
+            inplace = self.inplace
+        fl = engine(in_folder, extension='.zoo', name_contains=self.name_contains, subfolders=self.subfolders)
+        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, out_folder=out_folder, root_folder=in_folder)
+        method_name = inspect.currentframe().f_code.co_name
+        batchdisp('{} process complete for {} file(s) in {:.2f} secs'.format(method_name, len(fl), time.time() - start_time), 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):
+        """ filter data"""
+        start_time = time.time()
+        verbose = self.verbose
+        in_folder = self.in_folder
+        if inplace is None:
+            inplace = self.inplace
+        fl = engine(in_folder, name_contains=self.name_contains, subfolders=self.subfolders)
+        for f in fl:
+            if verbose:
+                batchdisp('filtering data for channel {} in {}'.format(ch, f), level=2, verbose=verbose)
+            data = zload(f)
+            data = filter_data(data, ch, filt)
+            zsave(f, data, inplace=inplace, out_folder=out_folder, root_folder=in_folder)
+        method_name = inspect.currentframe().f_code.co_name
+        batchdisp('{} process complete for {} file(s) in {:.2f} secs'.format(method_name, len(fl), time.time() - start_time),
+            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,95 @@
+from biomechzoo.utils.set_zoosystem import set_zoosystem
+
+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 = {}
+    data['zoosystem'] = set_zoosystem()
+    video_freq = None
+    analog_freq = None
+    # extract "video" data
+    if 'points' in c3d_obj['data']:
+        points = c3d_obj['data']['points']  # shape: (4, n_markers, n_frames)
+        labels = list(c3d_obj['parameters']['POINT']['LABELS']['value'])
+        video_freq = int(c3d_obj['parameters']['POINT']['RATE']['value'][0])
+        for i, label in enumerate(labels):
+            line_data = points[:3, i, :].T  # shape: (frames, 3)
+            data[label] = {
+                'line': line_data,
+                'event': {}  # empty for now
+            }
+
+        data['zoosystem']['Video']['Freq'] = video_freq
+        data['zoosystem']['Video']['Channels'] = labels
+
+    if 'analogs' in c3d_obj['data']:
+        analog_data = c3d_obj['data']['analogs']  # shape: (subframes, n_analog_channels, n_frames)
+        analog_labels = list(c3d_obj['parameters']['ANALOG']['LABELS']['value'])
+        analog_freq = int(c3d_obj['parameters']['ANALOG']['RATE']['value'][0])
+        # Flatten to 2D: (n_samples, n_channels)
+        # ezc3d stores analogs as subframes per frame, so we flatten across all
+        n_subframes, n_channels, n_frames = analog_data.shape
+        analog_data = analog_data.reshape(n_subframes * n_frames, n_channels)
+
+        for i, label in enumerate(analog_labels):
+            line_data = analog_data[:, i].reshape(-1, 1)  # shape: (samples, 1)
+            data[label] = {
+                'line': line_data,
+                'event': {},
+            }
+
+        data['zoosystem']['Analog']['Freq'] = analog_freq
+        data['zoosystem']['Analog']['Channels'] = analog_labels
+
+    # extract event information
+    params = c3d_obj['parameters']
+    if 'EVENT' in params and 'TIMES' in params['EVENT']:
+        if 'points' in c3d_obj['data']:
+            times_array = params['EVENT']['TIMES']['value']
+            frames = times_array[1]  # should be 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-1, 0, 0]       # remove 1 to follow python
+                    else:
+                        data[labels[0]]['event'][key_name] = [frame-1, 0, 0]    # remove 1 to follow python
+
+    # add more zoosystem
+    if analog_freq is not None and video_freq is not None:
+        data['zoosystem']['AVR'] = analog_freq/video_freq
+
+    return data

biomechzoo/conversion/mvnx2zoo_data.py

@@ -0,0 +1,113 @@
+import numpy as np
+from biomechzoo.mvn.load_mvnx import load_mvnx
+from biomechzoo.mvn.mvn import JOINTS, SEGMENTS
+from biomechzoo.utils.set_zoosystem import set_zoosystem
+
+def mvnx2zoo_data(fl):
+    """ loads mvnx file from xsens"""
+
+    mvnx_file = load_mvnx(fl)
+
+    # create zoo data dict
+    data = {'zoosystem': set_zoosystem()}
+    # extract joint angle data (All JOINTS may not exist in a given dataset)
+    for key, val in JOINTS.items():
+        try:
+            r = mvnx_file.get_joint_angle(joint=key)
+            data[val] = {
+                'line': np.array(r),
+                'event': {}
+            }
+        except KeyError:
+            print('joint {} does not exist, skipping'.format(val))
+
+    # extract segment orientations (All SEGMENTS may not exist in a given dataset)
+    for key, val in SEGMENTS.items():
+        try:
+            r = mvnx_file.get_sensor_ori(segment=key)
+
+            data[val] = {
+                'line': np.array(r),
+                'event': {}
+            }
+        except KeyError:
+            print('segment {} does not exist, skipping'.format(val))
+
+    # get foot strike events
+    data = _get_foot_strike_events(mvnx_file, data)
+
+    # add meta information
+    data = _get_meta_info(fl, mvnx_file, data)
+
+    return data
+
+
+def is_valid_for_zoo(val):
+    """
+    Returns True if the value is valid for a MATLAB-compatible zoo structure.
+    """
+    if val is None:
+        return False
+    if isinstance(val, list) and len(val) == 0:
+        return False
+    if isinstance(val, np.ndarray) and val.size == 0:
+        return False
+    return True
+
+
+def _get_meta_info(fl, mvnx_file, data):
+    # todo: add more, see mvnx_file object
+    data['zoosystem']['Video']['Freq'] = int(mvnx_file.frame_rate)
+    data['zoosystem']['mvnx_version'] = mvnx_file.version
+    data['zoosystem']['mvnx_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
+    return data
+
+
+def _get_foot_strike_events(mvnx_file, data):
+    RHeel = np.zeros(mvnx_file.frame_count)
+    LHeel = np.zeros(mvnx_file.frame_count)
+
+    for n in range(mvnx_file.frame_count):
+        list_contact = mvnx_file.get_foot_contacts(n)
+        for contact in list_contact:
+            if contact['segment_index'] == 17:
+                RHeel[n] = True
+            elif contact['segment_index'] == 21:
+                LHeel[n] = True
+
+    hs_r = []
+    hs_l = []
+    for i in range(1, len(LHeel)):  # Start from 1 to avoid i-1 out-of-range
+        if RHeel[i - 1] == 0 and RHeel[i] == 1:
+            hs_r.append(i)
+        if LHeel[i - 1] == 0 and LHeel[i] == 1:
+            hs_l.append(i)
+
+    # add to event branch of any channel
+    if 'jL5S1' in data:
+        ch = 'jL5S1'
+    else:
+        ch = next(iter(data))
+
+    if hs_r:
+        for i, rHS in enumerate(hs_r):
+            data[ch]['event']['R_FS' + str(i + 1)] = [rHS, 0, 0]
+    if hs_l:
+        for i, lHS in enumerate(hs_l):
+            data[ch]['event']['L_FS' + str(i + 1)] = [lHS, 0, 0]
+
+    return data
+
+
+if __name__ == '__main__':
+    """ testing """
+    import os
+    from biomechzoo.processing.split_trial_data import split_trial_data
+    # -------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', 'Flat001.mvnx')
+    fl_zoo = fl.replace('.mvnx', '.zoo')
+    data = mvnx2zoo_data(fl)

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)