cv::Quat<_Tp> 类模板参考

#include <opencv2/core/quaternion.hpp>

cv::Quat<_Tp> 的协作图

公有成员函数
	Quat ()
	Quat (_Tp w, _Tp x, _Tp y, _Tp z)
	从四个数字创建。
	Quat (const Vec< _Tp, 4 > &coeff)
	从 Vec4d 或 Vec4f。
Quat< _Tp >	acos () const
	返回此四元数的 arccos 值，arccos 可以按照以下方式计算：
Quat< _Tp >	acosh () const
	返回此四元数的 arccosh 值，arccosh 可以按照以下方式计算：
Quat< _Tp >	asin () const
	返回此四元数的 arcsin 值，arcsin 可以按照以下方式计算：
Quat< _Tp >	asinh () const
	返回此四元数的 arcsinh 值，arcsinh 可以按照以下方式计算：
void	assertNormal (_Tp eps=CV_QUAT_EPS) const
	如果此四元数不是单位四元数则抛出错误。
_Tp	at (size_t index) const
	获取元素的一种方式。
Quat< _Tp >	atan () const
	返回此四元数的 arctan 值，arctan 可以按照以下方式计算：
Quat< _Tp >	atanh () const
	返回此四元数的 arctanh 值，arctanh 可以按照以下方式计算：
Quat< _Tp >	Conjugate () const
	返回此四元数的共轭。
Quat< _Tp >	cos () const
	返回此四元数的 cos 值，cos 可以按照以下方式计算：
Quat< _Tp >	cosh () const
	返回此四元数的 cosh 值，cosh 可以按照以下方式计算：
Quat< _Tp >	crossProduct (const Quat< _Tp > &q) const
	返回 \(p = (a, b, c, d) = (a, \boldsymbol{u})\) 与 \(q = (w, x, y, z) = (w, \boldsymbol{v})\) 之间的叉乘。
_Tp	dot (Quat< _Tp > q) const
	返回四元数 \(q\) 和此四元数之间的点乘。
Quat< _Tp >	exp () const
	返回指数值。
_Tp	getAngle (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	获取四元数的角度，它返回旋转角度。
Vec< _Tp, 3 >	getAxis (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	获取四元数的轴，它返回一个长度为3的向量。
Quat< _Tp >	inv (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	返回 \(q^{-1}\) ，这是 \(q\) 的逆元，满足 \(q * q^{-1} = 1\)。
bool	isNormal (_Tp eps=CV_QUAT_EPS) const
	如果这个四元数是单位四元数，则返回 true。
Quat< _Tp >	log (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	返回对数函数的值。
_Tp	norm () const
	返回四元数的范数。
Quat< _Tp >	normalize () const
	返回一个归一化的 \(p\)。
Quat< _Tp >	operator* (const Quat< _Tp > &) const
	两个四元数 q 和 p 的乘法运算符。乘以运算符两边的值。
Quat< _Tp > &	operator*= (const _Tp s)
	四元数和标量相乘的赋值运算符。使用右操作数乘以左操作数，并将结果赋给左操作数。
Quat< _Tp > &	operator*= (const Quat< _Tp > &)
	两个四元数 q 和 p 的乘法赋值运算符。使用右操作数乘以左操作数，并将结果赋给左操作数。
Quat< _Tp >	operator+ (const Quat< _Tp > &) const
	两个四元数 p 和 q 的加法运算符。它返回一个新的四元数，其每个值都是 \(p_i\) 和 \(q_i\) 的和。
Quat< _Tp > &	operator+= (const Quat< _Tp> &)
	两个四元数 p 和 q 的加法赋值运算符。将右操作数加到左操作数上，并将结果赋给左操作数。
Quat< _Tp >	operator- () const
	返回相反的四元数 \(-p\)，它满足 \(p + (-p) = 0\)。
Quat< _Tp >	operator- (const Quat< _Tp > &) const
	两个四元数 p 和 q 的减法运算符。它返回一个新的四元数，其中每个值都是 \(p_i\) 和 \(-q_i\) 的和。
Quat< _Tp > &	operator-=` (const Quat< _Tp > &)
	两个四元数 p 和 q 的减法赋值运算符。它将右操作数从左操作数中减去，并将结果赋给左操作数。
Quat< _Tp >	operator/ (const _Tp s) const
	四元数与标量的除法运算符。它将左操作数除以右操作数，并将结果赋给左操作数。
Quat< _Tp >	operator/ (const Quat< _Tp > &) const
	两个四元数 p 和 q 的除法运算符。将左操作数除以右操作数。
Quat< _Tp > &	operator/= (const _Tp s)
	四元数与标量的除法赋值运算符。它将左操作数除以右操作数，并将结果赋给左操作数。
Quat< _Tp > &	operator/= (const Quat< _Tp > &)
	两个四元数 p 和 q 的除法赋值运算符；它将左操作数除以右操作数，并将结果赋给左操作数。
bool	operator== (const Quat< _Tp > &) const
	如果两个四元数 p 和 q 几乎相等，则返回 true，即当每个 \(p_i\) 和 \(q_i\) 的绝对值小于 CV_QUAT_EPS。
_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
	返回多项式函数的索引 \(x\) 的值。
Quat< _Tp >	power (const Quat< _Tp > &q, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	返回多项式函数的四元数 \(q\) 的值。
Quat< _Tp >	sin () const
	返回此四元数的正弦值，正弦值可以通过以下公式计算
Quat< _Tp >	sinh () const
	返回此四元数的双曲正弦值，双曲正弦值可以通过以下公式计算：\(\sinh(p) = \sin(w)\cos(||\boldsymbol{v}||) + \cosh(w)\frac{v}{||\boldsymbol{v}||}\sin||\boldsymbol{v}||\)，其中 \(\boldsymbol{v} = [x, y, z].
Quat< _Tp >	sqrt (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	返回 \(\sqrt{q}\)。
Quat< _Tp >	tan () const
	返回此四元数的正切值，正切值可以通过以下公式计算
Quat< _Tp >	tanh () const
	返回此四元数的双曲正切值，双曲正切值可以通过以下公式计算
Vec< _Tp, 3 >	toEulerAngles (QuatEnum::EulerAnglesType eulerAnglesType)
	将四元数转换为欧拉角。
Matx< _Tp, 3, 3 >	toRotMat3x3 (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	将四元数转换为3x3旋转矩阵。
Matx< _Tp, 4, 4 >	toRotMat4x4 (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	将四元数转换为4x4旋转矩阵。
Vec< _Tp, 3 >	toRotVec (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	将此四元数转换为旋转向量。
Vec< _Tp, 4 >	toVec () const
	将此四元数转换为Vec<T, 4>。

静态公共成员函数
static Quat< _Tp >	createFromAngleAxis (const _Tp angle, const Vec< _Tp, 3 > &axis)
	从角度和轴创建。此函数中将自动规范化轴，并生成
static Quat< _Tp >	createFromEulerAngles (const Vec< _Tp, 3 > &angles, QuatEnum::EulerAnglesType eulerAnglesType)
	从欧拉角创建
static Quat< _Tp >	createFromRotMat (InputArray R)
	从3x3旋转矩阵创建。
static Quat< _Tp >	createFromRvec (InputArray rvec)
	从旋转向量 \(r\) 创建，其形式为 \(\theta \cdot \boldsymbol{u}\)，其中 \(\theta\) 表示旋转角度，\(\boldsymbol{u}\) 表示规范化旋转轴。
static Quat< _Tp >	createFromXRot (const _Tp theta)
	从围绕X轴的旋转 \(\theta\) 获取四元数。
static Quat< _Tp >	createFromYRot (const _Tp theta)
	从围绕Y轴的旋转 \(\theta\) 获取四元数。
static Quat< _Tp >	createFromZRot (const _Tp theta)
	从围绕Z轴的旋转 \(\theta\) 获取四元数。
static Quat< _Tp >	interPoint (const Quat< _Tp > &q0, const Quat< _Tp > &q1, const Quat< _Tp > &q2, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
	这是四元组计算的部分。计算每组三个四元组之间的中间四元组 \(s_i\)。
static Quat< _Tp >	lerp (const Quat< _Tp > &q0, const Quat &q1, const _Tp t)
	通过线性插值(Nlerp)计算从 \(q_0\) 到 \(q_1\) 的插值。对于两个四元组，这个插值曲线可以表示为
static Quat< _Tp >	nlerp (const Quat< _Tp > &q0, const Quat &q1, const _Tp t, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
	通过标准化线性插值(Nlerp)计算从 \(q_0\) 到 \(q_1\) 的插值。它返回一个线性插值(Lerp)的标准化四元组。
static Quat< _Tp >	slerp (const Quat< _Tp > &q0, const Quat &q1, const _Tp t, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT, bool directChange=true)
	通过球形线性插值(Slerp)计算 \(q_0\) 和 \(q_1\) 之间的插值，它可以定义为
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)
	计算直接由 squad 在比率 t 创建的 \(C^1\) 连续样条曲线的结果四元组。在这里，插值值在 \(q_1\) 和 \(q_2\) 之间。\(q_0\) 和 \(q_2\) 用于确保 \(C^1\) 连续性。如果 t = 0，则返回 \(q_1\)，如果 t = 1，则返回 \(q_2\)。
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)
	通过球面和四边形(Squad)计算在 \(q_0\)、\(q_1\)、\(q_2\)、\(q_3\) 之间的插值。这可以定义为由 squad 在比率 t 创建的插值判决。

公共属性
_Tp	w
_Tp	x
_Tp	y
_Tp	z

静态公共属性
static constexpr _Tp	CV_QUAT_CONVERT_THRESHOLD = (_Tp)1.e-6
static constexpr _Tp	CV_QUAT_EPS = (_Tp)1.e-6

CV_QUAT_EPS
template<typename T >
Quat< T >	acos (const Quat< T > &q)
	返回四元数 q 的 arccos 值，arccos 可以计算为
template<typename T >
Quat< T >	acosh (const Quat< T > &q)
	返回四元数 q 的 arccosh 值，arccosh 可以计算为
template<typename T >
Quat< T >	asin (const Quat< T > &q)
	返回四元数 q 的 arcsin 值，arcsin 可以计算为
template<typename T >
Quat< T >	asinh (const Quat< T > &q)
	返回四元数 q 的 arcsinh 值，arcsinh 可以计算为
template<typename T >
Quat< T >	atan (const Quat< T > &q)
	返回四元数 q 的 arctan 值，arctan 可以计算为
template<typename T >
Quat< T >	atanh (const Quat< T > &q)
	返回四元数 q 的 arctanh 值，arctanh 可以计算为
template<typename T >
Quat< T >	cos (const Quat< T > &q)
	返回四元数 q 的 sin 值，cos 可以计算为
template<typename T >
Quat< T >	cosh (const Quat< T > &q)
	返回四元数 q 的 cosh 值，cosh 可以计算为
template<typename T >
Quat< T >	crossProduct (const Quat< T > &p, const Quat< T > &q)
	返回 \(p = (a, b, c, d) = (a, \boldsymbol{u})\) 与 \(q = (w, x, y, z) = (w, \boldsymbol{v})\) 之间的叉乘。
template<typename T >
Quat< T >	cv::operator* (const Quat< T > &, const T s)
	四元数与标量的乘法运算符。它将右操作数与左操作数相乘，并将结果赋值给左操作数。
template<typename T >
Quat< T >	cv::operator* (const T s, const Quat< T > &)
	标量与四元数的乘法运算符。它将右操作数与左操作数相乘，并将结果赋值给左操作数。
template<typename T >
Quat< T >	cv::operator+ (const Quat< T > &, const T s)
	四元数与标量的加法运算符。将右操作数加到左操作数上。
template<typename T >
Quat< T >	cv::operator+ (const T s, const Quat< T > &)
	四元数与标量的加法运算符。将右操作数加到左操作数上。
template<typename T >
Quat< T >	cv::operator- (const Quat< T > &, const T s)
	四元数与标量的减法运算符。从左操作数中减去右操作数。
template<typename T >
Quat< T >	cv::operator- (const T s, const Quat< T > &)
	标量与四元数的减法运算符。从左操作数中减去右操作数。
template<typename S >
std::ostream &	cv::operator<< (std::ostream &, const Quat< S > &)
template<typename T >
Quat< T >	exp (const Quat< T > &q)
	返回指数值。
template<typename T >
Quat< T >	inv (const Quat< T > &q, QuatAssumeType assumeUnit)
	返回 \(q^{-1}\)，它是 \(q\) 的逆，满足 \(q \times q^{-1} = 1\)。
template<typename T >
Quat< T >	log (const Quat< T > &q, QuatAssumeType assumeUnit)
	返回对数函数的值。
template<typename T >
Quat< T >	power (const Quat< T > &p, const Quat< T > &q, QuatAssumeType assumeUnit)
	返回多项式函数的四元数 \(q\) 的值。
template<typename T >
Quat< T >	power (const Quat< T > &q, const T x, QuatAssumeType assumeUnit)
	返回多项式函数的索引 \(x\) 的值。
template<typename T >
Quat< T >	sin (const Quat< T > &q)
	返回四元数 q 的 tanh 值，sin 可以计算为
template<typename T >
Quat< T >	sinh (const Quat< T > &q)
	返回四元数 q 的 sinh 值，sinh 可以计算为
template<typename T >
Quat< T >	sqrt (const Quat< T > &q, QuatAssumeType assumeUnit)
	返回 \(\sqrt{q}\)。
template<typename T >
Quat< T >	tan (const Quat< T > &q)
	返回四元数 q 的 tan 值，tan 可以计算为
template<typename T >
Quat< T >	tanh (const Quat< T > &q)
	返回四元数 q 的 tanh 值，tanh 可以计算为

详细信息

template<typename _Tp>
class cv::Quat< _Tp >

四元数是扩展复数的数系。它可以表示三维空间中的旋转。四元数通常表示为

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

其中 \(\psi = \frac{\theta}{2}\)，\(\theta\) 表示旋转角度，\(\boldsymbol{u} = [u_x, u_y, u_z]\) 表示归一化旋转轴，\(||q||\) 表示 \(q\) 的范数。

单位四元数通常表示旋转，其形式为

\[q = [\cos\psi, u_x\sin\psi,u_y\sin\psi, u_z\sin\psi].\]

要创建表示绕轴 \(\boldsymbol{u}\) 旋转角度 \(\theta\) 的四元数，可以使用

using namespace cv;
double angle = CV_PI;
Vec3d axis = {0, 0, 1};
Quatd q = Quatd::createFromAngleAxis(angle, axis);

你可以简单地使用四个相同类型的数字来创建一个四元数。

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

或者使用一个 Vec4d 或 Vec4f 向量。

Vec4d vec{1, 2, 3, 4};
Quatd q(vec);

Vec4f vec{1, 2, 3, 4};
Quatf q(vec);

如果你已经有了3x3的旋转矩阵R，则可以使用

Quatd q = Quatd::createFromRotMat(R);

如果你已经有了旋转向量rvec，其形式为 angle * axis，则可以使用

Quatd q = Quatd::createFromRvec(rvec);

要从四元数提取旋转矩阵，请参见 toRotMat3x3()

要从四元数提取 Vec4d 或 Vec4f，请参见 toVec()

要从四元数提取旋转向量，请参见 toRotVec()

如果有两个需要插值的三元数 q0, q1，则可以使用 nlerp()，slerp() 或 spline()

Quatd::nlerp(q0, q1, t)
 
Quatd::slerp(q0, q1, t)
 
Quatd::spline(q0, q0, q1, q1, t)

spline 可以为多个四元数的旋转提供平滑连接

获取四元数中元素的三个方法

Quatf q(1, 2, 3, 4);
std::cout << q.w << std::endl; // w=1, x=2, y=3, z=4
std::cout << q[0] << std::endl; // q[0]=1, q[1]=2, q[2]=3, q[3]=4
std::cout << q.at(0) << std::endl;

构造函数 & 析构函数文档

Quat() [1/3]

template<typename _Tp >

cv::Quat< _Tp >::Quat

(

)

Quat() [2/3]

template<typename _Tp >

cv::Quat< _Tp >::Quat ( const Vec< _Tp, 4 > &  coeff )

explicit

从 Vec4d 或 Vec4f。

Quat() [3/3]

template<typename _Tp >

cv::Quat< _Tp >::Quat	(	_Tp	w,
		_Tp	x,
		_Tp	y,
		_Tp	z
	)

从四个数字创建。

成员函数文档

acos()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::acos

(

)

const

返回此四元数的 arccos 值，arccos 可以按照以下方式计算：

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

其中 \(\boldsymbol{v} = [x, y, z].\)

例如

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

acosh()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::acosh

(

)

const

返回此四元数的 arccosh 值，arccosh 可以按照以下方式计算：

[\(\mathrm{arcosh}(q) = \ln\left(q + \sqrt{q^2 - 1}\right)\)]

.

例如

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

asin()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::asin

(

)

const

返回此四元数的 arcsin 值，arcsin 可以按照以下方式计算：

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

其中 \(\boldsymbol{v} = [x, y, z].\)

例如

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

asinh()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::asinh

(

)

const

返回此四元数的 arcsinh 值，arcsinh 可以按照以下方式计算：

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

.

例如

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

assertNormal()

template<typename _Tp >

void cv::Quat< _Tp >::assertNormal

(

_Tp

eps = CV_QUAT_EPS

)

const

如果此四元数不是单位四元数则抛出错误。

参数

eps

标准化容差范围。

另请参阅

isNormal

at()

template<typename _Tp >

_Tp cv::Quat< _Tp >::at

(

size_t

index

)

const

获取元素的一种方式。

参数

index

在一个范围 [0, 3] 内。

四元数 q

q.at(0) 等于 q.w

q.at(1) 等于 q.x

q.at(2) 等于 q.y

q.at(3) 等于 q.z

atan()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::atan

(

)

const

返回此四元数的 arctan 值，arctan 可以按照以下方式计算：

[\(\mathrm{arctan}(q) = -\frac{\boldsymbol{v}}{||\boldsymbol{v}||}\mathrm{artanh}\left(\frac{\boldsymbol{v}}{||\boldsymbol{v}||}q\right)\)]

其中 \(\boldsymbol{v} = [x, y, z].\)

例如

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

atanh()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::atanh

(

)

const

返回此四元数的 arctanh 值，arctanh 可以按照以下方式计算：

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

.

例如

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

共轭()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::conjugate

(

)

const

返回此四元数的共轭。

\[q.conjugate() = (w, -x, -y, -z).\]

余弦()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::cos

(

)

const

返回此四元数的 cos 值，cos 可以按照以下方式计算：

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

其中 \(\boldsymbol{v} = [x, y, z].\)

例如

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

双曲余弦()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::cosh

(

)

const

返回此四元数的 cosh 值，cosh 可以按照以下方式计算：

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

其中 \(\boldsymbol{v} = [x, y, z].\)

例如

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

由角度-轴创建()

template<typename _Tp >

静态 Quat< _Tp > cv::Quat< _Tp >::createFromAngleAxis ( const _Tp  angle, const Vec< _Tp, 3 > &  axis  )

静态

从角度和轴创建。此函数中将自动规范化轴，并生成

\[q = [\cos\psi, u_x\sin\psi,u_y\sin\psi, u_z\sin\psi].\]

其中 \(\psi = \frac{\theta}{2}\), \(\theta\) 是旋转角度。

由欧拉角创建()

template<typename _Tp >

静态 Quat< _Tp > cv::Quat< _Tp >::createFromEulerAngles ( const Vec< _Tp, 3 > &  angles, QuatEnum::EulerAnglesType  eulerAnglesType  )

静态

从欧拉角创建

可以通过组合欧拉旋转的四元数表示来生成四元数。

例如，如果我们使用顺序为 X-Y-Z 的内在旋转，\(\theta_1 \) 是围绕 X 轴的旋转，\(\theta_2 \) 是围绕 Y 轴的旋转，\(\theta_3 \) 是围绕 Z 轴的旋转。最终的四元数 q 可以通过以下方式计算：

{q} = q_{X, \theta_1} q_{Y, \theta_2} q_{Z, \theta_3}\]

其中 \( q_{X, \theta_1} \) 由 createFromXRot 创建，\( q_{Y, \theta_2} \) 由 createFromYRot 创建，\( q_{Z, \theta_3} \) 由 createFromZRot 创建。

参数

angles	3 个长度的向量中的欧拉角
eulerAnglesType	转换欧拉角类型

由旋转矩阵创建()

template<typename _Tp >

静态 Quat< _Tp > cv::Quat< _Tp >::createFromRotMat ( InputArray  R )

静态

从3x3旋转矩阵创建。

由旋转向量创建()

template<typename _Tp >

静态 Quat< _Tp > cv::Quat< _Tp >::createFromRvec ( InputArray  rvec )

静态

从旋转向量 \(r\) 创建，其形式为 \(\theta \cdot \boldsymbol{u}\)，其中 \(\theta\) 表示旋转角度，\(\boldsymbol{u}\) 表示规范化旋转轴。

角度和轴可以很容易地推导出

\[ \begin{equation} \begin{split} \psi &= ||r||\\ \boldsymbol{u} &= \frac{r}{\theta} \end{split} \end{equation} \]

然后可以计算出四元数

\[q = [\cos\psi, \boldsymbol{u}\sin\psi]\]

其中 \(\psi = \theta / 2 \)

由 X 旋转创建()

template<typename _Tp >

静态 Quat< _Tp > cv::Quat< _Tp >::createFromXRot ( const _Tp  theta )

静态

从围绕X轴的旋转 \(\theta\) 获取四元数。

\[q = \cos(\theta/2) + \sin(\theta/2) i + 0 j + 0 k \]

createFromYRot()

template<typename _Tp >

静态 Quat< _Tp > cv::Quat< _Tp >::createFromYRot ( const _Tp  theta )

静态

从围绕Y轴的旋转 \(\theta\) 获取四元数。

\[q = \cos(\theta/2) + 0 i + \sin(\theta/2) j + 0k \]

createFromZRot()

template<typename _Tp >

静态 Quat< _Tp > cv::Quat< _Tp >::createFromZRot ( const _Tp  theta )

静态

从围绕Z轴的旋转 \(\theta\) 获取四元数。

\[q = \cos(\theta/2) + 0 i + 0 j + \sin(\theta/2) k \]

crossProduct()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::crossProduct

(

const Quat< _Tp > &

q

)

const

返回 \(p = (a, b, c, d) = (a, \boldsymbol{u})\) 与 \(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. \]

例如

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

dot()

template<typename _Tp >

_Tp cv::Quat< _Tp >::dot

(

Quat< _Tp >

q

)

const

返回四元数 \(q\) 和此四元数之间的点乘。

dot(p, q)是衡量四元数之间接近程度的良好指标。实际上，考虑单位四元数的差异 \(p^{-1} * q\)，其实部是dot(p, q)。同时，其实部等于 \(\cos(\beta/2)\)，其中 \(\beta\) 是p和q之间的旋转角度，即。因此，dot(p, q)越接近1，它们之间的旋转就越小。

\[p \cdot q = p.w \cdot q.w + p.x \cdot q.x + p.y \cdot q.y + p.z \cdot q.z\]

参数

q

另一个四元数。

例如

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

exp()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::exp

(

)

const

返回指数值。

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

其中 \(\boldsymbol{v} = [x, y, z].\)

例如

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

getAngle()

template<typename _Tp >

_Tp cv::Quat< _Tp >::getAngle

(

QuatAssumeType

assumeUnit = QUAT_ASSUME_NOT_UNIT

)

const

获取四元数的角度，它返回旋转角度。

参数

assumeUnit

如果QUAT_ASSUME_UNIT，此四元数假定为单位四元数，并且此函数将节省一些计算。 \[\psi = 2 *arccos(\frac{w}{||q||})\]

例如

Quatd q(1,2,3,4);
q.getAngle();
 
QuatAssumeType assumeUnit = QUAT_ASSUME_UNIT;
q.normalize().getAngle(assumeUnit);//等同于 q.getAngle().

注意

它始终返回值在 \([0, 2\pi]\) 范围内。

getAxis()

template<typename _Tp >

Vec< _Tp, 3 > cv::Quat< _Tp >::getAxis

(

QuatAssumeType

assumeUnit = QUAT_ASSUME_NOT_UNIT

)

const

获取四元数的轴，它返回一个长度为3的向量。

参数

assumeUnit

如果QUAT_ASSUME_UNIT，此四元数假定为单位四元数，并且此函数将节省一些计算。

单位轴 \(\boldsymbol{u}\) 定义为

\[\begin{equation} \begin{split} \boldsymbol{v} &= \boldsymbol{u} ||\boldsymbol{v}||\\ &= \boldsymbol{u}||q||sin(\frac{\theta}{2}) \end{split} \end{equation}\]

其中 \(v=[x, y ,z]\) 和 \(\theta\) 表示旋转角度。

例如

Quatd q(1,2,3,4);
q.getAxis();
 
QuatAssumeType assumeUnit = QUAT_ASSUME_UNIT;
q.normalize().getAxis(assumeUnit);//等同于 q.getAxis()

interPoint()

template<typename _Tp >

static Quat< _Tp > cv::Quat< _Tp >::interPoint ( const Quat< _Tp > &  q0, const Quat< _Tp > &  q1, const Quat< _Tp > &  q2, QuatAssumeType  assumeUnit = QUAT_ASSUME_NOT_UNIT  )

静态

这是四元组计算的部分。计算每组三个四元组之间的中间四元组 \(s_i\)。

\[s_i = q_i\exp(-\frac{\log(q^*_iq_{i+1}) + \log(q^*_iq_{i-1})}{4}).\]

参数

q0	第一个四元数。
q1	第二个四元数。
q2	第三个四元数。
assumeUnit	如果 QUAT_ASSUME_UNIT，假设所有输入四元数是单位四元数。否则，将在函数内部对所有输入四元数进行归一化。

另请参阅

squad

inv()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::inv

(

QuatAssumeType

assumeUnit = QUAT_ASSUME_NOT_UNIT

)

const

返回 \(q^{-1}\) ，这是 \(q\) 的逆元，满足 \(q * q^{-1} = 1\)。

参数

assumeUnit

如果 QUAT_ASSUME_UNIT，四元数 q 假设为单位四元数，此函数将节省一些计算。

例如

Quatd q(1,2,3,4);
q.inv();
 
QuatAssumeType assumeUnit = QUAT_ASSUME_UNIT;
q = q.normalize();
q.inv(assumeUnit); // assumeUnit 表示 p 是单位四元数

isNormal()

template<typename _Tp >

bool cv::Quat< _Tp >::isNormal

(

_Tp

eps = CV_QUAT_EPS

)

const

如果这个四元数是单位四元数，则返回 true。

参数

eps	归一化的容忍度范围。eps 可以定义为

\[eps = |1 - dotValue|\]

其中

\[dotValue = (this.w^2 + this.x^2 + this.y^2 + this.z^2).\]

这个函数将考虑当 dotValue 超过范围 \([1-eps, 1+eps]\) 时为已经归一化。

lerp()

template<typename _Tp >

static Quat< _Tp > cv::Quat< _Tp >::lerp ( const Quat< _Tp > &  q0, const Quat< _Tp > &  q1, const _Tp  t  )

静态

通过线性插值(Nlerp)计算从 \(q_0\) 到 \(q_1\) 的插值。对于两个四元组，这个插值曲线可以表示为

\[Lerp(q_0, q_1, t) = (1 - t)q_0 + tq_1.\]

明显地，如果将 \(q_0\) 和 \(q_1\) 视为一个二维空间中的向量，lerp 将沿直线进行插值。当 \(t = 0\) 时，它返回 \(q_0\)，当 \(t= 1\) 时，它返回 \(q_1\)。\(t\) 通常应该在 \([0, 1]\) 范围内。

参数

q0	用于线性插值的一四元数。
q1	用于线性插值的一四元数。
t	向量 \(\overrightarrow{q_0q_1}\) 在 [0, 1] 范围内的百分比。

注意

它返回一个非单位四元数。

log()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::log

(

QuatAssumeType

assumeUnit = QUAT_ASSUME_NOT_UNIT

)

const

返回对数函数的值。

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

. 其中 \(\boldsymbol{v} = [x, y, z].\)

参数

assumeUnit

如果QUAT_ASSUME_UNIT，此四元数假定为单位四元数，并且此函数将节省一些计算。

例如

Quatd q(1,2,3,4);
q.log();
 
QuatAssumeType assumeUnit = QUAT_ASSUME_UNIT;
Quatd q1(1,2,3,4);
q1.normalize().log(assumeUnit);

nlerp()

template<typename _Tp >

static Quat< ( const Quat< _Tp > &  q0, const Quat< _Tp > &  q1, const _Tp  t, QuatAssumeType  assumeUnit = QUAT_ASSUME_NOT_UNIT  )

静态

通过标准化线性插值(Nlerp)计算从 \(q_0\) 到 \(q_1\) 的插值。它返回一个线性插值(Lerp)的标准化四元组。

\[ Nlerp(q_0, q_1, t) = \frac{(1 - t)q_0 + tq_1}{\||(\)(1 - t)q_0 + tq_1)||}.\]

插值始终选择最短路径，但并不能保证恒定速度。

参数

q0	用于归一化线性插值的一组四元数。
q1	用于归一化线性插值的一组四元数。
t	向量 \(\overrightarrow{q_0q_1}\) 在 [0, 1] 范围内的百分比。
assumeUnit	如果 QUAT_ASSUME_UNIT，所有输入的四元数假定为单位四元数。否则，所有输入的四元数将在函数内部归一化。

另请参阅

lerp

norm()

template<typename _Tp >

_Tp cv::Quat< _Tp >::norm

(

)

const

返回四元数的范数。

\[||q|| = \sqrt{w^2 + x^2 + y^2 + z^2}.\]

normalize()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::normalize

(

)

const

返回一个归一化的 \(p\)。

\[p = \frac{q}{||q||}\]

其中 \(p\) 满足 \((p.x)^2 + (p.y)^2 + (p.z)^2 + (p.w)^2 = 1.\)

operator*()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::operator*

(

const Quat< _Tp > &

)

const

两个四元数 q 和 p 的乘法运算符。乘以运算符两边的值。

四元数乘法规则

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

其中 \(\cdot\) 表示点乘积，\(\times \) 表示叉乘。

例如

Quatd p{1, 2, 3, 4};
Quatd q{5, 6, 7, 8};
std::cout << p * q << std::endl; //[-60, 12, 30, 24]

operator*=() [1/2]

template<typename _Tp >

Quat< _Tp > & cv::Quat< _Tp >::operator*=

(

const _Tp

s

)

四元数和标量相乘的赋值运算符。使用右操作数乘以左操作数，并将结果赋给左操作数。

标量与四元数乘法规则

\[ \begin{equation} \begin{split} p * s &= [w, x, y, z] * s\\ &=[w * s, x * s, y * s, z * s]. \end{split} \end{equation} \]

例如

Quatd p{1, 2, 3, 4};
double s = 2.0;
p *= s; // 等价于 p = p * s
std::cout << p << std::endl; //[2.0, 4.0, 6.0, 8.0]

注意

标量的类型应与四元数相同。

operator*=() [2/2]

template<typename _Tp >

Quat< _Tp > & cv::Quat< _Tp >::operator*=

(

const Quat< _Tp > &

)

两个四元数 q 和 p 的乘法赋值运算符。使用右操作数乘以左操作数，并将结果赋给左操作数。

四元数乘法规则

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

其中 \(\cdot\) 表示点乘积，\(\times \) 表示叉乘。

例如

Quatd p{1, 2, 3, 4};
Quatd q{5, 6, 7, 8};
p *= q; // 等价于 p = p * q
std::cout << p << std::endl; //[-60, 12, 30, 24]

operator+()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::operator+

(

const Quat< _Tp > &

)

const

两个四元数 p 和 q 的加法运算符。它返回一个新的四元数，其每个值都是 \(p_i\) 和 \(q_i\) 的和。

例如

Quatd p{1, 2, 3, 4};
Quatd q{5, 6, 7, 8};
std::cout << p + q << std::endl; //[6, 8, 10, 12]

operator+=()

template<typename _Tp >

Quat< _Tp > & cv::Quat< _Tp >::operator+=

(

const Quat< _Tp > &

)

两个四元数 p 和 q 的加法赋值运算符。将右操作数加到左操作数上，并将结果赋给左操作数。

例如

Quatd p{1, 2, 3, 4};
Quatd q{5, 6, 7, 8};
p += q; // 等价于 p = p + q
std::cout << p << std::endl; //[6, 8, 10, 12]

operator-() [1/2]

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::operator-

(

)

const

返回相反的四元数 \(-p\)，它满足 \(p + (-p) = 0\)。

例如

Quatd q{1, 2, 3, 4};
std::cout << -q << std::endl; // [-1, -2, -3, -4]

operator-() [2/2]

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::operator-

(

const Quat< _Tp > &

)

const

两个四元数 p 和 q 的减法运算符。它返回一个新的四元数，其中每个值都是 \(p_i\) 和 \(-q_i\) 的和。

例如

Quatd p{1, 2, 3, 4};
Quatd q{5, 6, 7, 8};
std::cout << p - q << std::endl; //[-4, -4, -4, -4]

operator-=()

template<typename _Tp >

Quat< _Tp > & cv::Quat< _Tp >::operator-=

(

const Quat< _Tp > &

)

两个四元数 p 和 q 的减法赋值运算符。它将右操作数从左操作数中减去，并将结果赋给左操作数。

例如

Quatd p{1, 2, 3, 4};
Quatd q{5, 6, 7, 8};
p -= q; // 等价于 p = p - q
std::cout << p << std::endl; //[-4, -4, -4, -4]

operator/(()) [1/2]

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::operator/

(

const _Tp

s

)

const

四元数与标量的除法运算符。它将左操作数除以右操作数，并将结果赋给左操作数。

标量四元数除法规则

\[ \begin{equation} \begin{split} p / s &= [w, x, y, z] / s\\ &=[w/s, x/s, y/s, z/s]. \end{split} \end{equation} \]

例如

Quatd p{1, 2, 3, 4};
double s = 2.0;
p /= s; // 等价于 p = p / s
std::cout << p << std::endl; //[0.5, 1, 1.5, 2]

注意

标量类型应与该四元数相同。

operator/(()) [2/2]

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::operator/

(

const Quat< _Tp > &

)

const

两个四元数 p 和 q 的除法运算符。将左操作数除以右操作数。

标量四元数除法规则

\[ \begin{equation} \begin{split} p / q &= p * q.inv()\\ \end{split} \end{equation} \]

例如

Quatd p{1, 2, 3, 4};
Quatd q{5, 6, 7, 8};
std::cout << p / q << std::endl; // 等价于 p * q.inv()

operator/=() [1/2]

template<typename _Tp >

Quat< _Tp > & cv::Quat< _Tp >::operator/=

(

const _Tp

s

)

四元数与标量的除法赋值运算符。它将左操作数除以右操作数，并将结果赋给左操作数。

标量四元数除法规则

\[ \begin{equation} \begin{split} p / s &= [w, x, y, z] / s\\ &=[w / s, x / s, y / s, z / s]. \end{split} \end{equation} \]

例如

Quatd p{1, 2, 3, 4};
double s = 2.0;;
p /= s; // 等价于 p = p / s
std::cout << p << std::endl; //[0.5, 1.0, 1.5, 2.0]

注意

标量的类型应与四元数相同。

operator/=() [2/2]

template<typename _Tp >

Quat< _Tp > & cv::Quat< _Tp >::operator/=

(

const Quat< _Tp > &

)

两个四元数 p 和 q 的除法赋值运算符；它将左操作数除以右操作数，并将结果赋给左操作数。

四元数除法规则

\[ \begin{equation} \begin{split} p / q&= p * q.inv()\\ \end{split} \end{equation} \]

例如

Quatd p{1, 2, 3, 4};
Quatd q{5, 6, 7, 8};
p /= q; // 等价于 p = p * q.inv()
std::cout << p << std::endl;

operator==()

template<typename _Tp >

bool cv::Quat< _Tp >::operator==

(

const Quat< _Tp > &

)

const

如果两个四元数 p 和 q 几乎相等，则返回 true，即当每个 \(p_i\) 和 \(q_i\) 的绝对值小于 CV_QUAT_EPS。

operator[]() [1/2]

template<typename _Tp >

_Tp & cv::Quat< _Tp >::operator[]

(

std::size_t

n

)

operator[]() [2/2]

template<typename _Tp >

const _Tp & cv::Quat< _Tp >::operator[]

(

std::size_t

n

)

const

power() [1/2]

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::power	(	const _Tp	x,
		QuatAssumeType	assumeUnit = QUAT_ASSUME_NOT_UNIT
	)		const

返回多项式函数的索引 \(x\) 的值。

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

参数

x	幂的指数。
assumeUnit	如果QUAT_ASSUME_UNIT，此四元数假定为单位四元数，并且此函数将节省一些计算。

例如

Quatd q(1,2,3,4);
q.power(2.0);
 
QuatAssumeType assumeUnit = QUAT_ASSUME_UNIT;
double angle = CV_PI;
Vec3d axis{0, 0, 1};
Quatd q1 = Quatd::createFromAngleAxis(angle, axis); //根据轴和角度生成一个单位四元数
q1.power(2.0, assumeUnit); //此 assumeUnt 表示 q1 是一个单位四元数

power() [2/2]

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::power	(	const Quat< _Tp > &	q,
		QuatAssumeType	assumeUnit = QUAT_ASSUME_NOT_UNIT
	)		const

返回多项式函数的四元数 \(q\) 的值。

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

参数

q	幂函数的四元数索引。
assumeUnit	如果QUAT_ASSUME_UNIT，此四元数假定为单位四元数，并且此函数将节省一些计算。

例如

Quatd p(1,2,3,4);
Quatd q(5,6,7,8);
p.power(q);
 
QuatAssumeType assumeUnit = QUAT_ASSUME_UNIT;
p = p.normalize();
p.power(q, assumeUnit); //此 assumeUnit 表示 p 是一个单位四元数

sin()

template<typename _Tp >

Quat〈 _Tp 〉 cv::Quat>〈 _Tp 〉::sin

(

)

const

返回此四元数的正弦值，正弦值可以通过以下公式计算

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

其中 \(\boldsymbol{v} = [x, y, z].\)

例如

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

sinh()

template<typename _Tp >

Quat< _Tp > cv::Quat>〈 _Tp 〉::sinh

(

)

const

返回此四元数的双曲正弦值，双曲正弦值可以通过以下公式计算：\(\sinh(p) = \sin(w)\cos(||\boldsymbol{v}||) + \cosh(w)\frac{v}{||\boldsymbol{v}||}\sin||\boldsymbol{v}||\)，其中 \(\boldsymbol{v} = [x, y, z].

例如

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

slerp()

template<typename _Tp >

静态 Quat〈 _Tp 〉 cv::Quat>〈 _Tp 〉::slerp ( const Quat< _Tp > &  q0, const Quat< _Tp > &  q1, const _Tp  t, QuatAssumeType  assumeUnit = QUAT_ASSUME_NOT_UNIT, bool  directChange = true  )

静态

通过球形线性插值(Slerp)计算 \(q_0\) 和 \(q_1\) 之间的插值，它可以定义为

\[ Slerp(q_0, q_1, t) = \frac{\sin((1-t)\theta)}{\sin(\theta)}q_0 + \frac{\sin(t\theta)}{\sin(\theta)}q_1\]

其中 \(\theta\) 可以计算为

\[\theta=cos^{-1}(q_0\cdot q_1)\]

因为它们的范数是单位。

参数

q0	在 Slerp 中使用的四元数。
q1	在 Slerp 中使用的四元数。
t	角度在 \(q_0\) 和 \(q_1\) 之间的百分比，范围在 [0, 1] 之间。
assumeUnit	如果 QUAT_ASSUME_UNIT，所有输入的四元数都假定是单位四元数。否则，函数内部将对所有输入的四元数进行归一化。
directChange	如果 QUAT_ASSUME_UNIT，插值将选择最近的路。

注意

如果插值角度较小，Nlerp 和 Slerp 之间的误差不会太大。为了提高效率和避免零除错误，我们使用 Nlerp 而不是 Slerp。

spline()

template<typename _Tp >

静态 Quat< _Tp > cv::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  )

静态

计算直接由 squad 在比率 t 创建的 \(C^1\) 连续样条曲线的结果四元组。在这里，插值值在 \(q_1\) 和 \(q_2\) 之间。\(q_0\) 和 \(q_2\) 用于确保 \(C^1\) 连续性。如果 t = 0，则返回 \(q_1\)，如果 t = 1，则返回 \(q_2\)。

参数

q0	第一个输入四元数以确保 \(C^1\) 连续性。
q1	第二个输入四元数。
q2	第三个输入四元数。
q3	第四个输入四元数与 \(q1\) 相同。
t	范围在 [0, 1] 之间的比例。
assumeUnit	如果 QUAT_ASSUME_UNIT，\(q_0, q_1, q_2, q_3\) 假定为单位四元数。否则，函数内部将对所有输入的四元数进行归一化。

例如

如果有三组双四元数 \(v_0, v_1, v_2\) 等待插值。

使用比例 \(t_0\) 在 \(v_0\) 和 \(v_1\) 之间进行插值，可以计算为

Quatd::spline(v0, v0, v1, v2, t0);

使用比例 \(t_0\) 在 \(v_1\) 和 \(v_2\) 之间进行插值，可以计算为

Quatd::spline(v0, v1, v2, v2, t0);

另请参阅

sqrt()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::sqrt

(

QuatAssumeType

assumeUnit = QUAT_ASSUME_NOT_UNIT

)

const

返回 \(\sqrt{q}\)。

参数

assumeUnit

如果QUAT_ASSUME_UNIT，此四元数假定为单位四元数，并且此函数将节省一些计算。

例如

Quatf q(1, 2, 3, 4);
q.sqrt();
 
QuatAssumeType assumeUnit = QUAT_ASSUME_UNIT;
q = {1,0,0,0};
q.sqrt(assumeUnit); //This assumeUnit means q is a unit quaternion

squad()

template<typename _Tp >

static Quat< _Tp > cv::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  )

静态

通过球面和四边形(Squad)计算在 \(q_0\)、\(q_1\)、\(q_2\)、\(q_3\) 之间的插值。这可以定义为由 squad 在比率 t 创建的插值判决。

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

其中

\[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	第一个四元数。
s0	第二个四元数。
s1	第三个四元数。
q1	第四个四元数。
t	在范围 \([0, 1]\) 内进行二次和线性插值的参数。
assumeUnit	如果 QUAT_ASSUME_UNIT，假设所有输入四元数是单位四元数。否则，将在函数内部对所有输入四元数进行归一化。
directChange	如果 QUAT_ASSUME_UNIT，squad 将寻找最近的路径进行插值。

另请参阅

interPoint, spline

tan()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::tan

(

)

const

返回此四元数的正切值，正切值可以通过以下公式计算

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

例如

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

tanh()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::tanh

(

)

const

返回此四元数的双曲正切值，双曲正切值可以通过以下公式计算

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

例如

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

另请参阅

sinh, cosh

toEulerAngles()

template<typename _Tp >

Vec< _Tp, 3 > cv::Quat< _Tp >::toEulerAngles

(

QuatEnum::EulerAnglesType

eulerAnglesType

)

将四元数转换为欧拉角。

当将四元数 \(q = w + x\boldsymbol{i} + y\boldsymbol{j} + z\boldsymbol{k}\) 转换为欧拉角时，旋转矩阵 M 可以通过以下方式计算

\[ \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}.\]

另一方面，可以通过欧拉角获得旋转矩阵。以 Euler 角类型 XYZ 的内源性旋转为例，\(\theta_1 \)，\(\theta_2 \)，\(\theta_3 \) 是欧拉角的三种角度，旋转矩阵 R 可以通过以下方式计算

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

旋转矩阵 M 和 R 是相等的。只要 \( s_{2} \neq 1 \)，通过比较两个矩阵的每个元素，解为 \(\begin{cases} \theta_1 = \arctan2(-m_{23},m_{33})\\\theta_2 = arcsin(m_{13}) \\\theta_3 = \arctan2(-m_{12},m_{11}) \end{cases}\).

当 \( s_{2}=1\) 或 \( s_{2}=-1\)，会发生陀螺仪锁定。函数将提示 "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."。

当 \( s_{2}=1 \)，旋转矩阵 R 为 \( 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} \)。

在条件 \(\begin{cases} \theta_1+\theta_3 = \arctan2(m_{21},m_{22}) \\ \theta_2=\pi/2 \end{cases}\) 下，解的数量是无限的。

我们设 \( \theta_3 = 0 \)，解为 \(\begin{cases} \theta_1=\arctan2(m_{21},m_{22}) \\ \theta_2=\pi/2 \\ \theta_3=0 \end{cases}\)。

当 \( s_{2}=-1 \)，旋转矩阵 R 为 \( 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}} \)。

在条件 \(\begin{cases} \theta_1+\theta_3 = \arctan2(m_{32},m_{22}) \\ \theta_2=\pi/2 \end{cases}\) 下，解的数量是无限的。

我们设 \( \theta_3 = 0 \)，解为 \( \begin{cases}\theta_1=\arctan2(m_{32},m_{22}) \\ \theta_2=-\pi/2 \\ \theta_3=0\end{cases} \)。

由于 \( \sin \theta \in [-1, 1] \) 且 \( \cos \theta \in [-1, 1] \)，未归一化的四元数会导致计算问题。因此，这个函数首先将四元数归一化，并且不需要 QuatAssumeType。

当发生陀螺仪锁定时，对于内禀旋转我们设定 \(\theta_3 = 0\)，对于外禀旋转我们设定 \(\theta_1 = 0\)。

因此，对于每个欧拉角类型，我们可以在下表中得到解决方案。

EulerAnglesType	普通	\(\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_XZY	\( \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}) \)	θ₁=0，θ₂=-π/2，θ₃=arctan2(m₃₂, m₂₂)

EulerAnglesType	普通	θ₂ = 0	θ₂ = π
INT_XYX	θ₁ = arctan2(m₂₁, -m₃₁)，θ₂ = arccos(m₁₁)，θ₃ = arctan2(m₁₂, m₁₃)	θ₁=arctan2(m₃₂, m₃₃)，θ₂=0，θ₃=0	θ₁=arctan2(m₂₃, m₂₂)，θ₂=π，θ₃=0
INT_XZX	θ₁ = arctan2(m₃₁, m₂₁)，θ₂ = arccos(m₁₁)，θ₃ = arctan2(m₁₃, -m₁₂)	θ₁=arctan2(m₃₂, m₃₃)，θ₂=0，θ₃=0	θ₁=arctan2(-m₃₂, m₃₃)，θ₂=π，θ₃=0
INT_YXY	θ₁ = arctan2(m₁₂, m₃₂)，θ₂ = arccos(m₂₂)，θ₃ = arctan2(m₂₁, -m₂₃)	θ₁=arctan2(m₁₃, m₁₁)，θ₂=0，θ₃=0	θ₁=arctan2(-m₃₁, m₁₁)，θ₂=π，θ₃=0
INT_YZY	θ₁ = arctan2(m₃₂, -m₁₂)，θ₂ = arccos(m₂₂)，θ₃ = arctan2(m₂₃, m₂₁)	θ₁=arctan2(m₁₃, m₁₁)，θ₂=0，θ₃=0	θ₁=arctan2(m₁₃, -m₁₁)，θ₂=π，θ₃=0
INT_ZXZ	θ₁ = arctan2(-m₁₃, m₂₃)，θ₂ = arccos(m₃₃)，θ₃ = arctan2(m₃₁, m₃₂)	θ₁=arctan2(m₂₁, m₂₂)，θ₂=0，θ₃=0	θ₁=arctan2(m₂₁, m₁₁)，θ₂=π，θ₃=0
INT_ZYZ	θ₁ = arctan2(m₂₃, m₁₃)，θ₂ = arccos(m₃₃)，θ₃ = arctan2(m₃₂, -m₃₁)	θ₁=arctan2(m₂₁, m₁₁)，θ₂=0，θ₃=0	θ₁=arctan2(m₂₁, m₁₁)，θ₂=π，θ₃=0
EXT_XYX	θ₁ = arctan2(m₁₂, m₁₃)，θ₂ = arccos(m₁₁)，θ₃ = arctan2(m₂₁, -m₃₁)	θ₁=0，θ₂=0，θ₃=arctan2(m₃₂, m₃₃)	θ₁= 0，θ₂=π，θ₃=arctan2(m₂₃, m₂₂)
EXT_XZX	θ₁ = arctan2(m₁₃, -m₁₂)，θ₂ = arccos(m₁₁)，θ₃ = arctan2(m₃₁, m₂₁)	θ₁= 0，θ₂=0，θ₃=arctan2(m₃₂, m₃₃)	θ₁= 0，θ₂=π，θ₃=arctan2(-m₃₂, m₃₃)
EXT_YXY	θ₁ = arctan2(m₂₁, -m₂₃)，θ₂ = arccos(m₂₂)，θ₃ = arctan2(m₁₂, m₃₂)	θ₁= 0，θ₂=0，θ₃=arctan2(m₁₃, m₁₁)	θ₁= 0，θ₂=π，θ₃=arctan2(-m₃₁, m₁₁)
EXT_YZY	θ₁ = arctan2(m₂₃, m₂₁)，θ₂ = arccos(m₂₂)，θ₃ = arctan2(m₃₂, -m₁₂)	θ₁= 0，θ₂=0，θ₃=arctan2(m₁₃, m₁₁)	θ₁=0，θ₂=π，θ₃=arctan2(m₁₃, -m₁₁)
EXT_ZXZ	θ₁ = arctan2(m₃₁, m₃₂)，θ₂ = arccos(m₃₃)，θ₃ = arctan2(-m₁₃, m₂₃)	θ₁=0，θ₂=0，θ₃=arctan2(m₂₁, m₂₂)	θ₁= 0，θ₂=π，θ₃=arctan2(m₂₁, m₁₁)
EXT_ZYZ	θ₁ = arctan2(m₃₂, -m₃₁)，θ₂ = arccos(m₃₃)，θ₃ = arctan2(m₂₃, m₁₃)	θ₁=0，θ₂=0，θ₃=arctan2(m₂₁, m₁₁)	θ₁= 0，θ₂=π，θ₃=arctan2(m₂₁, m₁₁)

参数

eulerAnglesType

转换欧拉角类型

toRotMat3x3()

template<typename _Tp >

Matx< _Tp, 3, 3 > cv::Quat< _Tp >::toRotMat3x3

(

QuatAssumeType

assumeUnit = QUAT_ASSUME_NOT_UNIT

)

const

将四元数转换为3x3旋转矩阵。

参数

assumeUnit

如果 QUAT_ASSUME_UNIT，则此四元数假定为单位四元数，并且此函数将节省一些计算。否则，此函数将首先对四元数进行归一化，然后进行转换。

注意

要旋转的矩阵 A 应具有以下形式：

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

其中相同的下标代表一个点。A 的形状假定是 [3, n]。点矩阵 A 可以通过 toRotMat3x3() * A 进行旋转。结果也有 3 行 n 列。

例如

double angle = CV_PI;
Vec3d axis{0,0,1};
Quatd q_unit = Quatd::createFromAngleAxis(angle, axis); //四元数也可以通过两个或多个四元数的插值获得。
 
//假设有两个点 (1,0,0) 和 (1,0,1) 需要旋转
Mat pointsA = (Mat_<double>(2, 3) << 1,0,0,1,0,1);
//改变形状
pointsA = pointsA.t();
//绕z轴旋转180度
Mat new_point = q_unit.toRotMat3x3() * pointsA;
//打印两个点
cout << new_point << endl;

toRotMat4x4()

template<typename _Tp >

Matx< _Tp, 4, 4 > cv::Quat< _Tp >::toRotMat4x4

(

QuatAssumeType

assumeUnit = QUAT_ASSUME_NOT_UNIT

)

const

将四元数转换为4x4旋转矩阵。

参数

assumeUnit

如果 QUAT_ASSUME_UNIT，则此四元数假定为单位四元数，并且此函数将节省一些计算。否则，此函数将首先对四元数进行归一化，然后进行转换。

操作与toRotMat3x3类似，但点矩阵的形式应该是

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

另请参阅

toRotMat3x3

toRotVec()

template<typename _Tp >

Vec< _Tp, 3 > cv::Quat< _Tp >::toRotVec

(

QuatAssumeType

assumeUnit = QUAT_ASSUME_NOT_UNIT

)

const

将此四元数转换为旋转向量。

参数

assumeUnit

如果QUAT_ASSUME_UNIT，则该四元数假设为单位四元数，该函数将节省一些计算。旋转向量rVec定义为 \[ rVec = [\theta v_x, \theta v_y, \theta v_z]\] 其中\(\theta\)表示旋转角度，\(\boldsymbol{v}\)表示归一化的旋转轴。

例如

Quatd q(1,2,3,4);
q.toRotVec();
 
QuatAssumeType assumeUnit = QUAT_ASSUME_UNIT;
q.normalize().toRotVec(assumeUnit); //答案与q.toRotVec().相同。

toVec()

template<typename _Tp >

Vec< _Tp, 4 > cv::Quat< _Tp >::toVec

(

)

const

将此四元数转换为Vec<T, 4>。

例如

Quatd q(1,2,3,4);
q.toVec();

朋友和相关符号文档

acos

template<typename _Tp >

template<typename T >

Quat< T > acos ( const Quat< T > &  q )

friend

返回四元数 q 的 arccos 值，arccos 可以计算为

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

其中 \(\boldsymbol{v} = [x, y, z].\)

参数

q	a quaternion.

例如

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

acosh

template<typename _Tp >

template<typename T >

Quat< T > acosh ( const Quat< T > &  q )

friend

返回四元数 q 的 arccosh 值，arccosh 可以计算为

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

.

参数

q	a quaternion.

例如

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

asin

template<typename _Tp >

template<typename T >

Quat< T > asin ( const Quat< T > &  q )

friend

返回四元数 q 的 arcsin 值，arcsin 可以计算为

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

其中 \(\boldsymbol{v} = [x, y, z].\)

参数

q	a quaternion.

例如

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

asinh

template<typename _Tp >

template<typename T >

Quat< T > asinh ( const Quat< T > &  q )

friend

返回四元数 q 的 arcsinh 值，arcsinh 可以计算为

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

.

参数

q	a quaternion.

例如

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

atan

template<typename _Tp >

template<typename T >

Quat< T > atan ( const Quat< T > &  q )

friend

返回四元数 q 的 arctan 值，arctan 可以计算为

[\(\mathrm{arctan}(q) = -\frac{\boldsymbol{v}}{||\boldsymbol{v}||}\mathrm{artanh}\left(\frac{\boldsymbol{v}}{||\boldsymbol{v}||}q\right)\)]

其中 \(\boldsymbol{v} = [x, y, z].\)

参数

q	a quaternion.

例如

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

atanh

template<typename _Tp >

template<typename T >

Quat< T > atanh ( const Quat< T > &  q )

friend

返回四元数 q 的 arctanh 值，arctanh 可以计算为

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

.

参数

q	a quaternion.

例如

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

cos

template<typename _Tp >

template<typename T >

Quat< T > cos ( const Quat< T > &  q )

friend

返回四元数 q 的 sin 值，cos 可以计算为

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

其中 \(\boldsymbol{v} = [x, y, z].\)

参数

q	a quaternion.

例如

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

cosh

template<typename _Tp >

template<typename T >

Quat< T > cosh ( const Quat< T > &  q )

friend

返回四元数 q 的 cosh 值，cosh 可以计算为

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

其中 \(\boldsymbol{v} = [x, y, z].\)

参数

q	a quaternion.

例如

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

crossProduct

template<typename _Tp >

template<typename T >

Quat< T > crossProduct ( const Quat< T > &  p, const Quat< T > &  q  )

friend

返回 \(p = (a, b, c, d) = (a, \boldsymbol{u})\) 与 \(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 \]

例如

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

cv::operator* [1/2]

template<typename _Tp >

template<typename T >

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

friend

四元数与标量的乘法运算符。它将右操作数与左操作数相乘，并将结果赋值给左操作数。

标量与四元数乘法规则

\[ \begin{equation} \begin{split} p * s &= [w, x, y, z] * s\\ &=[w * s, x * s, y * s, z * s]. \end{split} \end{equation} \]

例如

Quatd p{1, 2, 3, 4};
double s = 2.0;
std::cout << p * s << std::endl; //[2.0, 4.0, 6.0, 8.0]

注意

标量的类型应与四元数相同。

cv::operator* [2/2]

template<typename _Tp >

template<typename T >

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

friend

标量与四元数的乘法运算符。它将右操作数与左操作数相乘，并将结果赋值给左操作数。

标量与四元数乘法规则

\[ \begin{equation} \begin{split} p * s &= [w, x, y, z] * s\\ &=[w * s, x * s, y * s, z * s]. \end{split} \end{equation} \]

例如

Quatd p{1, 2, 3, 4};
double s = 2.0;
std::cout << s * p << std::endl; //[2.0, 4.0, 6.0, 8.0]

注意

标量的类型应与四元数相同。

cv::operator+ [1/2]

template<typename _Tp >

template<typename T >

Quat< T > cv::operator+ ( const Quat< T > &  , const T  s  )

friend

四元数与标量的加法运算符。将右操作数加到左操作数上。

例如

Quatd p{1, 2, 3, 4};
double scalar = 2.0;
std::cout << p + scalar << std::endl; //[3.0, 2, 3, 4]

注意

标量的类型应与四元数相同。

cv::operator+ [2/2]

template<typename _Tp >

template<typename T >

Quat< T > cv::operator+ ( const T  s, const Quat< T > &    )

friend

四元数与标量的加法运算符。将右操作数加到左操作数上。

例如

Quatd p{1, 2, 3, 4};
double scalar = 2.0;
std::cout << scalar + p << std::endl; //[3.0, 2, 3, 4]

注意

标量的类型应与四元数相同。

cv::operator- [1/2]

template<typename _Tp >

template<typename T >

Quat< T > cv::operator- ( const Quat< T > &  , const T  s  )

friend

四元数与标量的减法运算符。从左操作数中减去右操作数。

例如

Quatd p{1, 2, 3, 4};
double scalar = 2.0;
std::cout << p - scalar << std::endl; //[-1.0, 2, 3, 4]

注意

标量的类型应与四元数相同。

cv::operator- [2/2]

template<typename _Tp >

template<typename T >

Quat< T > cv::operator- ( const T  s, const Quat< T > &    )

friend

标量与四元数的减法运算符。从左操作数中减去右操作数。

例如

Quatd p{1, 2, 3, 4};
double scalar = 2.0;
std::cout << scalar - p << std::endl; //[1.0, -2, -3, -4]

注意

标量的类型应与四元数相同。

cv::operator<<

template<typename _Tp >

template<typename S >

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

friend

exp

template<typename _Tp >

template<typename T >

Quat< T > exp ( const Quat< T > &  q )

friend

返回指数值。

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

其中 \(\boldsymbol{v} = [x, y, z].\)

参数

q	a quaternion.

例如

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

inv

template<typename _Tp >

template<typename T >

Quat< T > inv ( const Quat< T > &  q, QuatAssumeType  assumeUnit  )

friend

返回 \(q^{-1}\)，它是 \(q\) 的逆，满足 \(q \times q^{-1} = 1\)。

参数

q	a quaternion.
assumeUnit	如果 QUAT_ASSUME_UNIT，四元数 q 假设为单位四元数，此函数将节省一些计算。

例如

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

log

template<typename _Tp >

template<typename T >

Quat< T > log ( const Quat< T > &  q, QuatAssumeType  assumeUnit  )

friend

返回对数函数的值。

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

其中 \(\boldsymbol{v} = [x, y, z].\)

参数

q	a quaternion.
assumeUnit	如果 QUAT_ASSUME_UNIT，则假设 q 为单位四元数，此函数将节省一些计算。

例如

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

power [1/2]

template<typename _Tp >

template<typename T >

Quat< T > power ( const Quat< T > &  p, const Quat< T > &  q, QuatAssumeType  assumeUnit  )

friend

返回多项式函数的四元数 \(q\) 的值。

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

参数

p	power 函数的基本四元数。
q	幂函数的四元数索引。
assumeUnit	如果 QUAT_ASSUME_UNIT，四元数 \(p\) 假定为单位四元数，此函数将节省一些计算。

例如

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

power [2/2]

template<typename _Tp >

template<typename T >

Quat< T > power ( const Quat< T > &  q, const T  x, QuatAssumeType  assumeUnit  )

friend

返回多项式函数的索引 \(x\) 的值。

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

参数

q	a quaternion.
x	幂的指数。
assumeUnit	如果 QUAT_ASSUME_UNIT，四元数 q 假设为单位四元数，此函数将节省一些计算。

例如

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); //根据轴和角度生成一个单位四元数
power(q1, 2.0, assumeUnit);//This assumeUnit means q1 is a unit quaternion.

注意

索引的类型应与四元数相同。

sin

template<typename _Tp >

template<typename T >

Quat< T > sin ( const Quat< T > &  q )

friend

返回四元数 q 的 tanh 值，sin 可以计算为

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

其中 \(\boldsymbol{v} = [x, y, z].\)

参数

q	a quaternion.

例如

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

sinh

template<typename _Tp >

template<typename T >

Quat< T > sinh ( const Quat< T > &  q )

friend

返回四元数 q 的 sinh 值，sinh 可以计算为

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

其中 \(\boldsymbol{v} = [x, y, z].\)

参数

q	a quaternion.

例如

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

sqrt

template<typename _Tp >

template<typename T >

Quat< T > sqrt ( const Quat< T > &  q, QuatAssumeType  assumeUnit  )

friend

返回 \(\sqrt{q}\)。

参数

q	a quaternion.
assumeUnit	如果 QUAT_ASSUME_UNIT，四元数 q 假设为单位四元数，此函数将节省一些计算。

例如

Quatf q(1, 2, 3, 4);
sqrt(q);
 
QuatAssumeType assumeUnit = QUAT_ASSUME_UNIT;
q = {1,0,0,0};
sqrt(q, assumeUnit); //This assumeUnit means q is a unit quaternion.

tan

template<typename _Tp >

template<typename T >

Quat< T > tan ( const Quat< T > &  q )

friend

返回四元数 q 的 tan 值，tan 可以计算为

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

参数

q	a quaternion.

例如

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

tanh

template<typename _Tp >

template<typename T >

Quat< T > tanh ( const Quat< T > &  q )

friend

返回四元数 q 的 tanh 值，tanh 可以计算为

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

参数

q	a quaternion.

例如

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

另请参阅

sinh, cosh

成员数据文档

CV_QUAT_CONVERT_THRESHOLD

template<typename _Tp >

constexpr _Tp cv::Quat< _Tp >::CV_QUAT_CONVERT_THRESHOLD = (_Tp)1.e-6

staticconstexpr

CV_QUAT_EPS

template<typename _Tp >

constexpr _Tp cv::Quat< _Tp >::CV_QUAT_EPS = (_Tp)1.e-6

staticconstexpr

w

template<typename _Tp >

_Tp cv::Quat< _Tp >::w

x

template<typename _Tp >

template<typename _Tp >

template<typename _Tp >

---

本类的文档是从以下文件生成的：

• opencv2/core/quaternion.hpp

---

于2024年6月2日星期日 21:52:16 由OpenCV生成，由 1.9.8 编译