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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: c3d-parser
-Version: 1.2.4
+Version: 1.4.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.4.0/src/c3d_parser/__init__.py

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

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

@@ -16,6 +16,7 @@ from decimal import Decimal, ROUND_CEILING, ROUND_FLOOR
 
 from trc import TRCData
 from opensim_model_creator.Create_Model import create_model
+from ll_visualiser.utils import get_fit_metrics, load_landmarks, define_measurements
 
 from c3d_parser.core.c3d_patch import c3d
 from c3d_parser.core.utils import clear_directory
@@ -82,13 +83,13 @@ def parse_session(static_trial, dynamic_trials, input_directory, output_director
         grf_file_paths[trial] = grf_file_path
         deidentified_file_names[trial] = os.path.basename(trc_file_path).rsplit(".", 1)[0]
 
-    write_c3d_parser_history(input_directory, static_trial, deidentified_file_names)
-
     logger.info("Fitting shape model.")
     dynamic_trc_path = list(trc_file_paths.values())[0] if trc_file_paths else ""
     osim_model = create_osim_model(static_trc_path, dynamic_trc_path, frame, marker_diameter, static_data,
                                    output_directory, left_foot_flat, right_foot_flat, optimise_knee_axis, progress_tracker)
 
+    write_c3d_parser_history(input_directory, output_directory, static_trial, deidentified_file_names, static_data)
+
     if not trc_file_paths:
         raise CancelException("No dynamic trials found.")
 
@@ -236,7 +237,7 @@ def parse_dynamic_trial(c3d_file, lab, output_directory, trial_index, marker_dat
     return analog_data, events, s_t_data, trc_file_path, grf_file_path
 
 
-def write_c3d_parser_history(input_directory, static_trial, deidentified_file_names):
+def write_c3d_parser_history(input_directory, output_directory, static_trial, deidentified_file_names, static_data):
     log_path = os.path.join(input_directory, "c3d_parser_history.log")
     timestamp = datetime.now().strftime("%Y-%m-%d %H:%M")
 
@@ -251,11 +252,56 @@ def write_c3d_parser_history(input_directory, static_trial, deidentified_file_na
                 f.write("Deidentified file names:\n")
                 for original_name, updated_name in deidentified_file_names.items():
                     f.write(f"{original_name}: {updated_name}\n")
+                f.write("\n")
+
+            if static_data:
+                units = {
+                    "Height": "mm",
+                    "Weight": "kg",
+                    "ASIS Width": "mm",
+                    "Left Knee Width": "mm",
+                    "Right Knee Width": "mm",
+                    "Left Ankle Width": "mm",
+                    "Right Ankle Width": "mm",
+                    "Left Leg Length": "mm",
+                    "Right Leg Length": "mm",
+                }
+                f.write("Subject Information:\n")
+                for key, value in static_data.items():
+                    label = "Body Mass" if key == "Weight" else key
+                    unit = f" {units[key]}" if key in units else ""
+                    f.write(f"{label}: {value}{unit}\n")
+
+            metrics, measurements = define_metrics_and_measurements(output_directory)
+            if metrics:
+                f.write("\n")
+                f.write("ASM Fit Metrics:\n")
+                for key, value in metrics.items():
+                    f.write(f"{key}: {value} mm\n")
+            if measurements:
+                f.write("\n")
+                f.write("Bone Surface Measurements:\n")
+                for key, value in measurements.items():
+                    f.write(f"{key}: {value} mm\n")
 
     except (OSError, IOError):
         raise ParserError("Could not write c3d_parser_history.log")
 
 
+def define_metrics_and_measurements(output_directory):
+    model_directory = os.path.join(output_directory, "Models", "Meshes")
+    left_predicted_landmark_file = os.path.join(model_directory, 'predicted_lms_left.txt')
+    right_predicted_landmark_file = os.path.join(model_directory, 'predicted_lms_right.txt')
+
+    left_predicted_landmarks = load_landmarks(left_predicted_landmark_file)
+    right_predicted_landmarks = load_landmarks(right_predicted_landmark_file)
+
+    metrics = get_fit_metrics(model_directory)
+    measurements = define_measurements(left_predicted_landmarks, right_predicted_landmarks)
+
+    return metrics, measurements
+
+
 def write_event_data(events, file_name, output_directory):
     event_directory = os.path.join(output_directory, "events")
     if not os.path.exists(event_directory):
@@ -739,38 +785,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):
@@ -1046,6 +1095,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:
@@ -1227,6 +1285,15 @@ def normalise_kinetics(kinetic_data, events):
     return normalised_data
 
 
+def write_normalised_grfs(grf_data, selected_trials, excluded_cycles, 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']
+    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):

{c3d_parser-1.2.4 → c3d_parser-1.4.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.4.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
@@ -71,13 +71,14 @@ class MainWindow(QMainWindow):
         self._line_width = 1.0
         self._input_data_directory = ''
         self._output_data_directory = ''
-        self._optimise_knee_axis = True
+        self._optimise_knee_axis = False
         self._filter_trc = True
         self._filter_grf = True
         self._use_custom_ik_task_set = False
         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 +87,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 = {}
@@ -109,6 +111,13 @@ class MainWindow(QMainWindow):
         self._kinetic_curves = GaitCurves(self._kinetic_canvas, colours)
         self._boxes = None
 
+        self._kinematic_curves.signals.cycles_excluded.connect(self._kinetic_curves.exclude_cycles)
+        self._kinematic_curves.signals.cycles_excluded.connect(self._grf_curves.exclude_cycles)
+        self._kinematic_curves.signals.cycles_included.connect(self._kinetic_curves.include_cycles)
+        self._kinematic_curves.signals.cycles_included.connect(self._grf_curves.include_cycles)
+        self._kinetic_curves.signals.cycles_excluded.connect(self._grf_curves.exclude_cycles)
+        self._kinetic_curves.signals.cycles_included.connect(self._grf_curves.include_cycles)
+
     def _setup_progress_bar(self):
         self._progress_text = ""
         self._progress_value = 0
@@ -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()
@@ -673,7 +684,9 @@ class MainWindow(QMainWindow):
         selected_trials = {key: value for key, value in self._deidentified_file_names.items() if key in selected}
         kinematic_exclusions = self._kinematic_curves.get_excluded_cycles()
         kinetic_exclusions = self._kinetic_curves.get_excluded_cycles()
+        grf_exclusions = self._grf_curves.get_excluded_cycles()
         self._update_s_t_data_from_tables()
+        write_normalised_grfs(self._grf_data, selected_trials, grf_exclusions, 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)
@@ -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 = []
@@ -985,6 +1000,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 +1053,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):
@@ -1078,6 +1096,11 @@ class MainWindow(QMainWindow):
             curves.exclude_side(file_name, "Right")
 
 
+class CurveSignals(QObject):
+    cycles_included = Signal(list)
+    cycles_excluded = Signal(list)
+
+
 class GaitCurves(defaultdict):
 
     def __init__(self, canvas, colours):
@@ -1087,6 +1110,8 @@ class GaitCurves(defaultdict):
         self._canvas.mpl_connect('pick_event', lambda event: self.toggle_cycle(event))
         self._canvas.mpl_connect('button_press_event', lambda event: self.show_curve_menu(event))
 
+        self.signals = CurveSignals()
+
         self._selected_curves = []
         self._excluded_cycles = set()
 
@@ -1178,15 +1203,16 @@ class GaitCurves(defaultdict):
             context_menu.exec_(self._canvas.mapToGlobal(point))
 
     def include_curves(self):
-        self._excluded_cycles.difference_update(self._selected_curves)
-        for file_name, cycle in self._selected_curves:
-            colour = self._colour_left if "Left" in cycle else self._colour_right
-            for line in self[file_name][cycle]:
-                line.set_linestyle('solid')
-                line.set_color(colour)
-                line.set_zorder(2)
+        identifiers = list(self._selected_curves)
+        self.include_cycles(identifiers)
         self._selected_curves = []
 
+        self.signals.cycles_included.emit(identifiers)
+
+    def include_cycles(self, identifiers):
+        for file_name, cycle in identifiers:
+            colour = self._colour_left if "Left" in cycle else self._colour_right
+            self._include_cycle(file_name, cycle, colour)
         self._canvas.draw()
 
     def include_all(self):
@@ -1238,15 +1264,16 @@ class GaitCurves(defaultdict):
         self._canvas.draw_idle()
 
     def exclude_curves(self):
-        self._excluded_cycles.update(self._selected_curves)
-        for file_name, cycle in self._selected_curves:
-            colour = self._colour_left if "Left" in cycle else self._colour_right
-            for line in self[file_name][cycle]:
-                line.set_linestyle('dotted')
-                line.set_color(colour)
-                line.set_zorder(1)
+        identifiers = list(self._selected_curves)
+        self.exclude_cycles(identifiers)
         self._selected_curves = []
 
+        self.signals.cycles_excluded.emit(identifiers)
+
+    def exclude_cycles(self, identifiers):
+        for file_name, cycle in identifiers:
+            colour = self._colour_left if "Left" in cycle else self._colour_right
+            self._exclude_cycle(file_name, cycle, colour)
         self._canvas.draw()
 
     def exclude_all(self):

{c3d_parser-1.2.4 → c3d_parser-1.4.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.4.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.4.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"