Pose Estimator Library¶

Input to estimator are loaded and processed by +mocapdb.

grBody¶

+pelib.@grBody.applyTMatrix(obj, pts)¶

Apply the transformation matrix of grBody to points

Example 1:

out = obj.applyTMatrix(struct('LTIO': [0 0 1 1], 'RFEO': [1 0 0 1]))
% out = struct('LTIO', n x 3, 'RFEO', n x 3)

out.LTIO will contain \(^{W}_{LS}\mathbf{T}\) * pts.LTIO. The same logic applies for the other values (w/ the corresponding body frame) of input cell array pts.

Parameters

obj (+pelib.@grBody) – this object instance
pts (cell array) – cell array values indicate which body segment (see keys of +pelib.@grBody.grBody.TMap), struct value = 1 x 4 or n x 4 target point (3D homogenous point) wrt reference body

Returns

out - struct of points (n x 3)

Return type

struct

+pelib.@grBody.calcDOri(obj, ref, targetSeg)¶

Calculate d_ori of lower body grBody as defined in the Marcard paper

T. von Marcard, B. Rosenhahn, M. J. Black, G. P.-M. (2017). Sparse Inertial Poser: Automatic 3D Human Pose Estimation from Sparse IMUs. Eurographics, 36(2)

Parameters

obj – this grBody
ref – reference grBody to be compared with
targetSeg – segments to be computed (usually occluded)

Returns

out - array of d_ori with respect to time

+pelib.@grBody.calcDOrinobias(obj, ref, targetSeg)¶

Calculate d_ori of lower body grBody as defined in the Marcard paper

T. von Marcard, B. Rosenhahn, M. J. Black, G. P.-M. (2017). Sparse Inertial Poser: Automatic 3D Human Pose Estimation from Sparse IMUs. Eurographics, 36(2)

Parameters

obj – this grBody
ref – reference grBody to be compared with
targetSeg – segments to be computed (usually occluded)

Returns

out1 - array of d_ori no bias with respect to time

Returns

out2 - array of bias

+pelib.@grBody.calcDPos(obj, ref, includeRoot)¶

Calculate d_pos of lower body grBody as defined in the Marcard paper

T. von Marcard, B. Rosenhahn, M. J. Black, G. P.-M. (2017). Sparse Inertial Poser: Automatic 3D Human Pose Estimation from Sparse IMUs. Eurographics, 36(2)

Parameters

obj – this grBody
ref – reference grBody to be compared with
includeRoot – [boolean] if root/pelvis is included

Returns

out - array of d_pos with respect to time

+pelib.@grBody.calcDistRotm(prox, angles, seq)¶

Calculate the distal segment orientation rotation matrix

Parameters

prox – quaternion orientation (n x 4) of the proximal segment
angles – joint angles in seq order
seq – (default: YX’Z’’)

Returns

dist - quaternion orientation (n x 4) of the distal segment

+pelib.@grBody.calcJointAcc(obj, pts)¶

Calculate the joint acceleration of grBody

Example 1:

out = obj.calcJointAcc({'LTIO', 'RFEO'})
% out = struct('LTIO', n x 3, 'RFEO', n x 3)

Example 2:

RFA_p_RF = randn(n, 4); RFA_p_RF(:,4) = 1;
     out = obj.calcJointVel(struct('LTIO': [0 0 1 1], 'RFT': RFA_p_RF))
     % out = struct('LTIO', n x 3, 'RFT', n x 3)

the values in the struct denote the position of target point with respect the corresponding body frame (i.e., \(^{B}_{TP}p\)). For example, out.LTIO will contain the acceleration at point \(^{W}_{LS}\mathbf{T}\) * pts.LTIO where \(^{W}_{LS}\mathbf{T}\) is the transformation matrix of the left shanks wrt world frame and pts.LTIO is the position of the target point wrt the left shank frame, giving us the position of the target point wrt world frame. The same logic applies for the other keys (w/ the corresponding body frame) and values of input struct pts.

Parameters

obj (+pelib.@grBody) – this object instance
pts (cell array, struct, optional) – cell array values or struct key indicate which body segment (see keys of +pelib.@grBody.grBody.TMap), struct value = 1 x 4 or n x 4 target point (3D homogenous point) wrt reference body, defaults to cell array with all joints

Returns

out - struct of acceleration

Return type

struct

+pelib.@grBody.calcJointAngles(prox, dist, seq)¶

Calculate distal segment rotation matric from proximal segment and joint angle

Parameters

prox – quaternion orientation (n x 4) of the proximal segment
theta – joint angle in X, Y, Z axis
seq – (default: YX’Z’’)

Returns

theta [x y z] radians

+pelib.@grBody.calcJointVel(obj, pts)¶

Calculate the joint velocity of grBody

Example 1:

out = obj.calcJointVel({'LTIO', 'RFEO'})
% out = struct('LTIO', n x 3, 'RFEO', n x 3)

Example 2:

RFA_p_RF = randn(n, 4); RFA_p_RF(:,4) = 1;
     out = obj.calcJointVel(struct('LTIO': [0 0 1 1], 'RFT': RFA_p_RF))
     % out = struct('LTIO', n x 3, 'RFT', n x 3)

the values in the struct denote the position(s) of target point with respect the corresponding body frame (i.e., \(^{B}_{TP}p\)). For example, out.LTIO will contain the velocity at point \(^{W}_{LS}\mathbf{T}\) * pts.LTIO where \(^{W}_{LS}\mathbf{T}\) is the transformation matrix of the left shanks wrt world frame and pts.LTIO is the position of the target point wrt the left shank frame, giving us the position of the target point wrt world frame. The same logic applies for the other keys (w/ the corresponding body frame) and values of input struct pts.

Parameters

obj (+pelib.@grBody) – this object instance
pts (cell array, struct, optional) – cell array values or struct key indicate which body segment (see keys of +pelib.@grBody.grBody.TMap), struct value = 1 x 4 or n x 4 target point (3D homogenous point) wrt reference body, defaults to cell array with all joints

Returns

out - struct of velocities

Return type

struct

+pelib.@grBody.calcKneeAnglesFromMPLARADist(PELV_CS, LTIB_CS, RTIB_CS, dPelvis, dLFemur, dRFemur, dLTibia, dRTibia, dMPLADist, dMPRADist)¶

Calculate knee angle from 3P dist

Parameters

prox – quaternion orientation (n x 4) of the proximal segment
angles – joint angles in seq order
seq – (default: YX’Z’’)

Returns

dist quaternion orientation (n x 4) of the distal segment

+pelib.@grBody.calcMPLARAdist(obj)¶

Calculate the midpelvis, left ankle, and right ankle distances of grBody

Example:: out = obj.calcMPLARAdist(100) out = struct(‘MPLA’, n x 1, ‘MPRA’, n x 1, ‘LARA’, n x 1)

Parameters: obj – this grBody
Returns: out struct of distances

+pelib.@grBody.calcProxRotm(dist, angles, seq)¶

Calculate the proximal segment orientation rotation matrix

Parameters

dist – quaternion orientation (n x 4) of the distal segment
angles – joint angles in seq order
seq – (default: YX’Z’’)

Returns

dist quaternion orientation (n x 4) of the distal segment

+pelib.@grBody.calcRMSEvsTime(obj1, obj2, includeRoot, targetSeg)¶

Returns the RMSE difference between grBody1 and grBody2 VS time

Parameters

obj1 – grBody 1 (self)
obj1 – grBody 2 (other)
includeRoot – [boolean] if root/pelvis is included
targetSeg – segments to be computed (usually occluded)

Returns

out - struct with the difference of pos and ori parameters

+pelib.@grBody.calcSegAngAcc(obj, segs, frame)¶

Calculate the segment angular acceleration of grBody

Example:: out = obj.calcSegAngAcc({‘LTIB’, ‘RTIB’}) out = struct(‘LTIB’, n x 3, ‘RTIB’, n x 3)

Parameters

obj – this grBody
seg – cell array of segments to be calculated (if blank: all joints)
frame – out is expressed in this frame. B=body (default) or W=world

Returns

out struct of velocities

+pelib.@grBody.calcSegAngVel(obj, segs, frame)¶

Calculate the segment angular velocity of grBody

Example:: out = obj.calcSegAngVel({‘LTIB’, ‘RTIB’}) out = struct(‘LTIB’, n x 3, ‘RTIB’, n x 3)

Parameters

obj – this grBody
seg – cell array of segments to be calculated (if blank: all joints)
frame – out is expressed in this frame. B=body (default) or W=world

Returns

out struct of velocities

+pelib.@grBody.calcTTD(obj1, obj2, intervals, baseStruct)¶

Returns the RMSE and Mean difference between grBody1 and grBody2

Parameters

obj1 – grBody 1 (self)
obj2 – grBody 2 (other, basis)
intervals – interval when total distance is calculated
baseStruct – [Optional] append input struct if defined

Returns

out - struct with the difference of pos and ori parameters

+pelib.@grBody.calcTTDandStepParams(obj1, obj2, intervals, baseStruct)¶

Returns the total travelled distance, stride length, and gait speed

Parameters

obj1 – grBody 1 (self)
obj2 – grBody 2 (other, basis)
intervals – interval when total distance is calculated
baseStruct – [Optional] append input struct if defined

Returns

out - struct with the error report

+pelib.@grBody.changePosUnit(obj, newUnit, update)¶

Change position unit of grBody

Example:: out = obj.getSubset(5:100, segAlias);

Parameters

obj – class grBody (self)
newUnit – new unit
update – If true, update this body, else crease new grBody

Returns

out - grBody class whose data only includes the rows in idx

+pelib.@grBody.changeRefFrame(obj, ref)¶

Change reference frame of grBody Supported changes are vicon -> MIDPEL

Parameters

obj – grBody (self)
ref – reference frame

Returns

out - struct with the difference of pos and ori parameters

+pelib.@grBody.diff(obj1, obj2, seq)¶

Returns the difference between grBody1 and grBody2

Parameters

obj1 – grBody 1 (self)
obj2 – grBody 2 (other)
seq – orientation sequence

Returns

out - struct with the difference of pos and ori parameters

+pelib.@grBody.diffRMSE(obj1, obj2, ref, seq)¶

Returns the RMSE difference between grBody1 and grBody2

Parameters

obj1 – grBody 1 (self)
obj1 – grBody 2 (other)
ref – reference. default: MIDPEL
seq – orientation sequence. default: YXZ

Returns

out - struct with the difference of pos and ori parameters

+pelib.@grBody.diffRMSEandMean(obj1, obj2, includeRoot, targetSeg)¶

Returns the RMSE and Mean difference between grBody1 and grBody2

Parameters

obj1 – grBody 1 (self)
obj1 – grBody 2 (other)
includeRoot – [boolean] if root/pelvis is included
targetSeg – segments to be computed (usually occluded)

Returns

out - struct with the difference of pos and ori parameters

+pelib.@grBody.dumpStepParams(obj1, obj2, intervals, fname)¶

Dump each individual stride length and gait speed to a file

Parameters

obj1 – grBody 1 (self)
obj2 – grBody 2 (other, basis)
intervals – interval when total distance is calculated
fname – output step data to files (fname-<posFieldname>.csv)

+pelib.@grBody.exportc3d(obj, fname, sensors, refBody, lsteps, rsteps, extraMarkers, oriMode, spevents)¶

Generate c3d file

Example:

fname = ‘test.c3d’; sensors = {‘PELVAccX’: (n x 1), ‘PELVAccY’: (n x 1), … }; refBody = actBody;

out = obj.exportc3d(fname, sensors, refBody);

Parameters

obj (+pelib.@grBody) – grBody (self)
fname – output file name
sensors (Optional, struct.) – {‘label’: (n x 1) values to be saved as analog signals … } (e.g. raw acc, gyro, magnetometer)
refBody (Optional, +pelib.@grBody or array of +pelib.@grBody) – reference grBody class
lsteps (Optional, logical array) – (n x 1) logical where it is true during left foot step detection
rsteps (Optional, logical array) – (n x 1) logical where it is true during right foot step detection
extraMarkers – [Optional] extra markers of format struct {‘label’: (n x 3) position values
oriMode – 01 - refBody axis on refBody. obj axis on obj. 02 - refBody and obj axis on obj. 03 - refBody and obj axis on refBody.
oriMode – Optional, integer. Default to 1.
spevents – (n x 1) logical when general event happens
spevents – Optional, logical array

Returns

acq - handle pointer to new btk c3d

+pelib.@grBody.generateBodyFromJointAngles(posMP, qOriMP, anglesLT, anglesRT, angleLK, angleRK, dPelvis, dLFemur, dRFemur, dLTibia, dRTibia, seq)¶

Generate grBody from pelvis pos, ori and joint angles

Parameters

posMP – pelvis (root) position
qOriMP – pelvis (root) orientation
anglesLT – left thigh/femur joint angles (X, Y, Z axis)
anglesRT – right thigh/femur joint angles (X, Y, Z axis)
angleLK – left knee angle (X, Y, Z axis)
angleRK – right knee angle (X, Y, Z axis)
dPelvis – pelvis length
dLFemur – left femur length
dRFemur – right femur length
dLTibia – left tibia length
dRTibia – right tibia length
seq – (default: YX’Z’’)

Returns

out new grBody in world frame

+pelib.@grBody.getSubset(obj, idx)¶

Get subset of grBody

Example:: out = obj.getSubset(5:100, segAlias);

Parameters

obj – class grBody (self)
idx – indices of data to be included in out

Returns

out grBody class whose data only includes the rows in idx

+pelib.@grBody.getTMatrix(obj, pts, idx)¶

Calculate the transformation matrix of grBody

Example 1:

out = obj.getTMatrix({'LTIO', 'RFEO'})
% out = struct('LTIO', 4 x 4 x n, 'RFEO', 4 x 4 x n)

out.LTIO will contain the transformation matrix % \(^{W}_{LS}\mathbf{T}\) which containst that orientation of the left shank centered at pts.LTIO The same logic applies for the other values (w/ the corresponding body frame) of input cell array pts.

Example 2:

out = obj.getTMatrix('LTIO', 1:3)

Parameters

obj (+pelib.@grBody) – this object instance
pts (integer array) – cell array values or characters indicating which body segment (see keys of +pelib.@grBody.grBody.TMap), defaults to cell array with all joints
idx – target indices. defaults to 1:obj.nSamples

Returns

out - struct of transformation matrices (4 x 4 x n) or just the transformation matrix

Return type

struct, matrix

class +pelib.@grBody.grBody(varargin)¶

Bases: matlab.mixin.Copyable

Body class used to animate body and obtain gait parameters

LFEO = None¶: Left ankle joint center

LFEP = None¶: Left knee joint center

LTIO = None¶: Left toe

LTOE = None¶: Right hip joint center

MIDPEL = None¶: Left hip joint center

RFEO = None¶: Right ankle joint center

RFEP = None¶: Right knee joint center

RTIO = None¶: Right toe

RTOE = None¶: pelvis orientation (n x 4), z = upward, x = forward, y = towards left hip joint center

TMap = "struct('MIDPEL', struct('ori', 'qRPV', 'trans', 'MIDPEL'), 'LFEO', struct('ori', 'qLTH', 'trans', 'LFEO'), 'LTIO', struct('ori', 'qLSK', 'trans', 'LTIO'), 'RFEO', struct('ori', 'qRTH', 'trans', 'RFEO'), 'RTIO', struct('ori', 'qRSK', 'trans', 'RTIO'), 'LFT', struct('ori', 'qLFT', 'trans', 'LTIO'), 'RFT', struct('ori', 'qRFT', 'trans', 'RTIO'), 'qRPV', struct('ori', 'qRPV', 'trans', 'MIDPEL'), 'qLTH', struct('ori', 'qLTH', 'trans', 'LFEO'), 'qLSK', struct('ori', 'qLSK', 'trans', 'LTIO'), 'qRTH', struct('ori', 'qRTH', 'trans', 'RFEO'), 'qRSK', struct('ori', 'qRSK', 'trans', 'RTIO'), 'qLFT', struct('ori', 'qLFT', 'trans', 'LTIO'), 'qRFT', struct('ori', 'qRFT', 'trans', 'RTIO') )"¶

axisScale = '0.25'¶

calcJointAnglesLAnkle(idx)¶

Calculate left ankle joint angles (seq: YXZ)

Parameters

obj – this object class
idx – [OPTIONAL] index to be calculated (default: all)

Returns

theta - joint angles (n x 3)

calcJointAnglesLHip(idx)¶

Calculate left hip joint angles (seq: YXZ)

Parameters

obj – this object class
idx – [OPTIONAL] index to be calculated (default: all)

Returns

theta - joint angles (n x 3)

calcJointAnglesLKnee(idx)¶

Calculate left knee joint angles (seq: YXZ)

Parameters

obj – this object class
idx – [OPTIONAL] index to be calculated (default: all)

Returns

theta - joint angles (n x 3)

calcJointAnglesRAnkle(idx)¶

Calculate right ankle joint angles (seq: YXZ)

Parameters

obj – this object class
idx – [OPTIONAL] index to be calculated (default: all)

Returns

theta - joint angles (n x 3)

calcJointAnglesRHip(idx)¶

Calculate right hip joint angles (seq: YXZ)

Parameters

obj – this object class
idx – [OPTIONAL] index to be calculated (default: all)

Returns

theta - joint angles (n x 3)

calcJointAnglesRKnee(idx)¶

Calculate right knee joint angles (seq: YXZ)

Parameters

obj – this object class
idx – [OPTIONAL] index to be calculated (default: all)

Returns

theta - joint angles (n x 3)

calcLFemurLength(idx)¶

Calculate left femur length

Parameters

obj – this object class
idx – [OPTIONAL] index to be calculated (default: 1)

Returns