biomechzoo 0.4.10__tar.gz → 0.5.0__tar.gz

{biomechzoo-0.4.10/src/biomechzoo.egg-info → biomechzoo-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: biomechzoo
-Version: 0.4.10
+Version: 0.5.0
 Summary: Python implementation of the biomechZoo toolbox
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/mcgillmotionlab/biomechzoo

{biomechzoo-0.4.10 → biomechzoo-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "biomechzoo"
-version = "0.4.10"
+version = "0.5.0"
 description = "Python implementation of the biomechZoo toolbox"
 readme = "README.md"
 requires-python = ">=3.11,<3.12"   # max version for opencap-process tools is 3.11

{biomechzoo-0.4.10 → biomechzoo-0.5.0}/src/biomechzoo/biomech_ops/filter_data.py

@@ -13,10 +13,10 @@ def filter_data(data, ch, filt=None):
         The name(s) of the channel(s) to filter.
     filt : dict, optional
         Dictionary specifying filter parameters. Keys may include:
-        - 'type': 'butter' (default)
+        - 'ftype': 'butter' (default)
         - 'order': filter order (default: 4)
         - 'cutoff': cutoff frequency or tuple (Hz)
-        - 'btype': 'low', 'high', 'bandpass', 'bandstop' (default: 'low')
+        - 'btype': 'low', 'high', 'bandpass', 'bandstop' (default: 'lowpass')
 
     Returns
     -------
@@ -25,32 +25,34 @@ def filter_data(data, ch, filt=None):
     """
 
     if filt is None:
-        filt = {}
+        filt = {'ftype': 'butter',
+                'order': 4,
+                'cutoff': 10,
+                'btype': 'lowpass',
+                'filtfilt': True}
 
     if isinstance(ch, str):
         ch = [ch]
 
-    analog_channels = data['zoosystem']['Analog']['Channels']
-    if analog_channels:
-        analog_freq = data['zoosystem']['Analog']['Freq']
-    video_channels = data['zoosystem']['Video']['Channels']
-    if video_channels:
-        video_freq = data['zoosystem']['Video']['Freq']
-
+    # loop through all channels and filter
     for c in ch:
         if c not in data:
             raise KeyError('Channel {} not found in data'.format(c))
 
         if 'fs' not in filt:
+
+            video_channels = data['zoosystem']['Video']['Channels']
+            analog_channels = data['zoosystem']['Analog']['Channels']
+
             if c in analog_channels:
-                filt['fs'] = analog_freq
-            elif c in video_freq:
-                filt['fs'] = video_freq
+                filt['fs'] = data['zoosystem']['Analog']['Freq']
+            elif c in video_channels:
+                filt['fs'] =  data['zoosystem']['Video']['Freq']
             else:
-                raise ValueError('frequency not provided and cannot be inferred from zoosystem for channel'.format(c))
+                raise ValueError('Channel not analog or video')
 
         signal_raw = data[c]['line']
-        signal_filtered = filter_line(signal_raw, filt)
+        signal_filtered = filter_line(signal_raw=signal_raw, filt=filt)
         data[c]['line'] = signal_filtered
 
     return data

biomechzoo-0.5.0/src/biomechzoo/biomech_ops/filter_line.py

@@ -0,0 +1,85 @@
+import numpy as np
+import scipy.signal as sgl
+
+
+def filter_line(signal_raw, filt=None, fs=None):
+    """Filter an array using a Butterworth filter."""
+    #todo: verify that filter is working correctly
+    #todo add more filters
+    #todo: consider using kineticstoolkit
+
+    if filt is None:
+        filt = {'ftype': 'butter',
+                'order': 4,
+                'cutoff': 10,
+                'btype': 'lowpass',
+                'filtfilt': True}
+        if fs is None:
+            raise ValueError('fs is required if no filt is specified')
+
+    else:
+        if 'fs' not in filt:
+            raise ValueError('fs is a required key of filt')
+
+    # Normalize filter type strings
+    if filt['ftype'] == 'butterworth':
+        filt['ftype'] = 'butter'
+    if filt['btype'] is 'low':
+        filt['btype'] = 'lowpass'
+    if filt['btype'] is 'high':
+        filt['btype'] = 'highpass'
+
+    # Extract parameters
+    ftype = filt['ftype']
+    order = filt['order']
+    cutoff = filt['cutoff']
+    btype = filt['btype']
+    filtfilt = filt['filtfilt']
+    fs = filt['fs']
+
+    # prepare normalized cutoff(s)
+    nyq = 0.5 * fs
+    norm_cutoff = np.atleast_1d(np.array(cutoff) / nyq)
+
+    if ftype is 'butter':
+        signal_filtered = kt_butter(ts=signal_raw, fc=norm_cutoff, fs=fs, order=order, btype=btype, filtfilt=filtfilt)
+    else:
+        raise NotImplementedError(f"Filter type '{ftype}' not implemented.")
+
+    return signal_filtered
+
+
+def kt_butter(ts, fc, fs, order=2, btype='lowpass', filtfilt=True):
+    """
+    Apply a Butterworth filter to data.
+
+    Parameters
+    ----------
+    ts, ndarray, 1d.
+    fc, Cut-off frequency in Hz. This is a float for single-frequency filters
+        (lowpass, highpass), or a tuple of two floats (e.g., (10., 13.)
+        for two-frequency filters (bandpass, bandstop)).
+    order, Optional. Order of the filter. Default is 2.
+    btype, Optional. Can be either "lowpass", "highpass", "bandpass" or
+        "bandstop". Default is "lowpass".
+    filtfilt, Optional. If True, the filter is applied two times in reverse direction
+        to eliminate time lag. If False, the filter is applied only in forward
+        direction. Default is True.
+
+    Returns
+    -------
+    ts_f,  A copy of the input data which each data being filtered.
+    
+    Notes: 
+    - This code was adapted from kineticstoolkit Thanks @felxi
+    """
+
+    sos = sgl.butter(order, fc, btype, analog=False, output="sos", fs=fs)
+
+    # Filter
+    if filtfilt:
+        ts_f = sgl.sosfiltfilt(sos, ts, axis=0)
+    else:
+        ts_f = sgl.sosfilt(sos,ts, axis=0)
+
+    return ts_f

{biomechzoo-0.4.10 → biomechzoo-0.5.0}/src/biomechzoo/biomech_ops/normalize_data.py

@@ -1,4 +1,5 @@
 import warnings
+import copy
 from biomechzoo.biomech_ops.normalize_line import normalize_line
 
 
@@ -14,14 +15,14 @@ def normalize_data(data, nlength=101):
     """
 
     # normalize channel length
-    data_new = data.copy()
+    data_new = copy.deepcopy(data)
     for ch_name, ch_data in data_new.items():
         if ch_name != 'zoosystem':
             ch_data_line = ch_data['line']
             ch_data_event = ch_data['event']
             ch_data_normalized = normalize_line(ch_data_line, nlength)
-    data_new[ch_name]['line'] = ch_data_normalized
-    data_new[ch_name]['event'] = ch_data_event
+            data_new[ch_name]['line'] = ch_data_normalized
+            data_new[ch_name]['event'] = ch_data_event
     warnings.warn('event data have not been normalized')
 
     # update zoosystem

{biomechzoo-0.4.10 → biomechzoo-0.5.0}/src/biomechzoo/biomechzoo.py

@@ -12,6 +12,7 @@ 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
@@ -19,6 +20,7 @@ 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
 
 class BiomechZoo:
     def __init__(self, in_folder, inplace=False, subfolders=None, name_contains=None, verbose=0):
@@ -61,6 +63,8 @@ class BiomechZoo:
             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()
@@ -75,7 +79,7 @@ class BiomechZoo:
             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('{} conversion complete for {} files'.format(method_name, len(fl)), level=1, verbose=verbose)
+        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)
 
@@ -99,17 +103,21 @@ class BiomechZoo:
         # Update self.folder after  processing
         self._update_folder(out_folder, inplace, in_folder)
 
-    def table2zoo(self, out_folder=None, inplace=None, skip_rows=0, extension='csv'):
+    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, type=extension, skip_rows=skip_rows)
+            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
@@ -118,8 +126,13 @@ class BiomechZoo:
         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
+        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 phase_angle(self, ch, out_folder=None, inplace=None):
         """ computes phase angles"""
@@ -184,7 +197,8 @@ class BiomechZoo:
                     batchdisp('splitting by gait cycle from {} to {} for {}'.format(start, end, f), level=2,
                               verbose=verbose)
                     data_new = split_trial(data, start, end)
-                    zsave(fl_new, data_new, inplace=inplace, out_folder=out_folder, root_folder=in_folder)
+                    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)
 
@@ -266,6 +280,27 @@ class BiomechZoo:
         # 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()
@@ -306,7 +341,7 @@ class BiomechZoo:
         # 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):
+    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
@@ -318,7 +353,7 @@ class BiomechZoo:
             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)
+            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)
@@ -346,28 +381,22 @@ class BiomechZoo:
         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, verbose=verbose)
-        # method_name = inspect.currentframe().f_code.co_name
-        # batchdisp('{} computation complete for {} file(s)'.format(method_name, len(fl)), level=1, verbose=verbose)
-        #
-        # # Update self.folder after  processing
-        # self._update_folder(out_folder, inplace, in_folder)
-
+        """ 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-0.4.10 → biomechzoo-0.5.0}/src/biomechzoo/conversion/c3d2zoo_data.py

@@ -8,10 +8,14 @@ def c3d2zoo_data(c3d_obj):
     - 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 = c3d_obj['parameters']['POINT']['LABELS']['value']
+        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] = {
@@ -19,9 +23,32 @@ def c3d2zoo_data(c3d_obj):
                 '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']:
+        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
 
@@ -61,8 +88,8 @@ def c3d2zoo_data(c3d_obj):
                     else:
                         data[labels[0]]['event'][key_name] = [frame-1, 0, 0]    # remove 1 to follow python
 
-    # todo add relevant meta data to zoosystem
-    data['zoosystem'] = set_zoosystem()
-    data['zoosystem']['Analog']['Freq'] = int(params['ANALOG']['RATE']['value'][0])
+    # 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-0.4.10 → biomechzoo-0.5.0}/src/biomechzoo/conversion/mvnx2zoo_data.py

@@ -9,8 +9,7 @@ def mvnx2zoo_data(fl):
     mvnx_file = load_mvnx(fl)
 
     # create zoo data dict
-    data = {}
-
+    data = {'zoosystem': set_zoosystem()}
     # extract joint angle data (All JOINTS may not exist in a given dataset)
     for key, val in JOINTS.items():
         try:
@@ -58,7 +57,6 @@ def is_valid_for_zoo(val):
 
 def _get_meta_info(fl, mvnx_file, data):
     # todo: add more, see mvnx_file object
-    data['zoosystem'] = set_zoosystem(fl)
     data['zoosystem']['Video']['Freq'] = int(mvnx_file.frame_rate)
     data['zoosystem']['mvnx_version'] = mvnx_file.version
     data['zoosystem']['mvnx_configuration'] = mvnx_file.configuration

{biomechzoo-0.4.10 → biomechzoo-0.5.0}/src/biomechzoo/conversion/table2zoo_data.py

@@ -6,42 +6,59 @@ 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(csv_path, type='csv', skip_rows=0, freq=None):
-    # todo: check calculation for sampling rate
+def table2zoo_data(fl, extension, skip_rows=0, freq=None):
 
-    if type not in ['csv', 'parquet']:
-        raise NotImplementedError('Only csv and parquet currently supported')
+    if extension == 'csv':
+        df, metadata, freq = _csv2zoo(fl, skip_rows=skip_rows, freq=freq)
 
-    # Read header lines until 'endheader'
-    metadata = {}
-    if type == 'csv' and skip_rows > 0:
-        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)
-
-    if type == 'csv':
-        df = pd.read_csv(csv_path, skiprows=skip_rows)
-    elif type =='parquet':
-        df = pd.read_parquet(csv_path)
+    elif extension == 'parquet':
+        df, metadata, freq = _parquet2zoo(fl, skip_rows=skip_rows, freq=freq)
     else:
-        raise ValueError('type must be csv or parquet')
-
-    # Use all columns
-    data = df.iloc[:, 0:]
+        raise ValueError('extension {} not implemented'.format(extension))
 
     # assemble zoo data
-    zoo_data = {}
-    for ch in data.columns:
-        zoo_data[ch] = {
-            'line': data[ch].values,
+    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:
@@ -51,22 +68,12 @@ def table2zoo_data(csv_path, type='csv', skip_rows=0, freq=None):
         else:
             freq = None  # or raise an error
 
-    # 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:
-            time_data = df[time_col].to_numpy()[:, 0]
-            freq = compute_sampling_rate_from_time(time_data)
+    # read csv
+    df = pd.read_csv(fl, skiprows=skip_rows)
+
+    return df, metadata, freq
 
-    # add metadata
-    # todo update zoosystem to match biomechzoo requirements
-    zoo_data['zoosystem'] = set_zoosystem(csv_path)
-    zoo_data['zoosystem']['Video']['Freq'] = freq
-    zoo_data['zoosystem']['Analog']['Freq'] = 'None'
-    if 'version' in metadata:
-        zoo_data['zoosystem']['collection_system_version'] = metadata['version']
 
-    return zoo_data
 
 
 def _parse_metadata(header_lines):
@@ -96,6 +103,8 @@ def _parse_metadata(header_lines):
     return metadata
 
 
+
+
 if __name__ == '__main__':
     """ for unit testing"""
     current_dir = os.path.dirname(os.path.abspath(__file__))

biomechzoo-0.5.0/src/biomechzoo/processing/addevent_data.py

@@ -0,0 +1,98 @@
+import numpy as np
+import copy
+import warnings
+from biomechzoo.utils.peak_sign import peak_sign
+
+def addevent_data(data, channels, ename, etype, constant=None):
+
+    data_new = copy.deepcopy(data)
+
+    if isinstance(channels, str):
+        channels = [channels]
+
+    if len(channels) == 1 and channels[0].lower() == 'all':
+        channels = [key for key in data if key != 'zoosystem']
+
+    for channel in channels:
+        if ename == '':
+            data[channel]['event'] = {}
+            continue
+
+        if channel not in data:
+            raise KeyError('Channel {} does not exist'.format(channel))
+
+        yd = data_new[channel]['line']  # 1D array
+        etype = etype.lower()
+        if etype == 'absmax':
+            exd = int(np.argmax(np.abs(yd)))
+            eyd = float(yd[exd])
+        elif etype == 'first':
+            exd = 0
+            eyd = float(yd[exd])
+        elif etype == 'last':
+            exd = len(yd) - 1
+            eyd = float(yd[exd])
+        elif etype == 'max':
+            exd = int(np.argmax(yd))
+            eyd = float(yd[exd])
+        elif etype == 'min':
+            exd = int(np.argmin(yd))
+            eyd = float(yd[exd])
+        elif etype == 'rom':
+            eyd = float(np.max(yd) - np.min(yd))
+            exd = 0  # dummy index (like MATLAB version)
+        elif etype == 'max_stance':
+            # special event for gait and running
+            exd = max_stance(yd)
+            eyd = float(yd[exd])
+            eyd = float(yd[exd])
+        elif etype in ['fs_fp', 'fo_fp']:
+            # --- Handle constant ---
+            if constant is None:
+                print('Warning: Force plate threshold not set, defaulting to 0.')
+                constant = 0.0
+
+            # --- Check sampling rates ---
+            AVR = data['zoosystem']['AVR']
+            if AVR != 1:
+                warnings.warn('Video and Analog channels must be at the same sampling rate or events will be incorrect.')
+
+            # --- Handle units ---
+            units = data['zoosystem']['Units']['Forces']
+            if units == 'N/kg':
+                m = data['zoosystem']['Anthro']['Bodymass']
+            else:
+                m = 1.0
+
+            # --- Extract force signal ---
+            if '_' not in channel:
+                yd = data_new[channel]['line'][:, 2]  # looking for GRF Z
+            else:
+                yd = data_new[channel]['line']
+
+            # --- Determine peak sign ---
+            peak = peak_sign(yd)  # user-defined function
+
+            # --- Find threshold crossing ---
+            threshold_signal = peak * yd * m
+            if 'fs' in etype:
+                exd_array = np.where(threshold_signal > constant)[0]
+                exd = exd_array[0] - 1  # MATLAB indexing correction
+                eyd = yd[exd]
+            else:  # 'FO' type
+                exd_array = np.where(threshold_signal > constant)[0]
+                exd = exd_array[-1] + 1
+                eyd = yd[exd]
+
+        else:
+            raise ValueError(f'Unknown event type: {etype}')
+
+        # Add event to the channel's event dict
+        data_new[channel]['event'][ename] = [exd, eyd, 0]
+
+    return data_new
+
+def max_stance(yd):
+    """ extracts max from first 40% of the gait cycle"""
+    raise NotImplementedError
+    return exd