def test_operators_vector4(self):
v1 = Vector3()
v2 = Vector4([1.,2.,3.,4.])
# add
self.assertRaises(ValueError, lambda: v1 + v2)
# subtract
self.assertRaises(ValueError, lambda: v1 - v2)
# multiply
self.assertRaises(ValueError, lambda: v1 * v2)
# divide
self.assertRaises(ValueError, lambda: v1 / v2)
# or
self.assertRaises(ValueError, lambda: v1 | v2)
# xor
self.assertRaises(ValueError, lambda: v1 ^ v2)
# ==
self.assertRaises(ValueError, lambda: Vector3() == Vector4())
# !=
self.assertRaises(ValueError, lambda: Vector3() != Vector4([1.,1.,1.,1.]))
def test_apply_to_vector_non_unit(self):
q = Quaternion.from_x_rotation(np.pi)
# zero length
v = Vector3([0., 0., 0.])
self.assertTrue(
np.allclose(
q * v,
quaternion.apply_to_vector(
quaternion.create_from_x_rotation(np.pi), [0., 0., 0.])))
# >1 length
v = Vector3([2., 0., 0.])
self.assertTrue(
np.allclose(
q * v,
quaternion.apply_to_vector(
quaternion.create_from_x_rotation(np.pi), [2., 0., 0.])))
v = Vector3([0., 2., 0.])
self.assertTrue(
np.allclose(
q * v,
quaternion.apply_to_vector(
quaternion.create_from_x_rotation(np.pi), [0., 2., 0.])))
v = Vector3([0., 0., 2.])
self.assertTrue(
np.allclose(
q * v,
quaternion.apply_to_vector(
quaternion.create_from_x_rotation(np.pi), [0., 0., 2.])))
def test_operators_vector3(self):
v1 = Vector3()
v2 = Vector3([1.,2.,3.])
# add
self.assertTrue(np.array_equal(v1 + v2, [1.,2.,3.]))
# subtract
self.assertTrue(np.array_equal(v1 - v2, [-1.,-2.,-3.]))
# multiply
self.assertTrue(np.array_equal(v1 * v2, [0.,0.,0.]))
# divide
self.assertTrue(np.array_equal(v1 / v2, [0.,0.,0.]))
# or
self.assertTrue(np.array_equal(v1 | v2, vector3.dot(v1, v2)))
# xor
self.assertTrue(np.array_equal(v1 ^ v2, vector3.cross(v1, v2)))
# ==
self.assertTrue(Vector3() == Vector3())
self.assertFalse(Vector3() == Vector3([1.,1.,1.]))
# !=
self.assertTrue(Vector3() != Vector3([1.,1.,1.]))
self.assertFalse(Vector3() != Vector3())
def test_bitwise(self):
v1 = Vector3([1.,0.,0.])
v2 = Vector3([0.,1.,0.])
# xor (cross)
self.assertTrue(np.array_equal(v1 ^ v2, vector3.cross(v1, v2)))
# or (dot)
self.assertTrue(np.array_equal(v1 | v2, vector3.dot(v1, v2)))
def test_decompose(self):
# define expectations for multiple cases
testsets = [
(Vector3([1, 1, 2],
dtype='f4'), Quaternion.from_y_rotation(np.pi,
dtype='f4'),
Vector3([10, 0, -5], dtype='f4'),
Matrix44([
[-1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, -2, 0],
[10, 0, -5, 1],
],
dtype='f4')),
(Vector3([-1, 3, .5], dtype='f4'),
Quaternion.from_axis_rotation(Vector3([.75, .75, 0],
dtype='f4').normalized,
np.pi,
dtype='f4').normalized,
Vector3([1, -1, 1], dtype='f4'),
Matrix44([
[0, -1, 0, 0],
[3, 0, 0, 0],
[0, 0, -.5, 0],
[1, -1, 1, 1],
],
dtype='f4')),
]
for expected_scale, expected_rotation, expected_translation, expected_model in testsets:
# compose model matrix using original inputs
s = Matrix44.from_scale(expected_scale, dtype='f4')
r = Matrix44.from_quaternion(expected_rotation, dtype='f4')
t = Matrix44.from_translation(expected_translation, dtype='f4')
m = t * r * s
# check that it's the same as the expected matrix
np.testing.assert_almost_equal(np.array(m),
np.array(expected_model))
self.assertTrue(m.dtype == expected_model.dtype)
self.assertTrue(isinstance(m, expected_model.__class__))
# decompose this matrix and recompose the model matrix from the decomposition
ds, dr, dt = m.decompose()
ds = Matrix44.from_scale(ds, dtype='f4')
dr = Matrix44.from_quaternion(dr, dtype='f4')
dt = Matrix44.from_translation(dt, dtype='f4')
dm = dt * dr * ds
# check that it's the same as the original matrix
np.testing.assert_almost_equal(np.array(m), np.array(dm))
self.assertTrue(m.dtype == dm.dtype)
self.assertTrue(isinstance(dm, m.__class__))
def test_operators_number(self):
v1 = Vector3([1.,2.,3.])
fv = np.empty((1,), dtype=[('i', np.int16, 1),('f', np.float32, 1)])
fv[0] = (2, 2.0)
# add
self.assertTrue(np.array_equal(v1 + 1., [2., 3., 4.]))
self.assertTrue(np.array_equal(v1 + 1, [2., 3., 4.]))
self.assertTrue(np.array_equal(v1 + np.float(1.), [2., 3., 4.]))
self.assertTrue(np.array_equal(v1 + fv[0]['f'], [3., 4., 5.]))
self.assertTrue(np.array_equal(v1 + fv[0]['i'], [3., 4., 5.]))
# subtract
self.assertTrue(np.array_equal(v1 - 1., [0., 1., 2.]))
self.assertTrue(np.array_equal(v1 - 1, [0., 1., 2.]))
self.assertTrue(np.array_equal(v1 - np.float(1.), [0., 1., 2.]))
self.assertTrue(np.array_equal(v1 - fv[0]['f'], [-1., 0., 1.]))
self.assertTrue(np.array_equal(v1 - fv[0]['i'], [-1., 0., 1.]))
# multiply
self.assertTrue(np.array_equal(v1 * 2., [2., 4., 6.]))
self.assertTrue(np.array_equal(v1 * 2, [2., 4., 6.]))
self.assertTrue(np.array_equal(v1 * np.float(2.), [2., 4., 6.]))
self.assertTrue(np.array_equal(v1 * fv[0]['f'], [2., 4., 6.]))
self.assertTrue(np.array_equal(v1 * fv[0]['i'], [2., 4., 6.]))
# divide
self.assertTrue(np.array_equal(v1 / 2., [.5, 1., 1.5]))
self.assertTrue(np.array_equal(v1 / 2, [.5, 1., 1.5]))
self.assertTrue(np.array_equal(v1 / np.float(2.), [.5, 1., 1.5]))
self.assertTrue(np.array_equal(v1 / fv[0]['f'], [.5, 1., 1.5]))
self.assertTrue(np.array_equal(v1 / fv[0]['i'], [.5, 1., 1.5]))
# or
self.assertRaises(ValueError, lambda: v1 | .5)
self.assertRaises(ValueError, lambda: v1 | 5)
self.assertRaises(ValueError, lambda: v1 | np.float(2.))
self.assertRaises(ValueError, lambda: v1 | fv[0]['f'])
self.assertRaises(ValueError, lambda: v1 | fv[0]['i'])
# xor
self.assertRaises(ValueError, lambda: v1 ^ .5)
self.assertRaises(ValueError, lambda: v1 ^ 5)
self.assertRaises(ValueError, lambda: v1 ^ np.float(2.))
self.assertRaises(ValueError, lambda: v1 ^ fv[0]['f'])
self.assertRaises(ValueError, lambda: v1 ^ fv[0]['i'])
# ==
self.assertRaises(ValueError, lambda: v1 == .5)
self.assertRaises(ValueError, lambda: v1 == 5)
self.assertRaises(ValueError, lambda: v1 == np.float(2.))
self.assertRaises(ValueError, lambda: v1 == fv[0]['f'])
self.assertRaises(ValueError, lambda: v1 == fv[0]['i'])
# !=
self.assertRaises(ValueError, lambda: v1 != .5)
self.assertRaises(ValueError, lambda: v1 != 5)
self.assertRaises(ValueError, lambda: v1 != np.float(2.))
self.assertRaises(ValueError, lambda: v1 != fv[0]['f'])
self.assertRaises(ValueError, lambda: v1 != fv[0]['i'])
def test_create(self):
v = Vector3()
self.assertTrue(np.array_equal(v, [0.,0.,0.]))
self.assertEqual(v.shape, self._shape)
v = Vector3([1.,2.,3.])
self.assertTrue(np.array_equal(v, [1.,2.,3.]))
self.assertEqual(v.shape, self._shape)
v = Vector3(Vector3())
self.assertTrue(np.array_equal(v, [0.,0.,0.]))
self.assertEqual(v.shape, self._shape)
v4 = [1., 2., 3., 4.]
result = vector3.create_from_vector4(v4)
v, w = result
np.testing.assert_almost_equal(v, [1.,2.,3.], decimal=5)
np.testing.assert_almost_equal(w, 4., decimal=5)
v4 = Vector4([1., 2., 3., 4.])
result = vector3.create_from_vector4(v4)
v, w = result
np.testing.assert_almost_equal(v, [1.,2.,3.], decimal=5)
np.testing.assert_almost_equal(w, 4., decimal=5)
m = Matrix44.from_translation([1.,2.,3.])
v = Vector3.from_matrix44_translation(m)
self.assertTrue(np.array_equal(v, [1.,2.,3.]))
m = Matrix44.from_translation([1.,2.,3.])
v = Vector3(m)
self.assertTrue(np.array_equal(v, [1.,2.,3.]))
def test_normalise(self):
v = Vector3([1., 1., 1.])
np.testing.assert_almost_equal(v.normalised,
[0.57735, 0.57735, 0.57735],
decimal=5)
v.normalise()
np.testing.assert_almost_equal(v, [0.57735, 0.57735, 0.57735],
decimal=5)
def test_create(self):
v = Vector3()
self.assertTrue(np.array_equal(v, [0.,0.,0.]))
self.assertEqual(v.shape, self._shape)
v = Vector3([1.,2.,3.])
self.assertTrue(np.array_equal(v, [1.,2.,3.]))
self.assertEqual(v.shape, self._shape)
v = Vector3(Vector3())
self.assertTrue(np.array_equal(v, [0.,0.,0.]))
self.assertEqual(v.shape, self._shape)
v4 = [1., 2., 3., 4.]
result = vector3.create_from_vector4(v4)
v, w = result
np.testing.assert_almost_equal(v, [1.,2.,3.], decimal=5)
np.testing.assert_almost_equal(w, 4., decimal=5)
v4 = Vector4([1., 2., 3., 4.])
result = vector3.create_from_vector4(v4)
v, w = result
np.testing.assert_almost_equal(v, [1.,2.,3.], decimal=5)
np.testing.assert_almost_equal(w, 4., decimal=5)
m = Matrix44.from_translation([1.,2.,3.])
v = Vector3.from_matrix44_translation(m)
self.assertTrue(np.array_equal(v, [1.,2.,3.]))
m = Matrix44.from_translation([1.,2.,3.])
v = Vector3(m)
self.assertTrue(np.array_equal(v, [1.,2.,3.]))
def test_operators_vector3(self):
q = Quaternion.from_x_rotation(0.5)
v = Vector3([1.,0.,0.])
# add
self.assertRaises(ValueError, lambda: q + v)
# subtract
self.assertRaises(ValueError, lambda: q - v)
# multiply
self.assertTrue(np.array_equal(q * v, quaternion.apply_to_vector(quaternion.create_from_x_rotation(0.5), [1.,0.,0.])))
# divide
self.assertRaises(ValueError, lambda: q / v)
def test_operators_vector3(self):
m = Matrix33.identity()
v = Vector3([1,1,1])
# add
self.assertRaises(ValueError, lambda: m + v)
# subtract
self.assertRaises(ValueError, lambda: m - v)
# multiply
self.assertTrue(np.array_equal(m * v, matrix33.apply_to_vector(matrix33.create_identity(), [1,1,1])))
# divide
self.assertRaises(ValueError, lambda: m / v)
def test_operators_matrix44(self):
v = Vector3()
m = Matrix44.from_x_rotation(0.5)
# add
self.assertRaises(ValueError, lambda: v + m)
# subtract
self.assertRaises(ValueError, lambda: v - m)
# multiply
self.assertRaises(ValueError, lambda: v * m)
# divide
self.assertRaises(ValueError, lambda: v / m)
def test_operators_quaternion(self):
v = Vector3()
q = Quaternion.from_x_rotation(0.5)
# add
self.assertRaises(ValueError, lambda: v + q)
# subtract
self.assertRaises(ValueError, lambda: v - q)
# multiply
self.assertRaises(ValueError, lambda: v * q)
# divide
self.assertRaises(ValueError, lambda: v / q)
def test_from_z_rotation(self):
# 180 degree turn around Z axis
q = Quaternion.from_z_rotation(np.pi)
self.assertTrue(np.allclose(q, [0., 0., 1., 0.]))
self.assertTrue(np.allclose(q * Vector3([1., 0., 0.]), [-1., 0., 0.]))
self.assertTrue(np.allclose(q * Vector3([0., 1., 0.]), [0., -1., 0.]))
self.assertTrue(np.allclose(q * Vector3([0., 0., 1.]), [0., 0., 1.]))
# 90 degree rotation around Z axis
q = Quaternion.from_z_rotation(np.pi / 2.)
self.assertTrue(np.allclose(q, [0., 0., np.sqrt(0.5), np.sqrt(0.5)]))
self.assertTrue(np.allclose(q * Vector3([1., 0., 0.]), [0., 1., 0.]))
self.assertTrue(np.allclose(q * Vector3([0., 1., 0.]), [-1., 0., 0.]))
self.assertTrue(np.allclose(q * Vector3([0., 0., 1.]), [0., 0., 1.]))
# -90 degree rotation around Z axis
q = Quaternion.from_z_rotation(-np.pi / 2.)
self.assertTrue(np.allclose(q, [0., 0., -np.sqrt(0.5), np.sqrt(0.5)]))
self.assertTrue(np.allclose(q * Vector3([1., 0., 0.]), [0., -1., 0.]))
self.assertTrue(np.allclose(q * Vector3([0., 1., 0.]), [1., 0., 0.]))
self.assertTrue(np.allclose(q * Vector3([0., 0., 1.]), [0., 0., 1.]))
def test_accessors(self):
v = Vector3(np.arange(self._size))
self.assertTrue(np.array_equal(v.xy,[0,1]))
self.assertTrue(np.array_equal(v.xyz,[0,1,2]))
self.assertTrue(np.array_equal(v.xz,[0,2]))
self.assertTrue(np.array_equal(v.xyz,[0,1,2]))
self.assertEqual(v.x, 0)
self.assertEqual(v.y, 1)
self.assertEqual(v.z, 2)
v.x = 1
self.assertEqual(v.x, 1)
self.assertEqual(v[0], 1)
v.x += 1
self.assertEqual(v.x, 2)
self.assertEqual(v[0], 2)
def test_create(self):
v = Vector3()
self.assertTrue(np.array_equal(v, [0.,0.,0.]))
self.assertEqual(v.shape, self._shape)
v = Vector3([1.,2.,3.])
self.assertTrue(np.array_equal(v, [1.,2.,3.]))
self.assertEqual(v.shape, self._shape)
v = Vector3(Vector3())
self.assertTrue(np.array_equal(v, [0.,0.,0.]))
self.assertEqual(v.shape, self._shape)
m = Matrix44.from_translation([1.,2.,3.])
v = Vector3.from_matrix44_translation(m)
self.assertTrue(np.array_equal(v, [1.,2.,3.]))
m = Matrix44.from_translation([1.,2.,3.])
v = Vector3(m)
self.assertTrue(np.array_equal(v, [1.,2.,3.]))
def test_create(self):
v = Vector3()
self.assertTrue(np.array_equal(v, [0., 0., 0.]))
self.assertEqual(v.shape, self._shape)
v = Vector3([1., 2., 3.])
self.assertTrue(np.array_equal(v, [1., 2., 3.]))
self.assertEqual(v.shape, self._shape)
v = Vector3(Vector3())
self.assertTrue(np.array_equal(v, [0., 0., 0.]))
self.assertEqual(v.shape, self._shape)
m = Matrix44.from_translation([1., 2., 3.])
v = Vector3.from_matrix44_translation(m)
self.assertTrue(np.array_equal(v, [1., 2., 3.]))
m = Matrix44.from_translation([1., 2., 3.])
v = Vector3(m)
self.assertTrue(np.array_equal(v, [1., 2., 3.]))
def test_from_axis_rotation(self):
q = Quaternion.from_axis_rotation([1., 0., 0.], np.pi / 2.)
self.assertTrue(np.allclose(q, [np.sqrt(0.5), 0., 0., np.sqrt(0.5)]))
self.assertTrue(np.allclose(q * Vector3([1., 0., 0.]), [1., 0., 0.]))
self.assertTrue(np.allclose(q * Vector3([0., 1., 0.]), [0., 0., 1.]))
self.assertTrue(np.allclose(q * Vector3([0., 0., 1.]), [0., -1., 0.]))
def test_create_from_eulers(self):
e = Vector3([1, 2, 3])
m = Matrix44.from_eulers(e)
self.assertTrue(
np.array_equal(m, matrix44.create_from_eulers([1, 2, 3])))
def test_create_from_scale(self):
v = Vector3([1, 2, 3])
m = Matrix44.from_scale(v)
self.assertTrue(np.array_equal(m, np.diag([1, 2, 3, 1])))
def test_inverse(self):
v = Vector3([1.,2.,3.])
self.assertTrue(np.array_equal(v.inverse, [-1.,-2.,-3.]))
def test_from_z_rotation(self):
q = Quaternion.from_z_rotation(np.pi / 2.)
self.assertTrue(np.allclose(q*Vector3([1.,0.,0.]), [0.,-1.,0.]))
self.assertTrue(np.allclose(q*Vector3([0.,1.,0.]), [1.,0.,0.]))
self.assertTrue(np.allclose(q*Vector3([0.,0.,1.]), [0.,0.,1.]))
def test_normalize(self):
v = Vector3([1.,1.,1.])
np.testing.assert_almost_equal(np.array(v.normalized), [0.57735, 0.57735, 0.57735], decimal=5)
v.normalize()
np.testing.assert_almost_equal(np.array(v), [0.57735, 0.57735, 0.57735], decimal=5)