"rfemur": "RThigh",
"rtibia": "RLeg",
"rfoot": "RFoot",
"rtoes": "RToes",
}
targetmap = {}
for mocap_joint, rest_joint in joint_map.items():
# if rest_joint not in ["RHand", "LHand"]:
anim.rotations[:, rest_map[rest_joint]] += mocap.rotations[:, mocap_map[
mocap_joint]]
targetmap[rest_map[rest_joint]] = targets[:, mocap_map[mocap_joint]]
ik = JacobianInverseKinematics(anim,
targetmap,
iterations=5000,
damping=7,
silent=False)
ik()
BVH.save(retargetpath, anim, rest_names, 1.0 / 25, order='xyz')
############################################################################################
with open(constraintpath, 'r') as f:
content = f.readlines()
content = [x.strip() for x in content]
joints = [list(filter(None, c.split('\t'))) for c in content]
from bvh import Bvh
with open(retargetpath) as f:
print('%i of %i Processing %s' % (i + 1, len(database), filename))
hdm05anim, names, ftime = BVH.load(filename)
anim_scale = np.sqrt(np.mean(hdm05anim.offsets**2))
targets = Animation.positions_global(hdm05anim)
anim = rest.copy()
anim.positions = anim.positions.repeat(len(targets), axis=0)
anim.rotations.qs = anim.rotations.qs.repeat(len(targets), axis=0)
anim.positions[:, 0] = targets[:, 0]
anim.rotations[:, :] = hdm05anim.rotations[:, :]
targetmap = {}
for ti in range(targets.shape[1]):
targetmap[ti] = targets[:, ti]
ik = JacobianInverseKinematics(anim,
targetmap,
iterations=10,
damping=2.0,
silent=True)
ik()
BVH.save(
'./hdm05/' +
os.path.split(filename)[1].replace('/', '_').replace('\\', '_'), anim,
names, 1.0 / 120)
def retarget_skeleton(self, normalizedPose):
"""
Retargets the Panoptic Skeleton onto CMU skeleton
:param normalizedPose: Panoptic skeleton (57, F)
:return: retargeted animation
"""
# reshape
normalizedPose = np.transpose(normalizedPose) # (frames,57)
normalizedPose = normalizedPose.reshape(normalizedPose.shape[0], 19,
3) # (frames,19,3)
# Flip Y axis
normalizedPose[:, :, 1] = -normalizedPose[:, :, 1]
# calculate panoptic height
panopticThigh = normalizedPose[:, 6, :] - normalizedPose[:, 7, :]
panopticThigh = panopticThigh**2
panopticHeight = np.mean(np.sqrt(np.sum(panopticThigh, axis=1)))
# load the rest skeleton
rest, names, _ = BVH.load('meta/rest.bvh') # temp
# create a mock animation for the required duration
anim = rest.copy()
anim.positions = anim.positions.repeat(normalizedPose.shape[0], axis=0)
anim.rotations.qs = anim.rotations.qs.repeat(normalizedPose.shape[0],
axis=0)
# get the FK solved global positions
cmuMocapJoints = Animation.positions_global(anim)
# calculate CMU skeleton height
cmuThigh = cmuMocapJoints[:, 2, :] - cmuMocapJoints[:, 3, :]
cmuThigh = cmuThigh**2
cmuMocapHeight = np.mean(np.sqrt(np.sum(cmuThigh, axis=1)))
cmuMocapHeight = cmuMocapHeight * 0.9
# scale the skelton appropriately
scaleRatio = cmuMocapHeight / panopticHeight
print("cmuMocapHeight: %f, panopticHeight %f, scaleRatio: %f " %
(cmuMocapHeight, panopticHeight, scaleRatio))
normalizedPose = normalizedPose * scaleRatio # rescaling
# compute mean across vector
across1 = normalizedPose[:,
3] - normalizedPose[:,
9] # Right -> left (3) Shoulder
across0 = normalizedPose[:,
6] - normalizedPose[:,
12] # Right -> left (6) Hips
across = across0 + across1 # frame x 3
across = across / np.sqrt(
(across**2).sum(axis=-1))[...,
np.newaxis] ##frame x 3. Unit vectors
# compute forward direction
forward = np.cross(across, np.array([[0, -1, 0]]))
forward = forward / np.sqrt((forward**2).sum(axis=-1))[..., np.newaxis]
target = np.array([[0, 0, 1]]).repeat(len(forward), axis=0)
# Set root's movement by hipCenter joints (idx=2)
anim.positions[:, 0] = normalizedPose[:, 2] + np.array([0.0, 2.4, 0.0])
anim.rotations[:, 0:1] = -Quaternions.between(forward,
target)[:, np.newaxis]
targetmap = {}
for k in self.mapping:
targetmap[k] = normalizedPose[:, self.mapping[k], :]
# Retarget using JacobianIK
ik = JacobianInverseKinematics(anim,
targetmap,
iterations=20,
damping=10.0,
silent=True)
ik()
# scale skeleton appropriately
anim.positions = anim.positions * 6.25
anim.offsets = anim.offsets * 6.25
# Do FK recover 3D joint positions, select required Joints only
positions = Animation.positions_global(anim)
positions = positions[:, self.jointIdx]
return positions
18: 12,
19: 13,
20: 14,
25: 8,
26: 9,
27: 10,
}
targetmap = {}
for k in mapping:
targetmap[k] = xsenstargets[:, mapping[k]]
ik = JacobianInverseKinematics(xanim,
targetmap,
iterations=10,
damping=2.0,
silent=False)
ik()
BVH.save('./edin_xsens/capture_%03i.bvh' % i, xanim, names, 1.0 / 120)
#########
kinecttargets = io.loadmat('../external/edin_kinect/' + kin +
'.mat')['skel'].astype(np.float)
kinecttargets = kinecttargets[kin_start:kin_stop, kin_skel, :, :3]
kinecttargets = interpolate.griddata(np.linspace(0, 1,
len(kinecttargets) * 1),
kinecttargets,
def jac_anim_for_projection_sparse(
x, skeleton, curPose3D, rootTrans, curPose2D, floorNormal, floorPoint,
pointWeights, data_joint_weights, valid3DInd, valid2DInd,
jointsSmoothnessWeights, velConstraints, projWeight,
smoothnessWeightVel, smoothnessWeightAcc, dataWeight, velWeight,
floorWeight):
''' calc jacobian '''
noFrames = curPose3D.shape[0]
noProjPts = curPose3D.shape[1]
valid3DInd = np.arange(noProjPts)
valid2DInd = np.arange(noProjPts)
noPts = curPose3D.shape[1]
#forward kinematics
x = np.reshape(x, [noFrames, -1])
root = x[:, :3]
angles = x[:, 3:]
anim = skeleton.copy()
anim.orients.qs = skeleton.orients.qs.copy()
anim.offsets = skeleton.offsets.copy()
anim.positions = skeleton.positions.repeat(noFrames, axis=0)
anim.rotations = Quaternions.from_euler(angles.reshape(
(noFrames, noPts, 3)),
order='xyz',
world=True)
poses3D = Animation.positions_global(anim)
poses3D[:, 0] = root
y = 0 * poses3D
for j in range(poses3D.shape[1]):
y[:, j, :] = poses3D[:, BACKWARD_MAPPING[j], :]
y = np.reshape(y, [-1]) #[root positions; joint positions]
#calculate jacobian dE/dP = np.zeros((noTerms, noFrames * noPts * 3))
jac_dp = jac_root_all_for_projection(y,
curPose3D,
curPose2D,
floorNormal,
floorPoint,
pointWeights,
data_joint_weights,
valid3DInd,
valid2DInd,
jointsSmoothnessWeights,
velConstraints,
projWeight,
smoothnessWeightVel,
smoothnessWeightAcc,
dataWeight,
velWeight,
floorWeight,
root_idx=ROOT_IDX)
#calculate jocabian dP/dR = np.zeros((noFrames * (noPts * 3) * (noPts * 3))
targetmap = {}
for ee in range(poses3D.shape[1] - 1):
targetmap[ee + 1] = poses3D[:, ee + 1]
ik = JacobianInverseKinematics(anim,
targetmap,
translate=False,
iterations=50,
damping=2,
silent=False)
gt = Animation.transforms_global(anim)
gp = gt[:, :, :, 3]
gp = gp[:, :, :3] / gp[:, :, 3, np.newaxis]
gr = Quaternions.from_transforms(gt)
""" Calculate Descendants """
descendants = AnimationStructure.descendants_mask(anim.parents)
tdescendants = np.eye(anim.shape[1]) + descendants
first_descendants = descendants[:, 1:].repeat(3, axis=0).astype(int)
first_tdescendants = tdescendants[:, 1:].repeat(3, axis=0).astype(int)
jac_dr = ik.jacobian(angles, gp, gr, ik.targets, first_descendants,
first_tdescendants)
#full jacobian dE/dR
noVars = (noPts + 1) * 3
jac = np.zeros((jac_dp.shape[0], noFrames * noVars))
# print("jac dimension is %d %d" % (jac.shape[0], jac.shape[1]))
for fr in range(noFrames):
varIndex1 = fr * noPts * 3
varIndex2 = fr * noVars
jt1 = jac_dp[:, varIndex1:varIndex1 + noPts * 3]
jt2 = np.zeros(jt1.shape)
for p in range(noPts):
q = FORWARD_MAPPING[p]
jt2[:, p * 3:p * 3 + 3] = jt1[:, q * 3:q * 3 + 3]
jt = np.zeros((jac_dp.shape[0], noVars))
jt[:, :3] = jt2[:, :3]
jt[:, 3:] = np.matmul(jt2[:, 3:], jac_dr[fr])
jac[:, varIndex2:varIndex2 + noVars] = jt
# smoothness term for euler angle velocity
jac_smooth = np.zeros(((noFrames - 1) * noVars, noFrames * noVars))
count = 0
for fr in range(noFrames - 1):
varIndex = fr * noVars
varIndexNext = (fr + 1) * noVars
for j in range(noPts + 1):
jac_smooth[count + 0,
varIndex + 0] = smoothnessWeightVel * SMOOTH_VEL_EULER_X
jac_smooth[count + 1,
varIndex + 1] = smoothnessWeightVel * SMOOTH_VEL_EULER_Y
jac_smooth[count + 2,
varIndex + 2] = smoothnessWeightVel * SMOOTH_VEL_EULER_Z
jac_smooth[count + 0, varIndexNext +
0] = -smoothnessWeightVel * SMOOTH_VEL_EULER_X
jac_smooth[count + 1, varIndexNext +
1] = -smoothnessWeightVel * SMOOTH_VEL_EULER_Y
jac_smooth[count + 2, varIndexNext +
2] = -smoothnessWeightVel * SMOOTH_VEL_EULER_Z
count = count + 3
varIndex = varIndex + 3
varIndexNext = varIndexNext + 3
jac = np.concatenate((jac, jac_smooth), axis=0)
jac_sparse = sparse.lil_matrix(jac)
return jac_sparse