Python numpy.quaternion() Examples
The following are 30
code examples of numpy.quaternion().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
numpy
, or try the search function
.
Example #1
Source File: quaternion_time_series.py From quaternion with MIT License | 7 votes |
def slerp(R1, R2, t1, t2, t_out): """Spherical linear interpolation of rotors This function uses a simpler interface than the more fundamental `slerp_evaluate` and `slerp_vectorized` functions. The latter are fast, being implemented at the C level, but take input `tau` instead of time. This function adjusts the time accordingly. Parameters ---------- R1: quaternion Quaternion at beginning of interpolation R2: quaternion Quaternion at end of interpolation t1: float Time corresponding to R1 t2: float Time corresponding to R2 t_out: float or array of floats Times to which the rotors should be interpolated """ tau = (t_out-t1)/(t2-t1) return np.slerp_vectorized(R1, R2, tau)
Example #2
Source File: test_quaternion.py From quaternion with MIT License | 6 votes |
def test_quaternion_multiply_ufunc(Qs): ufunc_binary_utility(np.array([quaternion.one]), Qs[Qs_finite], operator.mul) ufunc_binary_utility(Qs[Qs_finite], np.array([quaternion.one]), operator.mul) ufunc_binary_utility(np.array([1.0]), Qs[Qs_finite], operator.mul) ufunc_binary_utility(Qs[Qs_finite], np.array([1.0]), operator.mul) ufunc_binary_utility(np.array([1]), Qs[Qs_finite], operator.mul) ufunc_binary_utility(Qs[Qs_finite], np.array([1]), operator.mul) ufunc_binary_utility(np.array([0.0]), Qs[Qs_finite], operator.mul) ufunc_binary_utility(Qs[Qs_finite], np.array([0.0]), operator.mul) ufunc_binary_utility(np.array([0]), Qs[Qs_finite], operator.mul) ufunc_binary_utility(Qs[Qs_finite], np.array([0]), operator.mul) ufunc_binary_utility(np.array([-3, -2.3, -1.2, -1.0, 0.0, 0, 1.0, 1, 1.2, 2.3, 3]), Qs[Qs_finite], operator.mul) ufunc_binary_utility(Qs[Qs_finite], np.array([-3, -2.3, -1.2, -1.0, 0.0, 0, 1.0, 1, 1.2, 2.3, 3]), operator.mul) ufunc_binary_utility(Qs[Qs_finite], Qs[Qs_finite], operator.mul)
Example #3
Source File: pointcloud.py From AlignNet-3D with BSD 3-Clause "New" or "Revised" License | 6 votes |
def clean_color(color): if color == 'red': color = [255, 0, 0] elif color == 'green': color = [0, 255, 0] elif color == 'blue': color = [0, 0, 255] elif color == 'yellow': color = [255, 255, 0] elif color == 'pink': color = [255, 0, 255] elif color == 'cyan': color = [0, 255, 255] elif color == 'white': color = [255, 255, 255] return color ####### Dataset generation # https://stackoverflow.com/questions/31600717/how-to-generate-a-random-quaternion-quickly # http://planning.cs.uiuc.edu/node198.html
Example #4
Source File: test_quaternion.py From quaternion with MIT License | 6 votes |
def test_from_spherical_coords(): np.random.seed(1843) random_angles = [[np.random.uniform(-np.pi, np.pi), np.random.uniform(-np.pi, np.pi)] for i in range(5000)] for vartheta, varphi in random_angles: q = quaternion.from_spherical_coords(vartheta, varphi) assert abs((np.quaternion(0, 0, 0, varphi / 2.).exp() * np.quaternion(0, 0, vartheta / 2., 0).exp()) - q) < 1.e-15 xprime = q * quaternion.x * q.inverse() yprime = q * quaternion.y * q.inverse() zprime = q * quaternion.z * q.inverse() nhat = np.quaternion(0.0, math.sin(vartheta)*math.cos(varphi), math.sin(vartheta)*math.sin(varphi), math.cos(vartheta)) thetahat = np.quaternion(0.0, math.cos(vartheta)*math.cos(varphi), math.cos(vartheta)*math.sin(varphi), -math.sin(vartheta)) phihat = np.quaternion(0.0, -math.sin(varphi), math.cos(varphi), 0.0) assert abs(xprime - thetahat) < 1.e-15 assert abs(yprime - phihat) < 1.e-15 assert abs(zprime - nhat) < 1.e-15 assert np.max(np.abs(quaternion.from_spherical_coords(random_angles) - np.array([quaternion.from_spherical_coords(vartheta, varphi) for vartheta, varphi in random_angles]))) < 1.e-15
Example #5
Source File: test_quaternion.py From quaternion with MIT License | 6 votes |
def test_isclose(): from quaternion import x, y assert np.array_equal(quaternion.isclose([1e10*x, 1e-7*y], [1.00001e10*x, 1e-8*y], rtol=1.e-5, atol=2.e-8), np.array([True, False])) assert np.array_equal(quaternion.isclose([1e10*x, 1e-8*y], [1.00001e10*x, 1e-9*y], rtol=1.e-5, atol=2.e-8), np.array([True, True])) assert np.array_equal(quaternion.isclose([1e10*x, 1e-8*y], [1.0001e10*x, 1e-9*y], rtol=1.e-5, atol=2.e-8), np.array([False, True])) assert np.array_equal(quaternion.isclose([x, np.nan*y], [x, np.nan*y]), np.array([True, False])) assert np.array_equal(quaternion.isclose([x, np.nan*y], [x, np.nan*y], equal_nan=True), np.array([True, True])) np.random.seed(1234) a = quaternion.as_quat_array(np.random.random((3, 5, 4))) assert quaternion.allclose(1e10 * a, 1.00001e10 * a, rtol=1.e-5, atol=2.e-8, verbose=True) == True assert quaternion.allclose(1e-7 * a, 1e-8 * a, rtol=1.e-5, atol=2.e-8) == False assert quaternion.allclose(1e10 * a, 1.00001e10 * a, rtol=1.e-5, atol=2.e-8, verbose=True) == True assert quaternion.allclose(1e-8 * a, 1e-9 * a, rtol=1.e-5, atol=2.e-8, verbose=True) == True assert quaternion.allclose(1e10 * a, 1.0001e10 * a, rtol=1.e-5, atol=2.e-8) == False assert quaternion.allclose(1e-8 * a, 1e-9 * a, rtol=1.e-5, atol=2.e-8, verbose=True) == True assert quaternion.allclose(np.nan * a, np.nan * a) == False assert quaternion.allclose(np.nan * a, np.nan * a, equal_nan=True, verbose=True) == True
Example #6
Source File: test_quaternion.py From quaternion with MIT License | 6 votes |
def test_as_euler_angles(): np.random.seed(1843) random_angles = [[np.random.uniform(-np.pi, np.pi), np.random.uniform(-np.pi, np.pi), np.random.uniform(-np.pi, np.pi)] for i in range(5000)] for alpha, beta, gamma in random_angles: R1 = quaternion.from_euler_angles(alpha, beta, gamma) R2 = quaternion.from_euler_angles(*list(quaternion.as_euler_angles(R1))) d = quaternion.rotation_intrinsic_distance(R1, R2) assert d < 6e3*eps, ((alpha, beta, gamma), R1, R2, d) # Can't use allclose here; we don't care about rotor sign q0 = quaternion.quaternion(0, 0.6, 0.8, 0) assert q0.norm() == 1.0 assert abs(q0 - quaternion.from_euler_angles(*list(quaternion.as_euler_angles(q0)))) < 1.e-15 # Unary bool returners
Example #7
Source File: test_WignerD.py From spherical_functions with MIT License | 6 votes |
def test_Wigner_D_element_values(special_angles, ell_max): LMpM = sf.LMpM_range_half_integer(0, ell_max // 2) # Compare with more explicit forms given in Euler angles print("") for alpha in special_angles: print("\talpha={0}".format(alpha)) # Need to show some progress to Travis for beta in special_angles: print("\t\tbeta={0}".format(beta)) for gamma in special_angles: a = np.conjugate(np.array([slow_Wigner_D_element(alpha, beta, gamma, ell, mp, m) for ell,mp,m in LMpM])) b = sf.Wigner_D_element(quaternion.from_euler_angles(alpha, beta, gamma), LMpM) # if not np.allclose(a, b, # atol=ell_max ** 6 * precision_Wigner_D_element, # rtol=ell_max ** 6 * precision_Wigner_D_element): # for i in range(min(a.shape[0], 100)): # print(LMpM[i], "\t", abs(a[i]-b[i]), "\t\t", a[i], "\t", b[i]) assert np.allclose(a, b, atol=ell_max ** 6 * precision_Wigner_D_element, rtol=ell_max ** 6 * precision_Wigner_D_element)
Example #8
Source File: means.py From quaternion with MIT License | 6 votes |
def mean_rotor_in_chordal_metric(R, t=None): """Return rotor that is closest to all R in the least-squares sense This can be done (quasi-)analytically because of the simplicity of the chordal metric function. It is assumed that the input R values all are normalized (or at least have the same norm). Note that the `t` argument is optional. If it is present, the times are used to weight the corresponding integral. If it is not present, a simple sum is used instead (which may be slightly faster). However, because a spline is used to do this integral, the number of input points must be at least 4 (one more than the degree of the spline). """ import numpy as np from . import as_float_array from .calculus import definite_integral if t is None: return np.sum(R).normalized() if len(t) < 4 or len(R) < 4: raise ValueError('Input arguments must have length greater than 3; their lengths are {0} and {1}.'.format(len(R), len(t))) mean = definite_integral(as_float_array(R), t) return np.quaternion(*mean).normalized()
Example #9
Source File: test_SWSHs.py From spherical_functions with MIT License | 6 votes |
def test_SWSH_spin_behavior(Rs, special_angles, ell_max): # We expect that the SWSHs behave according to # sYlm( R * exp(gamma*z/2) ) = sYlm(R) * exp(-1j*s*gamma) # See http://moble.github.io/spherical_functions/SWSHs.html#fn:2 # for a more detailed explanation # print("") for i, R in enumerate(Rs): # print("\t{0} of {1}: R = {2}".format(i, len(Rs), R)) for gamma in special_angles: for ell in range(ell_max + 1): for s in range(-ell, ell + 1): LM = np.array([[ell, m] for m in range(-ell, ell + 1)]) Rgamma = R * np.quaternion(math.cos(gamma / 2.), 0, 0, math.sin(gamma / 2.)) sYlm1 = sf.SWSH(Rgamma, s, LM) sYlm2 = sf.SWSH(R, s, LM) * cmath.exp(-1j * s * gamma) # print(R, gamma, ell, s, np.max(np.abs(sYlm1-sYlm2))) assert np.allclose(sYlm1, sYlm2, atol=ell ** 6 * precision_SWSH, rtol=ell ** 6 * precision_SWSH)
Example #10
Source File: test_SWSHs.py From spherical_functions with MIT License | 6 votes |
def test_SWSH_grid(special_angles, ell_max): LM = sf.LM_range(0, ell_max) # Test flat array arrangement R_grid = np.array([quaternion.from_euler_angles(alpha, beta, gamma).normalized() for alpha in special_angles for beta in special_angles for gamma in special_angles]) for s in range(-ell_max + 1, ell_max): values_explicit = np.array([sf.SWSH(R, s, LM) for R in R_grid]) values_grid = sf.SWSH_grid(R_grid, s, ell_max) assert np.array_equal(values_explicit, values_grid) # Test nested array arrangement R_grid = np.array([[[quaternion.from_euler_angles(alpha, beta, gamma) for alpha in special_angles] for beta in special_angles] for gamma in special_angles]) for s in range(-ell_max + 1, ell_max): values_explicit = np.array([[[sf.SWSH(R, s, LM) for R in R1] for R1 in R2] for R2 in R_grid]) values_grid = sf.SWSH_grid(R_grid, s, ell_max) assert np.array_equal(values_explicit, values_grid)
Example #11
Source File: test_quaternion.py From quaternion with MIT License | 6 votes |
def test_quaternion_parity_conjugates(Qs): for q in Qs[Qs_finite]: assert q.x_parity_conjugate() == np.quaternion(q.w, q.x, -q.y, -q.z) assert q.y_parity_conjugate() == np.quaternion(q.w, -q.x, q.y, -q.z) assert q.z_parity_conjugate() == np.quaternion(q.w, -q.x, -q.y, q.z) assert q.parity_conjugate() == np.quaternion(q.w, q.x, q.y, q.z) assert np.array_equal(np.x_parity_conjugate(Qs[Qs_finite]), np.array([q.x_parity_conjugate() for q in Qs[Qs_finite]])) assert np.array_equal(np.y_parity_conjugate(Qs[Qs_finite]), np.array([q.y_parity_conjugate() for q in Qs[Qs_finite]])) assert np.array_equal(np.z_parity_conjugate(Qs[Qs_finite]), np.array([q.z_parity_conjugate() for q in Qs[Qs_finite]])) assert np.array_equal(np.parity_conjugate(Qs[Qs_finite]), np.array([q.parity_conjugate() for q in Qs[Qs_finite]])) # Quaternion-quaternion binary quaternion returners
Example #12
Source File: __init__.py From quaternion with MIT License | 6 votes |
def from_rotation_vector(rot): """Convert input 3-vector in axis-angle representation to unit quaternion Parameters ---------- rot: (Nx3) float array Each vector represents the axis of the rotation, with norm proportional to the angle of the rotation in radians. Returns ------- q: array of quaternions Unit quaternions resulting in rotations corresponding to input rotations. Output shape is rot.shape[:-1]. """ rot = np.array(rot, copy=False) quats = np.zeros(rot.shape[:-1]+(4,)) quats[..., 1:] = rot[...]/2 quats = as_quat_array(quats) return np.exp(quats)
Example #13
Source File: __init__.py From quaternion with MIT License | 6 votes |
def as_rotation_vector(q): """Convert input quaternion to the axis-angle representation Note that if any of the input quaternions has norm zero, no error is raised, but NaNs will appear in the output. Parameters ---------- q: quaternion or array of quaternions The quaternion(s) need not be normalized, but must all be nonzero Returns ------- rot: float array Output shape is q.shape+(3,). Each vector represents the axis of the rotation, with norm proportional to the angle of the rotation in radians. """ return as_float_array(2*np.log(np.normalized(q)))[..., 1:]
Example #14
Source File: geometry_utils.py From habitat-api with MIT License | 6 votes |
def quaternion_from_two_vectors(v0: np.array, v1: np.array) -> np.quaternion: r"""Computes the quaternion representation of v1 using v0 as the origin. """ v0 = v0 / np.linalg.norm(v0) v1 = v1 / np.linalg.norm(v1) c = v0.dot(v1) # Epsilon prevents issues at poles. if c < (-1 + EPSILON): c = max(c, -1) m = np.stack([v0, v1], 0) _, _, vh = np.linalg.svd(m, full_matrices=True) axis = vh.T[:, 2] w2 = (1 + c) * 0.5 w = np.sqrt(w2) axis = axis * np.sqrt(1 - w2) return np.quaternion(w, *axis) axis = np.cross(v0, v1) s = np.sqrt((1 + c) * 2) return np.quaternion(s * 0.5, *(axis / s))
Example #15
Source File: test_quaternion.py From quaternion with MIT License | 6 votes |
def test_quaternion_divide_ufunc(Qs): ufunc_binary_utility(np.array([quaternion.one]), Qs[Qs_finitenonzero], operator.truediv) ufunc_binary_utility(Qs[Qs_finite], np.array([quaternion.one]), operator.truediv) ufunc_binary_utility(np.array([1.0]), Qs[Qs_finitenonzero], operator.truediv) ufunc_binary_utility(Qs[Qs_finite], np.array([1.0]), operator.truediv) ufunc_binary_utility(np.array([1]), Qs[Qs_finitenonzero], operator.truediv) ufunc_binary_utility(Qs[Qs_finite], np.array([1]), operator.truediv) ufunc_binary_utility(np.array([0.0]), Qs[Qs_finitenonzero], operator.truediv) ufunc_binary_utility(np.array([0]), Qs[Qs_finitenonzero], operator.truediv) ufunc_binary_utility(np.array([-3, -2.3, -1.2, -1.0, 0.0, 0, 1.0, 1, 1.2, 2.3, 3]), Qs[Qs_finitenonzero], operator.truediv) ufunc_binary_utility(Qs[Qs_finitenonzero], np.array([-3, -2.3, -1.2, -1.0, 1.0, 1, 1.2, 2.3, 3]), operator.truediv) ufunc_binary_utility(Qs[Qs_finite], Qs[Qs_finitenonzero], operator.truediv) ufunc_binary_utility(Qs[Qs_finite], Qs[Qs_finitenonzero], operator.floordiv) ufunc_binary_utility(Qs[Qs_finitenonzero], Qs[Qs_finitenonzero], operator.truediv) ufunc_binary_utility(Qs[Qs_finitenonzero], Qs[Qs_finitenonzero], operator.floordiv)
Example #16
Source File: utils.py From habitat-api with MIT License | 5 votes |
def default(self, object): # JSON doesn't support numpy ndarray and quaternion if isinstance(object, np.ndarray): return object.tolist() if isinstance(object, np.quaternion): return quaternion_to_list(object) return ( object.__getstate__() if hasattr(object, "__getstate__") else object.__dict__ ) # Overriding method to inject own `_repr` function for floats with needed # precision.
Example #17
Source File: geometry_utils.py From habitat-api with MIT License | 5 votes |
def quaternion_rotate_vector(quat: np.quaternion, v: np.array) -> np.array: r"""Rotates a vector by a quaternion Args: quaternion: The quaternion to rotate by v: The vector to rotate Returns: np.array: The rotated vector """ vq = np.quaternion(0, 0, 0, 0) vq.imag = v return (quat * vq * quat.inverse()).imag
Example #18
Source File: test_SWSHs.py From spherical_functions with MIT License | 5 votes |
def test_SWSH_WignerD_expression(special_angles, ell_max): for iota in special_angles: for phi in special_angles: for ell in range(ell_max + 1): for s in range(-ell, ell + 1): R = quaternion.from_euler_angles(phi, iota, 0) LM = np.array([[ell, m] for m in range(-ell, ell + 1)]) Y = sf.SWSH(R, s, LM) LMS = np.array([[ell, m, -s] for m in range(-ell, ell + 1)]) D = (-1.) ** (s) * math.sqrt((2 * ell + 1) / (4 * np.pi)) * sf.Wigner_D_element(R.a, R.b, LMS) assert np.allclose(Y, D, atol=ell ** 6 * precision_SWSH, rtol=ell ** 6 * precision_SWSH)
Example #19
Source File: geometry_utils.py From habitat-api with MIT License | 5 votes |
def quaternion_to_list(q: np.quaternion): return q.imag.tolist() + [q.real]
Example #20
Source File: geometry_utils.py From habitat-api with MIT License | 5 votes |
def angle_between_quaternions(q1: np.quaternion, q2: np.quaternion) -> float: r"""Returns the angle (in radians) between two quaternions. This angle will always be positive. """ q1_inv = np.conjugate(q1) dq = quaternion.as_float_array(q1_inv * q2) return 2 * np.arctan2(np.linalg.norm(dq[1:]), np.abs(dq[0]))
Example #21
Source File: test_SWSHs.py From spherical_functions with MIT License | 5 votes |
def test_SWSH_conjugation(special_angles, ell_max): # {s}Y{l,m}.conjugate() = (-1.)**(s+m) {-s}Y{l,-m} indices1 = sf.LM_range(0, ell_max) indices2 = np.array([[ell, -m] for ell, m in indices1]) neg1_to_m = np.array([(-1.)**m for ell, m in indices1]) for iota in special_angles: for phi in special_angles: R = quaternion.from_spherical_coords(iota, phi) for s in range(1-ell_max, ell_max): assert np.allclose(sf.SWSH(R, s, indices1), (-1.)**s * neg1_to_m * np.conjugate(sf.SWSH(R, -s, indices2)), atol=1e-15, rtol=1e-15)
Example #22
Source File: geometry_utils.py From habitat-api with MIT License | 5 votes |
def quaternion_from_coeff(coeffs: np.ndarray) -> np.quaternion: r"""Creates a quaternions from coeffs in [x, y, z, w] format """ quat = np.quaternion(0, 0, 0, 0) quat.real = coeffs[3] quat.imag = coeffs[0:3] return quat
Example #23
Source File: pointcloud.py From AlignNet-3D with BSD 3-Clause "New" or "Revised" License | 5 votes |
def rand_quat(): u = np.random.uniform(0, 1, 3) h1 = np.sqrt(1 - u[0]) * np.sin(2 * np.pi * u[1]) h2 = np.sqrt(1 - u[0]) * np.cos(2 * np.pi * u[1]) h3 = np.sqrt(u[0]) * np.sin(2 * np.pi * u[2]) h4 = np.sqrt(u[0]) * np.cos(2 * np.pi * u[2]) return np.quaternion(h1, h2, h3, h4)
Example #24
Source File: test_WignerD.py From spherical_functions with MIT License | 5 votes |
def test_Wigner_D_element_roundoff(Rs, ell_max): LMpM = sf.LMpM_range(0, ell_max) # Test rotations with |Ra|<1e-15 expected = [((-1.) ** ell if mp == -m else 0.0) for ell in range(ell_max + 1) for mp in range(-ell, ell + 1) for m in range(-ell, ell + 1)] assert np.allclose(sf.Wigner_D_element(quaternion.x, LMpM), expected, atol=ell_max * precision_Wigner_D_element, rtol=ell_max * precision_Wigner_D_element) expected = [((-1.) ** (ell + m) if mp == -m else 0.0) for ell in range(ell_max + 1) for mp in range(-ell, ell + 1) for m in range(-ell, ell + 1)] assert np.allclose(sf.Wigner_D_element(quaternion.y, LMpM), expected, atol=ell_max * precision_Wigner_D_element, rtol=ell_max * precision_Wigner_D_element) for theta in np.linspace(0, 2 * np.pi): expected = [((-1.) ** (ell + m) * (np.cos(theta) + 1j * np.sin(theta)) ** (2 * m) if mp == -m else 0.0) for ell in range(ell_max + 1) for mp in range(-ell, ell + 1) for m in range(-ell, ell + 1)] assert np.allclose(sf.Wigner_D_element(np.cos(theta) * quaternion.y + np.sin(theta) * quaternion.x, LMpM), expected, atol=ell_max * precision_Wigner_D_element, rtol=ell_max * precision_Wigner_D_element) # Test rotations with |Rb|<1e-15 expected = [(1.0 if mp == m else 0.0) for ell in range(ell_max + 1) for mp in range(-ell, ell + 1) for m in range(-ell, ell + 1)] assert np.allclose(sf.Wigner_D_element(quaternion.one, LMpM), expected, atol=ell_max * precision_Wigner_D_element, rtol=ell_max * precision_Wigner_D_element) expected = [((-1.) ** m if mp == m else 0.0) for ell in range(ell_max + 1) for mp in range(-ell, ell + 1) for m in range(-ell, ell + 1)] assert np.allclose(sf.Wigner_D_element(quaternion.z, LMpM), expected, atol=ell_max * precision_Wigner_D_element, rtol=ell_max * precision_Wigner_D_element) for theta in np.linspace(0, 2 * np.pi): expected = [((np.cos(theta) + 1j * np.sin(theta)) ** (2 * m) if mp == m else 0.0) for ell in range(ell_max + 1) for mp in range(-ell, ell + 1) for m in range(-ell, ell + 1)] assert np.allclose(sf.Wigner_D_element(np.cos(theta) * quaternion.one + np.sin(theta) * quaternion.z, LMpM), expected, atol=ell_max * precision_Wigner_D_element, rtol=ell_max * precision_Wigner_D_element)
Example #25
Source File: test_quaternion.py From quaternion with MIT License | 5 votes |
def test_quaternion_divide(Qs): # Check identity between "inverse" and "reciprocal" for q in Qs[Qs_finitenonzero]: assert q.inverse() == q.reciprocal() # Check scalar division for q in Qs[Qs_finitenonzero]: assert allclose(q / q, quaternion.one) assert allclose(1 / q, q.inverse()) assert allclose(1.0 / q, q.inverse()) assert 0.0 / q == quaternion.zero for s in [-3, -2.3, -1.2, -1.0, 0.0, 0, 1.0, 1, 1.2, 2.3, 3]: assert allclose(s / q, s * (q.inverse())) for q in Qs[Qs_nonnan]: assert q / 1.0 == q assert q / 1 == q for s in [-3, -2.3, -1.2, -1.0, 1.0, 1, 1.2, 2.3, 3]: assert allclose(q / s, q * (1.0/s)) # Check linearity for q1 in Qs[Qs_finite]: for q2 in Qs[Qs_finite]: for q3 in Qs[Qs_finitenonzero]: assert allclose((q1+q2)/q3, (q1/q3)+(q2/q3)) # Check the multiplication table for q in [Qs[q_1], Qs[x], Qs[y], Qs[z]]: assert Qs[q_1] / q == q.conj() assert q / Qs[q_1] == q assert Qs[x] / Qs[x] == Qs[q_1] assert Qs[x] / Qs[y] == -Qs[z] assert Qs[x] / Qs[z] == Qs[y] assert Qs[y] / Qs[x] == Qs[z] assert Qs[y] / Qs[y] == Qs[q_1] assert Qs[y] / Qs[z] == -Qs[x] assert Qs[z] / Qs[x] == -Qs[y] assert Qs[z] / Qs[y] == Qs[x] assert Qs[z] / Qs[z] == Qs[q_1]
Example #26
Source File: pointcloud.py From AlignNet-3D with BSD 3-Clause "New" or "Revised" License | 5 votes |
def get_mat(translation=None, rotation=None): assert False mat = np.eye(4) if translation is not None: mat[:3, 3] = translation if rotation is not None: assert False # Does not work? mat[:3, :3] = quaternion.as_rotation_matrix(np.quaternion(*rotation)) return mat
Example #27
Source File: dataset.py From fpl with MIT License | 5 votes |
def accumulate_egomotion(rots, vels): # Accumulate translation and rotation egos = [] qa = np.quaternion(1, 0, 0, 0) va = np.array([0., 0., 0.]) for rot, vel in zip(rots, vels): vel_rot = quaternion.rotate_vectors(qa, vel) va += vel_rot qa = qa * quaternion.from_rotation_vector(rot) egos.append(np.concatenate( (quaternion.as_rotation_vector(qa), va), axis=0)) return egos
Example #28
Source File: test_quaternion.py From quaternion with MIT License | 5 votes |
def test_pickle(): import pickle a = quaternion.one assert pickle.loads(pickle.dumps(a)) == a
Example #29
Source File: test_quaternion.py From quaternion with MIT License | 5 votes |
def test_mean_rotor_in_chordal_metric(): # Test interpolation of some random constant quaternion q = quaternion.quaternion(*np.random.rand(4)).normalized() qs = np.array([q]*10) ts = np.linspace(0.1, 23.4, num=10) for length in range(1, 4): mean1 = quaternion.mean_rotor_in_chordal_metric(qs[:length]) assert np.abs(q-mean1) < 1e-15, (q, mean1, length) with pytest.raises(ValueError): quaternion.mean_rotor_in_chordal_metric(qs[:length], ts[:length]) for length in range(4, 11): mean1 = quaternion.mean_rotor_in_chordal_metric(qs[:length]) assert np.abs(q-mean1) < 1e-15, (q, mean1, length) mean2 = quaternion.mean_rotor_in_chordal_metric(qs[:length], ts[:length]) assert np.abs(q-mean2) < 1e-15, (q, mean2, length)
Example #30
Source File: test_quaternion.py From quaternion with MIT License | 5 votes |
def test_setitem_quat(Qs): Ps = Qs.copy() # setitem from quaternion for j in range(len(Ps)): Ps[j] = np.quaternion(1.3, 2.4, 3.5, 4.7) for k in range(j + 1): assert Ps[k] == np.quaternion(1.3, 2.4, 3.5, 4.7) for k in range(j + 1, len(Ps)): assert Ps[k] == Qs[k] # setitem from np.array, list, or tuple for seq_type in [np.array, list, tuple]: Ps = Qs.copy() with pytest.raises(TypeError): Ps[0] = seq_type(()) with pytest.raises(TypeError): Ps[0] = seq_type((1.3,)) with pytest.raises(TypeError): Ps[0] = seq_type((1.3, 2.4,)) with pytest.raises(TypeError): Ps[0] = seq_type((1.3, 2.4, 3.5)) with pytest.raises(TypeError): Ps[0] = seq_type((1.3, 2.4, 3.5, 4.7, 5.9)) with pytest.raises(TypeError): Ps[0] = seq_type((1.3, 2.4, 3.5, 4.7, 5.9, np.nan)) for j in range(len(Ps)): Ps[j] = seq_type((1.3, 2.4, 3.5, 4.7)) for k in range(j + 1): assert Ps[k] == np.quaternion(1.3, 2.4, 3.5, 4.7) for k in range(j + 1, len(Ps)): assert Ps[k] == Qs[k] with pytest.raises(TypeError): Ps[0] = 's' with pytest.raises(TypeError): Ps[0] = 's'