def test_setFromEuler_setFromQuaternion(self):
angles = [
THREE.Vector3(1, 0, 0),
THREE.Vector3(0, 1, 0),
THREE.Vector3(0, 0, 1)
]
# ensure euler conversion to/from THREE.Quaternion matches.
for order in orders:
for angle in angles:
eulers2 = THREE.Euler().setFromQuaternion(
THREE.Quaternion().setFromEuler(
THREE.Euler(angle.x, angle.y, angle.z, order)), order)
newAngle = THREE.Vector3(eulers2.x, eulers2.y, eulers2.z)
self.assertAlmostEqual(newAngle.distanceTo(angle), 0)
def test_set_setFromVector3_toVector3(self):
a = THREE.Euler()
a.set(0, 1, 0, "ZYX")
self.assertTrue(a.equals(eulerAzyx)) # Passednot
self.assertTrue(not a.equals(eulerAxyz)) # Passednot
self.assertTrue(not a.equals(eulerZero)) # Passednot
vec = THREE.Vector3(0, 1, 0)
b = THREE.Euler().setFromVector3(vec, "ZYX")
self.assertTrue(a.equals(b)) # Passednot
c = b.toVector3()
self.assertTrue(c.equals(vec)) # Passednot
def test_compose_decompose( self ):
tValues = [
THREE.Vector3(),
THREE.Vector3( 3, 0, 0 ),
THREE.Vector3( 0, 4, 0 ),
THREE.Vector3( 0, 0, 5 ),
THREE.Vector3( -6, 0, 0 ),
THREE.Vector3( 0, -7, 0 ),
THREE.Vector3( 0, 0, -8 ),
THREE.Vector3( -2, 5, -9 ),
THREE.Vector3( -2, -5, -9 )
]
sValues = [
THREE.Vector3( 1, 1, 1 ),
THREE.Vector3( 2, 2, 2 ),
THREE.Vector3( 1, -1, 1 ),
THREE.Vector3( -1, 1, 1 ),
THREE.Vector3( 1, 1, -1 ),
THREE.Vector3( 2, -2, 1 ),
THREE.Vector3( -1, 2, -2 ),
THREE.Vector3( -1, -1, -1 ),
THREE.Vector3( -2, -2, -2 )
]
rValues = [
THREE.Quaternion(),
THREE.Quaternion().setFromEuler( THREE.Euler( 1, 1, 0 ) ),
THREE.Quaternion().setFromEuler( THREE.Euler( 1, -1, 1 ) ),
THREE.Quaternion( 0, 0.9238795292366128, 0, 0.38268342717215614 )
]
for t in tValues:
for s in sValues:
for r in rValues:
m = THREE.Matrix4().compose( t, r, s )
t2 = THREE.Vector3()
r2 = THREE.Quaternion()
s2 = THREE.Vector3()
m.decompose( t2, r2, s2 )
m2 = THREE.Matrix4().compose( t2, r2, s2 )
self.assertEqual( m, m2 )
def test_Matrix4_setFromEuler_Euler_fromRotationMatrix(self):
testValues = [eulerZero, eulerAxyz, eulerAzyx]
for v in testValues:
m = THREE.Matrix4().makeRotationFromEuler(v)
v2 = THREE.Euler().setFromRotationMatrix(m, v.order)
m2 = THREE.Matrix4().makeRotationFromEuler(v2)
self.assertTrue(matrixEquals4(m, m2, 0.0001)) # Passednot
def test_Quaternion_setFromEuler_Euler_fromQuaternion(self):
testValues = [eulerZero, eulerAxyz, eulerAzyx]
for v in testValues:
q = THREE.Quaternion().setFromEuler(v)
v2 = THREE.Euler().setFromQuaternion(q, v.order)
q2 = THREE.Quaternion().setFromEuler(v2)
self.assertTrue(quatEquals(q, q2)) # Passednot
def test_multiplyVector3(self):
angles = [
THREE.Euler(1, 0, 0),
THREE.Euler(0, 1, 0),
THREE.Euler(0, 0, 1)
]
# ensure euler conversion for THREE.Quaternion matches that of THREE.Matrix4
for order in orders:
for angle in angles:
orderAngle = angle.clone()
orderAngle.order = order
q = THREE.Quaternion().setFromEuler(orderAngle)
m = THREE.Matrix4().makeRotationFromEuler(orderAngle)
v0 = THREE.Vector3(1, 0, 0)
qv = v0.clone().applyQuaternion(q)
mv = v0.clone().applyMatrix4(m)
self.assertAlmostEqual(qv.distanceTo(mv), 0)
def test_gimbalLocalQuat(self):
# known problematic quaternions
q1 = THREE.Quaternion(0.5207769385244341, -0.4783214164122354,
0.520776938524434, 0.47832141641223547)
q2 = THREE.Quaternion(0.11284905712620674, 0.6980437630368944,
-0.11284905712620674, 0.6980437630368944)
eulerOrder = "ZYX"
# create Euler directly from a Quaternion
eViaQ1 = THREE.Euler().setFromQuaternion(
q1, eulerOrder) # there is likely a bug here
# create Euler from Quaternion via an intermediate Matrix4
mViaQ1 = THREE.Matrix4().makeRotationFromQuaternion(q1)
eViaMViaQ1 = THREE.Euler().setFromRotationMatrix(mViaQ1, eulerOrder)
# the results here are different
self.assertTrue(eulerEquals(
eViaQ1, eViaMViaQ1)) # Passednot # self result is correct
def test_multiplyQuaternions_multiply(self):
angles = [
THREE.Euler(1, 0, 0),
THREE.Euler(0, 1, 0),
THREE.Euler(0, 0, 1)
]
q1 = THREE.Quaternion().setFromEuler(angles[0])
q2 = THREE.Quaternion().setFromEuler(angles[1])
q3 = THREE.Quaternion().setFromEuler(angles[2])
q = THREE.Quaternion().multiplyQuaternions(q1, q2).multiply(q3)
m1 = THREE.Matrix4().makeRotationFromEuler(angles[0])
m2 = THREE.Matrix4().makeRotationFromEuler(angles[1])
m3 = THREE.Matrix4().makeRotationFromEuler(angles[2])
m = THREE.Matrix4().multiplyMatrices(m1, m2).multiply(m3)
qFromM = THREE.Quaternion().setFromRotationMatrix(m)
self.assertAlmostEqual(qSub(q, qFromM).length(), 0)
from __future__ import division
import unittest
import math
import sys
import THREE
from Constants import *
orders = ['XYZ', 'YXZ', 'ZXY', 'ZYX', 'YZX', 'XZY']
eulerAngles = THREE.Euler(0.1, -0.3, 0.25)
def qSub(a, b):
result = THREE.Quaternion()
result.copy(a)
result.x -= b.x
result.y -= b.y
result.z -= b.z
result.w -= b.w
return result
def doSlerpObject(aArr, bArr, t):
a = THREE.Quaternion().fromArray(aArr)
b = THREE.Quaternion().fromArray(bArr)
c = THREE.Quaternion().fromArray(aArr)
def test_constructor_equals(self):
a = THREE.Euler()
self.assertTrue(a.equals(eulerZero)) # Passednot
self.assertTrue(not a.equals(eulerAxyz)) # Passednot
self.assertTrue(not a.equals(eulerAzyx)) # Passednot
from __future__ import division
import unittest
import THREE
eulerZero = THREE.Euler(0, 0, 0, "XYZ")
eulerAxyz = THREE.Euler(1, 0, 0, "XYZ")
eulerAzyx = THREE.Euler(0, 1, 0, "ZYX")
def matrixEquals4(a, b, tolerance=0.0001):
if len(a.elements) != len(b.elements):
return False
for i in xrange(len(a.elements)):
delta = a.elements[i] - b.elements[i]
if delta > tolerance:
return False
return True
def eulerEquals(a, b, tolerance=0.0001):
diff = abs(a.x - b.x) + abs(a.y - b.y) + abs(a.z - b.z)
return (diff < tolerance)