BoundBox2D.h

浏览该文件的文档.

/************************************************************************
* @file BoundBox2d.h
*
* @brief 二维包围盒类
*
* @details 二维包围盒类
*
* @author lirf
*
* @version 1.0
*
* @date 2025-6-12
*
* @license 北京华科软科技有限公司
*
*************************************************************************/
 
#ifndef BIMHOMEBASE_BOUNDBOX2D_H
#define BIMHOMEBASE_BOUNDBOX2D_H
#ifndef BH_GLOBAL_H
#include <BHGlobal.h>
#endif
#include <cmath>
#include <cfloat>
#include <stdexcept>
#include "Base/Vector2D.h"
#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    /* "double" 最大值 */
#endif
 
#ifndef  DOUBLE_MIN
# define DOUBLE_MIN 2.2250738585072014E-308    /* "double" 最小值 */
#endif
 
namespace Base
{
    class Vector2d;
    class BoundBox2d;
    class LineSegment2D;
    class Polygon2d;
 
    class BaseExport BoundBox2d
    {
    public:
        inline BoundBox2d();
 
        inline BoundBox2d(const BoundBox2d& rclBB);
 
        inline BoundBox2d(double fX1, double fY1, double fX2, double fY2);
 
        inline bool IsValid();
 
        inline bool IsEqual(const BoundBox2d& rclBB, double tolerance) const;
 
        inline BoundBox2d& operator= (const BoundBox2d& rclBB);
 
        inline bool operator== (const BoundBox2d& rclBB) const;
 
        inline double Width() const;
 
        inline double Height() const;
 
        inline bool Contains(const Base::Vector2d& v) const;
 
        inline bool Contains(const Vector2d& v, double tolerance) const;
 
        inline Vector2d GetCenter() const;
 
        inline void SetVoid();
 
        inline void Add(const Vector2d& v);
 
        bool Intersect(const LineSegment2D& rclLine) const;
 
        bool Intersect(const BoundBox2d& rclBB) const;
 
        bool Intersect(const Polygon2d& rclPoly) const;
 
    public:
        double MinX;                
        double MinY;                
        double MaxX;                
        double MaxY;                
    };
    inline BoundBox2d::BoundBox2d()
    {
        MinX = MinY = DOUBLE_MAX;
        MaxX = MaxY = -DOUBLE_MAX;
    }
 
    inline BoundBox2d::BoundBox2d(const BoundBox2d& rclBB)
        : MinX(rclBB.MinX),
        MinY(rclBB.MinY),
        MaxX(rclBB.MaxX),
        MaxY(rclBB.MaxY)
    {
    }
 
    inline BoundBox2d::BoundBox2d(double fX1, double fY1, double fX2, double fY2)
    {
        MinX = std::min<double>(fX1, fX2);
        MaxX = std::max<double>(fX1, fX2);
        MinY = std::min<double>(fY1, fY2);
        MaxY = std::max<double>(fY1, fY2);
    }
 
    inline bool BoundBox2d::IsValid()
    {
        return (MaxX >= MinX) && (MaxY >= MinY);
    }
 
    inline bool BoundBox2d::IsEqual(const BoundBox2d& b, double tolerance) const
    {
        return Vector2d(MinX, MinY).IsEqual(Vector2d(b.MinX, b.MinY), tolerance) &&
            Vector2d(MaxX, MaxY).IsEqual(Vector2d(b.MaxX, b.MaxY), tolerance);
    }
 
    inline BoundBox2d& BoundBox2d::operator= (const BoundBox2d& rclBB)
    {
        MinX = rclBB.MinX;
        MinY = rclBB.MinY;
        MaxX = rclBB.MaxX;
        MaxY = rclBB.MaxY;
        return *this;
    }
 
    inline bool BoundBox2d::operator== (const BoundBox2d& rclBB) const
    {
        return (MinX == rclBB.MinX) &&
            (MinY == rclBB.MinY) &&
            (MaxX == rclBB.MaxX) &&
            (MaxY == rclBB.MaxY);
    }
 
    inline double BoundBox2d::Width() const
    {
        return MaxX - MinX;
    }
 
    inline double BoundBox2d::Height() const
    {
        return MaxY - MinY;
    }
 
    inline bool BoundBox2d::Contains(const Vector2d& v) const
    {
        return v.x >= MinX && v.x <= MaxX
            && v.y >= MinY && v.y <= MaxY;
    }
 
    inline bool BoundBox2d::Contains(const Vector2d& v, double tolerance) const
    {
        return v.x >= MinX - tolerance && v.x <= MaxX + tolerance
            && v.y >= MinY - tolerance && v.y <= MaxY + tolerance;
    }
 
    inline Vector2d BoundBox2d::GetCenter() const
    {
        return Vector2d((MinX + MaxX) * 0.5, (MinY + MaxY) * 0.5);
    }
 
    inline void BoundBox2d::SetVoid()
    {
        MinX = MinY = DOUBLE_MAX;
        MaxX = MaxY = -DOUBLE_MAX;
    }
 
    inline void BoundBox2d::Add(const Vector2d& v)
    {
        MinX = std::min<double>(MinX, v.x);
        MinY = std::min<double>(MinY, v.y);
        MaxX = std::max<double>(MaxX, v.x);
        MaxY = std::max<double>(MaxY, v.y);
    }
 
 
} 
 
#endif