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