OpenCV 4.12.0
開源計算機視覺
載入中...
搜尋中...
無匹配項
公共成員函式 | 靜態公共成員函式 | 公共屬性 | 靜態公共屬性 | 友元 | 所有成員列表
cv::Quat< _Tp > 類模板參考
核心功能 » 四元數

#include <opencv2/core/quaternion.hpp>

cv::Quat< _Tp > 的協作圖

公共成員函式

 Quat ()
 
 Quat (_Tp w, _Tp x, _Tp y, _Tp z)
 從四個數字建立。
 
 Quat (const Vec< _Tp, 4 > &coeff)
 從 Vec4d 或 Vec4f 建立。
 
Quat< _Tp > acos () const
 返回此四元數的反餘弦值，反餘弦可以計算為
 
Quat< _Tp > acosh () const
 返回此四元數的反雙曲餘弦值，反雙曲餘弦可以計算為
 
Quat< _Tp > asin () const
 返回此四元數的反正弦值，反正弦可以計算為
 
Quat< _Tp > asinh () const
 返回此四元數的反雙曲正弦值，反雙曲正弦可以計算為
 
void assertNormal (_Tp eps=CV_QUAT_EPS) const
 如果此四元數不是單位四元數，則丟擲錯誤。
 
_Tp at (size_t index) const
 獲取元素的方法。
 
Quat< _Tp > atan () const
 返回此四元數的反正切值，反正切可以計算為
 
Quat< _Tp > atanh () const
 返回此四元數的反雙曲正切值，反雙曲正切可以計算為
 
Quat< _Tp > conjugate () const
 返回此四元數的共軛。
 
Quat< _Tp > cos () const
 返回此四元數的餘弦值，餘弦可以計算為
 
Quat< _Tp > cosh () 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 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^{-1}\)，它是 \(q\) 的逆，滿足 \(q * q^{-1} = 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
 兩個四元數 q 和 p 的乘法運算子。將運算子兩側的值相乘。
 
Quat< _Tp > & operator*= (const _Tp s)
 四元數與標量的乘法賦值運算子。它將右運算元與左運算元相乘並將結果賦給左運算元。
 
Quat< _Tp > & operator*= (const Quat< _Tp > &)
 兩個四元數 q 和 p 的乘法賦值運算子。它將右運算元與左運算元相乘並將結果賦給左運算元。
 
Quat< _Tp > operator+ (const Quat< _Tp > &) const
 兩個四元數 p 和 q 的加法運算子。它返回一個新的四元數，其中每個值是 \(p_i\) 和 \(q_i\) 的和。
 
Quat< _Tp > & operator+= (const Quat< _Tp > &)
 兩個四元數 p 和 q 的加法賦值運算子。它將右運算元加到左運算元上並將結果賦給左運算元。
 
Quat< _Tp > operator- () const
 返回相反四元數 \(-p\)，滿足 \(p + (-p) = 0.\)。
 
Quat< _Tp > operator- (const Quat< _Tp > &) const
 兩個四元數 p 和 q 的減法運算子。它返回一個新的四元數，其中每個值是 \(p_i\) 和 \(-q_i\) 的和。
 
Quat< _Tp > & operator-= (const Quat< _Tp > &)
 兩個四元數 p 和 q 的減法賦值運算子。它將右運算元從左運算元中減去並將結果賦給左運算元。
 
Quat< _Tp > operator/ (const _Tp s) const
 四元數與標量的除法運算子。它將左運算元除以右運算元並將結果賦給左運算元。
 
Quat< _Tp > operator/ (const Quat< _Tp > &) const
 兩個四元數 p 和 q 的除法運算子。將左運算元除以右運算元。
 
Quat< _Tp > & operator/= (const _Tp s)
 四元數與標量的除法賦值運算子。它將左運算元除以右運算元並將結果賦給左運算元。
 
Quat< _Tp > & operator/= (const Quat< _Tp > &)
 兩個四元數 p 和 q 的除法賦值運算子；它將左運算元除以右運算元並將結果賦給左運算元。
 
bool operator== (const Quat< _Tp > &) const
 如果兩個四元數 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 > Quat< _Tp > 
 返回以四元數 \(q\) 為指數的冪函式值。
 
Quat< _Tp > sin () const
 返回此四元數的正弦值，正弦可以計算為
 
Quat< _Tp > sinh () const
 返回此四元數的雙曲正弦值，雙曲正弦可以計算為：\(\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
 返回此四元數的正切值，正切可以計算為
 
Quat< _Tp > tanh () const
 返回此四元數的雙曲正切值，雙曲正切可以計算為
 
Vec< _Tp, 3 > QuatEnum::EulerAnglesType 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 的部分計算。用於計算每三個四元數之間的中間四元數 \(s_i\)。
 
static Quat< _Tp > lerp (const Quat< _Tp > &q0, const Quat &q1, const _Tp t)
 透過線性插值（Lerp）計算從 \(q_0\) 到 \(q_1\) 的插值。對於兩個四元數，此插值曲線可以顯示為
 
static Quat< _Tp > nlerp (const Quat< _Tp > &q0, const Quat &q1, const _Tp t, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
 透過歸一化線性插值（Nlerp）計算從 \(q_0\) 到 \(q_1\) 的插值。它返回線性插值（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）計算 \(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)
 計算透過 squad 構造的 \(C^1\) 連續樣條曲線在比率 t 處的四元數結果。這裡，插值在 \(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)
 透過球面和四邊形（Squad）計算 \(q_0\), \(q_1\), \(q_2\), \(q_3\) 之間的插值。這可以定義為
 

公共屬性

_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 的反餘弦值，反餘弦可以計算為
 
template<typename T >
Quat< T > acosh (const Quat< T > &q)
 返回四元數 q 的反雙曲餘弦值，反雙曲餘弦可以計算為
 
template<typename T >
Quat< T > asin (const Quat< T > &q)
 返回四元數 q 的反正弦值，反正弦可以計算為
 
template<typename T >
Quat< T > asinh (const Quat< T > &q)
 返回四元數 q 的反雙曲正弦值，反雙曲正弦可以計算為
 
template<typename T >
Quat< T > atan (const Quat< T > &q)
 返回四元數 q 的反正切值，反正切可以計算為
 
template<typename T >
Quat< T > atanh (const Quat< T > &q)
 返回四元數 q 的反雙曲正切值，反雙曲正切可以計算為
 
template<typename T >
Quat< T > cos (const Quat< T > &q)
 返回四元數 q 的餘弦值，餘弦可以計算為
 
template<typename T >
Quat< T > cosh (const Quat< T > &q)
 返回四元數 q 的雙曲餘弦值，雙曲餘弦可以計算為
 
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^{-1}\)，它是 \(q\) 的逆，滿足 \(q * q^{-1} = 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 的正弦值，正弦可以計算為
 
template<typename T >
Quat< T > sinh (const Quat< T > &q)
 返回四元數 q 的雙曲正弦值，雙曲正弦可以計算為
 
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 的正切值，正切可以計算為
 
template<typename T >
Quat< T > tanh (const Quat< T > &q)
 返回四元數 q 的雙曲正切值，雙曲正切可以計算為
 

詳細描述

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

四元數是擴充套件複數的一個數系。它可以表示三維空間中的旋轉。一個四元數通常表示為以下形式：

\[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);
cv::Quat
定義 quaternion.hpp:211
cv::Quat::createFromAngleAxis
static Quat< _Tp > createFromAngleAxis(const _Tp angle, const Vec< _Tp, 3 > &axis)
從角度、軸建立。軸在此函式中將被歸一化。並且它生成
CV_PI
#define CV_PI
定義 cvdef.h:380
cv
定義 core.hpp:107

您可以簡單地使用四個相同型別的數字來建立一個四元數：

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)
從 3x3 旋轉矩陣建立。

如果您已經有一個旋轉向量 rvec，其形式為 angle * axis，則可以使用：

Quatd q = Quatd::createFromRvec(rvec);
cv::Quat::createFromRvec
static Quat< _Tp > createFromRvec(InputArray rvec)
從旋轉向量建立，其形式為，其中表示旋轉角度，表示歸一化旋轉軸...

要從四元數中提取旋轉矩陣，請參閱 toRotMat3x3()

要提取 Vec4d 或 Vec4f，請參閱 toVec()

要提取旋轉向量，請參閱 toRotVec()

如果需要插值兩個四元數 \(q_0, q_1\)，您可以使用 nlerp()、slerp() 或 spline()

Quatd::nlerp(q0, q1, t)
Quatd::slerp(q0, q1, t)
Quatd::spline(q0, q0, q1, q1, t)
cv::Quat::spline
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)
計算透過 squad 構造的連續樣條曲線在 t 處的四元數結果...
cv::Quat::slerp
static Quat< _Tp > slerp(const Quat< _Tp > &q0, const Quat &q1, const _Tp t, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT, bool directChange=true)
透過球面線性插值（Slerp）計算 和 之間的插值，...
cv::Quat::nlerp
static Quat< _Tp > nlerp(const Quat< _Tp > &q0, const Quat &q1, const _Tp t, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
透過歸一化線性插值（Nlerp）計算從 到 的插值。...

樣條曲線可以平滑地連線多個四元數的旋轉

獲取四元數元素的三種方式

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;
cv::Quat::at
_Tp at(size_t index) const
獲取元素的方法。
cv::Quat::w
_Tp w
定義 quaternion.hpp:1618

建構函式 & 解構函式文件

◆ 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)
顯式

從 Vec4d 或 Vec4f 建立。

◆ Quat() [3/3]

template<typename _Tp >
cv::Quat< _Tp >::Quat ( 包裝自定義型別的輔助函式。 w,
包裝自定義型別的輔助函式。 x,
包裝自定義型別的輔助函式。 y,
包裝自定義型別的輔助函式。 z )

從四個數字建立。

成員函式文件

◆ acos()

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

返回此四元數的反餘弦值，反餘弦可以計算為

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

返回此四元數的反雙曲餘弦值，反雙曲餘弦可以計算為

\[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(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(q) = \ln(q + \sqrt{q^2 + 1})\]

.

例如

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

◆ assertNormal()

template<typename _Tp >
void cv::Quat< _Tp >::assertNormal ( 包裝自定義型別的輔助函式。 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(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

返回此四元數的反雙曲正切值，反雙曲正切可以計算為

\[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(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(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 的順序使用內旋，\(\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 的尤拉角向量
尤拉角型別轉換的尤拉角型別

◆ 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})\) 之間的叉積。

\[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)
cv::Quat::crossProduct
friend Quat< T > crossProduct(const Quat< T > &p, const Quat< T > &q)
返回 和 之間的叉積。

◆ dot()

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

返回四元數 \(q\) 與此四元數之間的點積。

dot(p, q) 是衡量四元數接近程度的一個很好的指標。實際上，考慮單位四元數差 \(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;
cv::Quat::exp
friend Quat< T > exp(const Quat< T > &q)
返回指數值。

◆ 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);//與 q.getAngle() 相同。
cv::QuatAssumeType
QuatAssumeType
單位四元數標誌。
定義 quaternion.hpp:39
cv::QUAT_ASSUME_UNIT
@ QUAT_ASSUME_UNIT
定義 quaternion.hpp:52
注意
它始終返回 \([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);//與 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 的部分計算。用於計算每三個四元數之間的中間四元數 \(s_i\)。

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

引數
q0第一個四元數。
q1第二個四元數。
q2第三個四元數。
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 為真，則假定四元數 q 為單位四元數，此函式將節省一些計算。

例如

Quatd q(1,2,3,4);
q.inv();
QuatAssumeType assumeUnit = QUAT_ASSUME_UNIT;
q = q.normalize();
q.inv(assumeUnit); //assumeUnit 表示 p 是單位四元數

◆ isNormal()

template<typename _Tp >
bool cv::Quat< _Tp >::isNormal ( 包裝自定義型別的輔助函式。 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

透過線性插值（Lerp）計算從 \(q_0\) 到 \(q_1\) 的插值。對於兩個四元數，此插值曲線可以顯示為

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

顯然，如果我們將 \(q_0\) 和 \(q_1\) 視為二維空間中的向量，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

透過歸一化線性插值（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向量 \(\overrightarrow{q_0q_1}\) 的百分比，範圍在 [0, 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

兩個四元數 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; // 等同於 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 > & )

兩個四元數 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; // 等同於 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

兩個四元數 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 > & )

兩個四元數 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

兩個四元數 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 > & )

兩個四元數 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

兩個四元數 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; // 等同於 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 > & )

兩個四元數 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; // 等同於 p = p * q.inv()
std::cout << p << std::endl;

◆ operator==()

template<typename _Tp >
bool cv::Quat< _Tp >::operator== ( const Quat< _Tp > & ) const

如果兩個四元數 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); //透過軸和角度生成單位四元數
q1.power(2.0, assumeUnit); //此 assumeUnit 表示 q1 是單位四元數
cv::Quat::power
friend Quat< T > power(const Quat< T > &q, const T x, QuatAssumeType assumeUnit)
返回指數為 的冪函式值。

◆ 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); //此 assumeUnit 表示 p 是單位四元數

◆ sin()

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

返回此四元數的正弦值，正弦可以計算為

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

透過球面線性插值（Slerp）計算 \(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用於球面線性插值的四元數。
q1用於球面線性插值的四元數。
t在 [0, 1] 範圍內，\(q_0\) 和 \(q_1\) 之間角度的百分比。
assumeUnit如果 QUAT_ASSUME_UNIT 為真，則假定所有輸入四元數為單位四元數。否則，所有輸入四元數將在函式內部歸一化。
directChange如果 QUAT_ASSUME_UNIT 為真，則插值將選擇最近的路徑。
注意
如果插值角度很小，Nlerp 和 Slerp 之間的誤差不會太大。為了提高效率並避免零除錯誤，我們使用 Nlerp 而不是 Slerp。

◆ 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

計算透過 squad 構造的 \(C^1\) 連續樣條曲線在比率 t 處的四元數結果。這裡，插值在 \(q_1\) 和 \(q_2\) 之間。\(q_0\) 和 \(q_2\) 用於確保 \(C^1\) 連續性。如果 t = 0，它返回 \(q_1\)；如果 t = 1，它返回 \(q_2\)。

引數
q0第一個輸入四元數，用於確保 \(C^1\) 連續性。
q1第二個輸入四元數。
q2第三個輸入四元數。
q3第四個輸入四元數，與 \(q1\) 的用法相同。
t在 [0, 1] 範圍內的比率。
assumeUnit如果 QUAT_ASSUME_UNIT 為真，則假定 \(q_0, q_1, q_2, q_3\) 為單位四元數。否則，所有輸入四元數將在函式內部歸一化。

例如

如果存在三個雙精度四元數 \(v_0, v_1, v_2\) 等待插值。

使用比率 \(t_0\) 在 \(v_0\) 和 \(v_1\) 之間進行插值可以計算為：

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

使用比率 \(t_0\) 在 \(v_1\) 和 \(v_2\) 之間進行插值可以計算為：

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); //此 assumeUnit 表示 q 是單位四元數

◆ 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

透過球面和四邊形（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\) 需要由三個四元數計算。

引數
q0第一個四元數。
s0第二個四元數。
s1第三個四元數。
q1第四個四元數。
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(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(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 尤拉角型別)

將四元數 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 \) 是尤拉角的三個角度，旋轉矩陣 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 \)，透過比較兩個矩陣的每個元素，解為 \(\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（尤拉角型別）普通情況\(\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（尤拉角型別）普通情況\(\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}) \)
引數
尤拉角型別轉換的尤拉角型別

◆ 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]。點矩陣 A 可以透過 toRotMat3x3() * A 進行旋轉。結果也具有 3 行 n 列。

例如

double angle = CV_PI;
Vec3d axis{0,0,1};
Quatd q_unit = Quatd::createFromAngleAxis(angle, axis); //四元數也可以透過兩個或更多四元數的插值獲得。
// 假設有兩個點 (1,0,0) 和 (1,0,1) 待旋轉
Mat pointsA = (Mat_<double>(2, 3) << 1,0,0,1,0,1);
// 改變形狀
pointsA = pointsA.t();
// 繞 z 軸旋轉 180 度
Mat new_point = q_unit.toRotMat3x3() * pointsA;
// 列印兩個點
cout << new_point << endl;
cv::Mat_
從 Mat 派生的模板矩陣類。
定義 mat.hpp:2257
cv::Mat
n 維密集陣列類
定義 mat.hpp:830
cv::Mat::t
MatExpr t() const
轉置矩陣。
cv::Quat::toRotMat3x3
Matx< _Tp, 3, 3 > toRotMat3x3(QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
將四元數轉換為 3x3 旋轉矩陣。

◆ 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); //結果與 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();

友元和相關符號文件

◆ acos

template<typename _Tp >
template<typename T >
Quat< T > acos ( const Quat< T > & q)
friend

返回四元數 q 的反餘弦值，反餘弦可以計算為

\[\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
friend Quat< T > acos(const Quat< T > &q)
返回四元數 q 的反餘弦值，反餘弦可以計算為

◆ acosh

template<typename _Tp >
template<typename T >
Quat< T > acosh ( const Quat< T > & q)
friend

返回四元數 q 的反雙曲餘弦值，反雙曲餘弦可以計算為

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

.

引數
q一個四元數。

例如

Quatd q(1,2,3,4);
acosh(q);
cv::Quat::acosh
friend Quat< T > acosh(const Quat< T > &q)
返回四元數 q 的反雙曲餘弦值，反雙曲餘弦可以計算為

◆ asin

template<typename _Tp >
template<typename T >
Quat< T > asin ( const Quat< T > & q)
friend

返回四元數 q 的反正弦值，反正弦可以計算為

\[\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
friend Quat< T > asin(const Quat< T > &q)
返回四元數 q 的反正弦值，反正弦可以計算為

◆ asinh

template<typename _Tp >
template<typename T >
Quat< T > asinh ( const Quat< T > & q)
friend

返回四元數 q 的反雙曲正弦值，反雙曲正弦可以計算為

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

.

引數
q一個四元數。

例如

Quatd q(1,2,3,4);
asinh(q);
cv::Quat::asinh
friend Quat< T > asinh(const Quat< T > &q)
返回四元數 q 的反雙曲正弦值，反雙曲正弦可以計算為

◆ atan

template<typename _Tp >
template<typename T >
Quat< T > atan ( const Quat< T > & q)
friend

返回四元數 q 的反正切值，反正切可以計算為

\[\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
friend Quat< T > atan(const Quat< T > &q)
返回四元數 q 的反正切值，反正切可以計算為

◆ atanh

template<typename _Tp >
template<typename T >
Quat< T > atanh ( const Quat< T > & q)
friend

返回四元數 q 的反雙曲正切值，反雙曲正切可以計算為

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

.

引數
q一個四元數。

例如

Quatd q(1,2,3,4);
atanh(q);
cv::Quat::atanh
friend Quat< T > atanh(const Quat< T > &q)
返回四元數 q 的反雙曲正切值，反雙曲正切可以計算為

◆ cos

template<typename _Tp >
template<typename T >
Quat< T > cos ( const Quat< T > & q)
friend

返回四元數 q 的餘弦值，餘弦可以計算為

\[\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
friend Quat< T > cos(const Quat< T > &q)
返回四元數 q 的餘弦值，餘弦可以計算為

◆ cosh

template<typename _Tp >
template<typename T >
Quat< T > cosh ( const Quat< T > & q)
friend

返回四元數 q 的雙曲餘弦值，雙曲餘弦可以計算為

\[\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
friend Quat< T > cosh(const Quat< T > &q)
返回四元數 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})\) 之間的叉積。

\[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^{-1}\)，它是 \(q\) 的逆，滿足 \(q * q^{-1} = 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);// 此 assumeUnit 表示 p 是一個單位四元數
cv::Quat::inv
friend Quat< T > inv(const Quat< T > &q, QuatAssumeType assumeUnit)
返回 的逆，滿足 。

◆ 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;
cv::Quat::log
friend Quat< T > log(const Quat< T > &q, QuatAssumeType assumeUnit)
返回對數函式的值。

◆ 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); // 此 assumeUnit 表示 p 是一個單位四元數

◆ 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); //透過軸和角度生成單位四元數
power(q1, 2.0, assumeUnit);// 此 assumeUnit 表示 q1 是一個單位四元數。
注意
索引的型別應與四元數相同。

◆ sin

template<typename _Tp >
template<typename T >
Quat< T > sin ( const Quat< T > & q)
friend

返回四元數 q 的正弦值，正弦可以計算為

\[\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
friend Quat< T > sin(const Quat< T > &q)
返回四元數 q 的正弦值，正弦可以計算為

◆ sinh

template<typename _Tp >
template<typename T >
Quat< T > sinh ( const Quat< T > & q)
friend

返回四元數 q 的雙曲正弦值，雙曲正弦可以計算為

\[\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
friend Quat< T > sinh(const Quat< T > &q)
返回四元數 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); // 此 assumeUnit 表示 q 是一個單位四元數。
cv::Quat::sqrt
friend Quat< T > sqrt(const Quat< T > &q, QuatAssumeType assumeUnit)
返回。

◆ tan

template<typename _Tp >
template<typename T >
Quat< T > tan ( const Quat< T > & q)
friend

返回四元數 q 的正切值，正切可以計算為

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

引數
q一個四元數。

例如

Quatd q(1,2,3,4);
tan(q);
cv::Quat::tan
friend Quat< T > tan(const Quat< T > &q)
返回四元數 q 的正切值，正切可以計算為

◆ tanh

template<typename _Tp >
template<typename T >
Quat< T > tanh ( const Quat< T > & q)
friend

返回四元數 q 的雙曲正切值，雙曲正切可以計算為

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

引數
q一個四元數。

例如

Quatd q(1,2,3,4);
tanh(q);
cv::Quat::tanh
friend Quat< T > tanh(const Quat< T > &q)
返回四元數 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
此類的文件生成自以下檔案
於 2025 年 7 月 3 日星期四 12:14:37 為 OpenCV 生成，由  doxygen 1.12.0