c3d-parser 0.3.4__tar.gz → 0.5.0__tar.gz

{c3d_parser-0.3.4/src/c3d_parser.egg-info → c3d_parser-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: c3d-parser
-Version: 0.3.4
+Version: 0.5.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
@@ -12,10 +12,12 @@ Requires-Dist: numpy==1.26.4
 Requires-Dist: pandas
 Requires-Dist: c3d==0.5.2
 Requires-Dist: trc-data-reader
-Requires-Dist: opensim-model-creator>=0.1.19
+Requires-Dist: opensim-model-creator>=0.3.0
 Requires-Dist: PySide6
 Requires-Dist: matplotlib
 Requires-Dist: mplcursors
+Requires-Dist: pyvistaqt
+Requires-Dist: ll-visualiser>=0.3.0
 Dynamic: license-file
 
 # C3D-parser

{c3d_parser-0.3.4 → c3d_parser-0.5.0}/requirements.txt

@@ -3,7 +3,9 @@ numpy==1.26.4
 pandas
 c3d==0.5.2
 trc-data-reader
-opensim-model-creator>=0.1.19
+opensim-model-creator>=0.3.0
 PySide6
 matplotlib
 mplcursors
+pyvistaqt
+ll-visualiser>=0.3.0

c3d_parser-0.5.0/src/c3d_parser/__init__.py

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

{c3d_parser-0.3.4 → c3d_parser-0.5.0}/src/c3d_parser/core/c3d_parser.py

@@ -7,6 +7,7 @@ import logging
 import numpy as np
 import pandas as pd
 
+from datetime import datetime
 from collections import defaultdict
 from scipy import signal, interpolate
 from scipy.spatial.transform import Rotation
@@ -30,6 +31,7 @@ class CancelException(Exception):
     pass
 
 
+torso_markers = ["C7", "T2", "T10", "MAN"]
 required_markers = [{"LASI", "RASI"}, {"LKNE", "RKNE"}, {"LANK", "RANK"}, {"LMED", "RMED"}, {"LHEE", "RHEE"},
                     ({"LPSI", "RPSI"}, {"SACR"}), ({"LKNEM", "RKNEM"}, {"LKAX", "RKAX"})]
 
@@ -76,6 +78,8 @@ 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)
+
     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, optimise_knee_axis, progress_tracker)
@@ -85,7 +89,7 @@ def parse_session(static_trial, dynamic_trials, input_directory, output_director
 
     progress_tracker.progress.emit("Running IK and ID", "black")
 
-    for trial in dynamic_trials:
+    for trial in trc_file_paths.keys():
         ik_data, ik_output = run_ik(osim_model, trc_file_paths[trial], output_directory, marker_data_rate)
         ik_data = pd.concat([ik_data, foot_progression_data[trial]], axis=1)
         id_data = run_id(osim_model, ik_data, ik_output, grf_file_paths[trial], output_directory, marker_data_rate, event_data[trial], weight)
@@ -157,10 +161,12 @@ def parse_dynamic_trial(c3d_file, lab, output_directory, trial_index, marker_dat
     analog_data = concatenate_grf_data(analog_data, events, mean_centre)
     scale_grf_data(analog_data)
 
-    # Rotate trials for +X walking direction.
+    # Rotate trials for +X walking direction and +Y vertical.
     rotation_matrix = get_global_rotation(frame_data)
     rotate_trc_data(frame_data, rotation_matrix)
     rotate_grf_data(analog_data, rotation_matrix)
+    rotate_trc_y_vertical(frame_data)
+    rotate_grf_y_vertical(analog_data)
 
     # Write GRF data.
     grf_directory = os.path.join(output_directory, 'grf')
@@ -182,6 +188,26 @@ def parse_dynamic_trial(c3d_file, lab, output_directory, trial_index, marker_dat
     return analog_data, events, foot_progression, s_t_data, trc_file_path, grf_file_path
 
 
+def write_c3d_parser_history(input_directory, static_trial, deidentified_file_names):
+    log_path = os.path.join(input_directory, "c3d_parser_history.log")
+    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M")
+
+    try:
+        with open(log_path, "w", encoding="utf-8") as f:
+            f.write("C3D-Parser History\n")
+            f.write(f"Last Run: {timestamp}\n\n")
+
+            f.write(f"Static trial: {static_trial}\n\n")
+
+            if deidentified_file_names:
+                f.write("Deidentified file names:\n")
+                for original_name, updated_name in deidentified_file_names.items():
+                    f.write(f"{original_name}: {updated_name}\n")
+
+    except (OSError, IOError):
+        raise ParserError("Could not write c3d_parser_history.log")
+
+
 def run_ik(osim_model, trc_file_path, output_directory, marker_data_rate):
     # Perform inverse kinematics.
     file_name = os.path.splitext(os.path.basename(trc_file_path))[0]
@@ -276,6 +302,8 @@ def set_marker_data(trc_data, frame_data, rate=100):
     trc_data['DataRate'] = rate
     trc_data['CameraRate'] = rate
     trc_data['NumFrames'] = frame_data.shape[0]
+    trc_data['OrigDataStartFrame'] = trc_data['Frame#'][0]
+    trc_data['OrigNumFrames'] = frame_data.shape[0]
 
 
 def write_trc_data(trc_data, file_name, output_directory):
@@ -329,6 +357,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:
@@ -353,7 +383,9 @@ def trim_frames(frame_data):
         for marker_index in range(1, len(frame)):
             coordinates = frame.iloc[marker_index]
             if math.isnan(coordinates[0]):
-                missing_markers.append(frame_data.columns[marker_index])
+                marker_name = frame_data.columns[marker_index]
+                if marker_name not in torso_markers:
+                    missing_markers.append(marker_name)
         if missing_markers:
             incomplete_frames[frame_number] = missing_markers
 
@@ -382,8 +414,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
@@ -466,6 +500,11 @@ def get_static_rotation(frame_data):
     raise ParserError("ASIS markers not found. Cannot determine static trial rotation.")
 
 
+def rotate_trc_y_vertical(frame_data):
+    rotation_matrix = np.array([[1, 0, 0], [0, 0, 1], [0, -1, 0]])
+    rotate_trc_data(frame_data, rotation_matrix)
+
+
 def rotate_trc_data(frame_data, rotation_matrix):
     identity_matrix = np.eye(3)
     if np.array_equal(rotation_matrix, identity_matrix):
@@ -477,6 +516,11 @@ def rotate_trc_data(frame_data, rotation_matrix):
         )
 
 
+def rotate_grf_y_vertical(analog_data):
+    rotation_matrix = np.array([[1, 0, 0], [0, 0, 1], [0, -1, 0]])
+    rotate_grf_data(analog_data, rotation_matrix)
+
+
 def rotate_grf_data(analog_data, rotation_matrix):
     identity_matrix = np.eye(3)
     if np.array_equal(rotation_matrix, identity_matrix):
@@ -523,14 +567,21 @@ def extract_data(file_path, start_frame, end_frame):
         if 'EVENT' not in reader:
             raise ParserError("No events found in dynamic trial.")
 
+        def get_metadata(object, key):
+            value = object.get(key)
+            if value is None:
+                raise ParserError(f"Missing required metadata: {key}. Skipping trial.")
+            return value
+
         # Extract analog data
         time_increment = 1 / reader.analog_rate
         start = (start_frame - 1) / reader.point_rate
-        stop = end_frame / reader.point_rate - (time_increment / 2)
-        times = np.arange(start, stop, time_increment).tolist()
+        stop_analog = end_frame / reader.point_rate - (time_increment / 2)
+        stop_marker = (end_frame - 1) / reader.point_rate
+        times = np.arange(start, stop_analog, time_increment).tolist()
         analog_data = {'time': times}
 
-        labels = reader.get('ANALOG:LABELS').string_array
+        labels = get_metadata(reader, 'ANALOG:LABELS').string_array
         analog_data.update({label: [] for label in labels})
         for i, points, analog in reader.read_frames():
             if i < start_frame or end_frame < i:
@@ -543,11 +594,11 @@ def extract_data(file_path, start_frame, end_frame):
         analog_data = pd.DataFrame(analog_data)
 
         # Extract event information.
-        event_group = reader.get('EVENT')
-        event_count = event_group.get('USED').int8_value
-        contexts = event_group.get('CONTEXTS').string_array
-        labels = event_group.get('LABELS').string_array
-        times = event_group.get('TIMES').float_array
+        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
+        times = get_metadata(event_group, 'TIMES').float_array
         events = {'Left': {}, 'Right': {}}
 
         for i in range(event_count):
@@ -555,6 +606,7 @@ def extract_data(file_path, start_frame, end_frame):
             if foot:
                 label = labels[i].strip()
                 event_time = times[i][1]
+                event_time = round(float(event_time), 4)
                 events[foot][event_time] = label
         if not any(events.values()):
             raise ParserError("Event context (side) missing.")
@@ -580,23 +632,31 @@ def extract_data(file_path, start_frame, end_frame):
         for foot, events in annotated_events.items():
             for stride_number, stride_events in events.items():
                 for event_time, event_type in stride_events.items():
-                    if start < event_time < stop:
+                    if start <= event_time <= stop_marker:
                         if stride_number not in trimmed_events[foot]:
                             trimmed_events[foot][stride_number] = {}
                         trimmed_events[foot][stride_number][event_time] = event_type
                     else:
                         logger.warn(f"Event at {event_time}s is outside the trial's valid range "
-                                    f"of time stamps ({start}s - {stop}s).")
+                                    f"of time stamps ({start}s - {stop_marker}s).")
 
         # Get number of force plates.
-        plate_count = reader.get('FORCE_PLATFORM:USED').int8_value
+        plate_count = get_metadata(reader, 'FORCE_PLATFORM:USED').int8_value
 
         # Rotate GRF data to align with global CS.
-        corners = reader.get('FORCE_PLATFORM:CORNERS').float_array
+        corners = get_metadata(reader, 'FORCE_PLATFORM:CORNERS').float_array
 
     return analog_data, reader.analog_rate, trimmed_events, plate_count, corners
 
 
+# TODO: Georgio asked if we could maybe provide a way to approximate some of these values (from markers),
+#   if they haven't measured them.
+#   ...
+#   Thor suggests taking this value from the model.
+#   ...
+#   Discuss this with Elyse to see if she's Ok with this/
+#   If she can get the other labs to agree/
+#   See how each lab measures this.
 def extract_static_data(file_path):
     with open(file_path, 'rb') as handle:
         reader = c3d.Reader(handle)
@@ -897,6 +957,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:
@@ -968,6 +1030,9 @@ def normalise_grf_data(data, events):
                     data_segment = force_data.iloc[start:frame, 1:]
                     start = None if event_plate is None else frame
 
+                    # TODO: These need fixed!!!
+                    #   To align with new orientation.
+                    #   NOW!
                     # Perform side-specific transformations.
                     if "ground_force_vy" in data_segment.columns:
                         data_segment["ground_force_vy"] = -data_segment["ground_force_vy"]
@@ -1018,9 +1083,8 @@ def normalise_kinematics(kinematic_data, events):
                     if foot == "Left":
                         data_segment["pelvis_rotation"] = -data_segment["pelvis_rotation"]
                     if foot == "Right":
-                        data_segment["pelvis_list"] = -(data_segment["pelvis_list"] - 180)
+                        data_segment["pelvis_list"] = -data_segment["pelvis_list"]
                     data_segment["pelvis_tilt"] = -data_segment["pelvis_tilt"]
-                    data_segment["pelvis_list"] -= 90
 
                     normalised_data[foot][file_name][stride_number - 1] = data_segment.values.T
                     start = data[data['time'] <= event_time].index[-1]
@@ -1189,7 +1253,7 @@ def calculate_spatiotemporal_data(frame_data, events, static_data):
                     step_length = heel_coordinates[0] - previous_coordinates[0]     # type: ignore
                     step_lengths[opposite_foot][stride_numbers[opposite_foot]] = step_length / 1000
 
-                    step_width = abs(heel_coordinates[1] - previous_coordinates[1])     # type: ignore
+                    step_width = abs(heel_coordinates[2] - previous_coordinates[2])     # type: ignore
                     step_widths[opposite_foot][stride_numbers[opposite_foot]] = step_width / 1000
 
             # Calculate stance and swing phases.
@@ -1280,11 +1344,11 @@ def calculate_distance_covered(frame_data, start_time=None, end_time=None):
 
     start_pos = frame_data.loc[start_frame, ['LASI', 'RASI']].mean()
     end_pos = frame_data.loc[end_frame, ['LASI', 'RASI']].mean()
-    walking_direction = end_pos[:2] - start_pos[:2]
+    walking_direction = end_pos[[0, 2]] - start_pos[[0, 2]]
     walking_direction /= np.linalg.norm(walking_direction)
 
     distance_vector = end_pos - start_pos
-    distance_travelled = np.dot(distance_vector[:2], walking_direction)
+    distance_travelled = np.dot(distance_vector[[0, 2]], walking_direction)
 
     return distance_travelled
 
@@ -1292,7 +1356,7 @@ def calculate_distance_covered(frame_data, start_time=None, end_time=None):
 def calculate_walking_direction(frame_data):
     start_pos = frame_data[['LASI', 'RASI']].iloc[0].mean(axis=0)
     end_pos = frame_data[['LASI', 'RASI']].iloc[-1].mean(axis=0)
-    walking_direction = end_pos[:2] - start_pos[:2]
+    walking_direction = end_pos[[0, 2]] - start_pos[[0, 2]]
     walking_direction /= np.linalg.norm(walking_direction)
 
     return walking_direction
@@ -1305,15 +1369,15 @@ def calculate_foot_progression_angles(frame_data):
     foot_progression = pd.DataFrame()
     for foot in ['Left', 'Right']:
         side = foot[0]
-        heel_xy = np.stack(frame_data[f"{side}HEE"].values)[:, :2]
-        toe_xy = np.stack(frame_data[f"{side}TOE"].values)[:, :2]
+        heel_xz = np.stack(frame_data[f"{side}HEE"].values)[:, [0, 2]]
+        toe_xz = np.stack(frame_data[f"{side}TOE"].values)[:, [0, 2]]
 
-        foot_vectors = toe_xy - heel_xy
+        foot_vectors = toe_xz - heel_xz
         foot_unit_vectors = foot_vectors / np.linalg.norm(foot_vectors, axis=1, keepdims=True)
         foot_angles = np.arctan2(foot_unit_vectors[:, 1], foot_unit_vectors[:, 0])
         angles = np.degrees(foot_angles - walking_angle)
 
-        if foot == 'Left':
+        if foot == 'Right':
             angles = -angles
 
         foot_progression[f'foot_progression_{side.lower()}'] = angles

{c3d_parser-0.3.4 → c3d_parser-0.5.0}/src/c3d_parser/core/osim.py

@@ -18,6 +18,11 @@ def perform_ik(osim_file, trc_file, output_file):
     ik_tool.setModel(model)
     ik_tool.setMarkerDataFileName(trc_file)
     ik_tool.set_IKTaskSet(osim.IKTaskSet(IK_TASK_SET))
+
+    # TODO: Fix Teresa's OpenSim issue.
+    # ik_tool.setResultsDir(r"C:\Users\MyUser\AppData\Local\MyApp\results")
+    # ik_tool.setResultsDir(output_directory)
+
     ik_tool.setOutputMotionFileName(output_file)
     ik_tool.set_report_errors(False)
     ik_tool.run()
@@ -34,10 +39,19 @@ def perform_id(osim_file, ik_file, grf_file, output_file):
     id_tool = osim.InverseDynamicsTool()
     id_tool.setModel(model)
     id_tool.setCoordinatesFileName(ik_file)
-    id_tool.setExternalLoadsFileName(external_loads_file)
+
+    # TODO: Temporarily disable.
+    #   Now when I add this back in the ID_Tool crashes at run...
+    # id_tool.setExternalLoadsFileName(external_loads_file)
+    
     id_tool.setResultsDir(output_directory)
     id_tool.setOutputGenForceFileName(output_file_name)
+
+    # TODO: We shouldn't need this since the data (IK results) are already filtered.
+    # TODO: We may be filtering multiple times and this may be related to the kinetic issues...?
     id_tool.setLowpassCutoffFrequency(6)
+    # id_tool.setLowpassCutoffFrequency(4)
+
     id_tool.setStartTime(time_values[0])
     id_tool.setEndTime(time_values[-1])
     id_tool.run()

{c3d_parser-0.3.4 → c3d_parser-0.5.0}/src/c3d_parser/core/osim_resources/external_loads_template.xml

@@ -4,7 +4,7 @@
 		<objects>
 			<ExternalForce name="externalforce_l">
 				<!--Name of the body the force is applied to.-->
-				<applied_to_body>calcn_l_b</applied_to_body>
+				<applied_to_body>calcn_l</applied_to_body>
 				<!--Name of the body the force is expressed in (default is ground).-->
 				<force_expressed_in_body>ground</force_expressed_in_body>
 				<!--Name of the body the point is expressed in (default is ground).-->
@@ -20,7 +20,7 @@
 			</ExternalForce>
 			<ExternalForce name="externalforce_r">
 				<!--Name of the body the force is applied to.-->
-				<applied_to_body>calcn_r_b</applied_to_body>
+				<applied_to_body>calcn_r</applied_to_body>
 				<!--Name of the body the force is expressed in (default is ground).-->
 				<force_expressed_in_body>ground</force_expressed_in_body>
 				<!--Name of the body the point is expressed in (default is ground).-->

c3d_parser-0.5.0/src/c3d_parser/view/dialogs/delete_marker_set_dialog.py

@@ -0,0 +1,52 @@
+
+import os
+from PySide6.QtCore import Signal
+from PySide6.QtWidgets import QDialog, QMessageBox
+
+from c3d_parser.core.c3d_parser import ParserError
+from c3d_parser.settings.general import get_marker_maps_dir
+from c3d_parser.view.ui.ui_delete_marker_set_dialog import Ui_DeleteMarkerSetDialog
+
+
+class DeleteMarkerSetDialog(QDialog):
+    error_occurred = Signal(Exception)
+
+    def __init__(self, parent=None):
+        super(DeleteMarkerSetDialog, self).__init__(parent)
+        self._ui = Ui_DeleteMarkerSetDialog()
+        self._ui.setupUi(self)
+
+        self._setup_combo_box()
+
+        self._make_connections()
+
+    def _make_connections(self):
+        self._ui.pushButtonDelete.clicked.connect(self._delete_marker_set)
+
+    def _setup_combo_box(self):
+        marker_maps_dir = get_marker_maps_dir()
+        labs = [os.path.splitext(lab)[0] for lab in os.listdir(marker_maps_dir)]
+        self._ui.comboBoxMarkerSet.clear()
+        self._ui.comboBoxMarkerSet.addItems(labs)
+
+    def _delete_marker_set(self):
+        marker_maps_dir = get_marker_maps_dir()
+        selected = self._ui.comboBoxMarkerSet.currentText()
+
+        reply = QMessageBox.question( self, "Confirm Deletion",
+            "Are you sure you want to permanently delete this marker set?",
+            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
+            QMessageBox.StandardButton.No)
+        if reply == QMessageBox.StandardButton.No:
+            return
+
+        match = next((f for f in os.listdir(marker_maps_dir) if os.path.splitext(f)[0] == selected), None)
+        if match:
+            file_path = os.path.join(marker_maps_dir, match)
+            if os.path.isfile(file_path):
+                try:
+                    os.remove(file_path)
+                    self._ui.comboBoxMarkerSet.removeItem(self._ui.comboBoxMarkerSet.currentIndex())
+                except PermissionError:
+                    e = ParserError(f"PermissionError: Could not delete marker set: {selected}")
+                    self.error_occurred.emit(e)

{c3d_parser-0.3.4 → c3d_parser-0.5.0}/src/c3d_parser/view/dialogs/marker_set_dialog.py

@@ -33,6 +33,10 @@ class MarkerSetDialog(QtWidgets.QDialog):
         self._ui.pushButtonImport.clicked.connect(self._import_marker_map)
         self._ui.pushButtonSave.clicked.connect(self._validate_marker_set)
 
+        for marker in markers:
+            combo_box = getattr(self._ui, f"comboBox{marker}")
+            combo_box.currentTextChanged.connect(self.update_combo_box_style)
+
     def set_marker_names(self, marker_names):
         for marker in markers:
             combo_box = getattr(self._ui, f"comboBox{marker}")
@@ -58,6 +62,14 @@ class MarkerSetDialog(QtWidgets.QDialog):
             combo_box = getattr(self._ui, f"comboBox{key}")
             combo_box.setCurrentText(value)
 
+    def update_combo_box_style(self, text):
+        combo_box = self.sender()
+        items = [combo_box.itemText(i) for i in range(combo_box.count())]
+        if text and text not in items:
+            combo_box.setStyleSheet(INVALID_STYLE_SHEET)
+        else:
+            combo_box.setStyleSheet(DEFAULT_STYLE_SHEET)
+
     def _import_marker_map(self):
         dlg = MarkerSetImportDialog(self)
         if dlg.exec():

c3d_parser-0.5.0/src/c3d_parser/view/dialogs/options_dialog.py

@@ -0,0 +1,105 @@
+
+import os
+
+from PySide6.QtWidgets import QDialog, QFileDialog
+from PySide6.QtGui import QRegularExpressionValidator
+from PySide6.QtCore import QRegularExpression
+
+from c3d_parser.view.ui.ui_options_dialog import Ui_OptionsDialog
+from c3d_parser.settings.general import DEFAULT_STYLE_SHEET, INVALID_STYLE_SHEET
+
+
+class OptionsDialog(QDialog):
+
+    def __init__(self, parent=None):
+        super(OptionsDialog, self).__init__(parent)
+        self._ui = Ui_OptionsDialog()
+        self._ui.setupUi(self)
+
+        self._colour_boxes = {
+            self._ui.lineEditLeftColour: self._ui.labelLeftColour,
+            self._ui.lineEditRightColour: self._ui.labelRightColour,
+            self._ui.lineEditSelectionColour: self._ui.labelSelectionColour
+        }
+
+        self._setup_colour_settings()
+        self._disable_default_button_selection()
+
+        self._make_connections()
+
+    def _make_connections(self):
+        self._ui.lineEditRootInput.textChanged.connect(self._validate_data_directory)
+        self._ui.lineEditRootOutput.textChanged.connect(self._validate_data_directory)
+        self._ui.pushButtonRootInputChooser.clicked.connect(self._open_input_directory_chooser)
+        self._ui.pushButtonRootOutputChooser.clicked.connect(self._open_output_directory_chooser)
+
+    def _setup_colour_settings(self):
+        self._validator = QRegularExpressionValidator(QRegularExpression("^#[0-9A-Fa-f]{6}$"))
+        self._ui.lineEditLeftColour.setValidator(self._validator)
+        self._ui.lineEditLeftColour.textChanged.connect(self._colour_code_changed)
+        self._ui.lineEditRightColour.setValidator(self._validator)
+        self._ui.lineEditRightColour.textChanged.connect(self._colour_code_changed)
+        self._ui.lineEditSelectionColour.setValidator(self._validator)
+        self._ui.lineEditSelectionColour.textChanged.connect(self._colour_code_changed)
+
+    def _colour_code_changed(self, text):
+        line_edit = self.sender()
+        state, _, _ = self._validator.validate(text, 0)
+        if state == QRegularExpressionValidator.State.Acceptable:
+            line_edit.setStyleSheet(DEFAULT_STYLE_SHEET)
+            colour_box = self._colour_boxes[line_edit]
+            colour_box.setStyleSheet(f"border: 1px solid black;"
+                f"border-radius: 2px; background-color: {text};")
+        else:
+            line_edit.setStyleSheet(INVALID_STYLE_SHEET)
+
+    def _disable_default_button_selection(self):
+        self._ui.pushButtonOK.setAutoDefault(False)
+        self._ui.pushButtonCancel.setAutoDefault(False)
+        self._ui.pushButtonRootInputChooser.setAutoDefault(False)
+        self._ui.pushButtonRootOutputChooser.setAutoDefault(False)
+
+    def load(self, options):
+        self._ui.doubleSpinBoxLineWidth.setValue(options['line_width'])
+        self._ui.lineEditRootInput.setText(options['input_data_directory'])
+        self._ui.lineEditRootOutput.setText(options['output_data_directory'])
+        self._ui.checkBoxOptimiseKneeAxis.setChecked(options['optimise_knee_axis'])
+        self._ui.lineEditLeftColour.setText(options['colour_left'])
+        self._ui.lineEditRightColour.setText(options['colour_right'])
+        self._ui.lineEditSelectionColour.setText(options['colour_selection'])
+
+    def save(self):
+        options = {
+            'line_width': self._ui.doubleSpinBoxLineWidth.value(),
+            'input_data_directory': self._ui.lineEditRootInput.text(),
+            'output_data_directory': self._ui.lineEditRootOutput.text(),
+            'optimise_knee_axis': self._ui.checkBoxOptimiseKneeAxis.isChecked(),
+            'colour_left': self._ui.lineEditLeftColour.text(),
+            'colour_right': self._ui.lineEditRightColour.text(),
+            'colour_selection': self._ui.lineEditSelectionColour.text()
+        }
+
+        return options
+
+    def _validate_data_directory(self):
+        line_edit = self.sender()
+        directory = line_edit.text()
+        directory_valid = len(directory) and os.path.isdir(directory)
+        line_edit.setStyleSheet(DEFAULT_STYLE_SHEET if directory_valid else INVALID_STYLE_SHEET)
+
+    def _open_input_directory_chooser(self):
+        self._open_directory_chooser(self._ui.lineEditRootInput)
+
+    def _open_output_directory_chooser(self):
+        self._open_directory_chooser(self._ui.lineEditRootOutput)
+
+    def _open_directory_chooser(self, line_edit):
+        current_directory = line_edit.text()
+        if not os.path.isdir(current_directory):
+            current_directory = ''
+
+        directory = QFileDialog.getExistingDirectory(
+            self, 'Select Directory', current_directory)
+
+        if directory:
+            line_edit.setText(directory)