Vector3D.h

浏览该文件的文档.

/************************************************************************
* @file Vector3D.h
*
* @brief 坐标/向量类
*
* @details 坐标/向量类
*
* @author dixu
*
* @version 1.0
*
* @date 2014-9-11
*
* @license 北京华科软科技有限公司
*
*************************************************************************/
 
#ifndef BIMHOMEBASE_VECTOR3D_H
#define BIMHOMEBASE_VECTOR3D_H
 
#include <cmath>
#include <cfloat>
#include <stdexcept>
#ifndef  F_PI
# define F_PI  3.1415926f
#endif
 
#ifndef  D_PI
# define D_PI  3.141592653589793
#endif
 
#ifndef  FLOAT_MAX
# define FLOAT_MAX 3.402823466E+38F
#endif
 
#ifndef  FLOAT_MIN
# define FLOAT_MIN 1.175494351E-38F
#endif
 
#ifndef  DOUBLE_MAX
# define DOUBLE_MAX 1.7976931348623157E+308    
#endif
 
#ifndef  DOUBLE_MIN
# define DOUBLE_MIN 2.2250738585072014E-308   
#endif
 
 
namespace Base
{
 
 
    template <class numT>
    struct float_traits
    {
    };
 
    template <>
    struct float_traits<float>
    {
        typedef float float_type; 
        static inline float_type pi()
        {
            return F_PI;
        }
 
        static inline float_type epsilon()
        {
            return FLT_EPSILON;
        }
 
        static inline float_type maximum()
        {
            return FLT_MAX;
        }
    };
 
    template <>
    struct float_traits<double>
    {
        typedef double float_type; 
        static inline float_type pi()
        {
            return D_PI;
        }
 
        static inline float_type epsilon()
        {
            return DBL_EPSILON;
        }
 
        static inline float_type maximum()
        {
            return DBL_MAX;
        }
    };
    template <class _Precision>
    class Vector3
    {
    public:
 
        typedef _Precision num_type;                
        typedef float_traits<num_type> traits_type; 
 
        explicit Vector3(_Precision fx = 0.0, _Precision fy = 0.0, _Precision fz = 0.0);
 
        Vector3(const Vector3<_Precision>& v) = default;
 
        Vector3(Vector3<_Precision> && v) = default;
 
        ~Vector3() = default;
 
        void SetX(_Precision fX);
 
        void SetY(_Precision fY);
 
        void SetZ(_Precision fZ);
 
        _Precision magnitude2D() const;
 
        _Precision getDotProduct(const Vector3<_Precision>& v1, const Vector3<_Precision>& v2) const;
 
        _Precision angle() const;
 
        static Vector3 minimum(const Vector3& v1, const Vector3& v2);
 
        static Vector3 maximum(const Vector3& v1, const Vector3& v2);
 
        int IsOnLineSide(const Vector3<_Precision>& p1, const Vector3<_Precision>& p2, const Vector3<_Precision>& pot) const;
 
        static Vector3 calFootOfPerpendicular(const Vector3<_Precision>& A, const Vector3<_Precision>& B, const Vector3<_Precision>& C);
 
        static Vector3 calFixedAngleAndDistanceAndOnLinePoint(const Vector3<_Precision>& A, const Vector3<_Precision>& B, const Vector3<_Precision>& C, double angle, double d);
 
        static inline num_type epsilon()
        {
            return traits_type::epsilon();
        }
 
        _Precision Dot(const Vector3<_Precision>& rcVct) const;
 
        Vector3 Cross(const Vector3<_Precision>& rcVct) const;
 
        Vector3 absoluteValue() const;
 
        bool IsOnLineSegment(const Vector3<_Precision>& startVct, const Vector3<_Precision>& endVct) const;
 
        void ScaleX(_Precision f);
 
        void ScaleY(_Precision f);
 
        void ScaleZ(_Precision f);
 
        void Scale(_Precision fX, _Precision fY, _Precision fZ);
 
        void MoveX(_Precision f);
 
        void MoveY(_Precision f);
 
        void MoveZ(_Precision f);
 
        void Move(_Precision fX, _Precision fY, _Precision fZ);
 
        void RotateX(_Precision f);
 
        void RotateY(_Precision f);
 
        void RotateZ(_Precision f);
 
        void Set(_Precision fX, _Precision fY, _Precision fZ);
 
        _Precision Length() const;
 
        _Precision Sqr() const;
 
        Vector3& Normalize();
 
        bool IsNull() const;
 
        _Precision GetAngle(const Vector3& rcVect) const;
 
        void TransformToCoordinateSystem(const Vector3& rclBase, const Vector3& rclDirX, const Vector3& rclDirY);
 
        bool IsEqual(const Vector3& rclPnt, _Precision tol) const;
 
        Vector3& ProjectToPlane(const Vector3& rclBase, const Vector3& rclNorm);
 
        void ProjectToPlane(const Vector3& rclBase, const Vector3& rclNorm, Vector3& rclProj) const;
 
        Vector3& ProjectToLine(const Vector3& rclPoint, const Vector3& rclLine);
 
        Vector3 Perpendicular(const Vector3& rclBase, const Vector3& rclDir) const;
 
        _Precision DistanceToPlane(const Vector3& rclBase, const Vector3& rclNorm) const;
 
        _Precision DistanceToLine(const Vector3& rclBase, const Vector3& rclDirect) const;
 
        Vector3 DistanceToLineSegment(const Vector3& rclP1, const Vector3& rclP2) const;
 
        Vector3 moveAlongLinePt(const Vector3& rclP1, const double& d) const;
 
        Vector3 findPointOnLine(const Vector3& dir, const double& d) const;
 
        bool isParallelX() const;
 
        bool isParallelZ() const;
 
        bool isParallelY() const;
 
        _Precision& operator [] (unsigned short usIndex);
 
        const _Precision& operator [] (unsigned short usIndex) const;
 
        Vector3 operator +  (const Vector3<_Precision>& rcVct) const;
 
        Vector3 operator &  (const Vector3<_Precision>& rcVct) const;
 
        Vector3 operator -  (const Vector3<_Precision>& rcVct) const;
 
        Vector3 operator - () const;
 
        Vector3& operator += (const Vector3<_Precision>& rcVct);
 
        Vector3& operator -= (const Vector3<_Precision>& rcVct);
 
        Vector3 operator * (_Precision fScale) const;
 
        Vector3 operator / (_Precision fDiv) const;
 
        Vector3& operator *= (_Precision fScale);
 
        Vector3& operator /= (_Precision fDiv);
 
        Vector3& operator =  (const Vector3<_Precision>& v) = default;
 
        Vector3& operator =  (Vector3<_Precision>&& v) = default;
 
        _Precision operator *  (const Vector3<_Precision>& rcVct) const;
 
        Vector3 operator %  (const Vector3<_Precision>& rcVct) const;
 
        bool operator != (const Vector3<_Precision>& rcVct) const;
 
        bool operator == (const Vector3<_Precision>& rcVct) const;
 
        bool operator < (const Vector3<_Precision>& rcVct) const;
 
    public:
        _Precision x; 
        _Precision y; 
        _Precision z; 
    };
 
 
 
    template <class _Precision>
    Base::Vector3<_Precision> Base::Vector3<_Precision>::calFixedAngleAndDistanceAndOnLinePoint(const Vector3<_Precision>& A, const Vector3<_Precision>& B, const Vector3<_Precision>& C, double angle, double d)
    {
        Base::Vector3<_Precision> AB = B - A;
        Base::Vector3<_Precision> dirAB = AB.Normalize();
        Base::Vector3<_Precision> normAB(-dirAB.y, dirAB.x); // 法向量（右手螺旋规则）
 
        Base::Vector3<_Precision> dirNew(cos(angle), sin(angle), 0);
 
        double denominator = dirNew.Dot(normAB);
        if (std::abs(denominator) < 1e-10) {
            throw std::invalid_argument("Direction is parallel to AB. No unique solution.");
        }
 
        double t = d / denominator;
        return C + dirNew * t;
    }
 
    template <class _Precision>
    Base::Vector3<_Precision> Base::Vector3<_Precision>::calFootOfPerpendicular(const Vector3<_Precision>& A, const Vector3<_Precision>& B, const Vector3<_Precision>& C)
    {
        Base::Vector3<_Precision> AB = B - A;
        double abDotAb = AB.Dot(AB);
 
        if (abDotAb == 0) {
            throw std::invalid_argument("A and B are the same point. Cannot define a line.");
        }
 
        Base::Vector3<_Precision> AC = C - A;
        double t = AC.Dot(AB) / abDotAb;
 
        return A + AB * t;
    }
 
    template <class _Precision>
    Base::Vector3<_Precision> Base::Vector3<_Precision>::findPointOnLine(const Base::Vector3<_Precision>& dir, const double& d) const
    {
        double k = d / dir.Length();
        Base::Vector3<_Precision> point;
        point.x = this->x + k * dir.x;
        point.y = this->y + k * dir.y;
        point.z = this->z + k * dir.z;
        return point;
    }
 
    template <class _Precision>
    Base::Vector3<_Precision> Base::Vector3<_Precision>::moveAlongLinePt(const Vector3<_Precision>& rclP1, const double& d) const
    {
        double dx = rclP1.x - this->x;
        double dy = rclP1.y - this->y;
        double dz = rclP1.z - this->z;
        double L = std::sqrt(std::pow(rclP1.x - this->x, 2) + std::pow(rclP1.y - this->y, 2) + std::pow(rclP1.z - this->z, 2));
        double unit_dx = dx / L;
        double unit_dy = dy / L;
        double unit_dz = dz / L;
        double xNew = this->x + unit_dx * d;
        double yNew = this->y + unit_dy * d;
        double zNew = this->z + unit_dz * d;
        return Base::Vector3<_Precision>(xNew, yNew, zNew);
    }
 
    template <class _Precision>
    int Base::Vector3<_Precision>::IsOnLineSide(const Vector3<_Precision>& p1, const Vector3<_Precision>& p2, const Vector3<_Precision>& pot) const
    {
        int A = p2.y - p1.y;
        int B = p1.x - p2.x;
        int C = A * (p1.x) + B * (p1.y);
        int F = A * (pot.x - p1.x) + B * (pot.y - p1.y);
 
        if (F > FLT_EPSILON) return 1;
        if (F < FLT_EPSILON) return -1;
        return 0; // 在直线上
    }
 
    template <class _Precision>
    inline _Precision Distance(const Vector3<_Precision>& v1, const Vector3<_Precision>& v2)
    {
        _Precision x = v1.x - v2.x, y = v1.y - v2.y, z = v1.z - v2.z;
        return static_cast<_Precision>(sqrt((x * x) + (y * y) + (z * z)));
    }
 
    template <class _Precision>
    inline _Precision DistanceP2(const Vector3<_Precision>& v1, const Vector3<_Precision>& v2)
    {
        _Precision x = v1.x - v2.x, y = v1.y - v2.y, z = v1.z - v2.z;
        return x * x + y * y + z * z;
    }
 
    template <class _Precision>
    inline Vector3<_Precision> operator * (_Precision fFac, const Vector3<_Precision>& rcVct)
    {
        return Vector3<_Precision>(rcVct.x * fFac, rcVct.y * fFac, rcVct.z * fFac);
    }
 
    template <class _Pr1, class _Pr2>
    inline Vector3<_Pr1> toVector(const Vector3<_Pr2>& v)
    {
        return Vector3<_Pr1>(static_cast<_Pr1>(v.x), static_cast<_Pr1>(v.y), static_cast<_Pr1>(v.z));
    }
 
    typedef Vector3<float>  Vector3f;
    typedef Vector3<double> Vector3d;
} // namespace Base
 
#endif // BIMHOMEBASE_VECTOR3D_H