Bbox2.h

Go to the documentation of this file.

// Copyright (C) Geom Software e.U, Bernhard Kornberger, Graz/Austria
//
// This file is part of the Fade2D library. The student license is free
// of charge and covers personal, non-commercial research. Licensees
// holding a commercial license may use this file in accordance with
// the Commercial License Agreement.
//
// This software is provided AS IS with NO WARRANTY OF ANY KIND,
// INCLUDING THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE.
//
// Please contact the author if any conditions of this licensing are
// unclear to you.
//
// Support: https://www.geom.at/contact/
// Project: https://www.geom.at/fade2d/html/
 
#pragma once
#include "Segment2.h"
#include "common.h"
#if GEOM_PSEUDO3D==GEOM_TRUE
    namespace GEOM_FADE25D {
#elif GEOM_PSEUDO3D==GEOM_FALSE
    namespace GEOM_FADE2D {
#else
    #error GEOM_PSEUDO3D is not defined
#endif
 
class GeomTest; // FWD
 
class CLASS_DECLSPEC Bbox2
{
public:
    explicit Bbox2(GeomTest* pGeomTest_=NULL):
        minX(DBL_MAX),minY(DBL_MAX),
        maxX(-DBL_MAX),maxY(-DBL_MAX),
        maxAbsCoord(0),
        bValid(false),pGeomTest(pGeomTest_)
    {
    }
    ~Bbox2();
 
 
    void reset()
    {
        minX=DBL_MAX;
        minY=DBL_MAX;
        maxX=-DBL_MAX;
        maxY=-DBL_MAX;
        bValid=false;
    }
 
    bool isValid() const
    {
        return minX<DBL_MAX;
    }
 
    void getCorners(std::vector<Point2>& vBoxCorners) const;
 
    void getBoundary(std::vector<Segment2>& vBoundary) const;
 
    void getOffsetCorners(double offset,std::vector<Point2>& vBoxCorners) const;
 
 
    bool doIntersect(const Bbox2& other) const;
 
 
    bool add(std::vector<Point2*>::const_iterator start_it,std::vector<Point2*>::const_iterator end_it)
    {
        if(start_it==end_it) return false;
        if(bValid)
        {
            double oldMinX(minX),oldMinY(minY),oldMaxX(maxX),oldMaxY(maxY);
            for(;start_it!=end_it;++start_it) treatPointForValidBox(**start_it);
            updateMaxAbs();
            if(oldMinX!=minX || oldMinY!=minY || oldMaxX!=maxX || oldMaxY!=maxY ) return true;
            return false;
        }
        else
        {
            treatPointForInvalidBox(**start_it);
            ++start_it;
            for(;start_it!=end_it;++start_it) treatPointForValidBox(**start_it);
            updateMaxAbs();
            return true;
        }
 
    }
 
    bool add(std::vector<Point2>::const_iterator start_it,std::vector<Point2>::const_iterator end_it)
    {
        if(start_it==end_it) return false;
        if(bValid)
        {
            double oldMinX(minX),oldMinY(minY),oldMaxX(maxX),oldMaxY(maxY);
            for(;start_it!=end_it;++start_it) treatPointForValidBox(*start_it);
            updateMaxAbs();
            if(oldMinX!=minX || oldMinY!=minY || oldMaxX!=maxX || oldMaxY!=maxY ) return true;
            return false;
        }
        else
        {
            treatPointForInvalidBox(*start_it);
            ++start_it;
            for(;start_it!=end_it;++start_it) treatPointForValidBox(*start_it);
            updateMaxAbs();
            return true;
        }
    }
 
    bool add(size_t numPoints,double * coordinates)
    {
#if GEOM_PSEUDO3D==GEOM_TRUE
        const int NUMCOMPONENTS(3);
#else
        const int NUMCOMPONENTS(2);
#endif
 
        if(numPoints==0) return false;
        double oldMinX(minX),oldMinY(minY),oldMaxX(maxX),oldMaxY(maxY);
        double firstX(coordinates[0]);
        double firstY(coordinates[1]);
        if(firstX<minX) minX=firstX;
        if(firstX>maxX) maxX=firstX;
        if(firstY<minY) minY=firstY;
        if(firstY>maxY) maxY=firstY;
 
        for(size_t i=0;i<numPoints;++i)
        {
            double x(coordinates[NUMCOMPONENTS*i]);
            double y(coordinates[NUMCOMPONENTS*i+1]);
            if(x<minX) minX=x;
                else if(x>maxX) maxX=x;
            if(y<minY) minY=y;
                else if(y>maxY) maxY=y;
        }
        bValid=true;
        updateMaxAbs();
        if(oldMinX!=minX || oldMinY!=minY || oldMaxX!=maxX || oldMaxY!=maxY ) return true;
            else return false;
    }
 
    bool add(const Point2& p)
    {
        //GCOUT<<"Add point: "<<p<<std::endl;
        if(bValid)
        {
            double oldMinX(minX),oldMinY(minY),oldMaxX(maxX),oldMaxY(maxY);
            treatPointForValidBox(p);
            updateMaxAbs();
            if(oldMinX!=minX || oldMinY!=minY || oldMaxX!=maxX || oldMaxY!=maxY ) return true;
                else return false;
        }
        else
        {
            treatPointForInvalidBox(p);
            updateMaxAbs();
            return true;
        }
    }
    bool add(const Bbox2& other)
    {
        bool bRet(false);
        if(other.minX<minX) {minX=other.minX;bRet=true;}
        if(other.minY<minY) {minY=other.minY;bRet=true;}
        if(other.maxX>maxX) {maxX=other.maxX;bRet=true;}
        if(other.maxY>maxY) {maxY=other.maxY;bRet=true;}
        updateMaxAbs();
        return bRet;
    }
 
    bool isInBox(const Point2& p) const;
 
 
    Point2 computeCenter() const;
 
    Bbox2 operator+(const Bbox2& b);
 
 
    Point2 getMinPoint() const
    {
#if GEOM_PSEUDO3D==GEOM_TRUE
        return Point2(minX,minY,0);
#else
        return Point2(minX,minY);
#endif
    }
 
 
    Point2 getMaxPoint() const
    {
#if GEOM_PSEUDO3D==GEOM_TRUE
        return Point2(maxX,maxY,0);
#else
        return Point2(maxX,maxY);
#endif
    }
 
    double getMinCoord() const
    {
        return (std::min)(minX,minY);
    }
 
    double getMaxCoord() const
    {
        return (std::max)(maxX,maxY);
    }
 
 
    double getRangeX() const
    {
        return maxX-minX;
    }
 
    double getRangeY() const
    {
        return maxY-minY;
    }
 
    double getMaxRange() const
    {
        double range0=getRangeX();
        double range1=getRangeY();
        if(range0>range1) return range0;
        return range1;
    }
 
    double get_minX() const {return minX;}
    double get_minY() const {return minY;}
 
    double get_maxX() const {return maxX;}
 
    double get_maxY() const {return maxY;}
 
    void getBounds(double& minX_,double& maxX_,double& minY_,double& maxY_) const;
 
 
 
    void doubleTheBox();
 
    void setMinX(double val)
    {
        minX=val;
        updateMaxAbs();
        if(minX<=maxX && minY<=maxY) bValid=true;
    }
 
    void setMaxX(double val)
    {
        maxX=val;
        updateMaxAbs();
        if(minX<=maxX && minY<=maxY) bValid=true;
    }
 
    void setMinY(double val)
    {
        minY=val;
        updateMaxAbs();
        if(minX<=maxX && minY<=maxY) bValid=true;
    }
 
    void setMaxY(double val)
    {
        maxY=val;
        updateMaxAbs();
        if(minX<=maxX && minY<=maxY) bValid=true;
    }
 
 
    void enlargeRanges(double factor,bool bUseMaxRange,double minRange);
 
    void inflateIfDegenerate(double val)
    {
        if(bValid)
        {
            if(minX==maxX) maxX+=val;
            if(minY==maxY) maxY+=val;
        }
        updateMaxAbs();
    }
protected:
    inline void treatPointForValidBox(const Point2& p)
    {
        double x,y;
        p.xy(x,y);
        if(x<minX) minX=x;
            else if(x>maxX) maxX=x;
        if(y<minY) minY=y;
            else if(y>maxY) maxY=y;
        updateMaxAbs();
    }
    inline void treatPointForInvalidBox(const Point2& p)
    {
        // Individual bounds may have been set already. Keep them!
        if(minX==DBL_MAX) minX=p.x();
        if(minY==DBL_MAX) minY=p.y();
        if(maxX==-DBL_MAX) maxX=p.x();
        if(maxY==-DBL_MAX) maxY=p.y();
        updateMaxAbs();
        bValid=true;
    }
    friend std::ostream &operator<<(std::ostream &stream, const Bbox2& pC);
protected:
    double minX,minY;
    double maxX,maxY;
    double maxAbsCoord;
    bool bValid;
    GeomTest* pGeomTest;
    bool updateMaxAbs();
    friend Bbox2 intersection(const Bbox2& a,const Bbox2& b);
};
 
Bbox2 getBox(std::vector<Point2>& vP);
 
 Bbox2 getBox(std::vector<Point2*>& vP);
 
inline Bbox2 intersection(const Bbox2& a, const Bbox2& b)
{
    Bbox2 ret(a);
    if(b.minX > ret.minX) ret.minX=b.minX;
    if(b.maxX < ret.maxX) ret.maxX=b.maxX;
    if(b.minY > ret.minY) ret.minY=b.minY;
    if(b.maxY < ret.maxY) ret.maxY=b.maxY;
    if( (ret.minX>ret.maxX) || (ret.minY>ret.maxY) )
    {
        ret.bValid=false;
        ret.minX=DBL_MAX;
        ret.minY=DBL_MAX;
        ret.maxX=-DBL_MAX;
        ret.maxY=-DBL_MAX;
    }
    else
    {
        ret.bValid = true;
    }
    return ret;
}
 
 
inline std::ostream &operator<<(std::ostream &stream, const Bbox2& pC)
{
    stream<<"Bbox2: xy("<<pC.minX<<","<<pC.minY<<") -> xy("<<pC.maxX<<","<<pC.maxY<<"), rangeX="<<pC.getRangeX()<<", rangeY="<<pC.getRangeY();
    return stream;
}
 
 
 
} // (namespace)