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 + (-p) = 0.\)。
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 _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\)、旋转轴 \(\boldsymbol{u}\) 和平移 \(\boldsymbol{t}\) 创建一个双四元数。它会生成一个形式为
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)
	广义双四元数线性混合适用于两个以上的刚性变换。如果这些变换用单位双四元数 \(q_1,...,q_n\) 表示，并带有凸权重 \(w = (w_1,...,w_n)\)，则广义 DQB 简化为。
static DualQuat< _Tp >	gdqblend (InputArray dualquat, InputArray weights, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
	广义双四元数线性混合适用于两个以上的刚性变换。如果这些变换用单位双四元数 \(q_1,...,q_n\) 表示，并带有凸权重 \(w = (w_1,...,w_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
• "A beginners guide to dual-quaternions: what they are, how they work, and how to use them for 3D character hierarchies", Ben Kenwright, 2012
• "Dual Quaternions", Yan-Bin Jia, 2013
• "Geometric Skinning with Approximate Dual Quaternion Blending", 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]\)。点 \(v_1\) 在双四元数 \(\sigma\) 下变换到另一个点 \(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}\) 创建一个双四元数。它会生成一个形式为

\[\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	一个四元数，双四元数的实部。
dualPart	一个四元数，双四元数的对偶部。

另请参见

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 > &  dualquat, InputArray  weights, QuatAssumeType  assumeUnit = QUAT_ASSUME_NOT_UNIT  )

static

广义双四元数线性混合适用于两个以上的刚性变换。如果这些变换用单位双四元数 \(q_1,...,q_n\) 表示，并带有凸权重 \(w = (w_1,...,w_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||}. \]

参数

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

注意

权重元素的类型应与 dualquat 中的对偶四元数的日期类型相同。

gdqblend() [2/2]

template<typename _Tp >

static DualQuat< _Tp > cv::DualQuat< _Tp >::gdqblend ( InputArray  dualquat, InputArray  weights, QuatAssumeType  assumeUnit = QUAT_ASSUME_NOT_UNIT  )

static

广义双四元数线性混合适用于两个以上的刚性变换。如果这些变换用单位双四元数 \(q_1,...,q_n\) 表示，并带有凸权重 \(w = (w_1,...,w_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||}. \]

参数

dualquat	具有 8 个通道和 1 行或 1 列的对偶四元数。
weights	权重向量，权重的大小应与 dualquat 相同，并且权重应满足 \(\sum_0^n w_{i} = 1\) 且 \(w_i>0\)。
assumeUnit	如果 QUAT_ASSUME_UNIT，则这些对偶四元数假定为单位四元数，此函数将节省一些计算。

注意

权重元素的类型应与 dualquat 中的对偶四元数的日期类型相同。

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

(

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 几乎相等，则返回 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	(	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	如果为真，它始终返回最短路径。
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 >

constexpr _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