BoundingBox2d.h

// BoundingBox2d.h:
// ----------------
//

#ifndef __IPSDKGEOMETRY_BOUNDINGBOX2D_H__
#define __IPSDKGEOMETRY_BOUNDINGBOX2D_H__

// suppression warnings
// warning C4251: 'ipsdk::geom::BoundingBox2d<T>::_minCornerPt' : class 'ipsdk::geom::Point2dData<TIn>' needs to have dll-interface to be used by clients of class 'ipsdk::geom::BoundingBox2d<T>'
#pragma warning (push)
#pragma warning (disable : 4251)

#include <IPSDKGeometry/Entity/2d/BaseTypedGeometryEntity2d.h>
#include <IPSDKGeometry/Entity/2d/Point/Point2d.h>
#include <IPSDKGeometry/Entity/2d/BoundingBox/BoundingBox2dOperators.h>
#include <IPSDKGeometry/Entity/2d/BoundingBox/BoundingBox2dFunctions.h>

namespace ipsdk {
namespace geom {
    

template <typename T>
class IPSDKGEOMETRY_API BoundingBox2d : public BaseTypedGeometryEntity2d<T>
{
    // declare 2d geometry entity
    IPSDK_DECLARE_GEOMETRY_ENTITY_2D(IPSDKGeometry, BoundingBox2d);

// predefined public types
public:
    static const eCoordinateSystem2dType::domain g_coordinateSystem2dType = eCoordinateSystem2dType::eCS2DT_Cartesian;

    static const eEntity2dType::domain g_entity2dType = eEntity2dType::eE2DT_BoundingBox;

    typedef Point2dData<T> PointType;

public:
    BoundingBox2d();
    BoundingBox2d(const Point2dData<T>& minCornerPt, const Point2dData<T>& maxCornerPt);
    BoundingBox2d(const Point2d<T>& minCornerPt, const Point2d<T>& maxCornerPt);
    BoundingBox2d(const T xMin, const T yMin, const T xMax, const T yMax);
    ~BoundingBox2d();

// methods
public:
    inline eCoordinateSystem2dType  getCoordinateSystem2dType() const;

    inline eEntity2dType            getEntity2dType() const;

    inline void                     setCoords(const Point2dData<T>& minCornerPt, const Point2dData<T>& maxCornerPt);
    inline void                     setCoords(const Point2d<T>& minCornerPt, const Point2d<T>& maxCornerPt);
    inline void                     setCoords(const T xMin, const T yMin, const T xMax, const T yMax);
    inline void                     setXMin(const T xMin);
    inline void                     setXMax(const T xMax);
    inline void                     setYMin(const T yMin);
    inline void                     setYMax(const T yMax);
    inline void                     setMinCornerPt(const Point2dData<T>& minCornerPt);
    inline void                     setMinCornerPt(const Point2d<T>& minCornerPt);
    inline void                     setMaxCornerPt(const Point2dData<T>& maxCornerPt);
    inline void                     setMaxCornerPt(const Point2d<T>& maxCornerPt);
    inline T                        getXMin() const;
    inline T                        getXMax() const;
    inline T                        getYMin() const;
    inline T                        getYMax() const;
    inline T&                       getXMin();
    inline T&                       getXMax();
    inline T&                       getYMin();
    inline T&                       getYMax();
    inline const Point2dData<T>&    getMinCornerPt() const;
    inline const Point2dData<T>&    getMaxCornerPt() const;
    inline Point2dData<T>&          getMinCornerPt();
    inline Point2dData<T>&          getMaxCornerPt();

    inline T                        sizeX() const;
    inline T                        sizeY() const;
    inline T                        getArea() const;

    inline ipReal64                 centerX() const;
    inline ipReal64                 centerY() const;
    inline Point2dData<ipReal64>    center() const;

// attributes
protected:
    Point2dData<T>  _minCornerPt;

    Point2dData<T>  _maxCornerPt;
};


template <typename T>
inline eCoordinateSystem2dType
BoundingBox2d<T>::getCoordinateSystem2dType() const
{
    return g_coordinateSystem2dType;
}

template <typename T>
inline eEntity2dType
BoundingBox2d<T>::getEntity2dType() const
{
    return g_entity2dType;
}

template <typename T>
inline void
BoundingBox2d<T>::setCoords(const Point2dData<T>& minCornerPt, const Point2dData<T>& maxCornerPt)
{
    _minCornerPt = minCornerPt;
    _maxCornerPt = maxCornerPt;
}

template <typename T>
inline void
BoundingBox2d<T>::setCoords(const Point2d<T>& minCornerPt, const Point2d<T>& maxCornerPt)
{
    _minCornerPt = minCornerPt.getCoords();
    _maxCornerPt = maxCornerPt.getCoords();
}

template <typename T>
inline void
BoundingBox2d<T>::setCoords(const T xMin, const T yMin, const T xMax, const T yMax)
{
    _minCornerPt.setCoords(xMin, yMin);
    _maxCornerPt.setCoords(xMax, yMax);
}

template <typename T>
inline void
BoundingBox2d<T>::setXMin(const T xMin)
{
    _minCornerPt._x = xMin;
}

template <typename T>
inline void
BoundingBox2d<T>::setXMax(const T xMax)
{
    _maxCornerPt._x = xMax;
}

template <typename T>
inline void
BoundingBox2d<T>::setYMin(const T yMin)
{
    _minCornerPt._y = yMin;
}

template <typename T>
inline void
BoundingBox2d<T>::setYMax(const T yMax)
{
    _maxCornerPt._y = yMax;
}

template <typename T>
inline void
BoundingBox2d<T>::setMinCornerPt(const Point2dData<T>& minCornerPt)
{
    _minCornerPt = minCornerPt;
}

template <typename T>
inline void
BoundingBox2d<T>::setMinCornerPt(const Point2d<T>& minCornerPt)
{
    _minCornerPt = minCornerPt.getCoords();
}

template <typename T>
inline void
BoundingBox2d<T>::setMaxCornerPt(const Point2dData<T>& maxCornerPt)
{
    _maxCornerPt = maxCornerPt;
}

template <typename T>
inline void
BoundingBox2d<T>::setMaxCornerPt(const Point2d<T>& maxCornerPt)
{
    _maxCornerPt = maxCornerPt.getCoords();
}

template <typename T>
inline T
BoundingBox2d<T>::getXMin() const
{
    return _minCornerPt._x;
}

template <typename T>
inline T
BoundingBox2d<T>::getXMax() const
{
    return _maxCornerPt._x;
}

template <typename T>
inline T
BoundingBox2d<T>::getYMin() const
{
    return _minCornerPt._y;
}

template <typename T>
inline T
BoundingBox2d<T>::getYMax() const
{
    return _maxCornerPt._y;
}

template <typename T>
inline T&
BoundingBox2d<T>::getXMin()
{
    return _minCornerPt._x;
}

template <typename T>
inline T&
BoundingBox2d<T>::getXMax()
{
    return _maxCornerPt._x;
}

template <typename T>
inline T&
BoundingBox2d<T>::getYMin()
{
    return _minCornerPt._y;
}

template <typename T>
inline T&
BoundingBox2d<T>::getYMax()
{
    return _maxCornerPt._y;
}

template <typename T>
inline const Point2dData<T>&
BoundingBox2d<T>::getMinCornerPt() const
{
    return _minCornerPt;
}

template <typename T>
inline const Point2dData<T>&
BoundingBox2d<T>::getMaxCornerPt() const
{
    return _maxCornerPt;
}

template <typename T>
inline Point2dData<T>&
BoundingBox2d<T>::getMinCornerPt()
{
    return _minCornerPt;
}

template <typename T>
inline Point2dData<T>&
BoundingBox2d<T>::getMaxCornerPt()
{
    return _maxCornerPt;
}

template <typename T>
inline T
BoundingBox2d<T>::sizeX() const
{
    return _maxCornerPt._x - _minCornerPt._x;
}

template <typename T>
inline T
BoundingBox2d<T>::sizeY() const
{
    return _maxCornerPt._y - _minCornerPt._y;
}

template <typename T>
inline T
BoundingBox2d<T>::getArea() const
{
    return this->sizeX() * this->sizeY();
}

template <typename T>
inline ipReal64
BoundingBox2d<T>::centerX() const
{
    return (_maxCornerPt._x + _minCornerPt._x) / 2.0;
}

template <typename T>
inline ipReal64
BoundingBox2d<T>::centerY() const
{
    return (_maxCornerPt._y + _minCornerPt._y) / 2.0;
}

template <typename T>
inline Point2dData<ipReal64>
BoundingBox2d<T>::center() const
{
    return Point2dData<ipReal64>(centerX(), centerY());
}


} // end of namespace geom
} // end of namespace ipsdk

#pragma warning (pop)

#endif // __IPSDKGEOMETRY_BOUNDINGBOX2D_H__