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

{c3d_parser-1.3.0/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.3.0
+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.3.0 → 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):
@@ -421,8 +467,6 @@ 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:
@@ -478,10 +522,8 @@ 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
@@ -1045,8 +1087,6 @@ 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:
@@ -1222,11 +1262,6 @@ 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"]
@@ -1250,13 +1285,12 @@ def normalise_kinetics(kinetic_data, events):
     return normalised_data
 
 
-def write_normalised_grfs(grf_data, selected_trials, output_directory):
+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']
-    excluded_cycles = set()
     write_normalised_data(grf_data, columns, selected_trials, excluded_cycles, output_file)
 
 
@@ -1314,9 +1348,6 @@ 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": {}}
@@ -1339,8 +1370,6 @@ 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.3.0 → c3d_parser-1.4.0}/src/c3d_parser/view/main_window.py

@@ -57,7 +57,6 @@ class ProgressTracker(QObject):
     progress = Signal(str, str)
 
 
-# TODO: CGM2 event detector on GitHub...?
 class MainWindow(QMainWindow):
 
     def __init__(self):
@@ -72,7 +71,7 @@ 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
@@ -112,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
@@ -248,12 +254,6 @@ 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.
@@ -684,8 +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, self._output_directory)
+        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)
@@ -887,7 +888,6 @@ 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():
@@ -979,8 +979,6 @@ 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())
@@ -1098,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):
@@ -1107,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()
 
@@ -1173,9 +1178,6 @@ 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):
@@ -1201,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):
@@ -1261,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.3.0 → 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.3.0
+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.3.0/src/c3d_parser/__init__.py

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