def value(self, time):
""" Compute each component's interpolation and compose TRS matrix """
translation = translate(self.translate_keyframes.value(time))
rotation = quaternion_matrix(self.rotate_keyframes.value(time))
scaling = scale(self.scale_keyframes.value(time))
return translation @ rotation @ scaling
def value(self, time):
""" Compute each component's interpolation and compose TRS matrix """
T = translate(self.translation_keys.value(time))
R = quaternion_matrix(self.rotate_keys.value(time))
S = scale(self.scale_keys.value(time))
return T @ R @ S
def valueCycle(self, time):
""" Compute each component's interpolation and compose TRS matrix """
result_translation = translate(self.translation.valueCycle(time))
result_rotation = quaternion_matrix(self.rotation.valueCycle(time))
result_scale = scale(self.scale.valueCycle(time))
return result_translation @ result_rotation @ result_scale
def value(self, time):
""" Compute each component's interpolation and compose TRS matrix """
translate_mat = translate(self.translate_keys.value(time))
rotate_mat = quaternion_matrix(self.rotate_keys.value(time))
scale_mat = scale(self.scale_keys.value(time))
# return the composed matrix
return (translate_mat @ rotate_mat @ scale_mat)
def value(self, time):
""" Compute each component's interpolation and compose TRS matrix """
tlerp = self._linterp(time, self.ttimes, self.trans)
slerp = self._linterp(time, self.stimes, self.scale)
rlerp = self._qinterp(time)
rmat = quaternion_matrix(rlerp)
tmat = translate(*tlerp)
smat = scale(slerp)
transformation = tmat @ rmat @ smat
return transformation
def value(self, time):
""" Compute each component's interpolation and compose TRS matrix """
T = self.translation.value(time)
R = quaternion_matrix(self.rotation.value(time))
S = self.scale.value(time)
TRS = np.zeros([4, 4])
TRS[3][3] = 1.
for i in range(3):
TRS[i][3] = T[i]
for i in range(3):
for j in range(3):
TRS[i][j] = R[i][j] * S[i]
return TRS
def value(self, time):
""" Compute each component's interpolation and compose TRS matrix """
T_interp = self.translate.value(time)
R_interp = self.rotate.value(time)
S_interp = self.scale.value(time)
T_interp = np.append(T_interp, 0)
Z = np.zeros((4, 3))
T = np.append(Z, T_interp[:, None], axis=1)
R = quaternion_matrix(R_interp)
S_interp = np.array([S_interp, S_interp, S_interp, 0])
S = np.zeros((3, 4)) + S_interp
S = np.vstack([S, np.array([0, 0, 0, 1])])
return T + np.multiply(R, S)
error = np.mean(np.sum((np_q - tf_q)**2, axis=-1))
print(error)
assert (error < epsilon)
print('Test quaternion to so3')
q_tf = tf.placeholder(shape=[None, 4], dtype=tf.float32)
mat = quaternion_to_so3(q_tf)
np_mats = []
np_q = []
for i in range(batches):
q = (np.random.ranf(4) - .5) * 2.
q /= np.sqrt(np.sum(q**2, axis=-1))
np_mats.append(transform_util.quaternion_matrix(q))
np_q.append(q)
with tf.Session() as sess:
feed_dict = {q_tf: np_q}
tf_mat = sess.run(mat, feed_dict)
error = np.matmul(tf_mat, np.linalg.inv(np_mats)) - np.expand_dims(
np.eye(3), axis=0)
error = np.mean(np.sum((np.reshape(error, (-1, 9)))**2, axis=-1))
#error = np.mean(np.sum((np.reshape(np_mats - tf_mat, (-1, 9))) ** 2, axis=-1))
print(error)
assert (error < epsilon)
def value(self, time):
""" Compute each component's interpolation and compose TRS matrix """
translate_mat = translate(self.translate_keys.value(time))
rotate_mat = quaternion_matrix(self.rotate_keys.value(time))
# scale_mat = vec(self.scale_keys.value(time))
return translate_mat @ rotate_mat #* scale_mat
def get_trs_matrix(self):
""" Get TRS matrix """
return translate(0, self.height_ground,
0) @ self.translation_matrix @ quaternion_matrix(
self.rotation_quaternion) @ self.scale_matrix
