OpenCV 4.5.3(日本語機械翻訳)
quaternion.hpp
1 // This file is part of OpenCV project.
2 // It is subject to the license terms in the LICENSE file found in the top-level directory
3 // of this distribution and at http://opencv.org/license.html.
4 //
5 //
6 // License Agreement
7 // For Open Source Computer Vision Library
8 //
9 // Copyright (C) 2020, Huawei Technologies Co., Ltd. All rights reserved.
10 // Third party copyrights are property of their respective owners.
11 //
12 // Licensed under the Apache License, Version 2.0 (the "License");
13 // you may not use this file except in compliance with the License.
14 // You may obtain a copy of the License at
15 //
16 // http://www.apache.org/licenses/LICENSE-2.0
17 //
18 // Unless required by applicable law or agreed to in writing, software
19 // distributed under the License is distributed on an "AS IS" BASIS,
20 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
21 // See the License for the specific language governing permissions and
22 // limitations under the License.
23 //
24 // Author: Liangqian Kong <chargerKong@126.com>
25 // Longbu Wang <riskiest@gmail.com>
26 #ifndef OPENCV_CORE_QUATERNION_HPP
27 #define OPENCV_CORE_QUATERNION_HPP
28
29 #include <opencv2/core.hpp>
30 #include <opencv2/core/utils/logger.hpp>
31 #include <iostream>
32 namespace cv
33{
36
38 enum QuatAssumeType
39{
46 QUAT_ASSUME_NOT_UNIT,
52 QUAT_ASSUME_UNIT
53 };
54
55 class QuatEnum
56{
57 public:
98 enum EulerAnglesType
99 {
100 INT_XYZ,
101 INT_XZY,
102 INT_YXZ,
103 INT_YZX,
104 INT_ZXY,
105 INT_ZYX,
106 INT_XYX,
107 INT_XZX,
108 INT_YXY,
109 INT_YZY,
110 INT_ZXZ,
111 INT_ZYZ,
112
113 EXT_XYZ,
114 EXT_XZY,
115 EXT_YXZ,
116 EXT_YZX,
117 EXT_ZXY,
118 EXT_ZYX,
119 EXT_XYX,
120 EXT_XZX,
121 EXT_YXY,
122 EXT_YZY,
123 EXT_ZXZ,
124 EXT_ZYZ,
125 #ifndef CV_DOXYGEN
126 EULER_ANGLES_MAX_VALUE
127 #endif
128 };
129
130};
131
132 template <typename _Tp> class Quat;
133 template <typename _Tp> std::ostream& operator<<(std::ostream&, const Quat<_Tp>&);
134
209 template <typename _Tp>
210 class Quat
211{
212 static_assert(std::is_floating_point<_Tp>::value, "Quaternion only make sense with type of float or double");
213 using value_type = _Tp;
214 public:
215 static constexpr _Tp CV_QUAT_EPS = (_Tp)1.e-6;
216 static constexpr _Tp CV_QUAT_CONVERT_THRESHOLD = (_Tp)1.e-6;
217
218 Quat();
219
223 explicit Quat(const Vec<_Tp, 4> &coeff);
224
228 Quat(_Tp w, _Tp x, _Tp y, _Tp z);
229
236 static Quat<_Tp> createFromAngleAxis(const _Tp angle, const Vec<_Tp, 3> &axis);
237
241 static Quat<_Tp> createFromRotMat(InputArray R);
242
261 static Quat<_Tp> createFromRvec(InputArray rvec);
262
278 static Quat<_Tp> createFromEulerAngles(const Vec<_Tp, 3> &angles, QuatEnum::EulerAnglesType eulerAnglesType);
279
284 static Quat<_Tp> createFromYRot(const _Tp theta);
285
290 static Quat<_Tp> createFromXRot(const _Tp theta);
291
296 static Quat<_Tp> createFromZRot(const _Tp theta);
297
312 _Tp at(size_t index) const;
313
318 Quat<_Tp> conjugate() const;
319
333 template <typename T>
334 friend Quat<T> exp(const Quat<T> &q);
335
347 Quat<_Tp> exp() const;
348
362 template <typename T>
363 friend Quat<T> log(const Quat<T> &q, QuatAssumeType assumeUnit);
364
381 Quat<_Tp> log(QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const;
382
403 template <typename T>
404 friend Quat<T> power(const Quat<T> &q, const T x, QuatAssumeType assumeUnit);
405
424 Quat<_Tp> power(const _Tp x, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const;
425
441 template <typename T>
442 friend Quat<T> sqrt(const Quat<T> &q, QuatAssumeType assumeUnit);
443
458 Quat<_Tp> sqrt(QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const;
459
478 template <typename T>
479 friend Quat<T> power(const Quat<T> &p, const Quat<T> &q, QuatAssumeType assumeUnit);
480
498 Quat<_Tp> power(const Quat<_Tp> &q, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const;
499
513 template <typename T>
514 friend Quat<T> crossProduct(const Quat<T> &p, const Quat<T> &q);
515
529 Quat<_Tp> crossProduct(const Quat<_Tp> &q) const;
530
535 _Tp norm() const;
536
542 Quat<_Tp> normalize() const;
543
560 template <typename T>
561 friend Quat<T> inv(const Quat<T> &q, QuatAssumeType assumeUnit);
562
578 Quat<_Tp> inv(QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const;
579
592 template <typename T>
593 friend Quat<T> sinh(const Quat<T> &q);
594
606 Quat<_Tp> sinh() const;
607
620 template <typename T>
621 friend Quat<T> cosh(const Quat<T> &q);
622
634 Quat<_Tp> cosh() const;
635
648 template <typename T>
649 friend Quat<T> tanh(const Quat<T> &q);
650
662 Quat<_Tp> tanh() const;
663
676 template <typename T>
677 friend Quat<T> sin(const Quat<T> &q);
678
690 Quat<_Tp> sin() const;
691
704 template <typename T>
705 friend Quat<T> cos(const Quat<T> &q);
706
718 Quat<_Tp> cos() const;
719
731 template <typename T>
732 friend Quat<T> tan(const Quat<T> &q);
733
744 Quat<_Tp> tan() const;
745
758 template <typename T>
759 friend Quat<T> asin(const Quat<T> &q);
760
772 Quat<_Tp> asin() const;
773
786 template <typename T>
787 friend Quat<T> acos(const Quat<T> &q);
788
800 Quat<_Tp> acos() const;
801
814 template <typename T>
815 friend Quat<T> atan(const Quat<T> &q);
816
828 Quat<_Tp> atan() const;
829
841 template <typename T>
842 friend Quat<T> asinh(const Quat<T> &q);
843
854 Quat<_Tp> asinh() const;
855
867 template <typename T>
868 friend Quat<T> acosh(const Quat<T> &q);
869
880 Quat<_Tp> acosh() const;
881
893 template <typename T>
894 friend Quat<T> atanh(const Quat<T> &q);
895
906 Quat<_Tp> atanh() const;
907
915 bool isNormal(_Tp eps=CV_QUAT_EPS) const;
916
922 void assertNormal(_Tp eps=CV_QUAT_EPS) const;
923
956 Matx<_Tp, 3, 3> toRotMat3x3(QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const;
957
976 Matx<_Tp, 4, 4> toRotMat4x4(QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const;
977
987 Vec<_Tp, 4> toVec() const;
988
1006 Vec<_Tp, 3> toRotVec(QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const;
1007
1024 _Tp getAngle(QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const;
1025
1051 Vec<_Tp, 3> getAxis(QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const;
1052
1072 _Tp dot(Quat<_Tp> q) const;
1073
1086 static Quat<_Tp> lerp(const Quat<_Tp> &q0, const Quat &q1, const _Tp t);
1087
1100 static Quat<_Tp> nlerp(const Quat<_Tp> &q0, const Quat &q1, const _Tp t, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT);
1101
1118 static Quat<_Tp> slerp(const Quat<_Tp> &q0, const Quat &q1, const _Tp t, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT, bool directChange=true);
1119
1140 static Quat<_Tp> squad(const Quat<_Tp> &q0, const Quat<_Tp> &s0,
1141 const Quat<_Tp> &s1, const Quat<_Tp> &q1,
1142 const _Tp t, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT,
1143 bool directChange=true);
1144
1156 static Quat<_Tp> interPoint(const Quat<_Tp> &q0, const Quat<_Tp> &q1,
1157 const Quat<_Tp> &q2, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT);
1158
1186 static Quat<_Tp> spline(const Quat<_Tp> &q0, const Quat<_Tp> &q1,
1187 const Quat<_Tp> &q2, const Quat<_Tp> &q3,
1188 const _Tp t, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT);
1189
1200 Quat<_Tp> operator-() const;
1201
1206 bool operator==(const Quat<_Tp>&) const;
1207
1219 Quat<_Tp> operator+(const Quat<_Tp>&) const;
1220
1234 Quat<_Tp>& operator+=(const Quat<_Tp>&);
1235
1247 Quat<_Tp> operator-(const Quat<_Tp>&) const;
1248
1262 Quat<_Tp>& operator-=(const Quat<_Tp>&);
1263
1287 Quat<_Tp>& operator*=(const Quat<_Tp>&);
1288
1312 Quat<_Tp>& operator*=(const _Tp s);
1313
1336 Quat<_Tp> operator*(const Quat<_Tp>&) const;
1337
1361 Quat<_Tp> operator/(const _Tp s) const;
1362
1383 Quat<_Tp> operator/(const Quat<_Tp>&) const;
1384
1408 Quat<_Tp>& operator/=(const _Tp s);
1409
1431 Quat<_Tp>& operator/=(const Quat<_Tp>&);
1432
1433 _Tp& operator[](std::size_t n);
1434
1435 const _Tp& operator[](std::size_t n) const;
1436
1449 template <typename T>
1450 friend Quat<T> cv::operator-(const T s, const Quat<T>&);
1451
1464 template <typename T>
1465 friend Quat<T> cv::operator-(const Quat<T>&, const T s);
1466
1479 template <typename T>
1480 friend Quat<T> cv::operator+(const T s, const Quat<T>&);
1481
1494 template <typename T>
1495 friend Quat<T> cv::operator+(const Quat<T>&, const T s);
1496
1519 template <typename T>
1520 friend Quat<T> cv::operator*(const T s, const Quat<T>&);
1521
1544 template <typename T>
1545 friend Quat<T> cv::operator*(const Quat<T>&, const T s);
1546
1547 template <typename S>
1548 friend std::ostream& cv::operator<<(std::ostream&, const Quat<S>&);
1549
1616 Vec<_Tp, 3> toEulerAngles(QuatEnum::EulerAnglesType eulerAnglesType);
1617
1618 _Tp w, x, y, z;
1619
1620};
1621
1622 template <typename T>
1623 Quat<T> inv(const Quat<T> &q, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT);
1624
1625 template <typename T>
1626 Quat<T> sinh(const Quat<T> &q);
1627
1628 template <typename T>
1629 Quat<T> cosh(const Quat<T> &q);
1630
1631 template <typename T>
1632 Quat<T> tanh(const Quat<T> &q);
1633
1634 template <typename T>
1635 Quat<T> sin(const Quat<T> &q);
1636
1637 template <typename T>
1638 Quat<T> cos(const Quat<T> &q);
1639
1640 template <typename T>
1641 Quat<T> tan(const Quat<T> &q);
1642
1643 template <typename T>
1644 Quat<T> asinh(const Quat<T> &q);
1645
1646 template <typename T>
1647 Quat<T> acosh(const Quat<T> &q);
1648
1649 template <typename T>
1650 Quat<T> atanh(const Quat<T> &q);
1651
1652 template <typename T>
1653 Quat<T> asin(const Quat<T> &q);
1654
1655 template <typename T>
1656 Quat<T> acos(const Quat<T> &q);
1657
1658 template <typename T>
1659 Quat<T> atan(const Quat<T> &q);
1660
1661 template <typename T>
1662 Quat<T> power(const Quat<T> &q, const Quat<T> &p, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT);
1663
1664 template <typename T>
1665 Quat<T> exp(const Quat<T> &q);
1666
1667 template <typename T>
1668 Quat<T> log(const Quat<T> &q, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT);
1669
1670 template <typename T>
1671 Quat<T> power(const Quat<T>& q, const T x, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT);
1672
1673 template <typename T>
1674 Quat<T> crossProduct(const Quat<T> &p, const Quat<T> &q);
1675
1676 template <typename S>
1677 Quat<S> sqrt(const Quat<S> &q, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT);
1678
1679 template <typename T>
1680 Quat<T> operator*(const T, const Quat<T>&);
1681
1682 template <typename T>
1683 Quat<T> operator*(const Quat<T>&, const T);
1684
1685 template <typename S>
1686std::ostream& operator<<(std::ostream&, const Quat<S>&);
1687
1688 using Quatd = Quat<double>;
1689 using Quatf = Quat<float>;
1690
1692}
1693
1694 #include "opencv2/core/quaternion.inl.hpp"
1695
1696 #endif /* OPENCV_CORE_QUATERNION_HPP */
cv::Matx
Template class for small matrices whose type and size are known at compilation time
Definition: matx.hpp:100
cv::QuatEnum
Definition: quaternion.hpp:56
cv::QuatEnum::EulerAnglesType
EulerAnglesType
Enum of Euler angles type.
Definition: quaternion.hpp:99
cv::QuatEnum::INT_XYZ
@ INT_XYZ
Intrinsic rotations with the Euler angles type X-Y-Z
Definition: quaternion.hpp:100
cv::QuatEnum::EXT_YXZ
@ EXT_YXZ
Extrinsic rotations with the Euler angles type Y-X-Z
Definition: quaternion.hpp:115
cv::QuatEnum::INT_XZY
@ INT_XZY
Intrinsic rotations with the Euler angles type X-Z-Y
Definition: quaternion.hpp:101
cv::QuatEnum::EXT_YZX
@ EXT_YZX
Extrinsic rotations with the Euler angles type Y-Z-X
Definition: quaternion.hpp:116
cv::QuatEnum::INT_XZX
@ INT_XZX
Intrinsic rotations with the Euler angles type X-Z-X
Definition: quaternion.hpp:107
cv::QuatEnum::INT_ZYZ
@ INT_ZYZ
Intrinsic rotations with the Euler angles type Z-Y-Z
Definition: quaternion.hpp:111
cv::QuatEnum::EXT_ZXY
@ EXT_ZXY
Extrinsic rotations with the Euler angles type Z-X-Y
Definition: quaternion.hpp:117
cv::QuatEnum::INT_YZY
@ INT_YZY
Intrinsic rotations with the Euler angles type Y-Z-Y
Definition: quaternion.hpp:109
cv::QuatEnum::INT_YXZ
@ INT_YXZ
Intrinsic rotations with the Euler angles type Y-X-Z
Definition: quaternion.hpp:102
cv::QuatEnum::INT_XYX
@ INT_XYX
Intrinsic rotations with the Euler angles type X-Y-X
Definition: quaternion.hpp:106
cv::QuatEnum::EXT_YXY
@ EXT_YXY
Extrinsic rotations with the Euler angles type Y-X-Y
Definition: quaternion.hpp:121
cv::QuatEnum::INT_ZXY
@ INT_ZXY
Intrinsic rotations with the Euler angles type Z-X-Y
Definition: quaternion.hpp:104
cv::QuatEnum::EXT_ZXZ
@ EXT_ZXZ
Extrinsic rotations with the Euler angles type Z-X-Z
Definition: quaternion.hpp:123
cv::QuatEnum::EXT_ZYX
@ EXT_ZYX
Extrinsic rotations with the Euler angles type Z-Y-X
Definition: quaternion.hpp:118
cv::QuatEnum::EXT_YZY
@ EXT_YZY
Extrinsic rotations with the Euler angles type Y-Z-Y
Definition: quaternion.hpp:122
cv::QuatEnum::EXT_ZYZ
@ EXT_ZYZ
Extrinsic rotations with the Euler angles type Z-Y-Z
Definition: quaternion.hpp:124
cv::QuatEnum::INT_ZXZ
@ INT_ZXZ
Intrinsic rotations with the Euler angles type Z-X-Z
Definition: quaternion.hpp:110
cv::QuatEnum::EXT_XZX
@ EXT_XZX
Extrinsic rotations with the Euler angles type X-Z-X
Definition: quaternion.hpp:120
cv::QuatEnum::EXT_XYZ
@ EXT_XYZ
Extrinsic rotations with the Euler angles type X-Y-Z
Definition: quaternion.hpp:113
cv::QuatEnum::INT_ZYX
@ INT_ZYX
Intrinsic rotations with the Euler angles type Z-Y-X
Definition: quaternion.hpp:105
cv::QuatEnum::INT_YZX
@ INT_YZX
Intrinsic rotations with the Euler angles type Y-Z-X
Definition: quaternion.hpp:103
cv::QuatEnum::EXT_XYX
@ EXT_XYX
Extrinsic rotations with the Euler angles type X-Y-X
Definition: quaternion.hpp:119
cv::QuatEnum::EXT_XZY
@ EXT_XZY
Extrinsic rotations with the Euler angles type X-Z-Y
Definition: quaternion.hpp:114
cv::QuatEnum::INT_YXY
@ INT_YXY
Intrinsic rotations with the Euler angles type Y-X-Y
Definition: quaternion.hpp:108
cv::Quat
Definition: quaternion.hpp:211
cv::Quat::cosh
Quat< _Tp > cosh() const
return cosh value of this quaternion, cosh could be calculated as:
cv::Quat::dot
_Tp dot(Quat< _Tp > q) const
return the dot between quaternion and this quaternion.
cv::Quat::createFromRvec
static Quat< _Tp > createFromRvec(InputArray rvec)
from a rotation vector has the form , where represents rotation angle and represents normalized ro...
cv::Quat::createFromZRot
static Quat< _Tp > createFromZRot(const _Tp theta)
get a quaternion from a rotation about the Z-axis by .
cv::Quat::cosh
friend Quat< T > cosh(const Quat< T > &q)
return cosh value of quaternion q, cosh could be calculated as:
cv::Quat::createFromYRot
static Quat< _Tp > createFromYRot(const _Tp theta)
get a quaternion from a rotation about the Y-axis by .
cv::Quat::conjugate
Quat< _Tp > conjugate() const
return the conjugate of this quaternion.
cv::Quat::operator==
bool operator==(const Quat< _Tp > &) const
return true if two quaternions p and q are nearly equal, i.e. when the absolute value of each and i...
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)
to calculate a quaternion which is the result of a continuous spline curve constructed by squad at t...
cv::Quat::tanh
friend Quat< T > tanh(const Quat< T > &q)
return tanh value of quaternion q, tanh could be calculated as:
cv::Quat::power
friend Quat< T > power(const Quat< T > &q, const T x, QuatAssumeType assumeUnit)
return the value of power function with index .
cv::Quat::operator*
Quat< _Tp > operator*(const Quat< _Tp > &) const
Multiplication operator of two quaternions q and p. Multiplies values on either side of the operator.
cv::Quat::asinh
Quat< _Tp > asinh() const
return arcsinh value of this quaternion, arcsinh could be calculated as:
cv::Quat::acosh
Quat< _Tp > acosh() const
return arccosh value of this quaternion, arccosh could be calculated as:
cv::Quat::createFromEulerAngles
static Quat< _Tp > createFromEulerAngles(const Vec< _Tp, 3 > &angles, QuatEnum::EulerAnglesType eulerAnglesType)
from Euler angles
cv::Quat::createFromXRot
static Quat< _Tp > createFromXRot(const _Tp theta)
get a quaternion from a rotation about the X-axis by .
cv::Quat::getAngle
_Tp getAngle(QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
get the angle of quaternion, it returns the rotation angle.
cv::Quat::power
Quat< _Tp > power(const Quat< _Tp > &q, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
return the value of power function with quaternion .
cv::Quat::getAxis
Vec< _Tp, 3 > getAxis(QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
get the axis of quaternion, it returns a vector of length 3.
cv::Quat::sin
friend Quat< T > sin(const Quat< T > &q)
return tanh value of quaternion q, sin could be calculated as:
cv::Quat::exp
Quat< _Tp > exp() const
return the value of exponential value.
cv::Quat::log
friend Quat< T > log(const Quat< T > &q, QuatAssumeType assumeUnit)
return the value of logarithm function.
cv::Quat::createFromRotMat
static Quat< _Tp > createFromRotMat(InputArray R)
from a 3x3 rotation matrix.
cv::Quat::operator/=
Quat< _Tp > & operator/=(const Quat< _Tp > &)
Division assignment operator of two quaternions p and q; It divides left operand with the right opera...
cv::Quat::operator*=
Quat< _Tp > & operator*=(const _Tp s)
Multiplication assignment operator of a quaternions and a scalar. It multiplies right operand with th...
cv::Quat::toRotMat4x4
Matx< _Tp, 4, 4 > toRotMat4x4(QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
transform a quaternion to a 4x4 rotation matrix.
cv::Quat::tan
Quat< _Tp > tan() const
return tan value of this quaternion, tan could be calculated as:
cv::Quat::sqrt
Quat< _Tp > sqrt(QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
return .
cv::Quat::atan
Quat< _Tp > atan() const
return arctan value of this quaternion, arctan could be calculated as:
cv::Quat::operator-
Quat< _Tp > operator-(const Quat< _Tp > &) const
Subtraction operator of two quaternions p and q. It returns a new quaternion that each value is the s...
cv::Quat::operator-=
Quat< _Tp > & operator-=(const Quat< _Tp > &)
Subtraction assignment operator of two quaternions p and q. It subtracts right operand from the left ...
cv::Quat::operator*=
Quat< _Tp > & operator*=(const Quat< _Tp > &)
Multiplication assignment operator of two quaternions q and p. It multiplies right operand with the l...
cv::Quat::sinh
Quat< _Tp > sinh() const
return sinh value of this quaternion, sinh could be calculated as: where
cv::Quat::isNormal
bool isNormal(_Tp eps=CV_QUAT_EPS) const
return true if this quaternion is a unit quaternion.
cv::Quat::toEulerAngles
Vec< _Tp, 3 > toEulerAngles(QuatEnum::EulerAnglesType eulerAnglesType)
Transform a quaternion q to Euler angles.
cv::Quat::toVec
Vec< _Tp, 4 > toVec() const
transform the this quaternion to a Vec<T, 4>.
cv::Quat::crossProduct
Quat< _Tp > crossProduct(const Quat< _Tp > &q) const
return the crossProduct between and .
cv::Quat::asin
Quat< _Tp > asin() const
return arcsin value of this quaternion, arcsin could be calculated as:
cv::Quat::operator+=
Quat< _Tp > & operator+=(const Quat< _Tp > &)
Addition assignment operator of two quaternions p and q. It adds right operand to the left operand an...
cv::Quat::atanh
friend Quat< T > atanh(const Quat< T > &q)
return arctanh value of quaternion q, arctanh could be calculated as:
cv::Quat::normalize
Quat< _Tp > normalize() const
return a normalized .
cv::Quat::sinh
friend Quat< T > sinh(const Quat< T > &q)
return sinh value of quaternion q, sinh could be calculated as:
cv::Quat::power
Quat< _Tp > power(const _Tp x, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
return the value of power function with index .
cv::Quat::squad
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)
To calculate the interpolation between , , , by Spherical and quadrangle(Squad). This could be defin...
cv::Quat::acosh
friend Quat< T > acosh(const Quat< T > &q)
return arccosh value of quaternion q, arccosh could be calculated as:
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)
To calculate the interpolation between and by Spherical Linear Interpolation(Slerp),...
cv::Quat::atan
friend Quat< T > atan(const Quat< T > &q)
return arctan value of quaternion q, arctan could be calculated as:
cv::Quat::inv
friend Quat< T > inv(const Quat< T > &q, QuatAssumeType assumeUnit)
return which is an inverse of which satisfies .
cv::Quat::acos
Quat< _Tp > acos() const
return arccos value of this quaternion, arccos could be calculated as:
cv::Quat::nlerp
static Quat< _Tp > nlerp(const Quat< _Tp > &q0, const Quat &q1, const _Tp t, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
To calculate the interpolation from to by Normalized Linear Interpolation(Nlerp)....
cv::Quat::exp
friend Quat< T > exp(const Quat< T > &q)
return the value of exponential value.
cv::Quat::cos
Quat< _Tp > cos() const
return cos value of this quaternion, cos could be calculated as:
cv::Quat::log
Quat< _Tp > log(QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
return the value of logarithm function.
cv::Quat::tanh
Quat< _Tp > tanh() const
return tanh value of this quaternion, tanh could be calculated as:
cv::Quat::operator+
Quat< _Tp > operator+(const Quat< _Tp > &) const
Addition operator of two quaternions p and q. It returns a new quaternion that each value is the sum ...
cv::Quat::interPoint
static Quat< _Tp > interPoint(const Quat< _Tp > &q0, const Quat< _Tp > &q1, const Quat< _Tp > &q2, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
This is the part calculation of squad. To calculate the intermedia quaternion between each three qua...
cv::Quat::tan
friend Quat< T > tan(const Quat< T > &q)
return tan value of quaternion q, tan could be calculated as:
cv::Quat::lerp
static Quat< _Tp > lerp(const Quat< _Tp > &q0, const Quat &q1, const _Tp t)
To calculate the interpolation from to by Linear Interpolation(Nlerp) For two quaternions,...
cv::Quat::norm
_Tp norm() const
return the norm of quaternion.
cv::Quat::assertNormal
void assertNormal(_Tp eps=CV_QUAT_EPS) const
to throw an error if this quaternion is not a unit quaternion.
cv::Quat::operator-
Quat< _Tp > operator-() const
Return opposite quaternion which satisfies
cv::Quat::Quat
Quat(_Tp w, _Tp x, _Tp y, _Tp z)
from four numbers.
cv::Quat::sin
Quat< _Tp > sin() const
return sin value of this quaternion, sin could be calculated as:
cv::Quat::asinh
friend Quat< T > asinh(const Quat< T > &q)
return arcsinh value of quaternion q, arcsinh could be calculated as:
cv::Quat::sqrt
friend Quat< T > sqrt(const Quat< T > &q, QuatAssumeType assumeUnit)
return .
cv::Quat::Quat
Quat(const Vec< _Tp, 4 > &coeff)
From Vec4d or Vec4f.
cv::Quat::inv
Quat< _Tp > inv(QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
return which is an inverse of satisfying .
cv::Quat::acos
friend Quat< T > acos(const Quat< T > &q)
return arccos value of quaternion q, arccos could be calculated as:
cv::Quat::toRotMat3x3
Matx< _Tp, 3, 3 > toRotMat3x3(QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
transform a quaternion to a 3x3 rotation matrix.
cv::Quat::operator/=
Quat< _Tp > & operator/=(const _Tp s)
Division assignment operator of a quaternions and a scalar. It divides left operand with the right op...
cv::Quat::atanh
Quat< _Tp > atanh() const
return arctanh value of this quaternion, arctanh could be calculated as:
cv::Quat::crossProduct
friend Quat< T > crossProduct(const Quat< T > &p, const Quat< T > &q)
return the crossProduct between and .
cv::Quat::cos
friend Quat< T > cos(const Quat< T > &q)
return sin value of quaternion q, cos could be calculated as:
cv::Quat::toRotVec
Vec< _Tp, 3 > toRotVec(QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const
transform this quaternion to a Rotation vector.
cv::Quat::at
_Tp at(size_t index) const
a way to get element.
cv::Quat::asin
friend Quat< T > asin(const Quat< T > &q)
return arcsin value of quaternion q, arcsin could be calculated as:
cv::Quat::power
friend Quat< T > power(const Quat< T > &p, const Quat< T > &q, QuatAssumeType assumeUnit)
return the value of power function with quaternion .
cv::Quat::operator/
Quat< _Tp > operator/(const Quat< _Tp > &) const
Division operator of two quaternions p and q. Divides left hand operand by right hand operand.
cv::Quat::createFromAngleAxis
static Quat< _Tp > createFromAngleAxis(const _Tp angle, const Vec< _Tp, 3 > &axis)
from an angle, axis. Axis will be normalized in this function. And it generates
cv::Quat::operator/
Quat< _Tp > operator/(const _Tp s) const
Division operator of a quaternions and a scalar. It divides left operand with the right operand and a...
cv::sqrt
CV_EXPORTS_W void sqrt(InputArray src, OutputArray dst)
Calculates a square root of array elements.
cv::exp
CV_EXPORTS_W void exp(InputArray src, OutputArray dst)
Calculates the exponent of every array element.
cv::log
CV_EXPORTS_W void log(InputArray src, OutputArray dst)
Calculates the natural logarithm of every array element.
cv::tan
Quat< T > tan(const Quat< T > &q)
cv::asinh
Quat< T > asinh(const Quat< T > &q)
cv::asin
Quat< T > asin(const Quat< T > &q)
cv::tanh
Quat< T > tanh(const Quat< T > &q)
cv::crossProduct
Quat< T > crossProduct(const Quat< T > &p, const Quat< T > &q)
cv::acosh
Quat< T > acosh(const Quat< T > &q)
cv::atanh
Quat< T > atanh(const Quat< T > &q)
cv::cos
Quat< T > cos(const Quat< T > &q)
cv::sinh
Quat< T > sinh(const Quat< T > &q)
cv::QuatAssumeType
QuatAssumeType
Unit quaternion flag
Definition: quaternion.hpp:39
cv::cosh
Quat< T > cosh(const Quat< T > &q)
cv::atan
Quat< T > atan(const Quat< T > &q)
cv::sin
Quat< T > sin(const Quat< T > &q)
cv::acos
Quat< T > acos(const Quat< T > &q)
cv::QUAT_ASSUME_NOT_UNIT
@ QUAT_ASSUME_NOT_UNIT
Definition: quaternion.hpp:46
cv::QUAT_ASSUME_UNIT
@ QUAT_ASSUME_UNIT
Definition: quaternion.hpp:52
cv
"black box" representation of the file storage associated with a file on disk.
Definition: aruco.hpp:75
cv::inv
DualQuat< T > inv(const DualQuat< T > &dq, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
Definition: dualquaternion.inl.hpp:187
cv::power
DualQuat< T > power(const DualQuat< T > &dq, const T t, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
Definition: dualquaternion.inl.hpp:358
構築: doxygen 1.9.2