def test_quats():
for x, y, z in eg_rots:
M1 = nea.euler2mat(z, y, x)
quatM = nq.mat2quat(M1)
quat = nea.euler2quat(z, y, x)
yield nq.nearly_equivalent, quatM, quat
quatS = sympy_euler2quat(z, y, x)
yield nq.nearly_equivalent, quat, quatS
zp, yp, xp = nea.quat2euler(quat)
# The parameters may not be the same as input, but they give the
# same rotation matrix
M2 = nea.euler2mat(zp, yp, xp)
yield assert_array_almost_equal, M1, M2
def test_euler_mat():
M = nea.euler2mat()
yield assert_array_equal, M, np.eye(3)
for x, y, z in eg_rots:
M1 = nea.euler2mat(z, y, x)
M2 = sympy_euler(z, y, x)
yield assert_array_almost_equal, M1, M2
M3 = np.dot(x_only(x), np.dot(y_only(y), z_only(z)))
yield assert_array_almost_equal, M1, M3
zp, yp, xp = nea.mat2euler(M1)
# The parameters may not be the same as input, but they give the
# same rotation matrix
M4 = nea.euler2mat(zp, yp, xp)
yield assert_array_almost_equal, M1, M4
def test_euler_instability():
# Test for numerical errors in mat2euler
# problems arise for cos(y) near 0
po2 = pi / 2
zyx = po2, po2, po2
M = nea.euler2mat(*zyx)
# Round trip
M_back = nea.euler2mat(*nea.mat2euler(M))
yield assert_true, np.allclose(M, M_back)
# disturb matrix slightly
M_e = M - FLOAT_EPS
# round trip to test - OK
M_e_back = nea.euler2mat(*nea.mat2euler(M_e))
yield assert_true, np.allclose(M_e, M_e_back)
# not so with crude routine
M_e_back = nea.euler2mat(*crude_mat2euler(M_e))
yield assert_false, np.allclose(M_e, M_e_back)
from numpy.testing import assert_array_almost_equal, assert_array_equal
import nipy.io.imageformats.quaternions as nq
import nipy.io.imageformats.eulerangles as nea
# Example rotations '''
eg_rots = []
params = (-pi,pi,pi/2)
zs = np.arange(*params)
ys = np.arange(*params)
xs = np.arange(*params)
for z in zs:
for y in ys:
for x in xs:
eg_rots.append(nea.euler2mat(z,y,x))
# Example quaternions (from rotations)
eg_quats = []
for M in eg_rots:
eg_quats.append(nq.mat2quat(M))
# M, quaternion pairs
eg_pairs = zip(eg_rots, eg_quats)
# Set of arbitrary unit quaternions
unit_quats = set()
params = range(-2,3)
for w in params:
for x in params:
for y in params:
for z in params:
q = (w, x, y, z)
def test_basic_euler():
# some example rotations, in radians
zr = 0.05
yr = -0.4
xr = 0.2
# Rotation matrix composing the three rotations
M = nea.euler2mat(zr, yr, xr)
# Corresponding individual rotation matrices
M1 = nea.euler2mat(zr)
M2 = nea.euler2mat(0, yr)
M3 = nea.euler2mat(0, 0, xr)
# which are all valid rotation matrices
yield assert_true, is_valid_rotation(M)
yield assert_true, is_valid_rotation(M1)
yield assert_true, is_valid_rotation(M2)
yield assert_true, is_valid_rotation(M3)
# Full matrix is composition of three individual matrices
yield assert_true, np.allclose(M, np.dot(M3, np.dot(M2, M1)))
# Rotations can be specified with named args, default 0
yield assert_true, np.all(nea.euler2mat(zr) == nea.euler2mat(z=zr))
yield assert_true, np.all(nea.euler2mat(0, yr) == nea.euler2mat(y=yr))
yield assert_true, np.all(nea.euler2mat(0, 0, xr) == nea.euler2mat(x=xr))
# Applying an opposite rotation same as inverse (the inverse is
# the same as the transpose, but just for clarity)
yield assert_true, np.allclose(nea.euler2mat(x=-xr),
np.linalg.inv(nea.euler2mat(x=xr)))