Plan3d.h

// Plan3d.h:
// ---------
//

#ifndef __IPSDKGEOMETRY_PLAN3D_H__
#define __IPSDKGEOMETRY_PLAN3D_H__

#include <IPSDKGeometry/IPSDKGeometryExports.h>
#include <IPSDKGeometry/Entity/3d/BaseTypedGeometryEntity3d.h>
#include <IPSDKGeometry/Entity/3d/Plan/Plan3dOperators.h>
#include <IPSDKMath/Geometry/3d/Angles3d.h>

namespace ipsdk {
namespace geom {

template <typename T>
struct Point3dData;
class Vector3d;


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

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

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

public:
    Plan3d();
    Plan3d(const ipReal64 rho, const ipReal64 theta, const ipReal64 phi);
    template <typename T>
    Plan3d(const Point3dData<T>& pt0, const Point3dData<T>& pt1, const Point3dData<T>& pt2);
    template <typename T>
    Plan3d(const Point3d<T>& pt0, const Point3d<T>& pt1, const Point3d<T>& pt2);
    ~Plan3d();
    template <typename T>
    Plan3d(const Point3dData<T>& pt, const Vector3d& normal);
    template <typename T>
    Plan3d(const Point3d<T>& pt, const Vector3d& normal);

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

    inline eEntity3dType            getEntity3dType() const;

    void                            setCoords(const ipReal64 rho, const ipReal64 theta, const ipReal64 phi);
    template <typename T>
    void                            setCoords(const Point3dData<T>& pt0, const Point3dData<T>& pt1, const Point3dData<T>& pt2);
    template <typename T>
    void                            setCoords(const Point3d<T>& pt0, const Point3d<T>& pt1, const Point3d<T>& pt2);
    template <typename T>
    void                            setCoords(const Point3dData<T>& pt, const Vector3d& normal);
    template <typename T>
    void                            setCoords(const Point3d<T>& pt, const Vector3d& normal);
    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;

    Vector3d                        getNormal() const;

    Point3dData<ipReal64>           getNearestPointFromOrigin() const;

    template <typename T>
    inline ipReal64                 distance(const Point3d<T>& pt) const;
    template <typename T>
    ipReal64                        distance(const Point3dData<T>& pt) const;

    template <typename T>
    inline ipReal64                 signedDistance(const Point3d<T>& pt) const;
    template <typename T>
    ipReal64                        signedDistance(const Point3dData<T>& pt) const;

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

    Plan3d&                         operator+=(const Vector3d& vec);
    Plan3d                          operator+(const Vector3d& vec) const;
    Plan3d&                         operator-=(const Vector3d& vec);
    Plan3d                          operator-(const Vector3d& vec) const;

// attributes
protected:
    ipReal64    _rho;

    ipReal64    _theta;

    ipReal64    _phi;

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


template <typename T>
inline
Plan3d::Plan3d(const Point3dData<T>& pt0, const Point3dData<T>& pt1, const Point3dData<T>& pt2)
{
    setCoords(pt0, pt1, pt2);
}

template <typename T>
inline
Plan3d::Plan3d(const Point3d<T>& pt0, const Point3d<T>& pt1, const Point3d<T>& pt2)
{
    setCoords(pt0, pt1, pt2);
}

template <typename T>
inline
Plan3d::Plan3d(const Point3dData<T>& pt, const Vector3d& normal)
{
    setCoords(pt, normal);
}

template <typename T>
inline
Plan3d::Plan3d(const Point3d<T>& pt, const Vector3d& normal)
{
    setCoords(pt, normal);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

#endif // __IPSDKGEOMETRY_PLAN3D_H__