Ellipse2d.h

// Ellipse2d.h:
// ------------
//

#ifndef __IPSDKGEOMETRY_ELLIPSE2D_H__
#define __IPSDKGEOMETRY_ELLIPSE2D_H__

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

namespace ipsdk {
namespace geom {


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

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

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

public:
    Ellipse2d();
    Ellipse2d(const Point2dData<T>& center, const T majorRadius, const T minorRadius, const ipReal64 theta);
    Ellipse2d(const Point2d<T>& center, const T majorRadius, const T minorRadius, const ipReal64 theta);
    Ellipse2d(const T xCenter, const T yCenter, const T majorRadius, const T minorRadius, const ipReal64 theta);
    ~Ellipse2d();

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

    inline eEntity2dType            getEntity2dType() const;

    inline void                     setCoords(const Point2dData<T>& centerPt,
                                              const T majorRadius, const T minorRadius,
                                              const ipReal64 theta);
    inline void                     setCoords(const Point2d<T>& centerPt,
                                              const T majorRadius, const T minorRadius,
                                              const ipReal64 theta);
    inline void                     setCoords(const T xCenter, const T yCenter,
                                              const T majorRadius, const T minorRadius,
                                              const ipReal64 theta);
    inline void                     setCenter(const Point2dData<T>& center);
    inline void                     setCenter(const Point2d<T>& center);
    inline void                     setCenter(const T xCenter, const T yCenter);
    inline void                     setMajorRadius(const T majorRadius);
    inline void                     setMinorRadius(const T minorRadius);
    inline void                     setTheta(const ipReal64 theta);
    inline T                        getMajorRadius() const;
    inline T                        getMinorRadius() const;
    inline ipReal64                 getTheta() const;
    inline T                        centerX() const;
    inline T                        centerY() const;
    inline const Point2dData<T>&    center() const;

    inline ipReal64                 focalLength() const;

    inline Point2dData<ipReal64>    focus1() const;
    inline Point2dData<ipReal64>    focus2() const;

    inline ipReal64                 perimeterLowerBound() const;

    inline ipReal64                 perimeterUpperBound() const;

    inline ipReal64                 area() const;

    inline ipReal64                 excentricity() const;

    inline ipReal64                 radius(const ipReal64 phi) const;

    inline Point2dData<ipReal64>    boundaryPoint(const ipReal64 phi) const;

// attributes
protected:
    Point2dData<T>  _centerPt;

    T               _majorRadius;

    T               _minorRadius;

    ipReal64        _theta;

    ipReal64        _cosTheta;
    ipReal64        _sinTheta;
};


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

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

template <typename T>
inline void
Ellipse2d<T>::setCoords(const Point2dData<T>& centerPt,
                        const T majorRadius, const T minorRadius,
                        const ipReal64 theta)
{
    _centerPt = centerPt;
    _majorRadius = majorRadius;
    _minorRadius = minorRadius;
    setTheta(theta);
}

template <typename T>
inline void
Ellipse2d<T>::setCoords(const Point2d<T>& centerPt,
                        const T majorRadius, const T minorRadius,
                        const ipReal64 theta)
{
    _centerPt = centerPt.getCoords();
    _majorRadius = majorRadius;
    _minorRadius = minorRadius;
    setTheta(theta);
}

template <typename T>
inline void
Ellipse2d<T>::setCoords(const T xCenter, const T yCenter,
                        const T majorRadius, const T minorRadius,
                        const ipReal64 theta)
{
    _centerPt.setCoords(xCenter, yCenter);
    _majorRadius = majorRadius;
    _minorRadius = minorRadius;
    setTheta(theta);
}

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

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

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

template <typename T>
inline void
Ellipse2d<T>::setMajorRadius(const T majorRadius)
{
    _majorRadius = majorRadius;
}

template <typename T>
inline void
Ellipse2d<T>::setMinorRadius(const T minorRadius)
{
    _minorRadius = minorRadius;
}

template <typename T>
inline void
Ellipse2d<T>::setTheta(const ipReal64 theta)
{
    _theta = math::centerModulo(theta, 2*M_PI);
    _cosTheta = std::cos(_theta);
    _sinTheta = std::sin(_theta);
}

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

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

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

template <typename T>
inline T
Ellipse2d<T>::getMajorRadius() const
{
    return _majorRadius;
}

template <typename T>
inline T
Ellipse2d<T>::getMinorRadius() const
{
    return _minorRadius;
}

template <typename T>
inline ipReal64
Ellipse2d<T>::getTheta() const
{
    return _theta;
}

template <typename T>
inline ipReal64
Ellipse2d<T>::focalLength() const
{
    const ipReal64 a2 = _majorRadius*_majorRadius;
    const ipReal64 b2 = _minorRadius*_minorRadius;

    return std::sqrt(std::abs(a2 - b2));
}

template <typename T>
inline Point2dData<ipReal64>
Ellipse2d<T>::focus1() const
{
    const ipReal64 f = focalLength();
    
    return Point2dData<ipReal64>(_centerPt._x + f*_cosTheta,
                                 _centerPt._y + f*_sinTheta);
}

template <typename T>
inline Point2dData<ipReal64>
Ellipse2d<T>::focus2() const
{
    const ipReal64 f = focalLength();
    
    return Point2dData<ipReal64>(_centerPt._x - f*_cosTheta,
                                 _centerPt._y - f*_sinTheta);
}

template <typename T>
inline ipReal64
Ellipse2d<T>::perimeterLowerBound() const
{
    return math::ellipsePerimeterLowerBound(_majorRadius, _minorRadius);
}

template <typename T>
inline ipReal64
Ellipse2d<T>::perimeterUpperBound() const
{
    return math::ellipsePerimeterUpperBound(_majorRadius, _minorRadius);
}

template <typename T>
inline ipReal64
Ellipse2d<T>::area() const
{
    return math::ellipseArea(_majorRadius, _minorRadius);
}

template <typename T>
inline ipReal64
Ellipse2d<T>::excentricity() const
{
    return math::ellipseExcentricity(_majorRadius, _minorRadius);
}

template <typename T>
inline ipReal64
Ellipse2d<T>::radius(const ipReal64 phi) const
{
    return math::ellipseRadius(_majorRadius, _minorRadius, _theta, phi);
}

template <typename T>
inline Point2dData<ipReal64>
Ellipse2d<T>::boundaryPoint(const ipReal64 phi) const
{
    Point2dData<ipReal64> pt;
    math::ellipsePoint(_centerPt._x, _centerPt._y,
                       _majorRadius, _minorRadius,
                       _theta, phi,
                       pt._x, pt._y);

    return pt;
}


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

#pragma warning (pop)

#endif // __IPSDKGEOMETRY_ELLIPSE2D_H__