クォータニオン

詳細説明

クラス
class	cv::DualQuat< _Tp >
class	cv::Quat< _Tp >
class	cv::QuatEnum

型定義
using	cv::DualQuatd = DualQuat<double>
using	cv::DualQuatf = DualQuat<float>
using	cv::Quatd = Quat<double>
using	cv::Quatf = Quat<float>

列挙型
enum	cv::QuatAssumeType {   cv::QUAT_ASSUME_NOT_UNIT ,   cv::QUAT_ASSUME_UNIT }
	単位クォータニオンフラグ。 続き...

関数
template<typename T >
Quat< T >	cv::acos (const Quat< T > &q)
template<typename T >
Quat< T >	cv::acosh (const Quat< T > &q)
template<typename T >
Quat< T >	cv::asin (const Quat< T > &q)
template<typename T >
Quat< T >	cv::asinh (const Quat< T > &q)
template<typename T >
Quat< T >	cv::atan (const Quat< T > &q)
template<typename T >
Quat< T >	cv::atanh (const Quat< T > &q)
template<typename T >
Quat< T >	cv::cos (const Quat< T > &q)
template<typename T >
Quat< T >	cv::cosh (const Quat< T > &q)
template<typename T >
Quat< T >	cv::crossProduct (const Quat< T > &p, const Quat< T > &q)
template<typename T >
Quat< T >	cv::exp (const Quat< T > &q)
template<typename T >
Quat< T >	cv::inv (const Quat< T > &q, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
template<typename T >
Quat< T >	cv::log (const Quat< T > &q, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
template<typename T >
Quat< T >	cv::operator* (const Quat< T > &, const T)
template<typename T >
Quat< T >	cv::operator* (const T, const Quat< T > &)
template<typename _Tp >
std::ostream &	cv::operator<< (std::ostream &, const DualQuat< _Tp > &)
template<typename _Tp >
std::ostream &	cv::operator<< (std::ostream &, const Quat< _Tp > &)
template<typename S >
std::ostream &	cv::operator<< (std::ostream &, const Quat< S > &)
template<typename T >
Quat< T >	cv::power (const Quat< T > &q, const Quat< T > &p, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
template<typename T >
Quat< T >	cv::power (const Quat< T > &q, const T x, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
template<typename T >
Quat< T >	cv::sin (const Quat< T > &q)
template<typename T >
Quat< T >	cv::sinh (const Quat< T > &q)
template<typename S >
Quat< S >	cv::sqrt (const Quat< S > &q, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
template<typename T >
Quat< T >	cv::tan (const Quat< T > &q)
template<typename T >
Quat< T >	cv::tanh (const Quat< T > &q)

型定義詳解

DualQuatd

using cv::DualQuatd = DualQuat<double>

#include <opencv2/core/dualquaternion.hpp>

DualQuatf

using cv::DualQuatf = DualQuat<float>

#include <opencv2/core/dualquaternion.hpp>

Quatd

using cv::Quatd = Quat<double>

#include <opencv2/core/quaternion.hpp>

Quatf

using cv::Quatf = Quat<float>

#include <opencv2/core/quaternion.hpp>

列挙型詳解

QuatAssumeType

enum cv::QuatAssumeType

#include <opencv2/core/quaternion.hpp>

単位クォータニオンフラグ。

列挙値
QUAT_ASSUME_NOT_UNIT  Python: cv.QUAT_ASSUME_NOT_UNIT	このフラグはデフォルトで指定される。このフラグが指定されると、入力されるクォータニオンは単位クォータニオンではないと仮定される。計算速度はフラグ QUAT_ASSUME_UNIT よりも遅くなるが、計算の正しさを保証できる。
QUAT_ASSUME_UNIT  Python: cv.QUAT_ASSUME_UNIT	このフラグが指定されると、入力されるクォータニオンは単位クォータニオンと仮定され、一部の計算を省略できる。ただし、単位クォータニオンでないのにこのフラグを指定した場合、プログラムの結果の正しさは保証されない。

関数詳解

acos()

template<typename T >

Quat< T > cv::acos

(

const Quat< T > &

q

)

#include <opencv2/core/quaternion.hpp>

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

Quat< T > cv::acosh

(

const Quat< T > &

q

)

#include <opencv2/core/quaternion.hpp>

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

.

引数

q

クォータニオン。

例えば

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

asin()

template<typename T >

Quat< T > cv::asin

(

const Quat< T > &

q

)

#include <opencv2/core/quaternion.hpp>

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

Quat< T > cv::asinh

(

const Quat< T > &

q

)

#include <opencv2/core/quaternion.hpp>

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

.

引数

q

クォータニオン。

例えば

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

atan()

template<typename T >

Quat< T > cv::atan

(

const Quat< T > &

q

)

#include <opencv2/core/quaternion.hpp>

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

Quat< T > cv::atanh

(

const Quat< T > &

q

)

#include <opencv2/core/quaternion.hpp>

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

.

引数

q

クォータニオン。

例えば

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

cos()

template<typename T >

Quat< T > cv::cos

(

const Quat< T > &

q

)

#include <opencv2/core/quaternion.hpp>

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

Quat< T > cv::cosh

(

const Quat< T > &

q

)

#include <opencv2/core/quaternion.hpp>

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

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

#include <opencv2/core/quaternion.hpp>

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

exp()

template<typename T >

Quat< T > cv::exp

(

const Quat< T > &

q

)

Python:
	cv.exp(	src[, dst]	) ->	dst

#include <opencv2/core/quaternion.hpp>

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

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

#include <opencv2/core/quaternion.hpp>

引数

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

Quat< T > cv::log	(	const Quat< T > &	q,
		QuatAssumeType	assumeUnit = QUAT_ASSUME_NOT_UNIT )

Python:
	cv.log(	src[, dst]	) ->	dst

#include <opencv2/core/quaternion.hpp>

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

operator*() [1/2]

template<typename T >

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

#include <opencv2/core/quaternion.hpp>

operator*() [2/2]

template<typename T >

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

#include <opencv2/core/quaternion.hpp>

operator<<() [1/3]

template<typename _Tp >

std::ostream & cv::operator<<	(	std::ostream &	,
		const DualQuat< _Tp > &	)

#include <opencv2/core/dualquaternion.hpp>

operator<<() [2/3]

template<typename _Tp >

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

#include <opencv2/core/quaternion.hpp>

operator<<() [3/3]

template<typename S >

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

#include <opencv2/core/quaternion.hpp>

power() [1/2]

template<typename T >

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

#include <opencv2/core/quaternion.hpp>

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

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

#include <opencv2/core/quaternion.hpp>

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

Quat< T > cv::sin

(

const Quat< T > &

q

)

#include <opencv2/core/quaternion.hpp>

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

Quat< T > cv::sinh

(

const Quat< T > &

q

)

#include <opencv2/core/quaternion.hpp>

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

Quat< S > cv::sqrt	(	const Quat< S > &	q,
		QuatAssumeType	assumeUnit = QUAT_ASSUME_NOT_UNIT )

Python:
	cv.sqrt(	src[, dst]	) ->	dst

#include <opencv2/core/quaternion.hpp>

tan()

template<typename T >

Quat< T > cv::tan

(

const Quat< T > &

q

)

#include <opencv2/core/quaternion.hpp>

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

引数

q

クォータニオン。

例えば

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

tanh()

template<typename T >

Quat< T > cv::tanh

(

const Quat< T > &

q

)

#include <opencv2/core/quaternion.hpp>

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

引数

q

クォータニオン。

例えば

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

参照

sinh, cosh