def test_from_axis_angle(self):
"""Test generation of a quaternion from axis angle specification"""
result = Quaternion.from_axis_angle(Vector3D(1, 0, 0), 45)
answer = Quaternion(0.3826834323650898, 0.0, 0.0, 0.9238795325112867)
self.assertAlmostEqual(answer.x, result.x, delta=1e-10,
msg="Converting axis angle to quaternion produced wrong result [X].")
self.assertAlmostEqual(answer.y, result.y, delta=1e-10,
msg="Converting axis angle to quaternion produced wrong result [Y].")
self.assertAlmostEqual(answer.z, result.z, delta=1e-10,
msg="Converting axis angle to quaternion produced wrong result [Z].")
self.assertAlmostEqual(answer.s, result.s, delta=1e-10,
msg="Converting axis angle to quaternion produced wrong result [S].")
result = Quaternion.from_axis_angle(Vector3D(0.5, 0.5, 0), -30)
answer = Quaternion(-0.1830127018922193, -0.1830127018922193, -0.0, 0.9659258262890683)
self.assertAlmostEqual(answer.y, result.y, delta=1e-10,
msg="Converting axis angle to quaternion produced wrong result [Y].")
self.assertAlmostEqual(answer.z, result.z, delta=1e-10,
msg="Converting axis angle to quaternion produced wrong result [Z].")
self.assertAlmostEqual(answer.x, result.x, delta=1e-10,
msg="Converting axis angle to quaternion produced wrong result [X].")
self.assertAlmostEqual(answer.s, result.s, delta=1e-10,
msg="Converting axis angle to quaternion produced wrong result [S].")
def test_length(self):
"""Get/set the vector length."""
v = Vector3D(1.2, -3, 9.8)
# get length
r = sqrt(1.2 * 1.2 + 3 * 3 + 9.8 * 9.8)
self.assertAlmostEqual(v.length,
r,
places=14,
msg="Vector3D returned incorrect length.")
# set length
v.length = 10.0
rx = 1.2 / sqrt(1.2 * 1.2 + 3 * 3 + 9.8 * 9.8) * 10
ry = -3 / sqrt(1.2 * 1.2 + 3 * 3 + 9.8 * 9.8) * 10
rz = 9.8 / sqrt(1.2 * 1.2 + 3 * 3 + 9.8 * 9.8) * 10
self.assertAlmostEqual(v.x, rx, 14,
"Vector3D length was not set correctly [X].")
self.assertAlmostEqual(v.y, ry, 14,
"Vector3D length was not set correctly [Y].")
self.assertAlmostEqual(v.z, rz, 14,
"Vector3D length was not set correctly [Z].")
# trying to rescale a zero length vector should raise a ZeroDivisionError
v = Vector3D(0, 0, 0)
with self.assertRaises(
ZeroDivisionError,
msg=
"Adjusting length of zero length vector did not raise a ZeroDivisionError."
):
v.length = 10.0
def test_transform(self):
# transform between space 1 and space 2
m = rotate_z(47)
# define in coordinate space 1
v1 = Vector3D(1, 0.3, -0.2)
q1 = Quaternion.from_axis_angle(Vector3D(0.1, -0.7, 0.2), 57)
# transform to coordinate space 2
v2 = v1.transform(m)
q2 = q1.transform(m)
# use quaternion to rotate vector in each space
r1 = v1.transform(q1.as_matrix())
r2 = v2.transform(q2.as_matrix())
# convert result in space 2 to space 1 for comparison
r2_1 = r2.transform(m.inverse())
self.assertAlmostEqual(r1.x,
r2_1.x,
delta=1e-10,
msg='Transform failed [X]')
self.assertAlmostEqual(r1.y,
r2_1.y,
delta=1e-10,
msg='Transform failed [Y]')
self.assertAlmostEqual(r1.z,
r2_1.z,
delta=1e-10,
msg='Transform failed [Z]')
def test_add_vector(self):
v = [-1e10, -7, -0.001, 0.0, 0.00003, 10, 2.3e49]
c1 = Vector3D(3, 4, 5)
c2 = Vector3D(5, 12, 13)
r1 = c1 + self.vf1
r2 = self.vf1 + c2
for x in v:
for y in v:
self.assertEqual(r1(x, y), c1 + self.refv1(x, y), "vector3d.Function2D add Vector3D (V + vf()) did not match reference function value.")
self.assertEqual(r2(x, y), self.refv1(x, y) + c2, "vector3d.Function2D add Vector3D (vf() + V) did not match reference function value.")
def test_sub_vector(self):
v = [-1e10, -7, -0.001, 0.0, 0.00003, 10, 2.3e49]
c1 = Vector3D(3, 4, 5)
c2 = Vector3D(5, 12, 13)
r1 = c1 - self.vf1
r2 = self.vf1 - c2
for x in v:
for y in v:
self.assertEqual(r1(x, y), c1 - self.refv1(x, y), "vector3d.Function2D subtract Vector3D (V - vf()) did not match reference function value.")
self.assertEqual(r2(x, y), self.refv1(x, y) - c2, "vector3d.Function2D subtract Vector3D (vf() - V) did not match reference function value.")
def test_subtract(self):
"""Subtract operator."""
# Vector3D - Vector3D, returns Vector3D
a = Vector3D(-1.4, 0.2, 99.1)
b = Vector3D(0.7, -64.0, -0.1)
r = a - b
self.assertTrue(isinstance(r, Vector3D),
"Vector3D - Vector3D did not return a Vector3D.")
self.assertEqual(r.x, -1.4 - 0.7, "Vector3D - Vector3D failed [X].")
self.assertEqual(r.y, 0.2 + 64.0, "Vector3D - Vector3D failed [Y].")
self.assertEqual(r.z, 99.1 + 0.1, "Vector3D - Vector3D failed [Z].")
def test_add(self):
"""Add operator."""
# Vector3D + Vector3D, returns Vector3D
a = Vector3D(-1.4, 0.2, 99.1)
b = Vector3D(0.7, -64.0, -0.1)
r = a + b
self.assertTrue(isinstance(r, Vector3D),
"Vector3D + Vector3D did not return a Vector3D.")
self.assertEqual(r.x, -1.4 + 0.7, "Vector3D + Vector3D failed [X].")
self.assertEqual(r.y, 0.2 - 64.0, "Vector3D + Vector3D failed [Y].")
self.assertEqual(r.z, 99.1 - 0.1, "Vector3D + Vector3D failed [Z].")
def setUp(self):
self.refv1 = lambda x, y, z: Vector3D(10 * x + 5 * y + z, 10 * x - 5 * y - 2 * z, x + y + z)
self.refv2 = lambda x, y, z: Vector3D(x * x + y * y + z * z, x * x - y * y - z * z, x * y * z)
self.vf1 = PythonVector3DFunction3D(self.refv1)
self.vf2 = PythonVector3DFunction3D(self.refv2)
self.ref1 = lambda x, y, z: 10 * x + 5 * y + z
self.ref2 = lambda x, y, z: x * x + y * y + z * z
self.f1 = PythonFloatFunction3D(self.ref1)
self.f2 = PythonFloatFunction3D(self.ref2)
def setUp(self):
self.refv1 = lambda x, y: Vector3D(10 * x + 5 * y, 10 * x - 5 * y, x + y)
self.refv2 = lambda x, y: Vector3D(x * x + y * y, x * x - y * y, x * y)
self.vf1 = PythonVector3DFunction2D(self.refv1)
self.vf2 = PythonVector3DFunction2D(self.refv2)
self.ref1 = lambda x, y: 10 * x + 5 * y
self.ref2 = lambda x, y: x * x + y * y
self.f1 = PythonFloatFunction2D(self.ref1)
self.f2 = PythonFloatFunction2D(self.ref2)
def setUp(self):
self.refv1 = lambda x: Vector3D(10 * x + 5, 10 * x - 5, x)
self.refv2 = lambda x: Vector3D(x * x + 25, x * x - 25, x * 5)
self.vf1 = PythonVector3DFunction1D(self.refv1)
self.vf2 = PythonVector3DFunction1D(self.refv2)
self.ref1 = lambda x: 10 * x + 5
self.ref2 = lambda x: x * x
self.f1 = PythonFloatFunction1D(self.ref1)
self.f2 = PythonFloatFunction1D(self.ref2)
def test_lerp(self):
"""Testing method lerp()."""
a = Vector3D(1, 0, 0)
b = Vector3D(0, 1, 0)
self.assertEqual(
a.lerp(b, 0), Vector3D(1, 0, 0),
"Lerp (linear vector interpolation) operation failed.")
self.assertEqual(
a.lerp(b, 1), Vector3D(0, 1, 0),
"Lerp (linear vector interpolation) operation failed.")
self.assertEqual(
a.lerp(b, 0.5), Vector3D(0.5, 0.5, 0.0),
"Lerp (linear vector interpolation) operation failed.")
def test_initialise_indexable(self):
"""Initialisation with an indexable object."""
v = Vector3D(1.0, 2.0, 3.0)
self.assertEqual(v.x, 1.0, "Initialisation with indexable failed [X].")
self.assertEqual(v.y, 2.0, "Initialisation with indexable failed [Y].")
self.assertEqual(v.z, 3.0, "Initialisation with indexable failed [Z].")
def test_vector_cross(self):
"""Cross product."""
a = Vector3D(3, -4, 5)
b = Normal3D(6, 3, -9)
# Vector3D x Normal3D
r = a.cross(b)
self.assertTrue(isinstance(r, Vector3D),
"Cross did not return a Vector3D.")
self.assertEqual(r.x, a.y * b.z - b.y * a.z,
"Cross product failed [X].")
self.assertEqual(r.y, b.x * a.z - a.x * b.z,
"Cross product failed [Y].")
self.assertEqual(r.z, a.x * b.y - b.x * a.y,
"Cross product failed [Z].")
# Normal3D x Vector3D
r = b.cross(a)
self.assertTrue(isinstance(r, Vector3D),
"Cross did not return a Vector3D.")
self.assertEqual(r.x, b.y * a.z - a.y * b.z,
"Cross product failed [X].")
self.assertEqual(r.y, a.x * b.z - b.x * a.z,
"Cross product failed [Y].")
self.assertEqual(r.z, b.x * a.y - a.x * b.y,
"Cross product failed [Z].")
def test_negate(self):
"""Negate operator."""
r = -Vector3D(2.5, 6.7, -4.6)
self.assertEqual(r.x, -2.5, "Negation failed [X].")
self.assertEqual(r.y, -6.7, "Negation failed [Y].")
self.assertEqual(r.z, 4.60, "Negation failed [Z].")
def test_rotate_vector(self):
"""Rotation about vector matrix factory function."""
m = rotate_vector(54, Vector3D(1.0, 0.22, 0.34))
s = sin(pi*54/180)
c = cos(pi*54/180)
x = 1.0
y = 0.22
z = 0.34
# normalise
l = sqrt(x * x + y * y + z * z)
x = x / l
y = y / l
z = z / l
r = [[x*x+(1-x*x)*c, x*y*(1-c)-z*s, x*z*(1-c)+y*s, 0],
[x*y*(1-c)+z*s, y*y+(1-y*y)*c, y*z*(1-c)-x*s, 0],
[x*z*(1-c)-y*s, y*z*(1-c)+x*s, z*z+(1-z*z)*c, 0],
[0, 0, 0, 1]]
for i, row in enumerate(r):
for j, v in enumerate(row):
self.assertAlmostEqual(m[i, j], v, places=14, msg="Rotate_vector matrix generation failed (R"+str(i)+", C"+str(j)+").")
def test_indexing(self):
"""Getting/setting components by indexing."""
v = Vector3D(2.5, 6.7, -4.6)
v[0] = 1.0
v[1] = 2.0
v[2] = 7.0
# check getting/setting via valid indexes
self.assertEqual(v[0], 1.0, "Indexing failed [X].")
self.assertEqual(v[1], 2.0, "Indexing failed [Y].")
self.assertEqual(v[2], 7.0, "Indexing failed [Z].")
# check invalid indexes
with self.assertRaises(
IndexError,
msg="Invalid positive index did not raise IndexError."):
r = v[4]
with self.assertRaises(
IndexError,
msg="Invalid negative index did not raise IndexError."):
r = v[-1]
def test_divide(self):
"""Division operator."""
v = Vector3D(-1.4, 0.2, 99.1)
# Vector3D / c, returns Vector3D
r = v / 5.3
self.assertTrue(isinstance(r, Vector3D),
"Vector3D * c did not return a Vector3D.")
self.assertEqual(r.x, -1.4 / 5.3, "Vector3D * c failed [X].")
self.assertEqual(r.y, 0.20 / 5.3, "Vector3D * c failed [Y].")
self.assertEqual(r.z, 99.1 / 5.3, "Vector3D * c failed [Z].")
# dividing by zero should raise a ZeroDivisionError
with self.assertRaises(
ZeroDivisionError,
msg="Dividing by zero did not raise a ZeroDivisionError."):
r = v / 0.0
# any other division operations should raise TypeError
with self.assertRaises(
TypeError,
msg="Undefined division did not raised a TypeError."):
r = 54.2 / v
with self.assertRaises(
TypeError,
msg="Undefined division did not raised a TypeError."):
r = v / v
def test_richcmp_function2d_function2d(self):
v = [-1e10, -7, -0.001, 0.0, 0.00003, 10, 2.3e49]
for x in v:
for y in v:
ref_value = self.vf1
shift = Vector3D(*[abs(r) + 1 for r in self.refv1(x, y)])
not_ref_value = self.vf1 + shift
self.assertEqual(
(self.vf1 == ref_value)(x, y),
1.0,
msg=
"vector3d.Function2D equals vector3d.Function2D (vf1() == vf2()) did not return true when it should."
)
self.assertEqual(
(self.vf1 == not_ref_value)(x, y),
0.0,
msg=
"vector3d.Function2D equals vector3d.Function2D (vf1() == vf2()) did not return false when it should."
)
self.assertEqual(
(self.vf1 != not_ref_value)(x, y),
1.0,
msg=
"vector3d.Function2D not equals vector3d.Function2D (vf1() != vf2()) did not return true when it should."
)
self.assertEqual(
(self.vf1 != ref_value)(x, y),
0.0,
msg=
"vector3d.Function2D not equals vector3d.Function2D (vf1() != vf2()) did not return false when it should."
)
def test_rotate_basis(self):
"""Rotation specified by a pair of basis vectors."""
# valid vectors
m = rotate_basis(Vector3D(1.0, 0.0, 0.0), Vector3D(0.0, -1.0, 0.0))
r = [[0, 0, 1, 0],
[0, -1, 0, 0],
[1, 0, 0, 0],
[0, 0, 0, 1]]
for i, row in enumerate(r):
for j, v in enumerate(row):
self.assertAlmostEqual(m[i, j], v, places=14, msg="Rotate_basis matrix generation failed (R"+str(i)+", C"+str(j)+").")
# invalid, coincident vectors
with self.assertRaises(ValueError, msg="Coincident forward and up vectors did not raise a ValueError."):
rotate_basis(Vector3D(1, 2, 3), Vector3D(1, 2, 3))
def test_constant(self):
v = [-1e10, -7, -0.001, 0.0, 0.00003, 10, 2.3e49]
for x in v:
for y in v:
for z in v:
vector = Vector3D(x, y, z)
constant = Constant2D(vector)
self.assertEqual(constant(500, -1.5), vector,
"vector3d.Constant2D call did not match reference value.")
def test_richcmp_vector(self):
v = [-1e10, -7, -0.001, 0.0, 0.00003, 10, 2.3e49]
for x in v:
for y in v:
for z in v:
ref_value = self.refv1(x, y, z)
not_ref_value = ref_value + Vector3D(
*[ref + abs(ref) + 1 for ref in ref_value])
self.assertEqual(
(self.vf1 == ref_value)(x, y, z),
1.0,
msg=
"vector3d.Function3D equals Vector3D (vf() == V) did not return true when it should."
)
self.assertEqual(
(ref_value == self.vf1)(x, y, z),
1.0,
msg=
"Vector3D equals vector3d.Function3D(V == vf()) did not return true when it should."
)
self.assertEqual(
(self.vf1 == not_ref_value)(x, y, z),
0.0,
msg=
"vector3d.Function3D equals Vector3D (vf() == V) did not return false when it should."
)
self.assertEqual(
(not_ref_value == self.vf1)(x, y, z),
0.0,
msg=
"Vector3D equals vector3d.Function3D(V == vf()) did not return false when it should."
)
self.assertEqual(
(self.vf1 != not_ref_value)(x, y, z),
1.0,
msg=
"vector3d.Function3D not equals Vector3D (vf() != V) did not return true when it should."
)
self.assertEqual(
(not_ref_value != self.vf1)(x, y, z),
1.0,
msg=
"Vector3D not equals vector3d.Function3D(V != vf()) did not return true when it should."
)
self.assertEqual(
(self.vf1 != ref_value)(x, y, z),
0.0,
msg=
"vector3d.Function3D not equals Vector3D (vf() != V) did not return false when it should."
)
self.assertEqual(
(ref_value != self.vf1)(x, y, z),
0.0,
msg=
"Vector3D not equals vector3d.Function3D(V != vf()) did not return false when it should."
)
def test_orthogonal(self):
v = Vector3D(1.0, 2.0, 3.0)
r = v.orthogonal()
self.assertAlmostEqual(
v.dot(r),
0.0,
delta=1e-10,
msg="Orthogonal did not return an orthogonal vector.")
def test_initialise_default(self):
"""Default initialisation, unit vector pointing along z-axis."""
v = Vector3D()
self.assertEqual(v.x, 0.0,
"Default initialisation is not (0,0,1) [X].")
self.assertEqual(v.y, 0.0,
"Default initialisation is not (0,0,1) [Y].")
self.assertEqual(v.z, 1.0,
"Default initialisation is not (0,0,1) [Z].")
def test_z(self):
"""Get/set z co-ordinate."""
v = Vector3D(2.5, 6.7, -4.6)
# get z attribute
self.assertEqual(v.z, -4.6, "Getting z attribute failed.")
# set z attribute
v.z = 157.3
self.assertEqual(v.z, 157.3, "Setting z attribute failed.")
def test_iter(self):
"""Obtain values by iteration."""
v = Vector3D(2.5, 6.7, -4.6)
l = list(v)
self.assertEqual(
len(l), 3,
"Iteration failed to return the correct number of items.")
self.assertEqual(l[0], 2.5, "Iteration failed [X].")
self.assertEqual(l[1], 6.7, "Iteration failed [Y].")
self.assertEqual(l[2], -4.6, "Iteration failed [Z].")
def test_x(self):
"""Get/set x co-ordinate."""
v = Vector3D(2.5, 6.7, -4.6)
# get x attribute
self.assertEqual(v.x, 2.5, "Getting x attribute failed.")
# set x attribute
v.x = 10.0
self.assertEqual(v.x, 10.0, "Setting x attribute failed.")
def test_y(self):
"""Get/set y co-ordinate."""
v = Vector3D(2.5, 6.7, -4.6)
# get y attribute
self.assertEqual(v.y, 6.7, "Getting y attribute failed.")
# set y attribute
v.y = -7.1
self.assertEqual(v.y, -7.1, "Setting y attribute failed.")
def test_scalar_to_vector(self):
vx = 1 # Will be auto-wrapped to Constant1D
vy = Arg1D()
vz = Sin1D(Arg1D('x'))
fv = FloatToVector3DFunction1D(vx, vy, vz)
v = [-1e10, -7, -0.001, 0.0, 0.00003, 10, 2.3e49]
for x in v:
expected = Vector3D(1, x, sin(x))
actual = fv(x)
self.assertEqual(actual, expected,
"FloatToVector3DFunction1D call did not match reference value.")
def test_vector_initialise(self):
"""Initialisation."""
v = Vector3D(3, -4, 5)
n = Normal3D(6, 3, -9)
p = Point3D(-5, -2, 10)
# check Vector3D can be initialise by other vector objects
r = Vector3D(*n)
self.assertEqual(r.x, 6, "Vector3D initialisation failed [X].")
self.assertEqual(r.y, 3, "Vector3D initialisation failed [Y].")
self.assertEqual(r.z, -9, "Vector3D initialisation failed [Z].")
r = Vector3D(*p)
self.assertEqual(r.x, -5, "Vector3D initialisation failed [X].")
self.assertEqual(r.y, -2, "Vector3D initialisation failed [Y].")
self.assertEqual(r.z, 10, "Vector3D initialisation failed [Z].")
# check Normal3D can be initialise by other vector objects
r = Normal3D(*v)
self.assertEqual(r.x, 3, "Normal3D initialisation failed [X].")
self.assertEqual(r.y, -4, "Normal3D initialisation failed [Y].")
self.assertEqual(r.z, 5, "Normal3D initialisation failed [Z].")
r = Normal3D(*p)
self.assertEqual(r.x, -5, "Normal3D initialisation failed [X].")
self.assertEqual(r.y, -2, "Normal3D initialisation failed [Y].")
self.assertEqual(r.z, 10, "Normal3D initialisation failed [Z].")
# check Point3D can be initialise by other vector objects
r = Point3D(*v)
self.assertEqual(r.x, 3, "Point3D initialisation failed [X].")
self.assertEqual(r.y, -4, "Point3D initialisation failed [Y].")
self.assertEqual(r.z, 5, "Point3D initialisation failed [Z].")
r = Point3D(*n)
self.assertEqual(r.x, 6, "Point3D initialisation failed [X].")
self.assertEqual(r.y, 3, "Point3D initialisation failed [Y].")
self.assertEqual(r.z, -9, "Point3D initialisation failed [Z].")
def test_scalar_to_vector(self):
vx = 2 * Arg3D('z') # Will be auto-wrapped to Constant3D
vy = Arg3D('y')
vz = Sin3D(Arg3D('x'))
fv = FloatToVector3DFunction3D(vx, vy, vz)
v = [-1e10, -7, -0.001, 0.0, 0.00003, 10, 2.3e49]
for x in v:
for y in v:
for z in v:
expected = Vector3D(2 * z, y, sin(x))
actual = fv(x, y, z)
self.assertEqual(actual, expected,
"FloatToVector3DFunction3D call did not match reference value.")
