Vector3d.h

// Vector3d.h:
// -----------
//

#ifndef __IPSDKGEOMETRY_VECTOR3D_H__
#define __IPSDKGEOMETRY_VECTOR3D_H__

#include <IPSDKGeometry/Entity/3d/BaseTypedGeometryEntity3d.h>
#include <IPSDKGeometry/Entity/3d/Vector/Vector3dOperators.h>
#include <IPSDKGeometry/Entity/3d/Vector/Vector3dFunctions.h>
#include <IPSDKMath/Geometry/3d/Angles3d.h>

namespace ipsdk {
namespace geom {

template <typename T>
class Point3d;


class IPSDKGEOMETRY_API Vector3d : public BaseTypedGeometryEntity3d<ipReal64>
{
    // declare 3d geometry entity
    IPSDK_DECLARE_GEOMETRY_ENTITY_3D(IPSDKGeometry, Vector3d);

// predefined public types
public:
    static const eCoordinateSystem3dType::domain g_coordinateSystem3dType = eCoordinateSystem3dType::eCS3DT_Spherical;

    static const eEntity3dType::domain g_entity3dType = eEntity3dType::eE3DT_Vector;

public:
    Vector3d();
    Vector3d(const ipReal64 rho, const ipReal64 theta, const ipReal64 phi);
    template <typename T>
    Vector3d(const Point3d<T>& ptEnd, const Point3d<T>& ptStart);
    template <typename T>
    Vector3d(const Point3dData<T>& ptEnd, const Point3dData<T>& ptStart);
    template <typename T>
    explicit Vector3d(const Point3d<T>& ptEnd);
    template <typename T>
    explicit Vector3d(const Point3dData<T>& ptEnd);
    ~Vector3d();

// methods
public:
    inline eCoordinateSystem3dType  getCoordinateSystem3dType() const;

    inline eEntity3dType            getEntity3dType() const;

    void                            setCoords(const ipReal64 rho, const ipReal64 theta, const ipReal64 phi);
    template <typename T>
    inline void                     setCoords(const Point3d<T>& ptEnd, const Point3d<T>& ptStart);
    template <typename T>
    void                            setCoords(const Point3dData<T>& ptEnd, const Point3dData<T>& ptStart);
    template <typename T>
    inline void                     setCoords(const Point3d<T>& ptEnd);
    template <typename T>
    void                            setCoords(const Point3dData<T>& ptEnd);
    inline void                     setRho(const ipReal64 rho);
    inline void                     setTheta(const ipReal64 theta);
    inline void                     setPhi(const ipReal64 phi);
    inline ipReal64                 getRho() const;
    inline ipReal64                 getTheta() const;
    inline ipReal64                 getPhi() const;

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

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

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

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

// attributes
protected:
    ipReal64    _rho;

    ipReal64    _theta;

    ipReal64    _phi;

    ipReal64    _cosTheta;
    ipReal64    _sinTheta;
    ipReal64    _cosPhi;
    ipReal64    _sinPhi;
};


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

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

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

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

inline eCoordinateSystem3dType
Vector3d::getCoordinateSystem3dType() const
{
    return g_coordinateSystem3dType;
}

inline eEntity3dType
Vector3d::getEntity3dType() const
{
    return g_entity3dType;
}

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

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

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

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

inline void
Vector3d::setPhi(const ipReal64 phi)
{
    _phi = math::centerModulo(phi, 2*M_PI);
    _cosPhi = std::cos(_phi);
    _sinPhi = std::sin(_phi);
}

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

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

inline ipReal64
Vector3d::getPhi() const
{
    return _phi;
}

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

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

inline ipReal64
Vector3d::getCosPhi() const
{
    return _cosPhi;
}

inline ipReal64
Vector3d::getSinPhi() const
{
    return _sinPhi;
}

inline ipReal64
Vector3d::getX() const
{
    return math::sphericalToXCartesian<ipReal64>(_rho, _cosTheta, _sinTheta, _cosPhi, _sinPhi);
}

inline ipReal64
Vector3d::getY() const
{
    return math::sphericalToYCartesian<ipReal64>(_rho, _cosTheta, _sinTheta, _cosPhi, _sinPhi);
}

inline ipReal64
Vector3d::getZ() const
{
    return math::sphericalToZCartesian<ipReal64>(_rho, _cosTheta, _sinTheta, _cosPhi, _sinPhi);
}

inline ipReal64
Vector3d::getNx() const
{
    return math::sphericalToXCartesian<ipReal64>(1.0, _cosTheta, _sinTheta, _cosPhi, _sinPhi);
}

inline ipReal64
Vector3d::getNy() const
{
    return math::sphericalToYCartesian<ipReal64>(1.0, _cosTheta, _sinTheta, _cosPhi, _sinPhi);
}

inline ipReal64
Vector3d::getNz() const
{
    return math::sphericalToZCartesian<ipReal64>(1.0, _cosTheta, _sinTheta, _cosPhi, _sinPhi);
}


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

#endif // __IPSDKGEOMETRY_VECTOR3D_H__