dualquaternion.hpp

// 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 <kongliangqian@huawei.com>
//         Longbu Wang <wanglongbu@huawei.com>
#ifndef OPENCV_CORE_DUALQUATERNION_HPP
#define OPENCV_CORE_DUALQUATERNION_HPP
 
#include <opencv2/core/quaternion.hpp>
#include <opencv2/core/affine.hpp>
 
namespace cv{
 
template <typename _Tp> class DualQuat;
template <typename _Tp> std::ostream& operator<<(std::ostream&, const DualQuat<_Tp>&);
 
template <typename _Tp>
class CV_EXPORTS DualQuat{
    static_assert(std::is_floating_point<_Tp>::value, "Dual quaternion only make sense with type of float or double");
    using value_type = _Tp;
 
public:
    static constexpr _Tp CV_DUAL_QUAT_EPS = (_Tp)1.e-6;
 
    DualQuat();
 
    DualQuat(const _Tp w, const _Tp x, const _Tp y, const _Tp z, const _Tp w_, const _Tp x_, const _Tp y_, const _Tp z_);
 
    DualQuat(const Vec<_Tp, 8> &q);
 
    _Tp w, x, y, z, w_, x_, y_, z_;
 
    static DualQuat<_Tp> createFromQuat(const Quat<_Tp> &realPart, const Quat<_Tp> &dualPart);
 
    static DualQuat<_Tp> createFromAngleAxisTrans(const _Tp angle, const Vec<_Tp, 3> &axis, const Vec<_Tp, 3> &translation);
 
    static DualQuat<_Tp> createFromMat(InputArray _R);
 
    static DualQuat<_Tp> createFromAffine3(const Affine3<_Tp> &R);
 
    static DualQuat<_Tp> createFromPitch(const _Tp angle, const _Tp d, const Vec<_Tp, 3> &axis, const Vec<_Tp, 3> &moment);
 
    Quat<_Tp> getRealPart() const;
 
    Quat<_Tp> getDualPart() const;
 
    template <typename T>
    friend DualQuat<T> conjugate(const DualQuat<T> &dq);
 
    DualQuat<_Tp> conjugate() const;
 
    Quat<_Tp> getRotation(QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const;
 
    Vec<_Tp, 3> getTranslation(QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const;
 
    DualQuat<_Tp> norm() const;
 
    DualQuat<_Tp> normalize() const;
 
    template <typename T>
    friend DualQuat<T> inv(const DualQuat<T> &dq, QuatAssumeType assumeUnit);
 
    DualQuat<_Tp> inv(QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const;
 
    _Tp dot(DualQuat<_Tp> p) const;
 
    template <typename T>
    friend DualQuat<T> power(const DualQuat<T> &dq, const T t, QuatAssumeType assumeUnit);
 
    DualQuat<_Tp> power(const _Tp t, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const;
 
    template <typename T>
    friend DualQuat<T> power(const DualQuat<T>& p, const DualQuat<T>& q, QuatAssumeType assumeUnit);
 
    DualQuat<_Tp> power(const DualQuat<_Tp>& q, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const;
 
    template <typename T>
    friend DualQuat<T> exp(const DualQuat<T> &dq);
 
    DualQuat<_Tp> exp() const;
 
    template <typename T>
    friend DualQuat<T> log(const DualQuat<T> &dq, QuatAssumeType assumeUnit);
 
    DualQuat<_Tp> log(QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const;
 
    Vec<_Tp, 8> toVec() const;
 
    Matx<_Tp, 4, 4> toMat(QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const;
 
    Affine3<_Tp> toAffine3(QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT) const;
 
    static DualQuat<_Tp> sclerp(const DualQuat<_Tp> &q1, const DualQuat<_Tp> &q2, const _Tp t,
                                bool directChange=true, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT);
    static DualQuat<_Tp> dqblend(const DualQuat<_Tp> &q1, const DualQuat<_Tp> &q2, const _Tp t,
                                   QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT);
 
    template <int cn>
    static DualQuat<_Tp> gdqblend(const Vec<DualQuat<_Tp>, cn> &dualquat, InputArray weights,
                                QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT);
 
    static DualQuat<_Tp> gdqblend(InputArray dualquat, InputArray weights,
                                QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT);
 
    DualQuat<_Tp> operator-() const;
 
    bool operator==(const DualQuat<_Tp>&) const;
 
    DualQuat<_Tp> operator-(const DualQuat<_Tp>&) const;
 
    DualQuat<_Tp>& operator-=(const DualQuat<_Tp>&);
 
    DualQuat<_Tp> operator+(const DualQuat<_Tp>&) const;
 
    DualQuat<_Tp>& operator+=(const DualQuat<_Tp>&);
 
    DualQuat<_Tp>& operator*=(const DualQuat<_Tp>&);
 
    DualQuat<_Tp> operator*=(const _Tp s);
 
 
    DualQuat<_Tp> operator*(const DualQuat<_Tp>&) const;
 
    DualQuat<_Tp> operator/(const _Tp s) const;
 
    DualQuat<_Tp> operator/(const DualQuat<_Tp>&) const;
 
    DualQuat<_Tp>& operator/=(const DualQuat<_Tp>&);
 
    Quat<_Tp>& operator/=(const _Tp s);
 
    template <typename T>
    friend DualQuat<T> cv::operator+(const T s, const DualQuat<T>&);
 
    template <typename T>
    friend DualQuat<T> cv::operator+(const DualQuat<T>&, const T s);
 
    template <typename T>
    friend DualQuat<T> cv::operator*(const T s, const DualQuat<T>&);
 
    template <typename T>
    friend DualQuat<T> cv::operator-(const DualQuat<T>&, const T s);
 
    template <typename T>
    friend DualQuat<T> cv::operator-(const T s, const DualQuat<T>&);
 
    template <typename T>
    friend DualQuat<T> cv::operator*(const DualQuat<T>&, const T s);
 
    template <typename S>
    friend std::ostream& cv::operator<<(std::ostream&, const DualQuat<S>&);
 
};
 
using DualQuatd = DualQuat<double>;
using DualQuatf = DualQuat<float>;
 
}//namespace
 
#include "dualquaternion.inl.hpp"
 
#endif /* OPENCV_CORE_QUATERNION_HPP */