Rectangle2d.h

// Rectangle2d.h:
// --------------
//

#ifndef __IPSDKGEOMETRY_RECTANGLE2D_H__
#define __IPSDKGEOMETRY_RECTANGLE2D_H__

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

#include <IPSDKGeometry/IPSDKGeometryExports.h>
#include <IPSDKGeometry/Entity/2d/BaseTypedGeometryEntity2d.h>
#include <IPSDKGeometry/Entity/2d/Point/Point2d.h>
#include <IPSDKGeometry/Entity/2d/Rectangle/Rectangle2dOperators.h>

namespace ipsdk {
namespace geom {

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

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

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

public:
    Rectangle2d();
    Rectangle2d(const Point2dData<T>& centerPt, const T halfLength, const T halfWidth, const ipReal64 orientation);
    Rectangle2d(const Point2d<T>& centerPt, const T halfLength, const T halfWidth, const ipReal64 orientation);
    Rectangle2d(const T xCenter, const T yCenter, const T halfLength, const T halfWidth, const ipReal64 orientation);
    ~Rectangle2d();

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

    inline eEntity2dType            getEntity2dType() const;

    inline void                     setCenter(const Point2dData<T>& centerPt);
    inline void                     setCenter(const Point2d<T>& centerPt);
    inline void                     setCenter(const T xMin, const T yMin);
    inline void                     setHalfLength(const T halfLength);
    inline void                     setHalfWidth(const T halfWidth);
    inline void                     setOrientation(const ipReal64 orientation);
    inline ipReal64                 getOrientation() const;
    inline T                        centerX() const;
    inline T                        centerY() const;
    inline const Point2dData<T>&    center() const;
    inline T                        getHalfLength() const;
    inline T                        getHalfWidth() const;
    inline T                        getLength() const;
    inline T                        getWidth() const;
    inline T                        getArea() const;

    inline Point2dData<T>           topLeftCorner() const;
    inline Point2dData<T>           topRightCorner() const;
    inline Point2dData<T>           bottomLeftCorner() const;
    inline Point2dData<T>           bottomRightCorner() const;

// attributes
protected:
    Point2dData<T>  _centerPt;

    T               _halfLength;
    T               _halfWidth;

    ipReal64        _orientation;

};


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

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

template <typename T>
inline void
Rectangle2d<T>::setCenter(const Point2dData<T>& centerPt)
{
    _centerPt = centerPt;
}

template <typename T>
inline void
Rectangle2d<T>::setCenter(const Point2d<T>& centerPt)
{
    _centerPt = centerPt.getCoords();
}

template <typename T>
inline void
Rectangle2d<T>::setCenter(const T xMin, const T yMin)
{
    _centerPt.setCoords(xMin, yMin);
}

template <typename T>
inline void
Rectangle2d<T>::setHalfLength(const T halfLength)
{
    _halfLength = halfLength;
}

template <typename T>
inline void
Rectangle2d<T>::setHalfWidth(const T halfWidth)
{
    _halfWidth = halfWidth;
}

template <typename T>
inline T
Rectangle2d<T>::centerX() const
{
    return _centerPt._x;
}

template <typename T>
inline T
Rectangle2d<T>::centerY() const
{
    return _centerPt._y;
}

template <typename T>
inline const Point2dData<T>&
Rectangle2d<T>::center() const
{
    return _centerPt;
}

template <typename T>
inline void
Rectangle2d<T>::setOrientation(const ipReal64 orientation)
{
    _orientation = orientation;
}

template <typename T>
inline T
Rectangle2d<T>::getHalfLength() const
{
    return _halfLength;
}

template <typename T>
inline T
Rectangle2d<T>::getHalfWidth() const
{
    return _halfWidth;
}

template <typename T>
inline T
Rectangle2d<T>::getLength() const
{
    return 2 * this->getHalfLength();
}

template <typename T>
inline T
Rectangle2d<T>::getWidth() const
{
    return 2 * this->getHalfWidth();
}

template <typename T>
inline T
Rectangle2d<T>::getArea() const
{
    return this->getLength() * this->getWidth();
}

template <typename T>
inline ipReal64
Rectangle2d<T>::getOrientation() const
{
    return _orientation;
}

template <typename T>
inline Point2dData<T>
Rectangle2d<T>::topLeftCorner() const
{
    const ipReal64 modulus = std::sqrt(_halfLength*_halfLength + _halfWidth*_halfWidth);
    const ipReal64 alpha = std::atan(_halfWidth/_halfLength);
    return Point2dData<T>(static_cast<T>(modulus*std::cos(_orientation+M_PI+alpha)) + _centerPt._x,
                          static_cast<T>(modulus*std::sin(_orientation+M_PI+alpha)) + _centerPt._y);
}

template <typename T>
inline Point2dData<T>
Rectangle2d<T>::topRightCorner() const
{
    const ipReal64 modulus = std::sqrt(_halfLength*_halfLength + _halfWidth*_halfWidth);
    const ipReal64 alpha = std::atan(_halfWidth/_halfLength);
    return Point2dData<T>(static_cast<T>(modulus*std::cos(_orientation-alpha)) + _centerPt._x,
                          static_cast<T>(modulus*std::sin(_orientation-alpha)) + _centerPt._y);
}

template <typename T>
inline Point2dData<T>
Rectangle2d<T>::bottomLeftCorner() const
{
    const ipReal64 modulus = std::sqrt(_halfLength*_halfLength + _halfWidth*_halfWidth);
    const ipReal64 alpha = std::atan(_halfWidth/_halfLength);
    return Point2dData<T>(static_cast<T>(modulus*std::cos(_orientation+M_PI-alpha) )+ _centerPt._x,
                          static_cast<T>(modulus*std::sin(_orientation+M_PI-alpha)) + _centerPt._y);
}

template <typename T>
inline Point2dData<T>
Rectangle2d<T>::bottomRightCorner() const
{
    const ipReal64 modulus = std::sqrt(_halfLength*_halfLength + _halfWidth*_halfWidth);
    const ipReal64 alpha = std::atan(_halfWidth/_halfLength);
    return Point2dData<T>(static_cast<T>(modulus*std::cos(_orientation+alpha)) + _centerPt._x,
                          static_cast<T>(modulus*std::sin(_orientation+alpha)) + _centerPt._y);
}


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

#pragma warning (pop)

#endif // __IPSDKGEOMETRY_RECTANGLE2D_H__