generic-joint-angles.calqulus.yaml

# A pipeline is written in YAML and instructs the Calqulus processing engine what to calculate.
# In order to process this pipeline, skeleton must be solved in QTM first.

# A pipeline consists of any number of base nodes defined on the root level. 

# Output nodes define an end result that is exported to the global scope and exported in the resulting JSON file.
# Output node can be 'event' or 'parameter'
# The main difference between the parameter and event is what type of data is stored. 
# A parameter node will store series and scalar data, whereas an event node will store event data.

# Space node defines custom coordinate systems. It is useful when orientation of subject changes
# with regards to the global coordinate system, e.g. walking through lab in both directions.

# Order of nodes is not important. They can be placed anywhere in YAML file.

############
## SPACES ##
############

# Create a space named VirtualLab, that is defined by the orientation of Hips (Pelvis) segment.
- space: VirtualLab
  alignWithSegment:
    segment: Hips

############
## EVENTS ##
############

# An event node defines steps used to calculate an event.
# An event is a label that describes one or more points in time.
# Events can be used in both event and parameter calculations, as well as for normalization by the reporting framework. 
# The resulting event is exported to the global scope and exported in the resulting JSON file.

# Create event at left knee maximum flexion
- event: BOF
  where:
    name: '!Static*'
  steps:
    - import: [0]
  
- event: EOF
  where:
    name: '!Static*'
  steps:
    - import: [$length]

############
## SERIES ##
############

# Calculating joint angles

# --- Pelvis ---

- parameter: Pelvic Angles
  where:
    name: '!Static*'
  steps:
    - angle: Hips # angle is calculated relative to axes of global coordinate system, if only single input exists
      space: VirtualLab # calculate angle relative to virtual lab
    - multiply: [$prev, [-1, 1, 1]] # invert first component of output

# --- Hips ---

- parameter: Left Hip Angles
  where:
    name: '!Static*'
  set: left
  steps:
    - angle: [Hips, LeftUpLeg] # when two segments are specified, joint angle between the segments is calculated
    - multiply: [$prev, [1, -1, -1]]

- parameter: Right Hip Angles
  where:
    name: '!Static*'
  set: right
  steps:
    - angle: [Hips, RightUpLeg]

# --- Knee ---

- parameter: Left Knee Angles
  where:
    name: '!Static*'
  set: left
  steps:
    - angle: [LeftUpLeg, LeftLeg]
    - multiply: [$prev, [-1, -1, -1]]

- parameter: Right Knee Angles
  where:
    name: '!Static*'
  set: right
  steps:
    - angle: [RightUpLeg, RightLeg]
    - multiply: [$prev, [-1, 1, 1]]

# --- Ankle ---

- parameter: Left Ankle Angles
  where:
    name: '!Static*'
  set: left
  steps:
    - angle: [LeftLeg, LeftFoot]
    - multiply: [$prev, [1, -1, 1]]

- parameter: Right Ankle Angles
  where:
    name: '!Static*'
  set: right
  steps:
    - angle: [RightLeg, RightFoot]
    - multiply: [$prev, [1, 1, -1]]

# --- Thorax ---

- parameter: Thorax Angles
  where:
    name: '!Static*'
  steps:
    - angle: [Hips, Spine2]
    - multiply: [$prev, [-1, -1, 1]]

# --- Shoulder ---

- parameter: Left Shoulder Angles
  where:
    name: '!Static*'
  set: left
  steps:
    - angle: [Spine2, LeftArm]
    - multiply: [$prev, [1, -1, -1]]

- parameter: Right Shoulder Angles
  where:
    name: '!Static*'
  set: right
  steps:
    - angle: [Spine2, RightArm]
    - multiply: [$prev, [1, 1, 1]]

# --- Elbow ---

- parameter: Left Elbow Angles
  where:
    name: '!Static*'
  set: left
  steps:
    - angle: [LeftArm, LeftForeArm]
    - multiply: [$prev, [1, 1, -1]]

- parameter: Right Elbow Angles
  where:
    name: '!Static*'
  set: right
  steps:
    - angle: [RightArm, RightForeArm]

# --- Wrist ---

- parameter: Left Wrist Angles
  where:
    name: '!Static*'
  set: left
  steps:
    - angle: [LeftForeArm, LeftHand]
    - multiply: [$prev, [1, -1, 1]]

- parameter: Right Wrist Angles
  where:
    name: '!Static*'
  set: right
  steps:
    - angle: [RightForeArm, RightHand]
    - multiply: [$prev, [1, 1, -1]]

# --- Head ---

- parameter: Head Angles
  where:
    name: '!Static*'
  steps:
    - angle: [Head, Spine2]


#############
## Metrics ##
#############

# Find global maximum/minimum/range

# Pelvis
- parameter: Pelvis Tilt max
  where:
    name: '!Static*'
  set: left
  steps:
    - import: Pelvic Angles
    - eventMask: [$prev, BOF, EOF]
    - max: $prev.x

- parameter: Pelvis Tilt min
  where:
    name: '!Static*'
  set: left
  steps:
    - import: Pelvic Angles
    - eventMask: [$prev, BOF, EOF]
    - min: $prev.x

- parameter: Pelvis Tilt range
  where:
    name: '!Static*'
  set: left
  steps:
    - subtract: [Pelvis Tilt max, Pelvis Tilt min]

# Hips
- parameter: Left Hip Flex max
  where:
    name: '!Static*'
  set: left
  steps:
    - import: Left Hip Angles
    - eventMask: [$prev, BOF, EOF]
    - max: $prev.x

- parameter: Left Hip Flex min
  where:
    name: '!Static*'
  set: left
  steps:
    - import: Left Hip Angles
    - eventMask: [$prev, BOF, EOF]
    - min: $prev.x

- parameter: Left Hip Flex range
  where:
    name: '!Static*'
  set: left
  steps:
    - subtract: [Left Hip Flex max, Left Hip Flex min]

- parameter: Right Hip Flex max
  where:
    name: '!Static*'
  set: right
  steps:
    - import: Right Hip Angles
    - eventMask: [$prev, BOF, EOF]
    - max: $prev.x

- parameter: Right Hip Flex min
  where:
    name: '!Static*'
  set: right
  steps:
    - import: Right Hip Angles
    - eventMask: [$prev, BOF, EOF]
    - min: $prev.x

- parameter: Right Hip Flex range
  where:
    name: '!Static*'
  set: right
  steps:
    - subtract: [Right Hip Flex max, Right Hip Flex min]

# Knees
- parameter: Left Knee Flex max
  where:
    name: '!Static*'
  set: left
  steps:
    - import: Left Knee Angles
    - eventMask: [$prev, BOF, EOF]
    - max: $prev.x

- parameter: Left Knee Flex min
  where:
    name: '!Static*'
  set: left
  steps:
    - import: Left Knee Angles
    - eventMask: [$prev, BOF, EOF]
    - min: $prev.x

- parameter: Left Knee Flex range
  where:
    name: '!Static*'
  set: left
  steps:
    - subtract: [Left Knee Flex max, Left Knee Flex min]

- parameter: Right Knee Flex max
  where:
    name: '!Static*'
  set: right
  steps:
    - import: Right Knee Angles
    - eventMask: [$prev, BOF, EOF]
    - max: $prev.x

- parameter: Right Knee Flex min
  where:
    name: '!Static*'
  set: right
  steps:
    - import: Right Knee Angles
    - eventMask: [$prev, BOF, EOF]
    - min: $prev.x

- parameter: Right Knee Flex range
  where:
    name: '!Static*'
  set: right
  steps:
    - subtract: [Right Knee Flex max, Right Knee Flex min]

# Ankles
- parameter: Left Ankle Flex max
  where:
    name: '!Static*'
  set: left
  steps:
    - import: Left Ankle Angles
    - eventMask: [$prev, BOF, EOF]
    - max: $prev.x

- parameter: Left Ankle Flex min
  where:
    name: '!Static*'
  set: left
  steps:
    - import: Left Ankle Angles
    - eventMask: [$prev, BOF, EOF]
    - min: $prev.x

- parameter: Left Ankle Flex range
  where:
    name: '!Static*'
  set: left
  steps:
    - subtract: [Left Ankle Flex max, Left Ankle Flex min]

- parameter: Right Ankle Flex max
  where:
    name: '!Static*'
  set: right
  steps:
    - import: Right Ankle Angles
    - eventMask: [$prev, BOF, EOF]
    - max: $prev.x

- parameter: Right Ankle Flex min
  where:
    name: '!Static*'
  set: right
  steps:
    - import: Right Ankle Angles
    - eventMask: [$prev, BOF, EOF]
    - min: $prev.x

- parameter: Right Ankle Flex range
  where:
    name: '!Static*'
  set: right
  steps:
    - subtract: [Right Ankle Flex max, Right Ankle Flex min]

# Shoulders
- parameter: Left Shoulder Flex max
  where:
    name: '!Static*'
  set: left
  steps:
    - import: Left Shoulder Angles
    - eventMask: [$prev, BOF, EOF]
    - max: $prev.x

- parameter: Left Shoulder Flex min
  where:
    name: '!Static*'
  set: left
  steps:
    - import: Left Shoulder Angles
    - eventMask: [$prev, BOF, EOF]
    - min: $prev.x

- parameter: Left Shoulder Flex range
  where:
    name: '!Static*'
  set: left
  steps:
    - subtract: [Left Shoulder Flex max, Left Shoulder Flex min]

- parameter: Right Shoulder Flex max
  where:
    name: '!Static*'
  set: right
  steps:
    - import: Right Shoulder Angles
    - eventMask: [$prev, BOF, EOF]
    - max: $prev.x

- parameter: Right Shoulder Flex min
  where:
    name: '!Static*'
  set: right
  steps:
    - import: Right Shoulder Angles
    - eventMask: [$prev, BOF, EOF]
    - min: $prev.x

- parameter: Right Shoulder Flex range
  where:
    name: '!Static*'
  set: right
  steps:
    - subtract: [Right Shoulder Flex max, Right Shoulder Flex min]

# Elbows
- parameter: Left Elbow Flex max
  where:
    name: '!Static*'
  set: left
  steps:
    - import: Left Elbow Angles
    - eventMask: [$prev, BOF, EOF]
    - max: $prev.x

- parameter: Left Elbow Flex min
  where:
    name: '!Static*'
  set: left
  steps:
    - import: Left Elbow Angles
    - eventMask: [$prev, BOF, EOF]
    - min: $prev.x

- parameter: Left Elbow Flex range
  where:
    name: '!Static*'
  set: left
  steps:
    - subtract: [Left Elbow Flex max, Left Elbow Flex min]

- parameter: Right Elbow Flex max
  where:
    name: '!Static*'
  set: right
  steps:
    - import: Right Elbow Angles
    - eventMask: [$prev, BOF, EOF]
    - max: $prev.x

- parameter: Right Elbow Flex min
  where:
    name: '!Static*'
  set: right
  steps:
    - import: Right Elbow Angles
    - eventMask: [$prev, BOF, EOF]
    - min: $prev.x

- parameter: Right Elbow Flex range
  where:
    name: '!Static*'
  set: right
  steps:
    - subtract: [Right Elbow Flex max, Right Elbow Flex min]

# Wrists
- parameter: Left Wrist Flex max
  where:
    name: '!Static*'
  set: left
  steps:
    - import: Left Wrist Angles
    - eventMask: [$prev, BOF, EOF]
    - max: $prev.x

- parameter: Left Wrist Flex min
  where:
    name: '!Static*'
  set: left
  steps:
    - import: Left Wrist Angles
    - eventMask: [$prev, BOF, EOF]
    - min: $prev.x

- parameter: Left Wrist Flex range
  where:
    name: '!Static*'
  set: left
  steps:
    - subtract: [Left Wrist Flex max, Left Wrist Flex min]

- parameter: Right Wrist Flex max
  where:
    name: '!Static*'
  set: right
  steps:
    - import: Right Wrist Angles
    - eventMask: [$prev, BOF, EOF]
    - max: $prev.x

- parameter: Right Wrist Flex min
  where:
    name: '!Static*'
  set: right
  steps:
    - import: Right Wrist Angles
    - eventMask: [$prev, BOF, EOF]
    - min: $prev.x

- parameter: Right Wrist Flex range
  where:
    name: '!Static*'
  set: right
  steps:
    - subtract: [Right Wrist Flex max, Right Wrist Flex min]

# Thorax
- parameter: Thorax Forward Tilt max
  where:
    name: '!Static*'
  set: left
  steps:
    - import: Thorax Angles
    - eventMask: [$prev, BOF, EOF]
    - max: $prev.x

- parameter: Thorax Forward Tilt min
  where:
    name: '!Static*'
  set: left
  steps:
    - import: Thorax Angles
    - eventMask: [$prev, BOF, EOF]
    - min: $prev.x

- parameter: Thorax Forward Tilt range
  where:
    name: '!Static*'
  set: left
  steps:
    - subtract: [Thorax Forward Tilt max, Thorax Forward Tilt min]

# Head
- parameter: Head Forward Tilt max
  where:
    name: '!Static*'
  set: left
  steps:
    - import: Head Angles
    - eventMask: [$prev, BOF, EOF]
    - max: $prev.x

- parameter: Head Forward Tilt min
  where:
    name: '!Static*'
  set: left
  steps:
    - import: Head Angles
    - eventMask: [$prev, BOF, EOF]
    - min: $prev.x

- parameter: Head Forward Tilt range
  where:
    name: '!Static*'
  set: left
  steps:
    - subtract: [Head Forward Tilt max, Head Forward Tilt min]