def test_multiplyMatrices( self ):
# Reference:
#
# #not/usr/bin/env python
# from __future__ # # print(
# np.dot(
# np.reshape([2, 3, 5, 7, 11, 13, 17, 19, 23], (3, 3)),
# np.reshape([29, 31, 37, 41, 43, 47, 53, 59, 61], (3, 3))
# )
# )
#
# [[ 446 486 520]
# [1343 1457 1569]
# [2491 2701 2925]]
lhs = THREE.Matrix3().set( 2, 3, 5, 7, 11, 13, 17, 19, 23 )
rhs = THREE.Matrix3().set( 29, 31, 37, 41, 43, 47, 53, 59, 61 )
ans = THREE.Matrix3()
ans.multiplyMatrices(lhs, rhs)
self.assertEqual( ans.elements[0], 446 )
self.assertEqual( ans.elements[1], 1343 )
self.assertEqual( ans.elements[2], 2491 )
self.assertEqual( ans.elements[3], 486 )
self.assertEqual( ans.elements[4], 1457 )
self.assertEqual( ans.elements[5], 2701 )
self.assertEqual( ans.elements[6], 520 )
self.assertEqual( ans.elements[7], 1569 )
self.assertEqual( ans.elements[8], 2925 )
def test_identity( self ):
b = THREE.Matrix4().set( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 )
self.assertEqual( b.elements[0], 0 )
self.assertEqual( b.elements[1], 4 )
self.assertEqual( b.elements[2], 8 )
self.assertEqual( b.elements[3], 12 )
self.assertEqual( b.elements[4], 1 )
self.assertEqual( b.elements[5], 5 )
self.assertEqual( b.elements[6], 9 )
self.assertEqual( b.elements[7], 13 )
self.assertEqual( b.elements[8], 2 )
self.assertEqual( b.elements[9], 6 )
self.assertEqual( b.elements[10], 10 )
self.assertEqual( b.elements[11], 14 )
self.assertEqual( b.elements[12], 3 )
self.assertEqual( b.elements[13], 7 )
self.assertEqual( b.elements[14], 11 )
self.assertEqual( b.elements[15], 15 )
a = THREE.Matrix4()
self.assertNotEqual( a, b )
b.identity()
self.assertEqual( a, b )
def test_rotateX_Y_Z(self):
geometry = THREE.BufferGeometry()
geometry.addAttribute(
"position",
THREE.BufferAttribute(ctypesArray("f", [1, 2, 3, 4, 5, 6]), 3))
pos = geometry.attributes["position"].array
geometry.rotateX(180 * DegToRad)
# object was rotated around x so all items should be flipped but the x ones
self.assertTrue( pos[0] == 1 and pos[1] == -2 and pos[2] == -3 and \
pos[3] == 4 and pos[4] == -5 and pos[5] == -6 ) # vertices were rotated around x by 180 degrees
geometry.rotateY(180 * DegToRad)
# vertices were rotated around y so all items should be flipped again but the y ones
self.assertTrue( pos[0] == -1 and pos[1] == -2 and pos[2] == 3 and \
pos[3] == -4 and pos[4] == -5 and pos[5] == 6 ) # vertices were rotated around y by 180 degrees
geometry.rotateZ(180 * DegToRad)
# vertices were rotated around z so all items should be flipped again but the z ones
self.assertTrue( pos[0] == 1 and pos[1] == 2 and pos[2] == 3 and \
pos[3] == 4 and pos[4] == 5 and pos[5] == 6 ) # vertices were rotated around z by 180 degrees
def test_coplanarPoint( self ):
a = THREE.Plane( THREE.Vector3( 1, 0, 0 ), 0 )
self.assertEqual( a.distanceToPoint( a.coplanarPoint() ), 0 ) # Passednot
a = THREE.Plane( THREE.Vector3( 0, 1, 0 ), -1 )
self.assertEqual( a.distanceToPoint( a.coplanarPoint() ), 0 ) # Passednot
def test_multiply_divide(self):
a = THREE.Vector4(x, y, z, w)
b = THREE.Vector4(-x, -y, -z, -w)
a.multiplyScalar(-2)
self.assertEqual(a.x, x * -2)
self.assertEqual(a.y, y * -2)
self.assertEqual(a.z, z * -2)
self.assertEqual(a.w, w * -2)
b.multiplyScalar(-2)
self.assertEqual(b.x, 2 * x)
self.assertEqual(b.y, 2 * y)
self.assertEqual(b.z, 2 * z)
self.assertEqual(b.w, 2 * w)
a.divideScalar(-2)
self.assertEqual(a.x, x)
self.assertEqual(a.y, y)
self.assertEqual(a.z, z)
self.assertEqual(a.w, w)
b.divideScalar(-2)
self.assertEqual(b.x, -x)
self.assertEqual(b.y, -y)
self.assertEqual(b.z, -z)
self.assertEqual(b.w, -w)
def test_distanceToPoint( self ):
a = THREE.Plane( THREE.Vector3( 2, 0, 0 ), -2 )
a.normalize()
self.assertEqual( a.distanceToPoint( a.projectPoint( zero3.clone() ) ), 0 ) # Passednot
self.assertEqual( a.distanceToPoint( THREE.Vector3( 4, 0, 0 ) ), 3 ) # Passednot
def test_at( self ):
a = THREE.Ray( one3.clone(), THREE.Vector3( 0, 0, 1 ) )
self.assertTrue( a.at( 0 ).equals( one3 ) ) # Passednot
self.assertTrue( a.at( -1 ).equals( THREE.Vector3( 1, 1, 0 ) ) ) # Passednot
self.assertTrue( a.at( 1 ).equals( THREE.Vector3( 1, 1, 2 ) ) ) # Passednot
def test_clone(self):
instance = THREE.Face3(0, 1, 2, THREE.Vector3(0, 1, 0),
THREE.Color(0.25, 0.5, 0.75), 2)
copiedInstance = instance.clone()
self.checkCopy(copiedInstance)
self.checkVertexAndColors(copiedInstance)
def test_normalize( self ):
a = THREE.Plane( THREE.Vector3( 2, 0, 0 ), 2 )
a.normalize()
self.assertEqual( a.normal.length(), 1 ) # Passednot
self.assertTrue( a.normal.equals( THREE.Vector3( 1, 0, 0 ) ) ) # Passednot
self.assertEqual( a.constant, 1 ) # Passednot
def test_copyHex(self):
c = THREE.Color()
c2 = THREE.Color(0xF5FFFA)
c.copy(c2)
self.assertEqual(
c.getHex(),
c2.getHex()) # "Hex c: " + c.getHex() + " Hex c2: " + c2.getHex()
def test_applyMatrix4(self):
a = THREE.Sphere(one3.clone(), 1)
m = THREE.Matrix4().makeTranslation(1, -2, 1)
self.assertTrue(a.clone().applyMatrix4(m).getBoundingBox().equals(
a.getBoundingBox().applyMatrix4(m))) # Passednot
def test_getSize(self):
a = THREE.Box3(zero3.clone(), zero3.clone())
self.assertTrue(a.getSize().equals(zero3)) # Passednot
a = THREE.Box3(zero3.clone(), one3.clone())
self.assertTrue(a.getSize().equals(one3)) # Passednot
def test_intersectsSphere(self):
a = THREE.Sphere(one3.clone(), 1)
b = THREE.Sphere(zero3.clone(), 1)
c = THREE.Sphere(zero3.clone(), 0.25)
self.assertTrue(a.intersectsSphere(b)) # Passednot
self.assertTrue(not a.intersectsSphere(c)) # Passednot
def test_getSize(self):
a = THREE.Box2(zero2.clone(), zero2.clone())
self.assertTrue(a.getSize().equals(zero2)) # Passednot
a = THREE.Box2(zero2.clone(), one2.clone())
self.assertTrue(a.getSize().equals(one2)) # Passednot
def test_copyColorString(self):
c = THREE.Color()
c2 = THREE.Color("ivory")
c.copy(c2)
self.assertEqual(
c.getHex(),
c2.getHex()) # "Hex c: " + c.getHex() + " Hex c2: " + c2.getHex()
def test_constructor_equals( self ):
a = THREE.Ray()
self.assertTrue( a.origin.equals( zero3 ) ) # Passednot
self.assertTrue( a.direction.equals( zero3 ) ) # Passednot
a = THREE.Ray( two3.clone(), one3.clone() )
self.assertTrue( a.origin.equals( two3 ) ) # Passednot
self.assertTrue( a.direction.equals( one3 ) ) # Passednot
def getBSForVertices(self, vertices):
geometry = THREE.BufferGeometry()
geometry.addAttribute(
"position", THREE.BufferAttribute(ctypesArray("f", vertices), 3))
geometry.computeBoundingSphere()
return geometry.boundingSphere
def test_lerp(self):
c = THREE.Color()
c2 = THREE.Color()
c.setRGB(0, 0, 0)
c.lerp(c2, 0.2)
self.assertEqual(c.r, 0.2) # "Red: " + c.r
self.assertEqual(c.g, 0.2) # "Green: " + c.g
self.assertEqual(c.b, 0.2) # "Blue: " + c.b
def test_constructor(self):
a = THREE.Vector2()
self.assertEqual(a.x, 0)
self.assertEqual(a.y, 0)
a = THREE.Vector2(x, y)
self.assertEqual(a.x, x)
self.assertEqual(a.y, y)
def test_copyLinearToGamma(self):
c = THREE.Color()
c2 = THREE.Color()
c2.setRGB(0.09, 0.25, 0.81)
c.copyLinearToGamma(c2)
self.assertEqual(c.r, 0.3) # "Red c: " + c.r + " Red c2: " + c2.r
self.assertEqual(c.g, 0.5) # "Green c: " + c.g + " Green c2: " + c2.g
self.assertEqual(c.b, 0.9) # "Blue c: " + c.b + " Blue c2: " + c2.b
def test_constructor(self):
a = THREE.Sphere()
self.assertTrue(a.center.equals(zero3)) # Passednot
self.assertEqual(a.radius, 0) # Passednot
a = THREE.Sphere(one3.clone(), 1)
self.assertTrue(a.center.equals(one3)) # Passednot
self.assertEqual(a.radius, 1) # Passednot
def test_constructor_equals(self):
a = THREE.Line3()
self.assertTrue(a.start.equals(zero3)) # Passednot
self.assertTrue(a.end.equals(zero3)) # Passednot
a = THREE.Line3(two3.clone(), one3.clone())
self.assertTrue(a.start.equals(two3)) # Passednot
self.assertTrue(a.end.equals(one3)) # Passednot
def test_getCenter(self):
a = THREE.Box3(zero3.clone(), zero3.clone())
self.assertTrue(a.getCenter().equals(zero3)) # Passednot
a = THREE.Box3(zero3.clone(), one3.clone())
midpoint = one3.clone().multiplyScalar(0.5)
self.assertTrue(a.getCenter().equals(midpoint)) # Passednot
def test_intersectsSphere(self):
a = THREE.Box3(zero3.clone(), one3.clone())
b = THREE.Sphere(zero3.clone(), 1)
self.assertTrue(a.intersectsSphere(b)) # Passednot
b.translate(THREE.Vector3(2, 2, 2))
self.assertTrue(not a.intersectsSphere(b)) # Passednot
def test_copy( self ):
a = THREE.Matrix3().set( 0, 1, 2, 3, 4, 5, 6, 7, 8 )
b = THREE.Matrix3().copy( a )
self.assertTrue( matrixEquals3( a, b ) ) # Passednot
# ensure that it is a True copy
a.elements[0] = 2
self.assertTrue( not matrixEquals3( a, b ) ) # Passednot
def test_copy( self ):
a = THREE.Matrix4().set( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 )
b = THREE.Matrix4().copy( a )
self.assertEqual( a, b )
# ensure that it is a True copy
a.elements[0] = 2
self.assertNotEqual( a, b )
def test_dot(self):
a = THREE.Vector4(x, y, z, w)
b = THREE.Vector4(-x, -y, -z, -w)
c = THREE.Vector4(0, 0, 0, 0)
result = a.dot(b)
self.assertEqual(result, -x * x - y * y - z * z - w * w)
result = a.dot(c)
self.assertEqual(result, 0)
def test_union(self):
a = THREE.Box3(zero3.clone(), zero3.clone())
b = THREE.Box3(zero3.clone(), one3.clone())
c = THREE.Box3(one3.clone().negate(), one3.clone())
self.assertTrue(a.clone().union(a).equals(a)) # Passednot
self.assertTrue(a.clone().union(b).equals(b)) # Passednot
self.assertTrue(a.clone().union(c).equals(c)) # Passednot
self.assertTrue(b.clone().union(c).equals(c)) # Passednot
def test_clampPoint(self):
a = THREE.Sphere(one3.clone(), 1)
self.assertTrue(
a.clampPoint(THREE.Vector3(1, 1, 3)).equals(THREE.Vector3(
1, 1, 2))) # Passednot
self.assertTrue(
a.clampPoint(THREE.Vector3(1, 1, -3)).equals(THREE.Vector3(
1, 1, 0))) # Passednot
def test_getBoundingBox(self):
a = THREE.Sphere(one3.clone(), 1)
self.assertTrue(a.getBoundingBox().equals(THREE.Box3(
zero3, two3))) # Passednot
a.set(zero3, 0)
self.assertTrue(a.getBoundingBox().equals(THREE.Box3(
zero3, zero3))) # Passednot