Square2d.h

// Square2d.h:
// -----------
//

#ifndef __IPSDKGEOMETRY_SQUARE2D_H__
#define __IPSDKGEOMETRY_SQUARE2D_H__

// suppression warnings
// warning C4251: 'ipsdk::geom::Square2d<T>::_centerPt' : struct 'ipsdk::geom::Point2dData<T>' needs to have dll-interface to be used by clients of class 'ipsdk::geom::Square2d<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/Square/Square2dOperators.h>

namespace ipsdk {
namespace geom {


template <typename T>
class IPSDKGEOMETRY_API Square2d : public BaseTypedGeometryEntity2d<T>
{
    // declare 2d geometry entity
    IPSDK_DECLARE_GEOMETRY_ENTITY_2D(IPSDKGeometry, Square2d);
    
// predefined public types
public:
    static const eCoordinateSystem2dType::domain g_coordinateSystem2dType = eCoordinateSystem2dType::eCS2DT_Cartesian;

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

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

// 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                     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                        getLength() 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;

    ipReal64        _orientation;

};


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

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

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

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

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

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

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

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

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

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

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

template <typename T>
inline T
Square2d<T>::getLength() const
{
    return 2*_halfLength;
}

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

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

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

template <typename T>
inline Point2dData<T>
Square2d<T>::bottomLeftCorner() const
{
    const ipReal64 modulus = std::sqrt(2*(_halfLength*_halfLength));
    return Point2dData<T>(static_cast<T>(modulus*std::cos(_orientation+3.*M_PI/4.)) + _centerPt._x,
                          static_cast<T>(modulus*std::sin(_orientation+3.*M_PI/4.)) + _centerPt._y);
}

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


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

#pragma warning (pop)

#endif // __IPSDKGEOMETRY_SQUARE2D_H__