h2d::base::SegVec< SV, FPT > Class Template Reference

A line segment, oriented (OSegment_) or not (Segment_). Holds the two points. More...

#include <homog2d.hpp>

Inheritance diagram for h2d::base::SegVec< SV, FPT >:

Collaboration diagram for h2d::base::SegVec< SV, FPT >:

Public Types
using	FType = FPT
using	SType = SV

Public Member Functions
void	draw (img::Image< cv::Mat > &, img::DrawParams dp=img::DrawParams()) const
void	draw (img::Image< img::SvgImage > &, img::DrawParams dp=img::DrawParams()) const
template<typename T >
std::pair< SegVec< SV, FPT >, SegVec< SV, FPT > >	getParallelSegs (T dist) const
	Returns two parallel segments to the current one in a pair. More...
template<typename T >
PointSide	getPointSide (const Point2d_< T > &pt) const
	Return side of point pt relatively to the segment (Oriented only) More...
template<typename T >
std::pair< OSegment_< FPT >, OSegment_< FPT > >	split (T dist) const
	Returns a pair of segments/vectors split by point at arbitrary distance. More...
Type	type () const
Constructors
	SegVec ()
	Default constructor: initializes segment to (0,0)–(1,1) More...
template<typename FP1 , typename FP2 >
	SegVec (Point2d_< FP1 > p1, Point2d_< FP2 > p2)
	Constructor 2: build segment from two points, can hold different FP types. More...
template<typename FP1 , typename FP2 , typename FP3 , typename FP4 >
	SegVec (FP1 x1, FP2 y1, FP3 x2, FP4 y2)
	Constructor 3: build segment from two points coordinates, calls constructor 2. More...
template<typename FP1 , typename FP2 >
	SegVec (const PointPair2_< FP1, FP2 > &ppts)
	Constructor 4: build segment from pair of points. More...
template<typename SV2 , typename FPT2 >
	SegVec (const SegVec< SV2, FPT2 > &other)
	Copy-Constructor, behavior depends on concrete types. More...
Modifying functions
SegVec< SV, FPT >	operator- ()
	Reverse oriented segment. More...
template<typename FP1 , typename FP2 >
void	set (const Point2d_< FP1 > &p1, const Point2d_< FP2 > &p2)
	Setter. More...
template<typename FP1 , typename FP2 >
void	set (const PointPair2_< FP1, FP2 > &ppts)
	Setter from a std::pair. More...
template<typename FP1 , typename FP2 , typename FP3 , typename FP4 >
void	set (FP1 x1, FP2 y1, FP3 x2, FP4 y2)
	Setter from 4 raw point coordinates. More...
template<typename T1 , typename T2 >
void	translate (T1 dx, T2 dy)
	Translate Segment. More...
template<typename T1 , typename T2 >
void	translate (const std::pair< T1, T2 > &pa)
	Translate Segment, using pair of values. More...
template<typename TX , typename TY >
void	moveTo (TX x, TY y)
	Move Segment to other location. More...
template<typename T1 >
void	moveTo (const Point2d_< T1 > &pt)
	Move Segment to other location, given by pt. More...
Attributes access
FRect_< HOMOG2D_INUMTYPE >	getBB () const
	Get Bounding Box of segment, always throws but needed so the function getBB(T1,T2) builds, whatever the types and because of variant (. More...
constexpr size_t	size () const
	Returns 2. More...
HOMOG2D_INUMTYPE	length () const
	Get segment length. More...
constexpr HOMOG2D_INUMTYPE	area () const
	A segment always has a null area. More...
std::pair< HOMOG2D_INUMTYPE, HOMOG2D_INUMTYPE >	getVector () const
	Get vector of Oriented segment as a pair of values. More...
template<typename SV2 , typename FPT2 >
HOMOG2D_INUMTYPE	getAngle (const SegVec< SV2, FPT2 > &other) const
	Get angle between segment and other segment. More...
template<typename LP , typename FPT2 >
HOMOG2D_INUMTYPE	getAngle (const base::LPBase< LP, FPT2 > &other) const
	Get angle between segment and line. More...
Operators
bool	operator== (const SegVec &s2) const
bool	operator!= (const SegVec &s2) const
bool	operator< (const SegVec &other) const
Enclosing functions
template<typename FPT2 >
bool	isInside (const Circle_< FPT2 > &shape) const
	Segment is inside Circle. More...
template<typename FPT2 >
bool	isInside (const FRect_< FPT2 > &shape) const
	Segment is inside FRect. More...
template<typename FPT2 >
bool	isInside (const Ellipse_< FPT2 > &shape) const
	Segment is inside Ellipse. More...
template<typename FPT2 >
constexpr bool	isInside (const OPolyline_< FPT2 > &) const
	Segment is inside OPolyline_. More...
template<typename FPT2 >
bool	isInside (const CPolyline_< FPT2 > &cpoly) const
	Segment is inside CPolyline_. More...
Intersection functions
template<typename SV2 , typename FPT2 >
detail::Intersect< detail::Inters_1, FPT >	intersects (const SegVec< SV2, FPT2 > &) const
	Segment/Segment intersection. More...
template<typename FPT2 >
detail::Intersect< detail::Inters_1, FPT >	intersects (const Line2d_< FPT2 > &) const
	Segment/Line intersection. More...
template<typename FPT2 >
detail::IntersectM< FPT >	intersects (const Circle_< FPT2 > &) const
	Segment/Circle intersection. More...
template<typename FPT2 >
detail::IntersectM< FPT >	intersects (const FRect_< FPT2 > &r) const
	Segment/FRect intersection. More...
template<typename PLT , typename FPT2 >
detail::IntersectM< FPT >	intersects (const base::PolylineBase< PLT, FPT2 > &other) const
	Segment/Polyline intersection. More...
Public Member Functions inherited from h2d::detail::Common< FPT >
std::pair< int, int >	dsize () const
	Get data size expressed as number of bits for, respectively, mantissa and exponent. More...
Dtype	dtype () const
	Get numerical data type as a Dtype value, can be stringified with h2d::getString(Dtype) More...
template<typename T >
constexpr bool	isInside (const Common< T > &) const
	This function is a fallback for all sub-classes that do not provide such a method. More...
size_t	size () const
Public Member Functions inherited from h2d::rtp::Root
virtual	~Root ()

Friends
template<typename U , typename V >
std::ostream &	operator<< (std::ostream &, const SegVec< U, V > &)
template<typename T1 , typename T2 >
class	SegVec

Other const functions
PointPair_< FPT >	getPts () const
	Returns the points of segment as a std::pair. More...
template<typename T >
std::pair< SegVec, SegVec >	getParallelSegs (T dist) const
template<typename FPT2 >
Point2d_< HOMOG2D_INUMTYPE >	getPointAt (FPT2 dist) const
	Returns the point at a distance dist from starting point of oriented vector. More...
std::array< Point2d_< FPT >, 4 >	getOrthogPts () const
	Returns the 4 points orthogonal to the segment/vector. More...
std::array< Segment_< FPT >, 4 >	getOrthogSegs () const
	Returns the 4 segments/vectors orthogonal to the segment. More...
auto	getLine () const
	Returns supporting line. More...
template<typename FPT2 >
PointSide	getPointSide (const Point2d_< FPT2 > &pt) const
std::pair< SegVec< SV, FPT >, SegVec< SV, FPT > >	split () const
	Returns a pair of segments/vectors split by the middle. More...
template<typename T >
std::pair< SegVec< typ::IsOSeg, FPT >, SegVec< typ::IsOSeg, FPT > >	split (T dist) const
template<typename FPT2 >
HOMOG2D_INUMTYPE	distTo (const Point2d_< FPT2 > &, int *segDistCase=0) const
	Distance from point to segment. More...
template<typename T >
constexpr bool	isParallelTo (const T &other) const
auto	getCenter () const
	Returns point at middle distance between p1 and p2. More...
SegVec< SV, FPT >	getExtended () const
	Returns a segment with same support line but tripled length. More...
auto	getBisector () const
	Returns the bisector line of the segment. More...

Detailed Description

template<typename SV, typename FPT>
class h2d::base::SegVec< SV, FPT >

A line segment, oriented (OSegment_) or not (Segment_). Holds the two points.

This will get instanciated as Segment_ or OSegment_

The difference between theses two types is that with Segment_, the "smallest" point is always stored as first element (see constructor).

Member Typedef Documentation

FType

template<typename SV, typename FPT>

using h2d::base::SegVec< SV, FPT >::FType = FPT

SType

template<typename SV, typename FPT>

using h2d::base::SegVec< SV, FPT >::SType = SV

Constructor & Destructor Documentation

SegVec() [1/5]

template<typename SV, typename FPT>

h2d::base::SegVec< SV, FPT >::SegVec ( )

inline

Default constructor: initializes segment to (0,0)–(1,1)

            : _ptS2(1.,1.)
    {}

SegVec() [2/5]

template<typename SV, typename FPT>

template<typename FP1 , typename FP2 >

h2d::base::SegVec< SV, FPT >::SegVec ( Point2d_< FP1 >  p1, Point2d_< FP2 >  p2  )

inline

Constructor 2: build segment from two points, can hold different FP types.

Please note that the source (points) floating-point type is lost

        : _ptS1(p1), _ptS2(p2)
    {
#ifndef HOMOG2D_NOCHECKS
        if( p1 == p2 )
            HOMOG2D_THROW_ERROR_1( "cannot build a segment with two identical points: " << p1 << " and " << p2 );
#endif
        if constexpr( std::is_same_v<SV,typ::IsSegment> )
            priv::fix_order( _ptS1, _ptS2 );
    }

Here is the call graph for this function:

SegVec() [3/5]

template<typename SV, typename FPT>

template<typename FP1 , typename FP2 , typename FP3 , typename FP4 >

h2d::base::SegVec< SV, FPT >::SegVec ( FP1  x1, FP2  y1, FP3  x2, FP4  y2  )

inline

Constructor 3: build segment from two points coordinates, calls constructor 2.

        : SegVec( Point2d_<FPT>(x1,y1), Point2d_<FPT>(x2,y2) )
    {
        HOMOG2D_CHECK_IS_NUMBER(FP1);
        HOMOG2D_CHECK_IS_NUMBER(FP2);
        HOMOG2D_CHECK_IS_NUMBER(FP3);
        HOMOG2D_CHECK_IS_NUMBER(FP4);
    }

SegVec() [4/5]

template<typename SV, typename FPT>

template<typename FP1 , typename FP2 >

h2d::base::SegVec< SV, FPT >::SegVec ( const PointPair2_< FP1, FP2 > &  ppts )

inline

Constructor 4: build segment from pair of points.

        : SegVec(ppts.first, ppts.second)
    {}

SegVec() [5/5]

template<typename SV, typename FPT>

template<typename SV2 , typename FPT2 >

h2d::base::SegVec< SV, FPT >::SegVec ( const SegVec< SV2, FPT2 > &  other )

inline

Copy-Constructor, behavior depends on concrete types.

• OSegment(OSegment): OK
• Segment(OSegment): OK, but loose orientation
• Segment(Segment): OK
• OSegment(Segment): No build, because orientation would be arbitrary

        : _ptS1(other._ptS1), _ptS2(other._ptS2)
    {
        static_assert(
            ( std::is_same_v<SV,typ::IsSegment>
            ||
            ( std::is_same_v<SV,typ::IsOSeg> && std::is_same_v<SV2,typ::IsOSeg> ) ),
            "Cannot build a OSegment from a Segment"
        );
        if constexpr( std::is_same_v<SV2,typ::IsSegment> )
            priv::fix_order( _ptS1, _ptS2 );
    }

Here is the call graph for this function:

Member Function Documentation

area()

template<typename SV, typename FPT>

constexpr HOMOG2D_INUMTYPE h2d::base::SegVec< SV, FPT >::area ( ) const

inlinevirtual

A segment always has a null area.

Implements h2d::rtp::Root.

    {
        return 0.;
    }

Here is the caller graph for this function:

distTo()

template<typename SV , typename FPT >

template<typename FPT2 >

HOMOG2D_INUMTYPE h2d::base::SegVec< SV, FPT >::distTo	(	const Point2d_< FPT2 > &	pt,
		int *	segDistCase = 0
	)		const

Distance from point to segment.

source: https://stackoverflow.com/a/6853926/193789

Temp implementation, until we get into this a bit more deeper

Todo:

20250219: pass an enum instead as an int, for segDistCase

Parameters

pt	the point
segDistCase	optional, may be used to know if its the orthogonal distance or not

{
    auto ppts = getPts();
    auto x1 = static_cast<HOMOG2D_INUMTYPE>( ppts.first.getX() );
    auto y1 = static_cast<HOMOG2D_INUMTYPE>( ppts.first.getY() );
    auto x2 = static_cast<HOMOG2D_INUMTYPE>( ppts.second.getX() );
    auto y2 = static_cast<HOMOG2D_INUMTYPE>( ppts.second.getY() );

    auto A = static_cast<HOMOG2D_INUMTYPE>(pt.getX()) - x1;
    auto B = static_cast<HOMOG2D_INUMTYPE>(pt.getY()) - y1;
    auto C = x2 - x1;
    auto D = y2 - y1;

    auto dot    = A * C + B * D;
    auto len_sq = C * C + D * D;
    auto param  = dot / len_sq;

    HOMOG2D_INUMTYPE xx, yy;

    if( param < 0. )
    {
        if( segDistCase )
            *segDistCase = -1;
        xx = x1;
        yy = y1;
    }
    else
    {
        if( param > 1. )
        {
            if( segDistCase )
                *segDistCase = +1;
            xx = x2;
            yy = y2;
        }
        else
        {
            if( segDistCase )
                *segDistCase = 0;
            xx = x1 + param * C;
            yy = y1 + param * D;
        }
    }

    auto dx = pt.getX() - xx;
    auto dy = pt.getY() - yy;
    return homog2d_sqrt( dx * dx + dy * dy );
}

Here is the call graph for this function:

Here is the caller graph for this function:

draw() [1/2]

template<typename SV , typename FPT >

void h2d::base::SegVec< SV, FPT >::draw ( img::Image< cv::Mat > &  im, img::DrawParams  dp = img::DrawParams()  ) const

virtual

Implements h2d::rtp::Root.

{
    cv::line(
        im.getReal(),
        _ptS1.getCvPtd(),
        _ptS2.getCvPtd(),
        dp.cvColor(),
        dp._dpValues._lineThickness,
        dp._dpValues._lineType==1?cv::LINE_AA:cv::LINE_8
    );

    if constexpr( std::is_same_v<SV,typ::IsOSeg> )
    {
        auto arrsegs = priv::getArrowSegments( *this );
        for( auto ppts: arrsegs )
            cv::line(
                im.getReal(),
                ppts.first.getCvPtd(),
                ppts.second.getCvPtd(),
                dp.cvColor(),
                dp._dpValues._lineThickness,
                dp._dpValues._lineType==1?cv::LINE_AA:cv::LINE_8
            );
    }
    else
    {
        if( dp._dpValues._showPoints )
        {
            _ptS1.draw( im, dp );
            _ptS2.draw( im, dp );
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

draw() [2/2]

template<typename SV , typename FPT >

void h2d::base::SegVec< SV, FPT >::draw ( img::Image< img::SvgImage > &  im, img::DrawParams  dp = img::DrawParams()  ) const

virtual

Implements h2d::rtp::Root.

{
    auto group = false;
    if( dp._dpValues._showPoints || std::is_same_v<SV,typ::IsOSeg> )
        group = true;

    if( group )
        im.getReal()._svgString << "<g>";

    auto pts = getPts();
    priv::drawSvgSeg( im, pts, dp.getSvgRgbColor(), dp._dpValues._lineThickness, dp.getAttrString() );

    if constexpr( std::is_same_v<SV,typ::IsOSeg> )
    {
        auto arrsegs = priv::getArrowSegments( *this );
        for( auto ppts: arrsegs )
            priv::drawSvgSeg( im, ppts, dp.getSvgRgbColor(), dp._dpValues._lineThickness );
    }
    else
    {
        if( dp._dpValues._showPoints )
        {
            _ptS1.draw( im, dp );
            _ptS2.draw( im, dp );
        }
    }

    if( group )
        im.getReal()._svgString << "</g>\n";
}

Here is the call graph for this function:

getAngle() [1/2]

template<typename SV, typename FPT>

template<typename SV2 , typename FPT2 >

HOMOG2D_INUMTYPE h2d::base::SegVec< SV, FPT >::getAngle ( const SegVec< SV2, FPT2 > &  other ) const

inline

Get angle between segment and other segment.

• if either the object or the argument is not oriented, then this will return the line angles, in the range [0:+PI]
• if both are oriented, will return a value in the range [-PI:+PI]

    {
// if one of the two is a (unoriented) segment, then we just return the lines angle
        if constexpr( std::is_same_v<SV,typ::IsSegment> || std::is_same_v<SV2,typ::IsSegment> )
            return other.getLine().getAngle( this->getLine() );
        else
        {                                          // both are oriented segments
            auto v1 = this->getVector();
            auto v2 = other.getVector();
            auto dx1 = v1.first;
            auto dx2 = v2.first;
            auto dy1 = v1.second;
            auto dy2 = v2.second;
            return std::atan2(
                dx1 * dy2 - dy1 * dx2,
                dx1 * dx2 + dy1 * dy2
            );
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

getAngle() [2/2]

template<typename SV, typename FPT>

template<typename LP , typename FPT2 >

HOMOG2D_INUMTYPE h2d::base::SegVec< SV, FPT >::getAngle ( const base::LPBase< LP, FPT2 > &  other ) const

inline

Get angle between segment and line.

    {
        static_assert( std::is_same_v<LP,typ::IsLine>, "cannot compute angle between segment and point" );
        return getLine().getAngle( other );
    }

Here is the call graph for this function:

getBB()

template<typename SV, typename FPT>

FRect_<HOMOG2D_INUMTYPE> h2d::base::SegVec< SV, FPT >::getBB ( ) const

inline

Get Bounding Box of segment, always throws but needed so the function getBB(T1,T2) builds, whatever the types and because of variant (.

See also

CommonType) (HOMOG2D_ENABLE_VRTP)

    {
        HOMOG2D_THROW_ERROR_1( "invalid call, Segment has no Bounding Box" );
    }

getBisector()

template<typename SV, typename FPT>

auto h2d::base::SegVec< SV, FPT >::getBisector ( ) const

inline

Returns the bisector line of the segment.

See also

free function h2d::getBisector()

    {
        SegVec<SV,HOMOG2D_INUMTYPE> seg2 = *this; // convert to (possibly) enhance precision
        return seg2.getLine().getOrthogLine( seg2.getCenter() );
    }

Here is the caller graph for this function:

getCenter()

template<typename SV, typename FPT>

auto h2d::base::SegVec< SV, FPT >::getCenter ( ) const

inline

Returns point at middle distance between p1 and p2.

    {
        return Point2d_<HOMOG2D_INUMTYPE>(
            ( static_cast<HOMOG2D_INUMTYPE>(_ptS1.getX()) + _ptS2.getX() ) / 2.,
            ( static_cast<HOMOG2D_INUMTYPE>(_ptS1.getY()) + _ptS2.getY() ) / 2.
        );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

getExtended()

template<typename SV , typename FPT >

SegVec< SV, FPT > h2d::base::SegVec< SV, FPT >::getExtended

(

)

const

Returns a segment with same support line but tripled length.

With (1,0)-(2,0) as input, will return the segment (0,0)-(3,0)

{
    Segment_<HOMOG2D_INUMTYPE> seg(*this); // to get highest precision
    auto li = seg.getLine();
    auto rad1 = seg.length();
    auto c1 = Circle_<HOMOG2D_INUMTYPE>( _ptS1, rad1 );
    auto c2 = Circle_<HOMOG2D_INUMTYPE>( _ptS2, rad1 );

    auto int1 = li.intersects( c1 );
    auto int2 = li.intersects( c2 );
    assert( int1() );
    assert( int2() );
    auto ppt1 = int1.get();
    auto ppt2 = int2.get();

    return Segment_<FPT>(
        ppt1.first,
        ppt2.second
    );
}

Here is the call graph for this function:

Here is the caller graph for this function:

getLine()

template<typename SV, typename FPT>

auto h2d::base::SegVec< SV, FPT >::getLine ( ) const

inline

Returns supporting line.

    {
        Point2d_<HOMOG2D_INUMTYPE> pt1( _ptS1 );
        Point2d_<HOMOG2D_INUMTYPE> pt2( _ptS2 );
        auto li = pt1 * pt2;
        return Line2d_<HOMOG2D_INUMTYPE>(li);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

getOrthogPts()

template<typename SV, typename FPT>

std::array<Point2d_<FPT>,4> h2d::base::SegVec< SV, FPT >::getOrthogPts ( ) const

inline

Returns the 4 points orthogonal to the segment/vector.

    {
        return p_getOrthog();
    }

Here is the caller graph for this function:

getOrthogSegs()

template<typename SV, typename FPT>

std::array<Segment_<FPT>,4> h2d::base::SegVec< SV, FPT >::getOrthogSegs ( ) const

inline

Returns the 4 segments/vectors orthogonal to the segment.

    {
        std::array<Segment_<FPT>,4> out;
        auto pts = p_getOrthog();
        out[0] = Segment_<FPT>( _ptS1, pts[0] );
        out[1] = Segment_<FPT>( _ptS1, pts[1] );
        out[2] = Segment_<FPT>( _ptS2, pts[2] );
        out[3] = Segment_<FPT>( _ptS2, pts[3] );
        return out;
    }

Here is the caller graph for this function:

getParallelSegs() [1/2]

template<typename SV, typename FPT>

template<typename T >

std::pair<SegVec,SegVec> h2d::base::SegVec< SV, FPT >::getParallelSegs

(

T

dist

)

const

Here is the caller graph for this function:

getParallelSegs() [2/2]

template<typename SV, typename FPT>

template<typename T >

std::pair<SegVec<SV,FPT>,SegVec<SV,FPT> > h2d::base::SegVec< SV, FPT >::getParallelSegs

(

T

dist

)

const

Returns two parallel segments to the current one in a pair.

Behavior differs depending on type of segment:

• if oriented (OSegment_), the returned pair will hold as first the segment that is left of the original
• if not oriented (Segment_), the order will be unpredictable

{
    HOMOG2D_CHECK_IS_NUMBER( T );
#ifndef HOMOG2D_NOCHECKS
    if( dist <= 0 )
        HOMOG2D_THROW_ERROR_1( "Invalid value for distance:" << dist );
#endif

    auto plines = getLine().getParallelLines( dist );
    auto lo1 = getLine().getOrthogLine( _ptS1 );
    auto lo2 = getLine().getOrthogLine( _ptS2 );

    auto pA1 = lo1 * plines.first;
    auto pA2 = lo2 * plines.first;
    auto pB1 = lo1 * plines.second;
    auto pB2 = lo2 * plines.second;

    if constexpr( std::is_same_v<SV,typ::IsOSeg> )
        if( getPointSide(pB1) == PointSide::Left )
        {
            std::swap( pA1, pB1 );
            std::swap( pA2, pB2 );
        }

    return std::make_pair(
        SegVec( pA1, pA2 ),
        SegVec( pB1, pB2 )
    );
}

Here is the call graph for this function:

getPointAt()

template<typename SV , typename FPT >

template<typename FPT2 >

Point2d_< HOMOG2D_INUMTYPE > h2d::base::SegVec< SV, FPT >::getPointAt

(

FPT2

dist

)

const

Returns the point at a distance dist from starting point of oriented vector.

{
    static_assert( std::is_same_v<SV,typ::IsOSeg>, "Cannot apply on non-oriented segment" );
    HOMOG2D_CHECK_IS_NUMBER(FPT2);
#ifndef HOMOG2D_NOCHECKS
    if( dist < 0 )
        HOMOG2D_THROW_ERROR_1( "distance value must be >0, current value=" << dist );
#endif

    Line2d_<HOMOG2D_INUMTYPE> li = getLine();
    auto ppts = li.getPoints( _ptS1, dist );
    if( _ptS2.distTo( ppts.first ) < _ptS2.distTo( ppts.second ) )
        return ppts.first;
    else
        return ppts.second;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getPointSide() [1/2]

template<typename SV, typename FPT>

template<typename FPT2 >

PointSide h2d::base::SegVec< SV, FPT >::getPointSide

(

const Point2d_< FPT2 > &

pt

)

const

Here is the caller graph for this function:

getPointSide() [2/2]

template<typename SV, typename FPT>

template<typename T >

PointSide h2d::base::SegVec< SV, FPT >::getPointSide

(

const Point2d_< T > &

pt

)

const

Return side of point pt relatively to the segment (Oriented only)

{
    static_assert( std::is_same_v<SV,typ::IsOSeg>, "unable to get side of point related to Segment" );

    if( pt == _ptS1 || pt == _ptS2 )
        return PointSide::Neither;

    OSegment_<FPT> other( _ptS1, pt );
    HOMOG2D_INUMTYPE cp = detail::crossProductV( other, *this );
    PointSide out;
    switch ( priv::sign(cp) )
    {
        case  0: out = PointSide::Neither; break;
        case -1: out = PointSide::Left;    break;
        case +1: out = PointSide::Right;   break;
        default: assert(0);
    }
    return out;
}

Here is the call graph for this function:

getPts()

template<typename SV, typename FPT>

PointPair_<FPT> h2d::base::SegVec< SV, FPT >::getPts ( ) const

inline

Returns the points of segment as a std::pair.

If "Segment", then the one with smallest x coordinate will be returned as "first". If x-coordinate are equal, then the one with smallest y-coordinate will be returned first

    {
        return std::make_pair( _ptS1, _ptS2 );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

getVector()

template<typename SV, typename FPT>

std::pair<HOMOG2D_INUMTYPE,HOMOG2D_INUMTYPE> h2d::base::SegVec< SV, FPT >::getVector ( ) const

inline

Get vector of Oriented segment as a pair of values.

    {
        static_assert( std::is_same_v<SV,typ::IsOSeg>, "cannot return vector of unoriented segment" );
        return std::make_pair(
            _ptS2.getX() - _ptS1.getX(),
            _ptS2.getY() - _ptS1.getY()
        );
    }

Here is the call graph for this function:

intersects() [1/5]

template<typename SV , typename FPT >

template<typename SV2 , typename FPT2 >

detail::Intersect< detail::Inters_1, FPT > h2d::base::SegVec< SV, FPT >::intersects

(

const SegVec< SV2, FPT2 > &

s2

)

const

Segment/Segment intersection.

Algorithm:

• first compute the intersection point
• then check if the intersection point lies in between the range of both segments, both on x and on y

{
//  HOMOG2D_START;
    if( *this == s2 )              // same segment => no intersection
        return detail::Intersect<detail::Inters_1,FPT>();

    Line2d_<HOMOG2D_INUMTYPE> l1 = getLine();
    Line2d_<HOMOG2D_INUMTYPE> l2 = s2.getLine();
    if( l1.isParallelTo( l2 ) )                            // if parallel,
        return detail::Intersect<detail::Inters_1,FPT>();  // then, no intersection

    const auto& ptA1 = getPts().first;
    const auto& ptA2 = getPts().second;
    const auto& ptB1 = s2.getPts().first;
    const auto& ptB2 = s2.getPts().second;

    auto ptInter = l1 * l2;   // intersection point

    auto dA1 = ptA1.distTo( ptInter );
    auto dA2 = ptA2.distTo( ptInter );
    if( homog2d_abs(dA1+dA2 - length()) < thr::nullDistance() )
    {
        auto dB1 = ptB1.distTo( ptInter );
        auto dB2 = ptB2.distTo( ptInter );
        if( homog2d_abs(dB1+dB2 - s2.length()) < thr::nullDistance() )
            return detail::Intersect<detail::Inters_1,FPT>( ptInter );
    }
    return detail::Intersect<detail::Inters_1,FPT>(); // no intersection
}

Here is the call graph for this function:

Here is the caller graph for this function:

intersects() [2/5]

template<typename SV , typename FPT >

template<typename FPT2 >

detail::Intersect< detail::Inters_1, FPT > h2d::base::SegVec< SV, FPT >::intersects

(

const Line2d_< FPT2 > &

li1

)

const

Segment/Line intersection.

Algorithm:
We check if the intersection point lies in between the range of the segment, both on x and on y

{
//  HOMOG2D_START;
//  HOMOG2D_LOG( "seg=" << *this << " line=" << li1 );
    detail::Intersect<detail::Inters_1,FPT> out;
    auto li2 = getLine();

    if( li1.isParallelTo( li2 ) ) // if parallel, no intersection
        return out;

    out._ptIntersect = li1 * li2;   // intersection point

    const auto& pi  = out._ptIntersect;
    const auto& pt1 = getPts().first;
    const auto& pt2 = getPts().second;

    auto d1 = pt1.distTo( pi );
    auto d2 = pt2.distTo( pi );
    if( homog2d_abs(d1+d2-length()) < thr::nullDistance() )
        out._doesIntersect = true;

    return out;
}

Here is the call graph for this function:

intersects() [3/5]

template<typename SV , typename FPT >

template<typename FPT2 >

detail::IntersectM< FPT > h2d::base::SegVec< SV, FPT >::intersects

(

const Circle_< FPT2 > &

circle

)

const

Segment/Circle intersection.

For each point of the segment, we need to consider 3 different situations

• point is inside (PI)
• point is outside (PO)
• point is on the edge (PE)

That makes 6 different situations to handle:

• S1: PI-PI => no intersection
• S2: PI-PO => 1 intersection
• S3: PI-PE => 1 intersection
• S4: PO-PO => depends on the support line:
  • S4A: if line does NOT intersects circle, no intersection pts
  • S4B: if line does intersects circle, and intersections point in segment area => 2 intersection pts
  • S4C: if line does intersects circle, and intersections point NOT in segment area => no intersection pts
• S5: PO-PE => 1 intersection
• S6: PE-PE => 2 intersections

{
//  HOMOG2D_START;
    using detail::PtTag;

    auto tag_ptS1 = detail::getPtLabel( _ptS1, circle ); // get status of segment points related to circle (inside/outside/on-edge)
    auto tag_ptS2 = detail::getPtLabel( _ptS2, circle );

    if( tag_ptS1 == PtTag::Inside )
        if( tag_ptS2 == PtTag::Inside )
            return detail::IntersectM<FPT>();

    auto int_lc = getLine().intersects( circle );
    if( !int_lc() )
        return detail::IntersectM<FPT>();

    auto p_pts = int_lc.get();      // get the line intersection points
    const auto& p1 = p_pts.first;
    const auto& p2 = p_pts.second;

    if(                                                            // one inside, the other outside
        ( tag_ptS1 == PtTag::Inside  && tag_ptS2 == PtTag::Outside )
        ||
        ( tag_ptS1 == PtTag::Outside && tag_ptS2 == PtTag::Inside )
    )
    {
        detail::IntersectM<FPT> out;

        auto d1 = _ptS1.distTo( p1 );
        auto d2 = _ptS2.distTo( p1 );
        if( homog2d_abs( d1+d2-length() ) < thr::nullDistance() )
            out.add( p1 );                          // points is inside
        else
            out.add( p2 );
        return out;
    }

    detail::IntersectM<FPT> out;
    if( tag_ptS1 == PtTag::Outside && tag_ptS2 == PtTag::Outside ) // both outside
    {
        auto d1 = _ptS1.distTo( p1 );
        auto d2 = _ptS2.distTo( p1 );
        if( homog2d_abs( d1+d2-length() ) >= thr::nullDistance() )   // if sum of the two distances is higher than length
            return detail::IntersectM<FPT>();

        out.add( p1 );
        out.add( p2 );
        return out;
    }

    if( tag_ptS1 == PtTag::OnEdge )
        out.add( _ptS1 );
    if( tag_ptS2 == PtTag::OnEdge )
        out.add( _ptS2 );

    return out;
}

Here is the call graph for this function:

intersects() [4/5]

template<typename SV, typename FPT>

template<typename FPT2 >

detail::IntersectM<FPT> h2d::base::SegVec< SV, FPT >::intersects ( const FRect_< FPT2 > &  r ) const

inline

Segment/FRect intersection.

    {
        return r.intersects( *this );
    }

Here is the call graph for this function:

intersects() [5/5]

template<typename SV, typename FPT>

template<typename PLT , typename FPT2 >

detail::IntersectM<FPT> h2d::base::SegVec< SV, FPT >::intersects ( const base::PolylineBase< PLT, FPT2 > &  other ) const

inline

Segment/Polyline intersection.

    {
        return other.intersects( *this );
    }

Here is the call graph for this function:

isInside() [1/5]

template<typename SV, typename FPT>

template<typename FPT2 >

bool h2d::base::SegVec< SV, FPT >::isInside ( const Circle_< FPT2 > &  shape ) const

inline

Segment is inside Circle.

    {
        return p_bothPtsAreInside( shape );
    }

Here is the caller graph for this function:

isInside() [2/5]

template<typename SV, typename FPT>

template<typename FPT2 >

bool h2d::base::SegVec< SV, FPT >::isInside ( const FRect_< FPT2 > &  shape ) const

inline

Segment is inside FRect.

    {
        return p_bothPtsAreInside( shape );
    }

isInside() [3/5]

template<typename SV, typename FPT>

template<typename FPT2 >

bool h2d::base::SegVec< SV, FPT >::isInside ( const Ellipse_< FPT2 > &  shape ) const

inline

Segment is inside Ellipse.

    {
        return p_bothPtsAreInside( shape );
    }

isInside() [4/5]

template<typename SV, typename FPT>

template<typename FPT2 >

constexpr bool h2d::base::SegVec< SV, FPT >::isInside ( const OPolyline_< FPT2 > &  ) const

inline

Segment is inside OPolyline_.

    {
        return false;
    }

isInside() [5/5]

template<typename SV, typename FPT>

template<typename FPT2 >

bool h2d::base::SegVec< SV, FPT >::isInside ( const CPolyline_< FPT2 > &  cpoly ) const

inline

Segment is inside CPolyline_.

Requires both points inside AND no intersections

    {
        if( !p_bothPtsAreInside( cpoly ) )
            return false;

        for( auto poly_seg: cpoly.getSegs() )
            if( poly_seg.intersects( *this )() )
                return false;
        return true;
    }

Here is the call graph for this function:

isParallelTo()

template<typename SV, typename FPT>

template<typename T >

constexpr bool h2d::base::SegVec< SV, FPT >::isParallelTo ( const T &  other ) const

inline

    {
        static_assert(
            std::is_same<T,SegVec<SV,FPT>>::value ||
            std::is_same<T,Line2d_<FPT>>::value,
            "type needs to be a segment, a vector, or a line" );
        return getLine().isParallelTo( other );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

length()

template<typename SV, typename FPT>

HOMOG2D_INUMTYPE h2d::base::SegVec< SV, FPT >::length ( ) const

inlinevirtual

Get segment length.

Implements h2d::rtp::Root.

    {
        return _ptS1.distTo( _ptS2 );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

moveTo() [1/2]

template<typename SV, typename FPT>

template<typename TX , typename TY >

void h2d::base::SegVec< SV, FPT >::moveTo ( TX  x, TY  y  )

inline

Move Segment to other location.

    {
        HOMOG2D_CHECK_IS_NUMBER( TX );
        HOMOG2D_CHECK_IS_NUMBER( TY );
        moveTo( Point2d_<FPT>(x,y) );
    }

Here is the call graph for this function:

moveTo() [2/2]

template<typename SV, typename FPT>

template<typename T1 >

void h2d::base::SegVec< SV, FPT >::moveTo ( const Point2d_< T1 > &  pt )

inline

Move Segment to other location, given by pt.

    {
        auto w = _ptS2.getX() - _ptS1.getX();
        auto h = _ptS2.getY() - _ptS1.getY();
        _ptS1 = pt;
        _ptS2.set( _ptS1.getX() + w, _ptS1.getY() + h );
    }

Here is the call graph for this function:

operator!=()

template<typename SV, typename FPT>

bool h2d::base::SegVec< SV, FPT >::operator!= ( const SegVec< SV, FPT > &  s2 ) const

inline

    {
        return !(*this == s2);
    }

operator-()

template<typename SV, typename FPT>

SegVec<SV,FPT> h2d::base::SegVec< SV, FPT >::operator- ( )

inline

Reverse oriented segment.

    {
        static_assert( !std::is_same_v<SV,typ::IsSegment>, "cannot reverse non-oriented segment" );
        std::swap( _ptS1, _ptS2 );
        return *this;
    }

operator<()

template<typename SV, typename FPT>

bool h2d::base::SegVec< SV, FPT >::operator< ( const SegVec< SV, FPT > &  other ) const

inline

    {
        return _ptS1 < other._ptS1;
    }

Here is the call graph for this function:

operator==()

template<typename SV, typename FPT>

bool h2d::base::SegVec< SV, FPT >::operator== ( const SegVec< SV, FPT > &  s2 ) const

inline

    {
        if( _ptS1 != s2._ptS1 )
            return false;
        if( _ptS2 != s2._ptS2 )
            return false;
        return true;
    }

set() [1/3]

template<typename SV, typename FPT>

template<typename FP1 , typename FP2 >

void h2d::base::SegVec< SV, FPT >::set ( const Point2d_< FP1 > &  p1, const Point2d_< FP2 > &  p2  )

inline

Setter.

    {
#ifndef HOMOG2D_NOCHECKS
        if( p1 == p2 )
            HOMOG2D_THROW_ERROR_1( "cannot define a segment with two identical points" << p1 << " and " << p2 );
#endif
        _ptS1 = p1;
        _ptS2 = p2;
        if constexpr( std::is_same_v<SV,typ::IsSegment> )
            priv::fix_order( _ptS1, _ptS2 );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

set() [2/3]

template<typename SV, typename FPT>

template<typename FP1 , typename FP2 >

void h2d::base::SegVec< SV, FPT >::set ( const PointPair2_< FP1, FP2 > &  ppts )

inline

Setter from a std::pair.

    {
        set( ppts.first, ppts.second );
    }

set() [3/3]

template<typename SV, typename FPT>

template<typename FP1 , typename FP2 , typename FP3 , typename FP4 >

void h2d::base::SegVec< SV, FPT >::set ( FP1  x1, FP2  y1, FP3  x2, FP4  y2  )

inline

Setter from 4 raw point coordinates.

    {
        HOMOG2D_CHECK_IS_NUMBER(FP1);
        HOMOG2D_CHECK_IS_NUMBER(FP2);
        HOMOG2D_CHECK_IS_NUMBER(FP3);
        HOMOG2D_CHECK_IS_NUMBER(FP4);
        set( Point2d_<FPT>(x1,y1), Point2d_<FPT>(x2,y2) );
    }

size()

template<typename SV, typename FPT>

constexpr size_t h2d::base::SegVec< SV, FPT >::size ( ) const

inlinevirtual

Returns 2.

Implements h2d::rtp::Root.

    {
        return 2;
    }

split() [1/3]

template<typename SV , typename FPT >

std::pair< SegVec< SV, FPT >, SegVec< SV, FPT > > h2d::base::SegVec< SV, FPT >::split

(

)

const

Returns a pair of segments/vectors split by the middle.

{
    auto pt_mid = getCenter();
    return std::make_pair(
        SegVec<SV,FPT>( _ptS1,  pt_mid ),
        SegVec<SV,FPT>( pt_mid, _ptS2 )
    );
}

Here is the call graph for this function:

Here is the caller graph for this function:

split() [2/3]

template<typename SV, typename FPT>

template<typename T >

std::pair<SegVec<typ::IsOSeg,FPT>,SegVec<typ::IsOSeg,FPT> > h2d::base::SegVec< SV, FPT >::split

(

T

dist

)

const

split() [3/3]

template<typename SV, typename FPT>

template<typename T >

std::pair<OSegment_<FPT>,OSegment_<FPT> > h2d::base::SegVec< SV, FPT >::split

(

T

dist

)

const

Returns a pair of segments/vectors split by point at arbitrary distance.

Note

: distance value must be >0 and less than segment length

{
    static_assert( std::is_same_v<SV,typ::IsOSeg>, "cannot use this on non-oriented segments" );
    HOMOG2D_CHECK_IS_NUMBER(T);
#ifndef HOMOG2D_NOCHECKS
    if( dist <= 0 )
        HOMOG2D_THROW_ERROR_1( "distance value must be >=0, current value=" << dist );
    if( dist >= length() )
        HOMOG2D_THROW_ERROR_1( "distance value must less than length, current value="
            << dist << " length=" << length() );
#endif

    auto pt = getPointAt(dist);
    return std::make_pair(
        SegVec<SV,FPT>( _ptS1, pt ),
        SegVec<SV,FPT>( pt, _ptS2 )
    );
}

Here is the call graph for this function:

translate() [1/2]

template<typename SV, typename FPT>

template<typename T1 , typename T2 >

void h2d::base::SegVec< SV, FPT >::translate ( T1  dx, T2  dy  )

inline

Translate Segment.

    {
        HOMOG2D_CHECK_IS_NUMBER( T1 );
        HOMOG2D_CHECK_IS_NUMBER( T2 );
        _ptS1.translate( dx, dy );
        _ptS2.translate( dx, dy );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

translate() [2/2]

template<typename SV, typename FPT>

template<typename T1 , typename T2 >

void h2d::base::SegVec< SV, FPT >::translate ( const std::pair< T1, T2 > &  pa )

inline

Translate Segment, using pair of values.

    {
        this->translate( pa.first, pa.second );
    }

Here is the call graph for this function:

type()

template<typename SV, typename FPT>

Type h2d::base::SegVec< SV, FPT >::type ( ) const

inlinevirtual

Todo:

20250127: if this works, then generalize to all the other base type() member functions

Implements h2d::rtp::Root.

    {
        if constexpr( std::is_same_v<SV,typ::IsSegment> )
            return Type::Segment;
        else
            return Type::OSegment;
    }

Friends And Related Function Documentation

operator<<

template<typename SV, typename FPT>

template<typename U , typename V >

std::ostream& operator<< ( std::ostream &  , const SegVec< U, V > &    )

friend

SegVec

template<typename SV, typename FPT>

template<typename T1 , typename T2 >

friend class SegVec

friend

---

The documentation for this class was generated from the following file:

• homog2d.hpp