#include <dualquaternion.hpp>

公開メンバ関数
	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_)
	8つの同じ型の数値から作成する。

	DualQuat (const Vec< _Tp, 8 > &q)
	doubleまたはfloatのベクトルから作成します。

Quat< _Tp >	getRealPart () const
	双対四元数の実数部を表す四元数を返します。実部の定義は以下のとおりです。createFromQuat().[【詳解】（英語］

Quat< _Tp >	getDualPart () const
	は、二重四元数の二重部分を表す四元数を返します。二重部分の定義は以下の通りです。createFromQuat().[【詳解】（英語］

DualQuat< _Tp >	conjugate () const
	dual quaternionの共役を返します。[【詳解】（英語］

Quat< _Tp >	getRotation (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	回転をクオータニオン形式で返します。

Vec< _Tp, 3 >	getTranslation (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	並進ベクトルを返す。回転この二重四元演算子の $\sigma$ の回転は平行移動の前に適用されます。. 双対の四元演算子 $\sigma$ は次のように定義されます。[【詳解】（英語］

DualQuat< _Tp >	norm () const
	のノルムを返します。 $\|\|\sigma\|\|$ のノルムを返します。 $\sigma = p + \epsilon q$ .[【詳解】（英語］

DualQuat< _Tp >	normalize () const
	は正規化された二重四元数を返します。デュアルクォータニオンは次のように表されます。[【詳解】（英語］

DualQuat< _Tp >	inv (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	もし $\sigma = p + \epsilon q$ は双対四元数であり，pはゼロではないので，逆双対四元数は[【詳解】（英語］

_Tp	dot (DualQuat< _Tp > p) const
	2つの双対四元数のドットプロダクトを返します。[【詳解】（英語］

DualQuat< _Tp >	power (const _Tp t, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	の値を返します。ここで、pは二重四元演算子です。これは次のように計算できます。[【詳解】（英語］

DualQuat< _Tp >	power (const DualQuat< _Tp > &q, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	の値を返します。pとqは二重四元数です。これは次のように計算できます。[【詳解】（英語］

DualQuat< _Tp >	exp () const
	指数関数の値を返します。

DualQuat< _Tp >	log (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	対数関数の値を返す。[【詳解】（英語］

Vec< _Tp, 8 >	toVec () const
	このデュアルクォータニオンをベクトルに変換します。

Matx< _Tp, 4, 4 >	toMat (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	この双対の四元演算子を，行列形式のアフィン変換行列に変換します。createFromMat().

Affine3< _Tp >	toAffine3 (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	この双対の四元数を Affine3 のインスタンスに変換します。

DualQuat< _Tp >	operator- () const
	反対側の二元クォータニオンを返します。を満足する反対側の二元四元演算子 [【詳解】（英語］

bool	operator== (const DualQuat< _Tp > &) const
	2つのクォータニオン p と q がほぼ等しい場合，つまりそれぞれの絶対値が CV_DUAL_QUATRONI よりも小さい場合，true を返します．およびすなわち，それぞれの絶対値が CV_DUAL_QUAT_EPS よりも小さい場合です．

DualQuat< _Tp >	operator- (const DualQuat< _Tp > &) const
	2つの二元四元数p,qの減算演算子です。および.[【詳解】（英語］

DualQuat< _Tp > &	operator-= (const DualQuat< _Tp > &)
	2つの二元四元数pとqの減算代入演算子。左のオペランドから右のオペランドを引き、その結果を左のオペランドに代入します。[【詳解】（英語］

DualQuat< _Tp >	operator+ (const DualQuat< _Tp > &) const
	2つのデュアルクォータニオンpとqの加算演算子です。および.[【詳解】（英語］

DualQuat< _Tp > &	operator+= (const DualQuat< _Tp > &)
	2つの二元四元数p,qの加算代入演算子です。左のオペランドに右のオペランドを加算し、その結果を左のオペランドに代入します。[【詳解】（英語］

DualQuat< _Tp > &	operator*= (const DualQuat< _Tp > &)
	2つのクォータニオンの乗算代入演算子です。右のオペランドと左のオペランドを乗算し、その結果を左のオペランドに代入します。[【詳解】（英語］

DualQuat< _Tp >	operator*= (const _Tp s)
	四元数とスカラーの乗算代入演算子。右のオペランドと左のオペランドを掛け合わせ、その結果を左のオペランドに代入します。[【詳解】（英語］

DualQuat< _Tp >	operator* (const DualQuat< _Tp > &) const
	2つの双対四元数qとpの乗算演算子。演算子の両側の値を乗算します。[【詳解】（英語］

DualQuat< _Tp >	operator/ (const _Tp s) const
	2つの四元数とスカラーの除算演算子です。左のオペランドを右のオペランドで除算し、その結果を左のオペランドに代入します。[【詳解】（英語］

DualQuat< _Tp >	operator/ (const DualQuat< _Tp > &) const
	左手のオペランドを右手のオペランドで除算する2つの2元クォータニオンpとqの除算演算子です。[【詳解】（英語］

DualQuat< _Tp > &	operator/= (const DualQuat< _Tp > &)
	2つの二元四元数p,qの除算代入演算子；左オペランドを右オペランドで除算し、結果を左オペランドに代入します。[【詳解】（英語］

Quat< _Tp > &	operator/= (const _Tp s)
	二重四元数とスカラーの除算代入演算子です。左手のオペランドを右手のオペランドで除算し、その結果を左手のオペランドに代入します。[【詳解】（英語］

template<typename T >
DualQuat< T >	power (const T t, QuatAssumeType assumeUnit) const

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

template<int cn>
DualQuat< T >	gdqblend (const Vec< DualQuat< T >, cn > &_dualquat, InputArray _weight, QuatAssumeType assumeUnit)

静的公開メンバ関数
static DualQuat< _Tp >	createFromQuat (const Quat< _Tp > &realPart, const Quat< _Tp > &dualPart)
	同じ型の2つのクォータニオンpとqからデュアルクォータニオンを作成します。デュアルクォータニオン $\sigma$ は次のような形をしています。[【詳解】（英語］

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)
	この二重四元演算子をアフィン変換行列に変換します。. デュアルクオータニオンは、回転並進 $t=[\Delta x,\Delta y,\Delta z]$ . アフィン変換行列は次のような形をしています。[【詳解】（英語］

static DualQuat< _Tp >	createFromAffine3 (const Affine3< _Tp > &R)
	アフィン行列から二重四元演算を行います．アフィン行列の定義は，以下を参照してくださいcreateFromMat()

static DualQuat< _Tp >	createFromPitch (const _Tp angle, const _Tp d, const Vec< _Tp, 3 > &axis, const Vec< _Tp, 3 > &moment)
	デュアルクォータニオンは、次の形式のベクトルです。[【詳解】（英語］

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$ は初期ポーズと最終ポーズを表す2つの二重四元数です。ScLERP関数の補間は次のように定義できる。[【詳解】（英語］

static DualQuat< _Tp >	dqblend (const DualQuat< _Tp > &q1, const DualQuat< _Tp > &q2, const _Tp t, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
	Dual Quaternion Linear Blending(DQB)は、2つのdual quaternion間の変換を計算するものです。およびと定義することができます。[【詳解】（英語］

template<int cn>
static DualQuat< _Tp >	gdqblend (const Vec< DualQuat< _Tp >, cn > &dualquat, InputArray weights, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
	一般化されたDual Quaternion linear Blendingは，2つ以上の剛体変換に対して動作します．これらの変換が，凸型の重みを持つ単位双対四元数として表される場合は凸の重みを持つとすると、一般化DQBは単に[【詳解】（英語］

static DualQuat< _Tp >	gdqblend (InputArray dualquat, InputArray weights, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
	一般化されたDual Quaternion linear Blendingは，2つ以上の剛体変換に対して動作します．これらの変換が，凸型の重みを持つ単位双対四元数として表される場合は凸の重みを持つとすると、一般化DQBは単に[【詳解】（英語］

公開変数類
_Tp	w

_Tp	x

_Tp	y

_Tp	z

_Tp	w_

_Tp	x_

_Tp	y_

_Tp	z_

静的公開変数類
static constexpr _Tp	CV_DUAL_QUAT_EPS = (_Tp)1.e-6

フレンド
template<typename T >
DualQuat< T >	conjugate (const DualQuat< T > &dq)
	dual quaternionの共役を返します。[【詳解】（英語］

template<typename T >
DualQuat< T >	inv (const DualQuat< T > &dq, QuatAssumeType assumeUnit)
	もし $\sigma = p + \epsilon q$ は双対四元数であり，pはゼロではないので，逆双対四元数は[【詳解】（英語］

template<typename T >
DualQuat< T >	power (const DualQuat< T > &dq, const T t, QuatAssumeType assumeUnit)
	の値を返します。ここで、pは二重四元演算子です。これは次のように計算できます。[【詳解】（英語］

template<typename T >
DualQuat< T >	power (const DualQuat< T > &p, const DualQuat< T > &q, QuatAssumeType assumeUnit)
	の値を返します。pとqは二重四元数です。これは次のように計算できます。[【詳解】（英語］

template<typename T >
DualQuat< T >	exp (const DualQuat< T > &dq)
	指数関数の値を返します。[【詳解】（英語］

template<typename T >
DualQuat< T >	log (const DualQuat< T > &dq, QuatAssumeType assumeUnit)
	対数関数の値を返す。[【詳解】（英語］

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 T >
DualQuat< T >	cv::operator* (const DualQuat< T > &, const T s)
	デュアルクォータニオンとスカラーの乗算演算子です。右のオペランドと左のオペランドを掛け合わせ、その結果を左のオペランドに代入します。[【詳解】（英語］

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

詳解

template<typename _Tp>
クラス cv::DualQuat< _Tp > 。

デュアルクォータニオンは，通常のクォータニオンが回転のみを記述できるのに対して，回転と並進を同時に記述するために導入されました．これは，最短経路でのポーズ補間，局所的なポーズの最適化，空間的な変形などに利用できます．詳細は以下をご覧ください。

単位デュアルクオータニオンは、古典的に次のように表すことができます。

$\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$ はそれぞれ回転（通常の単位四元数）と並進（純粋な通常四元数）を表します。

2つの四元数からなる一般的な二元四元数は、通常、次のような形で表されます。

$\sigma = p + \epsilon q$

ここで、導入された双対単位 $\epsilon$ は以下の条件を満たします。 $\epsilon^2 = \epsilon^3 =...=0$ を満たす。 $p, q$ は四元数である。

また、双対四元数は4つの要素で構成されていると解釈することもできます。双対数:

$\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;


// create from eight number
DualQuatd dq1(1, 2, 3, 4, 5, 6, 7, 8);
//p = [1,2,3,4]. q=[5,6,7,8]


// create from Vec
Vec<double, 8> v{1,2,3,4,5,6,7,8};
DualQuatd dq_v{v};


// create from two quaternion
Quatd p(1, 2, 3, 4);
Quatd q(5, 6, 7, 8);
DualQuatd dq2 =
DualQuatd::createFromQuat(p, q);


// create from an angle, an axis and a translation
Vec3d axis{0, 0, 1};
Vec3d trans{3, 4, 5};
DualQuatd dq3 =
DualQuatd::createFromAngleAxisTrans(angle, axis, trans);


// If you already have an instance of class Affine3, then you can use
Affine3d R = dq3.toAffine3();
DualQuatd dq4 =
DualQuatd::createFromAffine3(R);


// or create directly by affine transformation matrix Rt

// see createFromMat() in detail for the form of Rt
Matx44d Rt = dq3.toMat();
DualQuatd dq5 =
DualQuatd::createFromMat(Rt);


// Any rotation + translation movement can

// be expressed as a rotation + translation around the same line in space (expressed by Plucker

// coords), and here's a way to represent it this way.
Vec3d axis{1, 1, 1};
// axis will be normalized in createFromPitch
Vec3d trans{3, 4 ,5};
axis = axis /
std::sqrt(axis.dot(axis));// The formula for computing moment that I use below requires a normalized 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$ から別の点 $v_2$ 二元的な四元数の下で $\sigma$ が

$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();

2つのクォータニオンの場合 $q_0, q_1$ が補間される必要がある場合はsclerp()

DualQuatd::sclerp(q0, q1, t)

cv::DualQuat::sclerp

static DualQuat< _Tp > sclerp(const DualQuat< _Tp > &q1, const DualQuat< _Tp > &q2, const _Tp t, bool directChange=true, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)

The screw linear interpolation(ScLERP) is an extension of spherical linear interpolation of dual quat...

Definition: dualquaternion.inl.hpp:405

またはdqblend().

DualQuatd::dqblend(q0, q1, t)

cv::DualQuat::dqblend

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

The method of Dual Quaternion linear Blending(DQB) is to compute a transformation between dual quater...

Definition: dualquaternion.inl.hpp:424

2つ以上のデュアルクォータニオンをブレンドする必要がある場合は、対応するウェイトを用いた一般化線形デュアルクォータニオンブレンドを使用できます、つまりgdqblend().

関数詳解

◆ conjugate()

template<typename T >

DualQuat< T > cv::DualQuat< T >::conjugate

inline

dual quaternionの共役を返します。

$\begin{equation} \begin{split} \sigma^* &= (p + \epsilon q)^* &= (p^* + \epsilon q^*) \end{split} \end{equation}$

◆ createFromAngleAxisTrans()

template<typename _Tp >

DualQuat< T > cv::DualQuat< T >::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	回転軸．
translation	長さ3のベクトル．

覚え書き: 軸はこの関数で正規化されます。また，回転の後に平行移動が行われます．使用するcreateFromQuat(r, r * t / 2) を使って、回転の前に並進が適用される二重四元数を作成します。

参照: Quat

◆ createFromMat()

template<typename T >

DualQuat< T > cv::DualQuat< T >::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 >

DualQuat< T > cv::DualQuat< T >::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の四元数で表されます。
moment	は線のモーメントで、軸と直交している必要があります。

覚え書き: 並進は回転の後に適用されます。createFromQuat(r, r * t / 2) を使用して、回転の前に並進が適用されるデュアルクォータニオンを作成します。

◆ createFromQuat()

template<typename _Tp >

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

static

同じ型の2つのクォータニオン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	a quaternion, dual quaternionの双対部分。

参照: Quat

◆ dot()

template<typename _Tp >

T cv::DualQuat< T >::dot ( DualQuat< _Tp > p ) const

inline

2つの双対四元数のドットプロダクトを返します。

引数

p	他のデュアルクオータニオン。

◆ dqblend()

template<typename _Tp >

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

static

Dual Quaternion Linear Blending(DQB)は、2つのdual quaternion間の変換を計算するものです。 $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$ は入力された変換を表す単位双対四元数です。2つ以上の剛体変換に対応するDQBを使いたい場合は、以下を参照してください。gdqblend

引数

q1	は，入力変換を表す単位双対四元数です。
q2	は，入力変換を表す単位双対四元数です。
t	パラメータ $t\in[0,1]$ .
assumeUnit	もしQUAT_ASSUME_UNITを指定すると，この双対四元数は単位双対四元数であると仮定され，この関数はいくつかの計算を節約します。

参照: gdqblend

◆ 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

一般化されたDual Quaternion linear Blendingは，2つ以上の剛体変換に対して動作します．これらの変換が，凸型の重みを持つ単位双対四元数として表される場合は $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$ および.
assumeUnit	もしQUAT_ASSUME_UNITこれらの双対四元数は単位四元数であると仮定し、この関数はいくつかの計算を節約します。

覚え書き: 重みの要素のタイプは、dualquat内の双対四元数の日付タイプと同じでなければなりません。

◆ gdqblend() [2/2]

template<typename T >

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

static

一般化されたDual Quaternion linear Blendingは，2つ以上の剛体変換に対して動作します．これらの変換が，凸型の重みを持つ単位双対四元数として表される場合は $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$ および.
assumeUnit	もしQUAT_ASSUME_UNITこれらの双対四元数は単位四元数であると仮定し、この関数はいくつかの計算を節約します。

覚え書き: 重みの要素のタイプは、dualquat内の双対四元数の日付タイプと同じでなければなりません。

◆ getDualPart()

template<typename T >

Quat< T > cv::DualQuat< T >::getDualPart

inline

は、二重四元数の二重部分を表す四元数を返します。二重部分の定義は以下の通りです。createFromQuat().

参照: createFromQuat,getRealPart

◆ getRealPart()

template<typename T >

Quat< T > cv::DualQuat< T >::getRealPart

inline

双対四元数の実数部を表す四元数を返します。実部の定義は以下のとおりです。createFromQuat().

参照: createFromQuat,getDualPart

◆ getTranslation()

template<typename T >

Vec< T, 3 > cv::DualQuat< T >::getTranslation ( QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT ) const

inline

並進ベクトルを返す。回転 $r$ この二重四元演算子の $\sigma$ の回転は平行移動の前に適用されます。 $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 T >

DualQuat< T > cv::DualQuat< T >::inv ( QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT ) const

inline

もし $\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 T >

DualQuat< T > cv::DualQuat< T >::log ( QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT ) const

対数関数の値を返す。

引数

assumeUnit もしQUAT_ASSUME_UNITを指定すると，この双対四元数は単位双対四元数であると仮定され，この関数はいくつかの計算を節約します。

◆ norm()

template<typename T >

DualQuat< T > cv::DualQuat< T >::norm

のノルムを返します。 $||\sigma||$ のノルムを返します。 $\sigma = p + \epsilon q$ .

$\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].$

覚え書き: デュアルナンバーのデータタイプは dual quaternion です。

◆ normalize()

template<typename T >

DualQuat< T > cv::DualQuat< T >::normalize

は正規化された二重四元数を返します。デュアルクォータニオンは次のように表されます。

$\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< T > cv::DualQuat< T >::operator* ( const DualQuat< _Tp > & ) const

inline

2つの双対四元数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 > & )

2つのクォータニオンの乗算代入演算子です。右のオペランドと左のオペランドを乗算し、その結果を左のオペランドに代入します。

双対四元数乗算のルール。双対の四元数は、四元数の順序付きペア[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< T > cv::DualQuat< T >::operator+ ( const DualQuat< _Tp > & ) const

inline

2つのデュアルクォータニオン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< T > & cv::DualQuat< T >::operator+= ( const DualQuat< _Tp > & )

inline

2つの二元四元数p,qの加算代入演算子です。左のオペランドに右のオペランドを加算し、その結果を左のオペランドに代入します。

例えば

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

◆ operator-() [1/2]

template<typename T >

DualQuat< T > cv::DualQuat< T >::operator-

inline

反対側の二元クォータニオンを返します。 $-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

2つの二元四元数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< T > & cv::DualQuat< T >::operator-= ( const DualQuat< _Tp > & )

inline

2つの二元四元数pとqの減算代入演算子。左のオペランドから右のオペランドを引き、その結果を左のオペランドに代入します。

例えば

DualQuatd p{1, 2, 3, 4, 5, 6, 7, 8};
DualQuatd q{5, 6, 7, 8, 9, 10, 11, 12};
p -= q;
// equivalent to 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

2つの四元数とスカラーの除算演算子です。左のオペランドを右のオペランドで除算し、その結果を左のオペランドに代入します。

スカラーを用いた二重四元演算のルール。

$\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;
// equivalent to 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

左手のオペランドを右手のオペランドで除算する2つの2元クォータニオン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;
// equivalent to 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;
// equivalent to 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 > & )

2つの二元四元数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;
// equivalent to p = p * q.inv()
std::cout << p << std::endl;

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

DualQuat< T > cv::DualQuat< T >::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$ は初期ポーズと最終ポーズを表す2つの二重四元数です。ScLERP関数の補間は次のように定義できる。

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

引数

q1	a dual quaternion は初期ポーズを表す。
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);

フレンドと関連関数の詳解

◆ conjugate

template<typename _Tp >

template<typename T >

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

friend

dual quaternionの共役を返します。

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

覚え書き: スカラーのタイプはデュアルクォータニオンと同じでなければなりません。

◆ 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 = `QUAT_ASSUME_NOT_UNIT`
	)

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_UNITdual quaternion dq は、単位二重四元数であると仮定し、この関数はいくつかの計算を節約します。

◆ log

template<typename _Tp >

template<typename T >

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

friend

対数関数の値を返す。

引数

dq	デュアルクオータニオンの乗算演算子。
assumeUnit	もしQUAT_ASSUME_UNITdual quaternion dq は、単位二重四元数であると仮定し、この関数はいくつかの計算を節約します。

◆ power [1/2]

template<typename _Tp >

template<typename T >

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

friend

の値を返します。 $p^t$ ここで、pは二重四元演算子です。これは次のように計算できます。

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

引数

dq	デュアルクオータニオンの乗算演算子。
t	べき乗関数の指数。
assumeUnit	もしQUAT_ASSUME_UNITdual quaternion dq は、単位二重四元数であると仮定し、この関数はいくつかの計算を節約します。

◆ power [2/2]

template<typename _Tp >

template<typename T >

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

friend

の値を返します。 $p^q$ pとqは二重四元数です。これは次のように計算できます。

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

引数

p	デュアルクオータニオンの乗算演算子。
q	デュアルクオータニオンの乗算演算子。
assumeUnit	もしQUAT_ASSUME_UNITdual quaternion p は， dual unit quaternion であると仮定し，この関数はいくつかの計算を節約します．

このクラス詳解は次のファイルから抽出されました:

公開メンバ関数

静的公開メンバ関数

公開変数類

静的公開変数類

フレンド

詳解

関数詳解

◆ conjugate()

◆ createFromAngleAxisTrans()

◆ createFromMat()

◆ createFromPitch()

◆ createFromQuat()

◆ dot()

◆ dqblend()

◆ gdqblend() [1/2]

◆ gdqblend() [2/2]

◆ getDualPart()

◆ getRealPart()

◆ getTranslation()

◆ inv()

◆ log()

◆ norm()

◆ normalize()

◆ operator*()

◆ operator*=() [1/2]

◆ operator*=() [2/2]

◆ operator+()

◆ operator+=()

◆ operator-() [1/2]

◆ operator-() [2/2]

◆ operator-=()

◆ operator/() [1/2]

◆ operator/() [2/2]

◆ operator/=() [1/2]

◆ operator/=() [2/2]

◆ power() [1/2]

◆ power() [2/2]

◆ sclerp()

フレンドと関連関数の詳解

◆ conjugate

◆ cv::operator* [1/2]

◆ cv::operator* [2/2]

◆ cv::operator+ [1/2]

◆ cv::operator+ [2/2]

◆ cv::operator- [1/2]

◆ cv::operator- [2/2]

◆ exp

◆ inv

◆ log

◆ power [1/2]

◆ power [2/2]