c3d-parser 1.2.2__tar.gz → 1.2.4__tar.gz

{c3d_parser-1.2.2/src/c3d_parser.egg-info → c3d_parser-1.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: c3d-parser
-Version: 1.2.2
+Version: 1.2.4
 Summary: C3D parser for gait data harmonisation.
 Author-email: Timothy Salemink <tim.nicolas@outlook.com>, Sally Jack <sallyjaack@gmail.com>
 License-Expression: Apache-2.0
@@ -12,7 +12,7 @@ Requires-Dist: numpy==1.26.4
 Requires-Dist: pandas
 Requires-Dist: c3d==0.5.2
 Requires-Dist: trc-data-reader>=0.4.1
-Requires-Dist: opensim-model-creator==0.7.1
+Requires-Dist: opensim-model-creator==0.7.2
 Requires-Dist: PySide6
 Requires-Dist: matplotlib
 Requires-Dist: mplcursors

{c3d_parser-1.2.2 → c3d_parser-1.2.4}/requirements.txt

@@ -3,7 +3,7 @@ numpy==1.26.4
 pandas
 c3d==0.5.2
 trc-data-reader>=0.4.1
-opensim-model-creator==0.7.1
+opensim-model-creator==0.7.2
 PySide6
 matplotlib
 mplcursors

c3d_parser-1.2.4/src/c3d_parser/__init__.py

@@ -0,0 +1,2 @@
+
+__version__ = "1.2.4"

{c3d_parser-1.2.2 → c3d_parser-1.2.4}/src/c3d_parser/core/c3d_parser.py

@@ -1,6 +1,7 @@
 
 import os
 import re
+import copy
 import math
 import json
 import logging
@@ -38,7 +39,8 @@ required_markers = [{"LASI", "RASI"}, {"LKNE", "RKNE"}, {"LANK", "RANK"}, {"LMED
 
 
 def parse_session(static_trial, dynamic_trials, input_directory, output_directory, lab, marker_diameter, static_data,
-                  left_foot_flat, right_foot_flat, optimise_knee_axis, filter_trc, filter_grf, ik_task_set, progress_tracker):
+                  left_foot_flat, right_foot_flat, optimise_knee_axis, filter_trc, filter_grf, ik_task_set,
+                  running_gait, progress_tracker):
 
     clear_directory(output_directory)
 
@@ -67,7 +69,7 @@ def parse_session(static_trial, dynamic_trials, input_directory, output_director
         try:
             analog_data, events, s_t_data, trc_file_path, grf_file_path = \
                 parse_dynamic_trial(file_path, lab, output_directory, trial_index, marker_data_rate, static_data,
-                                    filter_trc, filter_grf)
+                                    filter_trc, filter_grf, running_gait)
         except ParserError as e:
             logger.error(e)
             continue
@@ -167,7 +169,9 @@ def parse_static_trial(c3d_file, lab, marker_diameter, output_directory, static_
     return frame, trc_file_path, height, weight
 
 
-def parse_dynamic_trial(c3d_file, lab, output_directory, trial_index, marker_data_rate, static_data, filter_trc, filter_grf):
+def parse_dynamic_trial(c3d_file, lab, output_directory, trial_index, marker_data_rate, static_data, filter_trc,
+                        filter_grf, running_gait):
+
     file_name = os.path.basename(c3d_file)
     logger.info(f"Parsing dynamic trial: {file_name}.")
 
@@ -221,7 +225,13 @@ def parse_dynamic_trial(c3d_file, lab, output_directory, trial_index, marker_dat
     set_marker_data(trc_data, frame_data, rate=marker_data_rate)
     trc_file_path = write_trc_data(trc_data, output_file_name, output_directory)
 
-    s_t_data = calculate_spatiotemporal_data(frame_data, events, static_data)
+    # Write gait event data.
+    write_event_data(events, output_file_name, output_directory)
+
+    # Disable spatio-temporal analysis for running gait.
+    s_t_data = {}
+    if not running_gait:
+        s_t_data = calculate_spatiotemporal_data(frame_data, events, static_data)
 
     return analog_data, events, s_t_data, trc_file_path, grf_file_path
 
@@ -246,6 +256,24 @@ def write_c3d_parser_history(input_directory, static_trial, deidentified_file_na
         raise ParserError("Could not write c3d_parser_history.log")
 
 
+def write_event_data(events, file_name, output_directory):
+    event_directory = os.path.join(output_directory, "events")
+    if not os.path.exists(event_directory):
+        os.makedirs(event_directory)
+    event_file_path = os.path.join(event_directory, f"{file_name}.json")
+
+    simplified_events = {
+        side: {
+            cycle: {time: event[0] for time, event in times.items()}
+            for cycle, times in cycles.items()
+        }
+        for side, cycles in events.items()
+    }
+
+    with open(event_file_path, 'w') as f:
+        json.dump(simplified_events, f, indent=2)
+
+
 def run_ik(osim_model, trc_file_path, output_directory, ik_task_set):
     # Perform inverse kinematics.
     file_name = os.path.splitext(os.path.basename(trc_file_path))[0]
@@ -613,8 +641,8 @@ def extract_data(file_path, start_frame, end_frame):
         times = np.arange(start, stop_analog, time_increment).tolist()
         analog_data = {'time': times}
 
-        labels = get_metadata(reader, 'ANALOG:LABELS').string_array
-        analog_data.update({label: [] for label in labels})
+        analog_labels = get_metadata(reader, 'ANALOG:LABELS').string_array
+        analog_data.update({label: [] for label in analog_labels})
         for i, points, analog in reader.read_frames():
             if i < start_frame or end_frame < i:
                 continue
@@ -629,14 +657,14 @@ def extract_data(file_path, start_frame, end_frame):
         event_group = get_metadata(reader, 'EVENT')
         event_count = get_metadata(event_group, 'USED').int8_value
         contexts = get_metadata(event_group, 'CONTEXTS').string_array
-        labels = get_metadata(event_group, 'LABELS').string_array
+        event_labels = get_metadata(event_group, 'LABELS').string_array
         times = get_metadata(event_group, 'TIMES').float_array
         events = {'Left': {}, 'Right': {}}
 
         for i in range(event_count):
             foot = contexts[i].strip()
             if foot:
-                label = labels[i].strip()
+                label = event_labels[i].strip()
                 event_time = times[i][1]
                 event_time = round(float(event_time), 4)
                 events[foot][event_time] = label
@@ -680,15 +708,23 @@ def extract_data(file_path, start_frame, end_frame):
         corners = get_metadata(reader, 'FORCE_PLATFORM:CORNERS').float_array
 
         try:
-            units = get_metadata(reader, 'ANALOG:UNITS').string_array
+            # Convert analog units in V (to N).
             channels = get_metadata(reader, 'FORCE_PLATFORM:CHANNEL').int16_array
-
+            units = get_metadata(reader, 'ANALOG:UNITS').string_array
             if all(units[i - 1] == 'V' for i in channels.flatten()):
                 calibration_matrix = get_metadata(reader, 'FORCE_PLATFORM:CAL_MATRIX').float_array
                 apply_calibration_matrix(plate_count, calibration_matrix, channels, analog_data)
         except ParserError as e:
             logger.warn(e)
 
+        try:
+            # Reorder analog channels according to metadata order.
+            channels = get_metadata(reader, 'FORCE_PLATFORM:CHANNEL').int16_array
+            selected_channels = [analog_labels[i - 1] for i in channels.flatten()]
+            analog_data = analog_data[['time'] + selected_channels]
+        except ParserError as e:
+            logger.warn(e)
+
     return analog_data, reader.analog_rate, trimmed_events, plate_count, corners
 
 
@@ -730,7 +766,7 @@ def extract_static_data(file_path):
         if 'RLEGLENGTH' in processing_group:
             right_leg_length = reader.get('PROCESSING:RLegLength').float_value
 
-        if mass > 200:
+        if mass and mass > 200:
             mass = mass / 9.81
 
     return (height, mass, asis_width, left_knee_width, right_knee_width,
@@ -777,14 +813,6 @@ def calculate_force_and_couple(analog_data, plate_count):
 
     for i in range(plate_count):
         start = 1 + (6 * i)
-
-        next_plate = 1 + (6 * (i + 1))
-        if next_plate < len(analog_data.columns):
-            channel = analog_data.columns[start]
-            next_channel = analog_data.columns[next_plate]
-            if channel.startswith('Fx_3') and next_channel.startswith('Fx_3_new'):
-                start = next_plate
-
         columns = list(range(start, start + 6))
         Fx, Fy, Fz, Mx, My, Mz = analog_data.iloc[:, columns].values.T.astype(float)
 
@@ -1259,6 +1287,10 @@ def calculate_spatiotemporal_data(frame_data, events, static_data):
     step_widths = {"Left": {}, "Right": {}}
     phases = {"Left": {}, "Right": {}}
     gait_speeds = {"Left": {}, "Right": {}}
+    cadences = {"Left": {}, "Right": {}}
+    initial_contact_times = {"Left": {}, "Right": {}}
+    toe_off_times = {"Left": {}, "Right": {}}
+    terminal_contact_times = {"Left": {}, "Right": {}}
     strike_count = 0
 
     left_leg_length = static_data['Left Leg Length'] / 1000
@@ -1271,6 +1303,27 @@ def calculate_spatiotemporal_data(frame_data, events, static_data):
             for event_time, (event_type, event_plate) in stride_events.items():
                 time_ordered_events[event_time][foot] = [event_type, stride_number]
 
+    # Add terminal foot-strike to events for each cycle.
+    full_cycle_events = copy.deepcopy(events)
+    for foot, foot_events in full_cycle_events.items():
+        for stride_number, stride_events in foot_events.items():
+            if len(stride_events) == 2 and (stride_number + 1) in foot_events:
+                event_list = list(stride_events.values())
+                next_event_time, next_event = next(iter(foot_events[stride_number + 1].items()))
+                if event_list[0][0] == "Foot Strike" and event_list[1][0] == "Foot Off":
+                    if next_event[0] == "Foot Strike":
+                        stride_events[next_event_time] = ["Terminal Foot Strike", next_event[1]]
+
+    # Extract event times.
+    for foot, foot_events in full_cycle_events.items():
+        for stride_number, stride_events in foot_events.items():
+            if len(stride_events) == 3:
+                (strike_time, strike), (off_time, off), (terminal_time, terminal) = stride_events.items()
+                if strike[0] == "Foot Strike" and off[0] == "Foot Off" and terminal[0] == "Terminal Foot Strike":
+                    initial_contact_times[foot][stride_number] = strike_time
+                    toe_off_times[foot][stride_number] = off_time
+                    terminal_contact_times[foot][stride_number] = terminal_time
+
     opposite_side = {"Left": "Right", "Right": "Left"}
     strike_position = {"Left": None, "Right": None}
     foot_events = {"Left": None, "Right": None}
@@ -1291,6 +1344,7 @@ def calculate_spatiotemporal_data(frame_data, events, static_data):
                     stride_lengths[foot][stride_number - 1] = stride_length / 1000
                     total_time = event_time - strike_times[foot]
                     gait_speeds[foot][stride_number - 1] = (stride_length / total_time) / 1000
+                    cadences[foot][stride_number - 1] = (60 / total_time) * 2
                 strike_position[foot] = heel_coordinates
                 strike_times[foot] = event_time
 
@@ -1353,7 +1407,10 @@ def calculate_spatiotemporal_data(frame_data, events, static_data):
     s_t_data["Normalised Step Length"] = normalised_step_lengths
     s_t_data["Step Width (m)"] = step_widths
 
-    # Determine phase percentages.
+    # Determine phase times and percentages.
+    stride_durations = {"Left": {}, "Right": {}}
+    stance_durations = {"Left": {}, "Right": {}}
+    swing_durations = {"Left": {}, "Right": {}}
     stance_phases = {"Left": {}, "Right": {}}
     swing_phases = {"Left": {}, "Right": {}}
     single_support_phases = {"Left": {}, "Right": {}}
@@ -1365,11 +1422,20 @@ def calculate_spatiotemporal_data(frame_data, events, static_data):
                 stance_phases[side][cycle_number] = (cycle["Stance"] / total_time) * 100
                 swing_phases[side][cycle_number] = (cycle["Swing"] / total_time) * 100
 
+                stride_durations[side][cycle_number] = total_time
+                stance_durations[side][cycle_number] = cycle["Stance"]
+                swing_durations[side][cycle_number] = cycle["Swing"]
+
                 if "Initial-DS" in cycle and "Terminal-DS" in cycle:
                     ds_time = cycle["Initial-DS"] + cycle["Terminal-DS"]
                     single_support_phases[side][cycle_number] = ((cycle["Stance"] - ds_time) / total_time) * 100
                     double_support_phases[side][cycle_number] = (ds_time / total_time) * 100
 
+    # Define time based measurements.
+    s_t_data["Stride Duration (s)"] = stride_durations
+    s_t_data["Stance Duration (s)"] = stance_durations
+    s_t_data["Swing Duration (s)"] = swing_durations
+
     # Assign phase percentages.
     s_t_data["Stance Phase %"] = stance_phases
     s_t_data["Swing Phase %"] = swing_phases
@@ -1377,6 +1443,12 @@ def calculate_spatiotemporal_data(frame_data, events, static_data):
     s_t_data["Double Support Phase %"] = double_support_phases
     s_t_data["Gait Speed (m/s)"] = gait_speeds
     s_t_data["Normalised Gait Speed"] = normalised_gait_speeds
+    s_t_data["Cadence (steps/min)"] = cadences
+
+    # Assign event times.
+    s_t_data["Initial Foot Contact (t)"] = initial_contact_times
+    s_t_data["Foot Contact (t)"] = toe_off_times
+    s_t_data["Terminal Foot Contact (t)"] = terminal_contact_times
 
     data_frame = convert_to_data_frame(s_t_data)
 

{c3d_parser-1.2.2 → c3d_parser-1.2.4}/src/c3d_parser/view/dialogs/options_dialog.py

@@ -90,6 +90,7 @@ class OptionsDialog(QDialog):
         self._ui.checkBoxCustomTaskSet.setChecked(options['use_custom_ik_task_set'])
         self._ui.lineEditIKTaskSet.setText(options['ik_task_set_path'])
         self._ui.checkBoxApproximateAnthropometrics.setChecked(options['approximate_anthropometrics'])
+        self._ui.checkBoxRunningGait.setChecked(options['running_gait'])
 
     def save(self):
         options = {
@@ -105,6 +106,7 @@ class OptionsDialog(QDialog):
             'use_custom_ik_task_set': self._ui.checkBoxCustomTaskSet.isChecked(),
             'ik_task_set_path': self._ui.lineEditIKTaskSet.text(),
             'approximate_anthropometrics': self._ui.checkBoxApproximateAnthropometrics.isChecked(),
+            'running_gait': self._ui.checkBoxRunningGait.isChecked(),
         }
 
         return options

{c3d_parser-1.2.2 → c3d_parser-1.2.4}/src/c3d_parser/view/main_window.py

@@ -77,6 +77,7 @@ class MainWindow(QMainWindow):
         self._use_custom_ik_task_set = False
         self._ik_task_set_path = ''
         self._approximate_anthropometrics = False
+        self._running_gait = False
 
         self._colour_left = '#A52A2A'
         self._colour_right = '#0F52BA'
@@ -245,6 +246,11 @@ class MainWindow(QMainWindow):
         self._spatiotemporal_tables = []
 
     def _visualise_spatiotemporal_data(self):
+
+        # Temporarily disable spatio-temporal visualisation for running gait.
+        if self._running_gait:
+            return
+
         layout = self._ui.scrollAreaSpatiotemporal.layout()
         self._clear_spatiotemporal_data()
 
@@ -597,7 +603,7 @@ class MainWindow(QMainWindow):
         self._worker = _ExecThread(parse_session, static_trial, dynamic_trials, input_directory,
                                    self._output_directory, lab, marker_diameter, static_data,
                                    left_foot_flat, right_foot_flat, optimise_knee_axis, self._filter_trc,
-                                   self._filter_grf, ik_task_set, self._progress_tracker)
+                                   self._filter_grf, ik_task_set, self._running_gait, self._progress_tracker)
         self._worker.finished.connect(self._parse_finished)
         self._worker.cancelled.connect(self._parse_cancelled)
         self._worker.failed.connect(self._parse_failed)
@@ -890,6 +896,7 @@ class MainWindow(QMainWindow):
             'use_custom_ik_task_set': self._use_custom_ik_task_set,
             'ik_task_set_path': self._ik_task_set_path,
             'approximate_anthropometrics': self._approximate_anthropometrics,
+            'running_gait': self._running_gait,
         }
 
         return options
@@ -907,6 +914,7 @@ class MainWindow(QMainWindow):
         self._use_custom_ik_task_set = options['use_custom_ik_task_set']
         self._ik_task_set_path = options['ik_task_set_path']
         self._approximate_anthropometrics = options['approximate_anthropometrics']
+        self._running_gait = options['running_gait']
 
     def _show_custom_marker_set_dialog(self):
         static_trials = []
@@ -976,6 +984,7 @@ class MainWindow(QMainWindow):
         settings.setValue('use_custom_ik_task_set', self._use_custom_ik_task_set)
         settings.setValue('ik_task_set_path', self._ik_task_set_path)
         settings.setValue('approximate_anthropometrics', self._approximate_anthropometrics)
+        settings.setValue('running_gait', self._running_gait)
         settings.endGroup()
 
     def _load_settings(self):
@@ -1026,6 +1035,8 @@ class MainWindow(QMainWindow):
             self._ik_task_set_path = settings.value('ik_task_set_path')
         if settings.contains('approximate_anthropometrics'):
             self._approximate_anthropometrics = settings.value('approximate_anthropometrics') == 'true'
+        if settings.contains('running_gait'):
+            self._running_gait = settings.value('running_gait') == 'true'
         settings.endGroup()
 
     def _quit_application(self):
@@ -1386,27 +1397,31 @@ class SpatiotemporalTableDelegate(QStyledItemDelegate):
                     painter.drawLine(right, centre_y + whisker_width, right, centre_y - whisker_width)
                     painter.drawLine(left, centre_y, right, centre_y)
 
-            # Calculate slightly-arbitrary max value for meter metrics.
-            max_value = data.iloc[:2, :].max().max() + 0.40
-            if index.row() in [5, 6, 7, 8]:
+            # Calculate slightly-arbitrary max value for meter and second metrics.
+            max_meter_value = data.iloc[:2, :].max().max() + 0.40
+            max_time_value = data.iloc[5:7, :].max().max() + 0.40
+            if index.row() in [0, 1, 2, 3, 4]:
+                max_value = max_meter_value
+            elif index.row() in [5, 6, 7]:
+                max_value = max_time_value
+            elif index.row() in [8, 9, 10, 11]:
                 max_value = 100
-            else:
-                if index.row() == 9:
-                    max_value = 3.0
-                elif index.row() == 10:
-                    max_value = 1.5
-                elif index.row() == 11:
-                    max_value = 240
+            elif index.row() == 12:
+                max_value = 3.0
+            elif index.row() == 13:
+                max_value = 1.5
+            elif index.row() == 14:
+                max_value = 240
 
             left_columns = [i for i in columns if "Left" in data.columns[i]]
             right_columns = [i for i in columns if "Right" in data.columns[i]]
             left_values = data.iloc[index.row(), left_columns]
             right_values = data.iloc[index.row(), right_columns]
 
-            if not left_values.empty:
+            if not left_values.empty and index.row() < 15:
                 l_min, l_max, l_mean = left_values.min(), left_values.max(), left_values.mean()
                 draw_box(l_min, l_max, l_mean, max_value, side='left')
-            if not right_values.empty:
+            if not right_values.empty and index.row() < 15:
                 r_min, r_max, r_mean = right_values.min(), right_values.max(), right_values.mean()
                 draw_box(r_min, r_max, r_mean, max_value, side='right')
 

{c3d_parser-1.2.2 → c3d_parser-1.2.4}/src/c3d_parser/view/ui/ui_options_dialog.py

@@ -3,7 +3,7 @@
 ################################################################################
 ## Form generated from reading UI file 'options_dialog.ui'
 ##
-## Created by: Qt User Interface Compiler version 6.10.2
+## Created by: Qt User Interface Compiler version 6.9.0
 ##
 ## WARNING! All changes made in this file will be lost when recompiling UI file!
 ################################################################################
@@ -24,7 +24,7 @@ class Ui_OptionsDialog(object):
     def setupUi(self, OptionsDialog):
         if not OptionsDialog.objectName():
             OptionsDialog.setObjectName(u"OptionsDialog")
-        OptionsDialog.resize(450, 624)
+        OptionsDialog.resize(450, 686)
         self.verticalLayout = QVBoxLayout(OptionsDialog)
         self.verticalLayout.setObjectName(u"verticalLayout")
         self.groupBox_3 = QGroupBox(OptionsDialog)
@@ -259,6 +259,18 @@ class Ui_OptionsDialog(object):
 
         self.verticalLayout.addWidget(self.groupBox_6)
 
+        self.groupBox_7 = QGroupBox(OptionsDialog)
+        self.groupBox_7.setObjectName(u"groupBox_7")
+        self.verticalLayout_4 = QVBoxLayout(self.groupBox_7)
+        self.verticalLayout_4.setObjectName(u"verticalLayout_4")
+        self.checkBoxRunningGait = QCheckBox(self.groupBox_7)
+        self.checkBoxRunningGait.setObjectName(u"checkBoxRunningGait")
+
+        self.verticalLayout_4.addWidget(self.checkBoxRunningGait)
+
+
+        self.verticalLayout.addWidget(self.groupBox_7)
+
         self.horizontalLayout_3 = QHBoxLayout()
         self.horizontalLayout_3.setObjectName(u"horizontalLayout_3")
         self.horizontalSpacer = QSpacerItem(40, 20, QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum)
@@ -315,6 +327,8 @@ class Ui_OptionsDialog(object):
         self.pushButtonIKTaskSetChooser.setText(QCoreApplication.translate("OptionsDialog", u"...", None))
         self.groupBox_6.setTitle(QCoreApplication.translate("OptionsDialog", u"Anthropometrics", None))
         self.checkBoxApproximateAnthropometrics.setText(QCoreApplication.translate("OptionsDialog", u"Approximate missing anthropometrics", None))
+        self.groupBox_7.setTitle(QCoreApplication.translate("OptionsDialog", u"Experimental", None))
+        self.checkBoxRunningGait.setText(QCoreApplication.translate("OptionsDialog", u"Running gait", None))
         self.pushButtonOK.setText(QCoreApplication.translate("OptionsDialog", u"OK", None))
         self.pushButtonCancel.setText(QCoreApplication.translate("OptionsDialog", u"Cancel", None))
     # retranslateUi

{c3d_parser-1.2.2 → c3d_parser-1.2.4/src/c3d_parser.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: c3d-parser
-Version: 1.2.2
+Version: 1.2.4
 Summary: C3D parser for gait data harmonisation.
 Author-email: Timothy Salemink <tim.nicolas@outlook.com>, Sally Jack <sallyjaack@gmail.com>
 License-Expression: Apache-2.0
@@ -12,7 +12,7 @@ Requires-Dist: numpy==1.26.4
 Requires-Dist: pandas
 Requires-Dist: c3d==0.5.2
 Requires-Dist: trc-data-reader>=0.4.1
-Requires-Dist: opensim-model-creator==0.7.1
+Requires-Dist: opensim-model-creator==0.7.2
 Requires-Dist: PySide6
 Requires-Dist: matplotlib
 Requires-Dist: mplcursors

{c3d_parser-1.2.2 → c3d_parser-1.2.4}/src/c3d_parser.egg-info/requires.txt

@@ -3,7 +3,7 @@ numpy==1.26.4
 pandas
 c3d==0.5.2
 trc-data-reader>=0.4.1
-opensim-model-creator==0.7.1
+opensim-model-creator==0.7.2
 PySide6
 matplotlib
 mplcursors

c3d_parser-1.2.2/src/c3d_parser/__init__.py

@@ -1,2 +0,0 @@
-
-__version__ = "1.2.2"