Vector2d.h

// Vector2d.h:
// -----------
//

#ifndef __IPSDKGEOMETRY_VECTOR2D_H__
#define __IPSDKGEOMETRY_VECTOR2D_H__

#include <IPSDKGeometry/Entity/2d/BaseTypedGeometryEntity2d.h>
#include <IPSDKGeometry/Entity/2d/Vector/Vector2dOperators.h>
#include <IPSDKGeometry/Entity/2d/Vector/Vector2dFunctions.h>
#include <IPSDKMath/Geometry/2d/Angles2d.h>

namespace ipsdk {
namespace geom {

template <typename T>
class Point2d;


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

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

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

public:
    Vector2d();
    Vector2d(const ipReal64 rho, const ipReal64 theta);
    template <typename T>
    Vector2d(const Point2d<T>& ptEnd, const Point2d<T>& ptStart);
    template <typename T>
    Vector2d(const Point2dData<T>& ptEnd, const Point2dData<T>& ptStart);
    template <typename T>
    explicit Vector2d(const Point2d<T>& ptEnd);
    template <typename T>
    explicit Vector2d(const Point2dData<T>& ptEnd);
    ~Vector2d();

// 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>& ptEnd, const Point2d<T>& ptStart);
    template <typename T>
    void                            setCoords(const Point2dData<T>& ptEnd, const Point2dData<T>& ptStart);
    template <typename T>
    inline void                     setCoords(const Point2d<T>& ptEnd);
    template <typename T>
    void                            setCoords(const Point2dData<T>& ptEnd);
    inline void                     setRho(const ipReal64 rho);
    inline void                     setTheta(const ipReal64 theta);
    inline ipReal64                 getRho() const;
    inline ipReal64                 getTheta() const;

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

    inline ipReal64                 getX() const;
    inline ipReal64                 getY() const;

    inline ipReal64                 getNx() const;
    inline ipReal64                 getNy() const;

    Vector2d&                       operator+=(const Vector2d& vec);
    Vector2d                        operator+(const Vector2d& vec) const;
    Vector2d&                       operator-=(const Vector2d& vec);
    Vector2d                        operator-(const Vector2d& vec) const;
    Vector2d&                       operator*=(const ipReal64 value);
    Vector2d                        operator*(const ipReal64 value) const;
    Vector2d&                       operator/=(const ipReal64 value);
    Vector2d                        operator/(const ipReal64 value) const;

// attributes
protected:
    ipReal64    _rho;

    ipReal64    _theta;

    ipReal64    _cosTheta;
    ipReal64    _sinTheta;
};


template <typename T>
inline
Vector2d::Vector2d(const Point2d<T>& ptEnd, const Point2d<T>& ptStart)
{
    setCoords(ptEnd, ptStart);
}

template <typename T>
inline
Vector2d::Vector2d(const Point2dData<T>& ptEnd, const Point2dData<T>& ptStart)
{
    setCoords(ptEnd, ptStart);
}

template <typename T>
inline
Vector2d::Vector2d(const Point2d<T>& ptEnd)
{
    setCoords(ptEnd);
}

template <typename T>
inline
Vector2d::Vector2d(const Point2dData<T>& ptEnd)
{
    setCoords(ptEnd);
}

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

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

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

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

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

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

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

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

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

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

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

inline ipReal64
Vector2d::getX() const
{
    return math::polarToXCartesian<ipReal64>(_rho, _cosTheta, _sinTheta);
}

inline ipReal64
Vector2d::getY() const
{
    return math::polarToYCartesian<ipReal64>(_rho, _cosTheta, _sinTheta);
}

inline ipReal64
Vector2d::getNx() const
{
    return math::polarToXCartesian<ipReal64>(1.0, _cosTheta, _sinTheta);
}

inline ipReal64
Vector2d::getNy() const
{
    return math::polarToYCartesian<ipReal64>(1.0, _cosTheta, _sinTheta);
}


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

#endif // __IPSDKGEOMETRY_VECTOR2D_H__