def _VerifyOrthonormVecs(mat):
v0 = Gf.Vec3d(mat[0][0], mat[0][1], mat[0][2])
v1 = Gf.Vec3d(mat[1][0], mat[1][1], mat[1][2])
v2 = Gf.Vec3d(mat[2][0], mat[2][1], mat[2][2])
self.assertTrue(Gf.IsClose(Gf.Dot(v0,v1), 0, 0.0001) and \
Gf.IsClose(Gf.Dot(v0,v2), 0, 0.0001) and \
Gf.IsClose(Gf.Dot(v1,v2), 0, 0.0001))
def test_Operators(self):
for quatType, vec3Type, closeVal in testClasses:
q1 = quatType(1, vec3Type(2, 3, 4))
q2 = quatType(1, vec3Type(2, 3, 4))
self.assertEqual(q1, q2)
self.assertFalse(q1 != q2)
q2.real = 2
self.assertTrue(q1 != q2)
q = quatType(1, vec3Type(2, 3, 4)) * quatType.GetIdentity()
self.assertEqual(q, quatType(1, vec3Type(2, 3, 4)))
q = quatType(1, vec3Type(2, 3, 4))
q_original = q
q *= quatType.GetIdentity()
self.assertEqual(q, quatType(1, vec3Type(2, 3, 4)))
self.assertTrue(q is q_original)
q *= 10
self.assertEqual(q, quatType(10, vec3Type(20, 30, 40)))
self.assertTrue(q is q_original)
q = q * 10
self.assertEqual(q, quatType(100, vec3Type(200, 300, 400)))
q = 10 * q
self.assertEqual(q, quatType(1000, vec3Type(2000, 3000, 4000)))
q_original = q
q /= 100
self.assertEqual(q, quatType(10, vec3Type(20, 30, 40)))
self.assertTrue(q is q_original)
q = q / 10
self.assertEqual(q, quatType(1, vec3Type(2, 3, 4)))
q_original = q
q += q
self.assertEqual(q, quatType(2, vec3Type(4, 6, 8)))
self.assertTrue(q is q_original)
q -= quatType(1, vec3Type(2, 3, 4))
self.assertEqual(q, quatType(1, vec3Type(2, 3, 4)))
self.assertTrue(q is q_original)
q = q + q
self.assertEqual(q, quatType(2, vec3Type(4, 6, 8)))
q = q - quatType(1, vec3Type(2, 3, 4))
self.assertEqual(q, quatType(1, vec3Type(2, 3, 4)))
q = q * q
self.assertEqual(q, quatType(-28, vec3Type(4, 6, 8)))
q1 = quatType(1, vec3Type(2, 3, 4)).GetNormalized()
q2 = quatType(4, vec3Type(3, 2, 1)).GetNormalized()
self.assertEqual(Gf.Slerp(0, q1, q2), q1)
self.assertEqual(Gf.Slerp(1, q1, q2), q2)
q = Gf.Slerp(0.5, q1, q2)
self.assertTrue(
Gf.IsClose(q.real, 0.5, closeVal)
and Gf.IsClose(q.imaginary, vec3Type(0.5, 0.5, 0.5), closeVal))
# code coverage goodness
q1 = quatType(0, vec3Type(1, 1, 1))
q2 = quatType(0, vec3Type(-1, -1, -1))
q = Gf.Slerp(0.5, q1, q2)
self.assertTrue(
Gf.IsClose(q.real, 0, closeVal)
and Gf.IsClose(q.imaginary, vec3Type(1, 1, 1), closeVal))
q1 = quatType(0, vec3Type(1, 1, 1))
q2 = quatType(0, vec3Type(1, 1, 1))
q = Gf.Slerp(0.5, q1, q2)
self.assertTrue(
Gf.IsClose(q.real, 0, closeVal)
and Gf.IsClose(q.imaginary, vec3Type(1, 1, 1), closeVal))
self.assertEqual(q, eval(repr(q)))
self.assertTrue(len(str(quatType())))
if quatType is Gf.Quaternion:
# The remaining tests are not for Gf.Quaternion
continue
q1 = quatType(1, [2, 3, 4])
q2 = quatType(2, [3, 4, 5])
self.assertTrue(Gf.IsClose(Gf.Dot(q1, q2), 40, closeVal))
# GetConjugate and Transform only exist on Quatd, Quatf, and Quath
q = quatType(1, vec3Type(2, 3, 4)).GetConjugate()
self.assertEqual(q, quatType(1, -vec3Type(2, 3, 4)))
# q is a 90 degree rotation around Z axis.
theta = math.radians(90)
cosHalfTheta = math.cos(theta / 2)
sinHalfTheta = math.sin(theta / 2)
q = quatType(cosHalfTheta, sinHalfTheta * vec3Type(0, 0, 1))
p = vec3Type(1.0, 0.0, 0.0) # point on the x-axis
r1 = (q * quatType(0, p) * q.GetInverse()).imaginary
r2 = q.Transform(p)
self.assertTrue(
Gf.IsClose(r1, vec3Type(0.0, 1.0, 0.0), closeVal)
and Gf.IsClose(r1, r2, closeVal))
def test_Exceptions(self):
with self.assertRaises(TypeError):
Gf.Dot('monkey', (1, 1))
with self.assertRaises(TypeError):
Gf.Dot('monkey', (1, 1, 1))
with self.assertRaises(TypeError):
Gf.Dot('monkey', (1, 1, 1, 1))
with self.assertRaises(TypeError):
Gf.Dot('monkey', (1.0, 1.0))
with self.assertRaises(TypeError):
Gf.Dot('monkey', (1.0, 1.0, 1.0))
with self.assertRaises(TypeError):
Gf.Dot('monkey', (1.0, 1.0, 1.0, 1.0))
with self.assertRaises(TypeError):
Gf.Dot((1, 1, 1, 1, 1, 1), (1, 1))
with self.assertRaises(TypeError):
Gf.Dot((1, 1, 1, 1, 1, 1), (1, 1, 1))
with self.assertRaises(TypeError):
Gf.Dot((1, 1, 1, 1, 1, 1), (1, 1, 1, 1))
with self.assertRaises(TypeError):
Gf.Dot((1.0, 1.0, 1.0, 1.0, 1.0, 1.0), (1.0, 1.0))
with self.assertRaises(TypeError):
Gf.Dot((1.0, 1.0, 1.0, 1.0, 1.0, 1.0), (1.0, 1.0, 1.0))
with self.assertRaises(TypeError):
Gf.Dot((1.0, 1.0, 1.0, 1.0, 1.0, 1.0), (1.0, 1.0, 1.0, 1.0))
with self.assertRaises(TypeError):
Gf.Dot(('a', 'b'), (1, 1))
with self.assertRaises(TypeError):
Gf.Dot(('a', 'b', 'c'), (1, 1, 1))
with self.assertRaises(TypeError):
Gf.Dot(('a', 'b', 'c', 'd'), (1, 1, 1, 1))
with self.assertRaises(TypeError):
Gf.Dot(('a', 'b'), (1.0, 1.0))
with self.assertRaises(TypeError):
Gf.Dot(('a', 'b', 'c'), (1.0, 1.0, 1.0))
with self.assertRaises(TypeError):
Gf.Dot(('a', 'b', 'c', 'd'), (1.0, 1.0, 1.0, 1.0))
def test_TupleToVec(self):
# Test passing tuples for vecs.
self.assertEqual(Gf.Dot((1, 1), (1, 1)), 2)
self.assertEqual(Gf.Dot((1, 1, 1), (1, 1, 1)), 3)
self.assertEqual(Gf.Dot((1, 1, 1, 1), (1, 1, 1, 1)), 4)
self.assertEqual(Gf.Dot((1.0, 1.0), (1.0, 1.0)), 2.0)
self.assertEqual(Gf.Dot((1.0, 1.0, 1.0), (1.0, 1.0, 1.0)), 3.0)
self.assertEqual(Gf.Dot((1.0, 1.0, 1.0, 1.0), (1.0, 1.0, 1.0, 1.0)),
4.0)
self.assertEqual(Gf.Vec2f((1, 1)), Gf.Vec2f(1, 1))
self.assertEqual(Gf.Vec3f((1, 1, 1)), Gf.Vec3f(1, 1, 1))
self.assertEqual(Gf.Vec4f((1, 1, 1, 1)), Gf.Vec4f(1, 1, 1, 1))
# Test passing lists for vecs.
self.assertEqual(Gf.Dot([1, 1], [1, 1]), 2)
self.assertEqual(Gf.Dot([1, 1, 1], [1, 1, 1]), 3)
self.assertEqual(Gf.Dot([1, 1, 1, 1], [1, 1, 1, 1]), 4)
self.assertEqual(Gf.Dot([1.0, 1.0], [1.0, 1.0]), 2.0)
self.assertEqual(Gf.Dot([1.0, 1.0, 1.0], [1.0, 1.0, 1.0]), 3.0)
self.assertEqual(Gf.Dot([1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]),
4.0)
self.assertEqual(Gf.Vec2f([1, 1]), Gf.Vec2f(1, 1))
self.assertEqual(Gf.Vec3f([1, 1, 1]), Gf.Vec3f(1, 1, 1))
self.assertEqual(Gf.Vec4f([1, 1, 1, 1]), Gf.Vec4f(1, 1, 1, 1))
# Test passing both for vecs.
self.assertEqual(Gf.Dot((1, 1), [1, 1]), 2)
self.assertEqual(Gf.Dot((1, 1, 1), [1, 1, 1]), 3)
self.assertEqual(Gf.Dot((1, 1, 1, 1), [1, 1, 1, 1]), 4)
self.assertEqual(Gf.Dot((1.0, 1.0), [1.0, 1.0]), 2.0)
self.assertEqual(Gf.Dot((1.0, 1.0, 1.0), [1.0, 1.0, 1.0]), 3.0)
self.assertEqual(Gf.Dot((1.0, 1.0, 1.0, 1.0), [1.0, 1.0, 1.0, 1.0]),
4.0)
self.assertEqual(Gf.Vec2f([1, 1]), Gf.Vec2f(1, 1))
self.assertEqual(Gf.Vec3f([1, 1, 1]), Gf.Vec3f(1, 1, 1))
self.assertEqual(Gf.Vec4f([1, 1, 1, 1]), Gf.Vec4f(1, 1, 1, 1))
def MethodsTest(self, Vec):
v1 = Vec()
v2 = Vec()
if isFloatingPoint(Vec):
eps = getEps(Vec)
# length
SetVec(v1, [3, 1, 4, 1])
l = Gf.GetLength(v1)
l2 = v1.GetLength()
self.assertTrue(Gf.IsClose(l, l2, eps), repr(l) + ' ' + repr(l2))
self.assertTrue(Gf.IsClose(l, math.sqrt(Gf.Dot(v1, v1)), eps), \
' '.join([repr(x) for x in [l, v1, math.sqrt(Gf.Dot(v1, v1))]]))
# Normalize...
SetVec(v1, [3, 1, 4, 1])
v2 = Vec(v1)
v2.Normalize()
nv = Gf.GetNormalized(v1)
nv2 = v1.GetNormalized()
nvcheck = v1 / Gf.GetLength(v1)
self.assertTrue(Gf.IsClose(nv, nvcheck, eps))
self.assertTrue(Gf.IsClose(nv2, nvcheck, eps))
self.assertTrue(Gf.IsClose(v2, nvcheck, eps))
SetVec(v1, [3, 1, 4, 1])
nv = v1.GetNormalized()
nvcheck = v1 / Gf.GetLength(v1)
self.assertEqual(nv, nvcheck)
SetVec(v1, [0, 0, 0, 0])
v1.Normalize()
self.assertTrue(checkVec(v1, [0, 0, 0, 0]))
SetVec(v1, [2, 0, 0, 0])
Gf.Normalize(v1)
self.assertTrue(checkVec(v1, [1, 0, 0, 0]))
# projection
SetVec(v1, [3, 1, 4, 1])
SetVec(v2, [5, 9, 2, 6])
p1 = Gf.GetProjection(v1, v2)
p2 = v1.GetProjection(v2)
check = (v1 * v2) * v2
self.assertTrue((p1 == check) and (p2 == check))
# complement
SetVec(v1, [3, 1, 4, 1])
SetVec(v2, [5, 9, 2, 6])
p1 = Gf.GetComplement(v1, v2)
p2 = v1.GetComplement(v2)
check = v1 - (v1 * v2) * v2
self.assertTrue((p1 == check) and (p2 == check))
# component-wise multiplication
SetVec(v1, [3, 1, 4, 1])
SetVec(v2, [5, 9, 2, 6])
v3 = Gf.CompMult(v1, v2)
self.assertTrue(checkVec(v3, [15, 9, 8, 6]))
# component-wise division
SetVec(v1, [3, 9, 18, 21])
SetVec(v2, [3, 3, 9, 7])
v3 = Gf.CompDiv(v1, v2)
self.assertTrue(checkVec(v3, [1, 3, 2, 3]))
# is close
SetVec(v1, [3, 1, 4, 1])
SetVec(v2, [5, 9, 2, 6])
self.assertTrue(Gf.IsClose(v1, v1, 0.1))
self.assertFalse(Gf.IsClose(v1, v2, 0.1))
# static Axis methods
for i in range(Vec.dimension):
v1 = Vec.Axis(i)
v2 = Vec()
v2[i] = 1
self.assertEqual(v1, v2)
v1 = Vec.XAxis()
self.assertTrue(checkVec(v1, [1, 0, 0, 0]))
v1 = Vec.YAxis()
self.assertTrue(checkVec(v1, [0, 1, 0, 0]))
if Vec.dimension != 2:
v1 = Vec.ZAxis()
self.assertTrue(checkVec(v1, [0, 0, 1, 0]))
if Vec.dimension == 3:
# cross product
SetVec(v1, [3, 1, 4, 0])
SetVec(v2, [5, 9, 2, 0])
v3 = Vec(Gf.Cross(v1, v2))
v4 = v1 ^ v2
v5 = v1.GetCross(v2) # 2x compatibility
check = Vec()
SetVec(check, [1 * 2 - 4 * 9, 4 * 5 - 3 * 2, 3 * 9 - 1 * 5, 0])
self.assertTrue(v3 == check and v4 == check and v5 == check)
# orthogonalize basis
# case 1: close to orthogonal, don't normalize
SetVec(v1, [1, 0, 0.1])
SetVec(v2, [0.1, 1, 0])
SetVec(v3, [0, 0.1, 1])
self.assertTrue(Vec.OrthogonalizeBasis(v1, v2, v3, False))
self.assertTrue(Gf.IsClose(Gf.Dot(v2, v1), 0, eps))
self.assertTrue(Gf.IsClose(Gf.Dot(v3, v1), 0, eps))
self.assertTrue(Gf.IsClose(Gf.Dot(v2, v3), 0, eps))
# case 2: far from orthogonal, normalize
SetVec(v1, [1, 2, 3])
SetVec(v2, [-1, 2, 3])
SetVec(v3, [-1, -2, 3])
self.assertTrue(Vec.OrthogonalizeBasis(v1, v2, v3, True))
self.assertTrue(Gf.IsClose(Gf.Dot(v2, v1), 0, eps))
self.assertTrue(Gf.IsClose(Gf.Dot(v3, v1), 0, eps))
self.assertTrue(Gf.IsClose(Gf.Dot(v2, v3), 0, eps))
self.assertTrue(Gf.IsClose(v1.GetLength(), 1, eps))
self.assertTrue(Gf.IsClose(v2.GetLength(), 1, eps))
self.assertTrue(Gf.IsClose(v3.GetLength(), 1, eps))
# case 3: already orthogonal - shouldn't change, even with large
# tolerance
SetVec(v1, [1, 0, 0])
SetVec(v2, [0, 1, 0])
SetVec(v3, [0, 0, 1])
vt1 = v1
vt2 = v2
vt3 = v3
self.assertTrue(Vec.OrthogonalizeBasis(v1, v2, v3, False, 1.0))
self.assertTrue(v1 == vt1)
self.assertTrue(v2 == vt2)
self.assertTrue(v3 == vt3)
# case 4: co-linear input vectors - should do nothing
SetVec(v1, [1, 0, 0])
SetVec(v2, [1, 0, 0])
SetVec(v3, [0, 0, 1])
vt1 = v1
vt2 = v2
vt3 = v3
self.assertFalse(Vec.OrthogonalizeBasis(
v1, v2, v3, False, 1.0))
self.assertEqual(v1, vt1)
self.assertEqual(v2, vt2)
self.assertEqual(v3, vt3)
# build orthonormal frame
SetVec(v1, [1, 1, 1, 1])
(v2, v3) = v1.BuildOrthonormalFrame()
self.assertTrue(Gf.IsClose(Gf.Dot(v2, v1), 0, eps))
self.assertTrue(Gf.IsClose(Gf.Dot(v3, v1), 0, eps))
self.assertTrue(Gf.IsClose(Gf.Dot(v2, v3), 0, eps))
SetVec(v1, [0, 0, 0, 0])
(v2, v3) = v1.BuildOrthonormalFrame()
self.assertTrue(Gf.IsClose(v2, Vec(), eps))
self.assertTrue(Gf.IsClose(v3, Vec(), eps))
SetVec(v1, [1, 0, 0, 0])
(v2, v3) = v1.BuildOrthonormalFrame()
self.assertTrue(Gf.IsClose(Gf.Dot(v2, v1), 0, eps))
self.assertTrue(Gf.IsClose(Gf.Dot(v3, v1), 0, eps))
self.assertTrue(Gf.IsClose(Gf.Dot(v2, v3), 0, eps))
SetVec(v1, [1, 0, 0, 0])
(v2, v3) = v1.BuildOrthonormalFrame()
self.assertTrue(Gf.IsClose(Gf.Dot(v2, v1), 0, eps))
self.assertTrue(Gf.IsClose(Gf.Dot(v3, v1), 0, eps))
self.assertTrue(Gf.IsClose(Gf.Dot(v2, v3), 0, eps))
SetVec(v1, [1, 0, 0, 0])
(v2, v3) = v1.BuildOrthonormalFrame(2)
self.assertTrue(Gf.IsClose(Gf.Dot(v2, v1), 0, eps))
self.assertTrue(Gf.IsClose(Gf.Dot(v3, v1), 0, eps))
self.assertTrue(Gf.IsClose(Gf.Dot(v2, v3), 0, eps))
# test Slerp w/ orthogonal vectors
SetVec(v1, [1, 0, 0])
SetVec(v2, [0, 1, 0])
v3 = Gf.Slerp(0, v1, v2)
self.assertTrue(Gf.IsClose(v3, v1, eps))
v3 = Gf.Slerp(1, v1, v2)
self.assertTrue(Gf.IsClose(v3, v3, eps))
v3 = Gf.Slerp(0.5, v1, v2)
self.assertTrue(Gf.IsClose(v3, Vec(.7071, .7071, 0), eps))
# test Slerp w/ nearly parallel vectors
SetVec(v1, [1, 0, 0])
SetVec(v2, [1.001, 0.0001, 0])
v2.Normalize()
v3 = Gf.Slerp(0, v1, v2)
self.assertTrue(Gf.IsClose(v3, v1, eps))
v3 = Gf.Slerp(1, v1, v2)
self.assertTrue(Gf.IsClose(v3, v3, eps))
v3 = Gf.Slerp(0.5, v1, v2)
self.assertTrue(Gf.IsClose(v3, v1, eps), [v3, v1, eps])
self.assertTrue(Gf.IsClose(v3, v2, eps))
# test Slerp w/ opposing vectors
SetVec(v1, [1, 0, 0])
SetVec(v2, [-1, 0, 0])
v3 = Gf.Slerp(0, v1, v2)
self.assertTrue(Gf.IsClose(v3, v1, eps))
v3 = Gf.Slerp(0.25, v1, v2)
self.assertTrue(Gf.IsClose(v3, Vec(.70711, 0, -.70711), eps))
v3 = Gf.Slerp(0.5, v1, v2)
self.assertTrue(Gf.IsClose(v3, Vec(0, 0, -1), eps))
v3 = Gf.Slerp(0.75, v1, v2)
self.assertTrue(Gf.IsClose(v3, Vec(-.70711, 0, -.70711), eps))
v3 = Gf.Slerp(1, v1, v2)
self.assertTrue(Gf.IsClose(v3, v3, eps))
# test Slerp w/ opposing vectors
SetVec(v1, [0, 1, 0])
SetVec(v2, [0, -1, 0])
v3 = Gf.Slerp(0, v1, v2)
self.assertTrue(Gf.IsClose(v3, v1, eps))
v3 = Gf.Slerp(0.25, v1, v2)
self.assertTrue(Gf.IsClose(v3, Vec(0, .70711, .70711), eps))
v3 = Gf.Slerp(0.5, v1, v2)
self.assertTrue(Gf.IsClose(v3, Vec(0, 0, 1), eps))
v3 = Gf.Slerp(0.75, v1, v2)
self.assertTrue(Gf.IsClose(v3, Vec(0, -.70711, .70711), eps))
v3 = Gf.Slerp(1, v1, v2)
self.assertTrue(Gf.IsClose(v3, v3, eps))
def OperatorsTest(self, Vec):
v1 = Vec()
v2 = Vec()
# equality
SetVec(v1, [3, 1, 4, 1])
SetVec(v2, [3, 1, 4, 1])
self.assertEqual(v1, v2)
# inequality
SetVec(v1, [3, 1, 4, 1])
SetVec(v2, [5, 9, 2, 6])
self.assertNotEqual(v1, v2)
# component-wise addition
SetVec(v1, [3, 1, 4, 1])
SetVec(v2, [5, 9, 2, 6])
v3 = v1 + v2
v1 += v2
self.assertTrue(checkVec(v1, [8, 10, 6, 7]))
self.assertTrue(checkVec(v3, [8, 10, 6, 7]))
# component-wise subtraction
SetVec(v1, [3, 1, 4, 1])
SetVec(v2, [5, 9, 2, 6])
v3 = v1 - v2
v1 -= v2
self.assertTrue(checkVec(v1, [-2, -8, 2, -5]))
self.assertTrue(checkVec(v3, [-2, -8, 2, -5]))
# component-wise multiplication
SetVec(v1, [3, 1, 4, 1])
SetVec(v2, [5, 9, 2, 6])
v4 = v1 * 10
v5 = 10 * v1
v1 *= 10
self.assertTrue(checkVec(v1, [30, 10, 40, 10]))
self.assertTrue(checkVec(v4, [30, 10, 40, 10]))
self.assertTrue(checkVec(v5, [30, 10, 40, 10]))
# component-wise division
SetVec(v1, [3, 6, 9, 12])
v3 = v1 / 3
v1 /= 3
self.assertTrue(checkVec(v1, [1, 2, 3, 4]))
self.assertTrue(checkVec(v3, [1, 2, 3, 4]))
# dot product
SetVec(v1, [3, 1, 4, 1])
SetVec(v2, [5, 9, 2, 6])
dp = v1 * v2
dp2 = Gf.Dot(v1, v2)
dp3 = v1.GetDot(v2) # 2x compatibility
self.assertTrue(checkVecDot(v1, v2, dp))
self.assertTrue(checkVecDot(v1, v2, dp2))
self.assertTrue(checkVecDot(v1, v2, dp3))
# unary minus (negation)
SetVec(v1, [3, 1, 4, 1])
self.assertTrue(checkVec(-v1, [-3, -1, -4, -1]))
# repr
self.assertEqual(v1, eval(repr(v1)))
# string
self.assertTrue(len(str(Vec())) > 0)
# indexing
v = Vec()
for i in range(Vec.dimension):
v[i] = i + 1
self.assertEqual(v[-1], v[v.dimension - 1])
self.assertEqual(v[0], 1)
self.assertIn(v.dimension, v)
self.assertNotIn(v.dimension + 1, v)
with self.assertRaises(IndexError):
v[v.dimension + 1] = v.dimension + 1
# slicing
v = Vec()
value = [3, 1, 4, 1]
SetVec(v, value)
value = v[0:v.dimension]
self.assertEqual(v[:], value)
self.assertEqual(v[:2], value[:2])
self.assertEqual(v[0:2], value[0:2])
self.assertEqual(v[-2:], value[-2:])
self.assertEqual(v[1:1], [])
if v.dimension > 2:
self.assertEqual(v[0:3:2], [3, 4])
v[:2] = (8, 9)
checkVec(v, [8, 9, 4, 1])
if v.dimension > 2:
v[:3:2] = [0, 1]
checkVec(v, [0, 9, 1, 1])
with self.assertRaises(ValueError):
# This should fail. Wrong length sequence
#
v[:2] = [1, 2, 3]
with self.assertRaises(TypeError):
# This should fail. Cannot use floats for indices
v[0.0:2.0] = [7, 7]
with self.assertRaises(TypeError):
# This should fail. Cannot convert None to vector data
#
v[:2] = [None, None]
def test_Exceptions(self):
with self.assertRaises(TypeError):
Gf.Dot('monkey', (1, 1))
with self.assertRaises(TypeError):
Gf.Dot('monkey', (1, 1, 1))
with self.assertRaises(TypeError):
Gf.Dot('monkey', (1, 1, 1, 1))
with self.assertRaises(TypeError):
Gf.Dot('monkey', (1.0, 1.0))
with self.assertRaises(TypeError):
Gf.Dot('monkey', (1.0, 1.0, 1.0))
with self.assertRaises(TypeError):
Gf.Dot('monkey', (1.0, 1.0, 1.0, 1.0))
with self.assertRaises(TypeError):
Gf.Dot((1, 1, 1, 1, 1, 1), (1, 1))
with self.assertRaises(TypeError):
Gf.Dot((1, 1, 1, 1, 1, 1), (1, 1, 1))
with self.assertRaises(TypeError):
Gf.Dot((1, 1, 1, 1, 1, 1), (1, 1, 1, 1))
with self.assertRaises(TypeError):
Gf.Dot((1.0, 1.0, 1.0, 1.0, 1.0, 1.0), (1.0, 1.0))
with self.assertRaises(TypeError):
Gf.Dot((1.0, 1.0, 1.0, 1.0, 1.0, 1.0), (1.0, 1.0, 1.0))
with self.assertRaises(TypeError):
Gf.Dot((1.0, 1.0, 1.0, 1.0, 1.0, 1.0), (1.0, 1.0, 1.0, 1.0))
with self.assertRaises(TypeError):
Gf.Dot(('a', 'b'), (1, 1))
with self.assertRaises(TypeError):
Gf.Dot(('a', 'b', 'c'), (1, 1, 1))
with self.assertRaises(TypeError):
Gf.Dot(('a', 'b', 'c', 'd'), (1, 1, 1, 1))
with self.assertRaises(TypeError):
Gf.Dot(('a', 'b'), (1.0, 1.0))
with self.assertRaises(TypeError):
Gf.Dot(('a', 'b', 'c'), (1.0, 1.0, 1.0))
with self.assertRaises(TypeError):
Gf.Dot(('a', 'b', 'c', 'd'), (1.0, 1.0, 1.0, 1.0))
# Bug USD-6284 shows that we erroneously implemented the Python 2.x
# buffer protocol 'getcharbuffer' method to expose the binary content,
# where really a string is expected. This tests that we correctly raise
# instead of treating the binary object representation as a string.
# We get different exceptions between Python 2 & 3 here, see Python
# issue 41707 (https://bugs.python.org/issue41707).
excType = TypeError if sys.version_info.major < 3 else ValueError
with self.assertRaises(excType):
int(Gf.Vec3d(1, 2, 3))
with self.assertRaises(excType):
int(Gf.Vec3i(1, 2, 3))
with self.assertRaises(excType):
int(Gf.Vec3f(1, 2, 3))
def test_Operators(self):
q1 = Gf.Quaternion(1, Gf.Vec3d(2, 3, 4))
q2 = Gf.Quaternion(1, Gf.Vec3d(2, 3, 4))
self.assertEqual(q1, q2)
self.assertFalse(q1 != q2)
q2.real = 2
self.assertTrue(q1 != q2)
q = Gf.Quaternion(1, Gf.Vec3d(2, 3, 4)) * Gf.Quaternion.GetIdentity()
self.assertEqual(q, Gf.Quaternion(1, Gf.Vec3d(2, 3, 4)))
q = Gf.Quaternion(1, Gf.Vec3d(2, 3, 4))
q *= Gf.Quaternion.GetIdentity()
self.assertEqual(q, Gf.Quaternion(1, Gf.Vec3d(2, 3, 4)))
q *= 10
self.assertEqual(q, Gf.Quaternion(10, Gf.Vec3d(20, 30, 40)))
q = q * 10
self.assertEqual(q, Gf.Quaternion(100, Gf.Vec3d(200, 300, 400)))
q = 10 * q
self.assertEqual(q, Gf.Quaternion(1000, Gf.Vec3d(2000, 3000, 4000)))
q /= 100
self.assertEqual(q, Gf.Quaternion(10, Gf.Vec3d(20, 30, 40)))
q = q / 10
self.assertEqual(q, Gf.Quaternion(1, Gf.Vec3d(2, 3, 4)))
q += q
self.assertEqual(q, Gf.Quaternion(2, Gf.Vec3d(4, 6, 8)))
q -= Gf.Quaternion(1, Gf.Vec3d(2, 3, 4))
self.assertEqual(q, Gf.Quaternion(1, Gf.Vec3d(2, 3, 4)))
q = q + q
self.assertEqual(q, Gf.Quaternion(2, Gf.Vec3d(4, 6, 8)))
q = q - Gf.Quaternion(1, Gf.Vec3d(2, 3, 4))
self.assertEqual(q, Gf.Quaternion(1, Gf.Vec3d(2, 3, 4)))
q = q * q
self.assertEqual(q, Gf.Quaternion(-28, Gf.Vec3d(4, 6, 8)))
q1 = Gf.Quaternion(1, Gf.Vec3d(2, 3, 4)).GetNormalized()
q2 = Gf.Quaternion(4, Gf.Vec3d(3, 2, 1)).GetNormalized()
self.assertEqual(Gf.Slerp(0, q1, q2), q1)
self.assertEqual(Gf.Slerp(1, q1, q2), q2)
self.assertEqual(Gf.Slerp(0.5, q1, q2),
Gf.Quaternion(0.5, Gf.Vec3d(0.5, 0.5, 0.5)))
# code coverage goodness
q1 = Gf.Quaternion(0, Gf.Vec3d(1, 1, 1))
q2 = Gf.Quaternion(0, Gf.Vec3d(-1, -1, -1))
q = Gf.Slerp(0.5, q1, q2)
self.assertTrue(
Gf.IsClose(q.real, 0, 0.0001)
and Gf.IsClose(q.imaginary, Gf.Vec3d(1, 1, 1), 0.0001))
q1 = Gf.Quaternion(0, Gf.Vec3d(1, 1, 1))
q2 = Gf.Quaternion(0, Gf.Vec3d(1, 1, 1))
q = Gf.Slerp(0.5, q1, q2)
self.assertTrue(
Gf.IsClose(q.real, 0, 0.0001)
and Gf.IsClose(q.imaginary, Gf.Vec3d(1, 1, 1), 0.0001))
self.assertEqual(q, eval(repr(q)))
self.assertTrue(len(str(Gf.Quaternion())))
for quatType in (Gf.Quatd, Gf.Quatf, Gf.Quath):
q1 = quatType(1, [2, 3, 4])
q2 = quatType(2, [3, 4, 5])
self.assertTrue(Gf.IsClose(Gf.Dot(q1, q2), 40, 0.0001))
def test_Fitting(self):
# Collinear points should not define a plane.
a = Gf.Vec3d(0, 0, 0)
b = Gf.Vec3d(1, 0, 0)
c = Gf.Vec3d(2, 0, 0)
self.assertIsNone(Gf.FitPlaneToPoints([a, b, c]), err("collinear"))
# Cannot fit plane to 2 or fewer points.
with self.assertRaises(Tf.ErrorException):
Gf.FitPlaneToPoints([a, b])
# Perfect fit (normal should be parallel to Z-axis, but OK if opposite
# direction).
c = Gf.Vec3d(0, 1, 0)
p = Gf.FitPlaneToPoints([a, b, c])
self.assertAlmostEqual(Gf.Dot(p.GetNormal(), Gf.Vec3d.ZAxis()), 1.0,
msg=err("normal1"))
self.assertAlmostEqual(p.GetDistanceFromOrigin(), 0.0,
msg=err("distance1"))
# Try the same plane but with non-unit vectors.
b = Gf.Vec3d(1.5, 0, 0)
c = Gf.Vec3d(0, 3.2, 0)
p = Gf.FitPlaneToPoints([a, b, c])
self.assertAlmostEqual(Gf.Dot(p.GetNormal(), Gf.Vec3d.ZAxis()), 1.0,
msg=err("normal2"))
self.assertAlmostEqual(p.GetDistanceFromOrigin(), 0.0,
msg=err("distance2"))
# Try a more complicated plane.
p1 = Gf.Plane(Gf.Vec4d(3, 4, 0, 5)) # equation constructor
a = p1.Project(Gf.Vec3d(2, 3, 6))
b = p1.Project(Gf.Vec3d(34, -2, 2))
c = p1.Project(Gf.Vec3d(-3, 7, -8))
d = p1.Project(Gf.Vec3d(4, 1, 1))
e = p1.Project(Gf.Vec3d(87, 67, 92))
p2 = Gf.FitPlaneToPoints([a, b, c])
self.assertAlmostEqual(
Gf.Dot(p1.GetNormal(), p2.GetNormal()), 1.0,
msg=err("p2 normal parallel to p1"))
self.assertAlmostEqual(
p1.GetDistanceFromOrigin(),
p2.GetDistanceFromOrigin(),
msg=err("p2 distance equals p1"))
p3 = Gf.FitPlaneToPoints([a, b, c, d, e])
self.assertAlmostEqual(
Gf.Dot(p1.GetNormal(), p3.GetNormal()), 1.0,
msg=err("p3 normal parallel to p1"))
self.assertAlmostEqual(
p1.GetDistanceFromOrigin(),
p3.GetDistanceFromOrigin(),
msg=err("p3 distance equals p1"))
# Try fitting points that don't form a perfect plane.
# This roughly forms the plane with normal (1, -1, 0) passing through
# the origin.
# Decrease the number of places of accuracy since these points are
# fudged and don't form an exact plane.
a = Gf.Vec3d(1.1, 1, 5)
b = Gf.Vec3d(1, 1.1, 2)
c = Gf.Vec3d(2, 2.1, -4)
d = Gf.Vec3d(2.1, 2, 1)
e = Gf.Vec3d(25.3, 25.2, 3)
f = Gf.Vec3d(25.1, 25.4, 6)
p = Gf.FitPlaneToPoints([a, b, c, d, e, f])
expectedNormal = Gf.Vec3d(1, -1, 0).GetNormalized()
self.assertAlmostEqual(
Gf.Dot(p.GetNormal(), expectedNormal), 1.0,
places=2,
msg=err("normal3"))
self.assertAlmostEqual(
p.GetDistanceFromOrigin(), 0.0,
places=2,
msg=err("distance3"))
