h2d::base::PolylineBase< PLT, FPT > Class Template Reference

Polyline, will be instanciated either as OPolyline_ (open polyline) or CPolyline_. More...

#include <homog2d.hpp>

Inheritance diagram for h2d::base::PolylineBase< PLT, FPT >:

Collaboration diagram for h2d::base::PolylineBase< PLT, FPT >:

Public Types
using	FType = FPT
using	SType = std::conditional< std::is_same_v< PLT, typ::IsClosed >, typ::T_CPol, typ::T_OPol >

Public Member Functions
void	draw (img::Image< img::SvgImage > &, img::DrawParams dp=img::DrawParams()) const
	Draw Polyline (SVG implementation) More...
void	draw (img::Image< cv::Mat > &, img::DrawParams dp=img::DrawParams()) const
	Draw PolylineBase (Opencv implementation) More...
std::vector< Line2d_< HOMOG2D_INUMTYPE > >	getBisectorLines () const
template<typename T >
PolylineBase< typ::IsClosed, FPT >	getOffsetPoly (T value, OffsetPolyParams p=OffsetPolyParams{}) const
	Return an "offsetted" closed polyline, requires simple polygon (CPolyline AND no crossings) as input. More...
template<typename T , typename std::enable_if< trait::IsShape< T >::value, T >::type * = nullptr>
detail::IntersectM< FPT >	intersects (const T &other) const
	Polyline intersection with Line, Segment, FRect, Circle. More...
template<typename T , typename std::enable_if<(trait::HasArea< T >::value &&!trait::PolIsClosed< T >::value), T >::type * = nullptr>
bool	isInside (const T &prim) const
	Polyline isInside other primitive. More...
template<typename T , typename std::enable_if< trait::PolIsClosed< T >::value, T >::type * = nullptr>
bool	isInside (const T &cpol) const
	Polyline isInside other CPolyline. More...
Type	type () const
Constructors
	PolylineBase ()=default
	Default constructor. More...
template<typename FPT2 >
	PolylineBase (const FRect_< FPT2 > &rect)
	Constructor from FRect. Enabled for "closed" type, disabled for "open" type. More...
template<typename FPT2 >
	PolylineBase (const Segment_< FPT2 > &seg)
template<typename T , typename std::enable_if< trait::IsContainer< T >::value, T >::type * = nullptr>
	PolylineBase (const T &vec)
	Constructor from a vector of points. More...
template<typename FPT2 , typename T >
	PolylineBase (FPT2 rad, T n)
	Constructor that builds a regular convex polygon of n points at a distance rad, centered at (0,0). More...
template<typename FPT2 >
constexpr	PolylineBase (const CPolyline_< FPT2 > &other)
	Copy-Constructor from Closed Polyline. More...
template<typename FPT2 >
	PolylineBase (const OPolyline_< FPT2 > &other)
	Copy-Constructor from Open Polyline. More...
template<typename BPT , bool CLKW, bool CLOSED>
	PolylineBase (const boost::geometry::model::polygon< BPT, CLKW, CLOSED > &bgpol)
	Constructor from a boost geometry polygon, see misc/test_files/bg_test_1.cpp. More...
Attributes access
size_t	size () const
	Returns the number of points. More...
constexpr bool	isClosed () const
HOMOG2D_INUMTYPE	length () const
	Returns length of Polyline. More...
HOMOG2D_INUMTYPE	area () const
	Returns area of polygon (computed only if necessary) More...
bool	isSimple () const
	Returns true if object is a polygon (closed, and no segment crossing) More...
auto	getBB () const
	Returns Bounding Box of Polyline. More...
LPBase< typ::IsPoint, HOMOG2D_INUMTYPE >	centroid () const
	Compute centroid of polygon. More...
size_t	nbSegs () const
	Returns the number of segments. If "closed",. More...
Point2d_< FPT >	getExtremePoint (CardDir) const
	Get Top-most / Bottom-most / Left-most / Right-most point. More...
Point2d_< FPT >	getTmPoint () const
	Return Top-most point of Polyline. More...
Point2d_< FPT >	getBmPoint () const
	Return Bottom-most point of Polyline. More...
Point2d_< FPT >	getLmPoint () const
	Return Left-most point of Polyline. More...
Point2d_< FPT >	getRmPoint () const
	Return Right-most point of Polyline. More...
bool	isConvex () const
	Returns true if polygon is convex. More...
Modifiers (non-const member functions)
void	clear ()
	Clear all (does not change the "open/close" status). More...
template<typename FPT2 >
void	rotate (Rotate, const Point2d_< FPT2 > &)
	Rotates the polyline by either 90°, 180°, 270° (-90°) at point refpt. More...
void	rotate (Rotate)
	Rotates the polyline by either 90°, 180°, 270° (-90°) at point (0,0) More...
void	minimize ()
	Miminize the PolylineBase: remove all points that lie in the middle of two segments with same angle. More...
template<typename TX , typename TY >
void	translate (TX dx, TY dy)
	Translate Polyline using dx, dy. More...
template<typename T1 , typename T2 >
void	translate (const std::pair< T1, T2 > &ppt)
	Translate Polyline, using a pair of numerical values. More...
template<typename TX , typename TY >
void	moveTo (TX x, TY y)
	Move Polyline to new origin. More...
template<typename T1 >
void	moveTo (const Point2d_< T1 > &new_org)
	Move Polyline to new origin, given by new_org. More...
template<typename CONT , typename std::enable_if< trait::IsContainer< CONT >::value, CONT >::type * = nullptr>
void	set (const CONT &vec)
	Set from vector/array/list of points (discards previous points) More...
template<typename FPT1 , typename FPT2 , typename FPT3 >
void	setParallelogram (const Point2d_< FPT1 > &pt1, const Point2d_< FPT2 > &pt2, const Point2d_< FPT3 > &pt3)
	Build a parallelogram (4 points) from 3 points. More...
template<typename FPT2 >
void	set (const FRect_< FPT2 > &rect)
	Set from FRect. More...
template<typename FPT2 , typename T >
std::pair< HOMOG2D_INUMTYPE, HOMOG2D_INUMTYPE >	set (FPT2 rad, T n)
	Build RCP (Regular Convex Polygon), and return distance between consecutive points. More...
Operators
template<typename PLT2 , typename FPT2 >
bool	operator== (const PolylineBase< PLT2, FPT2 > &other) const
template<typename PLT2 , typename FPT2 >
bool	operator!= (const PolylineBase< PLT2, FPT2 > &other) const
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 T1 , typename T2 >
std::ostream &	h2d::base::operator<< (std::ostream &, const h2d::base::PolylineBase< T1, T2 > &)
template<typename T1 >
class	h2d::Ellipse_
template<typename FPT1 , typename FPT2 >
CPolyline_< FPT1 >	h2d::operator* (const h2d::Homogr_< FPT2 > &, const h2d::FRect_< FPT1 > &)
template<typename FPT1 , typename FPT2 , typename PLT2 >
auto	h2d::operator* (const Homogr_< FPT2 > &, const base::PolylineBase< PLT2, FPT1 > &) -> base::PolylineBase< PLT2, FPT1 >
template<typename T1 , typename T2 >
class	PolylineBase

Data access
std::vector< Point2d_< FPT > > &	getPts ()
	Returns the points (reference) More...
const std::vector< Point2d_< FPT > > &	getPts () const
	Returns the points (const reference) More...
std::vector< OSegment_< FPT > >	getOSegs () const
	Returns (as a copy) the oriented segments of the polyline. More...
std::vector< Segment_< FPT > >	getSegs () const
	Returns (as a copy) the segments of the polyline. More...
Point2d_< FPT >	getPoint (size_t idx) const
	Returns one point of the polyline. More...
OSegment_< FPT >	getOSegment (size_t idx) const
	Returns one oriented segment of the polyline. More...
Segment_< FPT >	getSegment (size_t idx) const
	Returns one segment of the polyline. More...
CPolyline_< FPT >	convexHull () const
	Return convex hull (member function implementation) More...

Detailed Description

template<typename PLT, typename FPT>
class h2d::base::PolylineBase< PLT, FPT >

Polyline, will be instanciated either as OPolyline_ (open polyline) or CPolyline_.

Warning

When closed, in order to be able to compare two objects describing the same structure but potentially in different order, the comparison operator will proceed a sorting.
The consequence is that when adding points, if you have done a comparison before, you might not add point after the one you thought!

template args:

• PLT: PolyLine Type: typ::IsClosed or typ::IsOpen
• FPT: Floating Point Type

Member Typedef Documentation

FType

template<typename PLT, typename FPT>

using h2d::base::PolylineBase< PLT, FPT >::FType = FPT

SType

template<typename PLT, typename FPT>

using h2d::base::PolylineBase< PLT, FPT >::SType = std::conditional<std::is_same_v<PLT,typ::IsClosed>,typ::T_CPol,typ::T_OPol>

Constructor & Destructor Documentation

PolylineBase() [1/8]

template<typename PLT, typename FPT>

h2d::base::PolylineBase< PLT, FPT >::PolylineBase ( )

default

Default constructor.

PolylineBase() [2/8]

template<typename PLT, typename FPT>

template<typename FPT2 >

h2d::base::PolylineBase< PLT, FPT >::PolylineBase ( const FRect_< FPT2 > &  rect )

inline

Constructor from FRect. Enabled for "closed" type, disabled for "open" type.

    {
        static_assert( std::is_same_v<PLT,typ::IsClosed>, "cannot build an OPolyline object from a FRect");
        for( const auto& pt: rect.get4Pts() )
            _plinevec.push_back( pt );
    }

PolylineBase() [3/8]

template<typename PLT, typename FPT>

template<typename FPT2 >

h2d::base::PolylineBase< PLT, FPT >::PolylineBase ( const Segment_< FPT2 > &  seg )

inline

    {
        const auto& ppts = seg.getPts();
        p_addPoint( ppts.first );
        p_addPoint( ppts.second );
    }

PolylineBase() [4/8]

template<typename PLT, typename FPT>

template<typename T , typename std::enable_if< trait::IsContainer< T >::value, T >::type * = nullptr>

h2d::base::PolylineBase< PLT, FPT >::PolylineBase ( const T &  vec )

inline

Constructor from a vector of points.

    {
        set( vec );
    }

PolylineBase() [5/8]

template<typename PLT, typename FPT>

template<typename FPT2 , typename T >

h2d::base::PolylineBase< PLT, FPT >::PolylineBase ( FPT2  rad, T  n  )

inline

Constructor that builds a regular convex polygon of n points at a distance rad, centered at (0,0).

    {
        set( rad, n );
    }

PolylineBase() [6/8]

template<typename PLT, typename FPT>

template<typename FPT2 >

constexpr h2d::base::PolylineBase< PLT, FPT >::PolylineBase ( const CPolyline_< FPT2 > &  other )

inline

Copy-Constructor from Closed Polyline.

    {
        static_assert(
            !(std::is_same<PLT,typ::IsOpen>::value),
            "Error, cannot build an Open Polyline from a closed one"
        );
        set( other._plinevec );
    }

PolylineBase() [7/8]

template<typename PLT, typename FPT>

template<typename FPT2 >

h2d::base::PolylineBase< PLT, FPT >::PolylineBase ( const OPolyline_< FPT2 > &  other )

inline

Copy-Constructor from Open Polyline.

    {
        set( other._plinevec );
    }

PolylineBase() [8/8]

template<typename PLT, typename FPT>

template<typename BPT , bool CLKW, bool CLOSED>

h2d::base::PolylineBase< PLT, FPT >::PolylineBase ( const boost::geometry::model::polygon< BPT, CLKW, CLOSED > &  bgpol )

inline

Constructor from a boost geometry polygon, see misc/test_files/bg_test_1.cpp.

Note

Only imports the "outer" envelope, homog2d does not handle polygons with holes

Requirements: the Boost polygon must have 2-cartesian coordinates points, either bg::model::point or bg::model::d2::point_xy but the underlying numerical type is free.

Note

At present, the 3th template parameter (bool) (Closed or Open) is ignored, because it is unclear how this relates to the actual fact that last point is equal to first point.

Todo:

20230216: add some checking that the type BPT needs to fit certain requirements (must have 2-dimensions, and use cartesian coordinates). Maybe we should add some Sfinae to check this.

Parameters

bgpol

Boost Point Type (either bg::model::point or bg::model::d2::point_xy) this one is ignored here true: closed, false: open input boost geometry polygon

    {
        const auto& outer = bgpol.outer();
        bool isClosed = false;
        auto ptf = outer.front();
        auto ptb = outer.back();
        Point2d_<HOMOG2D_INUMTYPE> pt_front( boost::geometry::get<0>(ptf), boost::geometry::get<1>(ptf) );
        Point2d_<HOMOG2D_INUMTYPE> pt_back(  boost::geometry::get<0>(ptb), boost::geometry::get<1>(ptb) );
/*
this should work !!! (but doesn't...)
        Point2d_<HOMOG2D_INUMTYPE> pt_front( outer.front() );
        Point2d_<HOMOG2D_INUMTYPE> pt_back(  outer.back() );
*/
        if( pt_front == pt_back ) // means it's closed
            isClosed = true;

        if( isClosed && std::is_same_v<PLT,typ::IsOpen> ) // cannot build an open polyline from a closed one
            HOMOG2D_THROW_ERROR_1( "unable to convert a closed boost::polygon into an OPolyline" );

        _plinevec.reserve( outer.size() - isClosed );
        for( auto it=outer.begin(); it!=outer.end()-isClosed; it++ )
        {
            const auto& bgpt = *it;
            _plinevec.emplace_back(
                Point2d_<FPT>( boost::geometry::get<0>(bgpt), boost::geometry::get<1>(bgpt) )
            );
        }
    }

Member Function Documentation

area()

template<typename PLT , typename FPT >

HOMOG2D_INUMTYPE h2d::base::PolylineBase< PLT, FPT >::area ( ) const

virtual

Returns area of polygon (computed only if necessary)

Implements h2d::rtp::Root.

{
    if( !isSimple() )  // implies that is both closed and has no intersections
        return 0.;

    if( _attribs._area.isBad() )
        _attribs._area.set( homog2d_abs( p_ComputeSignedArea() ) );
    return _attribs._area.value();
}

Here is the caller graph for this function:

centroid()

template<typename PLT, typename FPT>

Point2d_< HOMOG2D_INUMTYPE > h2d::base::base::PolylineBase::centroid

(

)

const

Compute centroid of polygon.

ref: https://en.wikipedia.org/wiki/Centroid#Of_a_polygon

Warning

: centroid CAN be outside of polygon!

{
    if( !isSimple() )
        HOMOG2D_THROW_ERROR_1( "unable, Polyline object is not simple" );

    if( _attribs._centroid.isBad() )
    {
        HOMOG2D_INUMTYPE cx = 0.;
        HOMOG2D_INUMTYPE cy = 0.;
        for( size_t i=0; i<size(); i++ )
        {
            auto j = (i == size()-1 ? 0 : i+1);
            const auto& pt1 = _plinevec[i];
            const auto& pt2 = _plinevec[j];
            auto x1 = pt1.getX();
            auto x2 = pt2.getX();
            auto y1 = pt1.getY();
            auto y2 = pt2.getY();

            auto prod = x1*y2 - x2*y1;
            cx += (x1+x2) * prod;
            cy += (y1+y2) * prod;
        }
        auto signedArea = p_ComputeSignedArea();
        cx /= (6. * signedArea);
        cy /= (6. * signedArea);

        auto c = Point2d_<HOMOG2D_INUMTYPE>( cx, cy );
        _attribs._centroid.set( c );
    }
    return _attribs._centroid.value();
}

Here is the caller graph for this function:

clear()

template<typename PLT, typename FPT>

void h2d::base::PolylineBase< PLT, FPT >::clear ( )

inline

Clear all (does not change the "open/close" status).

    {
        _plinevec.clear();
        _plIsNormalized=false;
        _attribs.setBad();
    }

convexHull()

template<typename CT , typename FPT >

CPolyline_< FPT > h2d::base::PolylineBase< CT, FPT >::convexHull

(

)

const

Return convex hull (member function implementation)

{
    return h2d::convexHull( *this );
}

Here is the caller graph for this function:

draw() [1/2]

template<typename PLT , typename FPT >

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

virtual

Draw Polyline (SVG implementation)

Note

To show the points index, we don't use the svg "marker-start/marker-mid/marker-end" syntax so that the dots always have the same color as the segments

Todo:

20240215 Why don't we use the drawText() function ?

Implements h2d::rtp::Root.

{
    if( size() < 2 ) // nothing to draw
        return;

    if( dp._dpValues._showIndex || dp._dpValues._showPoints )
        im.getReal()._svgString << "<g>\n";

    im.getReal()._svgString << '<' << (isClosed() ? "polygon" : "polyline")
        << " stroke=\""
        << dp.getSvgRgbColor()
        << "\" stroke-width=\"" << dp._dpValues._lineThickness << "\" ";
    if( !dp.holdsFill() )
        im.getReal()._svgString << "fill=\"none\" ";
    im.getReal()._svgString << dp.getAttrString()
        << "points=\"";
    for( const auto& pt: getPts() )
        im.getReal()._svgString << pt.getX() << ',' << pt.getY() << ' ';
    im.getReal()._svgString << "\"/>\n";

    if( dp._dpValues._showIndex )
    {
        im.getReal()._svgString << "<g>\n";
        for( size_t i=0; i<size(); i++ )
        {
            auto pt = getPoint(i);
            im.getReal()._svgString << "<text x=\""
                << (int)pt.getX()
                << "\" y=\""
                << (int)pt.getY()
                << "\" class=\"txt1\">"
                << i
                << "</text>\n";
        }
        im.getReal()._svgString << "</g>\n";
    }

    if( dp._dpValues._showPoints )
    {
        im.getReal()._svgString << "<g>\n";
        for( size_t i=0; i<size(); i++ )
            getPoint(i).draw( im, dp );
        im.getReal()._svgString << "</g>\n";
    }

    if( dp._dpValues._showAngles )
    {
        auto osegs = getOSegs();
//          std::cout << "osegs size=" << osegs.size() << "\n";

        const auto& pts = getPts();
        for( size_t i=0; i<osegs.size()-1; i++ )
        {
            auto seg1 = osegs[i];
            auto seg2 = osegs[i+1];
            auto angle = getAngle( seg1, seg2 );
//          std::cout << "angle " << i << "=" << angle*180/3.1415 << "\n";
            drawText( im, std::to_string(angle * 180./M_PI), pts[i+1] );
        }
    }

    if( dp._dpValues._showIndex || dp._dpValues._showPoints )
        im.getReal()._svgString << "</g>\n";
}

Here is the caller graph for this function:

draw() [2/2]

template<typename PLT , typename FPT >

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

virtual

Draw PolylineBase (Opencv implementation)

Implements h2d::rtp::Root.

{
    if( size() < 2 ) // nothing to draw
        return;

    for( size_t i=0; i<nbSegs(); i++ )
        getSegment(i).draw( im, dp );

    if( dp._dpValues._showPoints )
    {
        auto newPointStyle = dp._dpValues.nextPointStyle();
        getPoint(0).draw( im, dp.setColor(10,10,10).setPointStyle( newPointStyle ) );
    }

    if( dp._dpValues._showIndex )
        for( size_t i=0; i<size(); i++ )
        {
            auto pt = getPoint(i);
            cv::putText(
                im.getReal(),
                std::to_string(i),
                pt.getCvPti(),
                0,
                0.6,
                cv::Scalar( 20,20,20 ),
                2
            );
        }

    if( dp._dpValues._showAngles )
    {
        auto osegs = getOSegs();
//          std::cout << "osegs size=" << osegs.size() << "\n";

        const auto& pts = getPts();
        for( size_t i=0; i<osegs.size()-1; i++ )
        {
            auto seg1 = osegs[i];
            auto seg2 = osegs[i+1];
            auto angle = getAngle( seg1, seg2 );
//          std::cout << "angle " << i << "=" << angle*180/3.1415 << "\n";
            drawText( im, std::to_string(angle * 180./M_PI), pts[i+1] );
        }
        if( isClosed() )
        {
            auto seg1 = osegs.back();
            auto seg2 = osegs.front();
            auto angle = getAngle( seg1, seg2 );
//          std::cout << "final angle " << "=" << angle*180/3.1415 << "\n";
            drawText( im, std::to_string(angle * 180./M_PI), pts[0] );
        }
    }
}

getBB()

template<typename PLT, typename FPT>

auto h2d::base::PolylineBase< PLT, FPT >::getBB ( ) const

inline

Returns Bounding Box of Polyline.

    {
        HOMOG2D_START;
#ifndef HOMOG2D_NOCHECKS
        if( size() < 2 )
            HOMOG2D_THROW_ERROR_1( "cannot compute bounding box of empty Polyline" );
#endif
        auto ppts = priv::getBB_Points( getPts() );
#ifndef HOMOG2D_NOCHECKS
        if( shareCommonCoord( ppts.first, ppts.second ) )
            HOMOG2D_THROW_ERROR_1( "unable, points share common coordinate" );
#endif
        return FRect_<HOMOG2D_INUMTYPE>( ppts );
    }

Here is the caller graph for this function:

getBisectorLines()

template<typename PLT, typename FPT>

std::vector<Line2d_<HOMOG2D_INUMTYPE> > h2d::base::PolylineBase< PLT, FPT >::getBisectorLines ( ) const

inline

    {
         return h2d::getBisectorLines( *this );
    }

getBmPoint()

template<typename PLT , typename FPT >

Point2d_< FPT > h2d::base::PolylineBase< PLT, FPT >::getBmPoint

(

)

const

Return Bottom-most point of Polyline.

{
    return h2d::getBmPoint( *this );
}

Here is the caller graph for this function:

getExtremePoint()

template<typename PLT , typename FPT >

Point2d_< FPT > h2d::base::PolylineBase< PLT, FPT >::getExtremePoint

(

CardDir

dir

)

const

Get Top-most / Bottom-most / Left-most / Right-most point.

{
    return getExtremePoint( dir, *this );
}

getLmPoint()

template<typename PLT , typename FPT >

Point2d_< FPT > h2d::base::PolylineBase< PLT, FPT >::getLmPoint

(

)

const

Return Left-most point of Polyline.

{
    return h2d::getLmPoint( *this );
}

Here is the caller graph for this function:

getOffsetPoly()

template<typename PLT , typename FPT >

template<typename T >

PolylineBase< typ::IsClosed, FPT > h2d::base::PolylineBase< PLT, FPT >::getOffsetPoly	(	T	dist,
		OffsetPolyParams	params = OffsetPolyParams{}
	)		const

Return an "offsetted" closed polyline, requires simple polygon (CPolyline AND no crossings) as input.

On failure (for whatever reason), will return an empty CPolyline

• If dist>0, returns the polyline "outside" the source one
• If dist<0, returns the polyline "inside" the source one

{
    HOMOG2D_CHECK_IS_NUMBER(T);
    auto dist0 = (HOMOG2D_INUMTYPE)dist; // casting

    bool valid = true;
    if( homog2d_abs(dist) < thr::nullDistance() )
    {
        HOMOG2D_LOG_WARNING( "Failure, distance value is null, returning empty CPolyline" );
        valid = false;
    }
    if( size()<3 )
    {
        HOMOG2D_LOG_WARNING( "Failure, computing offsetted Polyline requires at least 3 points, returning empty CPolyline" );
        valid = false;
    }
    if( !isSimple() )
    {
        HOMOG2D_LOG_WARNING( "Failure, Polyline is not a polygon, returning empty CPolyline" );
        valid = false;
    }
    if( !valid )
        return PolylineBase<typ::IsClosed,FPT>();

    p_normalizePoly();

    size_t current = 0;
//  bool paraLines = false;

    std::vector<Point2d_<FPT>> v_out;
    auto osegs = getOSegs();
    auto oseg1 = osegs.at(current);
    do
    {
        auto next = (current==size()-1 ? 0 : current+1);

        auto pt1 = getPoint(next);

        auto oseg2 = osegs.at(next);

        auto psegs1 = oseg1.getParallelSegs(homog2d_abs(dist0));
        auto psegs2 = oseg2.getParallelSegs(homog2d_abs(dist0));

        auto pseg1 = &psegs1.first;
        auto pseg2 = &psegs2.first;
        if( dist < 0 )
        {
            pseg1 = &psegs1.second;
            pseg2 = &psegs2.second;
        }

        auto li1 = pseg1->getLine();
        auto li2 = pseg2->getLine();
        if( !areParallel(li1,li2) )
        {
            auto pt_int = li1 * li2;
            if( !params._angleSplit || getAngle(oseg1,oseg2)>0 || dist < 0 )
            {
                v_out.push_back( pt_int );  // add point intersection of the two lines
            }
            else
            {
                auto oseg = OSegment_<HOMOG2D_INUMTYPE>( pt1, pt_int );
                auto dist_cut = std::min( oseg.length(), dist0 );

                auto pt_cut = oseg.getPointAt( dist_cut );
                auto oli = oseg.getLine().getOrthogLine( pt_cut );

                auto pt_cut1 = oli * li1;
                auto pt_cut2 = oli * li2;

                v_out.push_back( pt_cut1 );
                if( pt_cut1 != pt_cut2 )        // so we don't add two identical pts (in case they were computed as such)
                    v_out.push_back( pt_cut2 );
            }
        }
//      else
//          std::cout << "parallel!\n";

        current++;
        oseg1 = oseg2;
    }
    while( current<size() ); //&& !paraLines );

    return PolylineBase<typ::IsClosed,FPT>( v_out );
}

getOSegment()

template<typename PLT, typename FPT>

OSegment_<FPT> h2d::base::PolylineBase< PLT, FPT >::getOSegment ( size_t  idx ) const

inline

Returns one oriented segment of the polyline.

    {
        return impl_getSegment( idx, OSegment_<FPT>() );
    }

Here is the caller graph for this function:

getOSegs()

template<typename PLT, typename FPT>

std::vector<OSegment_<FPT> > h2d::base::PolylineBase< PLT, FPT >::getOSegs ( ) const

inline

Returns (as a copy) the oriented segments of the polyline.

    {
        return priv::p_getSegs( *this, OSegment_<FPT>() );
    }

Here is the caller graph for this function:

getPoint()

template<typename PLT, typename FPT>

Point2d_<FPT> h2d::base::PolylineBase< PLT, FPT >::getPoint ( size_t  idx ) const

inline

Returns one point of the polyline.

    {
#ifndef HOMOG2D_NOCHECKS
        if( idx >= size() )
            HOMOG2D_THROW_ERROR_1( "requesting point " << idx
                << ", only has "  << size()
            );
#endif
        return _plinevec[idx];
    }

Here is the caller graph for this function:

getPts() [1/2]

template<typename PLT, typename FPT>

std::vector<Point2d_<FPT> >& h2d::base::PolylineBase< PLT, FPT >::getPts ( )

inline

Returns the points (reference)

    {
        _attribs.setBad();  // because we send the non-const reference
        _plIsNormalized=false;
        return _plinevec;
    }

Here is the caller graph for this function:

getPts() [2/2]

template<typename PLT, typename FPT>

const std::vector<Point2d_<FPT> >& h2d::base::PolylineBase< PLT, FPT >::getPts ( ) const

inline

Returns the points (const reference)

    {
        return _plinevec;
    }

getRmPoint()

template<typename PLT , typename FPT >

Point2d_< FPT > h2d::base::PolylineBase< PLT, FPT >::getRmPoint

(

)

const

Return Right-most point of Polyline.

{
    return h2d::getRmPoint( *this );
}

Here is the caller graph for this function:

getSegment()

template<typename PLT, typename FPT>

Segment_<FPT> h2d::base::PolylineBase< PLT, FPT >::getSegment ( size_t  idx ) const

inline

Returns one segment of the polyline.

Segment n is the one between point n and point n+1

    {
        return impl_getSegment( idx, Segment_<FPT>() );
    }

getSegs()

template<typename PLT, typename FPT>

std::vector<Segment_<FPT> > h2d::base::PolylineBase< PLT, FPT >::getSegs ( ) const

inline

Returns (as a copy) the segments of the polyline.

    {
        return priv::p_getSegs( *this, Segment_<FPT>() );
    }

Here is the caller graph for this function:

getTmPoint()

template<typename PLT , typename FPT >

Point2d_< FPT > h2d::base::PolylineBase< PLT, FPT >::getTmPoint

(

)

const

Return Top-most point of Polyline.

{
    return h2d::getTmPoint( *this );
}

Here is the caller graph for this function:

intersects()

template<typename PLT, typename FPT>

template<typename T , typename std::enable_if< trait::IsShape< T >::value, T >::type * = nullptr>

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

inline

Polyline intersection with Line, Segment, FRect, Circle.

    {
        detail::IntersectM<FPT> out;
        for( const auto& pseg: getSegs() )
        {
            auto inters = pseg.intersects( other );
            if( inters() )
                out.add( inters.get() );
        }
        return out;
    }

Here is the caller graph for this function:

isClosed()

template<typename PLT, typename FPT>

constexpr bool h2d::base::PolylineBase< PLT, FPT >::isClosed ( ) const

inline

    {
        if constexpr( std::is_same_v<PLT,typ::IsClosed> )
            return true;
        else
            return false;
    }

Here is the caller graph for this function:

isConvex()

template<typename PLT , typename FPT >

bool h2d::base::PolylineBase< PLT, FPT >::isConvex

(

)

const

Returns true if polygon is convex.

This implies that:

• the Polyline is a Polygon
• cross product of consecutive points have same sign (see https://stackoverflow.com/a/1881201/193789 )

Todo:

20221120: as points are homogeneous, the cross product can probably be computed in a different way (quicker? simpler?). Need to check this.

Todo:

20250127: use crossProduct free function with base::SegVec args

{
    if( !isSimple() )
        return false;

    int8_t sign = 0;
    const auto& vpts = getPts();
    if( vpts.size() == 3 )   // 3 pts => always convex
        return true;

    for( size_t i=0; i<vpts.size(); i++ )
    {
        const auto& pt0 = vpts[ i==0?vpts.size()-1:i-1 ];
        const auto& pt1 = vpts[ i ];
        const auto& pt2 = vpts[ i==vpts.size()-1?0:i+1 ];
        auto dx1 = pt1.getX() - pt0.getX();
        auto dy1 = pt1.getY() - pt0.getY();

        auto dx2 = pt2.getX() - pt1.getX();
        auto dy2 = pt2.getY() - pt1.getY();

        auto crossproduct = dx1*dy2 - dy1*dx2;
        if( sign == 0 )                          // initial sign value
            sign = (crossproduct>0 ? +1 : -1);
        else
            if (sign != (crossproduct>0 ? +1 : -1) )
                return false;
    }
    return true;
}

Here is the caller graph for this function:

isInside() [1/2]

template<typename PLT, typename FPT>

template<typename T , typename std::enable_if<(trait::HasArea< T >::value &&!trait::PolIsClosed< T >::value), T >::type * = nullptr>

bool h2d::base::PolylineBase< PLT, FPT >::isInside ( const T &  prim ) const

inline

Polyline isInside other primitive.

Sfinae should resolve for T=Circle,FRect,Ellipse but not for CPolyline

    {
        HOMOG2D_START;
        if( size() == 0 )
            return false;
        for( const auto& pt: getPts() )
            if( !pt.isInside( prim ) )
                return false;
        return true;
    }

Here is the caller graph for this function:

isInside() [2/2]

template<typename PLT, typename FPT>

template<typename T , typename std::enable_if< trait::PolIsClosed< T >::value, T >::type * = nullptr>

bool h2d::base::PolylineBase< PLT, FPT >::isInside ( const T &  cpol ) const

inline

Polyline isInside other CPolyline.

Sfinae should resolve ONLY for CPolyline

    {
        HOMOG2D_START;
        if( size() == 0 )
            return false;
        for( const auto& pt: getPts() )
            if( !pt.isInside( cpol ) )
                return false;
        if( intersects(cpol)() )
            return false;
        return true;
    }

isSimple()

template<typename PLT , typename FPT >

bool h2d::base::PolylineBase< PLT, FPT >::isSimple

(

)

const

Returns true if object is a polygon (closed, and no segment crossing)

{
    if( size()<3 )       // needs at least 3 points to be a polygon
        return false;
    if constexpr( std::is_same_v<PLT,typ::IsOpen> ) // If open, then not a polygon
        return false;
    else                  // If closed, we need to check for crossings
    {
        if( _attribs._isSimplePolyg.isBad() )
        {
            auto nbs = nbSegs();
            size_t i=0;
            bool notDone = true;
            bool hasIntersections = false;
            do
            {
                auto seg1 = getSegment(i);
                auto lastone = i==0?nbs-1:nbs;
                for( auto j=i+2; j<lastone; j++ )
                    if( getSegment(j).intersects(seg1)() )
                    {
                        notDone = false;
                        hasIntersections = true;
                        break;
                    }
                i++;
            }
            while( i<nbs && notDone );
            _attribs._isSimplePolyg.set( !hasIntersections );
        }
        return _attribs._isSimplePolyg.value();
    }
}

Here is the caller graph for this function:

length()

template<typename PLT , typename FPT >

HOMOG2D_INUMTYPE h2d::base::PolylineBase< PLT, FPT >::length ( ) const

virtual

Returns length of Polyline.

Implements h2d::rtp::Root.

{
    if( _attribs._length.isBad() )
    {
        HOMOG2D_INUMTYPE sum = 0.;
        for( const auto& seg: getSegs() )
            sum += static_cast<HOMOG2D_INUMTYPE>( seg.length() );
        _attribs._length.set( sum );
    }
    return _attribs._length.value();
}

Here is the caller graph for this function:

minimize()

template<typename PLT, typename FPT>

void h2d::base::PolylineBase< PLT, FPT >::minimize ( )

inline

Miminize the PolylineBase: remove all points that lie in the middle of two segments with same angle.

For example, if we have the following points ("Open" polyline): (0,0)-(1,0)-(2,0)
This will be replaced by: (0,0)–(2,0)

Note

We cannot use the Segment_::getAngle() function because it returns a value in [0,PI/2], so we would'nt be able to detect a segment going at 180° of the previous one.

Todo:

20230217: implement these:

• https://en.wikipedia.org/wiki/Visvalingam%E2%80%93Whyatt_algorithm
• https://en.wikipedia.org/wiki/Ramer%E2%80%93Douglas%E2%80%93Peucker_algorithm Also use the areCollinear() function

    {
        if( size()<3 )
            return;
        impl_minimizePL( detail::PlHelper<PLT>() );
    }

moveTo() [1/2]

template<typename PLT, typename FPT>

template<typename TX , typename TY >

void h2d::base::PolylineBase< PLT, FPT >::moveTo ( TX  x, TY  y  )

inline

Move Polyline to new origin.

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

moveTo() [2/2]

template<typename PLT, typename FPT>

template<typename T1 >

void h2d::base::PolylineBase< PLT, FPT >::moveTo ( const Point2d_< T1 > &  new_org )

inline

Move Polyline to new origin, given by new_org.

Warning

The polygon origin is NOT its center but the point No 0!

    {
        if( size() == 0 )
            HOMOG2D_THROW_ERROR_1( "Invalid call, Polyline is empty" );
        auto dx = new_org.getX() - getPoint(0).getX();
        auto dy = new_org.getY() - getPoint(0).getY();
        for( auto& pt: _plinevec )
            pt.translate( dx, dy );
    }

nbSegs()

template<typename PLT, typename FPT>

size_t h2d::base::PolylineBase< PLT, FPT >::nbSegs ( ) const

inline

Returns the number of segments. If "closed",.

the last segment (going from last to first point) is counted

    {
        if( size() < 2 )
            return 0;
        if constexpr( std::is_same_v<PLT,typ::IsClosed> )
            return size();
        else
            return size() - 1;
    }

Here is the caller graph for this function:

operator!=()

template<typename PLT, typename FPT>

template<typename PLT2 , typename FPT2 >

bool h2d::base::PolylineBase< PLT, FPT >::operator!= ( const PolylineBase< PLT2, FPT2 > &  other ) const

inline

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

operator==()

template<typename PLT, typename FPT>

template<typename PLT2 , typename FPT2 >

bool h2d::base::PolylineBase< PLT, FPT >::operator== ( const PolylineBase< PLT2, FPT2 > &  other ) const

inline

    {
        if constexpr( std::is_same_v<PLT,PLT2> )
        {
            if( size() != other.size() )          // for quick exit
                return false;

            p_normalizePoly();
            other.p_normalizePoly();

            auto it = other._plinevec.begin();
            for( const auto& elem: _plinevec )
                if( *it++ != elem )
                    return false;
            return true;
        }
        else
            return false;
    }

rotate() [1/2]

template<typename PLT , typename FPT >

template<typename FPT2 >

void h2d::base::PolylineBase< PLT, FPT >::rotate	(	Rotate	rot,
		const Point2d_< FPT2 > &	refpt
	)

Rotates the polyline by either 90°, 180°, 270° (-90°) at point refpt.

For an arbitrary angle alpha (rad.), you can write:

auto poly2 = Homogr(alpha) * poly;

See also

PolylineBase<PLT,FPT>::rotate( Rotate )

{
    translate( -refpt.getX(), -refpt.getY() );
    this->rotate( rot );
    translate( refpt.getX(), refpt.getY() );
}

Here is the caller graph for this function:

rotate() [2/2]

template<typename PLT , typename FPT >

void h2d::base::PolylineBase< PLT, FPT >::rotate

(

Rotate

rot

)

Rotates the polyline by either 90°, 180°, 270° (-90°) at point (0,0)

For an arbitrary angle alpha (rad.), you can write:

auto poly2 = Homogr(alpha) * poly;

See also

PolylineBase<PLT,FPT>::rotate( Rotate, const Point2d_<FPT2>& )

{
    switch( rot )
    {
        case Rotate::CCW:
            for( auto& pt: getPts() )
                pt.set( -pt.getY(), +pt.getX() );
        break;
        case Rotate::CW:
            for( auto& pt: getPts() )
                pt.set( +pt.getY(), -pt.getX() );
        break;
        case Rotate::Full:
            for( auto& pt: getPts() )
                pt.set( -pt.getX(), -pt.getY() );
        break;
        case Rotate::VMirror:
            for( auto& pt: getPts() )
                pt.set( -pt.getX(), pt.getY() );
        break;
        case Rotate::HMirror:
            for( auto& pt: getPts() )
                pt.set( pt.getX(), -pt.getY() );
        break;

        default: assert(0);
    }
}

set() [1/3]

template<typename PLT, typename FPT>

template<typename CONT , typename std::enable_if< trait::IsContainer< CONT >::value, CONT >::type * = nullptr>

void h2d::base::PolylineBase< PLT, FPT >::set ( const CONT &  vec )

inline

Set from vector/array/list of points (discards previous points)

• nb of elements must be 0 or 2 or more

    {
#ifndef HOMOG2D_NOCHECKS
        if( vec.size() == 1 )
            HOMOG2D_THROW_ERROR_1( "Invalid: number of points must be 0, 2 or more" );
        if( vec.size() > 1 )
            p_checkInputData( vec );
#endif
        _attribs.setBad();
        _plIsNormalized=false;
        _plinevec.resize( vec.size() );
        auto it = std::begin( _plinevec );
        for( const auto& pt: vec )   // copying one by one will allow
            *it++ = pt;              //  type conversions (std::copy implies same FP type)
    }

Here is the caller graph for this function:

set() [2/3]

template<typename PLT, typename FPT>

template<typename FPT2 >

void h2d::base::PolylineBase< PLT, FPT >::set ( const FRect_< FPT2 > &  rect )

inline

Set from FRect.

    {
        static_assert( std::is_same_v<PLT,typ::IsClosed>, "Invalid: cannot set a OPolyline from a FRect" );

        CPolyline_<FPT> tmp(rect);
        std::swap( *this, tmp );
    }

set() [3/3]

template<typename PLT , typename FPT >

template<typename FPT2 , typename T >

std::pair< HOMOG2D_INUMTYPE, HOMOG2D_INUMTYPE > h2d::base::PolylineBase< PLT, FPT >::set	(	FPT2	rad,
		T	ni
	)

Build RCP (Regular Convex Polygon), and return distance between consecutive points.

Build a Regular Convex Polygon of radius rad with n points, centered at (0,0)

Returns

segment distance, inscribed circle radius

Parameters

rad	Radius
ni	Nb of points

{
    static_assert(
        std::is_integral<T>::value,
        "2nd argument type must be integral type"
    );
    static_assert(
        std::is_same_v<PLT,typ::IsClosed>,
        "Cannot build a RCP as open polyline"
    );

    if( ni < 3 )
        HOMOG2D_THROW_ERROR_1( "unable, nb of points must be > 2" );
    if( rad <= 0  )
        HOMOG2D_THROW_ERROR_1( "unable, radius must be > 0" );

    size_t n(ni);
    std::vector<Point2d_<HOMOG2D_INUMTYPE>> v_pts(n);
    auto it = std::begin( v_pts );
    auto angle0 = (HOMOG2D_INUMTYPE)2. * M_PI / n;

    Point2d_<HOMOG2D_INUMTYPE> pt0( rad, 0. ); // initial point
    HOMOG2D_INUMTYPE radius = 0.;

    for( size_t i=0; i<n; i++ )
    {
        auto angle = angle0 * i;
        auto x = homog2d_cos( angle );
        auto y = homog2d_sin( angle );

        if( i == 1 )    // compute radius of inscribed circle
        {
            auto pt1 = Point2d_<HOMOG2D_INUMTYPE>( x * rad, y * rad );
            Segment_<HOMOG2D_INUMTYPE> seg( pt0, pt1 );
            Line2d_<HOMOG2D_INUMTYPE> li( seg.getCenter() );     // line passing through (0,0) and middle point of segment
            auto inters_pt = seg.intersects( li ) ;              // intersection point
            assert( inters_pt() );
            radius = Point2d_<HOMOG2D_INUMTYPE>(0,0).distTo( inters_pt.get() );
        }

        *it = Point2d_<HOMOG2D_INUMTYPE>( x * rad, y * rad );
        it++;
    }
    *this = PolylineBase<PLT,FPT>( v_pts );

    return std::make_pair(
        getPoint(0).distTo( getPoint(1) ),
        radius
    );
}

setParallelogram()

template<typename PLT , typename FPT >

template<typename FPT1 , typename FPT2 , typename FPT3 >

void h2d::base::PolylineBase< PLT, FPT >::setParallelogram	(	const Point2d_< FPT1 > &	pt1,
		const Point2d_< FPT2 > &	pt2,
		const Point2d_< FPT3 > &	pt3
	)

Build a parallelogram (4 points) from 3 points.

{
    static_assert( std::is_same_v<PLT,typ::IsClosed>, "Invalid: cannot set a OPolyline as a parallelogram" );

    Point2d_<HOMOG2D_INUMTYPE> pt1(p1);
    Point2d_<HOMOG2D_INUMTYPE> pt2(p2);
    Point2d_<HOMOG2D_INUMTYPE> pt3(p3);

    std::vector<Point2d_<FPT>> vpts(4);
    vpts[0] = pt1;
    vpts[1] = pt2;
    vpts[2] = pt3;

    auto li_21 = pt1 * pt2;
    auto li_23 = pt3 * pt2;
    auto li_34 = li_21.getParallelLine( pt3 );
    auto li_14 = li_23.getParallelLine( pt1 );
    vpts[3] = li_34 * li_14;
    set( vpts );
}

Here is the caller graph for this function:

size()

template<typename PLT, typename FPT>

size_t h2d::base::PolylineBase< PLT, FPT >::size ( ) const

inlinevirtual

Returns the number of points.

Implements h2d::rtp::Root.

{ return _plinevec.size(); }

Here is the caller graph for this function:

translate() [1/2]

template<typename PLT, typename FPT>

template<typename TX , typename TY >

void h2d::base::PolylineBase< PLT, FPT >::translate ( TX  dx, TY  dy  )

inline

Translate Polyline using dx, dy.

    {
        HOMOG2D_CHECK_IS_NUMBER( TX );
        HOMOG2D_CHECK_IS_NUMBER( TY );
        for( auto& pt: _plinevec )
            pt.translate( dx, dy );
    }

Here is the caller graph for this function:

translate() [2/2]

template<typename PLT, typename FPT>

template<typename T1 , typename T2 >

void h2d::base::PolylineBase< PLT, FPT >::translate ( const std::pair< T1, T2 > &  ppt )

inline

Translate Polyline, using a pair of numerical values.

    {
        translate( ppt.first, ppt.second );
    }

type()

template<typename PLT, typename FPT>

Type h2d::base::PolylineBase< PLT, FPT >::type ( ) const

inlinevirtual

Implements h2d::rtp::Root.

    {
        if constexpr( std::is_same_v<PLT,typ::IsClosed> )
            return Type::CPolyline;
        else
            return Type::OPolyline;
    }

Friends And Related Function Documentation

h2d::base::operator<<

template<typename PLT, typename FPT>

template<typename T1 , typename T2 >

std::ostream& h2d::base::operator<< ( std::ostream &  , const h2d::base::PolylineBase< T1, T2 > &    )

friend

h2d::Ellipse_

template<typename PLT, typename FPT>

template<typename T1 >

friend class h2d::Ellipse_

friend

h2d::operator* [1/2]

template<typename PLT, typename FPT>

template<typename FPT1 , typename FPT2 >

CPolyline_<FPT1> h2d::operator* ( const h2d::Homogr_< FPT2 > &  , const h2d::FRect_< FPT1 > &    )

friend

h2d::operator* [2/2]

template<typename PLT, typename FPT>

template<typename FPT1 , typename FPT2 , typename PLT2 >

auto h2d::operator* ( const Homogr_< FPT2 > &  , const base::PolylineBase< PLT2, FPT1 > &    ) -> base::PolylineBase< PLT2, FPT1 >

friend

PolylineBase

template<typename PLT, typename FPT>

template<typename T1 , typename T2 >

friend class PolylineBase

friend

---

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

• homog2d.hpp