def test_inverse_normalized_random(self):
"""Tests that the inverse function returns normalized quaternions."""
random_quaternion = test_helpers.generate_random_test_quaternions()
inverse_quaternion = quaternion.inverse(random_quaternion)
self.assertAllEqual(
quaternion.is_normalized(inverse_quaternion),
np.ones(shape=random_quaternion.shape[:-1] + (1,), dtype=bool))
def test_from_rotation_matrix_normalized_random(self):
"""Tests that from_rotation_matrix produces normalized quaternions."""
random_matrix = test_helpers.generate_random_test_rotation_matrix_3d()
random_quaternion = quaternion.from_rotation_matrix(random_matrix)
self.assertAllEqual(
quaternion.is_normalized(random_quaternion),
np.ones(shape=random_matrix.shape[:-2] + (1,), dtype=bool))
def test_from_axis_angle_normalized_random(self):
"""Test that from_axis_angle produces normalized quaternions."""
random_axis, random_angle = test_helpers.generate_random_test_axis_angle()
random_quaternion = quaternion.from_axis_angle(random_axis, random_angle)
self.assertAllEqual(
quaternion.is_normalized(random_quaternion),
np.ones(shape=random_angle.shape, dtype=bool))
def test_from_euler_normalized_random(self):
"""Tests that quaternions.from_euler returns normalized quaterions."""
random_euler_angles = test_helpers.generate_random_test_euler_angles()
tensor_shape = random_euler_angles.shape[:-1]
random_quaternion = quaternion.from_euler(random_euler_angles)
self.assertAllEqual(quaternion.is_normalized(random_quaternion),
np.ones(shape=tensor_shape + (1, ), dtype=bool))
def test_normalize_random(self):
"""Tests that normalize works as intended."""
random_quaternion = test_helpers.generate_random_test_quaternions()
tensor_shape = random_quaternion.shape[:-1]
unnormalized_random_quaternion = random_quaternion * 1.01
quat = np.concatenate((random_quaternion, unnormalized_random_quaternion),
axis=0)
mask = np.concatenate(
(np.ones(shape=tensor_shape + (1,),
dtype=bool), np.zeros(shape=tensor_shape + (1,), dtype=bool)),
axis=0)
is_normalized_before = quaternion.is_normalized(quat)
normalized = quaternion.normalize(quat)
is_normalized_after = quaternion.is_normalized(normalized)
self.assertAllEqual(mask, is_normalized_before)
self.assertAllEqual(is_normalized_after,
np.ones(shape=is_normalized_after.shape, dtype=bool))
def test_between_two_vectors_3d_random(self):
"""Checks the extracted rotation between two 3d vectors."""
tensor_size = np.random.randint(3)
tensor_shape = np.random.randint(1, 10, size=(tensor_size)).tolist()
source = np.random.random(tensor_shape + [3]).astype(np.float32)
target = np.random.random(tensor_shape + [3]).astype(np.float32)
rotation = quaternion.between_two_vectors_3d(source, target)
rec_target = quaternion.rotate(source, rotation)
self.assertAllClose(tf.nn.l2_normalize(target, axis=-1),
tf.nn.l2_normalize(rec_target, axis=-1))
# Checks that resulting quaternions are normalized.
self.assertAllEqual(quaternion.is_normalized(rotation),
np.full(tensor_shape + [1], True))
