biomechzoo 0.5.9__py3-none-any.whl

biomechzoo/mvn/mvn.py

@@ -0,0 +1,232 @@
+FRAMES_ALL = -1
+
+AXIS_ALL = -1
+AXIS_X = 0
+AXIS_Y = 1
+AXIS_Z = 2
+AXIS_W = 3  # The retrieval method will shift indices for w,x,y,z to 0,1,2,3
+
+ANGLE_ALL = -1
+
+ANGLE_ABDUCTION_ADDUCTION = 0
+ANGLE_RADIAL_ULNAR_DEVIATION = 0
+ANGLE_LATERAL_BENDING = 0
+
+ANGLE_INTERNAL_EXTERNAL_ROTATION = 1
+ANGLE_PRONATION_SUPINATION = 1
+ANGLE_AXIAL_ROTATION = 1
+
+ANGLE_FLEXION_EXTENSION = 2
+ANGLE_DORSIFLEXION_PLANTARFLEXION = 2
+
+SEGMENT_PELVIS = 0
+SEGMENT_L5 = 1
+SEGMENT_L3 = 2
+SEGMENT_T12 = 3
+SEGMENT_T8 = 4
+SEGMENT_NECK = 5
+SEGMENT_HEAD = 6
+SEGMENT_RIGHT_SHOULDER = 7
+SEGMENT_RIGHT_UPPER_ARM = 8
+SEGMENT_RIGHT_FOREARM = 9
+SEGMENT_RIGHT_HAND = 10
+SEGMENT_LEFT_SHOULDER = 11
+SEGMENT_LEFT_UPPER_ARM = 12
+SEGMENT_LEFT_FOREARM = 13
+SEGMENT_LEFT_HAND = 14
+SEGMENT_RIGHT_UPPER_LEG = 15
+SEGMENT_RIGHT_LOWER_LEG = 16
+SEGMENT_RIGHT_FOOT = 17
+SEGMENT_RIGHT_TOE = 18
+SEGMENT_LEFT_UPPER_LEG = 19
+SEGMENT_LEFT_LOWER_LEG = 20
+SEGMENT_LEFT_FOOT = 21
+SEGMENT_LEFT_TOE = 22
+
+SEGMENT_CENTER_OF_MASS = 1000
+
+SEGMENTS = {SEGMENT_PELVIS: 'Pelvis',
+            SEGMENT_L5: 'L5',
+            SEGMENT_L3: 'L3',
+            SEGMENT_T12: 'T12',
+            SEGMENT_T8: 'T8',
+            SEGMENT_NECK: 'Neck',
+            SEGMENT_HEAD: 'Head',
+            SEGMENT_RIGHT_SHOULDER: 'RightShoulder',
+            SEGMENT_RIGHT_UPPER_ARM: 'RightUpperArm',
+            SEGMENT_RIGHT_FOREARM: 'RightForeArm',
+            SEGMENT_RIGHT_HAND: 'RightHand',
+            SEGMENT_LEFT_SHOULDER: 'LeftShoulder',
+            SEGMENT_LEFT_UPPER_ARM: 'LeftUpperArm',
+            SEGMENT_LEFT_FOREARM: 'LeftForeArm',
+            SEGMENT_LEFT_HAND: 'LeftHand',
+            SEGMENT_RIGHT_UPPER_LEG: 'RightUpperLeg',
+            SEGMENT_RIGHT_LOWER_LEG: 'RightLowerLeg',
+            SEGMENT_RIGHT_FOOT: 'RightFoot',
+            SEGMENT_RIGHT_TOE: 'RightToe',
+            SEGMENT_LEFT_UPPER_LEG: 'LeftUpperLeg',
+            SEGMENT_LEFT_LOWER_LEG: 'LeftLowerLeg',
+            SEGMENT_LEFT_FOOT: 'LeftFoot',
+            SEGMENT_LEFT_TOE: 'LeftToe',
+            SEGMENT_CENTER_OF_MASS: 'CoM'}
+
+
+# regular joints
+
+JOINT_L5_S1 = 0
+JOINT_L4_L3 = 1
+JOINT_L1_T12 = 2
+JOINT_T9_T8 = 3
+JOINT_T1_C7 = 4
+JOINT_C1_HEAD = 5
+JOINT_RIGHT_T4_SHOULDER = 6
+JOINT_RIGHT_SHOULDER = 7
+JOINT_RIGHT_ELBOW = 8
+JOINT_RIGHT_WRIST = 9
+JOINT_LEFT_T4_SHOULDER = 10
+JOINT_LEFT_SHOULDER = 11
+JOINT_LEFT_ELBOW = 12
+JOINT_LEFT_WRIST = 13
+JOINT_RIGHT_HIP = 14
+JOINT_RIGHT_KNEE = 15
+JOINT_RIGHT_ANKLE = 16
+JOINT_RIGHT_BALL_FOOT = 17
+JOINT_LEFT_HIP = 18
+JOINT_LEFT_KNEE = 19
+JOINT_LEFT_ANKLE = 20
+JOINT_LEFT_BALL_FOOT = 21
+
+JOINTS = {JOINT_L5_S1: 'jL5S1',
+          JOINT_L4_L3: 'jL4L3',
+          JOINT_L1_T12: 'jL1T12',
+          JOINT_T9_T8: 'jT9T8',
+          JOINT_T1_C7: 'jT1C7',
+          JOINT_C1_HEAD: 'jC1Head',
+          JOINT_RIGHT_T4_SHOULDER: 'jRightT4Shoulder',
+          JOINT_RIGHT_SHOULDER: 'jRightShoulder',
+          JOINT_RIGHT_ELBOW: 'jRightElbow',
+          JOINT_RIGHT_WRIST: 'jRightWrist',
+          JOINT_LEFT_T4_SHOULDER: 'jLeftT4Shoulder',
+          JOINT_LEFT_SHOULDER: 'jLeftShoulder',
+          JOINT_LEFT_ELBOW: 'jLeftElbow',
+          JOINT_LEFT_WRIST: 'jLeftWrist',
+          JOINT_RIGHT_HIP: 'jRightHip',
+          JOINT_RIGHT_KNEE: 'jRightKnee',
+          JOINT_RIGHT_ANKLE: 'jRightAnkle',
+          JOINT_RIGHT_BALL_FOOT: 'jRightBallFoot',
+          JOINT_LEFT_HIP: 'jLeftHip',
+          JOINT_LEFT_KNEE: 'jLeftKnee',
+          JOINT_LEFT_ANKLE: 'jLeftAnkle',
+          JOINT_LEFT_BALL_FOOT: 'jLeftBallFoot'}
+
+PARAMETER_JOINTS = {JOINT_L5_S1: 'j_l5_s1',
+                    JOINT_L4_L3: 'j_l4_l3',
+                    JOINT_L1_T12: 'j_l1_t12',
+                    JOINT_T9_T8: 'j_t9_t8',
+                    JOINT_T1_C7: 'j_t1_c7',
+                    JOINT_C1_HEAD: 'j_c1_head',
+                    JOINT_RIGHT_T4_SHOULDER: 'j_right_t4_shoulder',
+                    JOINT_RIGHT_SHOULDER: 'j_right_shoulder',
+                    JOINT_RIGHT_ELBOW: 'j_right_elbow',
+                    JOINT_RIGHT_WRIST: 'j_right_wrist',
+                    JOINT_LEFT_T4_SHOULDER: 'j_left_t4_shoulder',
+                    JOINT_LEFT_SHOULDER: 'j_left_shoulder',
+                    JOINT_LEFT_ELBOW: 'j_left_elbow',
+                    JOINT_LEFT_WRIST: 'j_left_wrist',
+                    JOINT_RIGHT_HIP: 'j_right_hip',
+                    JOINT_RIGHT_KNEE: 'j_right_knee',
+                    JOINT_RIGHT_ANKLE: 'j_right_ankle',
+                    JOINT_RIGHT_BALL_FOOT: 'j_right_ball_foot',
+                    JOINT_LEFT_HIP: 'j_left_hip',
+                    JOINT_LEFT_KNEE: 'j_left_knee',
+                    JOINT_LEFT_ANKLE: 'j_left_ankle',
+                    JOINT_LEFT_BALL_FOOT: 'j_left_ball_foot'}
+
+
+# ergonomic joints
+
+ERGO_JOINT_T8_HEAD = 0
+ERGO_JOINT_T8_LEFT_UPPER_ARM = 1
+ERGO_JOINT_T8_RIGHT_UPPER_ARM = 2
+ERGO_JOINT_PELVIS_T8 = 3
+ERGO_JOINT_VERTICAL_PELVIS = 4
+ERGO_JOINT_VERTICAL_T8 = 5
+
+ERGO_JOINT_INDICES = {ERGO_JOINT_T8_HEAD,
+                      ERGO_JOINT_T8_LEFT_UPPER_ARM,
+                      ERGO_JOINT_T8_RIGHT_UPPER_ARM,
+                      ERGO_JOINT_PELVIS_T8,
+                      ERGO_JOINT_VERTICAL_PELVIS,
+                      ERGO_JOINT_VERTICAL_T8}
+
+ERGO_JOINTS = {ERGO_JOINT_T8_HEAD: 'T8_Head',
+               ERGO_JOINT_T8_LEFT_UPPER_ARM: 'T8_LeftUpperArm',
+               ERGO_JOINT_T8_RIGHT_UPPER_ARM: 'T8_RightUpperArm',
+               ERGO_JOINT_PELVIS_T8: 'Pelvis_T8',
+               ERGO_JOINT_VERTICAL_PELVIS: 'Vertical_Pelvis',
+               ERGO_JOINT_VERTICAL_T8: 'Vertical_T8'}
+
+ERGO_PARAMETER_JOINTS = {ERGO_JOINT_T8_HEAD: 't8_head',
+                         ERGO_JOINT_T8_LEFT_UPPER_ARM: 't8_left_upper_arm',
+                         ERGO_JOINT_T8_RIGHT_UPPER_ARM: 't8_right_upper_arm',
+                         ERGO_JOINT_PELVIS_T8: 'pelvis_t8',
+                         ERGO_JOINT_VERTICAL_PELVIS: 'vertical_p1elvis',
+                         ERGO_JOINT_VERTICAL_T8: 'vertical_t8'}
+
+
+# foot contacts
+
+FOOT_CONTACT_LEFT_HEEL = 1
+FOOT_CONTACT_LEFT_TOE = 2
+FOOT_CONTACT_RIGHT_HEEL = 4
+FOOT_CONTACT_RIGHT_TOE = 8
+
+# some points
+
+POINT_JOINT_ANKLE = 0
+POINT_JOINT_BALL_FOOT = 1
+POINT_HEEL_FOOT = 2
+POINT_FIRST_METATARSAL = 3
+POINT_FIFTH_METATARSAL = 4
+POINT_PIVOT_FOOT = 5
+POINT_HEEL_CENTER = 6
+POINT_TOP_OF_FOOT = 7
+
+POINTS_LEFT_FOOT = {
+    POINT_JOINT_ANKLE: 'jLeftAnkle',
+    POINT_JOINT_BALL_FOOT: 'jLeftBallFoot',
+    POINT_HEEL_FOOT: 'pLeftHeelFoot',
+    POINT_FIRST_METATARSAL: 'pLeftFirstMetatarsal',
+    POINT_FIFTH_METATARSAL: 'pLeftFifthMetatarsal',
+    POINT_PIVOT_FOOT: 'pLeftPivotFoot',
+    POINT_HEEL_CENTER: 'pLeftHeelCenter',
+    POINT_TOP_OF_FOOT: 'pLeftTopOfFoot',
+}
+
+POINTS_RIGHT_FOOT = {
+    POINT_JOINT_ANKLE: 'jRightAnkle',
+    POINT_JOINT_BALL_FOOT: 'jRightBallFoot',
+    POINT_HEEL_FOOT: 'pRightHeelFoot',
+    POINT_FIRST_METATARSAL: 'pRightFirstMetatarsal',
+    POINT_FIFTH_METATARSAL: 'pRightFifthMetatarsal',
+    POINT_PIVOT_FOOT: 'pRightPivotFoot',
+    POINT_HEEL_CENTER: 'pRightHeelCenter',
+    POINT_TOP_OF_FOOT: 'pRightTopOfFoot',
+}
+
+# Toe
+# POINT_JOINT_BALL_FOOT = 0 # overlaps with foot segment
+POINT_TOE = 1
+POINT_JOINT_TOE = 2
+
+POINTS_LEFT_TOE = {
+    # POINT_JOINT_BALL_FOOT: 'jLeftBallFoot',
+    POINT_TOE: 'pLeftToe',
+    POINT_JOINT_TOE: 'jLeftToe',
+}
+
+POINTS_RIGHT_TOE = {
+    # POINT_JOINT_BALL_FOOT: 'jRightBallFoot',
+    POINT_TOE: 'pRightToe',
+    POINT_JOINT_TOE: 'jRightToe',
+}

biomechzoo/mvn/mvnx_file_accessor.py

@@ -0,0 +1,464 @@
+from biomechzoo.mvn import mvn
+import warnings
+
+
+class MvnxFileAccessor:
+
+    @property
+    def original_file_name(self):
+        return self.file_data['meta_data']['original_filename']
+
+    @property
+    def actor_name(self):
+        return self.file_data['meta_data']['name']
+
+    @property
+    def actor_color(self):
+        return self.file_data['meta_data']['color']
+
+    @property
+    def profile(self):
+        return self.file_data['meta_data']['scenario']
+
+    @property
+    def configuration(self):
+        return self.file_data['meta_data']['configuration']
+
+    @property
+    def comments(self):
+        return self.file_data['meta_data']['comments']
+
+    @property
+    def quality(self):
+        return self.file_data['meta_data']['quality']
+
+    @property
+    def frame_count(self):
+        return self._last_frame - self._first_frame
+
+    @property
+    def segment_count(self):
+        return self.file_data['frames']['segment_count']
+
+    @property
+    def joint_count(self):
+        return self.file_data['frames']['joint_count']
+
+    @property
+    def finger_joint_count(self):
+        return self.file_data['frames']['finger_joint_count']
+
+    @property
+    def ergo_joint_count(self):
+        ergo_joint_count = len(self.file_data['ergo_joints']) if self.file_data['ergo_joints'] is not None else None
+        return ergo_joint_count  # 'ergoJointCount' non-existing in mvnx
+
+    @property
+    def sensor_count(self):
+        return self.file_data['frames']['sensor_count']
+
+    @property
+    def frame_rate(self) -> int:
+        if 'sample_rate' in self.file_data['meta_data']:
+            return int(self.file_data['meta_data']['sample_rate'])
+        else:
+            warnings.warn('Using default sample rate of 240')
+            return 240
+
+    @property
+    def recording_date(self) -> str:
+        return self.file_data['meta_data']['rec_date']
+
+    @property
+    def version(self):
+        return self.file_data['meta_data']['version']
+
+    def __init__(self):
+        self.file_data = {}
+        self._all_frames_slice = None
+        self._first_frame = 0
+        self._last_frame = 0
+        self._index_to_segment = {}
+
+    def create_index_to_segment_dict(self):
+        segment_index = 0
+        for _, segment in self.file_data['segments']['elements'].items():
+            if 'label' in segment:
+                self._index_to_segment[segment_index] = segment['label']
+            segment_index += 1
+
+    def set_frame_window(self, first_frame, last_frame):
+        self._first_frame = first_frame
+        self._last_frame = last_frame
+        self._all_frames_slice = slice(self._first_frame, self._last_frame)
+
+    def reset_frame_window(self):
+        self._first_frame = 0
+        self._last_frame = len(self.file_data['frames']['segment_data'])
+        self._all_frames_slice = slice(self._first_frame, self._last_frame)
+
+    def window_profile(self):
+        """
+        This method determines the filter profile (aka scenario) for the currently selected window on the
+        data.
+        :return: The profile name (singleLevel, multiLevel, ...) or 'mixed' if different profiles
+        ere applied to the window.
+        """
+        if 'profiles' not in self.file_data['meta_data']:
+            return self.profile
+        else:
+            profiles = set()
+            for profile_spec in self.file_data['meta_data']['profiles']:
+                if profile_spec[1] > self._first_frame and profile_spec[0] <= self._last_frame:
+                    profiles.add(profile_spec[2])
+
+            if len(profiles) == 1:
+                return profiles.pop()
+            else:
+                return 'mixed'
+
+    def frame_to_mapped_slice(self, frame) -> (slice, bool):
+        # convert the frame parameter to a slice that is mapped to the current view on the file
+        single_frame = False
+        if not isinstance(frame, slice):
+            if frame == mvn.FRAMES_ALL:
+                # all frames slice already is mapped to the current view
+                self.reset_frame_window()
+                frame = self._all_frames_slice  # use the prepared 'all frames' slice
+            else:
+                # for a single frame, map the frame to the current view on all data by adding the virtual first frame
+                frame = slice(self._first_frame + frame, self._first_frame + frame + 1)  # create a single frame slice
+                single_frame = True
+        else:
+            # shift the slice to the current virtual 'view'
+            start = frame.start + self._first_frame
+            if frame.stop:
+                stop = frame.stop + self._first_frame
+            else:  # a slice with end given as None implies end at last frame
+                stop = self._last_frame
+            step = frame.step
+            frame = slice(start, stop, step)
+
+        return frame, single_frame
+
+    def segment_name_from_index(self, segment_index):
+        return self._index_to_segment[segment_index]
+
+    def point_name_from_indices(self, segment_index, point_index):
+        segment_name = self.segment_name_from_index(segment_index)
+        segment = self.file_data['segments']['elements'][segment_name]
+        return segment['info']['point_label_from_index'][point_index]
+
+    """ Pose methods """
+
+    def identity_pose_is_valid(self):
+        return ('identity' in self.file_data) and \
+               (self.identity_pose()['segments_counts'] > 0)
+
+    def identity_pose_segment_pos(self, segment):
+        return self.identity_pose()['segments'][segment]['pos_g']
+
+    def identity_pose_segment_ori(self, segment):
+        return self.identity_pose()['segments'][segment]['q_gb']
+
+    def t_pose_is_valid(self):
+        return ('tpose' in self.file_data) and \
+               (self.t_pose()['segments_counts'] > 0)
+
+    def t_pose_segment_pos(self, segment):
+        return self.t_pose()['segments'][segment]['pos_g']
+
+    def t_pose_segment_ori(self, segment):
+        return self.t_pose()['segments'][segment]['q_gb']
+
+    def identity_pose(self):
+        return self.file_data['identity']
+
+    def t_pose(self):
+        return self.file_data['tpose']
+
+    """ Segment methods """
+
+    def get_segment_pos(self, segment, frame=mvn.FRAMES_ALL, axis=mvn.AXIS_ALL):
+        """
+        Get the position information for a segment
+
+        :param segment: The index of the segment to return the data for (Mvn.SEGMENT_.... )
+        :param frame: Can be the index of the frame to return, a slice to return a range of frames
+                      or Mvn.FRAMES_ALL (default) to return all frames
+        :param axis: The frame number to return the data for (Mvn.AXIS_... ALL for all axes)
+        :return: A single value, list, or list of lists with position values
+        """
+
+        return self.get_segment_data('pos', segment, frame, axis)
+
+    def get_segment_ori(self, segment, frame=mvn.FRAMES_ALL, axis=mvn.AXIS_ALL):
+        """
+        Get the orientation information for a segment
+
+        :param segment: The index of the segment to return the data for (Mvn.SEGMENT_.... )
+        :param frame: Can be the index of the frame to return, a slice to return a range of frames
+                      or Mvn.FRAMES_ALL (default) to return all frames
+        :param axis: The frame number to return the data for (Mvn.AXIS_... ALL for all axes)
+        :return: A single value, list, or list of lists with orientation values
+        """
+
+        # For orientation data, if all axes requested, return all. If specific axis requested, shift index so that w,
+        # x,y,z becomes 0,1,2,3
+        axis = (axis + 1) % 4 if axis != mvn.AXIS_ALL else axis
+        return self.get_segment_data('ori', segment, frame, axis)
+
+    def get_segment_point_pos(self, segment, point):
+        segment_name = mvn.SEGMENTS[segment]
+        segment_info = self.file_data['segments'][segment_name]
+        points = segment_info['info']['point_label_from_index']
+        point_name = points[point]
+        return segment_info['points_mvn'][point_name]
+
+    def get_point_pos(self, segment, point):
+        segment_name = mvn.SEGMENTS[segment]
+
+        if segment_name == 'LeftFoot':
+            point_name = mvn.POINTS_LEFT_FOOT[point]
+        elif segment_name == 'RightFoot':
+            point_name = mvn.POINTS_RIGHT_FOOT[point]
+        elif segment_name == 'LeftToe':
+            point_name = mvn.POINTS_LEFT_TOE[point]
+        elif segment_name == 'RightToe':
+            point_name = mvn.POINTS_RIGHT_TOE[point]
+
+        return self.file_data['segments'][segment_name]['points_mvn'][point_name]
+
+    def get_segment_vel(self, segment, frame=mvn.FRAMES_ALL, axis=mvn.AXIS_ALL):
+        """
+        Get the local velocity information for a segment
+
+        :param segment: The index of the segment to return the data for (Mvn.SEGMENT_.... )
+        :param frame: Can be the index of the frame to return, a slice to return a range of frames
+                      or Mvn.FRAMES_ALL (default) to return all frames
+        :param axis: The frame number to return the data for (Mvn.AXIS_... ALL for all axes)
+        :return: A single value, list, or list of lists with velocity values
+        """
+
+        return self.get_segment_data('vel', segment, frame, axis)
+
+    def get_segment_acc(self, segment, frame=mvn.FRAMES_ALL, axis=mvn.AXIS_ALL):
+        """
+        Get the acceleration information for a segment
+
+        :param segment: The index of the segment to return the data for (Mvn.SEGMENT_.... )
+        :param frame: Can be the index of the frame to return, a slice to return a range of frames
+                      or Mvn.FRAMES_ALL (default) to return all frames
+        :param axis: The frame number to return the data for (Mvn.AXIS_... ALL for all axes)
+        :return: A single value, list, or list of lists with acceleration values
+        """
+
+        return self.get_segment_data('acc', segment, frame, axis)
+
+    def get_segment_angular_vel(self, segment, frame=mvn.FRAMES_ALL, axis=mvn.AXIS_ALL):
+        """
+        Get the acceleration information for a segment
+
+        :param segment: The index of the segment to return the data for (Mvn.SEGMENT_.... )
+        :param frame: Can be the index of the frame to return, a slice to return a range of frames
+                      or Mvn.FRAMES_ALL (default) to return all frames
+        :param axis: The frame number to return the data for (Mvn.AXIS_... ALL for all axes)
+        :return: A single value, list, or list of lists with angular velocity values
+        """
+
+        return self.get_segment_data('ang_vel', segment, frame, axis)
+
+    def get_segment_angular_acc(self, segment, frame=mvn.FRAMES_ALL, axis=mvn.AXIS_ALL):
+        """
+        Get the acceleration information for a segment
+
+        :param segment: The index of the segment to return the data for (Mvn.SEGMENT_.... )
+        :param frame: Can be the index of the frame to return, a slice to return a range of frames
+                      or Mvn.FRAMES_ALL (default) to return all frames
+        :param axis: The frame number to return the data for (Mvn.AXIS_... ALL for all axes)
+        :return: A single value, list, or list of lists with acceleration values
+        """
+
+        return self.get_segment_data('ang_acc', segment, frame, axis)
+
+    def get_segment_data(self, data_field, segment, frame=mvn.FRAMES_ALL, axis=mvn.AXIS_ALL):
+        return self.get_data('segment_data', data_field, segment, frame, axis)
+
+    """ Joint methods """
+
+    def get_joint_angle(self, joint, frame=mvn.FRAMES_ALL, angle=mvn.ANGLE_ALL):
+        joint_name = mvn.JOINTS[joint]
+        data_set = 'joint_data'
+
+        frame, is_single_frame = self.frame_to_mapped_slice(frame)
+
+        if angle == mvn.ANGLE_ALL:
+            return_values = [value[joint_name] for value in self.file_data['frames'][data_set][frame]]
+        else:
+            return_values = [value[joint_name][angle] for value in self.file_data['frames'][data_set][frame]]
+
+        return return_values[0] if is_single_frame else return_values
+
+    def get_joint_angle_xzy(self, joint, frame=mvn.FRAMES_ALL, angle=mvn.ANGLE_ALL):
+        joint_name = mvn.JOINTS[joint]
+        data_set = 'joint_data_xzy'
+
+        frame, is_single_frame = self.frame_to_mapped_slice(frame)
+
+        if angle == mvn.ANGLE_ALL:
+            return_values = [value[joint_name] for value in self.file_data['frames'][data_set][frame]]
+        else:
+            return_values = [value[joint_name][angle] for value in self.file_data['frames'][data_set][frame]]
+
+        return return_values[0] if is_single_frame else return_values
+
+    def get_ergo_joint_angle(self, joint, frame=mvn.FRAMES_ALL, angle=mvn.ANGLE_ALL):
+        joint_name = mvn.ERGO_JOINTS[joint]
+        data_set = 'ergo_joint_data'
+
+        frame, is_single_frame = self.frame_to_mapped_slice(frame)
+
+        if angle == mvn.ANGLE_ALL:
+            return_values = [value[joint_name] for value in self.file_data['frames'][data_set][frame]]
+        else:
+            return_values = [value[joint_name][angle] for value in self.file_data['frames'][data_set][frame]]
+
+        return return_values[0] if is_single_frame else return_values
+
+    """ Center of Mass methods """
+
+    def get_center_of_mass_pos(self, frame=mvn.FRAMES_ALL, axis=mvn.AXIS_ALL):
+        """
+        Get the position information for center of mass
+
+        :param frame: Can be the index of the frame to return, a slice to return a range of frames
+                      or Mvn.FRAMES_ALL (default) to return all frames
+        :param axis: The axis to return the data for (Mvn.AXIS_... ALL for all axes)
+        :return: A single value, list, or list of lists with position values
+        """
+
+        return self.get_segment_data('pos', mvn.SEGMENT_CENTER_OF_MASS, frame, axis)
+
+    def get_center_of_mass_vel(self, frame=mvn.FRAMES_ALL, axis=mvn.AXIS_ALL):
+        """
+        Get the velocity information for center of mass
+
+        :param frame: Can be the index of the frame to return, a slice to return a range of frames
+                      or Mvn.FRAMES_ALL (default) to return all frames
+        :param axis: The axis to return the data for (Mvn.AXIS_... ALL for all axes)
+        :return: A single value, list, or list of lists with position values
+        """
+
+        return self.get_segment_data('vel', mvn.SEGMENT_CENTER_OF_MASS, frame, axis)
+
+    def get_center_of_mass_acc(self, frame=mvn.FRAMES_ALL, axis=mvn.AXIS_ALL):
+        """
+        Get the acceleration information for center of mass
+
+        :param frame: Can be the index of the frame to return, a slice to return a range of frames
+                      or Mvn.FRAMES_ALL (default) to return all frames
+        :param axis: The axis to return the data for (Mvn.AXIS_... ALL for all axes)
+        :return: A single value, list, or list of lists with position values
+        """
+
+        return self.get_segment_data('acc', mvn.SEGMENT_CENTER_OF_MASS, frame, axis)
+
+    """ Sensor methods """
+
+    def get_sensor_ori(self, segment, frame=mvn.FRAMES_ALL, axis=mvn.AXIS_ALL):
+        """
+        Get the orientation information for a sensor
+
+        :param segment: The index of the segment to return the sensor data for (Mvn.SEGMENT_.... )
+        :param frame: Can be the index of the frame to return, a slice to return a range of frames
+                      or Mvn.FRAMES_ALL (default) to return all frames
+        :param axis: The frame number to return the data for (Mvn.AXIS_... ALL for all axes)
+        :return: A single value, list, or list of lists with orientation values
+        """
+
+        # if all axes requested, return all. If specific axis requested, shift index so that w,x,y,z becomes 0,1,2,3
+        axis = (axis + 1) % 4 if axis != mvn.AXIS_ALL else axis
+        return self.get_sensor_data('ori', segment, frame, axis)
+
+    def get_sensor_free_acc(self, segment, frame=mvn.FRAMES_ALL, axis=mvn.AXIS_ALL):
+        """
+        Get the free acceleration information for a sensor
+
+        :param segment: The index of the segment to return the sensor data for (Mvn.SEGMENT_.... )
+        :param frame: Can be the index of the frame to return, a slice to return a range of frames
+                      or Mvn.FRAMES_ALL (default) to return all frames
+        :param axis: The frame number to return the data for (Mvn.AXIS_... ALL for all axes)
+        :return: A single value, list, or list of lists with acceleration values
+        """
+
+        return self.get_sensor_data('acc', segment, frame, axis)
+
+    def get_sensor_data(self, data_field, sensor_segment, frame=mvn.FRAMES_ALL, axis=mvn.AXIS_ALL):
+        return self.get_data('sensor_data', data_field, sensor_segment, frame, axis)
+
+    """ Contact methods """
+
+    def get_foot_contacts(self, frame):
+        """
+        Get the contacts for a frame
+        :param frame: The frame, or a range of frames to retrieve the contacts for.
+        :return: The contacts
+        """
+        frame, is_single_frame = self.frame_to_mapped_slice(frame)
+        return_values = self.file_data['frames']['contacts_data'][frame] #edited Phil Dixon
+        return return_values[0] if is_single_frame else return_values
+
+
+    def has_foot_contact(self, frame, foot_contact_flags=0):
+        """
+        Find out if the frame has a contact, optionally for a specific segment/point combo
+
+        :param frame: The frame (or range) to retrieve the contacts for.
+        :param foot_contact_flags: The specific contact to check for:
+                                    mvn.FOOT_CONTACT_LEFT_HEEL,
+                                    mvn.FOOT_CONTACT_LEFT_TOE,
+                                    mvn.FOOT_CONTACT_RIGHT_HEEL or
+                                    mvn.FOOT_CONTACT_RIGHT_TOE
+
+                                 It is possible to combine contacts by summing the values, eg:
+                                    mvn.FOOT_CONTACT_LEFT_HEEL + mvn.FOOT_CONTACT_LEFT_TOE
+                                 This will return a contact if either of the flags has a contact
+
+                                 Passing 0 (or nothing) will return True if there is any contact
+
+        :return: Per frame True if a contact was found, False otherwise.
+        """
+        frame_contacts = self.get_foot_contacts(frame)  # frame will be shifted in the called method
+
+        if isinstance(frame_contacts, int):
+            if foot_contact_flags == 0:
+                return frame_contacts > 0
+            else:
+                return True if (frame_contacts & foot_contact_flags) > 0 else False
+        else:
+            has_contacts = []
+            for contacts in frame_contacts:
+                if foot_contact_flags == 0:
+                    has_contacts.append(frame_contacts > 0)
+                else:
+                    has_contacts.append(True if (contacts & foot_contact_flags) > 0 else False)
+            return has_contacts
+
+    """ Generic methods """
+
+    def get_data(self, data_set, data_field, segment, frame=mvn.FRAMES_ALL, axis=mvn.AXIS_ALL):
+        if segment == -1:
+            segment_name = 'com'
+        else:
+            segment_name = mvn.SEGMENTS[segment]
+
+        frame, is_single_frame = self.frame_to_mapped_slice(frame)
+        if data_set == 'joint_data':
+            return_values = [value[data_field] for value in self.file_data['frames'][data_set][frame]]
+        elif axis == mvn.AXIS_ALL:
+            return_values = [value[segment_name][data_field] for value in self.file_data['frames'][data_set][frame]]
+        else:
+            return_values = [value[segment_name][data_field][axis] for value in
+                             self.file_data['frames'][data_set][frame]]
+
+        return return_values[0] if is_single_frame else return_values