Bbox2.h

// 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
// not clear to you.
//
// Author: Bernhard Kornberger, bkorn (at) geom.at
// http://www.geom.at


#pragma once
#include "Point2.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),
        bValid(false),pGeomTest(pGeomTest_)
    {
    }

    Bbox2(  std::vector<Point2>::const_iterator start_it,
            std::vector<Point2>::const_iterator end_it,
            GeomTest* pGeomTest_=NULL)
            :
            minX(DBL_MAX),minY(DBL_MAX),
            maxX(-DBL_MAX),maxY(DBL_MAX),
            pGeomTest(pGeomTest_)
    {
        add(start_it,end_it);
    }


    bool isValid() const
    {
        return minX<DBL_MAX;
    }

    void getCorners(std::vector<Point2>& vBoxCorners) 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);
            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);
            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);
            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);
            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;
        if(oldMinX!=minX || oldMinY!=minY || oldMaxX!=maxX || oldMaxY!=maxY ) return true;
            else return false;
    }

    bool add(const Point2& p)
    {
        //std::cout<<"Add point: "<<p<<std::endl;
        if(bValid)
        {
            double oldMinX(minX),oldMinY(minY),oldMaxX(maxX),oldMaxY(maxY);
            treatPointForValidBox(p);
            if(oldMinX!=minX || oldMinY!=minY || oldMaxX!=maxX || oldMaxY!=maxY ) return true;
                else return false;
        }
        else
        {
            treatPointForInvalidBox(p);
            return true;
        }
    }

    bool isInBox(const Point2& p) const;

    Point2 computeCenter() const;

    Bbox2 operator+(const Bbox2& b);


#if GEOM_PSEUDO3D==GEOM_TRUE

#else

#endif

    Point2 getMinPoint() const
    {
#if GEOM_PSEUDO3D==GEOM_TRUE
        return Point2(minX,minY,0);
#else
        return Point2(minX,minY);
#endif
    }


#if GEOM_PSEUDO3D==GEOM_TRUE

#else

#endif

    Point2 getMaxPoint() const
    {
#if GEOM_PSEUDO3D==GEOM_TRUE
        return Point2(maxX,maxY,0);
#else
        return Point2(maxX,maxY);
#endif
    }

    double getMinCoord() const
    {
        if(minX<minY) return minX;
            else return minY;
    }
    double getMaxCoord() const
    {
        if(maxX>maxY) return maxX;
            else return 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 setMinX(double val)
    {
        minX=val;
        if(minX<=maxX && minY<=maxY) bValid=true;
    }
    void setMaxX(double val)
    {
        maxX=val;
        if(minX<=maxX && minY<=maxY) bValid=true;
    }
    void setMinY(double val)
    {
        minY=val;
        if(minX<=maxX && minY<=maxY) bValid=true;
    }
    void setMaxY(double val)
    {
        maxY=val;
        if(minX<=maxX && minY<=maxY) bValid=true;
    }

    void doubleTheBox();
    void enlargeRanges(double factor);
    void inflateIfDegenerate(double val)
    {
        if(bValid)
        {
            if(minX==maxX) maxX+=val;
            if(minY==maxY) maxY+=val;
        }
    }
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;
    }
    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();
        bValid=true;
    }

protected:
    double minX,minY;
    double maxX,maxY;
    bool bValid;
    friend std::ostream &operator<<(std::ostream &stream, Bbox2& pC);
    GeomTest* pGeomTest;
};

Bbox2 getBox(std::vector<Point2>& vP);
Bbox2 getBox(std::vector<Point2*>& vP);

inline std::ostream &operator<<(std::ostream &stream, Bbox2& pC)
{
    stream<<"Bbox2: ("<<pC.minX<<","<<pC.minY<<") -> ("<<pC.maxX<<","<<pC.maxY<<"), rangeX="<<pC.getRangeX()<<", rangeY="<<pC.getRangeY();
    return stream;
}



} // (namespace)