#include <quaternion.hpp>

公開メンバ関数
	Quat (const Vec< _Tp, 4 > &coeff)
	Vec4dまたはVec4fから。

	Quat (_Tp w, _Tp x, _Tp y, _Tp z)
	4つの数字から

_Tp	at (size_t index) const
	要素を取得する方法です。[【詳解】（英語］

Quat< _Tp >	conjugate () const
	この四元数の共役を返します。[【詳解】（英語］

Quat< _Tp >	exp () const
	の指数値を返します。[【詳解】（英語］

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

Quat< _Tp >	power (const _Tp x, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	累乗関数の値を指数で返します。.[【詳解】（英語］

Quat< _Tp >	sqrt (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	リターン $\sqrt{q}$ .[【詳解】（英語］

Quat< _Tp >	power (const Quat< _Tp > &q, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	四元数を用いたべき乗関数の値を返す.[【詳解】（英語］

Quat< _Tp >	crossProduct (const Quat< _Tp > &q) const
	の間のクロスプロダクトを返します。 $p = (a, b, c, d) = (a, \boldsymbol{u})$ および $q = (w, x, y, z) = (w, \boldsymbol{v})$ .[【詳解】（英語］

_Tp	norm () const
	quaternionのノルムを返します。[【詳解】（英語］

Quat< _Tp >	normalize () const
	正規化された.[【詳解】（英語］

Quat< _Tp >	inv (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	リターン $q^{-1}$ の逆数であるを満たします。 $q * q^{-1} = 1$ .[【詳解】（英語］

Quat< _Tp >	sinh () const
	return sinh このクォータニオンの値、sinhは次のように計算できます。 $\sinh(p) = \sin(w)\cos(\|\|\boldsymbol{v}\|\|) + \cosh(w)\frac{v}{\|\|\boldsymbol{v}\|\|}\sin\|\|\boldsymbol{v}\|\|$ ここで $\boldsymbol{v} = [x, y, z].$ [【詳解】（英語］

Quat< _Tp >	cosh () const
	return cosh この四元数の値、coshは次のように計算できます。[【詳解】（英語］

Quat< _Tp >	tanh () const
	return tanh このクォータニオンの値、tanhは次のように計算できます。[【詳解】（英語］

Quat< _Tp >	sin () const
	return sin この四元数の値、sinは次のように計算できます。[【詳解】（英語］

Quat< _Tp >	cos () const
	return cos この四元数の値、cosは次のように計算できます。[【詳解】（英語］

Quat< _Tp >	tan () const
	return tan このクォータニオンの値、tanは次のように計算できます。[【詳解】（英語］

Quat< _Tp >	asin () const
	Return arcsin この四元数の値、arcsin は次のように計算されます。[【詳解】（英語］

Quat< _Tp >	acos () const
	return arccos このクォータニオンの値，arccosは次のように計算できる．[【詳解】（英語］

Quat< _Tp >	atan () const
	このクォータニオンのarctan値を返す。arctanは次のように計算できる。[【詳解】（英語］

Quat< _Tp >	asinh () const
	Return arcsinh このクォータニオンの値、arcsinh は次のように計算できます。[【詳解】（英語］

Quat< _Tp >	acosh () const
	return arccosh このクォータニオンの値、arccoshは次のように計算できる。[【詳解】（英語］

Quat< _Tp >	atanh () const
	return arctanh このクォータニオンの値、arctanhは次のように計算できます。[【詳解】（英語］

bool	isNormal (_Tp eps=CV_QUAT_EPS) const
	このクォータニオンが単位クォータニオンであれば真を返します。[【詳解】（英語］

void	assertNormal (_Tp eps=CV_QUAT_EPS) const
	は、この四元数が単位四元数でない場合にエラーを発生させます。[【詳解】（英語］

Matx< _Tp, 3, 3 >	toRotMat3x3 (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	四元演算子を 3x3 回転行列に変換します。[【詳解】（英語］

Matx< _Tp, 4, 4 >	toRotMat4x4 (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	は、四元数を4x4の回転行列に変換します。[【詳解】（英語］

Vec< _Tp, 4 >	toVec () const
	このquaternionをVec<T, 4>に変換します。[【詳解】（英語］

Vec< _Tp, 3 >	toRotVec (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	この四元演算子を回転ベクトルに変換します。[【詳解】（英語］

_Tp	getAngle (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	quaternionの角度を取得すると、回転角度を返します。[【詳解】（英語］

Vec< _Tp, 3 >	getAxis (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	クォータニオンの軸を取得すると、長さ3のベクトルが返されます。[【詳解】（英語］

_Tp	dot (Quat< _Tp > q) const
	四元数とこの四元数の間のドットを返します。とこの四元演算子の間のドットを返します。[【詳解】（英語］

Quat< _Tp >	operator- () const
	反対側の四元数を返します。を満足する反対側の二元四元演算子 [【詳解】（英語］

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

Quat< _Tp >	operator+ (const Quat< _Tp > &) const
	2つの四元数pとqの加算演算子。それぞれの値が以下の合計である新しい四元数を返します。および.[【詳解】（英語］

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

Quat< _Tp >	operator- (const Quat< _Tp > &) const
	2つの四元数pとqの減算演算子です。それぞれの値が、以下の合計である新しい四元数を返します。および.[【詳解】（英語］

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

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

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

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

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

Quat< _Tp >	operator/ (const Quat< _Tp > &) const
	2つの四元数pとqの除算演算子。左手のオペランドを右手のオペランドで除算します。[【詳解】（英語］

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

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

_Tp &	operator[] (std::size_t n)

const _Tp &	operator[] (std::size_t n) const

Vec< _Tp, 3 >	toEulerAngles (QuatEnum::EulerAnglesType eulerAnglesType)
	四元演算子qをオイラー角に変換します。[【詳解】（英語］

静的公開メンバ関数
static Quat< _Tp >	createFromAngleAxis (const _Tp angle, const Vec< _Tp, 3 > &axis)
	角度から、axis。この関数では、軸は正規化されます。そして、それは[【詳解】（英語］

static Quat< _Tp >	createFromRotMat (InputArray R)
	3x3 の回転行列から

static Quat< _Tp >	createFromRvec (InputArray rvec)
	回転ベクトルからは次のような形をしています。 $\theta \cdot \boldsymbol{u}$ ここで $\theta$ は回転角を， $\boldsymbol{u}$ は正規化された回転軸を表します。[【詳解】（英語］

static Quat< _Tp >	createFromEulerAngles (const Vec< _Tp, 3 > &angles, QuatEnum::EulerAnglesType eulerAnglesType)
	オイラー角から[【詳解】（英語］

static Quat< _Tp >	createFromYRot (const _Tp theta)
	Y軸を中心とした回転による四元数を次のように求めます。 $\theta$ .[【詳解】（英語］

static Quat< _Tp >	createFromXRot (const _Tp theta)
	X軸を中心とした回転から、次のようにして四元数を求めます。 $\theta$ .[【詳解】（英語］

static Quat< _Tp >	createFromZRot (const _Tp theta)
	Z軸を中心とした回転による四元数を次の式で得る。 $\theta$ .[【詳解】（英語］

static Quat< _Tp >	lerp (const Quat< _Tp > &q0, const Quat &q1, const _Tp t)
	からの補間を計算するにはからby Linear Interpolation(Nlerp) 2つのクォータニオンの場合、この補間曲線は次のように表示されます。[【詳解】（英語］

static Quat< _Tp >	nlerp (const Quat< _Tp > &q0, const Quat &q1, const _Tp t, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
	からの補間を計算するにはから正規化線形補間(Nlerp)では，線形補間(Lerp)の正規化された四元数を返します．[【詳解】（英語］

static Quat< _Tp >	slerp (const Quat< _Tp > &q0, const Quat &q1, const _Tp t, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT, bool directChange=true)
	の補間を計算するにはおよびとの間の補間を球形線形補間（Slerp）で計算しますが、これは次のように定義できます。[【詳解】（英語］

static Quat< _Tp >	squad (const Quat< _Tp > &q0, const Quat< _Tp > &s0, const Quat< _Tp > &s1, const Quat< _Tp > &q1, const _Tp t, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT, bool directChange=true)
	の補間を計算するには,,,球形と四角形(Squadrangle)によるもの。と定義することができる。[【詳解】（英語］

static Quat< _Tp >	interPoint (const Quat< _Tp > &q0, const Quat< _Tp > &q1, const Quat< _Tp > &q2, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
	これが四元数の計算の一部です。媒介となる四元数の計算は3つのクォータニオンの間の[【詳解】（英語］

static Quat< _Tp >	spline (const Quat< _Tp > &q0, const Quat< _Tp > &q1, const Quat< _Tp > &q2, const Quat< _Tp > &q3, const _Tp t, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
	の結果であるクォータニオンを計算する。ここでは補間値として，比率tでスクワッドによって構成された連続スプライン曲線および.およびが使用され、連続性が確保されます。t = 0の場合はを返し、t = 1の場合は.[【詳解】（英語］

公開変数類
_Tp	w

_Tp	x

_Tp	y

_Tp	z

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

static constexpr _Tp	CV_QUAT_CONVERT_THRESHOLD = (_Tp)1.e-6

フレンド
template<typename T >
Quat< T >	exp (const Quat< T > &q)
	の指数値を返します。[【詳解】（英語］

template<typename T >
Quat< T >	log (const Quat< T > &q, QuatAssumeType assumeUnit)
	は、対数関数の値を返します。[【詳解】（英語］

template<typename T >
Quat< T >	power (const Quat< T > &q, const T x, QuatAssumeType assumeUnit)
	累乗関数の値を指数で返します。.[【詳解】（英語］

template<typename T >
Quat< T >	sqrt (const Quat< T > &q, QuatAssumeType assumeUnit)
	リターン $\sqrt{q}$ .[【詳解】（英語］

template<typename T >
Quat< T >	power (const Quat< T > &p, const Quat< T > &q, QuatAssumeType assumeUnit)
	四元数を用いたべき乗関数の値を返す.[【詳解】（英語］

template<typename T >
Quat< T >	crossProduct (const Quat< T > &p, const Quat< T > &q)
	の間のクロスプロダクトを返します。 $p = (a, b, c, d) = (a, \boldsymbol{u})$ および $q = (w, x, y, z) = (w, \boldsymbol{v})$ .[【詳解】（英語］

template<typename T >
Quat< T >	inv (const Quat< T > &q, QuatAssumeType assumeUnit)
	リターン $q^{-1}$ の逆数であるを満足する反対側の二元四元演算子 $q * q^{-1} = 1$ .[【詳解】（英語］

template<typename T >
Quat< T >	sinh (const Quat< T > &q)
	return sinh 四元演算子qの値、sinhは次のように計算できます。[【詳解】（英語］

template<typename T >
Quat< T >	cosh (const Quat< T > &q)
	return cosh 四元演算子qの値、coshは次のように計算できます。[【詳解】（英語］

template<typename T >
Quat< T >	tanh (const Quat< T > &q)
	return tanh 四元演算子 q の値, tanh は次のように計算できます．[【詳解】（英語］

template<typename T >
Quat< T >	sin (const Quat< T > &q)
	quaternion qのtanh値を返します。sinは次のように計算できます。[【詳解】（英語］

template<typename T >
Quat< T >	cos (const Quat< T > &q)
	return sin 四元数 q の値, cos 次のように計算できます。[【詳解】（英語］

template<typename T >
Quat< T >	tan (const Quat< T > &q)
	return tan 四元演算子qの値、tanは次のように計算できます。[【詳解】（英語］

template<typename T >
Quat< T >	asin (const Quat< T > &q)
	quaternion qのarcsin値を返し、arcsinは次のように計算できます。[【詳解】（英語］

template<typename T >
Quat< T >	acos (const Quat< T > &q)
	quaternion qのarccos値を返します。arccosは次のように計算できます。[【詳解】（英語］

template<typename T >
Quat< T >	atan (const Quat< T > &q)
	return arctan 四元数 q の値, arctan は次のように計算できます。[【詳解】（英語］

template<typename T >
Quat< T >	asinh (const Quat< T > &q)
	quaternion qのarcsinhの値を返してください。[【詳解】（英語］

template<typename T >
Quat< T >	acosh (const Quat< T > &q)
	quaternion qのarccosh値を返す。arccoshは次のように計算できる。[【詳解】（英語］

template<typename T >
Quat< T >	atanh (const Quat< T > &q)
	quaternion qのarctanh値を返し、arctanhは次のように計算できます。[【詳解】（英語］

template<typename T >
Quat< T >	cv::operator- (const T s, const Quat< T > &)
	スカラーと四元数の減算演算子です。左手のオペランドから右手のオペランドを減算します。[【詳解】（英語］

template<typename T >
Quat< T >	cv::operator- (const Quat< T > &, const T s)
	四元数とスカラの減算演算子です。右手のオペランドを左手のオペランドから引きます。[【詳解】（英語］

template<typename T >
Quat< T >	cv::operator+ (const T s, const Quat< T > &)
	四元数とスカラの加算演算子です。左手のオペランドから右手のオペランドを加算します。[【詳解】（英語］

template<typename T >
Quat< T >	cv::operator+ (const Quat< T > &, const T s)
	四元数とスカラの加算演算子です。左手のオペランドから右手のオペランドを加算します。[【詳解】（英語］

template<typename T >
Quat< T >	cv::operator* (const T s, const Quat< T > &)
	スカラーとクォータニオンの乗算演算子。スカラーと四元数の乗算演算子で、右のオペランドと左のオペランドを掛け合わせ、その結果を左のオペランドに代入します。[【詳解】（英語］

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

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

詳解

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

Quaternion は，複素数を拡張した数系です．これは，3次元空間における回転として表現することができます．クォータニオンは，一般に次のような形式で表されます．

$q = w + x\boldsymbol{i} + y\boldsymbol{j} + z\boldsymbol{k}$

$q = [w, x, y, z]$

$q = [w, \boldsymbol{v}]$

$q = ||q||[\cos\psi, u_x\sin\psi,u_y\sin\psi, u_z\sin\psi].$

$q = ||q||[\cos\psi, \boldsymbol{u}\sin\psi]$

ここで $\psi = \frac{\theta}{2}$ , $\theta$ は回転角を表す。 $\boldsymbol{u} = [u_x, u_y, u_z]$ は正規化された回転軸、そして $||q||$ のノルムを表す。 $q$ .

単位四元数は、通常、回転を表すもので、次のような形をしています。

$q = [\cos\psi, u_x\sin\psi,u_y\sin\psi, u_z\sin\psi].$

軸周りの回転を表す四元数を作成するには $\boldsymbol{u}$ 角度 $\theta$ の軸周りの回転を表す四元数を作るには、次のようにします。

using namespace

cv;

double
angle = CV_PI;
Vec3d axis = {0, 0, 1};
Quatd q =
Quatd::createFromAngleAxis(angle, axis);

同じ型の数値を4つ使って、単純にクォータニオンを作成することもできます。

Quatd q(1, 2, 3, 4);

または、Vec4dまたはVec4fのベクトルを使用します。

Vec4d vec{1, 2, 3, 4};

Quatd q(vec);

Vec4f vec{1, 2, 3, 4};

Quatf q(vec);

3x3の回転行列Rがすでにある場合は、次のようにします。

Quatd q = Quatd::createFromRotMat(R);

cv::Quat::createFromRotMat

static Quat< _Tp > createFromRotMat(InputArray R)

from a 3x3 rotation matrix.

の形をした回転ベクトルrvecがすでにある場合はangle * axisを使うことができます。

Quatd q = Quatd::createFromRvec(rvec);

cv::Quat::createFromRvec

static Quat< _Tp > createFromRvec(InputArray rvec)

from a rotation vector has the form , where represents rotation angle and represents normalized ro...

クォータニオンから回転行列を抽出するには、以下を参照してください。toRotMat3x3()

Vec4d または Vec4f を抽出するには、以下を参照してください。toVec()

回転ベクトルを抽出するには、以下を参照してください。toRotVec()

もし、2つのクォータニオン $q_0, q_1$ が必要な場合は、次のように補間します。nlerp(),slerp()またはspline()

Quatd::nlerp(q0, q1, t)

Quatd::slerp(q0, q1, t)

Quatd::spline(q0, q0, q1, q1, t)

スプラインは、複数のクォータニオンの回転を滑らかに接続することができます。

クォータニオンの要素を取得する3つの方法

Quatf q(1,2,3,4);
std::cout << q.w << std::endl;
// w=1, x=2, y=3, z=4
std::cout << q[0] << std::endl;
// q[0]=1, q[1]=2, q[2]=3, q[3]=4
std::cout << q.at(0) << std::endl;

関数詳解

◆ acos()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::acos ( ) const

return arccos このクォータニオンの値，arccosは次のように計算できる．

$\arccos(q) = -\frac{\boldsymbol{v}}{||\boldsymbol{v}||}arccosh(q)$

ここで $\boldsymbol{v} = [x, y, z].$

例えば

Quatd q(1,2,3,4);

q.acos();

◆ acosh()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::acosh ( ) const

return arccosh このクォータニオンの値、arccoshは次のように計算できる。

$arcosh(q) = \ln(q + \sqrt{q^2 - 1})$

.

例えば

Quatd q(1,2,3,4);

q.acosh();

◆ asin()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::asin ( ) const

Return arcsin この四元数の値、arcsin は次のように計算されます。

$\arcsin(q) = -\frac{\boldsymbol{v}}{||\boldsymbol{v}||}arcsinh(q\frac{\boldsymbol{v}}{||\boldsymbol{v}||})$

ここで $\boldsymbol{v} = [x, y, z].$

例えば

Quatd q(1,2,3,4);

q.asin();

◆ asinh()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::asinh ( ) const

Return arcsinh このクォータニオンの値、arcsinh は次のように計算できます。

$arcsinh(q) = \ln(q + \sqrt{q^2 + 1})$

.

例えば

Quatd q(1,2,3,4);

q.asinh();

◆ assertNormal()

template<typename _Tp >

void cv::Quat< _Tp >::assertNormal ( _Tp eps = CV_QUAT_EPS ) const

は、この四元数が単位四元数でない場合にエラーを発生させます。

引数

eps 正規化の許容範囲。

参照: isNormal

◆ at()

template<typename _Tp >

_Tp cv::Quat< _Tp >::at ( size_t index ) const

要素を取得する方法です。

引数

index 範囲[0, 3]での値。

四元演算子 q

q.at(0)はq.w.と等価である。

q.at(1)はq.xと同じである。

q.at(2)はq.yと等価である。

q.at(3)はq.zに相当する。

◆ atan()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::atan ( ) const

このクォータニオンのarctan値を返す。arctanは次のように計算できる。

$\arctan(q) = -\frac{\boldsymbol{v}}{||\boldsymbol{v}||}arctanh(q\frac{\boldsymbol{v}}{||\boldsymbol{v}||})$

ここで $\boldsymbol{v} = [x, y, z].$

例えば

Quatd q(1,2,3,4);

q.atan();

◆ atanh()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::atanh ( ) const

return arctanh このクォータニオンの値、arctanhは次のように計算できます。

$arcsinh(q) = \frac{\ln(q + 1) - \ln(1 - q)}{2}$

.

例えば

Quatd q(1,2,3,4);

q.atanh();

◆ conjugate()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::conjugate ( ) const

この四元数の共役を返します。

$q.conjugate() = (w, -x, -y, -z).$

◆ cos()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::cos ( ) const

return cos この四元数の値、cosは次のように計算できます。

$\cos(p) = \cos(w) * \cosh(||\boldsymbol{v}||) - \sin(w)\frac{\boldsymbol{v}}{||\boldsymbol{v}||}\sinh(||\boldsymbol{v}||)$

ここで $\boldsymbol{v} = [x, y, z].$

例えば

Quatd q(1,2,3,4);

q.cos();

◆ cosh()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::cosh ( ) const

return cosh この四元数の値、coshは次のように計算できます。

$\cosh(p) = \cosh(w) * \cos(||\boldsymbol{v}||) + \sinh(w)\frac{\boldsymbol{v}}{||\boldsymbol{v}||}sin(||\boldsymbol{v}||)$

ここで $\boldsymbol{v} = [x, y, z].$

例えば

Quatd q(1,2,3,4);

q.cosh();

◆ createFromAngleAxis()

template<typename _Tp >

static Quat< _Tp > cv::Quat< _Tp >::createFromAngleAxis	(	const _Tp	angle,
		const Vec< _Tp, 3 > &	axis
	)

static

角度から、axis。この関数では、軸は正規化されます。そして、それは

$q = [\cos\psi, u_x\sin\psi,u_y\sin\psi, u_z\sin\psi].$

ここで $\psi = \frac{\theta}{2}$ , $\theta$ は回転角度です。

◆ createFromEulerAngles()

template<typename _Tp >

static Quat< _Tp > cv::Quat< _Tp >::createFromEulerAngles	(	const Vec< _Tp, 3 > &	angles,
		QuatEnum::EulerAnglesType	eulerAnglesType
	)

static

オイラー角から

オイラー回転の四元数表現を組み合わせることで、オイラー角から四元数を生成することができます。

例えば、X-Y-Zの順に固有の回転を使用する場合。 $\theta_1$ はX軸周りの回転。 $\theta_2$ はY軸周りの回転。 $\theta_3$ はZ軸周りの回転です。最終的なクォータニオンqは次のように計算できます。

${q} = q_{X, \theta_1} q_{Y, \theta_2} q_{Z, \theta_3}$

ここで $q_{X, \theta_1}$ は次のものから作られます。createFromXRot, $q_{Y, \theta_2}$ は次のものから作られます。createFromYRot, $q_{Z, \theta_3}$ は次のものから作られます。createFromZRot.

引数

angles	長さ3のベクトルに含まれるオイラー角
eulerAnglesType	変換されたオイラー角のタイプ

◆ createFromRvec()

template<typename _Tp >

static Quat< _Tp > cv::Quat< _Tp >::createFromRvec ( InputArray rvec )

static

回転ベクトルから $r$ は次のような形をしています。 $\theta \cdot \boldsymbol{u}$ ここで $\theta$ は回転角を， $\boldsymbol{u}$ は正規化された回転軸を表します。

角度と軸は次のように簡単に導き出せます。

$\begin{equation} \begin{split} \psi &= ||r||\\ \boldsymbol{u} &= \frac{r}{\theta} \end{split} \end{equation}$

四元数は次のようにして求められます。

$q = [\cos\psi, \boldsymbol{u}\sin\psi]$

ここで $\psi = \theta / 2$

◆ createFromXRot()

template<typename _Tp >

static Quat< _Tp > cv::Quat< _Tp >::createFromXRot ( const _Tp theta )

static

X軸を中心とした回転から、次のようにして四元数を求めます。 $\theta$ .

$q = \cos(\theta/2)+sin(\theta/2) i +0 j +0 k$

◆ createFromYRot()

template<typename _Tp >

static Quat< _Tp > cv::Quat< _Tp >::createFromYRot ( const _Tp theta )

static

Y軸を中心とした回転による四元数を次のように求めます。 $\theta$ .

$q = \cos(\theta/2)+0 i+ sin(\theta/2) j +0k$

◆ createFromZRot()

template<typename _Tp >

static Quat< _Tp > cv::Quat< _Tp >::createFromZRot ( const _Tp theta )

static

Z軸を中心とした回転による四元数を次の式で得る。 $\theta$ .

$q = \cos(\theta/2)+0 i +0 j +sin(\theta/2) k$

◆ crossProduct()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::crossProduct ( const Quat< _Tp > & q ) const

の間のクロスプロダクトを返します。 $p = (a, b, c, d) = (a, \boldsymbol{u})$ および $q = (w, x, y, z) = (w, \boldsymbol{v})$ .

$p \times q = \frac{pq- qp}{2}.$

$p \times q = \boldsymbol{u} \times \boldsymbol{v}.$

$p \times q = (cz-dy)i + (dx-bz)j + (by-xc)k.$

例えば

Quatd q{1,2,3,4};
Quatd p{5,6,7,8};
p.crossProduct(q)

◆ dot()

template<typename _Tp >

_Tp cv::Quat< _Tp >::dot ( Quat< _Tp > q ) const

四元数とこの四元数の間のドットを返します。 $q$ とこの四元演算子の間のドットを返します。

dot(p, q)はquaternionがどれだけ近いかを示す良い指標です。実際，単位四元数の差を考えてみましょう。 $p^{-1} * q$ を考えると、その実部はdot(p, q)です。同時に、その実部は次のようになります。 $\cos(\beta/2)$ ここで $\beta$ はpとqの間の回転角、つまりdot(p, q)が1に近いほど、両者の間の回転が小さいことを意味します。

$p \cdot q = p.w \cdot q.w + p.x \cdot q.x + p.y \cdot q.y + p.z \cdot q.z$

引数

q	もう一方のクォータニオンである

例えば

Quatd q(1,2,3,4);
Quatd p(5,6,7,8);
p.dot(q);

◆ exp()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::exp ( ) const

の指数値を返します。

$\exp(q) = e^w (\cos||\boldsymbol{v}||+ \frac{v}{||\boldsymbol{v}||}\sin||\boldsymbol{v}||)$

ここで $\boldsymbol{v} = [x, y, z].$

例えば

Quatd q{1,2,3,4};

cout << q.exp() << endl;

◆ getAngle()

template<typename _Tp >

_Tp cv::Quat< _Tp >::getAngle ( QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT ) const

quaternionの角度を取得すると、回転角度を返します。

引数

assumeUnit

QUAT_ASSUME_UNITが指定された場合、このクォータニオンは単位クォータニオンであるとみなされ、この関数はいくつかの計算を節約します。

$\psi = 2 *arccos(\frac{w}{||q||})$

例えば

Quatd q(1,2,3,4);
q.getAngle();


QuatAssumeType
assumeUnit =
QUAT_ASSUME_UNIT;
q.normalize().getAngle(assumeUnit);//same as q.getAngle().

覚え書き: の間の値を常に返します。 $[0, 2\pi]$ .

◆ getAxis()

template<typename _Tp >

Vec< _Tp, 3 > cv::Quat< _Tp >::getAxis ( QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT ) const

クォータニオンの軸を取得すると、長さ3のベクトルが返されます。

引数

assumeUnit QUAT_ASSUME_UNITが指定された場合、このクォータニオンは単位クォータニオンであるとみなされ、この関数はいくつかの計算を節約します。

単位軸 $\boldsymbol{u}$ で定義されます。

$\begin{equation} \begin{split} \boldsymbol{v} &= \boldsymbol{u} ||\boldsymbol{v}||\\ &= \boldsymbol{u}||q||sin(\frac{\theta}{2}) \end{split} \end{equation}$

ここで $v=[x, y ,z]$ および $\theta$ は回転角を表します。

例えば

Quatd q(1,2,3,4);
q.getAxis();


QuatAssumeType
assumeUnit =
QUAT_ASSUME_UNIT;
q.normalize().getAxis(assumeUnit);//same as q.getAxis()

◆ interPoint()

template<typename _Tp >

static Quat< _Tp > cv::Quat< _Tp >::interPoint	(	const Quat< _Tp > &	q0,
		const Quat< _Tp > &	q1,
		const Quat< _Tp > &	q2,
		QuatAssumeType	assumeUnit = `QUAT_ASSUME_NOT_UNIT`
	)

static

これが四元数の計算の一部です。媒介となる四元数の計算は $s_i$ 3つのクォータニオンの間の

$s_i = q_i\exp(-\frac{\log(q^*_iq_{i+1}) + \log(q^*_iq_{i-1})}{4}).$

引数

q0	第1クオータニオン
q1	第2の四元演算子
q2	3つ目のクォータニオン
assumeUnit	QUAT_ASSUME_UNITが指定された場合、すべての入力四元数は単位四元数であるとみなされます。そうでない場合は、すべての入力クォータニオンが関数内で正規化されます。

参照: squad

◆ inv()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::inv ( QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT ) const

リターン $q^{-1}$ の逆数である $q$ を満たします。 $q * q^{-1} = 1$ .

引数

assumeUnit QUAT_ASSUME_UNITの場合、quaternion qは単位quaternionであるとみなされ、この関数はいくつかの計算を節約します。

例えば

Quatd q(1,2,3,4);
q.inv();


QuatAssumeType
assumeUnit =
QUAT_ASSUME_UNIT;
q = q.normalize();
q.inv(assumeUnit);
//assumeUnit means p is a unit quaternion

◆ isNormal()

template<typename _Tp >

bool cv::Quat< _Tp >::isNormal ( _Tp eps = CV_QUAT_EPS ) const

このクォータニオンが単位クォータニオンであれば真を返します。

引数

eps	正規化の許容範囲。epsは次のように定義できます。

$eps = |1 - dotValue|$

ここで

$dotValue = (this.w^2 + this.x^2 + this,y^2 + this.z^2).$

そして，この関数は，dotValueがある範囲を超えたときに正規化されたとみなします。 $[1-eps, 1+eps]$ .

◆ lerp()

template<typename _Tp >

static Quat< _Tp > cv::Quat< _Tp >::lerp	(	const Quat< _Tp > &	q0,
		const Quat< _Tp > &	q1,
		const _Tp	t
	)

static

からの補間を計算するには $q_0$ から $q_1$ by Linear Interpolation(Nlerp) 2つのクォータニオンの場合、この補間曲線は次のように表示されます。

$Lerp(q_0, q_1, t) = (1 - t)q_0 + tq_1.$

を2次元のベクトルと考えれば、明らかにLERPは直線に沿って補間することになります。 $q_0$ および $q_1$ を2次元空間のベクトルと考えれば、明らかにLERPは直線に沿って補間される。このとき $t = 0$ のときは $q_0$ を返し、いつ $t= 1$ のときは $q_1$ . $t$ で範囲指定されるはずです。 $[0, 1]$ 通常は

引数

q0	は，線形補間に使用される四元数です．
q1	は，線形補間に使用される四元数です．
t	ベクトルのパーセンテージ $\overrightarrow{q_0q_1}$ は、範囲 [0, 1] のベクトルのパーセントを返します。

覚え書き: は、単位のない四元数を返します。

◆ log()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::log ( QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT ) const

は、対数関数の値を返します。

$\ln(q) = \ln||q|| + \frac{\boldsymbol{v}}{||\boldsymbol{v}||}\arccos\frac{w}{||q||}$

となります。 $\boldsymbol{v} = [x, y, z].$

引数

assumeUnit QUAT_ASSUME_UNITが指定された場合、このクォータニオンは単位クォータニオンであるとみなされ、この関数はいくつかの計算を節約します。

例えば

Quatd q(1,2,3,4);
q.log();


QuatAssumeType
assumeUnit =
QUAT_ASSUME_UNIT;
Quatd q1(1,2,3,4);
q1.normalize().log(assumeUnit);

◆ nlerp()

template<typename _Tp >

static Quat< _Tp > cv::Quat< _Tp >::nlerp	(	const Quat< _Tp > &	q0,
		const Quat< _Tp > &	q1,
		const _Tp	t,
		QuatAssumeType	assumeUnit = `QUAT_ASSUME_NOT_UNIT`
	)

static

からの補間を計算するには $q_0$ から $q_1$ 正規化線形補間(Nlerp)では，線形補間(Lerp)の正規化された四元数を返します．

$Nlerp(q_0, q_1, t) = \frac{(1 - t)q_0 + tq_1}{||(1 - t)q_0 + tq_1||}.$

この補間は常に最短経路を選択しますが、一定の速度は保証されません。

引数

q0	正規化された線形補間で使用されるクォータニオンです。
q1	正規化された線形補間で使用されるクォータニオンです。
t	ベクトルのパーセンテージ $\overrightarrow{q_0q_1}$ は、範囲 [0, 1] のベクトルのパーセントを返します。
assumeUnit	QUAT_ASSUME_UNITの場合、すべての入力四元数は単位四元数であると仮定します。そうでない場合、すべての入力四元数は、この関数内で正規化されます。

参照: lerp

◆ norm()

template<typename _Tp >

_Tp cv::Quat< _Tp >::norm ( ) const

quaternionのノルムを返します。

$||q|| = \sqrt{w^2 + x^2 + y^2 + z^2}.$

◆ normalize()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::normalize ( ) const

正規化された $p$ .

$p = \frac{q}{||q||}$

ここで $p$ は以下の条件を満たします。 $(p.x)^2 + (p.y)^2 + (p.z)^2 + (p.w)^2 = 1.$

◆ operator*()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::operator* ( const Quat< _Tp > & ) const

2つの四元数qとpの乗算演算子。演算子の両側の値を乗算します。

四元数の乗算のルール。

$\begin{equation} \begin{split} p * q &= [p_0, \boldsymbol{u}]*[q_0, \boldsymbol{v}]\\ &=[p_0q_0 - \boldsymbol{u}\cdot \boldsymbol{v}, p_0\boldsymbol{v} + q_0\boldsymbol{u}+ \boldsymbol{u}\times \boldsymbol{v}]. \end{split} \end{equation}$

ここで $\cdot$ は点積を意味します。 $\times$ はクロスプロダクトを意味します。

例えば

Quatd p{1, 2, 3, 4};
Quatd q{5, 6, 7, 8};
std::cout << p * q << std::endl;
//[-60, 12, 30, 24]

◆ operator*=() [1/2]

template<typename _Tp >

Quat< _Tp > & cv::Quat< _Tp >::operator*= ( const _Tp s )

四元数とスカラーの乗算代入演算子。右のオペランドと左のオペランドを掛け合わせ、その結果を左のオペランドに代入します。

スカラーを使った四元数の乗算のルール。

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

例えば

Quatd p{1, 2, 3, 4};

double
s = 2.0;
p *= s;
// equivalent to p = p * s
std::cout << p << std::endl;
//[2.0, 4.0, 6.0, 8.0]

覚え書き: スカラーの種類は四元数と同じでなければならない。

◆ operator*=() [2/2]

template<typename _Tp >

Quat< _Tp > & cv::Quat< _Tp >::operator*= ( const Quat< _Tp > & )

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

四元数の乗算のルール。

$\begin{equation} \begin{split} p * q &= [p_0, \boldsymbol{u}]*[q_0, \boldsymbol{v}]\\ &=[p_0q_0 - \boldsymbol{u}\cdot \boldsymbol{v}, p_0\boldsymbol{v} + q_0\boldsymbol{u}+ \boldsymbol{u}\times \boldsymbol{v}]. \end{split} \end{equation}$

ここで $\cdot$ は点積を意味します。 $\times$ はクロスプロダクトを意味します。

例えば

Quatd p{1, 2, 3, 4};
Quatd q{5, 6, 7, 8};
p *= q;
// equivalent to p = p * q
std::cout << p << std::endl;
//[-60, 12, 30, 24]

◆ operator+()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::operator+ ( const Quat< _Tp > & ) const

2つの四元数pとqの加算演算子。それぞれの値が以下の合計である新しい四元数を返します。 $p_i$ および $q_i$ .

例えば

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

◆ operator+=()

template<typename _Tp >

Quat< _Tp > & cv::Quat< _Tp >::operator+= ( const Quat< _Tp > & )

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

例えば

Quatd p{1, 2, 3, 4};
Quatd q{5, 6, 7, 8};
p += q;
// equivalent to p = p + q
std::cout << p << std::endl;
//[6, 8, 10, 12]

◆ operator-() [1/2]

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::operator- ( ) const

反対側の四元数を返します。 $-p$ を満足する反対側の二元四元演算子 $p + (-p) = 0.$

例えば

Quatd q{1, 2, 3, 4};

std::cout << -q << std::endl; // [-1, -2, -3, -4]

◆ operator-() [2/2]

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::operator- ( const Quat< _Tp > & ) const

2つの四元数pとqの減算演算子です。それぞれの値が、以下の合計である新しい四元数を返します。 $p_i$ および $-q_i$ .

例えば

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

◆ operator-=()

template<typename _Tp >

Quat< _Tp > & cv::Quat< _Tp >::operator-= ( const Quat< _Tp > & )

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

例えば

Quatd p{1, 2, 3, 4};
Quatd q{5, 6, 7, 8};
p -= q;
// equivalent to p = p - q
std::cout << p << std::endl;
//[-4, -4, -4, -4]

◆ operator/() [1/2]

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::operator/ ( const _Tp s ) const

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

スカラーを用いた四元数の除算のルール。

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

例えば

Quatd p{1, 2, 3, 4};

double
s = 2.0;
p /= s;
// equivalent to p = p / s
std::cout << p << std::endl;
//[0.5, 1, 1.5, 2]

覚え書き: スカラーの種類は、この四元数と同じでなければなりません。

◆ operator/() [2/2]

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::operator/ ( const Quat< _Tp > & ) const

2つの四元数pとqの除算演算子。左手のオペランドを右手のオペランドで除算します。

スカラーを用いた四元数の除算のルール。

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

例えば

Quatd p{1, 2, 3, 4};
Quatd q{5, 6, 7, 8};
std::cout << p / q << std::endl;
// equivalent to p * q.inv()

◆ operator/=() [1/2]

template<typename _Tp >

Quat< _Tp > & cv::Quat< _Tp >::operator/= ( const _Tp s )

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

スカラーを用いた四元数の除算のルール。

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

例えば

Quatd p{1, 2, 3, 4};

double
s = 2.0;;
p /= s;
// equivalent to p = p / s
std::cout << p << std::endl;
//[0.5, 1.0, 1.5, 2.0]

覚え書き: スカラーの種類は四元数と同じでなければならない。

◆ operator/=() [2/2]

template<typename _Tp >

Quat< _Tp > & cv::Quat< _Tp >::operator/= ( const Quat< _Tp > & )

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

四元数を用いた四元数の除算の規則。

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

例えば

Quatd p{1, 2, 3, 4};
Quatd q{5, 6, 7, 8};
p /= q;
// equivalent to p = p * q.inv()
std::cout << p << std::endl;

◆ power() [1/2]

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::power	(	const _Tp	x,
		QuatAssumeType	assumeUnit = `QUAT_ASSUME_NOT_UNIT`
	)		const

累乗関数の値を指数で返します。 $x$ .

$q^x = ||q||(\cos(x\theta) + \boldsymbol{u}\sin(x\theta))).$

引数

x	累乗の指数
assumeUnit	QUAT_ASSUME_UNITが指定された場合、このクォータニオンは単位クォータニオンであるとみなされ、この関数はいくつかの計算を節約します。

例えば

Quatd q(1,2,3,4);
q.power(2.0);


QuatAssumeType
assumeUnit =
QUAT_ASSUME_UNIT;

double
angle = CV_PI;
Vec3d axis{0, 0, 1};
Quatd q1 =
Quatd::createFromAngleAxis(angle, axis);
//generate a unit quat by axis and angle
q1.power(2.0, assumeUnit);
//This assumeUnt means q1 is a unit quaternion

◆ power() [2/2]

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::power	(	const Quat< _Tp > &	q,
		QuatAssumeType	assumeUnit = `QUAT_ASSUME_NOT_UNIT`
	)		const

四元数を用いたべき乗関数の値を返す $q$ .

$p^q = e^{q\ln(p)}.$

引数

q	累乗関数の四元数のインデックス。
assumeUnit	QUAT_ASSUME_UNITが指定された場合、このクォータニオンは単位クォータニオンであるとみなされ、この関数はいくつかの計算を節約します。

例えば

Quatd p(1,2,3,4);
Quatd q(5,6,7,8);
p.power(q);


QuatAssumeType
assumeUnit =
QUAT_ASSUME_UNIT;
p = p.normalize();
p.power(q, assumeUnit);
//This assumeUnit means p is a unit quaternion

◆ sin()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::sin ( ) const

return sin この四元数の値、sinは次のように計算できます。

$\sin(p) = \sin(w) * \cosh(||\boldsymbol{v}||) + \cos(w)\frac{\boldsymbol{v}}{||\boldsymbol{v}||}\sinh(||\boldsymbol{v}||)$

ここで $\boldsymbol{v} = [x, y, z].$

例えば

Quatd q(1,2,3,4);

q.sin();

◆ sinh()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::sinh ( ) const

return sinh このクォータニオンの値、sinhは次のように計算できます。 $\sinh(p) = \sin(w)\cos(||\boldsymbol{v}||) + \cosh(w)\frac{v}{||\boldsymbol{v}||}\sin||\boldsymbol{v}||$ ここで $\boldsymbol{v} = [x, y, z].$

例えば

Quatd q(1,2,3,4);

q.sinh();

◆ slerp()

template<typename _Tp >

static Quat< _Tp > cv::Quat< _Tp >::slerp	(	const Quat< _Tp > &	q0,
		const Quat< _Tp > &	q1,
		const _Tp	t,
		QuatAssumeType	assumeUnit = `QUAT_ASSUME_NOT_UNIT`,
		bool	directChange = `true`
	)

static

の補間を計算するには $q_0$ および $q_1$ との間の補間を球形線形補間（Slerp）で計算しますが、これは次のように定義できます。

$Slerp(q_0, q_1, t) = \frac{\sin((1-t)\theta)}{\sin(\theta)}q_0 + \frac{\sin(t\theta)}{\sin(\theta)}q_1$

ここで $\theta$ は次のように計算できます。

$\theta=cos^{-1}(q_0\cdot q_1)$

両者のノルムが単位であることから、次のように計算できます。

引数

q0	は、Slerpで使用される四元数です。
q1	は、Slerpで使用される四元数です。
t	の間の角度の割合およびは、範囲 [0, 1] のベクトルのパーセントを返します。
assumeUnit	QUAT_ASSUME_UNITが指定された場合、入力されたすべての四元数は単位四元数であるとみなされます。そうでない場合、すべての入力クォータニオンは関数内で正規化されます。
directChange	QUAT_ASSUME_UNITの場合，補間は最も近い経路を選択します．

覚え書き: 補間角度が小さければ、NlerpとSlerpの間の誤差はそれほど大きくありません。効率を上げ、ゼロ除算エラーを避けるために、Slerpの代わりにNlerpを使用します。

◆ spline()

template<typename _Tp >

static Quat< _Tp > cv::Quat< _Tp >::spline	(	const Quat< _Tp > &	q0,
		const Quat< _Tp > &	q1,
		const Quat< _Tp > &	q2,
		const Quat< _Tp > &	q3,
		const _Tp	t,
		QuatAssumeType	assumeUnit = `QUAT_ASSUME_NOT_UNIT`
	)

static

の結果であるクォータニオンを計算する。 $C^1$ ここでは補間値として，比率tでスクワッドによって構成された連続スプライン曲線 $q_1$ および $q_2$ . $q_0$ および $q_2$ が使用され、連続性が確保されます。 $C^1$ t = 0の場合は $q_1$ を返し、t = 1の場合は $q_2$ .

引数

q0	を返し、連続性を確保します。連続性を確保します。
q1	2番目の入力四元数。
q2	3番目の入力四元数。
q3	4番目の入力四元数。.
t	比率を範囲[0, 1]で指定します。
assumeUnit	if QUAT_ASSUME_UNIT,単位四元数であると仮定します。それ以外の場合は、すべての入力四元数が関数内で正規化されます。

例えば、以下のようになります。

補間されるべき3つのダブルクォータニオンがある場合 $v_0, v_1, v_2$ がある場合は、補間されるのを待ちます。

の間を補間します。 $v_0$ および $v_1$ との間の補間は，比率 $t_0$ は次のように計算できます。

Quatd::spline(v0, v0, v1, v2, t0);

の間を補間します。 $v_1$ および $v_2$ との間の補間は，比率 $t_0$ は次のように計算できます。

Quatd::spline(v0, v1, v2, v2, t0);

参照: squad,slerp

◆ sqrt()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::sqrt ( QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT ) const

リターン $\sqrt{q}$ .

引数

assumeUnit QUAT_ASSUME_UNITが指定された場合、このクォータニオンは単位クォータニオンであるとみなされ、この関数はいくつかの計算を節約します。

例えば

Quatf q(1,2,3,4);
q.sqrt();


QuatAssumeType
assumeUnit =
QUAT_ASSUME_UNIT;
q = {1,0,0,0};
q.sqrt(assumeUnit);
//This assumeUnit means q is a unit quaternion

◆ squad()

template<typename _Tp >

static Quat< _Tp > cv::Quat< _Tp >::squad	(	const Quat< _Tp > &	q0,
		const Quat< _Tp > &	s0,
		const Quat< _Tp > &	s1,
		const Quat< _Tp > &	q1,
		const _Tp	t,
		QuatAssumeType	assumeUnit = `QUAT_ASSUME_NOT_UNIT`,
		bool	directChange = `true`
	)

static

の補間を計算するには $q_0$ , $q_1$ , $q_2$ , $q_3$ 球形と四角形(Squadrangle)によるもの。と定義することができる。

$Squad(q_i, s_i, s_{i+1}, q_{i+1}, t) = Slerp(Slerp(q_i, q_{i+1}, t), Slerp(s_i, s_{i+1}, t), 2t(1-t))$

ここで

$s_i = q_i\exp(-\frac{\log(q^*_iq_{i+1}) + \log(q^*_iq_{i-1})}{4})$

Squadの表現は $B\acute{e}zier$ 曲線に似ていますが、単純な線形補間ではなく、球形の線形補間を行います。それぞれの $s_i$ は3つの四元数で計算する必要があります。

引数

q0	第1クオータニオン
s0	第2の四元演算子
s1	3つ目のクォータニオン
q1	thr 4つ目のクォータニオン。
t	範囲内での二次補間および線形補間の補間パラメータ.
assumeUnit	QUAT_ASSUME_UNITが指定された場合、すべての入力四元数は単位四元数であるとみなされます。そうでない場合は、すべての入力クォータニオンが関数内で正規化されます。
directChange	QUAT_ASSUME_UNITの場合、squadは最も近い経路を探して補間を行います。

参照: interPoint,spline

◆ tan()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::tan ( ) const

return tan このクォータニオンの値、tanは次のように計算できます。

$\tan(q) = \frac{\sin(q)}{\cos(q)}.$

例えば

Quatd q(1,2,3,4);

q.tan();

◆ tanh()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::tanh ( ) const

return tanh このクォータニオンの値、tanhは次のように計算できます。

$\tanh(q) = \frac{\sinh(q)}{\cosh(q)}.$

例えば

Quatd q(1,2,3,4);

q.tanh();

参照: sinh,cosh

◆ toEulerAngles()

template<typename _Tp >

Vec< _Tp, 3 > cv::Quat< _Tp >::toEulerAngles ( QuatEnum::EulerAnglesType eulerAnglesType )

四元演算子qをオイラー角に変換します。

四元演算子qをオイラー角に変換する場合 $q = w + x\boldsymbol{i} + y\boldsymbol{j} + z\boldsymbol{k}$ をオイラー角に変換する場合、回転行列Mは次のように計算できます。

$\begin{aligned} {M} &={\begin{bmatrix}1-2(y^{2}+z^{2})&2(xy-zx)&2(xz+yw)\\2(xy+zw)&1-2(x^{2}+z^{2})&2(yz-xw)\\2(xz-yw)&2(yz+xw)&1-2(x^{2}+y^{2})\end{bmatrix}}\end{aligned}.$

一方、回転行列はオイラー角から求めることができます。オイラー角型のXYZを例にして、固有の回転を用います。 $\theta_1$ , $\theta_2$ , $\theta_3$ はオイラー角の3つの角度で、回転行列Rは次のように計算できます。

$R =X(\theta_1)Y(\theta_2)Z(\theta_3) ={\begin{bmatrix}\cos\theta_{2}\cos\theta_{3}&-\cos\theta_{2}\sin\theta_{3}&\sin\theta_{2}\\\cos\theta_{1}\sin\theta_{3}+\cos\theta_{3}\sin\theta_{1}\sin\theta_{2}&\cos\theta_{1}\cos\theta_{3}-\sin\theta_{1}\sin\theta_{2}\sin\theta_{3}&-\cos\theta_{2}\sin\theta_{1}\\\sin\theta_{1}\sin\theta_{3}-\cos\theta_{1}\cos\theta_{3}\sin\theta_{2}&\cos\theta_{3}\sin\theta_{1}+\cos\theta_{1}\sin\theta_{2}\sin\theta_{3}&\cos\theta_{1}\cos_{2}\end{bmatrix}}$

回転行列MとRは等しい。以上のように $s_{2} \neq 1$ である限り、2つの行列の各要素を比較すれば、次のように解けます。 $\begin{cases} \theta_1 = \arctan2(-m_{23},m_{33})\\\theta_2 = arcsin(m_{13}) \\\theta_3 = \arctan2(-m_{12},m_{11}) \end{cases}$ .

となります。 $s_{2}=1$ または $s_{2}=-1$ となると、ジンバルロックが発生します。WARNING: Gimbal Lock will occur." と表示されます。オイラー角は一意ではありません。内旋の場合は3つ目の角度を0に、外旋の場合は1つ目の角度を0にします」と表示されます。

となります。 $s_{2}=1$ , 回転行列Rは $R = {\begin{bmatrix}0&0&1\\\sin(\theta_1+\theta_3)&\cos(\theta_1+\theta_3)&0\\-\cos(\theta_1+\theta_3)&\sin(\theta_1+\theta_3)&0\end{bmatrix}}$ .

という条件で、解の数は無限大になります。 $\begin{cases} \theta_1+\theta_3 = \arctan2(m_{21},m_{22})\\ \theta_2=\pi/2 \end{cases}\$ .

と設定します。 $\theta_3 = 0$ とすると、解は $\begin{cases} \theta_1=\arctan2(m_{21},m_{22})\\ \theta_2=\pi/2\\ \theta_3=0 \end{cases}$ .

となります。 $s_{2}=-1$ , 回転行列Rは $X_{1}Y_{2}Z_{3}={\begin{bmatrix}0&0&-1\\-\sin(\theta_1-\theta_3)&\cos(\theta_1-\theta_3)&0\\\cos(\theta_1-\theta_3)&\sin(\theta_1-\theta_3)&0\end{bmatrix}}$ .

という条件で、解の数は無限大になります。 $\begin{cases} \theta_1+\theta_3 = \arctan2(m_{32},m_{22})\\ \theta_2=\pi/2 \end{cases}\$ .

と設定します。 $\theta_3 = 0$ とすると、解は $\begin{cases}\theta_1=\arctan2(m_{32},m_{22}) \\ \theta_2=-\pi/2\\ \theta_3=0\end{cases}$ .

となります。 $sin \theta\in [-1,1]$ および $cos \theta \in [-1,1]$ であるため，正規化されていない四元数は計算上の問題を引き起こします。そのため，この関数では，最初に四元数を正規化してしまいQuatAssumeTypeは必要ありません。

ジンバルロックが発生したときには $\theta_3 = 0$ 内側の回転には $\theta_1 = 0$ を設定します。

その結果、オイラー角の種類ごとに、以下の表のような解が得られます。

オイラー角タイプ	通常	$\theta_2 = π/2$	$\theta_2 = -π/2$
INT_XYZ	$\theta_1 = \arctan2(-m_{23},m_{33})\\\theta_2 = \arcsin(m_{13}) \\\theta_3= \arctan2(-m_{12},m_{11})$	$\theta_1=\arctan2(m_{21},m_{22})\\ \theta_2=\pi/2\\ \theta_3=0$	$\theta_1=\arctan2(m_{32},m_{22})\\ \theta_2=-\pi/2\\ \theta_3=0$
INT_XZY	$\theta_1 = \arctan2(m_{32},m_{22})\\\theta_2 = -\arcsin(m_{12}) \\\theta_3= \arctan2(m_{13},m_{11})$	$\theta_1=\arctan2(m_{31},m_{33})\\ \theta_2=\pi/2\\ \theta_3=0$	$\theta_1=\arctan2(-m_{23},m_{33})\\ \theta_2=-\pi/2\\ \theta_3=0$
INT_YXZ	$\theta_1 = \arctan2(m_{13},m_{33})\\\theta_2 = -\arcsin(m_{23}) \\\theta_3= \arctan2(m_{21},m_{22})$	$\theta_1=\arctan2(m_{12},m_{11})\\ \theta_2=\pi/2\\ \theta_3=0$	$\theta_1=\arctan2(-m_{12},m_{11})\\ \theta_2=-\pi/2\\ \theta_3=0$
INT_YZX	$\theta_1 = \arctan2(-m_{31},m_{11})\\\theta_2 = \arcsin(m_{21}) \\\theta_3= \arctan2(-m_{23},m_{22})$	$\theta_1=\arctan2(m_{13},m_{33})\\ \theta_2=\pi/2\\ \theta_3=0$	$\theta_1=\arctan2(m_{13},m_{12})\\ \theta_2=-\pi/2\\ \theta_3=0$
INT_ZXY	$\theta_1 = \arctan2(-m_{12},m_{22})\\\theta_2 = \arcsin(m_{32}) \\\theta_3= \arctan2(-m_{31},m_{33})$	$\theta_1=\arctan2(m_{21},m_{11})\\ \theta_2=\pi/2\\ \theta_3=0$	$\theta_1=\arctan2(m_{21},m_{11})\\ \theta_2=-\pi/2\\ \theta_3=0$
INT_ZYX	$\theta_1 = \arctan2(m_{21},m_{11})\\\theta_2 = \arcsin(-m_{31}) \\\theta_3= \arctan2(m_{32},m_{33})$	$\theta_1=\arctan2(m_{23},m_{22})\\ \theta_2=\pi/2\\ \theta_3=0$	$\theta_1=\arctan2(-m_{12},m_{22})\\ \theta_2=-\pi/2\\ \theta_3=0$
EXT_XYZ	$\theta_1 = \arctan2(m_{32},m_{33})\\\theta_2 = \arcsin(-m_{31}) \\\ \theta_3 = \arctan2(m_{21},m_{11})$	$\theta_1= 0\\ \theta_2=\pi/2\\ \theta_3=\arctan2(m_{23},m_{22})$	$\theta_1=0\\ \theta_2=-\pi/2\\ \theta_3=\arctan2(-m_{12},m_{22})$
EXT_XZY	$\theta_1 = \arctan2(-m_{23},m_{22})\\\theta_2 = \arcsin(m_{21}) \\\theta_3= \arctan2(-m_{31},m_{11})$	$\theta_1= 0\\ \theta_2=\pi/2\\ \theta_3=\arctan2(m_{13},m_{33})$	$\theta_1=0\\ \theta_2=-\pi/2\\ \theta_3=\arctan2(m_{13},m_{12})$
EXT_YXZ	$\theta_1 = \arctan2(-m_{31},m_{33}) \\\theta_2 = \arcsin(m_{32}) \\\theta_3= \arctan2(-m_{12},m_{22})$	$\theta_1= 0\\ \theta_2=\pi/2\\ \theta_3=\arctan2(m_{21},m_{11})$	$\theta_1=0\\ \theta_2=-\pi/2\\ \theta_3=\arctan2(m_{21},m_{11})$
EXT_YZX	$\theta_1 = \arctan2(m_{13},m_{11})\\\theta_2 = -\arcsin(m_{12}) \\\theta_3= \arctan2(m_{32},m_{22})$	$\theta_1= 0\\ \theta_2=\pi/2\\ \theta_3=\arctan2(m_{31},m_{33})$	$\theta_1=0\\ \theta_2=-\pi/2\\ \theta_3=\arctan2(-m_{23},m_{33})$
EXT_ZXY	$\theta_1 = \arctan2(m_{21},m_{22})\\\theta_2 = -\arcsin(m_{23}) \\\theta_3= \arctan2(m_{13},m_{33})$	$\theta_1= 0\\ \theta_2=\pi/2\\ \theta_3=\arctan2(m_{12},m_{11})$	$\theta_1= 0\\ \theta_2=-\pi/2\\ \theta_3=\arctan2(-m_{12},m_{11})$
EXT_ZYX	$\theta_1 = \arctan2(-m_{12},m_{11})\\\theta_2 = \arcsin(m_{13}) \\\theta_3= \arctan2(-m_{23},m_{33})$	$\theta_1=0\\ \theta_2=\pi/2\\ \theta_3=\arctan2(m_{21},m_{22})$	$\theta_1=0\\ \theta_2=-\pi/2\\ \theta_3=\arctan2(m_{32},m_{22})$

オイラー角タイプ	通常	$\theta_2 = 0$	$\theta_2 = π$
INT_XYX	$\theta_1 = \arctan2(m_{21},-m_{31})\\\theta_2 =\arccos(m_{11}) \\\theta_3 = \arctan2(m_{12},m_{13})$	$\theta_1=\arctan2(m_{32},m_{33})\\ \theta_2=0\\ \theta_3=0$	$\theta_1=\arctan2(m_{23},m_{22})\\ \theta_2=\pi\\ \theta_3=0$
INT_XZX	$\theta_1 = \arctan2(m_{31},m_{21})\\\theta_2 = \arccos(m_{11}) \\\theta_3 = \arctan2(m_{13},-m_{12})$	$\theta_1=\arctan2(m_{32},m_{33})\\ \theta_2=0\\ \theta_3=0$	$\theta_1=\arctan2(-m_{32},m_{33})\\ \theta_2=\pi\\ \theta_3=0$
INT_YXY	$\theta_1 = \arctan2(m_{12},m_{32})\\\theta_2 = \arccos(m_{22}) \\\theta_3 = \arctan2(m_{21},-m_{23})$	$\theta_1=\arctan2(m_{13},m_{11})\\ \theta_2=0\\ \theta_3=0$	$\theta_1=\arctan2(-m_{31},m_{11})\\ \theta_2=\pi\\ \theta_3=0$
INT_YZY	$\theta_1 = \arctan2(m_{32},-m_{12})\\\theta_2 = \arccos(m_{22}) \\\theta_3 =\arctan2(m_{23},m_{21})$	$\theta_1=\arctan2(m_{13},m_{11})\\ \theta_2=0\\ \theta_3=0$	$\theta_1=\arctan2(m_{13},-m_{11})\\ \theta_2=\pi\\ \theta_3=0$
INT_ZXZ	$\theta_1 = \arctan2(-m_{13},m_{23})\\\theta_2 = \arccos(m_{33}) \\\theta_3 =\arctan2(m_{31},m_{32})$	$\theta_1=\arctan2(m_{21},m_{22})\\ \theta_2=0\\ \theta_3=0$	$\theta_1=\arctan2(m_{21},m_{11})\\ \theta_2=\pi\\ \theta_3=0$
INT_ZYZ	$\theta_1 = \arctan2(m_{23},m_{13})\\\theta_2 = \arccos(m_{33}) \\\theta_3 = \arctan2(m_{32},-m_{31})$	$\theta_1=\arctan2(m_{21},m_{11})\\ \theta_2=0\\ \theta_3=0$	$\theta_1=\arctan2(m_{21},m_{11})\\ \theta_2=\pi\\ \theta_3=0$
EXT_XYX	$\theta_1 = \arctan2(m_{12},m_{13}) \\\theta_2 = \arccos(m_{11}) \\\theta_3 = \arctan2(m_{21},-m_{31})$	$\theta_1=0\\ \theta_2=0\\ \theta_3=\arctan2(m_{32},m_{33})$	$\theta_1= 0\\ \theta_2=\pi\\ \theta_3= \arctan2(m_{23},m_{22})$
EXT_XZX	$\theta_1 = \arctan2(m_{13},-m_{12})\\\theta_2 = \arccos(m_{11}) \\\theta_3 = \arctan2(m_{31},m_{21})$	$\theta_1= 0\\ \theta_2=0\\ \theta_3=\arctan2(m_{32},m_{33})$	$\theta_1= 0\\ \theta_2=\pi\\ \theta_3=\arctan2(-m_{32},m_{33})$
EXT_YXY	$\theta_1 = \arctan2(m_{21},-m_{23})\\\theta_2 = \arccos(m_{22}) \\\theta_3 = \arctan2(m_{12},m_{32})$	$\theta_1= 0\\ \theta_2=0\\ \theta_3=\arctan2(m_{13},m_{11})$	$\theta_1= 0\\ \theta_2=\pi\\ \theta_3=\arctan2(-m_{31},m_{11})$
EXT_YZY	$\theta_1 = \arctan2(m_{23},m_{21}) \\\theta_2 = \arccos(m_{22}) \\\theta_3 = \arctan2(m_{32},-m_{12})$	$\theta_1= 0\\ \theta_2=0\\ \theta_3=\arctan2(m_{13},m_{11})$	$\theta_1=0\\ \theta_2=\pi\\ \theta_3=\arctan2(m_{13},-m_{11})$
EXT_ZXZ	$\theta_1 = \arctan2(m_{31},m_{32}) \\\theta_2 = \arccos(m_{33}) \\\theta_3 = \arctan2(-m_{13},m_{23})$	$\theta_1=0\\ \theta_2=0\\ \theta_3=\arctan2(m_{21},m_{22})$	$\theta_1= 0\\ \theta_2=\pi\\ \theta_3=\arctan2(m_{21},m_{11})$
EXT_ZYZ	$\theta_1 = \arctan2(m_{32},-m_{31})\\\theta_2 = \arccos(m_{33}) \\\theta_3 = \arctan2(m_{23},m_{13})$	$\theta_1=0\\ \theta_2=0\\ \theta_3=\arctan2(m_{21},m_{11})$	$\theta_1= 0\\ \theta_2=\pi\\ \theta_3=\arctan2(m_{21},m_{11})$

引数

eulerAnglesType 変換されたオイラー角のタイプ

◆ toRotMat3x3()

template<typename _Tp >

Matx< _Tp, 3, 3 > cv::Quat< _Tp >::toRotMat3x3 ( QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT ) const

四元演算子を 3x3 回転行列に変換します。

引数

assumeUnit QUAT_ASSUME_UNIT が指定された場合、このクォータニオンは単位クォータニオンであるとみなされ、この関数はいくつかの計算を行います。そうでない場合，この関数はまずこの四元数を正規化してから変換を行います．

覚え書き: 回転させたい行列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 \end{bmatrix}$
ここで、同じ添え字は点を表します。A の形状は [3, n] と仮定しています。toRotMat3x3()* 結果は3行n列となります。

例えば

double
angle = CV_PI;
Vec3d axis{0,0,1};
Quatd q_unit =
Quatd::createFromAngleAxis(angle, axis);
//quaternion could also be get by interpolation by two or more quaternions.


//assume there is two points (1,0,0) and (1,0,1) to be rotated
Mat pointsA = (Mat_<double>(2, 3) << 1,0,0,1,0,1);

//change the shape
pointsA = pointsA.t();

// rotate 180 degrees around the z axis
Mat new_point = q_unit.toRotMat3x3() * pointsA;

// print two points
cout << new_point << endl;

◆ toRotMat4x4()

template<typename _Tp >

Matx< _Tp, 4, 4 > cv::Quat< _Tp >::toRotMat4x4 ( QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT ) const

は、四元数を4x4の回転行列に変換します。

引数

assumeUnit QUAT_ASSUME_UNIT が指定された場合、このクォータニオンは単位クォータニオンであるとみなされ、この関数はいくつかの計算を行います。そうでない場合，この関数はまずこの四元数を正規化してから変換を行います．

この操作は RotMat3x3 と同様ですが，点群が次のような形式であることが必要です

$\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\\ 0&0&0&...&0 \end{bmatrix}$

参照: toRotMat3x3

◆ toRotVec()

template<typename _Tp >

Vec< _Tp, 3 > cv::Quat< _Tp >::toRotVec ( QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT ) const

この四元演算子を回転ベクトルに変換します。

引数

assumeUnit

QUAT_ASSUME_UNIT の場合，このクォータニオンは単位クォータニオンであるとみなされ，この関数はいくつかの計算を節約します．回転ベクトルrVecは次のように定義されます。

$rVec = [\theta v_x, \theta v_y, \theta v_z]$

ここで $\theta$ は回転角度を表し $\boldsymbol{v}$ は正規化された回転軸を表します。

例えば

Quatd q(1,2,3,4);
q.toRotVec();


QuatAssumeType
assumeUnit =
QUAT_ASSUME_UNIT;
q.normalize().toRotVec(assumeUnit);
//answer is same as q.toRotVec().

◆ toVec()

template<typename _Tp >

Vec< _Tp, 4 > cv::Quat< _Tp >::toVec ( ) const

このquaternionをVec<T, 4>に変換します。

例えば

Quatd q(1,2,3,4);

q.toVec();

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

◆ acos

template<typename _Tp >

template<typename T >

Quat< T > acos ( const Quat< T > & q )

friend

quaternion qのarccos値を返します。arccosは次のように計算できます。

$\arccos(q) = -\frac{\boldsymbol{v}}{||\boldsymbol{v}||}arccosh(q)$

ここで $\boldsymbol{v} = [x, y, z].$

引数

q 四元演算子。

例えば

Quatd q(1,2,3,4);

acos(q);

cv::Quat::acos

Quat< _Tp > acos() const

return arccos value of this quaternion, arccos could be calculated as:

◆ acosh

template<typename _Tp >

template<typename T >

Quat< T > acosh ( const Quat< T > & q )

friend

quaternion qのarccosh値を返す。arccoshは次のように計算できる。

$arccosh(q) = \ln(q + \sqrt{q^2 - 1})$

.

引数

q 四元演算子。

例えば

Quatd q(1,2,3,4);

acosh(q);

cv::Quat::acosh

Quat< _Tp > acosh() const

return arccosh value of this quaternion, arccosh could be calculated as:

◆ asin

template<typename _Tp >

template<typename T >

Quat< T > asin ( const Quat< T > & q )

friend

quaternion qのarcsin値を返し、arcsinは次のように計算できます。

$\arcsin(q) = -\frac{\boldsymbol{v}}{||\boldsymbol{v}||}arcsinh(q\frac{\boldsymbol{v}}{||\boldsymbol{v}||})$

ここで $\boldsymbol{v} = [x, y, z].$

引数

q 四元演算子。

例えば

Quatd q(1,2,3,4);

asin(q);

cv::Quat::asin

Quat< _Tp > asin() const

return arcsin value of this quaternion, arcsin could be calculated as:

◆ asinh

template<typename _Tp >

template<typename T >

Quat< T > asinh ( const Quat< T > & q )

friend

quaternion qのarcsinhの値を返してください。

$arcsinh(q) = \ln(q + \sqrt{q^2 + 1})$

.

引数

q 四元演算子。

例えば

Quatd q(1,2,3,4);

asinh(q);

cv::Quat::asinh

Quat< _Tp > asinh() const

return arcsinh value of this quaternion, arcsinh could be calculated as:

◆ atan

template<typename _Tp >

template<typename T >

Quat< T > atan ( const Quat< T > & q )

friend

return arctan 四元数 q の値, arctan は次のように計算できます。

$\arctan(q) = -\frac{\boldsymbol{v}}{||\boldsymbol{v}||}arctanh(q\frac{\boldsymbol{v}}{||\boldsymbol{v}||})$

ここで $\boldsymbol{v} = [x, y, z].$

引数

q 四元演算子。

例えば

Quatd q(1,2,3,4);

atan(q);

cv::Quat::atan

Quat< _Tp > atan() const

return arctan value of this quaternion, arctan could be calculated as:

◆ atanh

template<typename _Tp >

template<typename T >

Quat< T > atanh ( const Quat< T > & q )

friend

quaternion qのarctanh値を返し、arctanhは次のように計算できます。

$arctanh(q) = \frac{\ln(q + 1) - \ln(1 - q)}{2}$

.

引数

q 四元演算子。

例えば

Quatd q(1,2,3,4);

atanh(q);

cv::Quat::atanh

Quat< _Tp > atanh() const

return arctanh value of this quaternion, arctanh could be calculated as:

◆ cos

template<typename _Tp >

template<typename T >

Quat< T > cos ( const Quat< T > & q )

friend

return sin 四元数 q の値, cos 次のように計算できます。

$\cos(p) = \cos(w) * \cosh(||\boldsymbol{v}||) - \sin(w)\frac{\boldsymbol{v}}{||\boldsymbol{v}||}\sinh(||\boldsymbol{v}||)$

ここで $\boldsymbol{v} = [x, y, z].$

引数

q 四元演算子。

例えば

Quatd q(1,2,3,4);

cos(q);

cv::Quat::cos

Quat< _Tp > cos() const

return cos value of this quaternion, cos could be calculated as:

◆ cosh

template<typename _Tp >

template<typename T >

Quat< T > cosh ( const Quat< T > & q )

friend

return cosh 四元演算子qの値、coshは次のように計算できます。

$\cosh(p) = \cosh(w) * \cos(||\boldsymbol{v}||) + \sinh(w)\frac{\boldsymbol{v}}{||\boldsymbol{v}||}\sin(||\boldsymbol{v}||)$

ここで $\boldsymbol{v} = [x, y, z].$

引数

q 四元演算子。

例えば

Quatd q(1,2,3,4);

cosh(q);

cv::Quat::cosh

Quat< _Tp > cosh() const

return cosh value of this quaternion, cosh could be calculated as:

◆ crossProduct

template<typename _Tp >

template<typename T >

Quat< T > crossProduct	(	const Quat< T > &	p,
		const Quat< T > &	q
	)

friend

の間のクロスプロダクトを返します。 $p = (a, b, c, d) = (a, \boldsymbol{u})$ および $q = (w, x, y, z) = (w, \boldsymbol{v})$ .

$p \times q = \frac{pq- qp}{2}$

$p \times q = \boldsymbol{u} \times \boldsymbol{v}$

$p \times q = (cz-dy)i + (dx-bz)j + (by-xc)k$

例えば

Quatd q{1,2,3,4};
Quatd p{5,6,7,8};

crossProduct(p, q);

◆ cv::operator* [1/2]

template<typename _Tp >

template<typename T >

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

friend

四元数とスカラーの乗算演算子です。右のオペランドと左のオペランドを掛け合わせ、その結果を左のオペランドに代入します。

スカラーを使った四元数の乗算のルール。

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

例えば

Quatd p{1, 2, 3, 4};

double
s = 2.0;
std::cout << p * s << std::endl;
//[2.0, 4.0, 6.0, 8.0]

覚え書き: スカラーの種類は四元数と同じでなければならない。

◆ cv::operator* [2/2]

template<typename _Tp >

template<typename T >

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

friend

スカラーとクォータニオンの乗算演算子。スカラーと四元数の乗算演算子で、右のオペランドと左のオペランドを掛け合わせ、その結果を左のオペランドに代入します。

スカラーを使った四元数の乗算のルール。

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

例えば

Quatd p{1, 2, 3, 4};

double
s = 2.0;
std::cout << s * p << std::endl;
//[2.0, 4.0, 6.0, 8.0]

覚え書き: スカラーの種類は四元数と同じでなければならない。

◆ cv::operator+ [1/2]

template<typename _Tp >

template<typename T >

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

friend

四元数とスカラの加算演算子です。左手のオペランドから右手のオペランドを加算します。

例えば

Quatd p{1, 2, 3, 4};

double
scalar = 2.0;
std::cout << p + scalar << std::endl;
//[3.0, 2, 3, 4]

覚え書き: スカラーの種類は四元数と同じでなければならない。

◆ cv::operator+ [2/2]

template<typename _Tp >

template<typename T >

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

friend

四元数とスカラの加算演算子です。左手のオペランドから右手のオペランドを加算します。

例えば

Quatd p{1, 2, 3, 4};

double
scalar = 2.0;
std::cout << scalar + p << std::endl;
//[3.0, 2, 3, 4]

覚え書き: スカラーの種類は四元数と同じでなければならない。

◆ cv::operator- [1/2]

template<typename _Tp >

template<typename T >

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

friend

四元数とスカラの減算演算子です。右手のオペランドを左手のオペランドから引きます。

例えば

Quatd p{1, 2, 3, 4};

double
scalar = 2.0;
std::cout << p - scalar << std::endl;
//[-1.0, 2, 3, 4]

覚え書き: スカラーの種類は四元数と同じでなければならない。

◆ cv::operator- [2/2]

template<typename _Tp >

template<typename T >

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

friend

スカラーと四元数の減算演算子です。左手のオペランドから右手のオペランドを減算します。

例えば

Quatd p{1, 2, 3, 4};

double
scalar = 2.0;
std::cout << scalar - p << std::endl;
//[1.0, -2, -3, -4]

覚え書き: スカラーの種類は四元数と同じでなければならない。

◆ exp

template<typename _Tp >

template<typename T >

Quat< T > exp ( const Quat< T > & q )

friend

の指数値を返します。

$\exp(q) = e^w (\cos||\boldsymbol{v}||+ \frac{v}{||\boldsymbol{v}||})\sin||\boldsymbol{v}||$

ここで $\boldsymbol{v} = [x, y, z].$

引数

q 四元演算子。

例えば、以下のようになります。

Quatd q{1,2,3,4};

cout << exp(q) << endl;

cv::Quat::exp

Quat< _Tp > exp() const

return the value of exponential value.

◆ inv

template<typename _Tp >

template<typename T >

Quat< T > inv	(	const Quat< T > &	q,
		QuatAssumeType	assumeUnit
	)

friend

リターン $q^{-1}$ の逆数である $q$ を満足する反対側の二元四元演算子 $q * q^{-1} = 1$ .

引数

q	四元演算子。
assumeUnit	QUAT_ASSUME_UNITの場合、quaternion qは単位quaternionであるとみなされ、この関数はいくつかの計算を節約します。

例えば

Quatd q(1,2,3,4);

inv(q);


QuatAssumeType
assumeUnit =
QUAT_ASSUME_UNIT;
q = q.normalize();

inv(q, assumeUnit);//This assumeUnit means p is a unit quaternion

◆ log

template<typename _Tp >

template<typename T >

Quat< T > log	(	const Quat< T > &	q,
		QuatAssumeType	assumeUnit
	)

friend

は、対数関数の値を返します。

$\ln(q) = \ln||q|| + \frac{\boldsymbol{v}}{||\boldsymbol{v}||}\arccos\frac{w}{||q||}.$

ここで $\boldsymbol{v} = [x, y, z].$

引数

q	四元演算子。
assumeUnit	QUAT_ASSUME_UNITが指定された場合、qは単位四元数であるとみなされ、この関数はいくつかの計算を行います。

例えば

Quatd q1{1,2,3,4};

cout << log(q1) << endl;

cv::Quat::log

friend Quat< T > log(const Quat< T > &q, QuatAssumeType assumeUnit)

return the value of logarithm function.

◆ power [1/2]

template<typename _Tp >

template<typename T >

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

friend

四元数を用いたべき乗関数の値を返す $q$ .

$p^q = e^{q\ln(p)}.$

引数

p	べき乗関数の基底四元数です。
q	累乗関数の四元数のインデックス。
assumeUnit	QUAT_ASSUME_UNITの場合、quaternionは単位四元数であるとみなし、この関数はいくつかの計算を節約します。

例えば

Quatd p(1,2,3,4);
Quatd q(5,6,7,8);

power(p, q);


QuatAssumeType
assumeUnit =
QUAT_ASSUME_UNIT;
p = p.normalize();

power(p, q, assumeUnit);
//This assumeUnit means p is a unit quaternion

◆ power [2/2]

template<typename _Tp >

template<typename T >

Quat< T > power	(	const Quat< T > &	q,
		const T	x,
		QuatAssumeType	assumeUnit
	)

friend

累乗関数の値を指数で返します。 $x$ .

$q^x = ||q||(cos(x\theta) + \boldsymbol{u}sin(x\theta))).$

引数

q	四元演算子。
x	累乗の指数
assumeUnit	QUAT_ASSUME_UNITの場合、quaternion qは単位quaternionであるとみなされ、この関数はいくつかの計算を節約します。

例えば

Quatd q(1,2,3,4);

power(q, 2.0);


QuatAssumeType
assumeUnit =
QUAT_ASSUME_UNIT;

double
angle = CV_PI;
Vec3d axis{0, 0, 1};
Quatd q1 =
Quatd::createFromAngleAxis(angle, axis);
//generate a unit quat by axis and angle

power(q1, 2.0, assumeUnit);//This assumeUnit means q1 is a unit quaternion.

覚え書き: インデックスの型は、四元数と同じでなければなりません。

◆ sin

template<typename _Tp >

template<typename T >

Quat< T > sin ( const Quat< T > & q )

friend

quaternion qのtanh値を返します。sinは次のように計算できます。

$\sin(p) = \sin(w) * \cosh(||\boldsymbol{v}||) + \cos(w)\frac{\boldsymbol{v}}{||\boldsymbol{v}||}\sinh(||\boldsymbol{v}||)$

ここで $\boldsymbol{v} = [x, y, z].$

引数

q 四元演算子。

例えば

Quatd q(1,2,3,4);

sin(q);

cv::Quat::sin

Quat< _Tp > sin() const

return sin value of this quaternion, sin could be calculated as:

◆ sinh

template<typename _Tp >

template<typename T >

Quat< T > sinh ( const Quat< T > & q )

friend

return sinh 四元演算子qの値、sinhは次のように計算できます。

$\sinh(p) = \sin(w)\cos(||\boldsymbol{v}||) + \cosh(w)\frac{v}{||\boldsymbol{v}||}\sin||\boldsymbol{v}||$

ここで $\boldsymbol{v} = [x, y, z].$

引数

q 四元演算子。

例えば

Quatd q(1,2,3,4);

sinh(q);

cv::Quat::sinh

Quat< _Tp > sinh() const

return sinh value of this quaternion, sinh could be calculated as: where

◆ sqrt

template<typename _Tp >

template<typename T >

Quat< T > sqrt	(	const Quat< T > &	q,
		QuatAssumeType	assumeUnit
	)

friend

リターン $\sqrt{q}$ .

引数

q	四元演算子。
assumeUnit	QUAT_ASSUME_UNITの場合、quaternion qは単位quaternionであるとみなされ、この関数はいくつかの計算を節約します。

例えば

Quatf q(1,2,3,4);

sqrt(q);


QuatAssumeType
assumeUnit =
QUAT_ASSUME_UNIT;
q = {1,0,0,0};

sqrt(q, assumeUnit);
//This assumeUnit means q is a unit quaternion.

◆ tan

template<typename _Tp >

template<typename T >

Quat< T > tan ( const Quat< T > & q )

friend

return tan 四元演算子qの値、tanは次のように計算できます。

$\tan(q) = \frac{\sin(q)}{\cos(q)}.$

引数

q 四元演算子。

例えば

Quatd q(1,2,3,4);

tan(q);

cv::Quat::tan

Quat< _Tp > tan() const

return tan value of this quaternion, tan could be calculated as:

◆ tanh

template<typename _Tp >

template<typename T >

Quat< T > tanh ( const Quat< T > & q )

friend

return tanh 四元演算子 q の値, tanh は次のように計算できます．

$\tanh(q) = \frac{\sinh(q)}{\cosh(q)}.$

引数

q 四元演算子。

例えば

Quatd q(1,2,3,4);

tanh(q);

cv::Quat::tanh

Quat< _Tp > tanh() const

return tanh value of this quaternion, tanh could be calculated as:

参照: sinh,cosh

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

quaternion.hpp

公開メンバ関数

静的公開メンバ関数

公開変数類

静的公開変数類

フレンド

詳解

関数詳解

◆ acos()

◆ acosh()

◆ asin()

◆ asinh()

◆ assertNormal()

◆ at()

◆ atan()

◆ atanh()

◆ conjugate()

◆ cos()

◆ cosh()

◆ createFromAngleAxis()

◆ createFromEulerAngles()

◆ createFromRvec()

◆ createFromXRot()

◆ createFromYRot()

◆ createFromZRot()

◆ crossProduct()

◆ dot()

◆ exp()

◆ getAngle()

◆ getAxis()

◆ interPoint()

◆ inv()

◆ isNormal()

◆ lerp()

◆ log()

◆ nlerp()

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

◆ sin()

◆ sinh()

◆ slerp()

◆ spline()

◆ sqrt()

◆ squad()

◆ tan()

◆ tanh()

◆ toEulerAngles()

◆ toRotMat3x3()

◆ toRotMat4x4()

◆ toRotVec()

◆ toVec()

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

◆ acos

◆ acosh

◆ asin

◆ asinh

◆ atan

◆ atanh

◆ cos

◆ cosh

◆ crossProduct

◆ cv::operator* [1/2]

◆ cv::operator* [2/2]

◆ cv::operator+ [1/2]

◆ cv::operator+ [2/2]

◆ cv::operator- [1/2]

◆ cv::operator- [2/2]