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"))