![]() |
OpenCV
Open Source Computer Vision
|
#include <opencv2/core/quaternion.hpp>
Public Member Functions | |
Quat () | |
Quat (const Vec< _Tp, 4 > &coeff) | |
From Vec4d or Vec4f. More... | |
Quat (_Tp w, _Tp x, _Tp y, _Tp z) | |
from four numbers. More... | |
Quat< _Tp > | acos () const |
return arccos value of this quaternion, arccos could be calculated as: \arccos(q) = -\frac{\boldsymbol{v}}{||\boldsymbol{v}||}arccosh(q) where \boldsymbol{v} = [x, y, z]. More... | |
Quat< _Tp > | acosh () const |
return arccosh value of this quaternion, arccosh could be calculated as: arcosh(q) = \ln(q + \sqrt{q^2 - 1}) . More... | |
Quat< _Tp > | asin () const |
return arcsin value of this quaternion, arcsin could be calculated as: \arcsin(q) = -\frac{\boldsymbol{v}}{||\boldsymbol{v}||}arcsinh(q\frac{\boldsymbol{v}}{||\boldsymbol{v}||}) where \boldsymbol{v} = [x, y, z]. More... | |
Quat< _Tp > | asinh () const |
return arcsinh value of this quaternion, arcsinh could be calculated as: arcsinh(q) = \ln(q + \sqrt{q^2 + 1}) . More... | |
void | assertNormal (_Tp eps=CV_QUAT_EPS) const |
to throw an error if this quaternion is not a unit quaternion. More... | |
_Tp | at (size_t index) const |
a way to get element. More... | |
Quat< _Tp > | atan () const |
return arctan value of this quaternion, arctan could be calculated as: \arctan(q) = -\frac{\boldsymbol{v}}{||\boldsymbol{v}||}arctanh(q\frac{\boldsymbol{v}}{||\boldsymbol{v}||}) where \boldsymbol{v} = [x, y, z]. More... | |
Quat< _Tp > | atanh () const |
return arctanh value of this quaternion, arctanh could be calculated as: arcsinh(q) = \frac{\ln(q + 1) - \ln(1 - q)}{2} . More... | |
Quat< _Tp > | conjugate () const |
return the conjugate of this quaternion. q.conjugate() = (w, -x, -y, -z).
More... | |
Quat< _Tp > | cos () const |
return cos value of this quaternion, cos could be calculated as: \cos(p) = \cos(w) * \cosh(||\boldsymbol{v}||) - \sin(w)\frac{\boldsymbol{v}}{||\boldsymbol{v}||}\sinh(||\boldsymbol{v}||) where \boldsymbol{v} = [x, y, z]. More... | |
Quat< _Tp > | cosh () const |
return cosh value of this quaternion, cosh could be calculated as: \cosh(p) = \cosh(w) * \cos(||\boldsymbol{v}||) + \sinh(w)\frac{\boldsymbol{v}}{||\boldsymbol{v}||}sin(||\boldsymbol{v}||) where \boldsymbol{v} = [x, y, z]. More... | |
Quat< _Tp > | crossProduct (const Quat< _Tp > &q) const |
return the crossProduct between p = (a, b, c, d) = (a, \boldsymbol{u}) and q = (w, x, y, z) = (w, \boldsymbol{v}). p \times q = \frac{pq- qp}{2}. p \times q = \boldsymbol{u} \times \boldsymbol{v}. p \times q = (cz-dy)i + (dx-bz)j + (by-xc)k.
More... | |
_Tp | dot (Quat< _Tp > q) const |
return the dot between quaternion q and this quaternion. More... | |
Quat< _Tp > | exp () const |
return the value of exponential value. \exp(q) = e^w (\cos||\boldsymbol{v}||+ \frac{v}{||\boldsymbol{v}||}\sin||\boldsymbol{v}||) where \boldsymbol{v} = [x, y, z]. More... | |
_Tp | getAngle (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const |
get the angle of quaternion, it returns the rotation angle. More... | |
Vec< _Tp, 3 > | getAxis (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const |
get the axis of quaternion, it returns a vector of length 3. More... | |
Quat< _Tp > | inv (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const |
return q^{-1} which is an inverse of q satisfying q * q^{-1} = 1. More... | |
bool | isNormal (_Tp eps=CV_QUAT_EPS) const |
return true if this quaternion is a unit quaternion. More... | |
Quat< _Tp > | log (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const |
return the value of logarithm function. \ln(q) = \ln||q|| + \frac{\boldsymbol{v}}{||\boldsymbol{v}||}\arccos\frac{w}{||q||} . where \boldsymbol{v} = [x, y, z]. More... | |
_Tp | norm () const |
return the norm of quaternion. ||q|| = \sqrt{w^2 + x^2 + y^2 + z^2}.
More... | |
Quat< _Tp > | normalize () const |
return a normalized p. p = \frac{q}{||q||} where p satisfies (p.x)^2 + (p.y)^2 + (p.z)^2 + (p.w)^2 = 1. More... | |
Quat< _Tp > | operator* (const Quat< _Tp > &) const |
Multiplication operator of two quaternions q and p. Multiplies values on either side of the operator. More... | |
Quat< _Tp > & | operator*= (const Quat< _Tp > &) |
Multiplication assignment operator of two quaternions q and p. It multiplies right operand with the left operand and assign the result to left operand. More... | |
Quat< _Tp > & | operator*= (const _Tp s) |
Multiplication assignment operator of a quaternions and a scalar. It multiplies right operand with the left operand and assign the result to left operand. More... | |
Quat< _Tp > | operator+ (const Quat< _Tp > &) const |
Addition operator of two quaternions p and q. It returns a new quaternion that each value is the sum of p_i and q_i. More... | |
Quat< _Tp > & | operator+= (const Quat< _Tp > &) |
Addition assignment operator of two quaternions p and q. It adds right operand to the left operand and assign the result to left operand. More... | |
Quat< _Tp > | operator- () const |
Return opposite quaternion -p which satisfies p + (-p) = 0.. More... | |
Quat< _Tp > | operator- (const Quat< _Tp > &) const |
Subtraction operator of two quaternions p and q. It returns a new quaternion that each value is the sum of p_i and -q_i. More... | |
Quat< _Tp > & | operator-= (const Quat< _Tp > &) |
Subtraction assignment operator of two quaternions p and q. It subtracts right operand from the left operand and assign the result to left operand. More... | |
Quat< _Tp > | operator/ (const _Tp s) const |
Division operator of a quaternions and a scalar. It divides left operand with the right operand and assign the result to left operand. More... | |
Quat< _Tp > | operator/ (const Quat< _Tp > &) const |
Division operator of two quaternions p and q. Divides left hand operand by right hand operand. More... | |
Quat< _Tp > & | operator/= (const _Tp s) |
Division assignment operator of a quaternions and a scalar. It divides left operand with the right operand and assign the result to left operand. More... | |
Quat< _Tp > & | operator/= (const Quat< _Tp > &) |
Division assignment operator of two quaternions p and q; It divides left operand with the right operand and assign the result to left operand. More... | |
bool | operator== (const Quat< _Tp > &) const |
return true if two quaternions p and q are nearly equal, i.e. when the absolute value of each p_i and q_i is less than CV_QUAT_EPS. More... | |
_Tp & | operator[] (std::size_t n) |
const _Tp & | operator[] (std::size_t n) const |
Quat< _Tp > | power (const _Tp x, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const |
return the value of power function with index x. q^x = ||q||(\cos(x\theta) + \boldsymbol{u}\sin(x\theta))).
More... | |
Quat< _Tp > | power (const Quat< _Tp > &q, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const |
return the value of power function with quaternion q. p^q = e^{q\ln(p)}.
More... | |
Quat< _Tp > | sin () const |
return sin value of this quaternion, sin could be calculated as: \sin(p) = \sin(w) * \cosh(||\boldsymbol{v}||) + \cos(w)\frac{\boldsymbol{v}}{||\boldsymbol{v}||}\sinh(||\boldsymbol{v}||) where \boldsymbol{v} = [x, y, z]. More... | |
Quat< _Tp > | sinh () const |
return sinh value of this quaternion, sinh could be calculated as: \sinh(p) = \sin(w)\cos(||\boldsymbol{v}||) + \cosh(w)\frac{v}{||\boldsymbol{v}||}\sin||\boldsymbol{v}|| where \boldsymbol{v} = [x, y, z]. More... | |
Quat< _Tp > | sqrt (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const |
return \sqrt{q}. More... | |
Quat< _Tp > | tan () const |
return tan value of this quaternion, tan could be calculated as: \tan(q) = \frac{\sin(q)}{\cos(q)}.
More... | |
Quat< _Tp > | tanh () const |
return tanh value of this quaternion, tanh could be calculated as: \tanh(q) = \frac{\sinh(q)}{\cosh(q)}.
More... | |
Vec< _Tp, 3 > | toEulerAngles (QuatEnum::EulerAnglesType eulerAnglesType) |
Transform a quaternion q to Euler angles. More... | |
Matx< _Tp, 3, 3 > | toRotMat3x3 (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const |
transform a quaternion to a 3x3 rotation matrix. More... | |
Matx< _Tp, 4, 4 > | toRotMat4x4 (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const |
transform a quaternion to a 4x4 rotation matrix. More... | |
Vec< _Tp, 3 > | toRotVec (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const |
transform this quaternion to a Rotation vector. More... | |
Vec< _Tp, 4 > | toVec () const |
transform the this quaternion to a Vec<T, 4>. More... | |
Static Public Member Functions | |
static Quat< _Tp > | createFromAngleAxis (const _Tp angle, const Vec< _Tp, 3 > &axis) |
from an angle, axis. Axis will be normalized in this function. And it generates q = [\cos\psi, u_x\sin\psi,u_y\sin\psi, u_z\sin\psi]. where \psi = \frac{\theta}{2}, \theta is the rotation angle. More... | |
static Quat< _Tp > | createFromEulerAngles (const Vec< _Tp, 3 > &angles, QuatEnum::EulerAnglesType eulerAnglesType) |
from Euler angles More... | |
static Quat< _Tp > | createFromRotMat (InputArray R) |
from a 3x3 rotation matrix. More... | |
static Quat< _Tp > | createFromRvec (InputArray rvec) |
from a rotation vector r has the form \theta \cdot \boldsymbol{u}, where \theta represents rotation angle and \boldsymbol{u} represents normalized rotation axis. More... | |
static Quat< _Tp > | createFromXRot (const _Tp theta) |
get a quaternion from a rotation about the X-axis by \theta . q = \cos(\theta/2)+sin(\theta/2) i +0 j +0 k
More... | |
static Quat< _Tp > | createFromYRot (const _Tp theta) |
get a quaternion from a rotation about the Y-axis by \theta . q = \cos(\theta/2)+0 i+ sin(\theta/2) j +0k
More... | |
static Quat< _Tp > | createFromZRot (const _Tp theta) |
get a quaternion from a rotation about the Z-axis by \theta. q = \cos(\theta/2)+0 i +0 j +sin(\theta/2) k
More... | |
static Quat< _Tp > | interPoint (const Quat< _Tp > &q0, const Quat< _Tp > &q1, const Quat< _Tp > &q2, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) |
This is the part calculation of squad. To calculate the intermedia quaternion s_i between each three quaternion s_i = q_i\exp(-\frac{\log(q^*_iq_{i+1}) + \log(q^*_iq_{i-1})}{4}). . More... | |
static Quat< _Tp > | lerp (const Quat< _Tp > &q0, const Quat &q1, const _Tp t) |
To calculate the interpolation from q_0 to q_1 by Linear Interpolation(Nlerp) For two quaternions, this interpolation curve can be displayed as: Lerp(q_0, q_1, t) = (1 - t)q_0 + tq_1. Obviously, the lerp will interpolate along a straight line if we think of q_0 and q_1 as a vector in a two-dimensional space. When t = 0, it returns q_0 and when t= 1, it returns q_1. t should to be ranged in [0, 1] normally. More... | |
static Quat< _Tp > | nlerp (const Quat< _Tp > &q0, const Quat &q1, const _Tp t, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) |
To calculate the interpolation from q_0 to q_1 by Normalized Linear Interpolation(Nlerp). it returns a normalized quaternion of Linear Interpolation(Lerp). Nlerp(q_0, q_1, t) = \frac{(1 - t)q_0 + tq_1}{||(1 - t)q_0 + tq_1||}. The interpolation will always choose the shortest path but the constant speed is not guaranteed. More... | |
static Quat< _Tp > | slerp (const Quat< _Tp > &q0, const Quat &q1, const _Tp t, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT, bool directChange=true) |
To calculate the interpolation between q_0 and q_1 by Spherical Linear Interpolation(Slerp), which can be defined as: Slerp(q_0, q_1, t) = \frac{\sin((1-t)\theta)}{\sin(\theta)}q_0 + \frac{\sin(t\theta)}{\sin(\theta)}q_1 where \theta can be calculated as: \theta=cos^{-1}(q_0\cdot q_1) resulting from the both of their norm is unit. More... | |
static Quat< _Tp > | spline (const Quat< _Tp > &q0, const Quat< _Tp > &q1, const Quat< _Tp > &q2, const Quat< _Tp > &q3, const _Tp t, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) |
to calculate a quaternion which is the result of a C^1 continuous spline curve constructed by squad at the ratio t. Here, the interpolation values are between q_1 and q_2. q_0 and q_2 are used to ensure the C^1 continuity. if t = 0, it returns q_1, if t = 1, it returns q_2. More... | |
static Quat< _Tp > | squad (const Quat< _Tp > &q0, const Quat< _Tp > &s0, const Quat< _Tp > &s1, const Quat< _Tp > &q1, const _Tp t, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT, bool directChange=true) |
To calculate the interpolation between q_0, q_1, q_2, q_3 by Spherical and quadrangle(Squad). This could be defined as: Squad(q_i, s_i, s_{i+1}, q_{i+1}, t) = Slerp(Slerp(q_i, q_{i+1}, t), Slerp(s_i, s_{i+1}, t), 2t(1-t)) where s_i = q_i\exp(-\frac{\log(q^*_iq_{i+1}) + \log(q^*_iq_{i-1})}{4}) . More... | |
Public Attributes | |
_Tp | w |
_Tp | x |
_Tp | y |
_Tp | z |
Static Public Attributes | |
static constexpr _Tp | CV_QUAT_CONVERT_THRESHOLD = (_Tp)1.e-6 |
static constexpr _Tp | CV_QUAT_EPS = (_Tp)1.e-6 |
Friends | |
template<typename T > | |
Quat< T > | acos (const Quat< T > &q) |
return arccos value of quaternion q, arccos could be calculated as: \arccos(q) = -\frac{\boldsymbol{v}}{||\boldsymbol{v}||}arccosh(q) where \boldsymbol{v} = [x, y, z]. More... | |
template<typename T > | |
Quat< T > | acosh (const Quat< T > &q) |
return arccosh value of quaternion q, arccosh could be calculated as: arccosh(q) = \ln(q + \sqrt{q^2 - 1}) . More... | |
template<typename T > | |
Quat< T > | asin (const Quat< T > &q) |
return arcsin value of quaternion q, arcsin could be calculated as: \arcsin(q) = -\frac{\boldsymbol{v}}{||\boldsymbol{v}||}arcsinh(q\frac{\boldsymbol{v}}{||\boldsymbol{v}||}) where \boldsymbol{v} = [x, y, z]. More... | |
template<typename T > | |
Quat< T > | asinh (const Quat< T > &q) |
return arcsinh value of quaternion q, arcsinh could be calculated as: arcsinh(q) = \ln(q + \sqrt{q^2 + 1}) . More... | |
template<typename T > | |
Quat< T > | atan (const Quat< T > &q) |
return arctan value of quaternion q, arctan could be calculated as: \arctan(q) = -\frac{\boldsymbol{v}}{||\boldsymbol{v}||}arctanh(q\frac{\boldsymbol{v}}{||\boldsymbol{v}||}) where \boldsymbol{v} = [x, y, z]. More... | |
template<typename T > | |
Quat< T > | atanh (const Quat< T > &q) |
return arctanh value of quaternion q, arctanh could be calculated as: arctanh(q) = \frac{\ln(q + 1) - \ln(1 - q)}{2} . More... | |
template<typename T > | |
Quat< T > | cos (const Quat< T > &q) |
return sin value of quaternion q, cos could be calculated as: \cos(p) = \cos(w) * \cosh(||\boldsymbol{v}||) - \sin(w)\frac{\boldsymbol{v}}{||\boldsymbol{v}||}\sinh(||\boldsymbol{v}||) where \boldsymbol{v} = [x, y, z]. More... | |
template<typename T > | |
Quat< T > | cosh (const Quat< T > &q) |
return cosh value of quaternion q, cosh could be calculated as: \cosh(p) = \cosh(w) * \cos(||\boldsymbol{v}||) + \sinh(w)\frac{\boldsymbol{v}}{||\boldsymbol{v}||}\sin(||\boldsymbol{v}||) where \boldsymbol{v} = [x, y, z]. More... | |
template<typename T > | |
Quat< T > | crossProduct (const Quat< T > &p, const Quat< T > &q) |
return the crossProduct between p = (a, b, c, d) = (a, \boldsymbol{u}) and q = (w, x, y, z) = (w, \boldsymbol{v}). p \times q = \frac{pq- qp}{2} p \times q = \boldsymbol{u} \times \boldsymbol{v} p \times q = (cz-dy)i + (dx-bz)j + (by-xc)k
More... | |
template<typename T > | |
Quat< T > | cv::operator* (const T s, const Quat< T > &) |
Multiplication operator of a scalar and a quaternions. It multiplies right operand with the left operand and assign the result to left operand. More... | |
template<typename T > | |
Quat< T > | cv::operator* (const Quat< T > &, const T s) |
Multiplication operator of a quaternion and a scalar. It multiplies right operand with the left operand and assign the result to left operand. More... | |
template<typename T > | |
Quat< T > | cv::operator+ (const T s, const Quat< T > &) |
Addition operator of a quaternions and a scalar. Adds right hand operand from left hand operand. More... | |
template<typename T > | |
Quat< T > | cv::operator+ (const Quat< T > &, const T s) |
Addition operator of a quaternions and a scalar. Adds right hand operand from left hand operand. More... | |
template<typename T > | |
Quat< T > | cv::operator- (const T s, const Quat< T > &) |
Subtraction operator of a scalar and a quaternions. Subtracts right hand operand from left hand operand. More... | |
template<typename T > | |
Quat< T > | cv::operator- (const Quat< T > &, const T s) |
Subtraction operator of a quaternions and a scalar. Subtracts right hand operand from left hand operand. More... | |
template<typename S > | |
std::ostream & | cv::operator<< (std::ostream &, const Quat< S > &) |
template<typename T > | |
Quat< T > | exp (const Quat< T > &q) |
return the value of exponential value. \exp(q) = e^w (\cos||\boldsymbol{v}||+ \frac{v}{||\boldsymbol{v}||})\sin||\boldsymbol{v}|| where \boldsymbol{v} = [x, y, z]. More... | |
template<typename T > | |
Quat< T > | inv (const Quat< T > &q, QuatAssumeType assumeUnit) |
return q^{-1} which is an inverse of q which satisfies q * q^{-1} = 1. More... | |
template<typename T > | |
Quat< T > | log (const Quat< T > &q, QuatAssumeType assumeUnit) |
return the value of logarithm function. \ln(q) = \ln||q|| + \frac{\boldsymbol{v}}{||\boldsymbol{v}||}\arccos\frac{w}{||q||}. where \boldsymbol{v} = [x, y, z]. More... | |
template<typename T > | |
Quat< T > | power (const Quat< T > &q, const T x, QuatAssumeType assumeUnit) |
return the value of power function with index x. q^x = ||q||(cos(x\theta) + \boldsymbol{u}sin(x\theta))).
More... | |
template<typename T > | |
Quat< T > | power (const Quat< T > &p, const Quat< T > &q, QuatAssumeType assumeUnit) |
return the value of power function with quaternion q. p^q = e^{q\ln(p)}.
More... | |
template<typename T > | |
Quat< T > | sin (const Quat< T > &q) |
return tanh value of quaternion q, sin could be calculated as: \sin(p) = \sin(w) * \cosh(||\boldsymbol{v}||) + \cos(w)\frac{\boldsymbol{v}}{||\boldsymbol{v}||}\sinh(||\boldsymbol{v}||) where \boldsymbol{v} = [x, y, z]. More... | |
template<typename T > | |
Quat< T > | sinh (const Quat< T > &q) |
return sinh value of quaternion q, sinh could be calculated as: \sinh(p) = \sin(w)\cos(||\boldsymbol{v}||) + \cosh(w)\frac{v}{||\boldsymbol{v}||}\sin||\boldsymbol{v}|| where \boldsymbol{v} = [x, y, z]. More... | |
template<typename T > | |
Quat< T > | sqrt (const Quat< T > &q, QuatAssumeType assumeUnit) |
return \sqrt{q}. More... | |
template<typename T > | |
Quat< T > | tan (const Quat< T > &q) |
return tan value of quaternion q, tan could be calculated as: \tan(q) = \frac{\sin(q)}{\cos(q)}.
More... | |
template<typename T > | |
Quat< T > | tanh (const Quat< T > &q) |
return tanh value of quaternion q, tanh could be calculated as: \tanh(q) = \frac{\sinh(q)}{\cosh(q)}.
More... | |
Quaternion is a number system that extends the complex numbers. It can be expressed as a rotation in three-dimensional space. A quaternion is generally represented in the form:
q = w + x\boldsymbol{i} + y\boldsymbol{j} + z\boldsymbol{k}
q = [w, x, y, z]
q = [w, \boldsymbol{v}]
q = ||q||[\cos\psi, u_x\sin\psi,u_y\sin\psi, u_z\sin\psi].
q = ||q||[\cos\psi, \boldsymbol{u}\sin\psi]
where \psi = \frac{\theta}{2}, \theta represents rotation angle, \boldsymbol{u} = [u_x, u_y, u_z] represents normalized rotation axis, and ||q|| represents the norm of q.
A unit quaternion is usually represents rotation, which has the form:
q = [\cos\psi, u_x\sin\psi,u_y\sin\psi, u_z\sin\psi].
To create a quaternion representing the rotation around the axis \boldsymbol{u} with angle \theta, you can use
You can simply use four same type number to create a quaternion
Or use a Vec4d or Vec4f vector.
If you already have a 3x3 rotation matrix R, then you can use
If you already have a rotation vector rvec which has the form of angle * axis
, then you can use
To extract the rotation matrix from quaternion, see toRotMat3x3()
To extract the Vec4d or Vec4f, see toVec()
To extract the rotation vector, see toRotVec()
If there are two quaternions q_0, q_1 are needed to interpolate, you can use nlerp(), slerp() or spline()
spline can smoothly connect rotations of multiple quaternions
Three ways to get an element in Quaternion
From Vec4d or Vec4f.
return arccos value of this quaternion, arccos could be calculated as:
\arccos(q) = -\frac{\boldsymbol{v}}{||\boldsymbol{v}||}arccosh(q)
where \boldsymbol{v} = [x, y, z].
For example
return arccosh value of this quaternion, arccosh could be calculated as:
arcosh(q) = \ln(q + \sqrt{q^2 - 1})
.
For example
return arcsin value of this quaternion, arcsin could be calculated as:
\arcsin(q) = -\frac{\boldsymbol{v}}{||\boldsymbol{v}||}arcsinh(q\frac{\boldsymbol{v}}{||\boldsymbol{v}||})
where \boldsymbol{v} = [x, y, z].
For example
return arcsinh value of this quaternion, arcsinh could be calculated as:
arcsinh(q) = \ln(q + \sqrt{q^2 + 1})
.
For example
void cv::Quat< _Tp >::assertNormal | ( | _Tp | eps = CV_QUAT_EPS | ) | const |
to throw an error if this quaternion is not a unit quaternion.
eps | tolerance scope of normalization. |
_Tp cv::Quat< _Tp >::at | ( | size_t | index | ) | const |
a way to get element.
index | over a range [0, 3]. |
A quaternion q
q.at(0) is equivalent to q.w,
q.at(1) is equivalent to q.x,
q.at(2) is equivalent to q.y,
q.at(3) is equivalent to q.z.
return arctan value of this quaternion, arctan could be calculated as:
\arctan(q) = -\frac{\boldsymbol{v}}{||\boldsymbol{v}||}arctanh(q\frac{\boldsymbol{v}}{||\boldsymbol{v}||})
where \boldsymbol{v} = [x, y, z].
For example
return arctanh value of this quaternion, arctanh could be calculated as:
arcsinh(q) = \frac{\ln(q + 1) - \ln(1 - q)}{2}
.
For example
return the conjugate of this quaternion.
q.conjugate() = (w, -x, -y, -z).
return cos value of this quaternion, cos could be calculated as:
\cos(p) = \cos(w) * \cosh(||\boldsymbol{v}||) - \sin(w)\frac{\boldsymbol{v}}{||\boldsymbol{v}||}\sinh(||\boldsymbol{v}||)
where \boldsymbol{v} = [x, y, z].
For example
return cosh value of this quaternion, cosh could be calculated as:
\cosh(p) = \cosh(w) * \cos(||\boldsymbol{v}||) + \sinh(w)\frac{\boldsymbol{v}}{||\boldsymbol{v}||}sin(||\boldsymbol{v}||)
where \boldsymbol{v} = [x, y, z].
For example
|
static |
from an angle, axis. Axis will be normalized in this function. And it generates
q = [\cos\psi, u_x\sin\psi,u_y\sin\psi, u_z\sin\psi].
where \psi = \frac{\theta}{2}, \theta is the rotation angle.
|
static |
from Euler angles
A quaternion can be generated from Euler angles by combining the quaternion representations of the Euler rotations.
For example, if we use intrinsic rotations in the order of X-Y-Z, \theta_1 is rotation around the X-axis, \theta_2 is rotation around the Y-axis, \theta_3 is rotation around the Z-axis. The final quaternion q can be calculated by
{q} = q_{X, \theta_1} q_{Y, \theta_2} q_{Z, \theta_3}
where q_{X, \theta_1} is created from createFromXRot, q_{Y, \theta_2} is created from createFromYRot, q_{Z, \theta_3} is created from createFromZRot.
angles | the Euler angles in a vector of length 3 |
eulerAnglesType | the convertion Euler angles type |
|
static |
from a 3x3 rotation matrix.
|
static |
from a rotation vector r has the form \theta \cdot \boldsymbol{u}, where \theta represents rotation angle and \boldsymbol{u} represents normalized rotation axis.
Angle and axis could be easily derived as:
\begin{equation} \begin{split} \psi &= ||r||\\ \boldsymbol{u} &= \frac{r}{\theta} \end{split} \end{equation}
Then a quaternion can be calculated by
q = [\cos\psi, \boldsymbol{u}\sin\psi]
where \psi = \theta / 2
get a quaternion from a rotation about the X-axis by \theta .
q = \cos(\theta/2)+sin(\theta/2) i +0 j +0 k
get a quaternion from a rotation about the Y-axis by \theta .
q = \cos(\theta/2)+0 i+ sin(\theta/2) j +0k
get a quaternion from a rotation about the Z-axis by \theta.
q = \cos(\theta/2)+0 i +0 j +sin(\theta/2) k
return the crossProduct between p = (a, b, c, d) = (a, \boldsymbol{u}) and q = (w, x, y, z) = (w, \boldsymbol{v}).
p \times q = \frac{pq- qp}{2}.
p \times q = \boldsymbol{u} \times \boldsymbol{v}.
p \times q = (cz-dy)i + (dx-bz)j + (by-xc)k.
For example
return the dot between quaternion q and this quaternion.
dot(p, q) is a good metric of how close the quaternions are. Indeed, consider the unit quaternion difference p^{-1} * q, its real part is dot(p, q). At the same time its real part is equal to \cos(\beta/2) where \beta is an angle of rotation between p and q, i.e., Therefore, the closer dot(p, q) to 1, the smaller rotation between them.
p \cdot q = p.w \cdot q.w + p.x \cdot q.x + p.y \cdot q.y + p.z \cdot q.z
q | the other quaternion. |
For example
return the value of exponential value.
\exp(q) = e^w (\cos||\boldsymbol{v}||+ \frac{v}{||\boldsymbol{v}||}\sin||\boldsymbol{v}||)
where \boldsymbol{v} = [x, y, z].
For example
_Tp cv::Quat< _Tp >::getAngle | ( | QuatAssumeType | assumeUnit = QUAT_ASSUME_NOT_UNIT | ) | const |
get the angle of quaternion, it returns the rotation angle.
assumeUnit | if QUAT_ASSUME_UNIT, this quaternion assume to be a unit quaternion and this function will save some computations. \psi = 2 *arccos(\frac{w}{||q||}) |
For example
Vec<_Tp, 3> cv::Quat< _Tp >::getAxis | ( | QuatAssumeType | assumeUnit = QUAT_ASSUME_NOT_UNIT | ) | const |
get the axis of quaternion, it returns a vector of length 3.
assumeUnit | if QUAT_ASSUME_UNIT, this quaternion assume to be a unit quaternion and this function will save some computations. |
the unit axis \boldsymbol{u} is defined by
\begin{equation} \begin{split} \boldsymbol{v} &= \boldsymbol{u} ||\boldsymbol{v}||\\ &= \boldsymbol{u}||q||sin(\frac{\theta}{2}) \end{split} \end{equation}
where v=[x, y ,z] and \theta represents rotation angle.
For example
|
static |
This is the part calculation of squad. To calculate the intermedia quaternion s_i between each three quaternion
s_i = q_i\exp(-\frac{\log(q^*_iq_{i+1}) + \log(q^*_iq_{i-1})}{4}).
.
q0 | the first quaternion. |
q1 | the second quaternion. |
q2 | the third quaternion. |
assumeUnit | if QUAT_ASSUME_UNIT, all input quaternions assume to be unit quaternion. Otherwise, all input quaternions will be normalized inside the function. |
Quat<_Tp> cv::Quat< _Tp >::inv | ( | QuatAssumeType | assumeUnit = QUAT_ASSUME_NOT_UNIT | ) | const |
return q^{-1} which is an inverse of q satisfying q * q^{-1} = 1.
assumeUnit | if QUAT_ASSUME_UNIT, quaternion q assume to be a unit quaternion and this function will save some computations. |
For example
bool cv::Quat< _Tp >::isNormal | ( | _Tp | eps = CV_QUAT_EPS | ) | const |
return true if this quaternion is a unit quaternion.
eps | tolerance scope of normalization. The eps could be defined as |
eps = |1 - dotValue|
where
dotValue = (this.w^2 + this.x^2 + this,y^2 + this.z^2).
And this function will consider it is normalized when the dotValue over a range [1-eps, 1+eps].
|
static |
To calculate the interpolation from q_0 to q_1 by Linear Interpolation(Nlerp) For two quaternions, this interpolation curve can be displayed as:
Lerp(q_0, q_1, t) = (1 - t)q_0 + tq_1.
Obviously, the lerp will interpolate along a straight line if we think of q_0 and q_1 as a vector in a two-dimensional space. When t = 0, it returns q_0 and when t= 1, it returns q_1. t should to be ranged in [0, 1] normally.
q0 | a quaternion used in linear interpolation. |
q1 | a quaternion used in linear interpolation. |
t | percent of vector \overrightarrow{q_0q_1} over a range [0, 1]. |
Quat<_Tp> cv::Quat< _Tp >::log | ( | QuatAssumeType | assumeUnit = QUAT_ASSUME_NOT_UNIT | ) | const |
return the value of logarithm function.
\ln(q) = \ln||q|| + \frac{\boldsymbol{v}}{||\boldsymbol{v}||}\arccos\frac{w}{||q||}
. where \boldsymbol{v} = [x, y, z].
assumeUnit | if QUAT_ASSUME_UNIT, this quaternion assume to be a unit quaternion and this function will save some computations. |
For example
|
static |
To calculate the interpolation from q_0 to q_1 by Normalized Linear Interpolation(Nlerp). it returns a normalized quaternion of Linear Interpolation(Lerp).
Nlerp(q_0, q_1, t) = \frac{(1 - t)q_0 + tq_1}{||(1 - t)q_0 + tq_1||}.
The interpolation will always choose the shortest path but the constant speed is not guaranteed.
q0 | a quaternion used in normalized linear interpolation. |
q1 | a quaternion used in normalized linear interpolation. |
t | percent of vector \overrightarrow{q_0q_1} over a range [0, 1]. |
assumeUnit | if QUAT_ASSUME_UNIT, all input quaternions assume to be unit quaternion. Otherwise, all inputs quaternion will be normalized inside the function. |
_Tp cv::Quat< _Tp >::norm | ( | ) | const |
return the norm of quaternion.
||q|| = \sqrt{w^2 + x^2 + y^2 + z^2}.
return a normalized p.
p = \frac{q}{||q||}
where p satisfies (p.x)^2 + (p.y)^2 + (p.z)^2 + (p.w)^2 = 1.
Multiplication operator of two quaternions q and p. Multiplies values on either side of the operator.
Rule of quaternion multiplication:
\begin{equation} \begin{split} p * q &= [p_0, \boldsymbol{u}]*[q_0, \boldsymbol{v}]\\ &=[p_0q_0 - \boldsymbol{u}\cdot \boldsymbol{v}, p_0\boldsymbol{v} + q_0\boldsymbol{u}+ \boldsymbol{u}\times \boldsymbol{v}]. \end{split} \end{equation}
where \cdot means dot product and \times means cross product.
For example
Multiplication assignment operator of two quaternions q and p. It multiplies right operand with the left operand and assign the result to left operand.
Rule of quaternion multiplication:
\begin{equation} \begin{split} p * q &= [p_0, \boldsymbol{u}]*[q_0, \boldsymbol{v}]\\ &=[p_0q_0 - \boldsymbol{u}\cdot \boldsymbol{v}, p_0\boldsymbol{v} + q_0\boldsymbol{u}+ \boldsymbol{u}\times \boldsymbol{v}]. \end{split} \end{equation}
where \cdot means dot product and \times means cross product.
For example
Multiplication assignment operator of a quaternions and a scalar. It multiplies right operand with the left operand and assign the result to left operand.
Rule of quaternion multiplication with a scalar:
\begin{equation} \begin{split} p * s &= [w, x, y, z] * s\\ &=[w * s, x * s, y * s, z * s]. \end{split} \end{equation}
For example
Return opposite quaternion -p which satisfies p + (-p) = 0..
For example
Division operator of a quaternions and a scalar. It divides left operand with the right operand and assign the result to left operand.
Rule of quaternion division with a scalar:
\begin{equation} \begin{split} p / s &= [w, x, y, z] / s\\ &=[w/s, x/s, y/s, z/s]. \end{split} \end{equation}
For example
Division operator of two quaternions p and q. Divides left hand operand by right hand operand.
Rule of quaternion division with a scalar:
\begin{equation} \begin{split} p / q &= p * q.inv()\\ \end{split} \end{equation}
For example
Division assignment operator of a quaternions and a scalar. It divides left operand with the right operand and assign the result to left operand.
Rule of quaternion division with a scalar:
\begin{equation} \begin{split} p / s &= [w, x, y, z] / s\\ &=[w / s, x / s, y / s, z / s]. \end{split} \end{equation}
For example
Division assignment operator of two quaternions p and q; It divides left operand with the right operand and assign the result to left operand.
Rule of quaternion division with a quaternion:
\begin{equation} \begin{split} p / q&= p * q.inv()\\ \end{split} \end{equation}
For example
return true if two quaternions p and q are nearly equal, i.e. when the absolute value of each p_i and q_i is less than CV_QUAT_EPS.
_Tp& cv::Quat< _Tp >::operator[] | ( | std::size_t | n | ) |
const _Tp& cv::Quat< _Tp >::operator[] | ( | std::size_t | n | ) | const |
Quat<_Tp> cv::Quat< _Tp >::power | ( | const _Tp | x, |
QuatAssumeType | assumeUnit = QUAT_ASSUME_NOT_UNIT |
||
) | const |
return the value of power function with index x.
q^x = ||q||(\cos(x\theta) + \boldsymbol{u}\sin(x\theta))).
x | index of exponentiation. |
assumeUnit | if QUAT_ASSUME_UNIT, this quaternion assume to be a unit quaternion and this function will save some computations. |
For example
Quat<_Tp> cv::Quat< _Tp >::power | ( | const Quat< _Tp > & | q, |
QuatAssumeType | assumeUnit = QUAT_ASSUME_NOT_UNIT |
||
) | const |
return the value of power function with quaternion q.
p^q = e^{q\ln(p)}.
q | index quaternion of power function. |
assumeUnit | if QUAT_ASSUME_UNIT, this quaternion assume to be a unit quaternion and this function will save some computations. |
For example
return sin value of this quaternion, sin could be calculated as:
\sin(p) = \sin(w) * \cosh(||\boldsymbol{v}||) + \cos(w)\frac{\boldsymbol{v}}{||\boldsymbol{v}||}\sinh(||\boldsymbol{v}||)
where \boldsymbol{v} = [x, y, z].
For example
return sinh value of this quaternion, sinh could be calculated as: \sinh(p) = \sin(w)\cos(||\boldsymbol{v}||) + \cosh(w)\frac{v}{||\boldsymbol{v}||}\sin||\boldsymbol{v}|| where \boldsymbol{v} = [x, y, z].
For example
|
static |
To calculate the interpolation between q_0 and q_1 by Spherical Linear Interpolation(Slerp), which can be defined as:
Slerp(q_0, q_1, t) = \frac{\sin((1-t)\theta)}{\sin(\theta)}q_0 + \frac{\sin(t\theta)}{\sin(\theta)}q_1
where \theta can be calculated as:
\theta=cos^{-1}(q_0\cdot q_1)
resulting from the both of their norm is unit.
q0 | a quaternion used in Slerp. |
q1 | a quaternion used in Slerp. |
t | percent of angle between q_0 and q_1 over a range [0, 1]. |
assumeUnit | if QUAT_ASSUME_UNIT, all input quaternions assume to be unit quaternions. Otherwise, all input quaternions will be normalized inside the function. |
directChange | if QUAT_ASSUME_UNIT, the interpolation will choose the nearest path. |
|
static |
to calculate a quaternion which is the result of a C^1 continuous spline curve constructed by squad at the ratio t. Here, the interpolation values are between q_1 and q_2. q_0 and q_2 are used to ensure the C^1 continuity. if t = 0, it returns q_1, if t = 1, it returns q_2.
q0 | the first input quaternion to ensure C^1 continuity. |
q1 | the second input quaternion. |
q2 | the third input quaternion. |
q3 | the fourth input quaternion the same use of q1. |
t | ratio over a range [0, 1]. |
assumeUnit | if QUAT_ASSUME_UNIT, q_0, q_1, q_2, q_3 assume to be unit quaternion. Otherwise, all input quaternions will be normalized inside the function. |
For example:
If there are three double quaternions v_0, v_1, v_2 waiting to be interpolated.
Interpolation between v_0 and v_1 with a ratio t_0 could be calculated as
Interpolation between v_1 and v_2 with a ratio t_0 could be calculated as
Quat<_Tp> cv::Quat< _Tp >::sqrt | ( | QuatAssumeType | assumeUnit = QUAT_ASSUME_NOT_UNIT | ) | const |
return \sqrt{q}.
assumeUnit | if QUAT_ASSUME_UNIT, this quaternion assume to be a unit quaternion and this function will save some computations. |
For example
|
static |
To calculate the interpolation between q_0, q_1, q_2, q_3 by Spherical and quadrangle(Squad). This could be defined as:
Squad(q_i, s_i, s_{i+1}, q_{i+1}, t) = Slerp(Slerp(q_i, q_{i+1}, t), Slerp(s_i, s_{i+1}, t), 2t(1-t))
where
s_i = q_i\exp(-\frac{\log(q^*_iq_{i+1}) + \log(q^*_iq_{i-1})}{4})
.
The Squad expression is analogous to the B\acute{e}zier curve, but involves spherical linear interpolation instead of simple linear interpolation. Each s_i needs to be calculated by three quaternions.
q0 | the first quaternion. |
s0 | the second quaternion. |
s1 | the third quaternion. |
q1 | thr fourth quaternion. |
t | interpolation parameter of quadratic and linear interpolation over a range [0, 1]. |
assumeUnit | if QUAT_ASSUME_UNIT, all input quaternions assume to be unit quaternion. Otherwise, all input quaternions will be normalized inside the function. |
directChange | if QUAT_ASSUME_UNIT, squad will find the nearest path to interpolate. |
return tan value of this quaternion, tan could be calculated as:
\tan(q) = \frac{\sin(q)}{\cos(q)}.
For example
Vec<_Tp, 3> cv::Quat< _Tp >::toEulerAngles | ( | QuatEnum::EulerAnglesType | eulerAnglesType | ) |
Transform a quaternion q to Euler angles.
When transforming a quaternion q = w + x\boldsymbol{i} + y\boldsymbol{j} + z\boldsymbol{k} to Euler angles, rotation matrix M can be calculated by:
\begin{aligned} {M} &={\begin{bmatrix}1-2(y^{2}+z^{2})&2(xy-zx)&2(xz+yw)\\2(xy+zw)&1-2(x^{2}+z^{2})&2(yz-xw)\\2(xz-yw)&2(yz+xw)&1-2(x^{2}+y^{2})\end{bmatrix}}\end{aligned}.
On the other hand, the rotation matrix can be obtained from Euler angles. Using intrinsic rotations with Euler angles type XYZ as an example, \theta_1 , \theta_2 , \theta_3 are three angles for Euler angles, the rotation matrix R can be calculated by:
R =X(\theta_1)Y(\theta_2)Z(\theta_3) ={\begin{bmatrix}\cos\theta_{2}\cos\theta_{3}&-\cos\theta_{2}\sin\theta_{3}&\sin\theta_{2}\\\cos\theta_{1}\sin\theta_{3}+\cos\theta_{3}\sin\theta_{1}\sin\theta_{2}&\cos\theta_{1}\cos\theta_{3}-\sin\theta_{1}\sin\theta_{2}\sin\theta_{3}&-\cos\theta_{2}\sin\theta_{1}\\\sin\theta_{1}\sin\theta_{3}-\cos\theta_{1}\cos\theta_{3}\sin\theta_{2}&\cos\theta_{3}\sin\theta_{1}+\cos\theta_{1}\sin\theta_{2}\sin\theta_{3}&\cos\theta_{1}\cos_{2}\end{bmatrix}}
Rotation matrix M and R are equal. As long as s_{2} \neq 1 , by comparing each element of two matrices ,the solution is \begin{cases} \theta_1 = \arctan2(-m_{23},m_{33})\\\theta_2 = arcsin(m_{13}) \\\theta_3 = \arctan2(-m_{12},m_{11}) \end{cases}.
When s_{2}=1 or s_{2}=-1, the gimbal lock occurs. The function will prompt "WARNING: Gimbal Lock will occur. Euler angles is non-unique. For intrinsic rotations, we set the third angle to 0, and for external rotation, we set the first angle to 0.".
When s_{2}=1 , The rotation matrix R is R = {\begin{bmatrix}0&0&1\\\sin(\theta_1+\theta_3)&\cos(\theta_1+\theta_3)&0\\-\cos(\theta_1+\theta_3)&\sin(\theta_1+\theta_3)&0\end{bmatrix}}.
The number of solutions is infinite with the condition \begin{cases} \theta_1+\theta_3 = \arctan2(m_{21},m_{22})\\ \theta_2=\pi/2 \end{cases}\ .
We set \theta_3 = 0, the solution is \begin{cases} \theta_1=\arctan2(m_{21},m_{22})\\ \theta_2=\pi/2\\ \theta_3=0 \end{cases}.
When s_{2}=-1, The rotation matrix R is X_{1}Y_{2}Z_{3}={\begin{bmatrix}0&0&-1\\-\sin(\theta_1-\theta_3)&\cos(\theta_1-\theta_3)&0\\\cos(\theta_1-\theta_3)&\sin(\theta_1-\theta_3)&0\end{bmatrix}}.
The number of solutions is infinite with the condition \begin{cases} \theta_1+\theta_3 = \arctan2(m_{32},m_{22})\\ \theta_2=\pi/2 \end{cases}\ .
We set \theta_3 = 0, the solution is \begin{cases}\theta_1=\arctan2(m_{32},m_{22}) \\ \theta_2=-\pi/2\\ \theta_3=0\end{cases}.
Since sin \theta\in [-1,1] and cos \theta \in [-1,1] , the unnormalized quaternion will cause computational troubles. For this reason, this function will normalize the quaternion at first and QuatAssumeType is not needed.
When the gimbal lock occurs, we set \theta_3 = 0 for intrinsic rotations or \theta_1 = 0 for extrinsic rotations.
As a result, for every Euler angles type, we can get solution as shown in the following table.
EulerAnglesType | Ordinary | \theta_2 = π/2 | \theta_2 = -π/2 |
---|---|---|---|
INT_XYZ | \theta_1 = \arctan2(-m_{23},m_{33})\\\theta_2 = \arcsin(m_{13}) \\\theta_3= \arctan2(-m_{12},m_{11}) | \theta_1=\arctan2(m_{21},m_{22})\\ \theta_2=\pi/2\\ \theta_3=0 | \theta_1=\arctan2(m_{32},m_{22})\\ \theta_2=-\pi/2\\ \theta_3=0 |
INT_XZY | \theta_1 = \arctan2(m_{32},m_{22})\\\theta_2 = -\arcsin(m_{12}) \\\theta_3= \arctan2(m_{13},m_{11}) | \theta_1=\arctan2(m_{31},m_{33})\\ \theta_2=\pi/2\\ \theta_3=0 | \theta_1=\arctan2(-m_{23},m_{33})\\ \theta_2=-\pi/2\\ \theta_3=0 |
INT_YXZ | \theta_1 = \arctan2(m_{13},m_{33})\\\theta_2 = -\arcsin(m_{23}) \\\theta_3= \arctan2(m_{21},m_{22}) | \theta_1=\arctan2(m_{12},m_{11})\\ \theta_2=\pi/2\\ \theta_3=0 | \theta_1=\arctan2(-m_{12},m_{11})\\ \theta_2=-\pi/2\\ \theta_3=0 |
INT_YZX | \theta_1 = \arctan2(-m_{31},m_{11})\\\theta_2 = \arcsin(m_{21}) \\\theta_3= \arctan2(-m_{23},m_{22}) | \theta_1=\arctan2(m_{13},m_{33})\\ \theta_2=\pi/2\\ \theta_3=0 | \theta_1=\arctan2(m_{13},m_{12})\\ \theta_2=-\pi/2\\ \theta_3=0 |
INT_ZXY | \theta_1 = \arctan2(-m_{12},m_{22})\\\theta_2 = \arcsin(m_{32}) \\\theta_3= \arctan2(-m_{31},m_{33}) | \theta_1=\arctan2(m_{21},m_{11})\\ \theta_2=\pi/2\\ \theta_3=0 | \theta_1=\arctan2(m_{21},m_{11})\\ \theta_2=-\pi/2\\ \theta_3=0 |
INT_ZYX | \theta_1 = \arctan2(m_{21},m_{11})\\\theta_2 = \arcsin(-m_{31}) \\\theta_3= \arctan2(m_{32},m_{33}) | \theta_1=\arctan2(m_{23},m_{22})\\ \theta_2=\pi/2\\ \theta_3=0 | \theta_1=\arctan2(-m_{12},m_{22})\\ \theta_2=-\pi/2\\ \theta_3=0 |
EXT_XYZ | \theta_1 = \arctan2(m_{32},m_{33})\\\theta_2 = \arcsin(-m_{31}) \\\ \theta_3 = \arctan2(m_{21},m_{11}) | \theta_1= 0\\ \theta_2=\pi/2\\ \theta_3=\arctan2(m_{23},m_{22}) | \theta_1=0\\ \theta_2=-\pi/2\\ \theta_3=\arctan2(-m_{12},m_{22}) |
EXT_XZY | \theta_1 = \arctan2(-m_{23},m_{22})\\\theta_2 = \arcsin(m_{21}) \\\theta_3= \arctan2(-m_{31},m_{11}) | \theta_1= 0\\ \theta_2=\pi/2\\ \theta_3=\arctan2(m_{13},m_{33}) | \theta_1=0\\ \theta_2=-\pi/2\\ \theta_3=\arctan2(m_{13},m_{12}) |
EXT_YXZ | \theta_1 = \arctan2(-m_{31},m_{33}) \\\theta_2 = \arcsin(m_{32}) \\\theta_3= \arctan2(-m_{12},m_{22}) | \theta_1= 0\\ \theta_2=\pi/2\\ \theta_3=\arctan2(m_{21},m_{11}) | \theta_1=0\\ \theta_2=-\pi/2\\ \theta_3=\arctan2(m_{21},m_{11}) |
EXT_YZX | \theta_1 = \arctan2(m_{13},m_{11})\\\theta_2 = -\arcsin(m_{12}) \\\theta_3= \arctan2(m_{32},m_{22}) | \theta_1= 0\\ \theta_2=\pi/2\\ \theta_3=\arctan2(m_{31},m_{33}) | \theta_1=0\\ \theta_2=-\pi/2\\ \theta_3=\arctan2(-m_{23},m_{33}) |
EXT_ZXY | \theta_1 = \arctan2(m_{21},m_{22})\\\theta_2 = -\arcsin(m_{23}) \\\theta_3= \arctan2(m_{13},m_{33}) | \theta_1= 0\\ \theta_2=\pi/2\\ \theta_3=\arctan2(m_{12},m_{11}) | \theta_1= 0\\ \theta_2=-\pi/2\\ \theta_3=\arctan2(-m_{12},m_{11}) |
EXT_ZYX | \theta_1 = \arctan2(-m_{12},m_{11})\\\theta_2 = \arcsin(m_{13}) \\\theta_3= \arctan2(-m_{23},m_{33}) | \theta_1=0\\ \theta_2=\pi/2\\ \theta_3=\arctan2(m_{21},m_{22}) | \theta_1=0\\ \theta_2=-\pi/2\\ \theta_3=\arctan2(m_{32},m_{22}) |
EulerAnglesType | Ordinary | \theta_2 = 0 | \theta_2 = π |
---|---|---|---|
INT_XYX | \theta_1 = \arctan2(m_{21},-m_{31})\\\theta_2 =\arccos(m_{11}) \\\theta_3 = \arctan2(m_{12},m_{13}) | \theta_1=\arctan2(m_{32},m_{33})\\ \theta_2=0\\ \theta_3=0 | \theta_1=\arctan2(m_{23},m_{22})\\ \theta_2=\pi\\ \theta_3=0 |
INT_XZX | \theta_1 = \arctan2(m_{31},m_{21})\\\theta_2 = \arccos(m_{11}) \\\theta_3 = \arctan2(m_{13},-m_{12}) | \theta_1=\arctan2(m_{32},m_{33})\\ \theta_2=0\\ \theta_3=0 | \theta_1=\arctan2(-m_{32},m_{33})\\ \theta_2=\pi\\ \theta_3=0 |
INT_YXY | \theta_1 = \arctan2(m_{12},m_{32})\\\theta_2 = \arccos(m_{22}) \\\theta_3 = \arctan2(m_{21},-m_{23}) | \theta_1=\arctan2(m_{13},m_{11})\\ \theta_2=0\\ \theta_3=0 | \theta_1=\arctan2(-m_{31},m_{11})\\ \theta_2=\pi\\ \theta_3=0 |
INT_YZY | \theta_1 = \arctan2(m_{32},-m_{12})\\\theta_2 = \arccos(m_{22}) \\\theta_3 =\arctan2(m_{23},m_{21}) | \theta_1=\arctan2(m_{13},m_{11})\\ \theta_2=0\\ \theta_3=0 | \theta_1=\arctan2(m_{13},-m_{11})\\ \theta_2=\pi\\ \theta_3=0 |
INT_ZXZ | \theta_1 = \arctan2(-m_{13},m_{23})\\\theta_2 = \arccos(m_{33}) \\\theta_3 =\arctan2(m_{31},m_{32}) | \theta_1=\arctan2(m_{21},m_{22})\\ \theta_2=0\\ \theta_3=0 | \theta_1=\arctan2(m_{21},m_{11})\\ \theta_2=\pi\\ \theta_3=0 |
INT_ZYZ | \theta_1 = \arctan2(m_{23},m_{13})\\\theta_2 = \arccos(m_{33}) \\\theta_3 = \arctan2(m_{32},-m_{31}) | \theta_1=\arctan2(m_{21},m_{11})\\ \theta_2=0\\ \theta_3=0 | \theta_1=\arctan2(m_{21},m_{11})\\ \theta_2=\pi\\ \theta_3=0 |
EXT_XYX | \theta_1 = \arctan2(m_{12},m_{13}) \\\theta_2 = \arccos(m_{11}) \\\theta_3 = \arctan2(m_{21},-m_{31}) | \theta_1=0\\ \theta_2=0\\ \theta_3=\arctan2(m_{32},m_{33}) | \theta_1= 0\\ \theta_2=\pi\\ \theta_3= \arctan2(m_{23},m_{22}) |
EXT_XZX | \theta_1 = \arctan2(m_{13},-m_{12})\\\theta_2 = \arccos(m_{11}) \\\theta_3 = \arctan2(m_{31},m_{21}) | \theta_1= 0\\ \theta_2=0\\ \theta_3=\arctan2(m_{32},m_{33}) | \theta_1= 0\\ \theta_2=\pi\\ \theta_3=\arctan2(-m_{32},m_{33}) |
EXT_YXY | \theta_1 = \arctan2(m_{21},-m_{23})\\\theta_2 = \arccos(m_{22}) \\\theta_3 = \arctan2(m_{12},m_{32}) | \theta_1= 0\\ \theta_2=0\\ \theta_3=\arctan2(m_{13},m_{11}) | \theta_1= 0\\ \theta_2=\pi\\ \theta_3=\arctan2(-m_{31},m_{11}) |
EXT_YZY | \theta_1 = \arctan2(m_{23},m_{21}) \\\theta_2 = \arccos(m_{22}) \\\theta_3 = \arctan2(m_{32},-m_{12}) | \theta_1= 0\\ \theta_2=0\\ \theta_3=\arctan2(m_{13},m_{11}) | \theta_1=0\\ \theta_2=\pi\\ \theta_3=\arctan2(m_{13},-m_{11}) |
EXT_ZXZ | \theta_1 = \arctan2(m_{31},m_{32}) \\\theta_2 = \arccos(m_{33}) \\\theta_3 = \arctan2(-m_{13},m_{23}) | \theta_1=0\\ \theta_2=0\\ \theta_3=\arctan2(m_{21},m_{22}) | \theta_1= 0\\ \theta_2=\pi\\ \theta_3=\arctan2(m_{21},m_{11}) |
EXT_ZYZ | \theta_1 = \arctan2(m_{32},-m_{31})\\\theta_2 = \arccos(m_{33}) \\\theta_3 = \arctan2(m_{23},m_{13}) | \theta_1=0\\ \theta_2=0\\ \theta_3=\arctan2(m_{21},m_{11}) | \theta_1= 0\\ \theta_2=\pi\\ \theta_3=\arctan2(m_{21},m_{11}) |
eulerAnglesType | the convertion Euler angles type |
Matx<_Tp, 3, 3> cv::Quat< _Tp >::toRotMat3x3 | ( | QuatAssumeType | assumeUnit = QUAT_ASSUME_NOT_UNIT | ) | const |
transform a quaternion to a 3x3 rotation matrix.
assumeUnit | if QUAT_ASSUME_UNIT, this quaternion assume to be a unit quaternion and this function will save some computations. Otherwise, this function will normalize this quaternion at first then do the transformation. |
\begin{bmatrix} x_0& x_1& x_2&...&x_n\\ y_0& y_1& y_2&...&y_n\\ z_0& z_1& z_2&...&z_n \end{bmatrix}
For example
Matx<_Tp, 4, 4> cv::Quat< _Tp >::toRotMat4x4 | ( | QuatAssumeType | assumeUnit = QUAT_ASSUME_NOT_UNIT | ) | const |
transform a quaternion to a 4x4 rotation matrix.
assumeUnit | if QUAT_ASSUME_UNIT, this quaternion assume to be a unit quaternion and this function will save some computations. Otherwise, this function will normalize this quaternion at first then do the transformation. |
The operations is similar as toRotMat3x3 except that the points matrix should have the form
\begin{bmatrix} x_0& x_1& x_2&...&x_n\\ y_0& y_1& y_2&...&y_n\\ z_0& z_1& z_2&...&z_n\\ 0&0&0&...&0 \end{bmatrix}
Vec<_Tp, 3> cv::Quat< _Tp >::toRotVec | ( | QuatAssumeType | assumeUnit = QUAT_ASSUME_NOT_UNIT | ) | const |
transform this quaternion to a Rotation vector.
assumeUnit | if QUAT_ASSUME_UNIT, this quaternion assume to be a unit quaternion and this function will save some computations. Rotation vector rVec is defined as: rVec = [\theta v_x, \theta v_y, \theta v_z]
where \theta represents rotation angle, and \boldsymbol{v} represents the normalized rotation axis. |
For example
|
friend |
return the crossProduct between p = (a, b, c, d) = (a, \boldsymbol{u}) and q = (w, x, y, z) = (w, \boldsymbol{v}).
p \times q = \frac{pq- qp}{2}
p \times q = \boldsymbol{u} \times \boldsymbol{v}
p \times q = (cz-dy)i + (dx-bz)j + (by-xc)k
For example
|
friend |
Multiplication operator of a scalar and a quaternions. It multiplies right operand with the left operand and assign the result to left operand.
Rule of quaternion multiplication with a scalar:
\begin{equation} \begin{split} p * s &= [w, x, y, z] * s\\ &=[w * s, x * s, y * s, z * s]. \end{split} \end{equation}
For example
|
friend |
Multiplication operator of a quaternion and a scalar. It multiplies right operand with the left operand and assign the result to left operand.
Rule of quaternion multiplication with a scalar:
\begin{equation} \begin{split} p * s &= [w, x, y, z] * s\\ &=[w * s, x * s, y * s, z * s]. \end{split} \end{equation}
For example
|
friend |
Addition operator of a quaternions and a scalar. Adds right hand operand from left hand operand.
For example
|
friend |
Addition operator of a quaternions and a scalar. Adds right hand operand from left hand operand.
For example
|
friend |
Subtraction operator of a scalar and a quaternions. Subtracts right hand operand from left hand operand.
For example
|
friend |
Subtraction operator of a quaternions and a scalar. Subtracts right hand operand from left hand operand.
For example
|
friend |
|
friend |
return q^{-1} which is an inverse of q which satisfies q * q^{-1} = 1.
q | a quaternion. |
assumeUnit | if QUAT_ASSUME_UNIT, quaternion q assume to be a unit quaternion and this function will save some computations. |
For example
|
friend |
return the value of logarithm function.
\ln(q) = \ln||q|| + \frac{\boldsymbol{v}}{||\boldsymbol{v}||}\arccos\frac{w}{||q||}.
where \boldsymbol{v} = [x, y, z].
q | a quaternion. |
assumeUnit | if QUAT_ASSUME_UNIT, q assume to be a unit quaternion and this function will save some computations. |
For example
|
friend |
return the value of power function with index x.
q^x = ||q||(cos(x\theta) + \boldsymbol{u}sin(x\theta))).
q | a quaternion. |
x | index of exponentiation. |
assumeUnit | if QUAT_ASSUME_UNIT, quaternion q assume to be a unit quaternion and this function will save some computations. |
For example
|
friend |
return the value of power function with quaternion q.
p^q = e^{q\ln(p)}.
p | base quaternion of power function. |
q | index quaternion of power function. |
assumeUnit | if QUAT_ASSUME_UNIT, quaternion p assume to be a unit quaternion and this function will save some computations. |
For example
|
friend |
return \sqrt{q}.
q | a quaternion. |
assumeUnit | if QUAT_ASSUME_UNIT, quaternion q assume to be a unit quaternion and this function will save some computations. |
For example
|
static |
|
static |
_Tp cv::Quat< _Tp >::w |
_Tp cv::Quat< _Tp >::x |
_Tp cv::Quat< _Tp >::y |
_Tp cv::Quat< _Tp >::z |