Segment2d.h

// Segment2d.h:
// ------------
//

#ifndef __IPSDKGEOMETRY_SEGMENT2D_H__
#define __IPSDKGEOMETRY_SEGMENT2D_H__

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

#include <IPSDKGeometry/Entity/2d/BaseTypedGeometryEntity2d.h>
#include <IPSDKGeometry/Entity/2d/Segment/Segment2dOperators.h>
#include <IPSDKGeometry/Entity/2d/Point/Point2d.h>
#include <IPSDKGeometry/Entity/2d/Vector/Vector2d.h>
#include <IPSDKMath/Tools/MathUtils.h>

namespace ipsdk {
namespace geom {

class Vector2d;


template <typename T>
class IPSDKGEOMETRY_API Segment2d : public BaseTypedGeometryEntity2d<T>
{
    // declare 2d geometry entity
    IPSDK_DECLARE_GEOMETRY_ENTITY_2D(IPSDKGeometry, Segment2d);

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

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

public:
    Segment2d();
    Segment2d(const T x0, const T y0, const T x1, const T y1);
    Segment2d(const Point2d<T>& pt0, const Point2d<T>& pt1);
    Segment2d(const Point2dData<T>& pt0, const Point2dData<T>& pt1);
    Segment2d(const Point2d<T>& pt0, const Vector2d& v10);
    Segment2d(const Point2dData<T>& pt0, const Vector2d& v10);
    ~Segment2d();

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

    inline eEntity2dType            getEntity2dType() const;

    inline void                     setCoords(const T x0, const T y0, const T x1, const T y1);
    inline void                     setCoords(const Point2d<T>& pt0, const Point2d<T>& pt1);
    inline void                     setCoords(const Point2dData<T>& pt0, const Point2dData<T>& pt1);
    inline void                     setCoords(const Point2d<T>& pt, const Vector2d& v01);
    inline void                     setCoords(const Point2dData<T>& pt, const Vector2d& v01);
    inline void                     setPoint0(const Point2d<T>& pt0);
    inline void                     setPoint0(const Point2dData<T>& pt0);
    inline void                     setPoint1(const Point2d<T>& pt1);
    inline void                     setPoint1(const Point2dData<T>& pt1);
    inline const Point2dData<T>&    getPoint0() const;
    inline const Point2dData<T>&    getPoint1() const;

    ipReal64                        getLength() const;

    Vector2d                        getDirection() const;

    Vector2d                        getUnitDirection() const;

    Vector2d                        getUnitNormal() const;

    inline ipReal64                 getMiddleX() const;
    inline ipReal64                 getMiddleY() const;
    inline Point2dData<ipReal64>    getMiddlePoint() const;

    inline ipReal64                 distance(const Point2d<T>& pt) const;
    inline ipReal64                 distance(const Point2d<T>& pt,
                                             Point2d<ipReal64>& nearestPointOnSegment) const;
    ipReal64                        distance(const Point2dData<T>& pt) const;
    ipReal64                        distance(const Point2dData<T>& pt,
                                             Point2dData<ipReal64>& nearestPointOnSegment) const;

    ipReal64                        distance(const Segment2d<T>& otherSegment) const;
    inline ipReal64                 distance(const Segment2d<T>& otherSegment,
                                             Point2d<ipReal64>& nearestPointOnThisSegment,
                                             Point2d<ipReal64>& nearestPointOnOtherSegment) const;
    ipReal64                        distance(const Segment2d<T>& otherSegment,
                                             Point2dData<ipReal64>& nearestPointOnThisSegment,
                                             Point2dData<ipReal64>& nearestPointOnOtherSegment) const;

// attributes
protected:
    Point2dData<T>      _pt0;

    Point2dData<T>      _pt1;
};


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

}

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

}

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

}

template <typename T>
inline
Segment2d<T>::Segment2d(const Point2d<T>& pt0, const Vector2d& v01)
{
    setCoords(pt0, v01);
}

template <typename T>
inline
Segment2d<T>::Segment2d(const Point2dData<T>& pt0, const Vector2d& v01)
{
    setCoords(pt0, v01);
}

template <typename T>
inline eCoordinateSystem2dType
Segment2d<T>::getCoordinateSystem2dType() const
{
    return g_coordinateSystem2dType;
}

template <typename T>
inline eEntity2dType
Segment2d<T>::getEntity2dType() const
{
    return g_entity2dType;
}

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

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

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

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

template <typename T>
inline void
Segment2d<T>::setCoords(const Point2dData<T>& pt, const Vector2d& v01)
{
    _pt0 = pt;
    _pt1 = pt;
    _pt1._x += math::round<T>(v01.getX());
    _pt1._y += math::round<T>(v01.getY());
}

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

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

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

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

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

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

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

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

template <typename T>
inline Point2dData<ipReal64>
Segment2d<T>::getMiddlePoint() const
{
    return Point2dData<ipReal64>(getMiddleX(), getMiddleY());
}

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

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

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


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

#pragma warning (pop)

#endif // __IPSDKGEOMETRY_SEGMENT2D_H__