Segment3d.h

// Segment3d.h:
// ------------
//

#ifndef __IPSDKGEOMETRY_SEGMENT3D_H__
#define __IPSDKGEOMETRY_SEGMENT3D_H__

// suppression warnings
// warning C4251: 'ipsdk::geom::Segment3d<ipsdk::ipInt32>::_pt0' : struct 'ipsdk::geom::Point3dData<T>' needs to have dll-interface to be used by clients of class 'ipsdk::geom::Segment3d<ipsdk::ipInt32>'
#pragma warning (push)
#pragma warning (disable : 4251)

#include <IPSDKGeometry/IPSDKGeometryExports.h>
#include <IPSDKGeometry/Entity/3d/Segment/Segment3dOperators.h>
#include <IPSDKGeometry/Entity/3d/Point/Point3d.h>
#include <IPSDKGeometry/Entity/3d/Vector/Vector3d.h>
#include <IPSDKMath/Tools/MathUtils.h>

namespace ipsdk {
namespace geom {

class Vector3d;


template <typename T>
class IPSDKGEOMETRY_API Segment3d : public BaseTypedGeometryEntity3d<T>
{
    // declare 3d geometry entity
    IPSDK_DECLARE_GEOMETRY_ENTITY_3D(IPSDKGeometry, Segment3d);

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

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

public:
    Segment3d();
    Segment3d(const T x0, const T y0, const T z0, const T x1, const T y1, const T z1);
    Segment3d(const Point3d<T>& pt0, const Point3d<T>& pt1);
    Segment3d(const Point3dData<T>& pt0, const Point3dData<T>& pt1);
    Segment3d(const Point3d<T>& pt0, const Vector3d& v01);
    Segment3d(const Point3dData<T>& pt0, const Vector3d& v01);
    ~Segment3d();

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

    inline eEntity3dType            getEntity3dType() const;

    inline void                     setCoords(const T x0, const T y0, const T z0, const T x1, const T y1, const T z1);
    inline void                     setCoords(const Point3d<T>& pt0, const Point3d<T>& pt1);
    inline void                     setCoords(const Point3dData<T>& pt0, const Point3dData<T>& pt1);
    inline void                     setCoords(const Point3d<T>& pt, const Vector3d& v01);
    inline void                     setCoords(const Point3dData<T>& pt, const Vector3d& v01);
    inline void                     setPoint0(const Point3d<T>& pt0);
    inline void                     setPoint0(const Point3dData<T>& pt0);
    inline void                     setPoint1(const Point3d<T>& pt1);
    inline void                     setPoint1(const Point3dData<T>& pt1);
    inline const Point3dData<T>&    getPoint0() const;
    inline const Point3dData<T>&    getPoint1() const;

    ipReal64                        getLength() const;

    Vector3d                        getDirection() const;

    Vector3d                        getUnitDirection() const;

    inline ipReal64                 getMiddleX() const;
    inline ipReal64                 getMiddleY() const;
    inline ipReal64                 getMiddleZ() const;
    inline Point3dData<ipReal64>    getMiddlePoint() const;

    inline ipReal64                 distance(const Point3d<T>& pt) const;
    inline ipReal64                 distance(const Point3d<T>& pt,
                                             Point3d<ipReal64>& nearestPointOnSegment) const;
    ipReal64                        distance(const Point3dData<T>& pt) const;
    ipReal64                        distance(const Point3dData<T>& pt,
                                             Point3dData<ipReal64>& nearestPointOnSegment) const;

    ipReal64                        distance(const Segment3d<T>& otherSegment) const;
    inline ipReal64                 distance(const Segment3d<T>& otherSegment,
                                             Point3d<ipReal64>& nearestPointOnThisSegment,
                                             Point3d<ipReal64>& nearestPointOnOtherSegment) const;
    ipReal64                        distance(const Segment3d<T>& otherSegment,
                                             Point3dData<ipReal64>& nearestPointOnThisSegment,
                                             Point3dData<ipReal64>& nearestPointOnOtherSegment) const;

// attributes
protected:
    Point3dData<T>      _pt0;

    Point3dData<T>      _pt1;
};


template <typename T>
inline
Segment3d<T>::Segment3d(const T x0, const T y0, const T z0, const T x1, const T y1, const T z1) :
    _pt0(x0, y0, z0),
    _pt1(x1, y1, z1)
{

}

template <typename T>
inline
Segment3d<T>::Segment3d(const Point3d<T>& pt0, const Point3d<T>& pt1) :
    _pt0(pt0.getCoords()),
    _pt1(pt1.getCoords())
{

}

template <typename T>
inline
Segment3d<T>::Segment3d(const Point3dData<T>& pt0, const Point3dData<T>& pt1) :
    _pt0(pt0),
    _pt1(pt1)
{

}

template <typename T>
inline
Segment3d<T>::Segment3d(const Point3d<T>& pt0, const Vector3d& v01)
{
    setCoords(pt0, v01);
}

template <typename T>
inline
Segment3d<T>::Segment3d(const Point3dData<T>& pt0, const Vector3d& v01)
{
    setCoords(pt0, v01);
}

template <typename T>
inline eCoordinateSystem3dType
Segment3d<T>::getCoordinateSystem3dType() const
{
    return g_coordinateSystem3dType;
}

template <typename T>
inline eEntity3dType
Segment3d<T>::getEntity3dType() const
{
    return g_entity3dType;
}

template <typename T>
inline void
Segment3d<T>::setCoords(const T x0, const T y0, const T z0, const T x1, const T y1, const T z1)
{
    _pt0.setCoords(x0, y0, z0);
    _pt1.setCoords(x1, y1, z1);
}

template <typename T>
inline void
Segment3d<T>::setCoords(const Point3d<T>& pt0, const Point3d<T>& pt1)
{
    _pt0 = pt0.getCoords();
    _pt1 = pt1.getCoords();
}

template <typename T>
inline void
Segment3d<T>::setCoords(const Point3dData<T>& pt0, const Point3dData<T>& pt1)
{
    _pt0 = pt0;
    _pt1 = pt1;
}

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

template <typename T>
inline void
Segment3d<T>::setCoords(const Point3dData<T>& pt, const Vector3d& v01)
{
    _pt0 = pt;
    _pt1 = pt;
    _pt1._x += math::round<T>(v01.getX());
    _pt1._y += math::round<T>(v01.getY());
    _pt1._z += math::round<T>(v01.getZ());
}

template <typename T>
inline void
Segment3d<T>::setPoint0(const Point3d<T>& pt0)
{
    _pt0 = pt0.getCoords();
}

template <typename T>
inline void
Segment3d<T>::setPoint0(const Point3dData<T>& pt0)
{
    _pt0 = pt0;
}

template <typename T>
inline void
Segment3d<T>::setPoint1(const Point3d<T>& pt1)
{
    _pt1 = pt1.getCoords();
}

template <typename T>
inline void
Segment3d<T>::setPoint1(const Point3dData<T>& pt1)
{
    _pt1 = pt1;
}

template <typename T>
inline const Point3dData<T>&
Segment3d<T>::getPoint0() const
{
    return _pt0;
}

template <typename T>
inline const Point3dData<T>&
Segment3d<T>::getPoint1() const
{
    return _pt1;
}

template <typename T>
inline ipReal64
Segment3d<T>::getMiddleX() const
{
    return (_pt0._x + _pt1._x) / 2.0;
}

template <typename T>
inline ipReal64
Segment3d<T>::getMiddleY() const
{
    return (_pt0._y + _pt1._y) / 2.0;
}

template <typename T>
inline ipReal64
Segment3d<T>::getMiddleZ() const
{
    return (_pt0._z + _pt1._z) / 2.0;
}

template <typename T>
inline Point3dData<ipReal64>
Segment3d<T>::getMiddlePoint() const
{
    return Point3dData<ipReal64>(getMiddleX(), getMiddleY(), getMiddleZ());
}

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

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

template <typename T>
inline ipReal64
Segment3d<T>::distance(const Segment3d<T>& otherSegment,
                       Point3d<ipReal64>& nearestPointOnThisSegment,
                       Point3d<ipReal64>& nearestPointOnOtherSegment) const
{
    return distance(otherSegment, nearestPointOnThisSegment.getCoords(), nearestPointOnOtherSegment.getCoords());
}


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

#pragma warning (pop)

#endif // __IPSDKGEOMETRY_SEGMENT3D_H__