react-native-executorch 0.4.7 → 0.5.0

package/third-party/include/opencv2/core/quaternion.hpp

@@ -0,0 +1,1889 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level
+// directory of this distribution and at http://opencv.org/license.html.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2020, Huawei Technologies Co., Ltd. All rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Author: Liangqian Kong <chargerKong@126.com>
+//         Longbu Wang <riskiest@gmail.com>
+#ifndef OPENCV_CORE_QUATERNION_HPP
+#define OPENCV_CORE_QUATERNION_HPP
+
+#include <iostream>
+#include <opencv2/core.hpp>
+#include <opencv2/core/utils/logger.hpp>
+namespace cv {
+//! @addtogroup core_quaternion
+//! @{
+
+//! Unit quaternion flag
+enum QuatAssumeType {
+  /**
+   * This flag is specified by default.
+   * If this flag is specified, the input quaternions are assumed to be not unit
+   * quaternions. It can guarantee the correctness of the calculations, although
+   * the calculation speed will be slower than the flag QUAT_ASSUME_UNIT.
+   */
+  QUAT_ASSUME_NOT_UNIT,
+  /**
+   * If this flag is specified, the input quaternions are assumed to be unit
+   * quaternions which will save some computations. However, if this flag is
+   * specified without unit quaternion, the program correctness of the result
+   * will not be guaranteed.
+   */
+  QUAT_ASSUME_UNIT
+};
+
+class QuatEnum {
+public:
+  /** @brief Enum of Euler angles type.
+   *
+   * Without considering the possibility of using two different convertions for
+   * the definition of the rotation axes , there exists twelve possible
+   * sequences of rotation axes, divided into two groups:
+   * - Proper Euler angles (Z-X-Z, X-Y-X, Y-Z-Y, Z-Y-Z, X-Z-X, Y-X-Y)
+   * - Tait–Bryan angles (X-Y-Z, Y-Z-X, Z-X-Y, X-Z-Y, Z-Y-X, Y-X-Z).
+   *
+   * The three elemental rotations may be
+   * [extrinsic](https://en.wikipedia.org/wiki/Euler_angles#Definition_by_extrinsic_rotations)
+   * (rotations about the axes *xyz* of the original coordinate system, which is
+   * assumed to remain motionless), or
+   * [intrinsic](https://en.wikipedia.org/wiki/Euler_angles#Definition_by_intrinsic_rotations)(rotations
+   * about the axes of the rotating coordinate system *XYZ*, solidary with the
+   * moving body, which changes its orientation after each elemental rotation).
+   *
+   *
+   * Extrinsic and intrinsic rotations are relevant.
+   *
+   * The definition of the Euler angles is as following,
+   * - \f$\theta_1 \f$ represents the first rotation angle,
+   * - \f$\theta_2 \f$ represents the second rotation angle,
+   * - \f$\theta_3 \f$ represents the third rotation angle.
+   *
+   * For intrinsic rotations in the order of X-Y-Z, the rotation matrix R can be
+   * calculated by:\f[R =X(\theta_1) Y(\theta_2) Z(\theta_3) \f] For extrinsic
+   * rotations in the order of X-Y-Z, the rotation matrix R can be calculated
+   * by:\f[R =Z({\theta_3}) Y({\theta_2}) X({\theta_1})\f] where
+   * \f[X({\theta_1})={\begin{bmatrix}1&0&0\\0&\cos {\theta_1} &-\sin {\theta_1}
+   * \\0&\sin {\theta_1} &\cos {\theta_1} \\\end{bmatrix}},
+   * Y({\theta_2})={\begin{bmatrix}\cos \theta_{2}&0&\sin \theta_{2}\\0&1 &0
+   * \\\ -sin \theta_2& 0&\cos \theta_{2} \\\end{bmatrix}},
+   * Z({\theta_3})={\begin{bmatrix}\cos\theta_{3} &-\sin \theta_3&0\\\sin
+   * \theta_3 &\cos \theta_3 &0\\0&0&1\\\end{bmatrix}}.
+   * \f]
+   *
+   * The function is designed according to this set of conventions:
+   * - [Right handed](https://en.wikipedia.org/wiki/Right_hand_rule) reference
+   * frames are adopted, and the [right hand
+   * rule](https://en.wikipedia.org/wiki/Right_hand_rule) is used to determine
+   * the sign of angles.
+   * - Each matrix is meant to represent an [active
+   * rotation](https://en.wikipedia.org/wiki/Active_and_passive_transformation)
+   * (the composing and composed matrices are supposed to act on the coordinates
+   * of vectors defined in the initial fixed reference frame and give as a
+   * result the coordinates of a rotated vector defined in the same reference
+   * frame).
+   * - For \f$\theta_1\f$ and \f$\theta_3\f$, the valid range is (−π, π].
+   *
+   *   For \f$\theta_2\f$, the valid range is [−π/2, π/2] or [0, π].
+   *
+   *   For Tait–Bryan angles, the valid range of \f$\theta_2\f$ is [−π/2, π/2].
+   * When transforming a quaternion to Euler angles, the solution of Euler
+   * angles is unique in condition of \f$ \theta_2 \in (−π/2, π/2)\f$ . If
+   * \f$\theta_2 = −π/2 \f$ or \f$ \theta_2 = π/2\f$, there are infinite
+   * solutions. The common name for this situation is gimbal lock. For Proper
+   * Euler angles,the valid range of \f$\theta_2\f$ is in [0, π]. The solutions
+   * of Euler angles are unique in condition of  \f$ \theta_2 \in (0, π)\f$ . If
+   * \f$\theta_2 =0 \f$ or \f$\theta_2 =π \f$, there are infinite solutions and
+   * gimbal lock will occur.
+   */
+  enum EulerAnglesType {
+    INT_XYZ, ///< Intrinsic rotations with the Euler angles type X-Y-Z
+    INT_XZY, ///< Intrinsic rotations with the Euler angles type X-Z-Y
+    INT_YXZ, ///< Intrinsic rotations with the Euler angles type Y-X-Z
+    INT_YZX, ///< Intrinsic rotations with the Euler angles type Y-Z-X
+    INT_ZXY, ///< Intrinsic rotations with the Euler angles type Z-X-Y
+    INT_ZYX, ///< Intrinsic rotations with the Euler angles type Z-Y-X
+    INT_XYX, ///< Intrinsic rotations with the Euler angles type X-Y-X
+    INT_XZX, ///< Intrinsic rotations with the Euler angles type X-Z-X
+    INT_YXY, ///< Intrinsic rotations with the Euler angles type Y-X-Y
+    INT_YZY, ///< Intrinsic rotations with the Euler angles type Y-Z-Y
+    INT_ZXZ, ///< Intrinsic rotations with the Euler angles type Z-X-Z
+    INT_ZYZ, ///< Intrinsic rotations with the Euler angles type Z-Y-Z
+
+    EXT_XYZ, ///< Extrinsic rotations with the Euler angles type X-Y-Z
+    EXT_XZY, ///< Extrinsic rotations with the Euler angles type X-Z-Y
+    EXT_YXZ, ///< Extrinsic rotations with the Euler angles type Y-X-Z
+    EXT_YZX, ///< Extrinsic rotations with the Euler angles type Y-Z-X
+    EXT_ZXY, ///< Extrinsic rotations with the Euler angles type Z-X-Y
+    EXT_ZYX, ///< Extrinsic rotations with the Euler angles type Z-Y-X
+    EXT_XYX, ///< Extrinsic rotations with the Euler angles type X-Y-X
+    EXT_XZX, ///< Extrinsic rotations with the Euler angles type X-Z-X
+    EXT_YXY, ///< Extrinsic rotations with the Euler angles type Y-X-Y
+    EXT_YZY, ///< Extrinsic rotations with the Euler angles type Y-Z-Y
+    EXT_ZXZ, ///< Extrinsic rotations with the Euler angles type Z-X-Z
+    EXT_ZYZ, ///< Extrinsic rotations with the Euler angles type Z-Y-Z
+#ifndef CV_DOXYGEN
+    EULER_ANGLES_MAX_VALUE
+#endif
+  };
+};
+
+template <typename _Tp> class Quat;
+template <typename _Tp>
+std::ostream &operator<<(std::ostream &, const Quat<_Tp> &);
+
+/**
+ * Quaternion is a number system that extends the complex numbers. It can be
+ * expressed as a rotation in three-dimensional space. A quaternion is generally
+ * represented in the form:
+ *      \f[q = w + x\boldsymbol{i} + y\boldsymbol{j} + z\boldsymbol{k}\f]
+ *      \f[q = [w, x, y, z]\f]
+ *      \f[q = [w, \boldsymbol{v}] \f]
+ *      \f[q = ||q||[\cos\psi, u_x\sin\psi,u_y\sin\psi,  u_z\sin\psi].\f]
+ *      \f[q = ||q||[\cos\psi, \boldsymbol{u}\sin\psi]\f]
+ * where \f$\psi = \frac{\theta}{2}\f$, \f$\theta\f$ represents rotation angle,
+ * \f$\boldsymbol{u} = [u_x, u_y, u_z]\f$ represents normalized rotation axis,
+ * and \f$||q||\f$ represents the norm of \f$q\f$.
+ *
+ * A unit quaternion is usually represents rotation, which has the form:
+ *      \f[q = [\cos\psi, u_x\sin\psi,u_y\sin\psi,  u_z\sin\psi].\f]
+ *
+ * To create a quaternion representing the rotation around the axis
+ * \f$\boldsymbol{u}\f$ with angle \f$\theta\f$, you can use
+ * ```
+ * using namespace cv;
+ * double angle = CV_PI;
+ * Vec3d axis = {0, 0, 1};
+ * Quatd q = Quatd::createFromAngleAxis(angle, axis);
+ * ```
+ *
+ * You can simply use four same type number to create a quaternion
+ * ```
+ * Quatd q(1, 2, 3, 4);
+ * ```
+ * Or use a Vec4d or Vec4f vector.
+ * ```
+ * Vec4d vec{1, 2, 3, 4};
+ * Quatd q(vec);
+ * ```
+ *
+ * ```
+ * Vec4f vec{1, 2, 3, 4};
+ * Quatf q(vec);
+ * ```
+ *
+ * If you already have a 3x3 rotation matrix R, then you can use
+ * ```
+ * Quatd q = Quatd::createFromRotMat(R);
+ * ```
+ *
+ * If you already have a rotation vector rvec which has the form of `angle *
+ * axis`, then you can use
+ * ```
+ * Quatd q = Quatd::createFromRvec(rvec);
+ * ```
+ *
+ * To extract the rotation matrix from quaternion, see toRotMat3x3()
+ *
+ * To extract the Vec4d or Vec4f, see toVec()
+ *
+ * To extract the rotation vector, see toRotVec()
+ *
+ * If there are two quaternions \f$q_0, q_1\f$ are needed to interpolate, you
+ * can use nlerp(), slerp() or spline()
+ * ```
+ * Quatd::nlerp(q0, q1, t)
+ *
+ * Quatd::slerp(q0, q1, t)
+ *
+ * Quatd::spline(q0, q0, q1, q1, t)
+ * ```
+ * spline can smoothly connect rotations of  multiple quaternions
+ *
+ * Three ways to get an element in Quaternion
+ * ```
+ * 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;
+ * ```
+ */
+template <typename _Tp> class Quat {
+  static_assert(std::is_floating_point<_Tp>::value,
+                "Quaternion only make sense with type of float or double");
+  using value_type = _Tp;
+
+public:
+  static constexpr _Tp CV_QUAT_EPS = (_Tp)1.e-6;
+  static constexpr _Tp CV_QUAT_CONVERT_THRESHOLD = (_Tp)1.e-6;
+
+  Quat();
+
+  /**
+   * @brief From Vec4d or Vec4f.
+   */
+  explicit Quat(const Vec<_Tp, 4> &coeff);
+
+  /**
+   * @brief from four numbers.
+   */
+  Quat(_Tp w, _Tp x, _Tp y, _Tp z);
+
+  /**
+   * @brief from an angle, axis. Axis will be normalized in this function. And
+   * it generates
+   * \f[q = [\cos\psi, u_x\sin\psi,u_y\sin\psi,  u_z\sin\psi].\f]
+   * where \f$\psi = \frac{\theta}{2}\f$, \f$\theta\f$ is the rotation angle.
+   */
+  static Quat<_Tp> createFromAngleAxis(const _Tp angle,
+                                       const Vec<_Tp, 3> &axis);
+
+  /**
+   * @brief from a 3x3 rotation matrix.
+   */
+  static Quat<_Tp> createFromRotMat(InputArray R);
+
+  /**
+   * @brief from a rotation vector
+   * \f$r\f$ has the form \f$\theta \cdot \boldsymbol{u}\f$, where \f$\theta\f$
+   * represents rotation angle and \f$\boldsymbol{u}\f$ represents normalized
+   * rotation axis.
+   *
+   * Angle and axis could be easily derived as:
+   * \f[
+   * \begin{equation}
+   * \begin{split}
+   * \psi &= ||r||\\
+   * \boldsymbol{u} &= \frac{r}{\theta}
+   * \end{split}
+   * \end{equation}
+   * \f]
+   * Then a quaternion can be calculated by
+   *  \f[q = [\cos\psi, \boldsymbol{u}\sin\psi]\f]
+   *  where \f$\psi = \theta / 2 \f$
+   */
+  static Quat<_Tp> createFromRvec(InputArray rvec);
+
+  /**
+   * @brief
+   * from Euler angles
+   *
+   * A quaternion can be generated from Euler angles by combining the quaternion
+   * representations of the Euler rotations.
+   *
+   * For example, if we use intrinsic rotations in the order of
+   * X-Y-Z,\f$\theta_1 \f$ is rotation around the X-axis, \f$\theta_2 \f$ is
+   * rotation around the Y-axis,
+   * \f$\theta_3 \f$ is rotation around the Z-axis. The final quaternion q can
+   * be calculated by
+   *
+   * \f[ {q} = q_{X, \theta_1}  q_{Y, \theta_2} q_{Z, \theta_3}\f]
+   * where \f$ q_{X, \theta_1} \f$ is created from @ref createFromXRot,  \f$
+   * q_{Y, \theta_2} \f$ is created from @ref createFromYRot,
+   *  \f$ q_{Z, \theta_3} \f$ is created from @ref createFromZRot.
+   * @param angles the Euler angles in a vector of length 3
+   * @param eulerAnglesType the convertion Euler angles type
+   */
+  static Quat<_Tp>
+  createFromEulerAngles(const Vec<_Tp, 3> &angles,
+                        QuatEnum::EulerAnglesType eulerAnglesType);
+
+  /**
+   * @brief get a quaternion from a rotation about the Y-axis by \f$\theta\f$ .
+   * \f[q = \cos(\theta/2)+0 i+ sin(\theta/2) j +0k \f]
+   */
+  static Quat<_Tp> createFromYRot(const _Tp theta);
+
+  /**
+   * @brief get a quaternion from a rotation about the X-axis by \f$\theta\f$ .
+   * \f[q = \cos(\theta/2)+sin(\theta/2) i +0 j +0 k \f]
+   */
+  static Quat<_Tp> createFromXRot(const _Tp theta);
+
+  /**
+   * @brief get a quaternion from a rotation about the Z-axis by \f$\theta\f$.
+   * \f[q = \cos(\theta/2)+0 i +0 j +sin(\theta/2) k \f]
+   */
+  static Quat<_Tp> createFromZRot(const _Tp theta);
+
+  /**
+   * @brief a way to get element.
+   * @param index over a range [0, 3].
+   *
+   * A quaternion q
+   *
+   * q.at(0) is equivalent to q.w,
+   *
+   * q.at(1) is equivalent to q.x,
+   *
+   * q.at(2) is equivalent to q.y,
+   *
+   * q.at(3) is equivalent to q.z.
+   */
+  _Tp at(size_t index) const;
+
+  /**
+   * @brief return the conjugate of this quaternion.
+   * \f[q.conjugate() = (w, -x, -y, -z).\f]
+   */
+  Quat<_Tp> conjugate() const;
+
+  /**
+   *
+   * @brief return the value of exponential value.
+   * \f[\exp(q) = e^w (\cos||\boldsymbol{v}||+
+   * \frac{v}{||\boldsymbol{v}||})\sin||\boldsymbol{v}||\f] where
+   * \f$\boldsymbol{v} = [x, y, z].\f$
+   * @param q a quaternion.
+   *
+   * For example:
+   * ```
+   * Quatd q{1,2,3,4};
+   * cout << exp(q) << endl;
+   * ```
+   */
+  template <typename T> friend Quat<T> exp(const Quat<T> &q);
+
+  /**
+   * @brief return the value of exponential value.
+   * \f[\exp(q) = e^w (\cos||\boldsymbol{v}||+
+   * \frac{v}{||\boldsymbol{v}||}\sin||\boldsymbol{v}||)\f] where
+   * \f$\boldsymbol{v} = [x, y, z].\f$
+   *
+   * For example
+   * ```
+   * Quatd q{1,2,3,4};
+   * cout << q.exp() << endl;
+   * ```
+   */
+  Quat<_Tp> exp() const;
+
+  /**
+   * @brief return the value of logarithm function.
+   * \f[\ln(q) = \ln||q|| +
+   * \frac{\boldsymbol{v}}{||\boldsymbol{v}||}\arccos\frac{w}{||q||}.\f] where
+   * \f$\boldsymbol{v} = [x, y, z].\f$
+   * @param q a quaternion.
+   * @param assumeUnit if QUAT_ASSUME_UNIT, q assume to be a unit quaternion and
+   * this function will save some computations.
+   *
+   * For example
+   * ```
+   * Quatd q1{1,2,3,4};
+   * cout << log(q1) << endl;
+   * ```
+   */
+  template <typename T>
+  friend Quat<T> log(const Quat<T> &q, QuatAssumeType assumeUnit);
+
+  /**
+   * @brief return the value of logarithm function.
+   *  \f[\ln(q) = \ln||q|| +
+   * \frac{\boldsymbol{v}}{||\boldsymbol{v}||}\arccos\frac{w}{||q||}\f]. where
+   * \f$\boldsymbol{v} = [x, y, z].\f$
+   * @param assumeUnit if QUAT_ASSUME_UNIT, this quaternion assume to be a unit
+   * quaternion and this function will save some computations.
+   *
+   * For example
+   * ```
+   * Quatd q(1,2,3,4);
+   * q.log();
+   *
+   * QuatAssumeType assumeUnit = QUAT_ASSUME_UNIT;
+   * Quatd q1(1,2,3,4);
+   * q1.normalize().log(assumeUnit);
+   * ```
+   */
+  Quat<_Tp> log(QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT) const;
+
+  /**
+   * @brief return the value of power function with index \f$x\f$.
+   * \f[q^x = ||q||(cos(x\theta) + \boldsymbol{u}sin(x\theta))).\f]
+   * @param q a quaternion.
+   * @param x index of exponentiation.
+   * @param assumeUnit if QUAT_ASSUME_UNIT, quaternion q assume to be a unit
+   * quaternion and this function will save some computations.
+   *
+   * For example
+   * ```
+   * 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.
+   * ```
+   * @note the type of the index should be the same as the quaternion.
+   */
+  template <typename T>
+  friend Quat<T> power(const Quat<T> &q, const T x, QuatAssumeType assumeUnit);
+
+  /**
+   * @brief return the value of power function with index \f$x\f$.
+   * \f[q^x = ||q||(\cos(x\theta) + \boldsymbol{u}\sin(x\theta))).\f]
+   * @param x index of exponentiation.
+   * @param assumeUnit if QUAT_ASSUME_UNIT, this quaternion assume to be a unit
+   * quaternion and this function will save some computations.
+   *
+   * For example
+   * ```
+   * 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
+   * ```
+   */
+  Quat<_Tp> power(const _Tp x,
+                  QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT) const;
+
+  /**
+   * @brief return \f$\sqrt{q}\f$.
+   * @param q a quaternion.
+   * @param assumeUnit if QUAT_ASSUME_UNIT, quaternion q assume to be a unit
+   * quaternion and this function will save some computations.
+   *
+   * For example
+   * ```
+   * 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.
+   * ```
+   */
+  template <typename T>
+  friend Quat<T> sqrt(const Quat<T> &q, QuatAssumeType assumeUnit);
+
+  /**
+   * @brief return \f$\sqrt{q}\f$.
+   * @param assumeUnit if QUAT_ASSUME_UNIT, this quaternion assume to be a unit
+   * quaternion and this function will save some computations.
+   *
+   * For example
+   * ```
+   * 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
+   * ```
+   */
+  Quat<_Tp> sqrt(QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT) const;
+
+  /**
+   * @brief return the value of power function with quaternion \f$q\f$.
+   * \f[p^q = e^{q\ln(p)}.\f]
+   * @param p base quaternion of power function.
+   * @param q index quaternion of power function.
+   * @param assumeUnit if QUAT_ASSUME_UNIT, quaternion \f$p\f$ assume to be a
+   * unit quaternion and this function will save some computations.
+   *
+   * For example
+   * ```
+   * 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
+   * ```
+   */
+  template <typename T>
+  friend Quat<T> power(const Quat<T> &p, const Quat<T> &q,
+                       QuatAssumeType assumeUnit);
+
+  /**
+   * @brief return the value of power function with quaternion \f$q\f$.
+   * \f[p^q = e^{q\ln(p)}.\f]
+   * @param q index quaternion of power function.
+   * @param assumeUnit if QUAT_ASSUME_UNIT, this quaternion assume to be a unit
+   * quaternion and this function will save some computations.
+   *
+   * For example
+   * ```
+   * 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
+   * ```
+   */
+  Quat<_Tp> power(const Quat<_Tp> &q,
+                  QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT) const;
+
+  /**
+   * @brief return the crossProduct between \f$p = (a, b, c, d) = (a,
+   * \boldsymbol{u})\f$ and \f$q = (w, x, y, z) = (w, \boldsymbol{v})\f$.
+   * \f[p \times q = \frac{pq- qp}{2}\f]
+   * \f[p \times q = \boldsymbol{u} \times \boldsymbol{v}\f]
+   * \f[p \times q = (cz-dy)i + (dx-bz)j + (by-xc)k \f]
+   *
+   * For example
+   * ```
+   * Quatd q{1,2,3,4};
+   * Quatd p{5,6,7,8};
+   * crossProduct(p, q);
+   * ```
+   */
+  template <typename T>
+  friend Quat<T> crossProduct(const Quat<T> &p, const Quat<T> &q);
+
+  /**
+   * @brief return the crossProduct between \f$p = (a, b, c, d) = (a,
+   * \boldsymbol{u})\f$ and \f$q = (w, x, y, z) = (w, \boldsymbol{v})\f$.
+   * \f[p \times q = \frac{pq- qp}{2}.\f]
+   * \f[p \times q = \boldsymbol{u} \times \boldsymbol{v}.\f]
+   * \f[p \times q = (cz-dy)i + (dx-bz)j + (by-xc)k. \f]
+   *
+   * For example
+   * ```
+   * Quatd q{1,2,3,4};
+   * Quatd p{5,6,7,8};
+   * p.crossProduct(q)
+   * ```
+   */
+  Quat<_Tp> crossProduct(const Quat<_Tp> &q) const;
+
+  /**
+   * @brief return the norm of quaternion.
+   * \f[||q|| = \sqrt{w^2 + x^2 + y^2 + z^2}.\f]
+   */
+  _Tp norm() const;
+
+  /**
+   * @brief return a normalized \f$p\f$.
+   * \f[p = \frac{q}{||q||}\f]
+   * where \f$p\f$ satisfies \f$(p.x)^2 + (p.y)^2 + (p.z)^2 + (p.w)^2 = 1.\f$
+   */
+  Quat<_Tp> normalize() const;
+
+  /**
+   * @brief return \f$q^{-1}\f$ which is an inverse of \f$q\f$
+   * which satisfies \f$q * q^{-1} = 1\f$.
+   * @param q a quaternion.
+   * @param assumeUnit if QUAT_ASSUME_UNIT, quaternion q assume to be a unit
+   * quaternion and this function will save some computations.
+   *
+   * For example
+   * ```
+   * 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
+   * ```
+   */
+  template <typename T>
+  friend Quat<T> inv(const Quat<T> &q, QuatAssumeType assumeUnit);
+
+  /**
+   * @brief return \f$q^{-1}\f$ which is an inverse of \f$q\f$
+   * satisfying \f$q * q^{-1} = 1\f$.
+   * @param assumeUnit if QUAT_ASSUME_UNIT, quaternion q assume to be a unit
+   * quaternion and this function will save some computations.
+   *
+   * For example
+   * ```
+   * 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
+   * ```
+   */
+  Quat<_Tp> inv(QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT) const;
+
+  /**
+   * @brief return sinh value of quaternion q, sinh could be calculated as:
+   * \f[\sinh(p) = \sin(w)\cos(||\boldsymbol{v}||) +
+   * \cosh(w)\frac{v}{||\boldsymbol{v}||}\sin||\boldsymbol{v}||\f] where
+   * \f$\boldsymbol{v} = [x, y, z].\f$
+   * @param q a quaternion.
+   *
+   * For example
+   * ```
+   * Quatd q(1,2,3,4);
+   * sinh(q);
+   * ```
+   */
+  template <typename T> friend Quat<T> sinh(const Quat<T> &q);
+
+  /**
+   * @brief return sinh value of this quaternion, sinh could be calculated as:
+   * \f$\sinh(p) = \sin(w)\cos(||\boldsymbol{v}||) +
+   * \cosh(w)\frac{v}{||\boldsymbol{v}||}\sin||\boldsymbol{v}||\f$ where
+   * \f$\boldsymbol{v} = [x, y, z].\f$
+   *
+   * For example
+   * ```
+   * Quatd q(1,2,3,4);
+   * q.sinh();
+   * ```
+   */
+  Quat<_Tp> sinh() const;
+
+  /**
+   * @brief return cosh value of quaternion q, cosh could be calculated as:
+   * \f[\cosh(p) = \cosh(w) * \cos(||\boldsymbol{v}||) +
+   * \sinh(w)\frac{\boldsymbol{v}}{||\boldsymbol{v}||}\sin(||\boldsymbol{v}||)\f]
+   * where \f$\boldsymbol{v} = [x, y, z].\f$
+   * @param q a quaternion.
+   *
+   * For example
+   * ```
+   * Quatd q(1,2,3,4);
+   * cosh(q);
+   * ```
+   */
+  template <typename T> friend Quat<T> cosh(const Quat<T> &q);
+
+  /**
+   * @brief return cosh value of this quaternion, cosh could be calculated as:
+   * \f[\cosh(p) = \cosh(w) * \cos(||\boldsymbol{v}||) +
+   * \sinh(w)\frac{\boldsymbol{v}}{||\boldsymbol{v}||}sin(||\boldsymbol{v}||)\f]
+   * where \f$\boldsymbol{v} = [x, y, z].\f$
+   *
+   * For example
+   * ```
+   * Quatd q(1,2,3,4);
+   * q.cosh();
+   * ```
+   */
+  Quat<_Tp> cosh() const;
+
+  /**
+   * @brief return tanh value of quaternion q, tanh could be calculated as:
+   * \f[ \tanh(q) = \frac{\sinh(q)}{\cosh(q)}.\f]
+   * @param q a quaternion.
+   *
+   * For example
+   * ```
+   * Quatd q(1,2,3,4);
+   * tanh(q);
+   * ```
+   * @sa sinh, cosh
+   */
+  template <typename T> friend Quat<T> tanh(const Quat<T> &q);
+
+  /**
+   * @brief return tanh value of this quaternion, tanh could be calculated as:
+   * \f[ \tanh(q) = \frac{\sinh(q)}{\cosh(q)}.\f]
+   *
+   * For example
+   * ```
+   * Quatd q(1,2,3,4);
+   * q.tanh();
+   * ```
+   * @sa sinh, cosh
+   */
+  Quat<_Tp> tanh() const;
+
+  /**
+   * @brief return tanh value of quaternion q, sin could be calculated as:
+   * \f[\sin(p) = \sin(w) * \cosh(||\boldsymbol{v}||) +
+   * \cos(w)\frac{\boldsymbol{v}}{||\boldsymbol{v}||}\sinh(||\boldsymbol{v}||)\f]
+   * where \f$\boldsymbol{v} = [x, y, z].\f$
+   * @param q a quaternion.
+   *
+   * For example
+   * ```
+   * Quatd q(1,2,3,4);
+   * sin(q);
+   * ```
+   */
+  template <typename T> friend Quat<T> sin(const Quat<T> &q);
+
+  /**
+   * @brief return sin value of this quaternion, sin could be calculated as:
+   * \f[\sin(p) = \sin(w) * \cosh(||\boldsymbol{v}||) +
+   * \cos(w)\frac{\boldsymbol{v}}{||\boldsymbol{v}||}\sinh(||\boldsymbol{v}||)\f]
+   * where \f$\boldsymbol{v} = [x, y, z].\f$
+   *
+   * For example
+   * ```
+   * Quatd q(1,2,3,4);
+   * q.sin();
+   * ```
+   */
+  Quat<_Tp> sin() const;
+
+  /**
+   * @brief return sin value of quaternion q, cos could be calculated as:
+   * \f[\cos(p) = \cos(w) * \cosh(||\boldsymbol{v}||) -
+   * \sin(w)\frac{\boldsymbol{v}}{||\boldsymbol{v}||}\sinh(||\boldsymbol{v}||)\f]
+   * where \f$\boldsymbol{v} = [x, y, z].\f$
+   * @param q a quaternion.
+   *
+   * For example
+   * ```
+   * Quatd q(1,2,3,4);
+   * cos(q);
+   * ```
+   */
+  template <typename T> friend Quat<T> cos(const Quat<T> &q);
+
+  /**
+   * @brief return cos value of this quaternion, cos could be calculated as:
+   * \f[\cos(p) = \cos(w) * \cosh(||\boldsymbol{v}||) -
+   * \sin(w)\frac{\boldsymbol{v}}{||\boldsymbol{v}||}\sinh(||\boldsymbol{v}||)\f]
+   * where \f$\boldsymbol{v} = [x, y, z].\f$
+   *
+   * For example
+   * ```
+   * Quatd q(1,2,3,4);
+   * q.cos();
+   * ```
+   */
+  Quat<_Tp> cos() const;
+
+  /**
+   * @brief return tan value of quaternion q, tan could be calculated as:
+   * \f[\tan(q) = \frac{\sin(q)}{\cos(q)}.\f]
+   * @param q a quaternion.
+   *
+   * For example
+   * ```
+   * Quatd q(1,2,3,4);
+   * tan(q);
+   * ```
+   */
+  template <typename T> friend Quat<T> tan(const Quat<T> &q);
+
+  /**
+   * @brief return tan value of this quaternion, tan could be calculated as:
+   * \f[\tan(q) = \frac{\sin(q)}{\cos(q)}.\f]
+   *
+   * For example
+   * ```
+   * Quatd q(1,2,3,4);
+   * q.tan();
+   * ```
+   */
+  Quat<_Tp> tan() const;
+
+  /**
+   * @brief return arcsin value of quaternion q, arcsin could be calculated as:
+   * \f[\arcsin(q) =
+   * -\frac{\boldsymbol{v}}{||\boldsymbol{v}||}arcsinh(q\frac{\boldsymbol{v}}{||\boldsymbol{v}||})\f]
+   * where \f$\boldsymbol{v} = [x, y, z].\f$
+   * @param q a quaternion.
+   *
+   * For example
+   * ```
+   * Quatd q(1,2,3,4);
+   * asin(q);
+   * ```
+   */
+  template <typename T> friend Quat<T> asin(const Quat<T> &q);
+
+  /**
+   * @brief return arcsin value of this quaternion, arcsin could be calculated
+   * as:
+   * \f[\arcsin(q) =
+   * -\frac{\boldsymbol{v}}{||\boldsymbol{v}||}arcsinh(q\frac{\boldsymbol{v}}{||\boldsymbol{v}||})\f]
+   * where \f$\boldsymbol{v} = [x, y, z].\f$
+   *
+   * For example
+   * ```
+   * Quatd q(1,2,3,4);
+   * q.asin();
+   * ```
+   */
+  Quat<_Tp> asin() const;
+
+  /**
+   * @brief return arccos value of quaternion q, arccos could be calculated as:
+   * \f[\arccos(q) = -\frac{\boldsymbol{v}}{||\boldsymbol{v}||}arccosh(q)\f]
+   * where \f$\boldsymbol{v} = [x, y, z].\f$
+   * @param q a quaternion.
+   *
+   * For example
+   * ```
+   * Quatd q(1,2,3,4);
+   * acos(q);
+   * ```
+   */
+  template <typename T> friend Quat<T> acos(const Quat<T> &q);
+
+  /**
+   * @brief return arccos value of this quaternion, arccos could be calculated
+   * as:
+   * \f[\arccos(q) = -\frac{\boldsymbol{v}}{||\boldsymbol{v}||}arccosh(q)\f]
+   * where \f$\boldsymbol{v} = [x, y, z].\f$
+   *
+   * For example
+   * ```
+   * Quatd q(1,2,3,4);
+   * q.acos();
+   * ```
+   */
+  Quat<_Tp> acos() const;
+
+  /**
+   * @brief return arctan value of quaternion q, arctan could be calculated as:
+   * \f[\arctan(q) =
+   * -\frac{\boldsymbol{v}}{||\boldsymbol{v}||}arctanh(q\frac{\boldsymbol{v}}{||\boldsymbol{v}||})\f]
+   * where \f$\boldsymbol{v} = [x, y, z].\f$
+   * @param q a quaternion.
+   *
+   * For example
+   * ```
+   * Quatd q(1,2,3,4);
+   * atan(q);
+   * ```
+   */
+  template <typename T> friend Quat<T> atan(const Quat<T> &q);
+
+  /**
+   * @brief return arctan value of this quaternion, arctan could be calculated
+   * as:
+   * \f[\arctan(q) =
+   * -\frac{\boldsymbol{v}}{||\boldsymbol{v}||}arctanh(q\frac{\boldsymbol{v}}{||\boldsymbol{v}||})\f]
+   * where \f$\boldsymbol{v} = [x, y, z].\f$
+   *
+   * For example
+   * ```
+   * Quatd q(1,2,3,4);
+   * q.atan();
+   * ```
+   */
+  Quat<_Tp> atan() const;
+
+  /**
+   * @brief return arcsinh value of quaternion q, arcsinh could be calculated
+   * as:
+   * \f[arcsinh(q) = \ln(q + \sqrt{q^2 + 1})\f].
+   * @param q a quaternion.
+   *
+   * For example
+   * ```
+   * Quatd q(1,2,3,4);
+   * asinh(q);
+   * ```
+   */
+  template <typename T> friend Quat<T> asinh(const Quat<T> &q);
+
+  /**
+   * @brief return arcsinh value of this quaternion, arcsinh could be calculated
+   * as:
+   * \f[arcsinh(q) = \ln(q + \sqrt{q^2 + 1})\f].
+   *
+   * For example
+   * ```
+   * Quatd q(1,2,3,4);
+   * q.asinh();
+   * ```
+   */
+  Quat<_Tp> asinh() const;
+
+  /**
+   * @brief return arccosh value of quaternion q, arccosh could be calculated
+   * as:
+   * \f[arccosh(q) = \ln(q + \sqrt{q^2 - 1})\f].
+   * @param q a quaternion.
+   *
+   * For example
+   * ```
+   * Quatd q(1,2,3,4);
+   * acosh(q);
+   * ```
+   */
+  template <typename T> friend Quat<T> acosh(const Quat<T> &q);
+
+  /**
+   * @brief return arccosh value of this quaternion, arccosh could be calculated
+   * as:
+   * \f[arcosh(q) = \ln(q + \sqrt{q^2 - 1})\f].
+   *
+   * For example
+   * ```
+   * Quatd q(1,2,3,4);
+   * q.acosh();
+   * ```
+   */
+  Quat<_Tp> acosh() const;
+
+  /**
+   * @brief return arctanh value of quaternion q, arctanh could be calculated
+   * as:
+   * \f[arctanh(q) = \frac{\ln(q + 1) - \ln(1 - q)}{2}\f].
+   * @param q a quaternion.
+   *
+   * For example
+   * ```
+   * Quatd q(1,2,3,4);
+   * atanh(q);
+   * ```
+   */
+  template <typename T> friend Quat<T> atanh(const Quat<T> &q);
+
+  /**
+   * @brief return arctanh value of this quaternion, arctanh could be calculated
+   * as:
+   * \f[arcsinh(q) = \frac{\ln(q + 1) - \ln(1 - q)}{2}\f].
+   *
+   * For example
+   * ```
+   * Quatd q(1,2,3,4);
+   * q.atanh();
+   * ```
+   */
+  Quat<_Tp> atanh() const;
+
+  /**
+   * @brief return true if this quaternion is a unit quaternion.
+   * @param eps tolerance scope of normalization. The eps could be defined as
+   *
+   * \f[eps = |1 - dotValue|\f] where \f[dotValue = (this.w^2 + this.x^2 +
+   * this,y^2 + this.z^2).\f] And this function will consider it is normalized
+   * when the dotValue over a range \f$[1-eps, 1+eps]\f$.
+   */
+  bool isNormal(_Tp eps = CV_QUAT_EPS) const;
+
+  /**
+   * @brief to throw an error if this quaternion is not a unit quaternion.
+   * @param eps tolerance scope of normalization.
+   * @sa isNormal
+   */
+  void assertNormal(_Tp eps = CV_QUAT_EPS) const;
+
+  /**
+   * @brief transform a quaternion to a 3x3 rotation matrix.
+   * @param assumeUnit if QUAT_ASSUME_UNIT, this quaternion assume to be a unit
+   quaternion and
+   * this function will save some computations. Otherwise, this function will
+   normalize this
+   * quaternion at first then do the transformation.
+   *
+   * @note Matrix A which is to be rotated should have the form
+   * \f[\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}\f]
+   * 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.
+
+   * For example
+   * ```
+   * 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;
+   * ```
+   */
+  Matx<_Tp, 3, 3>
+  toRotMat3x3(QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT) const;
+
+  /**
+   * @brief transform a quaternion to a 4x4 rotation matrix.
+   * @param assumeUnit if QUAT_ASSUME_UNIT, this quaternion assume to be a unit
+   * quaternion and this function will save some computations. Otherwise, this
+   * function will normalize this quaternion at first then do the
+   * transformation.
+   *
+   * The operations is similar as toRotMat3x3
+   * except that the points matrix should have the form
+   * \f[\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}\f]
+   *
+   * @sa toRotMat3x3
+   */
+
+  Matx<_Tp, 4, 4>
+  toRotMat4x4(QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT) const;
+
+  /**
+   * @brief transform the this quaternion to a Vec<T, 4>.
+   *
+   * For example
+   * ```
+   * Quatd q(1,2,3,4);
+   * q.toVec();
+   * ```
+   */
+  Vec<_Tp, 4> toVec() const;
+
+  /**
+   * @brief transform this quaternion to a Rotation vector.
+   * @param assumeUnit if QUAT_ASSUME_UNIT, this quaternion assume to be a unit
+   * quaternion and this function will save some computations. Rotation vector
+   * rVec is defined as:
+   * \f[ rVec = [\theta v_x, \theta v_y, \theta v_z]\f]
+   * where \f$\theta\f$ represents rotation angle, and \f$\boldsymbol{v}\f$
+   * represents the normalized rotation axis.
+   *
+   * For example
+   * ```
+   * Quatd q(1,2,3,4);
+   * q.toRotVec();
+   *
+   * QuatAssumeType assumeUnit = QUAT_ASSUME_UNIT;
+   * q.normalize().toRotVec(assumeUnit); //answer is same as q.toRotVec().
+   * ```
+   */
+  Vec<_Tp, 3> toRotVec(QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT) const;
+
+  /**
+   * @brief get the angle of quaternion, it returns the rotation angle.
+   * @param assumeUnit if QUAT_ASSUME_UNIT, this quaternion assume to be a unit
+   * quaternion and this function will save some computations.
+   * \f[\psi = 2 *arccos(\frac{w}{||q||})\f]
+   *
+   * For example
+   * ```
+   * Quatd q(1,2,3,4);
+   * q.getAngle();
+   *
+   * QuatAssumeType assumeUnit = QUAT_ASSUME_UNIT;
+   * q.normalize().getAngle(assumeUnit);//same as q.getAngle().
+   * ```
+   * @note It always return the value between \f$[0, 2\pi]\f$.
+   */
+  _Tp getAngle(QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT) const;
+
+  /**
+   * @brief get the axis of quaternion, it returns a vector of length 3.
+   * @param assumeUnit if QUAT_ASSUME_UNIT, this quaternion assume to be a unit
+   * quaternion and this function will save some computations.
+   *
+   * the unit axis \f$\boldsymbol{u}\f$ is defined by
+   * \f[\begin{equation}
+   *    \begin{split}
+   *      \boldsymbol{v}
+   *      &= \boldsymbol{u} ||\boldsymbol{v}||\\
+   *      &= \boldsymbol{u}||q||sin(\frac{\theta}{2})
+   *    \end{split}
+   *    \end{equation}\f]
+   *  where \f$v=[x, y ,z]\f$ and \f$\theta\f$ represents rotation angle.
+   *
+   *
+   * For example
+   * ```
+   * Quatd q(1,2,3,4);
+   * q.getAxis();
+   *
+   * QuatAssumeType assumeUnit = QUAT_ASSUME_UNIT;
+   * q.normalize().getAxis(assumeUnit);//same as q.getAxis()
+   * ```
+   */
+  Vec<_Tp, 3> getAxis(QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT) const;
+
+  /**
+   * @brief return the dot between quaternion \f$q\f$ and this quaternion.
+   *
+   * dot(p, q) is a good metric of how close the quaternions are.
+   * Indeed, consider the unit quaternion difference \f$p^{-1} * q\f$, its real
+   * part is dot(p, q). At the same time its real part is equal to
+   * \f$\cos(\beta/2)\f$ where \f$\beta\f$ is an angle of rotation between p and
+   * q, i.e., Therefore, the closer dot(p, q) to 1, the smaller rotation between
+   * them.
+   * \f[p \cdot q = p.w \cdot q.w + p.x \cdot q.x + p.y \cdot q.y + p.z \cdot
+   * q.z\f]
+   * @param q the other quaternion.
+   *
+   * For example
+   * ```
+   * Quatd q(1,2,3,4);
+   * Quatd p(5,6,7,8);
+   * p.dot(q);
+   * ```
+   */
+  _Tp dot(Quat<_Tp> q) const;
+
+  /**
+   * @brief To calculate the interpolation from \f$q_0\f$ to \f$q_1\f$ by Linear
+   * Interpolation(Nlerp) For two quaternions, this interpolation curve can be
+   * displayed as:
+   * \f[Lerp(q_0, q_1, t) = (1 - t)q_0 + tq_1.\f]
+   * Obviously, the lerp will interpolate along a straight line if we think of
+   * \f$q_0\f$ and \f$q_1\f$ as a vector in a two-dimensional space. When \f$t =
+   * 0\f$, it returns \f$q_0\f$ and when \f$t= 1\f$, it returns \f$q_1\f$.
+   * \f$t\f$ should to be ranged in \f$[0, 1]\f$ normally.
+   * @param q0 a quaternion used in linear interpolation.
+   * @param q1 a quaternion used in linear interpolation.
+   * @param t percent of vector \f$\overrightarrow{q_0q_1}\f$ over a range [0,
+   * 1].
+   * @note it returns a non-unit quaternion.
+   */
+  static Quat<_Tp> lerp(const Quat<_Tp> &q0, const Quat &q1, const _Tp t);
+
+  /**
+   * @brief To calculate the interpolation from \f$q_0\f$ to \f$q_1\f$ by
+   Normalized Linear Interpolation(Nlerp).
+   * it returns a normalized quaternion of Linear Interpolation(Lerp).
+   * \f[ Nlerp(q_0, q_1, t) = \frac{(1 - t)q_0 + tq_1}{||(1 - t)q_0 +
+   tq_1||}.\f]
+   * The interpolation will always choose the shortest path but the constant
+   speed is not guaranteed.
+   * @param q0 a quaternion used in normalized linear interpolation.
+   * @param q1 a quaternion used in normalized linear interpolation.
+   * @param t percent of vector \f$\overrightarrow{q_0q_1}\f$ over a range [0,
+   1].
+   * @param assumeUnit if QUAT_ASSUME_UNIT, all input quaternions assume to be
+   unit quaternion. Otherwise, all inputs quaternion will be normalized inside
+   the function.
+   * @sa lerp
+   */
+  static Quat<_Tp> nlerp(const Quat<_Tp> &q0, const Quat &q1, const _Tp t,
+                         QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT);
+
+  /**
+   @brief To calculate the interpolation between \f$q_0\f$ and \f$q_1\f$ by
+  Spherical Linear Interpolation(Slerp), which can be defined as:
+  \f[ Slerp(q_0, q_1, t) = \frac{\sin((1-t)\theta)}{\sin(\theta)}q_0 +
+  \frac{\sin(t\theta)}{\sin(\theta)}q_1\f] where \f$\theta\f$ can be calculated
+  as:
+  \f[\theta=cos^{-1}(q_0\cdot q_1)\f]
+  resulting from the both of their norm is unit.
+  @param q0 a quaternion used in Slerp.
+  @param q1 a quaternion used in Slerp.
+  @param t percent of angle between \f$q_0\f$ and \f$q_1\f$ over a range [0, 1].
+  @param assumeUnit if QUAT_ASSUME_UNIT, all input quaternions assume to be unit
+  quaternions. Otherwise, all input quaternions will be normalized inside the
+  function.
+  @param directChange if QUAT_ASSUME_UNIT, the interpolation will choose the
+  nearest path.
+  @note If the interpolation angle is small, the error between Nlerp and Slerp
+  is not so large. To improve efficiency and avoid zero division error, we use
+  Nlerp instead of Slerp.
+  */
+  static Quat<_Tp> slerp(const Quat<_Tp> &q0, const Quat &q1, const _Tp t,
+                         QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT,
+                         bool directChange = true);
+
+  /**
+   * @brief To calculate the interpolation between
+   * \f$q_0\f$,\f$q_1\f$,\f$q_2\f$,\f$q_3\f$  by Spherical and
+   * quadrangle(Squad). This could be defined as:
+   * \f[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))\f] where
+   * \f[s_i = q_i\exp(-\frac{\log(q^*_iq_{i+1}) + \log(q^*_iq_{i-1})}{4})\f]
+   *
+   * The Squad expression is analogous to the \f$B\acute{e}zier\f$ curve, but
+   * involves spherical linear interpolation instead of simple linear
+   * interpolation. Each \f$s_i\f$ needs to be calculated by three quaternions.
+   *
+   * @param q0 the first quaternion.
+   * @param s0 the second quaternion.
+   * @param s1 the third quaternion.
+   * @param q1 thr fourth quaternion.
+   * @param t interpolation parameter of quadratic and linear interpolation over
+   * a range \f$[0, 1]\f$.
+   * @param assumeUnit if QUAT_ASSUME_UNIT, all input quaternions assume to be
+   * unit quaternion. Otherwise, all input quaternions will be normalized inside
+   * the function.
+   * @param directChange if QUAT_ASSUME_UNIT, squad will find the nearest path
+   * to interpolate.
+   * @sa interPoint, spline
+   */
+  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);
+
+  /**
+   * @brief This is the part calculation of squad.
+   * To calculate the intermedia quaternion \f$s_i\f$ between each three
+   * quaternion
+   * \f[s_i = q_i\exp(-\frac{\log(q^*_iq_{i+1}) + \log(q^*_iq_{i-1})}{4}).\f]
+   * @param q0 the first quaternion.
+   * @param q1 the second quaternion.
+   * @param q2 the third quaternion.
+   * @param assumeUnit if QUAT_ASSUME_UNIT, all input quaternions assume to be
+   * unit quaternion. Otherwise, all input quaternions will be normalized inside
+   * the function.
+   * @sa squad
+   */
+  static Quat<_Tp> interPoint(const Quat<_Tp> &q0, const Quat<_Tp> &q1,
+                              const Quat<_Tp> &q2,
+                              QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT);
+
+  /**
+   * @brief to calculate a quaternion which is the result of a \f$C^1\f$
+   * continuous spline curve constructed by squad at the ratio t. Here, the
+   * interpolation values are between \f$q_1\f$ and \f$q_2\f$. \f$q_0\f$ and
+   * \f$q_2\f$ are used to ensure the \f$C^1\f$ continuity. if t = 0, it returns
+   * \f$q_1\f$, if t = 1, it returns \f$q_2\f$.
+   * @param q0 the first input quaternion to ensure \f$C^1\f$ continuity.
+   * @param q1 the second input quaternion.
+   * @param q2 the third input quaternion.
+   * @param q3 the fourth input quaternion the same use of \f$q1\f$.
+   * @param t ratio over a range [0, 1].
+   * @param assumeUnit if QUAT_ASSUME_UNIT, \f$q_0, q_1, q_2, q_3\f$ assume to
+   * be unit quaternion. Otherwise, all input quaternions will be normalized
+   * inside the function.
+   *
+   * For example:
+   *
+   * If there are three double quaternions \f$v_0, v_1, v_2\f$ waiting to be
+   * interpolated.
+   *
+   * Interpolation between \f$v_0\f$ and \f$v_1\f$ with a ratio \f$t_0\f$ could
+   * be calculated as
+   * ```
+   * Quatd::spline(v0, v0, v1, v2, t0);
+   * ```
+   * Interpolation between \f$v_1\f$ and \f$v_2\f$ with a ratio \f$t_0\f$ could
+   * be calculated as
+   * ```
+   * Quatd::spline(v0, v1, v2, v2, t0);
+   * ```
+   * @sa squad, 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);
+
+  /**
+   * @brief Return opposite quaternion \f$-p\f$
+   * which satisfies \f$p + (-p) = 0.\f$
+   *
+   * For example
+   * ```
+   * Quatd q{1, 2, 3, 4};
+   * std::cout << -q << std::endl; // [-1, -2, -3, -4]
+   * ```
+   */
+  Quat<_Tp> operator-() const;
+
+  /**
+   * @brief return true if two quaternions p and q are nearly equal, i.e. when
+   * the absolute value of each \f$p_i\f$ and \f$q_i\f$ is less than
+   * CV_QUAT_EPS.
+   */
+  bool operator==(const Quat<_Tp> &) const;
+
+  /**
+   * @brief Addition operator of two quaternions p and q.
+   * It returns a new quaternion that each value is the sum of \f$p_i\f$ and
+   * \f$q_i\f$.
+   *
+   * For example
+   * ```
+   * Quatd p{1, 2, 3, 4};
+   * Quatd q{5, 6, 7, 8};
+   * std::cout << p + q << std::endl; //[6, 8, 10, 12]
+   * ```
+   */
+  Quat<_Tp> operator+(const Quat<_Tp> &) const;
+
+  /**
+   * @brief Addition assignment operator of two quaternions p and q.
+   * It adds right operand to the left operand and assign the result to left
+   * operand.
+   *
+   * For example
+   * ```
+   * 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]
+   *
+   * ```
+   */
+  Quat<_Tp> &operator+=(const Quat<_Tp> &);
+
+  /**
+   * @brief Subtraction operator of two quaternions p and q.
+   * It returns a new quaternion that each value is the sum of \f$p_i\f$ and
+   * \f$-q_i\f$.
+   *
+   * For example
+   * ```
+   * Quatd p{1, 2, 3, 4};
+   * Quatd q{5, 6, 7, 8};
+   * std::cout << p - q << std::endl; //[-4, -4, -4, -4]
+   * ```
+   */
+  Quat<_Tp> operator-(const Quat<_Tp> &) const;
+
+  /**
+   * @brief Subtraction assignment operator of two quaternions p and q.
+   * It subtracts right operand from the left operand and assign the result to
+   * left operand.
+   *
+   * For example
+   * ```
+   * 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]
+   *
+   * ```
+   */
+  Quat<_Tp> &operator-=(const Quat<_Tp> &);
+
+  /**
+   * @brief Multiplication assignment operator of two quaternions q and p.
+   * It multiplies right operand with the left operand and assign the result to
+   * left operand.
+   *
+   * Rule of quaternion multiplication:
+   * \f[
+   * \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}
+   * \f]
+   * where \f$\cdot\f$ means dot product and \f$\times \f$ means cross product.
+   *
+   * For example
+   * ```
+   * 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]
+   * ```
+   */
+  Quat<_Tp> &operator*=(const Quat<_Tp> &);
+
+  /**
+   * @brief Multiplication assignment operator of a quaternions and a scalar.
+   * It multiplies right operand with the left operand and assign the result to
+   * left operand.
+   *
+   * Rule of quaternion multiplication with a scalar:
+   * \f[
+   * \begin{equation}
+   * \begin{split}
+   * p * s &= [w, x, y, z] * s\\
+   * &=[w * s, x * s, y * s, z * s].
+   * \end{split}
+   * \end{equation}
+   * \f]
+   *
+   * For example
+   * ```
+   * 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]
+   * ```
+   * @note the type of scalar should be equal to the quaternion.
+   */
+  Quat<_Tp> &operator*=(const _Tp s);
+
+  /**
+   * @brief Multiplication operator of two quaternions q and p.
+   * Multiplies values on either side of the operator.
+   *
+   * Rule of quaternion multiplication:
+   * \f[
+   * \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}
+   * \f]
+   * where \f$\cdot\f$ means dot product and \f$\times \f$ means cross product.
+   *
+   * For example
+   * ```
+   * Quatd p{1, 2, 3, 4};
+   * Quatd q{5, 6, 7, 8};
+   * std::cout << p * q << std::endl; //[-60, 12, 30, 24]
+   * ```
+   */
+  Quat<_Tp> operator*(const Quat<_Tp> &) const;
+
+  /**
+   * @brief Division operator of a quaternions and a scalar.
+   * It divides left operand with the right operand and assign the result to
+   * left operand.
+   *
+   * Rule of quaternion division with a scalar:
+   * \f[
+   * \begin{equation}
+   * \begin{split}
+   * p / s &= [w, x, y, z] / s\\
+   * &=[w/s, x/s, y/s, z/s].
+   * \end{split}
+   * \end{equation}
+   * \f]
+   *
+   * For example
+   * ```
+   * 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]
+   * ```
+   * @note the type of scalar should be equal to this quaternion.
+   */
+  Quat<_Tp> operator/(const _Tp s) const;
+
+  /**
+   * @brief Division operator of two quaternions p and q.
+   * Divides left hand operand by right hand operand.
+   *
+   * Rule of quaternion division with a scalar:
+   * \f[
+   * \begin{equation}
+   * \begin{split}
+   * p / q &= p * q.inv()\\
+   * \end{split}
+   * \end{equation}
+   * \f]
+   *
+   * For example
+   * ```
+   * Quatd p{1, 2, 3, 4};
+   * Quatd q{5, 6, 7, 8};
+   * std::cout << p / q << std::endl; // equivalent to p * q.inv()
+   * ```
+   */
+  Quat<_Tp> operator/(const Quat<_Tp> &) const;
+
+  /**
+   * @brief Division assignment operator of a quaternions and a scalar.
+   * It divides left operand with the right operand and assign the result to
+   * left operand.
+   *
+   * Rule of quaternion division with a scalar:
+   * \f[
+   * \begin{equation}
+   * \begin{split}
+   * p / s &= [w, x, y, z] / s\\
+   * &=[w / s, x / s, y / s, z / s].
+   * \end{split}
+   * \end{equation}
+   * \f]
+   *
+   * For example
+   * ```
+   * 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]
+   * ```
+   * @note the type of scalar should be equal to the quaternion.
+   */
+  Quat<_Tp> &operator/=(const _Tp s);
+
+  /**
+   * @brief Division assignment operator of two quaternions p and q;
+   * It divides left operand with the right operand and assign the result to
+   * left operand.
+   *
+   * Rule of quaternion division with a quaternion:
+   * \f[
+   * \begin{equation}
+   * \begin{split}
+   * p / q&= p * q.inv()\\
+   * \end{split}
+   * \end{equation}
+   * \f]
+   *
+   * For example
+   * ```
+   * 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;
+   * ```
+   */
+  Quat<_Tp> &operator/=(const Quat<_Tp> &);
+
+  _Tp &operator[](std::size_t n);
+
+  const _Tp &operator[](std::size_t n) const;
+
+  /**
+   * @brief Subtraction operator of a scalar and a quaternions.
+   * Subtracts right hand operand from left hand operand.
+   *
+   * For example
+   * ```
+   * Quatd p{1, 2, 3, 4};
+   * double scalar = 2.0;
+   * std::cout << scalar - p << std::endl; //[1.0, -2, -3, -4]
+   * ```
+   * @note the type of scalar should be equal to the quaternion.
+   */
+  template <typename T>
+  friend Quat<T> cv::operator-(const T s, const Quat<T> &);
+
+  /**
+   * @brief Subtraction operator of a quaternions and a scalar.
+   * Subtracts right hand operand from left hand operand.
+   *
+   * For example
+   * ```
+   * Quatd p{1, 2, 3, 4};
+   * double scalar = 2.0;
+   * std::cout << p - scalar << std::endl; //[-1.0, 2, 3, 4]
+   * ```
+   * @note the type of scalar should be equal to the quaternion.
+   */
+  template <typename T>
+  friend Quat<T> cv::operator-(const Quat<T> &, const T s);
+
+  /**
+   * @brief Addition operator of a quaternions and a scalar.
+   * Adds right hand operand from left hand operand.
+   *
+   * For example
+   * ```
+   * Quatd p{1, 2, 3, 4};
+   * double scalar = 2.0;
+   * std::cout << scalar + p << std::endl; //[3.0, 2, 3, 4]
+   * ```
+   * @note the type of scalar should be equal to the quaternion.
+   */
+  template <typename T>
+  friend Quat<T> cv::operator+(const T s, const Quat<T> &);
+
+  /**
+   * @brief Addition operator of a quaternions and a scalar.
+   * Adds right hand operand from left hand operand.
+   *
+   * For example
+   * ```
+   * Quatd p{1, 2, 3, 4};
+   * double scalar = 2.0;
+   * std::cout << p + scalar << std::endl; //[3.0, 2, 3, 4]
+   * ```
+   * @note the type of scalar should be equal to the quaternion.
+   */
+  template <typename T>
+  friend Quat<T> cv::operator+(const Quat<T> &, const T s);
+
+  /**
+   * @brief Multiplication operator of a scalar and a quaternions.
+   * It multiplies right operand with the left operand and assign the result to
+   * left operand.
+   *
+   * Rule of quaternion multiplication with a scalar:
+   * \f[
+   * \begin{equation}
+   * \begin{split}
+   * p * s &= [w, x, y, z] * s\\
+   * &=[w * s, x * s, y * s, z * s].
+   * \end{split}
+   * \end{equation}
+   * \f]
+   *
+   * For example
+   * ```
+   * Quatd p{1, 2, 3, 4};
+   * double s = 2.0;
+   * std::cout << s * p << std::endl; //[2.0, 4.0, 6.0, 8.0]
+   * ```
+   * @note the type of scalar should be equal to the quaternion.
+   */
+  template <typename T>
+  friend Quat<T> cv::operator*(const T s, const Quat<T> &);
+
+  /**
+   * @brief Multiplication operator of a quaternion and a scalar.
+   * It multiplies right operand with the left operand and assign the result to
+   * left operand.
+   *
+   * Rule of quaternion multiplication with a scalar:
+   * \f[
+   * \begin{equation}
+   * \begin{split}
+   * p * s &= [w, x, y, z] * s\\
+   * &=[w * s, x * s, y * s, z * s].
+   * \end{split}
+   * \end{equation}
+   * \f]
+   *
+   * For example
+   * ```
+   * Quatd p{1, 2, 3, 4};
+   * double s = 2.0;
+   * std::cout << p * s << std::endl; //[2.0, 4.0, 6.0, 8.0]
+   * ```
+   * @note the type of scalar should be equal to the quaternion.
+   */
+  template <typename T>
+  friend Quat<T> cv::operator*(const Quat<T> &, const T s);
+
+  template <typename S>
+  friend std::ostream &cv::operator<<(std::ostream &, const Quat<S> &);
+
+  /**
+   * @brief Transform a quaternion q to Euler angles.
+   *
+   *
+   * When transforming a quaternion \f$q = w + x\boldsymbol{i} + y\boldsymbol{j}
+   * + z\boldsymbol{k}\f$ to Euler angles, rotation matrix M can be calculated
+   * by:
+   * \f[ \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}.\f]
+   * On the other hand, the rotation matrix can be obtained from Euler angles.
+   * Using intrinsic rotations with Euler angles type XYZ as an example,
+   * \f$\theta_1 \f$, \f$\theta_2 \f$, \f$\theta_3 \f$ are three angles for
+   * Euler angles, the rotation matrix R can be calculated by:\f[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}}\f]
+   * Rotation matrix M and R are equal. As long as \f$ s_{2} \neq 1 \f$, by
+   * comparing each element of two matrices ,the solution is\f$\begin{cases}
+   * \theta_1 = \arctan2(-m_{23},m_{33})\\\theta_2 = arcsin(m_{13}) \\\theta_3 =
+   * \arctan2(-m_{12},m_{11}) \end{cases}\f$.
+   *
+   * When \f$ s_{2}=1\f$ or \f$ s_{2}=-1\f$, the gimbal lock occurs. The
+   * function will prompt "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.".
+   *
+   * When \f$ s_{2}=1\f$ ,
+   * The rotation matrix R is \f$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}}\f$.
+   *
+   * The number of solutions is infinite with the condition \f$\begin{cases}
+   * \theta_1+\theta_3 = \arctan2(m_{21},m_{22})\\ \theta_2=\pi/2
+   * \end{cases}\ \f$.
+   *
+   * We set \f$ \theta_3 = 0\f$, the solution is \f$\begin{cases}
+   * \theta_1=\arctan2(m_{21},m_{22})\\ \theta_2=\pi/2\\ \theta_3=0
+   * \end{cases}\f$.
+   *
+   * When \f$ s_{2}=-1\f$,
+   * The rotation matrix R is
+   * \f$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}}\f$.
+   *
+   * The number of solutions is infinite with the condition \f$\begin{cases}
+   * \theta_1+\theta_3 = \arctan2(m_{32},m_{22})\\ \theta_2=\pi/2
+   * \end{cases}\ \f$.
+   *
+   * We set \f$ \theta_3 = 0\f$, the solution is \f$
+   * \begin{cases}\theta_1=\arctan2(m_{32},m_{22})
+   * \\ \theta_2=-\pi/2\\  \theta_3=0\end{cases}\f$.
+   *
+   * Since \f$ sin \theta\in [-1,1] \f$ and \f$ cos \theta \in [-1,1] \f$, the
+   * unnormalized quaternion will cause computational troubles. For this reason,
+   * this function will normalize the quaternion at first and @ref
+   * QuatAssumeType is not needed.
+   *
+   * When the gimbal lock occurs, we set \f$\theta_3 = 0\f$ for intrinsic
+   * rotations or \f$\theta_1 = 0\f$ for extrinsic rotations.
+   *
+   * As a result, for every Euler angles type, we can get solution as shown in
+   * the following table. EulerAnglesType  | Ordinary | \f$\theta_2 = π/2\f$ |
+   * \f$\theta_2 = -π/2\f$
+   * ------------- | -------------| -------------| -------------
+   * INT_XYZ|\f$ \theta_1 = \arctan2(-m_{23},m_{33})\\\theta_2 = \arcsin(m_{13})
+   * \\\theta_3= \arctan2(-m_{12},m_{11}) \f$|\f$
+   * \theta_1=\arctan2(m_{21},m_{22})\\ \theta_2=\pi/2\\ \theta_3=0 \f$|\f$
+   * \theta_1=\arctan2(m_{32},m_{22})\\ \theta_2=-\pi/2\\ \theta_3=0 \f$
+   * INT_XZY|\f$ \theta_1 = \arctan2(m_{32},m_{22})\\\theta_2 = -\arcsin(m_{12})
+   * \\\theta_3= \arctan2(m_{13},m_{11}) \f$|\f$
+   * \theta_1=\arctan2(m_{31},m_{33})\\ \theta_2=\pi/2\\ \theta_3=0 \f$|\f$
+   * \theta_1=\arctan2(-m_{23},m_{33})\\ \theta_2=-\pi/2\\ \theta_3=0 \f$
+   * INT_YXZ|\f$ \theta_1 = \arctan2(m_{13},m_{33})\\\theta_2 = -\arcsin(m_{23})
+   * \\\theta_3= \arctan2(m_{21},m_{22}) \f$|\f$
+   * \theta_1=\arctan2(m_{12},m_{11})\\ \theta_2=\pi/2\\ \theta_3=0 \f$|\f$
+   * \theta_1=\arctan2(-m_{12},m_{11})\\ \theta_2=-\pi/2\\ \theta_3=0 \f$
+   * INT_YZX|\f$ \theta_1 = \arctan2(-m_{31},m_{11})\\\theta_2 = \arcsin(m_{21})
+   * \\\theta_3= \arctan2(-m_{23},m_{22}) \f$|\f$
+   * \theta_1=\arctan2(m_{13},m_{33})\\ \theta_2=\pi/2\\ \theta_3=0 \f$|\f$
+   * \theta_1=\arctan2(m_{13},m_{12})\\ \theta_2=-\pi/2\\ \theta_3=0 \f$
+   * INT_ZXY|\f$ \theta_1 = \arctan2(-m_{12},m_{22})\\\theta_2 = \arcsin(m_{32})
+   * \\\theta_3= \arctan2(-m_{31},m_{33}) \f$|\f$
+   * \theta_1=\arctan2(m_{21},m_{11})\\ \theta_2=\pi/2\\ \theta_3=0 \f$|\f$
+   * \theta_1=\arctan2(m_{21},m_{11})\\ \theta_2=-\pi/2\\ \theta_3=0 \f$
+   * INT_ZYX|\f$ \theta_1 = \arctan2(m_{21},m_{11})\\\theta_2 = \arcsin(-m_{31})
+   * \\\theta_3= \arctan2(m_{32},m_{33}) \f$|\f$
+   * \theta_1=\arctan2(m_{23},m_{22})\\ \theta_2=\pi/2\\ \theta_3=0 \f$|\f$
+   * \theta_1=\arctan2(-m_{12},m_{22})\\ \theta_2=-\pi/2\\ \theta_3=0 \f$
+   * EXT_XYZ|\f$ \theta_1 = \arctan2(m_{32},m_{33})\\\theta_2 = \arcsin(-m_{31})
+   * \\\ \theta_3 = \arctan2(m_{21},m_{11})\f$|\f$ \theta_1=
+   * 0\\ \theta_2=\pi/2\\ \theta_3=\arctan2(m_{23},m_{22}) \f$|\f$
+   * \theta_1=0\\ \theta_2=-\pi/2\\ \theta_3=\arctan2(-m_{12},m_{22}) \f$
+   * EXT_XZY|\f$ \theta_1 = \arctan2(-m_{23},m_{22})\\\theta_2 = \arcsin(m_{21})
+   * \\\theta_3=  \arctan2(-m_{31},m_{11})\f$|\f$ \theta_1=
+   * 0\\ \theta_2=\pi/2\\ \theta_3=\arctan2(m_{13},m_{33}) \f$|\f$
+   * \theta_1=0\\ \theta_2=-\pi/2\\ \theta_3=\arctan2(m_{13},m_{12}) \f$
+   * EXT_YXZ|\f$ \theta_1 = \arctan2(-m_{31},m_{33}) \\\theta_2 =
+   * \arcsin(m_{32}) \\\theta_3= \arctan2(-m_{12},m_{22})\f$|\f$ \theta_1=
+   * 0\\ \theta_2=\pi/2\\ \theta_3=\arctan2(m_{21},m_{11}) \f$|\f$
+   * \theta_1=0\\ \theta_2=-\pi/2\\ \theta_3=\arctan2(m_{21},m_{11}) \f$
+   * EXT_YZX|\f$ \theta_1 = \arctan2(m_{13},m_{11})\\\theta_2 = -\arcsin(m_{12})
+   * \\\theta_3= \arctan2(m_{32},m_{22})\f$|\f$ \theta_1=
+   * 0\\ \theta_2=\pi/2\\ \theta_3=\arctan2(m_{31},m_{33}) \f$|\f$
+   * \theta_1=0\\ \theta_2=-\pi/2\\ \theta_3=\arctan2(-m_{23},m_{33}) \f$
+   * EXT_ZXY|\f$ \theta_1 = \arctan2(m_{21},m_{22})\\\theta_2 = -\arcsin(m_{23})
+   * \\\theta_3= \arctan2(m_{13},m_{33})\f$|\f$ \theta_1=
+   * 0\\ \theta_2=\pi/2\\ \theta_3=\arctan2(m_{12},m_{11}) \f$|\f$ \theta_1=
+   * 0\\ \theta_2=-\pi/2\\ \theta_3=\arctan2(-m_{12},m_{11}) \f$ EXT_ZYX|\f$
+   * \theta_1 = \arctan2(-m_{12},m_{11})\\\theta_2 = \arcsin(m_{13}) \\\theta_3=
+   * \arctan2(-m_{23},m_{33})\f$|\f$
+   * \theta_1=0\\ \theta_2=\pi/2\\ \theta_3=\arctan2(m_{21},m_{22}) \f$|\f$
+   * \theta_1=0\\ \theta_2=-\pi/2\\ \theta_3=\arctan2(m_{32},m_{22}) \f$
+   *
+   *  EulerAnglesType  | Ordinary | \f$\theta_2 = 0\f$ | \f$\theta_2 = π\f$
+   * ------------- | -------------| -------------| -------------
+   * INT_XYX| \f$ \theta_1 = \arctan2(m_{21},-m_{31})\\\theta_2 =\arccos(m_{11})
+   * \\\theta_3 = \arctan2(m_{12},m_{13}) \f$| \f$
+   * \theta_1=\arctan2(m_{32},m_{33})\\ \theta_2=0\\ \theta_3=0 \f$| \f$
+   * \theta_1=\arctan2(m_{23},m_{22})\\ \theta_2=\pi\\ \theta_3=0 \f$ INT_XZX|
+   * \f$ \theta_1 = \arctan2(m_{31},m_{21})\\\theta_2 = \arccos(m_{11})
+   * \\\theta_3 = \arctan2(m_{13},-m_{12}) \f$| \f$
+   * \theta_1=\arctan2(m_{32},m_{33})\\ \theta_2=0\\ \theta_3=0 \f$| \f$
+   * \theta_1=\arctan2(-m_{32},m_{33})\\ \theta_2=\pi\\ \theta_3=0 \f$ INT_YXY|
+   * \f$ \theta_1 = \arctan2(m_{12},m_{32})\\\theta_2 = \arccos(m_{22})
+   * \\\theta_3 = \arctan2(m_{21},-m_{23}) \f$| \f$
+   * \theta_1=\arctan2(m_{13},m_{11})\\ \theta_2=0\\ \theta_3=0 \f$| \f$
+   * \theta_1=\arctan2(-m_{31},m_{11})\\ \theta_2=\pi\\ \theta_3=0 \f$ INT_YZY|
+   * \f$ \theta_1 = \arctan2(m_{32},-m_{12})\\\theta_2 = \arccos(m_{22})
+   * \\\theta_3 =\arctan2(m_{23},m_{21}) \f$| \f$
+   * \theta_1=\arctan2(m_{13},m_{11})\\ \theta_2=0\\ \theta_3=0 \f$| \f$
+   * \theta_1=\arctan2(m_{13},-m_{11})\\ \theta_2=\pi\\ \theta_3=0 \f$ INT_ZXZ|
+   * \f$ \theta_1 = \arctan2(-m_{13},m_{23})\\\theta_2 = \arccos(m_{33})
+   * \\\theta_3 =\arctan2(m_{31},m_{32}) \f$| \f$
+   * \theta_1=\arctan2(m_{21},m_{22})\\ \theta_2=0\\ \theta_3=0 \f$| \f$
+   * \theta_1=\arctan2(m_{21},m_{11})\\ \theta_2=\pi\\ \theta_3=0 \f$ INT_ZYZ|
+   * \f$ \theta_1 = \arctan2(m_{23},m_{13})\\\theta_2 = \arccos(m_{33})
+   * \\\theta_3 = \arctan2(m_{32},-m_{31}) \f$| \f$
+   * \theta_1=\arctan2(m_{21},m_{11})\\ \theta_2=0\\ \theta_3=0 \f$| \f$
+   * \theta_1=\arctan2(m_{21},m_{11})\\ \theta_2=\pi\\ \theta_3=0 \f$ EXT_XYX|
+   * \f$ \theta_1 = \arctan2(m_{12},m_{13}) \\\theta_2 = \arccos(m_{11})
+   * \\\theta_3 = \arctan2(m_{21},-m_{31})\f$| \f$
+   * \theta_1=0\\ \theta_2=0\\ \theta_3=\arctan2(m_{32},m_{33}) \f$| \f$
+   * \theta_1= 0\\ \theta_2=\pi\\ \theta_3= \arctan2(m_{23},m_{22}) \f$ EXT_XZX|
+   * \f$ \theta_1 = \arctan2(m_{13},-m_{12})\\\theta_2 = \arccos(m_{11})
+   * \\\theta_3 = \arctan2(m_{31},m_{21})\f$| \f$ \theta_1=
+   * 0\\ \theta_2=0\\ \theta_3=\arctan2(m_{32},m_{33}) \f$| \f$ \theta_1=
+   * 0\\ \theta_2=\pi\\ \theta_3=\arctan2(-m_{32},m_{33}) \f$ EXT_YXY| \f$
+   * \theta_1 = \arctan2(m_{21},-m_{23})\\\theta_2 = \arccos(m_{22}) \\\theta_3
+   * = \arctan2(m_{12},m_{32}) \f$| \f$ \theta_1=
+   * 0\\ \theta_2=0\\ \theta_3=\arctan2(m_{13},m_{11}) \f$| \f$ \theta_1=
+   * 0\\ \theta_2=\pi\\ \theta_3=\arctan2(-m_{31},m_{11}) \f$ EXT_YZY| \f$
+   * \theta_1 = \arctan2(m_{23},m_{21}) \\\theta_2 = \arccos(m_{22}) \\\theta_3
+   * = \arctan2(m_{32},-m_{12}) \f$| \f$ \theta_1=
+   * 0\\ \theta_2=0\\ \theta_3=\arctan2(m_{13},m_{11}) \f$| \f$
+   * \theta_1=0\\ \theta_2=\pi\\ \theta_3=\arctan2(m_{13},-m_{11}) \f$ EXT_ZXZ|
+   * \f$ \theta_1 = \arctan2(m_{31},m_{32}) \\\theta_2 = \arccos(m_{33})
+   * \\\theta_3 = \arctan2(-m_{13},m_{23})\f$| \f$
+   * \theta_1=0\\ \theta_2=0\\ \theta_3=\arctan2(m_{21},m_{22}) \f$| \f$
+   * \theta_1= 0\\ \theta_2=\pi\\ \theta_3=\arctan2(m_{21},m_{11}) \f$ EXT_ZYZ|
+   * \f$ \theta_1 = \arctan2(m_{32},-m_{31})\\\theta_2 = \arccos(m_{33})
+   * \\\theta_3 = \arctan2(m_{23},m_{13}) \f$| \f$
+   * \theta_1=0\\ \theta_2=0\\ \theta_3=\arctan2(m_{21},m_{11}) \f$| \f$
+   * \theta_1= 0\\ \theta_2=\pi\\ \theta_3=\arctan2(m_{21},m_{11}) \f$
+   *
+   * @param eulerAnglesType the convertion Euler angles type
+   */
+
+  Vec<_Tp, 3> toEulerAngles(QuatEnum::EulerAnglesType eulerAnglesType);
+
+  _Tp w, x, y, z;
+};
+
+template <typename T>
+Quat<T> inv(const Quat<T> &q, QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT);
+
+template <typename T> Quat<T> sinh(const Quat<T> &q);
+
+template <typename T> Quat<T> cosh(const Quat<T> &q);
+
+template <typename T> Quat<T> tanh(const Quat<T> &q);
+
+template <typename T> Quat<T> sin(const Quat<T> &q);
+
+template <typename T> Quat<T> cos(const Quat<T> &q);
+
+template <typename T> Quat<T> tan(const Quat<T> &q);
+
+template <typename T> Quat<T> asinh(const Quat<T> &q);
+
+template <typename T> Quat<T> acosh(const Quat<T> &q);
+
+template <typename T> Quat<T> atanh(const Quat<T> &q);
+
+template <typename T> Quat<T> asin(const Quat<T> &q);
+
+template <typename T> Quat<T> acos(const Quat<T> &q);
+
+template <typename T> Quat<T> atan(const Quat<T> &q);
+
+template <typename T>
+Quat<T> power(const Quat<T> &q, const Quat<T> &p,
+              QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT);
+
+template <typename T> Quat<T> exp(const Quat<T> &q);
+
+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> &q, const T x,
+              QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT);
+
+template <typename T> Quat<T> crossProduct(const Quat<T> &p, const Quat<T> &q);
+
+template <typename S>
+Quat<S> sqrt(const Quat<S> &q,
+             QuatAssumeType assumeUnit = QUAT_ASSUME_NOT_UNIT);
+
+template <typename T> Quat<T> operator*(const T, const Quat<T> &);
+
+template <typename T> Quat<T> operator*(const Quat<T> &, const T);
+
+template <typename S> std::ostream &operator<<(std::ostream &, const Quat<S> &);
+
+using Quatd = Quat<double>;
+using Quatf = Quat<float>;
+
+//! @} core
+} // namespace cv
+
+#include "opencv2/core/quaternion.inl.hpp"
+
+#endif /* OPENCV_CORE_QUATERNION_HPP */