node-native-win-utils 1.3.4 → 2.1.0

package/include/opencv2/core/quaternion.hpp

@@ -1,1696 +0,0 @@
-// 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 <opencv2/core.hpp>
-#include <opencv2/core/utils/logger.hpp>
-#include <iostream>
-namespace cv
-{
-//! @addtogroup core
-//! @{
-
-//! 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})={\begin{bmatrix}1&0&0\\0&\cos {\theta_1} &-\sin {\theta_1} \\0&\sin {\theta_1} &\cos {\theta_1} \\\end{bmatrix}},
-     * Y({\theta})={\begin{bmatrix}\cos \theta_{2}&0&\sin \theta_{2}\\0&1 &0 \\\ -sin \theta_2& 0&\cos \theta_{2} \\\end{bmatrix}},
-     * Z({\theta})={\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
-}
-
-#include "opencv2/core/quaternion.inl.hpp"
-
-#endif /* OPENCV_CORE_QUATERNION_HPP */