Vector2D.h

浏览该文件的文档.

/************************************************************************
* @file Vector2D.h
*
* @brief 二维坐标/向量类
*
* @details 二维坐标/向量类
*
* @author lirf
*
* @version 1.0
*
* @date 2025-6-12
*
* @license 北京华科软科技有限公司
*
*************************************************************************/
 
#ifndef BIMHOMEBASE_VECTOR2D_H
#define BIMHOMEBASE_VECTOR2D_H
#ifndef BH_GLOBAL_H
#include <BHGlobal.h>
#endif
#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    /* max decimal value of a "double"*/
#endif
 
#ifndef  DOUBLE_MIN
# define DOUBLE_MIN 2.2250738585072014E-308    /* min decimal value of a "double"*/
#endif
 
 
namespace Base
{
    class BaseExport Vector2d
    {
    public:
 
        inline Vector2d();
 
        inline Vector2d(float x, float y);
 
        inline Vector2d(double x, double y);
 
        inline Vector2d(const Vector2d& v);
 
        // operators
        inline Vector2d& operator= (const Vector2d& v);
 
        inline bool operator== (const Vector2d& v) const;
 
        inline Vector2d operator+ (void) const;
 
        inline Vector2d operator+ (const Vector2d& v) const;
 
        inline Vector2d& operator+= (const Vector2d& v);
 
        inline Vector2d operator- (void) const;
 
        inline Vector2d operator- (const Vector2d& v) const;
 
        inline Vector2d& operator-= (const Vector2d& v);
 
        inline Vector2d operator* (double c) const;
 
        inline Vector2d& operator*= (double c);
 
        inline double operator* (const Vector2d& v) const;
 
        inline Vector2d operator/ (double c) const;
 
        inline Vector2d& operator/= (double c);
 
        // methods
        inline bool IsNull(double tolerance = 0.0) const;
 
        inline double Length() const;
 
        inline double Angle() const;
 
        inline double Sqr() const;
 
        inline Vector2d& Set(double x, double y);
 
        inline Vector2d& Negate();
 
        inline Vector2d& Scale(double factor);
 
        inline Vector2d& Rotate(double angle);
 
        inline Vector2d& Normalize();
 
        inline Vector2d Perpendicular(bool clockwise = false) const;
 
        static inline Vector2d FromPolar(double r, double fi);
 
        inline double Distance(const Vector2d& v) const;
 
        static inline double Distance(const Vector2d& v1, const Vector2d& v2)
        {
            double x = v1.x - v2.x, y = v1.y - v2.y;
            return static_cast<double>(sqrt((x * x) + (y * y)));
        }
 
        inline bool IsEqual(const Vector2d& v, double tolerance = 0.0) const;
 
        inline bool IsLess(const Vector2d& v, double tolerance = 0.0) const;
 
        double GetAngle(const Vector2d& v) const;
 
        void ProjectToLine(const Vector2d& point, const Vector2d& line);
 
        Vector2d alongLineNormalMoveDistancePt(const Vector2d& rclP0, const Vector2d& rclP1, double d) const;
 
        Vector2d moveAlongLine(const Vector2d& rclP0, const Vector2d& rclP1, double d) const;
 
        Vector2d alongLineAngleMoveDistancePt(const Vector2d& rclP0, const Vector2d& rclP1, double angle, double d) const;
 
        Vector2d alongLineNormalDir(const Vector2d& rclP0, const Vector2d& rclP1) const;
 
        Vector2d perpendicularPointOnLine(const Vector2d& A, const Vector2d& B);
 
    public:
            double x, y; 
    };
 
    inline Vector2d::Vector2d()
        : x(0.0), y(0.0)
    {
    }
 
    inline Vector2d::Vector2d(float x, float y)
        : x(double(x)), y(double(y))
    {
    }
 
    inline Vector2d::Vector2d(double x, double y)
        : x(x), y(y)
    {
    }
 
    inline Vector2d::Vector2d(const Base::Vector2d& v)
        : x(v.x), y(v.y)
    {
    }
 
    inline Vector2d& Vector2d::operator= (const Vector2d& v)
    {
        x = v.x;
        y = v.y;
        return *this;
    }
 
    inline bool Vector2d::operator== (const Vector2d& v) const
    {
        return (x == v.x) && (y == v.y);
    }
 
    inline Vector2d Vector2d::operator+ () const
    {
        return Vector2d(x, y);
    }
 
    inline Vector2d Vector2d::operator+ (const Vector2d& v) const
    {
        return Vector2d(x + v.x, y + v.y);
    }
 
    inline Vector2d& Vector2d::operator+= (const Vector2d& v)
    {
        x += v.x;
        y += v.y;
        return *this;
    }
 
    inline Vector2d Vector2d::operator- () const
    {
        return Vector2d(-x, -y);
    }
 
    inline Vector2d Vector2d::operator- (const Vector2d& v) const
    {
        return Vector2d(x - v.x, y - v.y);
    }
 
    inline Vector2d& Vector2d::operator-= (const Vector2d& v)
    {
        x -= v.x;
        y -= v.y;
        return *this;
    }
 
    inline Vector2d Vector2d::operator* (double c) const
    {
        return Vector2d(c * x, c * y);
    }
 
    inline Vector2d& Vector2d::operator*= (double c)
    {
        x *= c;
        y *= c;
        return *this;
    }
 
    inline double Vector2d::operator* (const Vector2d& v) const
    {
        return x * v.x + y * v.y;
    }
 
    inline Vector2d operator* (double c, const Vector2d& v)
    {
        return Vector2d(c * v.x, c * v.y);
    }
 
    inline Vector2d Vector2d::operator/ (double c) const
    {
        return Vector2d(x / c, y / c);
    }
 
    inline Vector2d& Vector2d::operator/= (double c)
    {
        x /= c;
        y /= c;
        return *this;
    }
 
    inline bool Vector2d::IsNull(double tolerance) const
    {
        return x * x + y * y <= tolerance * tolerance;
    }
 
    inline double Vector2d::Length() const
    {
        return sqrt(x * x + y * y);
    }
 
    inline double Vector2d::Angle() const
    {
        return atan2(y, x);
    }
 
    inline double Vector2d::Sqr() const
    {
        return x * x + y * y;
    }
 
    inline Vector2d& Vector2d::Set(double x, double y)
    {
        this->x = x;
        this->y = y;
        return *this;
    }
 
    inline Vector2d& Vector2d::Negate()
    {
        x = -x;
        y = -y;
        return *this;
    }
 
    inline Vector2d& Vector2d::Scale(double factor)
    {
        x *= factor;
        y *= factor;
        return *this;
    }
 
    inline Vector2d& Vector2d::Rotate(double angle)
    {
        Vector2d cPt(*this);
        x = cPt.x * cos(angle) - cPt.y * sin(angle);
        y = cPt.x * sin(angle) + cPt.y * cos(angle);
        return *this;
    }
 
    inline Vector2d& Vector2d::Normalize()
    {
        double length = Length();
        if (length > 0.0)
        {
            x /= length;
            y /= length;
        }
 
        return *this;
    }
 
    inline Vector2d Vector2d::Perpendicular(bool clockwise) const
    {
        return clockwise ? Vector2d(y, -x) : Vector2d(-y, x);
    }
 
    inline Vector2d Vector2d::FromPolar(double r, double fi)
    {
        return Vector2d(r * cos(fi), r * sin(fi));
    }
 
    inline double Vector2d::Distance(const Vector2d& v) const
    {
        double dx = (x - v.x);
        double dy = (y - v.y);
 
        return sqrt(dx * dx + dy * dy);
    }
 
    inline bool Vector2d::IsEqual(const Vector2d& v, double tolerance) const
    {
        return Distance(v) <= tolerance;
    }
} // namespace Base
 
#endif // BIMHOMEBASE_VECTOR3D_H