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

#include <opencv2/core/dualquaternion.hpp>

cv::DualQuat< _Tp > 的协作图

公有成员函数
	DualQuat ()
	DualQuat (const _Tp w, const _Tp x, const _Tp y, const _Tp z, const _Tp w_, const _Tp x_, const _Tp y_, const _Tp z_)
	由八个相同类型的数字创建。
	DualQuat (const Vec< _Tp, 8 > &q)
	由双精度或浮点向量创建。
DualQuat< _Tp >	conjugate () const
	返回对偶四元数的共轭。
_Tp	dot (DualQuat< _Tp > p) const
	返回两个对偶四元数的点积。
DualQuat< _Tp >	exp () const
	返回指数函数的值。
Quat< _Tp >	getDualPart () const
	返回一个表示对偶四元数对偶部分的四元数。createFromQuat() 中定义了对偶部分。
Quat< _Tp >	getRealPart () const
	返回一个表示对偶四元数实数部分的四元数。createFromQuat() 中定义了实数部分。
Quat< _Tp >	getRotation (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	返回四元数形式的旋转。
Vec< _Tp, 3 >	getTranslation (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	返回平移向量。在这个对偶四元数 σ 中的旋转 r 在平移 t 之前应用。对偶四元数 σ 定义为
DualQuat< _Tp >	inv (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	如果 σ = p + εq 是一个对偶四元数，p 不为零，则逆对偶四元数为
DualQuat< _Tp >	log (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	返回对数函数的值。
DualQuat< _Tp >	norm () const
	返回对偶四元数 σ = p + εq 的范数 ||σ||。
DualQuat< _Tp >	normalize () const
	返回一个标准化的对偶四元数。对偶四元数可以表示为
DualQuat< _Tp >	operator* (const DualQuat< _Tp > &) const
	两个对偶四元数 q 和 p 的乘法运算符。将运算符两侧的值相乘。
DualQuat< _Tp >	operator*= (const _Tp s)
	四元数和标量的乘法赋值运算符。它将右操作数与左操作数相乘，并将结果赋值给左操作数。
DualQuat< _Tp > &	operator*= (const DualQuat< _Tp > &)
	两个四元数的乘法赋值运算符。它将右操作数与左操作数相乘，并将结果赋值给左操作数。
DualQuat< _Tp >	operator+ (const DualQuat< _Tp > &) const
	两个对偶四元数 p 和 q 的加法运算符。它返回一个新的对偶四元数，其每个值都是 pi 和 qi 的和。
DualQuat< _Tp > &	operator+= (const DualQuat< _Tp > &)
	两个对偶四元数 p 和 q 的加法赋值运算符。它将右操作数添加到左操作数，并将结果赋值给左操作数。
DualQuat< _Tp >	operator- () const
	返回相反的对偶四元数 -p，满足 p + (-p) = 0。
DualQuat< _Tp >	operator- (const DualQuat< _Tp > &) const
	两个对偶四元数 p 和 q 的减法运算符。它返回一个新的对偶四元数，其每个值都是 pi 和 -qi 的和。
DualQuat< _Tp > &	operator-= (const DualQuat< _Tp > &)
	两个对偶四元数 p 和 q 的减法赋值运算符。它从左操作数中减去右操作数，并将结果赋值给左操作数。
DualQuat< _Tp >	operator/ (const _Tp s) const
	对偶四元数和标量的除法运算符。它将左操作数除以右操作数，并将结果赋值给左操作数。
DualQuat< _Tp >	operator/ (const DualQuat< _Tp > &) const
	两个对偶四元数 p 和 q 的除法运算符。将左操作数除以右操作数。
Quat< _Tp > &	operator/= (const _Tp s)
	对偶四元数和标量的除法赋值运算符。它将左操作数除以右操作数，并将结果赋值给左操作数。
DualQuat< _Tp > &	operator/= (const DualQuat< _Tp > &)
	两个对偶四元数 p 和 q 的除法赋值运算符；它将左操作数除以右操作数并将结果赋值给左操作数。
bool	operator== (const DualQuat< _Tp > &) const
	如果两个对偶四元数 p 和 q 近似相等，则返回 true，即当每个 $p_i$ 和 $q_i$ 的绝对值小于 CV_DUAL_QUAT_EPS 时。
DualQuat< _Tp >	power (const _Tp t, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	返回 $p^t$ 的值，其中 p 是一个对偶四元数。这可以计算为
DualQuat< _Tp >	power (const DualQuat< _Tp > &q, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	返回 $p^q$ 的值，其中 p 和 q 是对偶四元数。这可以计算为
Affine3< _Tp >	toAffine3 (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	将此对偶四元数转换为 Affine3 的实例。
Matx< _Tp, 4, 4 >	toMat (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	将此对偶四元数转换为矩阵形式的仿射变换矩阵，参见 createFromMat()。
Vec< _Tp, 8 >	toVec () const
	将此对偶四元数转换为向量。

静态公共成员函数
static DualQuat< _Tp >	createFromAffine3 (const Affine3< _Tp > &R)
	从仿射矩阵创建对偶四元数。仿射矩阵的定义可以参考 createFromMat()
static DualQuat< _Tp >	createFromAngleAxisTrans (const _Tp angle, const Vec< _Tp, 3 > &axis, const Vec< _Tp, 3 > &translation)
	从旋转角 $\theta$、旋转轴 $\mathit{u}$ 和平移 $\mathit{t}$ 创建一个对偶四元数。它生成形式为
static DualQuat< _Tp >	createFromMat (InputArray _R)
	将此对偶四元数转换为仿射变换矩阵 $M$。对偶四元数由旋转 $r=[a,b,c,d]$ 和平移 $t=[\mathrm{\Delta }x,\mathrm{\Delta }y,\mathrm{\Delta }z]$ 组成。仿射变换矩阵 $M$ 的形式为。
static DualQuat< _Tp >	createFromPitch (const _Tp angle, const _Tp d, const Vec< _Tp, 3 > &axis, const Vec< _Tp, 3 > &moment)
	对偶四元数是形式为的向量。
static DualQuat< _Tp >	createFromQuat (const Quat< _Tp > &realPart, const Quat< _Tp > &dualPart)
	从两个相同类型的四元数 p 和 q 创建对偶四元数。对偶四元数 $\sigma$ 的形式为
static DualQuat< _Tp >	dqblend (const DualQuat< _Tp > &q1, const DualQuat< _Tp > &q2, const _Tp t, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
	对偶四元数线性混合 (DQB) 方法用于计算对偶四元数 $q_1$ 和 $q_2$ 之间的变换，可以定义为
template<int cn>
static DualQuat< _Tp >	gdqblend (const Vec< DualQuat< _Tp >, cn > &dualquat, InputArray weights, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
	广义对偶四元数线性混合适用于两个以上的刚体变换。如果这些变换表示为具有凸权重 $w=(w_1,...,w_n)$ 的单位对偶四元数 $q_1,...,q_n$，则广义 DQB 简化为。
static DualQuat< _Tp >	gdqblend (InputArray dualquat, InputArray weights, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
	广义对偶四元数线性混合适用于两个以上的刚体变换。如果这些变换表示为具有凸权重 $w=(w_1,...,w_n)$ 的单位对偶四元数 $q_1,...,q_n$，则广义 DQB 简化为。
static DualQuat< _Tp >	sclerp (const DualQuat< _Tp > &q1, const DualQuat< _Tp > &q2, const _Tp t, bool directChange=true, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
	螺旋线性插值 (ScLERP) 是对偶四元数球面线性插值的扩展。如果 ${\sigma }_1$ 和 ${\sigma }_2$ 是表示初始和最终姿态的两个对偶四元数。ScLERP 函数的插值可以定义为

公共属性
_Tp	w
_Tp	w_
_Tp	x
_Tp	x_
_Tp	y
_Tp	y_
_Tp	z
_Tp	z_

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

友元
template<typename T >
DualQuat< T >	conjugate (const DualQuat< T > &dq)
	返回对偶四元数的共轭。
template<typename T >
DualQuat< T >	cv::operator* (const DualQuat< T > &, const T s)
	双四元数与标量的乘法运算符。它将右操作数与左操作数相乘，并将结果赋值给左操作数。
template<typename T >
DualQuat< T >	cv::operator* (const T s, const DualQuat< T > &)
	标量与双四元数的乘法运算符。它将右操作数与左操作数相乘，并将结果赋值给左操作数。
template<typename T >
DualQuat< T >	cv::operator+ (const DualQuat< T > &, const T s)
	双四元数与标量的加法运算符。将右操作数加到左操作数。
template<typename T >
DualQuat< T >	cv::operator+ (const T s, const DualQuat< T > &)
	标量与双四元数的加法运算符。将右操作数加到左操作数。
template<typename T >
DualQuat< T >	cv::operator- (const DualQuat< T > &, const T s)
	双四元数与标量的减法运算符。从左操作数减去右操作数。
template<typename T >
DualQuat< T >	cv::operator- (const T s, const DualQuat< T > &)
	标量与双四元数的减法运算符。从右操作数减去左操作数。
template<typename S >
std::ostream &	cv::operator<< (std::ostream &, const DualQuat< S > &)
template<typename T >
DualQuat< T >	exp (const DualQuat< T > &dq)
	返回指数函数的值。
template<typename T >
DualQuat< T >	inv (const DualQuat< T > &dq, QuatAssumeType assumeUnit)
	如果 σ = p + εq 是一个对偶四元数，p 不为零，则逆对偶四元数为
template<typename T >
DualQuat< T >	log (const DualQuat< T > &dq, QuatAssumeType assumeUnit)
	返回对数函数的值。
template<typename T >
DualQuat< T >	power (const DualQuat< T > &dq, const T t, QuatAssumeType assumeUnit)
	返回 $p^t$ 的值，其中 p 是一个对偶四元数。这可以计算为
template<typename T >
DualQuat< T >	power (const DualQuat< T > &p, const DualQuat< T > &q, QuatAssumeType assumeUnit)
	返回 $p^q$ 的值，其中 p 和 q 是对偶四元数。这可以计算为

详细描述

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

双四元数用于同时描述旋转和平移，而普通四元数只能描述旋转。它可以用于最短路径姿态插值、局部姿态优化或体积变形。更多细节可以参考：

• https://en.wikipedia.org/wiki/Dual_quaternion
• “双四元数入门指南：它们是什么，如何工作，以及如何将它们用于3D角色层次结构”，Ben Kenwright，2012
• “双四元数”，Yan-Bin Jia，2013
• “使用近似双四元数混合的几何蒙皮”，Kavan，2008
• http://rodolphe-vaillant.fr/?e=29

单位双四元数通常表示为：

$$\begin{array}{rl}\sigma & =(r+\frac{ϵ}{2}tr)\\ & =[w,x,y,z,w\mathrm{\_},x\mathrm{\_},y\mathrm{\_},z\mathrm{\_}]\end{array}$$

其中$r,t$分别表示旋转（普通单位四元数）和平移（纯普通四元数）。

由两个四元数组成的通用双四元数通常表示为：

$$\sigma =p+ϵq$$

其中引入的双单位$ϵ$满足${ϵ}^2={ϵ}^3=...=0$，而$p,q$是四元数。

或者，双四元数也可以解释为四个分量，它们都是双数

$$\sigma ={\hat{q}}_w+{\hat{q}}_{x}i+{\hat{q}}_{y}j+{\hat{q}}_{z}k$$

如果我们将${\hat{q}}_x,{\hat{q}}_y$和${\hat{q}}_z$设置为0，则双四元数将转换为双数。参见normalize()。

如果要创建双四元数，可以使用：

using namespace cv;
double angle = CV_PI;
 
// 从八个数创建
DualQuatd dq1(1, 2, 3, 4, 5, 6, 7, 8); //p = [1,2,3,4]. q=[5,6,7,8]
 
// 从Vec创建
Vec<double, 8> v{1,2,3,4,5,6,7,8};
DualQuatd dq_v{v};
 
// 从两个四元数创建
Quatd p(1, 2, 3, 4);
Quatd q(5, 6, 7, 8);
DualQuatd dq2 = DualQuatd::createFromQuat(p, q);
 
// 从角度、轴和平移创建
Vec3d axis{0, 0, 1};
Vec3d trans{3, 4, 5};
DualQuatd dq3 = DualQuatd::createFromAngleAxisTrans(angle, axis, trans);
 
// 如果已经拥有Affine3类的实例，则可以使用
Affine3d R = dq3.toAffine3();
DualQuatd dq4 = DualQuatd::createFromAffine3(R);
 
// 或直接通过仿射变换矩阵Rt创建
// 详细了解createFromMat()中Rt的形式
Matx44d Rt = dq3.toMat();
DualQuatd dq5 = DualQuatd::createFromMat(Rt);
 
// 任何旋转+平移运动都可以
// 可以表示为绕空间中同一直线（由普吕克坐标表示）的旋转和平移，以下是一种表示方法。
// 以下是采用这种方法表示它的方式。
Vec3d axis{1, 1, 1}; // 轴向量将在createFromPitch函数中被归一化
Vec3d trans{3, 4 ,5};
axis = axis / std::sqrt(axis.dot(axis));// 我下面使用的计算矩的公式需要归一化的轴向量
Vec3d moment = 1.0 / 2 * (trans.cross(axis) + axis.cross(trans.cross(axis)) *
std::cos(rotation_angle / 2) / std::sin(rotation_angle / 2));
double d = trans.dot(qaxis);
DualQuatd dq6 = DualQuatd::createFromPitch(angle, d, axis, moment);

点$v=(x,y,z)$ 的对偶四元数形式为$[1+ϵv]=[1,0,0,0,0,x,y,z]$。在对偶四元数$\sigma$ 下，点$v_1$ 到点$v_2$ 的变换为

$$1+ϵv_2=\sigma \ast (1+ϵv_1)\ast {\sigma }^{\star }$$

其中${\sigma }^{\star }=p^{\ast }-ϵq^{\ast }.$

普吕克坐标$\hat{l},m$ 定义的直线由对偶四元数$l=\hat{l}+ϵm$表示。要变换一条直线，

$$l_2=\sigma \ast l_1\ast {\sigma }^{\ast },$$

其中$\sigma =r+\frac{ϵ}{2}rt$ 和 ${\sigma }^{\ast }=p^{\ast }+ϵq^{\ast }$.

要提取Vec<double, 8>或Vec<float, 8>，请参见toVec()；

要提取仿射变换矩阵，请参见toMat()；

要提取Affine3实例，请参见toAffine3()；

如果需要插值两个四元数$q_0,q_1$，可以使用sclerp()

DualQuatd::sclerp(q0, q1, t)

或dqblend()。

DualQuatd::dqblend(q0, q1, t)

对于需要混合多个（超过两个）对偶四元数的情况，可以使用带有相应权重的广义线性对偶四元数混合，即 gdqblend()。

构造函数和析构函数文档

DualQuat() [1/3]

template<typename _Tp >

cv::DualQuat< _Tp >::DualQuat

(

)

DualQuat() [2/3]

template<typename _Tp >

cv::DualQuat< _Tp >::DualQuat	(	const _Tp	w,
		const _Tp	x,
		const _Tp	y,
		const _Tp	z,
		const _Tp	w_,
		const _Tp	x_,
		const _Tp	y_,
		const _Tp	z_ )

由八个相同类型的数字创建。

DualQuat() [3/3]

template<typename _Tp >

cv::DualQuat< _Tp >::DualQuat

(

const Vec< _Tp, 8 > &

q

)

由双精度或浮点向量创建。

成员函数文档

conjugate()

template<typename _Tp >

DualQuat< _Tp > cv::DualQuat< _Tp >::conjugate

(

)

const

返回对偶四元数的共轭。

$$\begin{array}{rll}{\sigma }^{\ast }& =(p+ϵq{)}^{\ast }& =(p^{\ast }+ϵq^{\ast })\end{array}$$

createFromAffine3()

template<typename _Tp >

static DualQuat< _Tp > cv::DualQuat< _Tp >::createFromAffine3 ( 常量 Affine3< _Tp > & R )

静态

从仿射矩阵创建对偶四元数。仿射矩阵的定义可以参考 createFromMat()

createFromAngleAxisTrans()

template<typename _Tp >

静态 DualQuat< _Tp > cv::DualQuat< _Tp >::createFromAngleAxisTrans ( const _Tp 角度, 常量 Vec< _Tp, 3 > & 轴, 常量 Vec< _Tp, 3 > & 平移 )

静态

从旋转角 $\theta$、旋转轴 $\mathit{u}$ 和平移 $\mathit{t}$ 创建一个对偶四元数。它生成形式为

$$\begin{array}{rl}\sigma & =r+\frac{ϵ}{2}\mathit{t}r\\ & =[\cos (\frac{\theta }{2}),\mathit{u}\sin (\frac{\theta }{2})]+\frac{ϵ}{2}[0,\mathit{t}][[\cos (\frac{\theta }{2}),\mathit{u}\sin (\frac{\theta }{2})]]\\ & =\cos (\frac{\theta }{2})+\mathit{u}\sin (\frac{\theta }{2})+\frac{ϵ}{2}(-(\mathit{t}\cdot \mathit{u})\sin (\frac{\theta }{2})+\mathit{t}\cos (\frac{\theta }{2})+\mathit{u}\times \mathit{t}\sin (\frac{\theta }{2})).\end{array}$$

参数

角度	旋转角度。
轴	旋转轴。
平移	一个长度为3的向量。

注意

此函数中将对轴进行归一化处理。旋转之后应用平移。使用 createFromQuat(r, r * t / 2) 创建平移在旋转之前应用的双四元数。

另见

四元数

createFromMat()

template<typename _Tp >

静态 DualQuat< _Tp > cv::DualQuat< _Tp >::createFromMat ( 输入数组 _R )

静态

将此对偶四元数转换为仿射变换矩阵 $M$。对偶四元数由旋转 $r=[a,b,c,d]$ 和平移 $t=[\mathrm{\Delta }x,\mathrm{\Delta }y,\mathrm{\Delta }z]$ 组成。仿射变换矩阵 $M$ 的形式为。

$$\left[\begin{array}{cccc}1-2(e_2^2+e_3^2)& 2(e_1{e}_2-e_0{e}_3)& 2(e_0{e}_2+e_1{e}_3)& \mathrm{\Delta }x\\ 2(e_0{e}_3+e_1{e}_2)& 1-2(e_1^2+e_3^2)& 2(e_2{e}_3-e_0{e}_1)& \mathrm{\Delta }y\\ 2(e_1{e}_3-e_0{e}_2)& 2(e_0{e}_1+e_2{e}_3)& 1-2(e_1^2-e_2^2)& \mathrm{\Delta }z\\ 0& 0& 0& 1\end{array}\right]$$

如果 A 是一个由 n 个待转换点组成的矩阵，则可以通过以下方式实现：

$$new\mathrm{\_}A=M\ast A$$

其中 A 的形式为

$$\left[\begin{array}{ccccc}{x}_0& x_1& x_2& ...& x_n\\ y_0& y_1& y_2& ...& y_n\\ z_0& z_1& z_2& ...& z_n\\ 1& 1& 1& ...& 1\end{array}\right]$$

其中相同的下标表示相同的点。A 的大小应为 $[4,n]$ 。矩阵 new_A 的大小相同。

参数

_R	表示旋转和平移的 4x4 矩阵。

注意

旋转后应用平移。使用 createFromQuat(r, r * t / 2) 创建平移在旋转之前应用的双四元数。

createFromPitch()

template<typename _Tp >

静态 DualQuat< _Tp > cv::DualQuat< _Tp >::createFromPitch ( const _Tp 角度, const _Tp d, 常量 Vec< _Tp, 3 > & 轴, 常量 Vec< _Tp, 3 > & 矩 )

静态

对偶四元数是形式为的向量。

$$\begin{array}{rl}\sigma & =\mathit{p}+ϵ\mathit{q}\\ & =\cos \widehat{\frac{\theta }{2}}+\overline{\hat{l}}\sin \frac{\hat{\theta }}{2}\end{array}$$

其中 $\hat{\theta }$ 是对偶角，$\overline{\hat{l}}$ 是对偶轴

$$\begin{gathered} \hat{\theta }=\theta +ϵd, \\ \overline{\hat{l}}=\hat{l}+ϵm. \end{gathered}$$

在此表示中，$\theta$ 是旋转角，$(\hat{l},m)$ 是螺旋轴，d 是沿轴的平移距离。

参数

角度	旋转角度。
d	沿旋转轴的平移。
轴	由四元数表示的旋转轴，其中 w = 0。
矩	线的矩，它应该与轴正交。

注意

旋转后应用平移。使用 createFromQuat(r, r * t / 2) 创建平移在旋转之前应用的双四元数。

createFromQuat()

template<typename _Tp >

静态 DualQuat< _Tp > cv::DualQuat< _Tp >::createFromQuat ( 常量 Quat< _Tp > & 实部, 常量 Quat< _Tp > & 对偶部 )

静态

从两个相同类型的四元数 p 和 q 创建对偶四元数。对偶四元数 $\sigma$ 的形式为

$$\sigma =p+ϵq$$

其中 p 和 q 定义如下

$$\begin{array}{rl}p& =w+x\mathit{i}+y\mathit{j}+z\mathit{k}\\ q& =w\mathrm{\_}+x\mathrm{\_}\mathit{i}+y\mathrm{\_}\mathit{j}+z\mathrm{\_}\mathit{k}.\end{array}$$

p 和 q 分别是实部和对偶部。

参数

实部	一个四元数，双四元数的实部。
对偶部	一个四元数，双四元数的对偶部。

另见

四元数

dot()

template<typename _Tp >

_Tp cv::DualQuat< _Tp >::dot

(

DualQuat< _Tp >

p

)

const

返回两个对偶四元数的点积。

参数

p

另一个双四元数。

dqblend()

template<typename _Tp >

静态 DualQuat< _Tp > cv::DualQuat< _Tp >::dqblend ( 常量 DualQuat< _Tp > & q1, 常量 DualQuat< _Tp > & q2, const _Tp t, QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT )

静态

对偶四元数线性混合 (DQB) 方法用于计算对偶四元数 $q_1$ 和 $q_2$ 之间的变换，可以定义为

$$DQB(t;{\mathit{q}}_1,{\mathit{q}}_2)=\frac{(1-t){\mathit{q}}_1+t{\mathit{q}}_2}{||(1-t){\mathit{q}}_1+t{\mathit{q}}_2||}.$$

其中 $q_1$ 和 $q_2$ 是表示输入变换的单位双四元数。如果您想使用适用于两个以上刚性变换的 DQB，请参见 gdqblend

参数

q1	表示输入变换的单位双四元数。
q2	表示输入变换的单位双四元数。
t	参数 $t\in [0,1]$。
assumeUnit	如果 QUAT_ASSUME_UNIT，则此双四元数假定为单位双四元数，此函数将节省一些计算。

另见

gdqblend

exp()

template<typename _Tp >

DualQuat< _Tp > cv::DualQuat< _Tp >::exp

(

)

const

返回指数函数的值。

gdqblend() [1/2]

template<typename _Tp >

template<int cn>

静态 DualQuat< _Tp > cv::DualQuat< _Tp >::gdqblend ( const Vec< DualQuat< _Tp >, cn > & 对偶四元数向量, 输入数组 权重向量, QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT )

静态

广义对偶四元数线性混合适用于两个以上的刚体变换。如果这些变换表示为具有凸权重 $w=(w_1,...,w_n)$ 的单位对偶四元数 $q_1,...,q_n$，则广义 DQB 简化为。

$$gDQB(\mathit{w};{\mathit{q}}_1,...,{\mathit{q}}_n)=\frac{w_1{\mathit{q}}_1+...+w_n{\mathit{q}}_n}{||w_1{\mathit{q}}_1+...+w_n{\mathit{q}}_n||}.$$

参数

对偶四元数向量	对偶四元数向量
权重向量	权重向量，权重向量的尺寸应与对偶四元数向量相同，且权重应满足$\sum _0^n{w}_i=1$ 和 $w_i>0$。
assumeUnit	如果 QUAT_ASSUME_UNIT，则这些对偶四元数假定为单位四元数，此函数将节省一些计算。

注意

权重元素的数据类型应与对偶四元数向量中对偶四元数的数据类型相同。

gdqblend() [2/2]

template<typename _Tp >

静态 DualQuat< _Tp > cv::DualQuat< _Tp >::gdqblend ( 输入数组 对偶四元数向量, 输入数组 权重向量, QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT )

静态

广义对偶四元数线性混合适用于两个以上的刚体变换。如果这些变换表示为具有凸权重 $w=(w_1,...,w_n)$ 的单位对偶四元数 $q_1,...,q_n$，则广义 DQB 简化为。

$$gDQB(\mathit{w};{\mathit{q}}_1,...,{\mathit{q}}_n)=\frac{w_1{\mathit{q}}_1+...+w_n{\mathit{q}}_n}{||w_1{\mathit{q}}_1+...+w_n{\mathit{q}}_n||}.$$

参数

对偶四元数向量	具有8个通道和1行或1列的对偶四元数。
权重向量	权重向量，权重向量的尺寸应与对偶四元数向量相同，且权重应满足$\sum _0^n{w}_i=1$ 和 $w_i>0$。
assumeUnit	如果 QUAT_ASSUME_UNIT，则这些对偶四元数假定为单位四元数，此函数将节省一些计算。

注意

权重元素的数据类型应与对偶四元数向量中对偶四元数的数据类型相同。

getDualPart()

template<typename _Tp >

Quat< _Tp > cv::DualQuat< _Tp >::getDualPart

(

)

const

返回一个表示对偶四元数对偶部分的四元数。createFromQuat() 中定义了对偶部分。

另见

createFromQuat，getRealPart

getRealPart()

template<typename _Tp >

Quat< _Tp > cv::DualQuat< _Tp >::getRealPart

(

)

const

返回一个表示对偶四元数实数部分的四元数。createFromQuat() 中定义了实数部分。

另见

createFromQuat，getDualPart

getRotation()

template<typename _Tp >

Quat< _Tp > cv::DualQuat< _Tp >::getRotation

(

QuatAssumeType

assumeUnit = QUAT_ASSUME_NOT_UNIT

)

const

返回四元数形式的旋转。

getTranslation()

template<typename _Tp >

Vec< _Tp, 3 > cv::DualQuat< _Tp >::getTranslation

(

QuatAssumeType

assumeUnit = QUAT_ASSUME_NOT_UNIT

)

const

返回平移向量。在这个对偶四元数 σ 中的旋转 r 在平移 t 之前应用。对偶四元数 σ 定义为

$$\begin{array}{rl}\sigma & =p+ϵq\\ & =r+\frac{ϵ}{2}tr.\end{array}$$

因此，平移可以按如下方式获得

$$t=2q{p}^{\ast }.$$

参数

assumeUnit

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

注意

此对偶四元数的平移应用于旋转之后。

inv()

template<typename _Tp >

DualQuat< _Tp > cv::DualQuat< _Tp >::inv

(

QuatAssumeType

assumeUnit = QUAT_ASSUME_NOT_UNIT

)

const

如果 σ = p + εq 是一个对偶四元数，p 不为零，则逆对偶四元数为

$${\sigma }^{-1}=\frac{{\sigma }^{\ast }}{||\sigma |{|}^2},$$

或者等效地，

$${\sigma }^{-1}=p^{-1}-ϵp^{-1}q{p}^{-1}.$$

参数

assumeUnit

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

log()

template<typename _Tp >

DualQuat< _Tp > cv::DualQuat< _Tp >::log

(

QuatAssumeType

assumeUnit = QUAT_ASSUME_NOT_UNIT

)

const

返回对数函数的值。

参数

assumeUnit

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

norm()

template<typename _Tp >

DualQuat< _Tp > cv::DualQuat< _Tp >::norm

(

)

const

返回对偶四元数 σ = p + εq 的范数 ||σ||。

$$\begin{array}{rl}||\sigma ||& =\sqrt{\sigma \ast {\sigma }^{\ast }}\\ & =||p||+ϵ\frac{p\cdot q}{||p||}.\end{array}$$

一般来说，非单位对偶四元数的范数是一个对偶数。为方便起见，我们以对偶四元数的形式返回它，即

$$||\sigma ||=[||p||,0,0,0,\frac{p\cdot q}{||p||},0,0,0].$$

注意

对偶数的数据类型是对偶四元数。

normalize()

template<typename _Tp >

DualQuat< _Tp > cv::DualQuat< _Tp >::normalize

(

)

const

返回一个标准化的对偶四元数。对偶四元数可以表示为

$$\begin{array}{rl}\sigma & =p+ϵq\\ & =||\sigma ||(r+\frac{1}{2}tr)\end{array}$$

其中$r,t$分别表示旋转（普通四元数）和平移（纯普通四元数），$||\sigma ||$是对偶四元数的范数（一个对偶数）。当且仅当以下条件成立时，对偶四元数为单位四元数

$$||p||=1,p\cdot q=0$$

其中$\cdot$表示点积。归一化过程为

$${\sigma }_u=\frac{\sigma }{||\sigma ||}$$

接下来，我们简单证明${\sigma }_u$是一个单位对偶四元数

$$\begin{array}{rl}{\sigma }_u=\frac{\sigma }{||\sigma ||}& =\frac{p+ϵq}{||p||+ϵ\frac{p\cdot q}{||p||}}\\ & =\frac{p}{||p||}+ϵ(\frac{q}{||p||}-p\frac{p\cdot q}{||p|{|}^3})\\ & =\frac{p}{||p||}+ϵ\frac{1}{||p|{|}^2}(q{p}^{\ast }-p\cdot q)\frac{p}{||p||}\\ & =\frac{p}{||p||}+ϵ\frac{1}{||p|{|}^2}\mathrm{Im}(q{p}^{\ast })\frac{p}{||p||}.\end{array}$$

正如预期的那样，实部是旋转，对偶部是纯四元数。

operator*()

template<typename _Tp >

DualQuat< _Tp > cv::DualQuat< _Tp >::operator*

(

常量 DualQuat< _Tp > &

)

const

两个对偶四元数 q 和 p 的乘法运算符。将运算符两侧的值相乘。

对偶四元数乘法规则：对偶四元数可以写成四元数的有序对[A，B]。因此

$$\begin{array}{rl}p\ast q& =[A,B][C,D]\\ & =[AC,AD+BC]\end{array}$$

例如

DualQuatd p{1, 2, 3, 4, 5, 6, 7, 8};
DualQuatd q{5, 6, 7, 8, 9, 10, 11, 12};
std::cout << p * q << std::endl; //[-60, 12, 30, 24, -216, 80, 124, 120]

operator*=() [1/2]

template<typename _Tp >

DualQuat< _Tp > cv::DualQuat< _Tp >::operator*=

(

const _Tp

标量

)

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

对偶四元数与标量相乘的规则

$$\begin{array}{rl}p\ast s& =[w,x,y,z,w\mathrm{\_},x\mathrm{\_},y\mathrm{\_},z\mathrm{\_}]\ast s\\ & =[ws,xs,ys,zs,w\mathrm{\_}s,x\mathrm{\_}s,y\mathrm{\_}s,z\mathrm{\_}s].\end{array}$$

例如

DualQuatd p{1, 2, 3, 4, 5, 6, 7, 8};
double s = 2.0;
p *= s;
std::cout << p << std::endl; //[2, 4, 6, 8, 10, 12, 14, 16]

注意

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

operator*=() [2/2]

template<typename _Tp >

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

(

常量 DualQuat< _Tp > &

)

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

对偶四元数乘法规则：对偶四元数可以写成四元数的有序对[A，B]。因此

$$\begin{array}{rl}p\ast q& =[A,B][C,D]\\ & =[AC,AD+BC]\end{array}$$

例如

DualQuatd p{1, 2, 3, 4, 5, 6, 7, 8};
DualQuatd q{5, 6, 7, 8, 9, 10, 11, 12};
p *= q;
std::cout << p << std::endl; //[-60, 12, 30, 24, -216, 80, 124, 120]

operator+()

template<typename _Tp >

DualQuat< _Tp > cv::DualQuat< _Tp >::operator+

(

常量 DualQuat< _Tp > &

)

const

两个对偶四元数 p 和 q 的加法运算符。它返回一个新的对偶四元数，其每个值都是 pi 和 qi 的和。

例如

DualQuatd p{1, 2, 3, 4, 5, 6, 7, 8};
DualQuatd q{5, 6, 7, 8, 9, 10, 11, 12};
std::cout << p + q << std::endl; //[6, 8, 10, 12, 14, 16, 18, 20]

operator+=()

template<typename _Tp >

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

(

常量 DualQuat< _Tp > &

)

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

例如

DualQuatd p{1, 2, 3, 4, 5, 6, 7, 8};
DualQuatd q{5, 6, 7, 8, 9, 10, 11, 12};
p += q; // 等价于 p = p + q
std::cout << p << std::endl; //[6, 8, 10, 12, 14, 16, 18, 20]

operator-() [1/2]

template<typename _Tp >

DualQuat< _Tp > cv::DualQuat< _Tp >::operator-

(

)

const

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

例如

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

operator-() [2/2]

template<typename _Tp >

DualQuat< _Tp > cv::DualQuat< _Tp >::operator-

(

常量 DualQuat< _Tp > &

)

const

两个对偶四元数 p 和 q 的减法运算符。它返回一个新的对偶四元数，其每个值都是 pi 和 -qi 的和。

例如

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

operator-=()

template<typename _Tp >

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

(

常量 DualQuat< _Tp > &

)

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

例如

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

operator/() [1/2]

template<typename _Tp >

DualQuat< _Tp > cv::DualQuat< _Tp >::operator/

(

const _Tp

标量

)

const

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

对偶四元数除以标量的规则

$$\begin{array}{rl}p/s& =[w,x,y,z,w\mathrm{\_},x\mathrm{\_},y\mathrm{\_},z\mathrm{\_}]/s\\ & =[w/s,x/s,y/s,z/s,w\mathrm{\_}/s,x\mathrm{\_}/s,y\mathrm{\_}/s,z\mathrm{\_}/s].\end{array}$$

例如

DualQuatd p{1, 2, 3, 4, 5, 6, 7, 8};
double s = 2.0;
p /= s; // 等价于 p = p / s
std::cout << p << std::endl; //[0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4]

注意

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

operator/() [2/2]

template<typename _Tp >

DualQuat< _Tp > cv::DualQuat< _Tp >::operator/

(

常量 DualQuat< _Tp > &

)

const

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

对偶四元数除以对偶四元数的规则

$$\begin{array}{rl}p/q& =p\ast q.inv()\end{array}$$

例如

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

operator/=() [1/2]

template<typename _Tp >

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

(

const _Tp

标量

)

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

对偶四元数除以标量的规则

$$\begin{array}{rl}p/s& =[w,x,y,z,w\mathrm{\_},x\mathrm{\_},y\mathrm{\_},z\mathrm{\_}]/s\\ & =[w/s,x/s,y/s,z/s,w\mathrm{\_}/s,x\mathrm{\_}/s,y\mathrm{\_}/s,z\mathrm{\_}/s].\end{array}$$

例如

DualQuatd p{1, 2, 3, 4, 5, 6, 7, 8};
double s = 2.0;;
p /= s; // 等价于 p = p / s
std::cout << p << std::endl; //[0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0]

注意

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

operator/=() [2/2]

template<typename _Tp >

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

(

常量 DualQuat< _Tp > &

)

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

对偶四元数除以四元数的规则

$$\begin{array}{rl}p/q& =p\ast q.inv()\end{array}$$

例如

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

operator==()

template<typename _Tp >

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

(

常量 DualQuat< _Tp > &

)

const

如果两个对偶四元数 p 和 q 近似相等，则返回 true，即当每个 $p_i$ 和 $q_i$ 的绝对值小于 CV_DUAL_QUAT_EPS 时。

power() [1/2]

template<typename _Tp >

DualQuat< _Tp > cv::DualQuat< _Tp >::power	(	const _Tp	t,
		QuatAssumeType	assumeUnit = QUAT_ASSUME_NOT_UNIT ) const

返回 $p^t$ 的值，其中 p 是一个对偶四元数。这可以计算为

$$p^t=\exp (t\ln p)$$

参数

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

power() [2/2]

template<typename _Tp >

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

返回 $p^q$ 的值，其中 p 和 q 是对偶四元数。这可以计算为

$$p^q=\exp (q\ln p)$$

参数

q	一个对偶四元数
assumeUnit	如果QUAT_ASSUME_UNIT，则此对偶四元数假定为单位对偶四元数，此函数将节省一些计算。

sclerp()

template<typename _Tp >

static DualQuat< _Tp > cv::DualQuat< _Tp >::sclerp ( 常量 DualQuat< _Tp > & q1, 常量 DualQuat< _Tp > & q2, const _Tp t, 布尔值 directChange = true, QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT )

静态

螺旋线性插值 (ScLERP) 是对偶四元数球面线性插值的扩展。如果 ${\sigma }_1$ 和 ${\sigma }_2$ 是表示初始和最终姿态的两个对偶四元数。ScLERP 函数的插值可以定义为

$$ScLERP(t;{\sigma }_1,{\sigma }_2)={\sigma }_1\ast ({\sigma }_1^{-1}\ast {\sigma }_2{)}^t,t\in [0,1]$$

参数

q1	表示初始姿态的对偶四元数。
q2	表示最终姿态的对偶四元数。
t	插值参数
directChange	如果为真，则始终返回最短路径。
assumeUnit	如果 QUAT_ASSUME_UNIT，则此双四元数假定为单位双四元数，此函数将节省一些计算。

例如

double angle1 = CV_PI / 2;
Vec3d axis{0, 0, 1};
Vec3d t(0, 0, 3);
DualQuatd initial = DualQuatd::createFromAngleAxisTrans(angle1, axis, t);
double angle2 = CV_PI;
DualQuatd final = DualQuatd::createFromAngleAxisTrans(angle2, axis, t);
DualQuatd inter = DualQuatd::sclerp(initial, final, 0.5);

toAffine3()

template<typename _Tp >

Affine3< _Tp > cv::DualQuat< _Tp >::toAffine3

(

QuatAssumeType

assumeUnit = QUAT_ASSUME_NOT_UNIT

)

const

将此对偶四元数转换为 Affine3 的实例。

toMat()

template<typename _Tp >

Matx< _Tp, 4, 4 > cv::DualQuat< _Tp >::toMat

(

QuatAssumeType

assumeUnit = QUAT_ASSUME_NOT_UNIT

)

const

将此对偶四元数转换为矩阵形式的仿射变换矩阵，参见 createFromMat()。

toVec()

template<typename _Tp >

Vec< _Tp, 8 > cv::DualQuat< _Tp >::toVec

(

)

const

将此对偶四元数转换为向量。

友元和相关符号文档

conjugate

template<typename _Tp >

template<typename T >

DualQuat< T > conjugate ( const DualQuat< T > & dq )

friend

返回对偶四元数的共轭。

$$\begin{array}{rll}{\sigma }^{\ast }& =(p+ϵq{)}^{\ast }& =(p^{\ast }+ϵq^{\ast })\end{array}$$

参数

dq

一个对偶四元数。

cv::operator* [1/2]

template<typename _Tp >

template<typename T >

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

friend

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

对偶四元数与标量相乘的规则

$$\begin{array}{rl}p\ast s& =[w,x,y,z,w\mathrm{\_},x\mathrm{\_},y\mathrm{\_},z\mathrm{\_}]\ast s\\ & =[ws,xs,ys,zs,w\mathrm{\_}s,x\mathrm{\_}s,y\mathrm{\_}s,z\mathrm{\_}s].\end{array}$$

例如

DualQuatd p{1, 2, 3, 4, 5, 6, 7, 8};
double s = 2.0;
std::cout << p * s << std::endl; //[2, 4, 6, 8, 10, 12, 14, 16]

注意

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

cv::operator* [2/2]

template<typename _Tp >

template<typename T >

DualQuat< T > cv::operator* ( const T 标量, const DualQuat< T > &  )

friend

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

对偶四元数与标量相乘的规则

$$\begin{array}{rl}p\ast s& =[w,x,y,z,w\mathrm{\_},x\mathrm{\_},y\mathrm{\_},z\mathrm{\_}]\ast s\\ & =[ws,xs,ys,zs,w\mathrm{\_}s,x\mathrm{\_}s,y\mathrm{\_}s,z\mathrm{\_}s].\end{array}$$

例如

DualQuatd p{1, 2, 3, 4, 5, 6, 7, 8};
double s = 2.0;
std::cout << s * p << std::endl; //[2, 4, 6, 8, 10, 12, 14, 16]

注意

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

cv::operator+ [1/2]

template<typename _Tp >

template<typename T >

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

friend

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

例如

DualQuatd p{1, 2, 3, 4, 5, 6, 7, 8};
double scalar = 2.0;
std::cout << p + scalar << std::endl; //[3.0, 2, 3, 4, 5, 6, 7, 8]

注意

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

cv::operator+ [2/2]

template<typename _Tp >

template<typename T >

DualQuat< T > cv::operator+ ( const T 标量, const DualQuat< T > &  )

friend

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

例如

DualQuatd p{1, 2, 3, 4, 5, 6, 7, 8};
double scalar = 2.0;
std::cout << scalar + p << std::endl; //[3.0, 2, 3, 4, 5, 6, 7, 8]

注意

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

cv::operator- [1/2]

template<typename _Tp >

template<typename T >

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

friend

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

例如

DualQuatd p{1, 2, 3, 4, 5, 6, 7, 8};
double scalar = 2.0;
std::cout << p - scalar << std::endl; //[-1, 2, 3, 4, 5, 6, 7, 8]

注意

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

cv::operator- [2/2]

template<typename _Tp >

template<typename T >

DualQuat< T > cv::operator- ( const T 标量, const DualQuat< T > &  )

friend

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

例如

DualQuatd p{1, 2, 3, 4, 5, 6, 7, 8};
double scalar = 2.0;
std::cout << scalar - p << std::endl; //[1.0, -2, -3, -4, -5, -6, -7, -8]

注意

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

cv::operator<<

template<typename _Tp >

template<typename S >

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

friend

exp

template<typename _Tp >

template<typename T >

DualQuat< T > exp ( const DualQuat< T > & dq )

friend

返回指数函数的值。

参数

dq

一个对偶四元数。

inv

template<typename _Tp >

template<typename T >

DualQuat< T > inv ( const DualQuat< T > & dq, QuatAssumeType assumeUnit )

friend

如果 σ = p + εq 是一个对偶四元数，p 不为零，则逆对偶四元数为

$${\sigma }^{-1}=\frac{{\sigma }^{\ast }}{||\sigma |{|}^2},$$

或者等效地，

$${\sigma }^{-1}=p^{-1}-ϵp^{-1}q{p}^{-1}.$$

参数

dq	一个对偶四元数。
assumeUnit	如果 QUAT_ASSUME_UNIT，则双四元数dq假定为单位双四元数，此函数将节省一些计算。

log

template<typename _Tp >

template<typename T >

DualQuat< T > log ( const DualQuat< T > & dq, QuatAssumeType assumeUnit )

friend

返回对数函数的值。

参数

dq	一个对偶四元数。
assumeUnit	如果 QUAT_ASSUME_UNIT，则双四元数dq假定为单位双四元数，此函数将节省一些计算。

power [1/2]

template<typename _Tp >

template<typename T >

DualQuat< T > power ( const DualQuat< T > & dq, const T t, QuatAssumeType assumeUnit )

friend

返回 $p^t$ 的值，其中 p 是一个对偶四元数。这可以计算为

$$p^t=\exp (t\ln p)$$

参数

dq	一个对偶四元数。
t	幂函数的指数。
assumeUnit	如果 QUAT_ASSUME_UNIT，则双四元数dq假定为单位双四元数，此函数将节省一些计算。

power [2/2]

template<typename _Tp >

template<typename T >

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

friend

返回 $p^q$ 的值，其中 p 和 q 是对偶四元数。这可以计算为

$$p^q=\exp (q\ln p)$$

参数

p	一个对偶四元数。
q	一个对偶四元数。
assumeUnit	如果 QUAT_ASSUME_UNIT，则双四元数p假定为单位双四元数，此函数将节省一些计算。

成员数据文档

CV_DUAL_QUAT_EPS

template<typename _Tp >

_Tp cv::DualQuat< _Tp >::CV_DUAL_QUAT_EPS = (_Tp)1.e-6

staticconstexpr

w

template<typename _Tp >

_Tp cv::DualQuat< _Tp >::w

w_

template<typename _Tp >

_Tp cv::DualQuat< _Tp >::w_

x

template<typename _Tp >

_Tp cv::DualQuat< _Tp >::x

x_

template<typename _Tp >

_Tp cv::DualQuat< _Tp >::x_

y

template<typename _Tp >

_Tp cv::DualQuat< _Tp >::y

y_

template<typename _Tp >

_Tp cv::DualQuat< _Tp >::y_

z

template<typename _Tp >

_Tp cv::DualQuat< _Tp >::z

z_

template<typename _Tp >

_Tp cv::DualQuat< _Tp >::z_

---

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

• opencv2/core/dualquaternion.hpp