biomechzoo 0.5.9__py3-none-any.whl

biomechzoo/processing/addchannel_data.py

@@ -0,0 +1,71 @@
+import numpy as np
+
+
+def addchannel_data(data, ch_new_name, ch_new_data, section='Video'):
+    """
+    Add a new channel to zoo data.
+
+    Parameters
+    ----------
+    data : dict
+        Zoo file data.
+    ch_new_name : str
+        Name of the new channel.
+    ch_new_data : array-like
+        New data to be added to the channel (should be n x 1 or n x 3).
+    section : str
+        Section of zoo data ('Video' or 'Analog').
+
+    Returns
+    -------
+    dict
+        Updated zoo data with new channel added.
+
+    Notes
+    -----
+    - If the channel already exists, it will be overwritten.
+    - Adds channel name to the list in data['zoosystem'][section]['Channels'].
+    """
+
+    # Warn if overwriting
+    if ch_new_name in data:
+        print('Warning: channel {} already exists, overwriting...'.format(ch_new_name))
+
+# Assign channel data
+    data[ch_new_name] = {
+        'line': ch_new_data,
+        'event': {}
+    }
+
+    # Update channel list
+    ch_list = data['zoosystem'][section].get('Channels', [])
+
+    # If the channel list is a NumPy array, convert it to a list
+    if isinstance(ch_list, np.ndarray):
+        ch_list = ch_list.tolist()
+
+    # Ensure it's a flat list of strings
+    if isinstance(ch_list, list) and ch_new_name not in ch_list:
+        ch_list.append(ch_new_name)
+        data['zoosystem'][section]['Channels'] = ch_list
+
+    return data
+
+
+if __name__ == '__main__':
+    # -------TESTING--------
+    import os
+    from src.biomechzoo.utils.zload import zload
+    from src.biomechzoo.utils.zplot import zplot
+    # get path to sample zoo file
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    project_root = os.path.dirname(current_dir)
+    fl = os.path.join(project_root, 'data', 'other', 'HC030A05.zoo')
+
+    # load  zoo file
+    data = zload(fl)
+    data = data['data']
+    r = data['RKneeAngles']['line']*3
+    data= addchannel_data(data, ch_new_name='blah', ch_new_data=r)
+    zplot(data, 'blah')
+

biomechzoo/processing/addevent_data.py

@@ -0,0 +1,116 @@
+import numpy as np
+import copy
+import warnings
+from scipy.signal import find_peaks
+from biomechzoo.utils.peak_sign import peak_sign
+from biomechzoo.biomech_ops.movement_onset import movement_onset
+
+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 == 'first peak':
+            # special event for gait and running
+            exd = find_first_peak(yd, constant)
+            eyd = float(yd[exd])
+        elif etype == 'movement_onset':
+            exd = movement_onset(yd, constant, etype=etype)
+            eyd = yd[exd]
+        elif etype == 'movement_offset':
+            yd2 = yd[::-1].copy() # Reverse the time series.
+            exd = movement_onset(yd2, constant, etype=etype)
+            eyd = 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 find_first_peak(yd, constant):
+    """ extracts first peak from a series of 2 peaks """
+    # Find peaks above threshold
+    peaks, _ = find_peaks(yd, height=constant)
+
+    if len(peaks) == 0:
+        raise ValueError('No peaks found')
+    elif len(peaks) == 1:
+        raise ValueError('Only 1 peak found')
+    else:
+        # Take the first valid peak
+        exd = peaks[0]
+
+    return exd

biomechzoo/processing/explodechannel_data.py

@@ -0,0 +1,69 @@
+import copy
+import numpy as np
+
+def explodechannel_data(data, channels=None):
+    """ Explodes 3D channels (n x 3 arrays) into separate X, Y, Z channels.
+
+    Arguments:
+        data (dict): Zoo data loaded from a file
+        channels (list of str or None): Channels to explode.
+            If None, explode all channels with 'line' shaped (n x 3).
+
+    Returns:
+        data_new (dict): Modified zoo dictionary with exploded channels.
+    """
+    data_new = copy.deepcopy(data)
+
+    # Ensure zoosystem channel lists are Python lists
+    for sys in ['Video', 'Analog']:
+        if sys in data_new.get('zoosystem', {}):
+            ch_list = data_new['zoosystem'][sys].get('Channels', [])
+            if isinstance(ch_list, np.ndarray):
+                ch_list = ch_list.tolist()
+            # strip whitespace
+            ch_list = [str(ch).strip() for ch in ch_list]
+            data_new['zoosystem'][sys]['Channels'] = ch_list
+
+    # Find default channels if none provided
+    if channels is None:
+        channels = []
+        for ch in data_new:
+            if ch == 'zoosystem':
+                continue
+            ch_data = data_new[ch]['line']
+            if ch_data.ndim == 2 and ch_data.shape[1] == 3:
+                channels.append(ch)
+
+    # Explode each channel
+    for ch in channels:
+        if ch not in data_new:
+            print('Warning: channel {} not found, skipping.'.format(ch))
+            continue
+
+        ch_data = data_new[ch]['line']
+        if ch_data.ndim != 2 or ch_data.shape[1] != 3:
+            print(f"Warning: channel '{ch}' 'line' is not n x 3 shape, skipping.")
+            continue
+
+        x, y, z = ch_data[:, 0], ch_data[:, 1], ch_data[:, 2]
+        for axis, line in zip(['_x', '_y', '_z'], [x, y, z]):
+            key = ch + axis
+            data_new[key] = {
+                'line': line,
+                'event': data_new[ch]['event']}
+
+        # Remove original channel
+        del data_new[ch]
+
+        # --- Update zoosystem lists ---
+        for sys in ['Video', 'Analog']:
+            if sys in data_new['zoosystem']:
+                ch_list = data_new['zoosystem'][sys]['Channels']
+                if ch in ch_list:
+                    # Remove original channel
+                    ch_list = [c for c in ch_list if c != ch]
+                    # Add exploded channels
+                    ch_list.extend([ch + '_x', ch + '_y', ch + '_z'])
+                    data_new['zoosystem'][sys]['Channels'] = ch_list
+
+    return data_new

biomechzoo/processing/partition_data.py

@@ -0,0 +1,46 @@
+from biomechzoo.utils.findfield import findfield
+import warnings
+import copy
+import numpy as np
+
+
+def partition_data(data, evt_start, evt_end):
+    """ partition data for all channels between events evt_start and evt_end"""
+
+    # extract event values
+    e1, _ = findfield(data, evt_start)
+    e2, _ = findfield(data, evt_end)
+
+    if e1 is None or e2 is None or len(e1) == 0 or len(e2) == 0:
+        raise ValueError(f"Event not found: evt_start='{evt_start}' returned {e1}, evt_end='{evt_end}' returned {e2}")
+
+    # convert to int and get first value
+    e1 = int(e1[0])
+    e2 = int(e2[0])
+
+    data_new = copy.deepcopy(data)
+    for ch_name, ch_data in sorted(data_new.items()):
+        if ch_name != 'zoosystem':
+            r = ch_data['line']
+            try:
+                if r.ndim == 1:
+                    data_new[ch_name]['line'] = r[e1:e2]
+                else:
+                    data_new[ch_name]['line'] = r[e1:e2, :]
+            except (IndexError, ValueError) as e:
+                # IndexError: if e1[0]:e2[0] goes beyond the available indices
+                # ValueError: less likely, but may arise with shape mismatches
+                warnings.warn(f"Skipping {ch_name} due to error: {e}")
+
+            # partition events
+            events = ch_data['event']
+            for event_name, value in events.items():
+                original_frame = int(value[0])
+                if original_frame == 999:
+                    continue  # do not change outlier markers
+                else:
+                    arr = np.array(data_new[ch_name]['event'][event_name], dtype=np.int32)
+                    arr[0] = original_frame - e1
+                    data_new[ch_name]['event'][event_name] = arr
+
+    return data_new

biomechzoo/processing/removechannel_data.py

@@ -0,0 +1,46 @@
+def removechannel_data(data, channels, mode='remove'):
+    """
+    File-level processing: Remove or keep specified channels in a single zoo dictionary.
+
+    Parameters:
+    - data (dict): Zoo data loaded from a file
+    - channels (list of str): List of channels to remove or keep
+    - mode (str): 'remove' or 'keep'
+
+    Returns:
+    - dict: Modified zoo dictionary with updated channels
+    """
+    if mode not in ['remove', 'keep']:
+        raise ValueError("mode must be 'remove' or 'keep'.")
+
+    all_channels = [ch for ch in data if ch != 'zoosystem']
+
+    # Check for missing channels
+    missing = [ch for ch in channels if ch not in all_channels]
+    if missing:
+        print('Warning: the following channels were not found {}'.format(missing))
+
+    if mode == 'remove':
+        keep_channels = [ch for ch in all_channels if ch not in channels]
+    elif mode == 'keep':
+        keep_channels = [ch for ch in all_channels if ch in channels]
+    else:
+        raise ValueError("Mode must be 'remove' or 'keep'.")
+
+    # --- Compute channels to remove ---
+    remove_channels = [ch for ch in all_channels if ch not in keep_channels]
+
+    if remove_channels:
+        print('Removing channels: {}'.format(remove_channels))
+    else:
+        print('No channels to remove')
+
+    # Remove from main data dict ---
+    for ch in remove_channels:
+        data.pop(ch, None)
+        if ch in data['zoosystem']['Video']['Channels']:
+            data['zoosystem']['Video']['Channels'] = [c for c in data['zoosystem']['Video']['Channels'] if c != ch]
+        if ch in data['zoosystem']['Analog']['Channels']:
+            data['zoosystem']['Analog']['Channels'] = [c for c in data['zoosystem']['Analog']['Channels'] if c != ch]
+
+    return data

biomechzoo/processing/removeevent_data.py

@@ -0,0 +1,57 @@
+import copy
+import warnings
+from biomechzoo.utils.findfield import findfield
+
+def removeevent_data(data, events, mode='remove'):
+    """
+    Remove or keep specified events in all channels of a zoo dictionary.
+
+    Parameters
+    ----------
+    data : dict
+        Zoo data loaded from a file
+    events : list of str
+        Events to remove or keep
+    mode : str
+        'remove' or 'keep'
+
+    Returns
+    -------
+    dict
+        Modified zoo dictionary with events removed or kept
+    """
+    if mode not in ['remove', 'keep']:
+        raise ValueError("mode must be 'remove' or 'keep'.")
+
+    if isinstance(events, str):
+        events = [events]
+
+    # check if any events are not present
+    valid_events = []
+    for evt in events:
+        e, _ = findfield(data, evt)
+        if e is None:
+            warnings.warn('Could not find event {} in zoo file, skipping'.format(evt))
+        else:
+            valid_events.append(evt)
+    events = valid_events
+
+    data_new = copy.deepcopy(data)
+    channels = sorted([ch for ch in data_new if ch != 'zoosystem'])
+    for ch in channels:
+        event_dict = data_new[ch].get('event', {})
+        events_to_remove = []
+
+        for evt in list(event_dict.keys()):
+            if mode == 'remove' and evt in events:
+                events_to_remove.append(evt)
+            elif mode == 'keep' and evt not in events:
+                events_to_remove.append(evt)
+
+        for evt in events_to_remove:
+            event_dict.pop(evt, None)
+            # print('Removed event "{}" from channel "{}"'.format(evt, ch))
+
+        data_new[ch]['event'] = event_dict
+
+    return data_new

biomechzoo/processing/renamechannel_data.py

@@ -0,0 +1,79 @@
+import numpy as np
+
+
+def renamechannel_data(data, ch_old_names, ch_new_names, section='Video'):
+    """
+    Rename channels in a zoo data.
+
+    Parameters
+    ----------
+    data : dict
+        Zoo file data.
+    ch_old_names : str or list
+        Name of the old channels.
+    ch_new_names : str or list
+        Name of the new channels.
+
+    section : str
+        Section of zoo data ('Video' or 'Analog').
+
+    Returns
+    -------
+    dict
+        Updated zoo data with new channel added.
+
+    Notes
+    -----
+    - If the channel already exists, it will be overwritten.
+    - Adds channel name to the list in data['zoosystem'][section]['Channels'].
+    """
+
+    for i, ch_old_name in enumerate(ch_old_names):
+        ch_new_name = ch_new_names[i]
+        # Warn if overwriting
+        if ch_new_name in data:
+            print('Warning: channel {} already exists, overwriting...'.format(ch_new_name))
+
+        # Assign new channel
+        data[ch_new_name] = {
+            'line': data[ch_old_name]['line'],
+            'event': data[ch_old_name]['event']
+        }
+
+        # remove old channel
+        data.pop(ch_old_name)
+
+    # Update channel list
+    ch_list = data['zoosystem'][section].get('Channels', [])
+
+    # If the channel list is a NumPy array, convert it to a list
+    if isinstance(ch_list, np.ndarray):
+        ch_list = ch_list.tolist()
+
+    # Ensure it's a flat list of strings
+    if isinstance(ch_list, list) and ch_new_name not in ch_list:
+        ch_list.append(ch_new_name)
+        data['zoosystem'][section]['Channels'] = ch_list
+
+    return data
+
+
+if __name__ == '__main__':
+    # -------TESTING--------
+    import os
+    from src.biomechzoo.utils.zload import zload
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    project_root = os.path.dirname(current_dir)
+    fl = os.path.join(project_root, 'data', 'other', 'HC030A05.zoo')
+
+    # load  zoo file
+    data = zload(fl)
+    ch_old_name = 'RKneeAngles'
+    ch_new_name = 'RightKneeAngles'
+    data = renamechannel_data(data, ch_old_name=ch_old_name, ch_new_name=ch_new_name)
+
+    if ch_old_name not in data:
+        print('RkneeAngles removed')
+    if ch_new_name in data:
+        print('RightKneeAngles added')
+

biomechzoo/processing/renameevent_data.py

@@ -0,0 +1,62 @@
+def renameevent_data(data, evt, nevt):
+    """
+    Rename events in the Zoo data structure.
+
+    Parameters
+    ----------
+    data : dict
+        The Zoo-formatted dictionary.
+    evt : str or list of str
+        Names of existing events to rename.
+    nevt : str or list of str
+        Names of new events to apply.
+
+    Returns
+    -------
+    data : dict
+        Updated Zoo data with renamed events.
+    """
+    # Convert to list if passed as single string
+    if isinstance(evt, str):
+        evt = [evt]
+    if isinstance(nevt, str):
+        nevt = [nevt]
+
+    if len(evt) != len(nevt):
+        raise ValueError("`evt` and `nevt` must have the same length.")
+
+    # Get all data channels except 'zoosystem'
+    channels = [ch for ch in data if ch != 'zoosystem']
+    for old_name, new_name in zip(evt, nevt):
+        for ch in channels:
+            events = data[ch].get('event', {})
+            if old_name in events:
+                data[ch]['event'][new_name] = events[old_name]
+                del data[ch]['event'][old_name]
+
+    return data
+
+
+if __name__ == '__main__':
+    # -------TESTING--------
+    import os
+    from src.biomechzoo.utils.zload import zload
+    # get path to sample zoo file
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    project_root = os.path.dirname(current_dir)
+    fl = os.path.join(project_root, 'data', 'other', 'HC030A05.zoo')
+
+    # load  zoo file
+    data = zload(fl)
+    evt = ['Left_FootStrike1', 'Left_FootStrike2', 'NonExistingEvent']
+
+    # see existing keys
+    missing = [k for k in evt if k not in data['SACR']['event']]
+    print("Missing keys:", missing)   # expected behavior is missing 'NonExistingEvent'
+
+    nevt = ['LFS_1', 'LFS2', 'NE_1']
+    data = renameevent_data(data, evt=evt, nevt=nevt)
+
+    # after applying renameevent_data
+    missing = [k for k in nevt if k not in data['SACR']['event']]
+    print("Missing keys:", missing)   # expected behavior is missing 'NE_1'

biomechzoo/processing/split_trial_data.py

@@ -0,0 +1,40 @@
+import copy
+from biomechzoo.utils.findfield import findfield
+
+
+def split_trial_data(data, start_event, end_event):
+    # todo check index problem compared to matlab start at 0 or 1
+    data_new = copy.deepcopy(data)
+
+    start_event_indx, _ = findfield(data_new, start_event)
+    end_event_indx, _ = findfield(data_new, end_event)
+
+    if start_event_indx is None:
+        raise ValueError('start_event {} not found'.format(start_event))
+
+    if end_event_indx is None:
+        raise ValueError('event_event {} not found'.format(end_event))
+
+    for key, value in data_new.items():
+        if key == 'zoosystem':
+            continue
+
+        # Slice the line data
+        trial_length = len(data_new[key]['line'])
+        if trial_length > end_event_indx[0]:
+            data_new[key]['line'] = value['line'][start_event_indx[0]:end_event_indx[0]+1]
+        else:
+            print('skipping split trial since event is outside range of data')
+            return None
+
+        # Update events if present
+        if 'event' in value:
+            new_events = {}
+            for evt_name, evt_val in value['event'].items():
+                event_frame = evt_val[0]
+                # Adjust index relative to new start
+                n = event_frame - start_event_indx[0]
+                new_events[evt_name] = [n, 0, 0]
+            data_new[key]['event'] = new_events
+
+    return data_new