Circle2d.h

// Circle2d.h:
// ---------
//

#ifndef __IPSDKGEOMETRY_CIRCLE2D_H__
#define __IPSDKGEOMETRY_CIRCLE2D_H__

// suppression warnings
// warning C4251: 'ipsdk::geom::Circle2d<T>::_centerPt' : struct 'ipsdk::geom::Point2dData<T>' needs to have dll-interface to be used by clients of class 'ipsdk::geom::Circle2d<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/Circle/Circle2dOperators.h>
#include <IPSDKMath/Geometry/2d/Circle2d.h>

namespace ipsdk {
namespace geom {


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

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

public:
    Circle2d();
    Circle2d(const Point2dData<T>& center, const T radius);
    Circle2d(const Point2d<T>& center, const T radius);
    Circle2d(const T xCenter, const T yCenter, const T radius);
    ~Circle2d();

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

    inline eEntity2dType            getEntity2dType() const;

    inline void                     setCoords(const Point2dData<T>& centerPt, const T radius);
    inline void                     setCoords(const Point2d<T>& centerPt, const T radius);
    inline void                     setCoords(const T xCenter, const T yCenter, const T radius);
    inline void                     setCenter(const Point2dData<T>& centerPt);
    inline void                     setCenter(const Point2d<T>& centerPt);
    inline void                     setCenter(const T xCenter, const T yCenter);
    inline void                     setRadius(const T radius);
    inline T                        getRadius() const;
    inline T                        centerX() const;
    inline T                        centerY() const;
    inline const Point2dData<T>&    center() const;

    inline ipReal64                 distance(const Point2d<T>& pt) const;
    ipReal64                        distance(const Point2dData<T>& pt) const;

    inline ipReal64                 signedDistance(const Point2d<T>& pt) const;
    ipReal64                        signedDistance(const Point2dData<T>& pt) const;

    ipReal64                        perimeter() const;

    ipReal64                        area() const;

// attributes
protected:
    Point2dData<T>  _centerPt;

    T               _radius;

};


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

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

template <typename T>
inline void
Circle2d<T>::setCoords(const Point2dData<T>& centerPt,
                       const T radius)
{
    _centerPt = centerPt;
    _radius = radius;
}

template <typename T>
inline void
Circle2d<T>::setCoords(const Point2d<T>& centerPt,
                       const T radius)
{
    _centerPt = centerPt.getCoords();
    _radius = radius;
}

template <typename T>
inline void
Circle2d<T>::setCoords(const T xCenter, const T yCenter,
                       const T radius)
{
    _centerPt.setCoords(xCenter, yCenter);
    _radius = radius;
}

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

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

template <typename T>
inline void
Circle2d<T>::setCenter(const T xCenter, const T yCenter)
{
    _centerPt.setCoords(xCenter, yCenter);
}

template <typename T>
inline void
Circle2d<T>::setRadius(const T radius)
{
    _radius = radius;
}

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

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

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

template <typename T>
inline T
Circle2d<T>::getRadius() const
{
    return _radius;
}

template <typename T>
inline ipReal64
Circle2d<T>::distance(const Point2d<T>& pt) const
{
    return distance(pt.getCoords());
}

template <typename T>
inline ipReal64
Circle2d<T>::distance(const Point2dData<T>& pt) const
{
    return std::abs(signedDistance(pt));
}

template <typename T>
inline ipReal64
Circle2d<T>::signedDistance(const Point2d<T>& pt) const
{
    return signedDistance(pt.getCoords());
}

template <typename T>
inline ipReal64
Circle2d<T>::perimeter() const
{
    return math::circlePerimeter(_radius);
}

template <typename T>
inline ipReal64
Circle2d<T>::area() const
{
    return math::circleArea(_radius);
}


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

#pragma warning (pop)

#endif // __IPSDKGEOMETRY_CIRCLE2D_H__