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
	返回平移向量。此对偶四元数 \(\sigma\) 中的旋转 \(r\) 在平移 \(t\) 之前应用。对偶四元数 \(\sigma\) 定义为
DualQuat< _Tp >	inv (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	如果 \(\sigma = p + \epsilon q\) 是一个对偶四元数，且 p 不为零，则其逆对偶四元数为
DualQuat< _Tp >	log (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	返回对数函数值。
DualQuat< _Tp >	norm () const
	返回对偶四元数 \(\sigma = p + \epsilon q\) 的范数 \(||\sigma||\)。
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 的加法运算符。它返回一个新的对偶四元数，其中每个值都是 \(p_i\) 和 \(q_i\) 的和。
DualQuat< _Tp > &	operator+= (const DualQuat< _Tp > &)
	两个对偶四元数 p 和 q 的加法赋值运算符。它将右操作数加到左操作数上并将结果赋给左操作数。
DualQuat< _Tp >	operator- () const
	返回满足 \(p + (-p) = 0.\) 的反向对偶四元数 \(-p\)。
DualQuat< _Tp >	DualQuat< _Tp > &) const
	两个对偶四元数 p 和 q 的减法运算符。它返回一个新的对偶四元数，其中每个值都是 \(p_i\) 和 \(-q_i\) 的和。
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 近似相等，即当每个 \(p_i\) 和 \(q_i\) 的绝对值小于 CV_DUAL_QUAT_EPS 时，返回 true。
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\)、旋转轴 \(\boldsymbol{u}\) 和平移 \(\boldsymbol{t}\) 创建对偶四元数。它生成形式为以下所示的对偶四元数 \(\sigma\)
static DualQuat< _Tp >	createFromMat (InputArray _R)
	将此对偶四元数转换为仿射变换矩阵 \(M\)。对偶四元数由旋转 \(r=[a,b,c,d]\) 和平移 \(t=[\Delta x,\Delta y,\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_

静态公共属性
static 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)
	如果 \(\sigma = p + \epsilon 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
• “对偶四元数”，贾燕滨，2013
• “使用近似对偶四元数混合的几何蒙皮”，Kavan，2008
• http://rodolphe-vaillant.fr/?e=29

单位对偶四元数可以经典地表示为

\[ \begin{equation} \begin{split} \sigma &= \left(r+\frac{\epsilon}{2}tr\right)\\ &= [w, x, y, z, w\_, x\_, y\_, z\_] \end{split} \end{equation} \]

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

由两个四元数组成的通用对偶四元数通常表示为

\[ \sigma = p + \epsilon q \]

其中引入的对偶单位 \(\epsilon\) 满足 \(\epsilon^2 = \epsilon^3 =...=0\)，且 \(p, q\) 是四元数。

另外，对偶四元数也可以解释为四个分量，它们都是 对偶数

\[ \sigma = \hat{q}_w + \hat{q}_xi + \hat{q}_yj + \hat{q}_zk \]

如果我们设置 \(\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 创建
// 有关 Rt 形式的详细信息，请参阅 createFromMat()
Matx44d Rt = dq3.toMat();
DualQuatd dq5 = DualQuatd::createFromMat(Rt);
 
// 任何旋转+平移运动都可以
// 表示为围绕空间中同一条线（通过 Plucker 坐标表示）的旋转和平移，
// 这是一种表示它的方式。
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+\epsilon v]=[1,0,0,0,0,x,y,z]\)。在对偶四元数 \(\sigma\) 下，点 \(v_1\) 到另一个点 \(v_2\) 的变换为

\[ 1 + \epsilon v_2 = \sigma * (1 + \epsilon v_1) * \sigma^{\star} \]

其中 \(\sigma^{\star}=p^*-\epsilon q^*.\)

在 \(Pl\ddot{u}cker\) 坐标 \((\hat{l}, m)\) 中由对偶四元数 \(l=\hat{l}+\epsilon m\) 定义的直线。要变换一条直线，

\[l_2 = \sigma * l_1 * \sigma^*,\]

其中 \(\sigma=r+\frac{\epsilon}{2}rt\) 和 \(\sigma^*=p^*+\epsilon q^*\)。

要提取 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{equation} \begin{split} \sigma^* &= (p + \epsilon q)^* &= (p^* + \epsilon q^*) \end{split} \end{equation} \]

createFromAffine3()

template<typename _Tp >

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

static

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

createFromAngleAxisTrans()

template<typename _Tp >

static DualQuat< _Tp > cv::DualQuat< _Tp >::createFromAngleAxisTrans ( const _Tp angle, const Vec< _Tp, 3 > & axis（轴）, const Vec< _Tp, 3 > & translation )

static

从旋转角 \(\theta\)、旋转轴 \(\boldsymbol{u}\) 和平移 \(\boldsymbol{t}\) 创建对偶四元数。它生成形式为以下所示的对偶四元数 \(\sigma\)

\[\begin{equation} \begin{split} \sigma &= r + \frac{\epsilon}{2}\boldsymbol{t}r \\ &= [\cos(\frac{\theta}{2}), \boldsymbol{u}\sin(\frac{\theta}{2})] + \frac{\epsilon}{2}[0, \boldsymbol{t}][[\cos(\frac{\theta}{2}), \boldsymbol{u}\sin(\frac{\theta}{2})]]\\ &= \cos(\frac{\theta}{2}) + \boldsymbol{u}\sin(\frac{\theta}{2}) + \frac{\epsilon}{2}(-(\boldsymbol{t} \cdot \boldsymbol{u})\sin(\frac{\theta}{2}) + \boldsymbol{t}\cos(\frac{\theta}{2}) + \boldsymbol{u} \times \boldsymbol{t} \sin(\frac{\theta}{2})). \end{split} \end{equation}\]

参数

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

注意

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

另请参见

Quat

createFromMat()

template<typename _Tp >

static DualQuat< _Tp > cv::DualQuat< _Tp >::createFromMat ( InputArray _R )

static

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

\[ \begin{bmatrix} 1-2(e_2^2 +e_3^2) &2(e_1e_2-e_0e_3) &2(e_0e_2+e_1e_3) &\Delta x\\ 2(e_0e_3+e_1e_2) &1-2(e_1^2+e_3^2) &2(e_2e_3-e_0e_1) &\Delta y\\ 2(e_1e_3-e_0e_2) &2(e_0e_1+e_2e_3) &1-2(e_1^2-e_2^2) &\Delta z\\ 0&0&0&1 \end{bmatrix} \]

如果 A 是一个包含 n 个待变换点的矩阵，这可以通过以下方式实现：

\[ new\_A = M * A \]

其中 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\\ 1&1&1&...&1 \end{bmatrix} \]

其中相同的下标表示同一个点。A 的大小应为 \([4,n]\)。矩阵 new_A 的大小也相同。

参数

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

注意

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

createFromPitch()

template<typename _Tp >

static DualQuat< _Tp > cv::DualQuat< _Tp >::createFromPitch ( const _Tp angle, const _Tp d, const Vec< _Tp, 3 > & axis（轴）, const Vec< _Tp, 3 > & moment )

static

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

\[ \begin{equation} \begin{split} \sigma &=\boldsymbol{p} + \epsilon \boldsymbol{q}\\ &= \cos\hat{\frac{\theta}{2}}+\overline{\hat{l}}\sin\frac{\hat{\theta}}{2} \end{split} \end{equation} \]

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

\[ \hat{\theta}=\theta + \epsilon d,\\ \overline{\hat{l}}= \hat{l} +\epsilon m. \]

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

参数

angle	旋转角度。
d	沿旋转轴的平移。
axis（轴）	用 w = 0 的四元数表示的旋转轴。
力矩	线的力矩，应与轴正交。

注意

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

createFromQuat()

template<typename _Tp >

static DualQuat< _Tp > cv::DualQuat< _Tp >::createFromQuat ( const Quat< _Tp > & realPart, const Quat< _Tp > & dualPart )

static

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

\[\sigma = p + \epsilon q\]

其中 p 和 q 定义如下

\[\begin{equation} \begin{split} p &= w + x\boldsymbol{i} + y\boldsymbol{j} + z\boldsymbol{k}\\ q &= w\_ + x\_\boldsymbol{i} + y\_\boldsymbol{j} + z\_\boldsymbol{k}. \end{split} \end{equation} \]

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

参数

realPart	四元数，双四元数的实部。
对偶部	四元数，双四元数的对偶部。

另请参见

Quat

dot()

template<typename _Tp >

_Tp cv::DualQuat< _Tp >::dot

(

DualQuat< _Tp >

p

)

const

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

参数

p

另一个双四元数。

dqblend()

template<typename _Tp >

static DualQuat< _Tp > cv::DualQuat< _Tp >::dqblend ( const DualQuat< _Tp > & q1, const DualQuat< _Tp > & q2, const _Tp t, QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT )

static

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

\[ DQB(t;{\boldsymbol{q}}_1,{\boldsymbol{q}}_2)= \frac{(1-t){\boldsymbol{q}}_1+t{\boldsymbol{q}}_2}{||(1-t){\boldsymbol{q}}_1+t{\boldsymbol{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>

static DualQuat< _Tp > cv::DualQuat< _Tp >::gdqblend ( const Vec< DualQuat< _Tp >, cn > & 双四元数, InputArray weights, QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT )

static

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

\[ gDQB(\boldsymbol{w};{\boldsymbol{q}}_1,...,{\boldsymbol{q}}_n)=\frac{w_1{\boldsymbol{q}}_1+...+w_n{\boldsymbol{q}}_n} {||w_1{\boldsymbol{q}}_1+...+w_n{\boldsymbol{q}}_n||}. \]

参数

双四元数	双四元数向量
weights	权重向量，权重的尺寸应与双四元数相同，且权重应满足 \(\sum_0^n w_{i} = 1\) 和 \(w_i>0\)。
assumeUnit	如果 QUAT_ASSUME_UNIT，这些双四元数被假定为单位双四元数，此函数将节省一些计算。

注意

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

gdqblend() [2/2]

template<typename _Tp >

static DualQuat< _Tp > cv::DualQuat< _Tp >::gdqblend ( InputArray 双四元数, InputArray weights, QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT )

static

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

\[ gDQB(\boldsymbol{w};{\boldsymbol{q}}_1,...,{\boldsymbol{q}}_n)=\frac{w_1{\boldsymbol{q}}_1+...+w_n{\boldsymbol{q}}_n} {||w_1{\boldsymbol{q}}_1+...+w_n{\boldsymbol{q}}_n||}. \]

参数

双四元数	具有 8 个通道和 1 行或 1 列的双四元数。
weights	权重向量，权重的尺寸应与双四元数相同，且权重应满足 \(\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

返回平移向量。此对偶四元数 \(\sigma\) 中的旋转 \(r\) 在平移 \(t\) 之前应用。对偶四元数 \(\sigma\) 定义为

\[\begin{equation} \begin{split} \sigma &= p + \epsilon q \\ &= r + \frac{\epsilon}{2}{t}r. \end{split} \end{equation}\]

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

\[t = 2qp^*.\]

参数

assumeUnit

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

注意

此双四元数的平移在旋转之后应用。

inv()

template<typename _Tp >

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

(

QuatAssumeType

assumeUnit = QUAT_ASSUME_NOT_UNIT

)

const

如果 \(\sigma = p + \epsilon q\) 是一个对偶四元数，且 p 不为零，则其逆对偶四元数为

\[\sigma^{-1} = \frac{\sigma^*}{||\sigma||^2}, \]

或者等效地，

\[\sigma^{-1} = p^{-1} - \epsilon p^{-1}qp^{-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

返回对偶四元数 \(\sigma = p + \epsilon q\) 的范数 \(||\sigma||\)。

\[ \begin{equation} \begin{split} ||\sigma|| &= \sqrt{\sigma * \sigma^*} \\ &= ||p|| + \epsilon \frac{p \cdot q}{||p||}. \end{split} \end{equation} \]

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

\[ ||\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{equation} \begin{split} \sigma &= p + \epsilon q\\ &=||\sigma||\left(r+\frac{1}{2}tr\right) \end{split} \end{equation} \]

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

\[ ||p||=1, p \cdot q=0 \]

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

\[ \sigma_{u}=\frac{\sigma}{||\sigma||} \]

接下来，我们简单证明 \(\sigma_u\) 是一个单位双四元数

\[ \renewcommand{\Im}{\operatorname{Im}} \begin{equation} \begin{split} \sigma_{u}=\frac{\sigma}{||\sigma||}&=\frac{p + \epsilon q}{||p||+\epsilon\frac{p\cdot q}{||p||}}\\ &=\frac{p}{||p||}+\epsilon\left(\frac{q}{||p||}-p\frac{p\cdot q}{||p||^3}\right)\\ &=\frac{p}{||p||}+\epsilon\frac{1}{||p||^2}\left(qp^{*}-p\cdot q\right)\frac{p}{||p||}\\ &=\frac{p}{||p||}+\epsilon\frac{1}{||p||^2}\Im(qp^*)\frac{p}{||p||}.\\ \end{split} \end{equation} \]

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

operator*()

template<typename _Tp >

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

(

const DualQuat< _Tp > &

)

const

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

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

\[ \begin{equation} \begin{split} p * q &= [A, B][C, D]\\ &=[AC, AD + BC] \end{split} \end{equation} \]

例如

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

s

)

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

双四元数与标量相乘规则

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

例如

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*

(

const DualQuat< _Tp > &

)

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

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

\[ \begin{equation} \begin{split} p * q &= [A, B][C, D]\\ &=[AC, AD + BC] \end{split} \end{equation} \]

例如

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+

(

const DualQuat< _Tp > &

)

const

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

例如

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+=

(

const 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) = 0.\) 的反向对偶四元数 \(-p\)。

例如

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-

(

const DualQuat< _Tp > &

)

const

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

例如

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-

(

const 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

s

)

const

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

双四元数与标量相除规则

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

例如

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/

(

const DualQuat< _Tp > &

)

const

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

双四元数与双四元数相除规则

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

例如

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

s

)

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

双四元数与标量相除规则

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

例如

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/>

(

const DualQuat< _Tp > &

)

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

双四元数与四元数相除规则

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

例如

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==

(

const DualQuat< _Tp > &

)

const

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

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	(	const 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 ( const DualQuat< _Tp > & q1, const DualQuat< _Tp > & q2, const _Tp t, bool directChange = true, QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT )

static

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

\[ ScLERP(t;\sigma_1,\sigma_2) = \sigma_1 * (\sigma_1^{-1} * \sigma_2)^t, t\in[0,1] \]

参数

q1	表示初始位姿的双四元数。
q2	表示最终位姿的双四元数。
t	插值参数
directChange	如果为 true，它总是返回最短路径。
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{equation} \begin{split} \sigma^* &= (p + \epsilon q)^* &= (p^* + \epsilon q^*) \end{split} \end{equation} \]

参数

dq

一个双四元数。

cv::operator* [1/2]

template<typename _Tp >

template<typename T >

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

friend

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

双四元数与标量相乘规则

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

例如

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 s, const DualQuat< T > &  )

friend

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

双四元数与标量相乘规则

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

例如

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 s, 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 s, 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

如果 \(\sigma = p + \epsilon q\) 是一个对偶四元数，且 p 不为零，则其逆对偶四元数为

\[\sigma^{-1} = \frac{\sigma^*}{||\sigma||^2}, \]

或者等效地，

\[\sigma^{-1} = p^{-1} - \epsilon p^{-1}qp^{-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