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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: c3d-parser
-Version: 1.2.4
+Version: 1.3.0
 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

c3d_parser-1.3.0/src/c3d_parser/__init__.py

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

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

@@ -421,6 +421,8 @@ def harmonise_markers(frame_data, lab, required_markers):
     if None in frame_data.columns:
         frame_data.drop(columns=frame_data.columns[frame_data.columns.isna()], inplace=True)
 
+    # TODO: This error window does not indicate which trial has the issue.
+    #   Update this.
     # Ensure required markers are present.
     available = set(frame_data.columns)
     for item in required_markers:
@@ -476,8 +478,10 @@ def trim_frames(frame_data):
     if not drop_frames.empty:
         frame_data.drop(drop_frames, inplace=True)
 
+    # TODO: If we convert this to a dictionary we can keep the markers that are missing and check if they are required.
     remaining_frames = [frame for frame in incomplete_frames.keys() if trim_start <= frame <= trim_end]
     if remaining_frames:
+        # TODO: We should raise a ParserError (skip this trial) if the missing markers are required...?
         logger.warn(f"Frames {remaining_frames} are incomplete.")
 
     return trim_start, trim_end
@@ -739,38 +743,41 @@ def extract_static_data(file_path):
     with open(file_path, 'rb') as handle:
         reader = c3d.Reader(handle)
 
+        static_data = {}
         if 'PROCESSING' not in reader:
             logger.warn("No processing section found in static trial.")
-            return None, None, None, None, None, None, None, None, None
-
+            return static_data
         processing_group = reader.get('PROCESSING')
-        height = mass = asis_width = left_knee_width = right_knee_width = None
-        left_ankle_width = right_ankle_width = left_leg_length = right_leg_length = None
+
+        if 'SUBJECT_INFO' in reader:
+            subject_info = reader.get('SUBJECT_INFO')
+            if 'SEX' in subject_info:
+                static_data['sex'] = subject_info.get('SEX').string_value.title()
+            if 'AGE' in subject_info:
+                static_data['age'] = int(subject_info.get('AGE').float_value)
 
         if 'HEIGHT' in processing_group:
-            height = reader.get('PROCESSING:Height').float_value
+            static_data['height'] = reader.get('PROCESSING:Height').float_value
         if 'BODYMASS' in processing_group:
-            mass = reader.get('PROCESSING:Bodymass').float_value
+            static_data['mass'] = reader.get('PROCESSING:Bodymass').float_value
+            if static_data['mass'] > 200:
+                static_data['mass'] = static_data['mass'] / 9.81
         if 'INTERASISDISTANCE' in processing_group:
-            asis_width = reader.get('PROCESSING:InterAsisDistance').float_value
+            static_data['asis_width'] = reader.get('PROCESSING:InterAsisDistance').float_value
         if 'LKNEEWIDTH' in processing_group:
-            left_knee_width = reader.get('PROCESSING:LKneeWidth').float_value
+            static_data['left_knee_width'] = reader.get('PROCESSING:LKneeWidth').float_value
         if 'RKNEEWIDTH' in processing_group:
-            right_knee_width = reader.get('PROCESSING:RKneeWidth').float_value
+            static_data['right_knee_width'] = reader.get('PROCESSING:RKneeWidth').float_value
         if 'LANKLEWIDTH' in processing_group:
-            left_ankle_width = reader.get('PROCESSING:LAnkleWidth').float_value
+            static_data['left_ankle_width'] = reader.get('PROCESSING:LAnkleWidth').float_value
         if 'RANKLEWIDTH' in processing_group:
-            right_ankle_width = reader.get('PROCESSING:RAnkleWidth').float_value
+            static_data['right_ankle_width'] = reader.get('PROCESSING:RAnkleWidth').float_value
         if 'LLEGLENGTH' in processing_group:
-            left_leg_length = reader.get('PROCESSING:LLegLength').float_value
+            static_data['left_leg_length'] = reader.get('PROCESSING:LLegLength').float_value
         if 'RLEGLENGTH' in processing_group:
-            right_leg_length = reader.get('PROCESSING:RLegLength').float_value
-
-        if mass and mass > 200:
-            mass = mass / 9.81
+            static_data['right_leg_length'] = reader.get('PROCESSING:RLegLength').float_value
 
-    return (height, mass, asis_width, left_knee_width, right_knee_width,
-            left_ankle_width, right_ankle_width, left_leg_length, right_leg_length)
+    return static_data
 
 
 def read_grf(file_path):
@@ -1038,6 +1045,8 @@ def scale_grf_data(analog_data):
     analog_data[columns] = analog_data[columns] / 1000
 
 
+# TODO: This incorrectly classifies Adelaide's static trials as dynamic.
+#   Use `calculate_distance_covered`...?
 def is_dynamic(file_path):
     with open(file_path, 'rb') as handle:
         try:
@@ -1046,6 +1055,15 @@ def is_dynamic(file_path):
         finally:
             logging.disable(logging.NOTSET)
 
+        if 'PROCESSING' in reader:
+            processing_group = reader.get('PROCESSING')
+            if 'MEASUREMENT TYPE' in processing_group:
+                measurement_type = reader.get('PROCESSING:Measurement type').string_value.strip().capitalize()
+                if measurement_type == 'Dynamic':
+                    return True
+                elif measurement_type == 'Static':
+                    return False
+
         if reader.analog_used > 0 and reader.frame_count > 100:
             return True
         else:
@@ -1204,6 +1222,11 @@ def normalise_kinetics(kinetic_data, events):
                         normalised_data[foot][file_name] = {}
                     data_segment = data.iloc[start:frame, 1:]
 
+                    # TODO: If the model +tve and -tve are wrong, then we can't just flip these.
+                    #   Because the non-GRF parts of the moments would also be flipped.
+                    #   Just visually check the results against some clinical kinetics.
+                    #   ...
+                    #   Looks pretty good so far.
                     # Perform sign transformations.
                     data_segment[f"hip_flexion_{side}_moment"] = -data_segment[f"hip_flexion_{side}_moment"]
                     data_segment[f"hip_adduction_{side}_moment"] = -data_segment[f"hip_adduction_{side}_moment"]
@@ -1227,6 +1250,16 @@ def normalise_kinetics(kinetic_data, events):
     return normalised_data
 
 
+def write_normalised_grfs(grf_data, selected_trials, output_directory):
+    normalised_directory = os.path.join(output_directory, 'normalised')
+    if not os.path.exists(normalised_directory):
+        os.makedirs(normalised_directory)
+    output_file = os.path.join(normalised_directory, f"combined_grf.csv")
+    columns = ['anterior_posterior', 'medial_lateral', 'vertical']
+    excluded_cycles = set()
+    write_normalised_data(grf_data, columns, selected_trials, excluded_cycles, output_file)
+
+
 def write_normalised_kinematics(kinematic_data, selected_trials, excluded_cycles, output_directory):
     normalised_directory = os.path.join(output_directory, 'normalised')
     if not os.path.exists(normalised_directory):
@@ -1281,6 +1314,9 @@ def write_normalised_data(data, column_names, selected_trials, excluded_cycles,
                     file.write('\n')
 
 
+# TODO: Rework this function to be less sequential.
+#   It should be able to calculate metrics for walking and running gait.
+#   Put this at the start of the sequential bit.
 def calculate_spatiotemporal_data(frame_data, events, static_data):
     stride_lengths = {"Left": {}, "Right": {}}
     step_lengths = {"Left": {}, "Right": {}}
@@ -1303,6 +1339,8 @@ 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]
 
+    # TODO: We should be able to use this to calculate ALL measurements non-sequentially.
+    # TODO: Double check that we don't have situations where the events are not ordered in increasing 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():

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

@@ -91,6 +91,7 @@ class OptionsDialog(QDialog):
         self._ui.lineEditIKTaskSet.setText(options['ik_task_set_path'])
         self._ui.checkBoxApproximateAnthropometrics.setChecked(options['approximate_anthropometrics'])
         self._ui.checkBoxRunningGait.setChecked(options['running_gait'])
+        self._ui.checkBoxOutputGRFs.setChecked(options['output_grf'])
 
     def save(self):
         options = {
@@ -107,6 +108,7 @@ class OptionsDialog(QDialog):
             'ik_task_set_path': self._ui.lineEditIKTaskSet.text(),
             'approximate_anthropometrics': self._ui.checkBoxApproximateAnthropometrics.isChecked(),
             'running_gait': self._ui.checkBoxRunningGait.isChecked(),
+            'output_grf': self._ui.checkBoxOutputGRFs.isChecked(),
         }
 
         return options

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

@@ -6,18 +6,18 @@ import pandas as pd
 from collections import defaultdict
 
 from PySide6.QtGui import QPen, QColor, QFontMetrics
-from PySide6.QtCore import Qt, QSettings, QPoint, QThread, Signal, QObject, QTimer, QAbstractTableModel, QRect
+from PySide6.QtCore import Qt, QSettings, QPoint, QThread, Signal, QObject, QAbstractTableModel, QRect
 from PySide6.QtWidgets import (QApplication, QMainWindow, QMenu, QFileDialog, QListWidgetItem, QInputDialog,
                                QMessageBox, QTableView, QLabel, QAbstractButton, QHeaderView, QStyledItemDelegate,
-                               QWidget, QVBoxLayout, QHBoxLayout, QTableWidgetItem)
+                               QWidget, QVBoxLayout, QHBoxLayout, QTableWidgetItem, QComboBox, QSpinBox)
 from matplotlib.backends.backend_qtagg import FigureCanvasQTAgg
 from matplotlib.figure import Figure
 from pyvistaqt import QtInteractor
 from ll_visualiser.visualiser import visualise_model
 
 from c3d_parser.core.c3d_parser import (parse_session, extract_static_data, extract_marker_names, is_dynamic,
-    CancelException, write_normalised_kinematics, write_normalised_kinetics, write_spatiotemporal_data,
-    approximate_anthropometrics)
+    CancelException, write_normalised_grfs, write_normalised_kinematics, write_normalised_kinetics,
+    write_spatiotemporal_data, approximate_anthropometrics)
 from c3d_parser.settings.general import (APPLICATION_NAME, VERSION, DEFAULT_STYLE_SHEET, INVALID_STYLE_SHEET,
                                          get_marker_maps_dir)
 from c3d_parser.view.ui.ui_main_window import Ui_MainWindow
@@ -57,6 +57,7 @@ class ProgressTracker(QObject):
     progress = Signal(str, str)
 
 
+# TODO: CGM2 event detector on GitHub...?
 class MainWindow(QMainWindow):
 
     def __init__(self):
@@ -78,6 +79,7 @@ class MainWindow(QMainWindow):
         self._ik_task_set_path = ''
         self._approximate_anthropometrics = False
         self._running_gait = False
+        self._output_grf = False
 
         self._colour_left = '#A52A2A'
         self._colour_right = '#0F52BA'
@@ -86,6 +88,7 @@ class MainWindow(QMainWindow):
         self._static_trial = None
         self._analog_data = None
         self._subject_weight = None
+        self._grf_data = {}
         self._kinematic_data = {}
         self._kinetic_data = {}
         self._s_t_data = {}
@@ -245,6 +248,12 @@ class MainWindow(QMainWindow):
             table.deleteLater()
         self._spatiotemporal_tables = []
 
+    # TODO: The legend is not correctly displayed if the ST tab is open while processing...
+    #   Repositioning and updating the legend do nothing.
+
+    # TODO: The border is still having issues.
+    #   Seems to be related to the area being scrollable.
+    #   Only happens on some PCs/monitors...
     def _visualise_spatiotemporal_data(self):
 
         # Temporarily disable spatio-temporal visualisation for running gait.
@@ -478,28 +487,30 @@ class MainWindow(QMainWindow):
         self._ui.doubleSpinBoxRightLegLength.setValue(0)
 
     def _set_subject_info(self, static_trial):
+        field_map = {
+            'sex': self._ui.comboBoxSex,
+            'age': self._ui.spinBoxAge,
+            'height': self._ui.doubleSpinBoxHeight,
+            'mass': self._ui.doubleSpinBoxBodyMass,
+            'asis_width': self._ui.doubleSpinBoxASISWidth,
+            'left_knee_width': self._ui.doubleSpinBoxLeftKneeWidth,
+            'right_knee_width': self._ui.doubleSpinBoxRightKneeWidth,
+            'left_ankle_width': self._ui.doubleSpinBoxLeftAnkleWidth,
+            'right_ankle_width': self._ui.doubleSpinBoxRightAnkleWidth,
+            'left_leg_length': self._ui.doubleSpinBoxLeftLegLength,
+            'right_leg_length': self._ui.doubleSpinBoxRightLegLength,
+        }
+
         input_directory = self._ui.lineEditInputDirectory.text()
         c3d_file = os.path.join(input_directory, static_trial)
-        static_data = list(extract_static_data(c3d_file))
-
-        if static_data[0] is not None:
-            self._ui.doubleSpinBoxHeight.setValue(static_data[0])
-        if static_data[1] is not None:
-            self._ui.doubleSpinBoxBodyMass.setValue(static_data[1])
-        if static_data[2] is not None:
-            self._ui.doubleSpinBoxASISWidth.setValue(static_data[2])
-        if static_data[3] is not None:
-            self._ui.doubleSpinBoxLeftKneeWidth.setValue(static_data[3])
-        if static_data[4] is not None:
-            self._ui.doubleSpinBoxRightKneeWidth.setValue(static_data[4])
-        if static_data[5] is not None:
-            self._ui.doubleSpinBoxLeftAnkleWidth.setValue(static_data[5])
-        if static_data[6] is not None:
-            self._ui.doubleSpinBoxRightAnkleWidth.setValue(static_data[6])
-        if static_data[7] is not None:
-            self._ui.doubleSpinBoxLeftLegLength.setValue(static_data[7])
-        if static_data[8] is not None:
-            self._ui.doubleSpinBoxRightLegLength.setValue(static_data[8])
+        static_data = extract_static_data(c3d_file)
+        for key, widget in field_map.items():
+            value = static_data.get(key)
+            if value is not None:
+                if isinstance(widget, QComboBox):
+                    widget.setCurrentText(value)
+                else:
+                    widget.setValue(value)
 
     @handle_runtime_error
     def _parse_c3d_data(self):
@@ -611,9 +622,9 @@ class MainWindow(QMainWindow):
 
     @handle_runtime_error
     def _parse_finished(self, result):
-        grf_data, self._kinematic_data, self._kinetic_data, self._s_t_data, self._deidentified_file_names = result
+        self._grf_data, self._kinematic_data, self._kinetic_data, self._s_t_data, self._deidentified_file_names = result
 
-        self._visualise_grf_data(grf_data)
+        self._visualise_grf_data(self._grf_data)
         self._visualise_kinematic_data(self._kinematic_data)
         self._visualise_kinetic_data(self._kinetic_data)
         self._visualise_spatiotemporal_data()
@@ -674,6 +685,7 @@ class MainWindow(QMainWindow):
         kinematic_exclusions = self._kinematic_curves.get_excluded_cycles()
         kinetic_exclusions = self._kinetic_curves.get_excluded_cycles()
         self._update_s_t_data_from_tables()
+        write_normalised_grfs(self._grf_data, selected_trials, self._output_directory)
         write_normalised_kinematics(self._kinematic_data, selected_trials, kinematic_exclusions, self._output_directory)
         write_normalised_kinetics(self._kinetic_data, selected_trials, kinetic_exclusions, self._output_directory)
         write_spatiotemporal_data(self._s_t_data, selected_trials, self._output_directory)
@@ -875,6 +887,7 @@ class MainWindow(QMainWindow):
             self._update_s_t_colours()
             self._update_legend()
 
+    # TODO: For some reason the legend doesn't get created at all if we are visualising the ST tab while processing...
     def _update_legend(self):
         if self._boxes:
             for side, boxes in self._boxes.items():
@@ -897,6 +910,7 @@ class MainWindow(QMainWindow):
             'ik_task_set_path': self._ik_task_set_path,
             'approximate_anthropometrics': self._approximate_anthropometrics,
             'running_gait': self._running_gait,
+            'output_grf': self._output_grf,
         }
 
         return options
@@ -915,6 +929,7 @@ class MainWindow(QMainWindow):
         self._ik_task_set_path = options['ik_task_set_path']
         self._approximate_anthropometrics = options['approximate_anthropometrics']
         self._running_gait = options['running_gait']
+        self._output_grf = options['output_grf']
 
     def _show_custom_marker_set_dialog(self):
         static_trials = []
@@ -964,6 +979,8 @@ class MainWindow(QMainWindow):
         settings.beginGroup('MainWindow')
         settings.setValue('size', self.size())
         settings.setValue('pos', self.pos())
+        # TODO: The taskbar icon fails if the application opens in full-screen...
+        #   DON'T open in full screen...?
         settings.setValue('is_maximized', self.isMaximized())
         settings.setValue('lab', self._ui.comboBoxLab.currentText())
         settings.setValue('marker_diameter', self._ui.doubleSpinBoxMarkerDiameter.value())
@@ -985,6 +1002,7 @@ class MainWindow(QMainWindow):
         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.setValue('output_grf', self._output_grf)
         settings.endGroup()
 
     def _load_settings(self):
@@ -1037,6 +1055,8 @@ class MainWindow(QMainWindow):
             self._approximate_anthropometrics = settings.value('approximate_anthropometrics') == 'true'
         if settings.contains('running_gait'):
             self._running_gait = settings.value('running_gait') == 'true'
+        if settings.contains('output_grf'):
+            self._output_grf = settings.value('output_grf') == 'true'
         settings.endGroup()
 
     def _quit_application(self):
@@ -1153,6 +1173,9 @@ class GaitCurves(defaultdict):
                         line.set_color(colour)
                         line.set_zorder(z_order)
 
+        # TODO: Replace all these with `draw_idle`?
+        #   Just the ones that handle many curves...?
+        #   Probably all...?
         self._canvas.draw()
 
     def show_curve_menu(self, event):

{c3d_parser-1.2.4 → c3d_parser-1.3.0}/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.9.0
+## Created by: Qt User Interface Compiler version 6.10.2
 ##
 ## WARNING! All changes made in this file will be lost when recompiling UI file!
 ################################################################################
@@ -268,6 +268,11 @@ class Ui_OptionsDialog(object):
 
         self.verticalLayout_4.addWidget(self.checkBoxRunningGait)
 
+        self.checkBoxOutputGRFs = QCheckBox(self.groupBox_7)
+        self.checkBoxOutputGRFs.setObjectName(u"checkBoxOutputGRFs")
+
+        self.verticalLayout_4.addWidget(self.checkBoxOutputGRFs)
+
 
         self.verticalLayout.addWidget(self.groupBox_7)
 
@@ -329,6 +334,7 @@ class Ui_OptionsDialog(object):
         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.checkBoxOutputGRFs.setText(QCoreApplication.translate("OptionsDialog", u"Output GRF data to CSV", None))
         self.pushButtonOK.setText(QCoreApplication.translate("OptionsDialog", u"OK", None))
         self.pushButtonCancel.setText(QCoreApplication.translate("OptionsDialog", u"Cancel", None))
     # retranslateUi

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: c3d-parser
-Version: 1.2.4
+Version: 1.3.0
 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

c3d_parser-1.2.4/src/c3d_parser/__init__.py

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