Line2d.h

// Line2d.h:
// ---------
//

#ifndef __IPSDKGEOMETRY_LINE2D_H__
#define __IPSDKGEOMETRY_LINE2D_H__

#include <IPSDKGeometry/IPSDKGeometryExports.h>
#include <IPSDKGeometry/Entity/2d/BaseTypedGeometryEntity2d.h>
#include <IPSDKGeometry/Entity/2d/Line/Line2dOperators.h>
#include <IPSDKMath/Geometry/2d/Angles2d.h>

namespace ipsdk {
namespace geom {

template <typename T>
struct Point2dData;
template <typename T>
class Point2d;
class Vector2d;


class IPSDKGEOMETRY_API Line2d : public BaseTypedGeometryEntity2d<ipReal64>
{
    // declare 2d geometry entity
    IPSDK_DECLARE_GEOMETRY_ENTITY_2D(IPSDKGeometry, Line2d);

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

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

public:
    Line2d();
    Line2d(const ipReal64 rho, const ipReal64 theta);
    template <typename T>
    Line2d(const Point2d<T>& pt0, const Point2d<T>& pt1);
    template <typename T>
    Line2d(const Point2dData<T>& pt0, const Point2dData<T>& pt1);
    template <typename T>
    Line2d(const Point2d<T>& pt, const Vector2d& normal);
    template <typename T>
    Line2d(const Point2dData<T>& pt, const Vector2d& normal);
    ~Line2d();

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

    inline eEntity2dType            getEntity2dType() const;

    inline void                     setCoords(const ipReal64 rho, const ipReal64 theta);
    template <typename T>
    inline void                     setCoords(const Point2d<T>& pt0, const Point2d<T>& pt1);
    template <typename T>
    void                            setCoords(const Point2dData<T>& pt0, const Point2dData<T>& pt1);
    template <typename T>
    inline void                     setCoords(const Point2d<T>& pt, const Vector2d& normal);
    template <typename T>
    void                            setCoords(const Point2dData<T>& pt, const Vector2d& normal);
    inline void                     setRho(const ipReal64 rho);
    inline void                     setTheta(const ipReal64 theta);
    inline ipReal64                 getRho() const;
    inline ipReal64                 getTheta() const;

    Vector2d                        getDirection() const;

    Vector2d                        getNormal() const;

    Point2dData<ipReal64>           getNearestPointFromOrigin() const;

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

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

    inline ipReal64                 getCosTheta() const;
    inline ipReal64                 getSinTheta() const;

    Line2d&                         operator+=(const Vector2d& vec);
    Line2d                          operator+(const Vector2d& vec) const;
    Line2d&                         operator-=(const Vector2d& vec);
    Line2d                          operator-(const Vector2d& vec) const;

// attributes
protected:
    ipReal64    _rho;

    ipReal64    _theta;

    ipReal64    _cosTheta;
    ipReal64    _sinTheta;
};


template <typename T>
inline
Line2d::Line2d(const Point2d<T>& pt0, const Point2d<T>& pt1)
{
    setCoords(pt0, pt1);
}

template <typename T>
inline
Line2d::Line2d(const Point2dData<T>& pt0, const Point2dData<T>& pt1)
{
    setCoords(pt0, pt1);
}

template <typename T>
inline
Line2d::Line2d(const Point2d<T>& pt, const Vector2d& normal)
{
    setCoords(pt, normal);
}

template <typename T>
inline
Line2d::Line2d(const Point2dData<T>& pt, const Vector2d& normal)
{
    setCoords(pt, normal);
}

inline eCoordinateSystem2dType
Line2d::getCoordinateSystem2dType() const
{
    return g_coordinateSystem2dType;
}

inline eEntity2dType
Line2d::getEntity2dType() const
{
    return g_entity2dType;
}

inline void
Line2d::setCoords(const ipReal64 rho, const ipReal64 theta)
{
    setRho(rho);
    setTheta(theta);
}

template <typename T>
inline void
Line2d::setCoords(const Point2d<T>& pt0, const Point2d<T>& pt1)
{
    setCoords(pt0.getCoords(), pt1.getCoords());
}

template <typename T>
inline void
Line2d::setCoords(const Point2d<T>& pt, const Vector2d& normal)
{
    setCoords(pt.getCoords(), normal);
}

inline void
Line2d::setRho(const ipReal64 rho)
{
    _rho = rho;
}

inline void
Line2d::setTheta(const ipReal64 theta)
{
    _theta = math::centerModulo(theta, 2*M_PI);
    _cosTheta = std::cos(_theta);
    _sinTheta = std::sin(_theta);
}

inline ipReal64
Line2d::getRho() const
{
    return _rho;
}

inline ipReal64
Line2d::getTheta() const
{
    return _theta;
}

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

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

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

inline ipReal64
Line2d::getCosTheta() const
{
    return _cosTheta;
}

inline ipReal64
Line2d::getSinTheta() const
{
    return _sinTheta;
}


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

#endif // __IPSDKGEOMETRY_LINE2D_H__