Quaternion#

Detailed Description#

Classes#

Name	Description
`class` `cv::DualQuat< _Tp >`	View details
`class` `cv::Quat< _Tp >`	View details
`class` `cv::QuatEnum`	View details

Enumerations#

enum cv::QuatAssumeType {
    cv::QUAT_ASSUME_NOT_UNIT,
    cv::QUAT_ASSUME_UNIT
}

Unit quaternion flag. View details

Typedef Documentation#

DualQuatd#

typedef DualQuat< double > cv::DualQuatd

#include <opencv2/core/dualquaternion.hpp>

DualQuatf#

typedef DualQuat< float > cv::DualQuatf

#include <opencv2/core/dualquaternion.hpp>

Quatd#

typedef Quat< double > cv::Quatd

#include <opencv2/core/quaternion.hpp>

Quatf#

typedef Quat< float > cv::Quatf

#include <opencv2/core/quaternion.hpp>

Enumeration Type Documentation#

QuatAssumeType#

enum cv::QuatAssumeType

#include <opencv2/core/quaternion.hpp>

Unit quaternion flag.

Enumerator:

`QUAT_ASSUME_NOT_UNIT` Python: `cv.QUAT_ASSUME_NOT_UNIT`	This flag is specified by default. If this flag is specified, the input quaternions are assumed to be not unit quaternions. It can guarantee the correctness of the calculations, although the calculation speed will be slower than the flag QUAT_ASSUME_UNIT.
`QUAT_ASSUME_UNIT` Python: `cv.QUAT_ASSUME_UNIT`	If this flag is specified, the input quaternions are assumed to be unit quaternions which will save some computations. However, if this flag is specified without unit quaternion, the program correctness of the result will not be guaranteed.

Function Documentation#

acos()#

template<typename T>
Quat< T > cv::acos(const Quat< T > & q)

#include <opencv2/core/quaternion.hpp>

\[ \arccos(q) = -\frac{\boldsymbol{v}}{||\boldsymbol{v}||}arccosh(q) \]

where \(\boldsymbol{v} = [x, y, z].\) For example

Quatd q(1,2,3,4);
acos(q);

Parameters

q — a quaternion.

acosh()#

template<typename T>
Quat< T > cv::acosh(const Quat< T > & q)

#include <opencv2/core/quaternion.hpp>

\[ arccosh(q) = \ln(q + \sqrt{q^2 - 1}) \]

. For example

Quatd q(1,2,3,4);
acosh(q);

Parameters

q — a quaternion.

asin()#

template<typename T>
Quat< T > cv::asin(const Quat< T > & q)

#include <opencv2/core/quaternion.hpp>

\[ \arcsin(q) = -\frac{\boldsymbol{v}}{||\boldsymbol{v}||}arcsinh(q\frac{\boldsymbol{v}}{||\boldsymbol{v}||}) \]

where \(\boldsymbol{v} = [x, y, z].\) For example

Quatd q(1,2,3,4);
asin(q);

Parameters

q — a quaternion.

asinh()#

template<typename T>
Quat< T > cv::asinh(const Quat< T > & q)

#include <opencv2/core/quaternion.hpp>

\[ arcsinh(q) = \ln(q + \sqrt{q^2 + 1}) \]

. For example

Quatd q(1,2,3,4);
asinh(q);

Parameters

q — a quaternion.

atan()#

template<typename T>
Quat< T > cv::atan(const Quat< T > & q)

#include <opencv2/core/quaternion.hpp>

\[ \arctan(q) = -\frac{\boldsymbol{v}}{||\boldsymbol{v}||}arctanh(q\frac{\boldsymbol{v}}{||\boldsymbol{v}||}) \]

where \(\boldsymbol{v} = [x, y, z].\) For example

Quatd q(1,2,3,4);
atan(q);

Parameters

q — a quaternion.

atanh()#

template<typename T>
Quat< T > cv::atanh(const Quat< T > & q)

#include <opencv2/core/quaternion.hpp>

\[ arctanh(q) = \frac{\ln(q + 1) - \ln(1 - q)}{2} \]

. For example

Quatd q(1,2,3,4);
atanh(q);

Parameters

q — a quaternion.

cos()#

template<typename T>
Quat< T > cv::cos(const Quat< T > & q)

#include <opencv2/core/quaternion.hpp>

\[ \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

Quatd q(1,2,3,4);
cos(q);

Parameters

q — a quaternion.

cosh()#

template<typename T>
Quat< T > cv::cosh(const Quat< T > & q)

#include <opencv2/core/quaternion.hpp>

\[ \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

Quatd q(1,2,3,4);
cosh(q);

Parameters

q — a quaternion.

crossProduct()#

template<typename T>
Quat< T > cv::crossProduct(
const Quat< T > & p,
const Quat< T > & q )

#include <opencv2/core/quaternion.hpp>

\[ 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

Quatd q{1,2,3,4};
Quatd p{5,6,7,8};
crossProduct(p, q);

exp()#

template<typename T>
Quat< T > cv::exp(const Quat< T > & q)

#include <opencv2/core/quaternion.hpp>

\[ \exp(q) = e^w (\cos||\boldsymbol{v}||+ \frac{v}{||\boldsymbol{v}||})\sin||\boldsymbol{v}|| \]

where \(\boldsymbol{v} = [x, y, z].\) For example:

Quatd q{1,2,3,4};
cout << exp(q) << endl;

Parameters

q — a quaternion.

inv()#

template<typename T>
Quat< T > cv::inv(
const Quat< T > & q,
QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT )

#include <opencv2/core/quaternion.hpp>

For example

Quatd q(1,2,3,4);
inv(q);

QuatAssumeType assumeUnit = QUAT_ASSUME_UNIT;
q = q.normalize();
inv(q, assumeUnit);//This assumeUnit means p is a unit quaternion

Parameters

q — a quaternion.
assumeUnit — if QUAT_ASSUME_UNIT, quaternion q assume to be a unit quaternion and this function will save some computations.

log()#

template<typename T>
Quat< T > cv::log(
const Quat< T > & q,
QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT )

#include <opencv2/core/quaternion.hpp>

\[ \ln(q) = \ln||q|| + \frac{\boldsymbol{v}}{||\boldsymbol{v}||}\arccos\frac{w}{||q||}. \]

where \(\boldsymbol{v} = [x, y, z].\) For example

Quatd q1{1,2,3,4};
cout << log(q1) << endl;

Parameters

q — a quaternion.
assumeUnit — if QUAT_ASSUME_UNIT, q assume to be a unit quaternion and this function will save some computations.

operator*() [1/2]#

template<typename T>
Quat< T > cv::operator*(
const Quat< T > & ,
const T )

#include <opencv2/core/quaternion.hpp>

operator*() [2/2]#

template<typename T>
Quat< T > cv::operator*(
const T ,
const Quat< T > & )

#include <opencv2/core/quaternion.hpp>

operator<<() [1/3]#

template<typename _Tp>
std::ostream & cv::operator<<(
std::ostream & ,
const DualQuat< _Tp > & )

#include <opencv2/core/dualquaternion.hpp>

operator<<() [2/3]#

template<typename _Tp>
std::ostream & cv::operator<<(
std::ostream & ,
const Quat< _Tp > & )

#include <opencv2/core/quaternion.hpp>

operator<<() [3/3]#

template<typename S>
std::ostream & cv::operator<<(
std::ostream & ,
const Quat< S > & )

#include <opencv2/core/quaternion.hpp>

power() [1/2]#

template<typename T>
Quat< T > cv::power(
const Quat< T > & q,
const Quat< T > & p,
QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT )

#include <opencv2/core/quaternion.hpp>

\[ p^q = e^{q\ln(p)}. \]

For example

Quatd p(1,2,3,4);
Quatd q(5,6,7,8);
power(p, q);

QuatAssumeType assumeUnit = QUAT_ASSUME_UNIT;
p = p.normalize();
power(p, q, assumeUnit); //This assumeUnit means p is a unit quaternion

Parameters

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.

power() [2/2]#

template<typename T>
Quat< T > cv::power(
const Quat< T > & q,
const T x,
QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT )

#include <opencv2/core/quaternion.hpp>

\[ q^x = ||q||(cos(x\theta) + \boldsymbol{u}sin(x\theta))). \]

For example

Quatd q(1,2,3,4);
power(q, 2.0);

QuatAssumeType assumeUnit = QUAT_ASSUME_UNIT;
double angle = CV_PI;
Vec3d axis{0, 0, 1};
Quatd q1 = Quatd::createFromAngleAxis(angle, axis); //generate a unit quat by axis and angle
power(q1, 2.0, assumeUnit);//This assumeUnit means q1 is a unit quaternion.

Note

the type of the index should be the same as the quaternion.

Parameters

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.

sin()#

template<typename T>
Quat< T > cv::sin(const Quat< T > & q)

#include <opencv2/core/quaternion.hpp>

\[ \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

Quatd q(1,2,3,4);
sin(q);

Parameters

q — a quaternion.

sinh()#

template<typename T>
Quat< T > cv::sinh(const Quat< T > & q)

#include <opencv2/core/quaternion.hpp>

\[ \sinh(p) = \sin(w)\cos(||\boldsymbol{v}||) + \cosh(w)\frac{v}{||\boldsymbol{v}||}\sin||\boldsymbol{v}|| \]

where \(\boldsymbol{v} = [x, y, z].\) For example

Quatd q(1,2,3,4);
sinh(q);

Parameters

q — a quaternion.

sqrt()#

template<typename S>
Quat< S > cv::sqrt(
const Quat< S > & q,
QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT )

#include <opencv2/core/quaternion.hpp>

tan()#

template<typename T>
Quat< T > cv::tan(const Quat< T > & q)

#include <opencv2/core/quaternion.hpp>

\[ \tan(q) = \frac{\sin(q)}{\cos(q)}. \]

For example

Quatd q(1,2,3,4);
tan(q);

Parameters

q — a quaternion.

tanh()#

template<typename T>
Quat< T > cv::tanh(const Quat< T > & q)

#include <opencv2/core/quaternion.hpp>

\[ \tanh(q) = \frac{\sinh(q)}{\cosh(q)}. \]

For example

Quatd q(1,2,3,4);
tanh(q);