cv::Quat< _Tp > クラステンプレート

#include <opencv2/core/quaternion.hpp>

Collaboration diagram for cv::Quat< _Tp >:

公開メンバ関数
	Quat ()
	Quat (_Tp w, _Tp x, _Tp y, _Tp z)
	4つの数値から。
	Quat (const Vec< _Tp, 4 > &coeff)
	Vec4d または Vec4f から。
Quat< _Tp >	acos () const
	このクォータニオンのarccos値を返す。arccos は次のように計算できる:
Quat< _Tp >	acosh () const
	このクォータニオンのarccosh値を返す。arccosh は次のように計算できる:
Quat< _Tp >	asin () const
	このクォータニオンのarcsin値を返す。arcsin は次のように計算できる:
Quat< _Tp >	asinh () const
	このクォータニオンのarcsinh値を返す。arcsinh は次のように計算できる:
void	assertNormal (_Tp eps=CV_QUAT_EPS) const
	このクォータニオンが単位クォータニオンでない場合にエラーをスローするため。
_Tp	at (size_t index) const
	要素を取得する方法。
Quat< _Tp >	atan () const
	このクォータニオンのarctan値を返す。arctan は次のように計算できる:
Quat< _Tp >	atanh () const
	このクォータニオンのarctanh値を返す。arctanh は次のように計算できる:
Quat< _Tp >	conjugate () const
	このクォータニオンの共役を返す。
Quat< _Tp >	cos () const
	このクォータニオンのcos値を返す。cos は次のように計算できる:
Quat< _Tp >	cosh () const
	このクォータニオンのcosh値を返す。cosh は次のように計算できる:
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	dot (Quat< _Tp > q) const
	クォータニオン \(q\) とこのクォータニオンの間の内積を返す。
Quat< _Tp >	exp () const
	指数関数の値を返す。
_Tp	getAngle (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	クォータニオンの角度を取得する。回転角を返す。
Vec< _Tp, 3 >	getAxis (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	クォータニオンの軸を取得する。長さ3のベクトルを返す。
Quat< _Tp >	inv (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	\(q * q^{-1} = 1\) を満たす \(q\) の逆元である \(q^{-1}\) を返す。
bool	isNormal (_Tp eps=CV_QUAT_EPS) const
	このクォータニオンが単位クォータニオンであれば true を返す。
Quat< _Tp >	log (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	対数関数の値を返す。
_Tp	norm () const
	クォータニオンのノルムを返す。
Quat< _Tp >	normalize () const
	正規化された \(p\) を返す。
Quat< _Tp >	operator* (const Quat< _Tp > &) const
	2つのクォータニオン q と p の乗算演算子。演算子の両辺の値を乗算する。
Quat< _Tp > &	operator*= (const _Tp s)
	クォータニオンとスカラーの乗算代入演算子。右オペランドを左オペランドに乗算し、結果を左オペランドに代入する。
Quat< _Tp > &	operator*= (const Quat< _Tp > &)
	2つのクォータニオン q と p の乗算代入演算子。右オペランドを左オペランドに乗算し、結果を左オペランドに代入する。
Quat< _Tp >	operator+ (const Quat< _Tp > &) const
	2つのクォータニオン p と q の加算演算子。各値が \(p_i\) と \(q_i\) の和となる新しいクォータニオンを返す。
Quat< _Tp > &	operator+= (const Quat< _Tp > &)
	2つのクォータニオン p と q の加算代入演算子。右オペランドを左オペランドに加算し、結果を左オペランドに代入する。
Quat< _Tp >	operator- () const
	\(p + (-p) = 0.\) を満たす反対のクォータニオン \(-p\) を返す。
Quat< _Tp >	operator- (const Quat< _Tp > &) const
	2つのクォータニオン p と q の減算演算子。各値が \(p_i\) と \(-q_i\) の和となる新しいクォータニオンを返す。
Quat< _Tp > &	operator-= (const Quat< _Tp > &)
	2つのクォータニオン p と q の減算代入演算子。右オペランドを左オペランドから減算し、結果を左オペランドに代入する。
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 の除算代入演算子。左オペランドを右オペランドで除算し、結果を左オペランドに代入する。
bool	operator== (const Quat< _Tp > &) const
	2つのクォータニオン p と q がほぼ等しい場合、すなわち各 \(p_i\) と \(q_i\) の絶対値が CV_QUAT_EPS より小さい場合に true を返す。
_Tp &	operator[] (std::size_t n)
const _Tp &	operator[] (std::size_t n) const
Quat< _Tp >	power (const _Tp x, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	指数 \(x\) によるべき乗関数の値を返す。
Quat< _Tp >	power (const Quat< _Tp > &q, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	クォータニオン \(q\) によるべき乗関数の値を返す。
Quat< _Tp >	sin () const
	このクォータニオンの sin 値を返す。sin は次のように計算できる:
Quat< _Tp >	sinh () const
	このクォータニオンの 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 >	sqrt (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	\(\sqrt{q}\) を返す。
Quat< _Tp >	tan () const
	このクォータニオンの tan 値を返す。tan は次のように計算できる:
Quat< _Tp >	tanh () const
	このクォータニオンの tanh 値を返す。tanh は次のように計算できる:
Vec< _Tp, 3 >	toEulerAngles (QuatEnum::EulerAnglesType eulerAnglesType)
	クォータニオン q をオイラー角に変換する。
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, 3 >	toRotVec (QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
	このクォータニオンを回転ベクトルに変換する。
Vec< _Tp, 4 >	toVec () const
	このクォータニオンを Vec<T, 4> に変換する。

静的公開メンバ関数
static Quat< _Tp >	createFromAngleAxis (const _Tp angle, const Vec< _Tp, 3 > &axis)
	角度と軸から生成する。軸はこの関数内で正規化される。そして生成される
static Quat< _Tp >	createFromEulerAngles (const Vec< _Tp, 3 > &angles, QuatEnum::EulerAnglesType eulerAnglesType)
	オイラー角から生成する
static Quat< _Tp >	createFromRotMat (InputArray R)
	3x3 回転行列から生成する。
static Quat< _Tp >	createFromRvec (InputArray rvec)
	回転ベクトル \(r\) から生成する。これは \(\theta \cdot \boldsymbol{u}\) の形を持ち、\(\theta\) は回転角、\(\boldsymbol{u}\) は正規化された回転軸を表す。
static Quat< _Tp >	createFromXRot (const _Tp theta)
	X軸まわりに \(\theta\) だけ回転するクォータニオンを取得する。
static Quat< _Tp >	createFromYRot (const _Tp theta)
	Y軸まわりに \(\theta\) だけ回転するクォータニオンを取得する。
static Quat< _Tp >	createFromZRot (const _Tp theta)
	Z軸まわりに \(\theta\) だけ回転するクォータニオンを取得する。
static Quat< _Tp >	interPoint (const Quat< _Tp > &q0, const Quat< _Tp > &q1, const Quat< _Tp > &q2, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
	これは squad の一部の計算である。3つのクォータニオンの間の中間クォータニオン \(s_i\) を計算する。
static Quat< _Tp >	lerp (const Quat< _Tp > &q0, const Quat &q1, const _Tp t)
	\(q_0\) から \(q_1\) への補間を線形補間(Nlerp)で計算する。2つのクォータニオンについて、この補間曲線は次のように表示できる:
static Quat< _Tp >	nlerp (const Quat< _Tp > &q0, const Quat &q1, const _Tp t, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
	\(q_0\) から \(q_1\) への補間を正規化線形補間(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)
	\(q_0\) と \(q_1\) の間の補間を球面線形補間(Slerp)で計算する。これは次のように定義できる:
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 において squad で構成された \(C^1\) 連続なスプライン曲線の結果となるクォータニオンを計算する。ここで、補間値は \(q_1\) と \(q_2\) の間にある。\(q_0\) と \(q_2\) は \(C^1\) 連続性を保証するために使われる。t = 0 のとき \(q_1\) を返し、t = 1 のとき \(q_2\) を返す。
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)
	\(q_0\), \(q_1\), \(q_2\), \(q_3\) の間の補間を球面四辺形補間(Squad)で計算する。これは次のように定義できる:

公開変数類
_Tp	w
_Tp	x
_Tp	y
_Tp	z

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

フレンド
template<typename T >
Quat< T >	acos (const Quat< T > &q)
	クォータニオン q の arccos 値を返す。arccos は次のように計算できる:
template<typename T >
Quat< T >	acosh (const Quat< T > &q)
	クォータニオン q の arccosh 値を返す。arccosh は次のように計算できる:
template<typename T >
Quat< T >	asin (const Quat< T > &q)
	クォータニオン q の arcsin 値を返す。arcsin は次のように計算できる:
template<typename T >
Quat< T >	asinh (const Quat< T > &q)
	クォータニオン q の arcsinh 値を返す。arcsinh は次のように計算できる:
template<typename T >
Quat< T >	atan (const Quat< T > &q)
	クォータニオン q の arctan 値を返す。arctan は次のように計算できる:
template<typename T >
Quat< T >	atanh (const Quat< T > &q)
	クォータニオン q の arctanh 値を返す。arctanh は次のように計算できる:
template<typename T >
Quat< T >	cos (const Quat< T > &q)
	クォータニオン q の sin 値を返す。cos は次のように計算できる:
template<typename T >
Quat< T >	cosh (const Quat< T > &q)
	クォータニオン q の cosh 値を返す。cosh は次のように計算できる:
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 >	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 T >
Quat< T >	cv::operator- (const T s, const Quat< T > &)
	スカラーとクォータニオンの減算演算子。左オペランドから右オペランドを減算する。
template<typename S >
std::ostream &	cv::operator<< (std::ostream &, const Quat< S > &)
template<typename T >
Quat< T >	exp (const Quat< T > &q)
	指数関数の値を返す。
template<typename T >
Quat< T >	inv (const Quat< T > &q, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
	\(q * q^{-1} = 1\) を満たす \(q\) の逆元 \(q^{-1}\) を返す。
template<typename T >
Quat< T >	log (const Quat< T > &q, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
	対数関数の値を返す。
template<typename T >
Quat< T >	power (const Quat< T > &p, const Quat< T > &q, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
	クォータニオン \(q\) によるべき乗関数の値を返す。
template<typename T >
Quat< T >	power (const Quat< T > &q, const T x, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
	指数 \(x\) によるべき乗関数の値を返す。
template<typename T >
Quat< T >	sin (const Quat< T > &q)
	クォータニオン q の tanh 値を返す。sin は次のように計算できる:
template<typename T >
Quat< T >	sinh (const Quat< T > &q)
	クォータニオン q の sinh 値を返す。sinh は次のように計算できる:
template<typename T >
Quat< T >	sqrt (const Quat< T > &q, QuatAssumeType assumeUnit)
	\(\sqrt{q}\) を返す。
template<typename T >
Quat< T >	tan (const Quat< T > &q)
	クォータニオン q の tan 値を返す。tan は次のように計算できる:
template<typename T >
Quat< T >	tanh (const Quat< T > &q)
	クォータニオン q の tanh 値を返す。tanh は次のように計算できる:

詳細説明

template<typename _Tp>
class cv::Quat< _Tp >

クォータニオンは複素数を拡張した数体系である。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);

すでに angle * axis の形を持つ回転ベクトル rvec を持っている場合は、次を使用できる

Quatd q = Quatd::createFromRvec(rvec);

クォータニオンから回転行列を抽出するには、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)

spline は複数のクォータニオンの回転を滑らかに接続できる

クォータニオンの要素を取得する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;

構築子と解体子の詳解

Quat() [1/3]

template<typename _Tp >

cv::Quat< _Tp >::Quat

(

)

Quat() [2/3]

template<typename _Tp >

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

explicit

Vec4d または Vec4f から生成する。

Quat() [3/3]

template<typename _Tp >

cv::Quat< _Tp >::Quat	(	_Tp	w,
		_Tp	x,
		_Tp	y,
		_Tp	z )

4つの数値から生成する。

メンバ関数詳解

acos()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::acos

(

)

const

このクォータニオンの 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

このクォータニオンの 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

このクォータニオンの 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

このクォータニオンの 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

このクォータニオンの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

このクォータニオンの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

このクォータニオンの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

角度と軸から生成する。軸はこの関数内で正規化される。そして次を生成する

\[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の順で内因性回転(intrinsic rotation)を用いる場合、\(\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	変換に用いるオイラー角の型。

createFromRotMat()

template<typename _Tp >

static Quat< _Tp > cv::Quat< _Tp >::createFromRotMat ( InputArray R )

static

3x3回転行列から生成する。

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})\) の外積(crossProduct)を返す。

\[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)を返す。

dot(p, q) は2つのクォータニオンがどれだけ近いかを表す良い指標である。実際、単位クォータニオンの差 \(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

クォータニオンの角度を取得する。回転角を返す。

引数

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

これはsquadの一部の計算である。3つのクォータニオンごとの中間クォータニオン \(s_i\) を計算するためのものである。

\[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 * q^{-1} = 1\) を満たす \(q\) の逆元である \(q^{-1}\) を返す。

引数

assumeUnit

QUAT_ASSUME_UNIT の場合、クォータニオン q は単位クォータニオンと仮定され、この関数は一部の計算を省略する。

例えば

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

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

引数

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

線形補間(Nlerp)によって \(q_0\) から \(q_1\) への補間を計算する。2つのクォータニオンについて、この補間曲線は次のように表せる:

\[Lerp(q_0, q_1, t) = (1 - t)q_0 + tq_1.\]

明らかに、\(q_0\) と \(q_1\) を2次元空間内のベクトルとみなせば、lerp は直線に沿って補間する。\(t = 0\) のときは \(q_0\) を返し、\(t= 1\) のときは \(q_1\) を返す。\(t\) は通常 \([0, 1]\) の範囲であるべきである。

引数

q0	線形補間に用いるクォータニオン。
q1	線形補間に用いるクォータニオン。
t	範囲 [0, 1] にわたるベクトル \(\overrightarrow{q_0q_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

正規化線形補間(Nlerp)によって \(q_0\) から \(q_1\) への補間を計算する。線形補間(Lerp)を正規化したクォータニオンを返す。

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

この補間は常に最短経路を選ぶが、一定速度は保証されない。

引数

q0	正規化線形補間に用いるクォータニオン。
q1	正規化線形補間に用いるクォータニオン。
t	範囲 [0, 1] にわたるベクトル \(\overrightarrow{q_0q_1}\) の割合。
assumeUnit	QUAT_ASSUME_UNIT の場合、すべての入力クォータニオンは単位クォータニオンと仮定される。そうでない場合、すべての入力クォータニオンは関数内部で正規化される。

参照

lerp

norm()

template<typename _Tp >

_Tp cv::Quat< _Tp >::norm

(

)

const

クォータニオンのノルムを返す。

\[||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) = 0.\) を満たす反対のクォータニオン \(-p\) を返す。

例えば

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;

operator==()

template<typename _Tp >

bool cv::Quat< _Tp >::operator==

(

const Quat< _Tp > &

)

const

2つのクォータニオン p と q がほぼ等しい場合、すなわち各 \(p_i\) と \(q_i\) の差の絶対値が CV_QUAT_EPS 未満である場合に true を返す。

operator[]() [1/2]

template<typename _Tp >

_Tp & cv::Quat< _Tp >::operator[]

(

std::size_t

n

)

operator[]() [2/2]

template<typename _Tp >

const _Tp & cv::Quat< _Tp >::operator[]

(

std::size_t

n

)

const

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

このクォータニオンの 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

このクォータニオンの 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

球面線形補間 (Spherical Linear Interpolation, Slerp) によって \(q_0\) と \(q_1\) の間の補間を計算する。これは次のように定義できる:

\[ 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] にわたる \(q_0\) と \(q_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

比率 t において squad で構築された \(C^1\) 連続のスプライン曲線の結果となるクォータニオンを計算する。ここで補間値は \(q_1\) と \(q_2\) の間にある。\(q_0\) と \(q_2\) は \(C^1\) 連続性を保証するために用いられる。t = 0 のとき \(q_1\) を返し、t = 1 のとき \(q_2\) を返す。

引数

q0	\(C^1\) 連続性を保証するための1番目の入力クォータニオン。
q1	2番目の入力クォータニオン。
q2	3番目の入力クォータニオン。
q3	4番目の入力クォータニオン。\(q1\) と同じ用途。
t	範囲 [0, 1] にわたる比率。
assumeUnit	QUAT_ASSUME_UNIT の場合、\(q_0, q_1, q_2, q_3\) は単位クォータニオンと仮定される。そうでない場合、すべての入力クォータニオンは関数内部で正規化される。

例:

補間対象となる3つの double クォータニオン \(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

球面四角形補間 (Spherical and quadrangle, Squad) によって \(q_0\), \(q_1\), \(q_2\), \(q_3\) の間の補間を計算する。これは次のように定義できる:

\[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	4番目のクォータニオン。
t	範囲 \([0, 1]\) にわたる二次補間および線形補間の補間パラメータ。
assumeUnit	QUAT_ASSUME_UNIT の場合、すべての入力クォータニオンは単位クォータニオンと仮定される。そうでない場合、すべての入力クォータニオンは関数内部で正規化される。
directChange	QUAT_ASSUME_UNIT の場合、squad は補間のための最短経路を見つける。

参照

interPoint, spline

tan()

template<typename _Tp >

Quat< _Tp > cv::Quat< _Tp >::tan

(

)

const

このクォータニオンの 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

このクォータニオンの 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 = 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 型のオイラー角による内的回転 (intrinsic rotations) を例にとると、\(\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. Euler angles is non-unique. For intrinsic rotations, we set the third angle to 0, and for external rotation, we set the first angle to 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\) を設定する。

その結果、すべてのオイラー角の型について、次の表に示すように解を求めることができる。

EulerAnglesType	Ordinary	\(\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}) \)

EulerAnglesType	Ordinary	\(\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 の場合、このクォータニオンは単位クォータニオンと仮定され、この関数は一部の計算を省略する。そうでない場合、この関数はまずこのクォータニオンを正規化してから変換を行う。

覚え書き

Matrix A which is to be rotated should have the form

\[\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}\]

where the same subscript represents a point. The shape of A assume to be [3, n] The points matrix A can be rotated by toRotMat3x3() * A. The result has 3 rows and n columns too.

例えば

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 の場合、このクォータニオンは単位クォータニオンと仮定され、この関数は一部の計算を省略する。そうでない場合、この関数はまずこのクォータニオンを正規化してから変換を行う。

演算は toRotMat3x3 と同様だが、点の行列が次の形式である必要がある

\[\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

このクォータニオンを Vec<T, 4> に変換する。

例えば

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

Friends And Related Symbol Documentation

acos

template<typename _Tp >

template<typename T >

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

friend

クォータニオン 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);

acosh

template<typename _Tp >

template<typename T >

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

friend

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

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

.

引数

q

クォータニオン。

例えば

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

asin

template<typename _Tp >

template<typename T >

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

friend

クォータニオン 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);

asinh

template<typename _Tp >

template<typename T >

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

friend

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

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

.

引数

q

クォータニオン。

例えば

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

atan

template<typename _Tp >

template<typename T >

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

friend

クォータニオン q の arctan の値を返す。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);

atanh

template<typename _Tp >

template<typename T >

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

friend

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

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

.

引数

q

クォータニオン。

例えば

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

cos

template<typename _Tp >

template<typename T >

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

friend

クォータニオン q の sin の値を返す。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);

cosh

template<typename _Tp >

template<typename T >

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

friend

クォータニオン q の cosh の値を返す。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);

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})\) の外積(crossProduct)を返す。

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

覚え書き

スカラーの型はクォータニオンと等しくなければならない。

cv::operator<<

template<typename _Tp >

template<typename S >

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

friend

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;

inv

template<typename _Tp >

template<typename T >

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

friend

\(q * q^{-1} = 1\) を満たす \(q\) の逆元 \(q^{-1}\) を返す。

引数

q	クォータニオン。
assumeUnit	QUAT_ASSUME_UNIT の場合、クォータニオン q は単位クォータニオンと仮定され、この関数は一部の計算を省略する。

例えば

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

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;

power [1/2]

template<typename _Tp >

template<typename T >

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

friend

クォータニオン \(q\) のべき乗関数の値を返す。

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

引数

p	べき乗関数の基底クォータニオン。
q	べき乗関数の指数クォータニオン。
assumeUnit	QUAT_ASSUME_UNIT の場合、クォータニオン \(p\) は単位クォータニオンと仮定され、この関数は一部の計算を省略する。

例えば

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

friend

指数 \(x\) のべき乗関数の値を返す。

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

引数

q	クォータニオン。
x	べき乗の指数。
assumeUnit	QUAT_ASSUME_UNIT の場合、クォータニオン q は単位クォータニオンと仮定され、この関数は一部の計算を省略する。

例えば

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

クォータニオン 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);

sinh

template<typename _Tp >

template<typename T >

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

friend

クォータニオン q の sinh の値を返す。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);

sqrt

template<typename _Tp >

template<typename T >

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

friend

\(\sqrt{q}\) を返す。

引数

q	クォータニオン。
assumeUnit	QUAT_ASSUME_UNIT の場合、クォータニオン q は単位クォータニオンと仮定され、この関数は一部の計算を省略する。

例えば

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

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

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

引数

q

クォータニオン。

例えば

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

tanh

template<typename _Tp >

template<typename T >

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

friend

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

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

引数

q

クォータニオン。

例えば

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

参照

sinh, cosh

メンバ変数詳解

CV_QUAT_CONVERT_THRESHOLD

template<typename _Tp >

_Tp cv::Quat< _Tp >::CV_QUAT_CONVERT_THRESHOLD = (_Tp)1.e-6

staticconstexpr

CV_QUAT_EPS

template<typename _Tp >

_Tp cv::Quat< _Tp >::CV_QUAT_EPS = (_Tp)1.e-6

staticconstexpr

w

template<typename _Tp >

_Tp cv::Quat< _Tp >::w

x

template<typename _Tp >

_Tp cv::Quat< _Tp >::x

y

template<typename _Tp >

_Tp cv::Quat< _Tp >::y

z

template<typename _Tp >

_Tp cv::Quat< _Tp >::z

---

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

• opencv2/core/quaternion.hpp