h2d::base Namespace Reference

Holds base classes, not part of API. More...

Classes
class	LPBase
	Base class, will be instanciated as Point2d_ or Line2d_. More...
class	PolylineBase
	Polyline, will be instanciated either as OPolyline_ (open polyline) or CPolyline_. More...
class	SegVec
	A line segment, oriented (OSegment_) or not (Segment_). Holds the two points. More...

Functions
template<typename FPT >
CPolyline_< FPT >	convexHull (const std::vector< Point2d_< FPT >> &input)
	Computes and returns the convex hull of a set of points (free function) More...
template<typename LP , typename FPT >
auto	operator<< (std::ostream &, const h2d::base::LPBase< LP, FPT > &) -> std::ostream &
	Stream operator, free function, call member function pseudo operator impl_op_stream() More...
template<typename T1 , typename T2 >
auto	operator<< (std::ostream &, const h2d::base::PolylineBase< T1, T2 > &) -> std::ostream &
template<typename LP , typename FPT >
std::ostream &	operator<< (std::ostream &f, const h2d::base::LPBase< LP, FPT > &pl)
	Stream operator, free function, call member function pseudo operator impl_op_stream() More...
template<typename SV , typename T >
std::ostream &	operator<< (std::ostream &f, const h2d::base::SegVec< SV, T > &seg)
template<typename PLT , typename FPT >
std::ostream &	operator<< (std::ostream &f, const h2d::base::PolylineBase< PLT, FPT > &pl)

Detailed Description

Holds base classes, not part of API.

Draw Segment / OSegment (SVG implementation)

Draw Segment / OSegment (Opencv implementation)

Todo:

20250201: why do we need this and why isn't the same required for OSegment_ ?

Todo:

20250127: implement arrows for the Opencv/png version, and share the code between the two versions

Function Documentation

convexHull()

template<typename FPT >

CPolyline_<FPT> h2d::base::convexHull

(

const std::vector< Point2d_< FPT >> &

input

)

Computes and returns the convex hull of a set of points (free function)

• Graham scan algorithm: https://en.wikipedia.org/wiki/Graham_scan

Todo:

20230728: make this function accept also std::array and std::list (using Sfinae alogn with trait::IsContainer)

{
    if( input.size() < 4 )  // if 3 pts or less, then the hull is equal to input set
        return CPolyline_<FPT>( input );

// step 1: find pivot (point with smallest Y coord)
    auto pivot_idx = priv::chull::getPivotPoint( input );

// step 2: sort points by angle of lines between the current point and pivot point
    auto v2 = priv::chull::sortPoints( input, pivot_idx );

    std::stack<size_t> firstPoint;
    priv::chull::Mystack hull;
    hull.push( v2[0] );
    hull.push( v2[1] );
    hull.push( v2[2] );

    firstPoint.push( 0 );
    firstPoint.push( 1 );

// step 3: iterate
    size_t idx1 = 1;
    size_t idx2 = 2;
    size_t idx3 = 3;
    do
    {
//      HOMOG2D_LOG( "** loop start, idx1=" << idx1 << ", idx2=" << idx2  << ", idx3=" << idx3 << ", hull " << hull.getVect() );
        auto p = input.at( v2[idx1] );
        auto q = input.at( v2[idx2] );
        auto r = input.at( v2[idx3] );
        auto orient = priv::chull::orientation( p, q, r );
//      HOMOG2D_LOG( "considering pts: " << v2[idx1] << "," << v2[idx2] << "," << v2[idx3] << ": or = " << orient );
        if( orient != 1 )
        {
            hull.push( v2[idx3] );
            idx1 = idx2;
            idx2 = idx3;
            idx3++;
            firstPoint.push( idx1 );
        }
        else
        {
            hull.pop();
            idx2=idx1; // idx3 stays the same
            firstPoint.pop();
            idx1 = firstPoint.top();
        }
    }
    while( idx3 < v2.size() );

// final step: copy hull indexes to vector of points
    const auto v = hull.getVect();
    std::vector<Point2d_<FPT>> vout( v.size() );
    std::transform(
        v.begin(),
        v.end(),
        vout.begin(),
        [&input]               // lambda
        (size_t idx)
        {
            return input.at( idx );
        }
    );

    return CPolyline_<FPT>( vout );
}

Here is the call graph for this function:

operator<<() [1/5]

template<typename LP , typename FPT >

auto h2d::base::operator<<	(	std::ostream &	,
		const h2d::base::LPBase< LP, FPT > &
	)		-> std::ostream &

Stream operator, free function, call member function pseudo operator impl_op_stream()

{
    if constexpr( std::is_same_v<LP,typ::IsLine> )
        f << '[' << pl._v[0] << ',' << pl._v[1] << ',' << pl._v[2] << "]";
    else
    {
        if( pl.isInf() )
            f << '[' << pl._v[0] << ',' << pl._v[1] << ',' << pl._v[2] << "]";
        else
            f
        //  << std::scientific << std::setprecision(25)
                << '[' << pl.getX() << ',' << pl.getY() << "]";
    }

    return f;
}

operator<<() [2/5]

template<typename T1 , typename T2 >

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

operator<<() [3/5]

template<typename LP , typename FPT >

std::ostream& h2d::base::operator<<	(	std::ostream &	f,
		const h2d::base::LPBase< LP, FPT > &	pl
	)

Stream operator, free function, call member function pseudo operator impl_op_stream()

{
    if constexpr( std::is_same_v<LP,typ::IsLine> )
        f << '[' << pl._v[0] << ',' << pl._v[1] << ',' << pl._v[2] << "]";
    else
    {
        if( pl.isInf() )
            f << '[' << pl._v[0] << ',' << pl._v[1] << ',' << pl._v[2] << "]";
        else
            f
        //  << std::scientific << std::setprecision(25)
                << '[' << pl.getX() << ',' << pl.getY() << "]";
    }

    return f;
}

operator<<() [4/5]

template<typename SV , typename T >

std::ostream& h2d::base::operator<<	(	std::ostream &	f,
		const h2d::base::SegVec< SV, T > &	seg
	)

{
    f << seg._ptS1;
    if constexpr( std::is_same_v<SV,typ::IsOSeg> )
        f << "=>";
    else
        f << "-";
    f << seg._ptS2;
    return f;
}

operator<<() [5/5]

template<typename PLT , typename FPT >

std::ostream& h2d::base::operator<<	(	std::ostream &	f,
		const h2d::base::PolylineBase< PLT, FPT > &	pl
	)

{
    f << (pl.isClosed() ? 'C' : 'O' ) << "Polyline: ";
    if( !pl.size() )
        f << "empty";
    else
    {
        for( const auto& pt: pl._plinevec )
            f << pt << "-";
    }
    return f;
}