h2d::detail Namespace Reference

This namespace holds some private stuff, types here are not to be used directly by end-user code. More...

Classes
struct	AlwaysFalse
	A trick used in static_assert, so it aborts only if function is instanciated. More...
struct	BaseHelper
	Helper class for Root (Point/Line) type, used as a trick to allow partial specialization of member functions. More...
class	Common
	Common templated class for all the geometric primitives. More...
struct	DataFpType
	Helper class for used to get the underlying floating-point type, see Dtype and Common::dtype() More...
struct	EllParams
	Holds 9 parameters of Ellipse_. More...
struct	HelperPL
struct	HelperPL< typ::IsLine >
struct	HelperPL< typ::IsPoint >
class	Inters_1
class	Inters_2
class	Intersect
	Base class for intersection, gets specialized. More...
class	Intersect< Inters_1, FPT >
	One point intersection. More...
class	Intersect< Inters_2, FPT >
	Two points intersection. More...
struct	IntersectCommon
	Common stuff for intersection code. More...
class	IntersectM
	Multiple points intersections. More...
class	Matrix_
	A simple wrapper over a 3x3 matrix, provides root functionalities. More...
struct	PlHelper
	Helper class for PolylineBase, used as a trick to allow partial specialization of member functions. More...
class	RectArea
	Helper class, holds result of intersections of two FRect_. More...

Typedefs
template<typename T >
using	matrix_t = std::array< std::array< T, 3 >, 3 >
	An alias used to hold data of a 3x3 matrix, see detail::Matrix_. More...

Enumerations
enum	PtTag : uint8_t { PtTag::Inside, PtTag::Outside, PtTag::OnEdge }
	See getPtLabel( const Point2d_<FPT>& pt, const Circle_<FPT2>& circle ) More...

Functions
template<typename FPT >
Homogr_< FPT >	buildFrom4Points_Opencv (const std::vector< Point2d_< FPT >> &vpt1, const std::vector< Point2d_< FPT >> &vpt2)
	Build Homography from 2 sets of 4 points, using Opencv. More...
template<typename T1 , typename T2 , typename FPT1 , typename FPT2 >
base::LPBase< T1, FPT1 >	crossProduct (const base::LPBase< T2, FPT1 > &, const base::LPBase< T2, FPT2 > &)
template<typename Out , typename In , typename FPT1 , typename FPT2 >
base::LPBase< Out, FPT1 >	crossProduct (const base::LPBase< In, FPT1 > &r1, const base::LPBase< In, FPT2 > &r2)
	Cross product of points * points or line * line. More...
template<typename FPT1 , typename FPT2 >
HOMOG2D_INUMTYPE	crossProductV (const base::SegVec< typ::IsOSeg, FPT1 > &v1, const base::SegVec< typ::IsOSeg, FPT2 > &v2)
	Cross product of two oriented segments, return a scalar. More...
template<typename T >
void	drawPt (img::Image< T > &img, img::PtStyle ps, std::vector< Point2d_< float >> vpt, const img::DrawParams &dp, bool drawDiag=false)
	Private helper function, used by LPBase<IsPoint>::draw(). Draw point on image. More...
template<typename FPT >
PointPair_< FPT >	getCorrectPoints (const Point2d_< FPT > &p0, const Point2d_< FPT > &p1)
	Private free function, get top-left and bottom-right points from two arbitrary points. More...
template<typename FPT , typename FPT2 >
PtTag	getPtLabel (const Point2d_< FPT > &pt, const Circle_< FPT2 > &circle)
	Returns a label characterizing point pt, related to circle: inside, outside, or on edge of circle. More...
template<typename T1 , typename T2 >
Matrix_< T1 >	operator* (const Matrix_< T1 > &h1, const Matrix_< T2 > &h2)
template<typename U >
std::ostream &	operator<< (std::ostream &f, const EllParams< U > &par)
template<typename FPT1 , typename FPT2 , typename FPT3 >
void	product (Matrix_< FPT1 > &out, const Matrix_< FPT2 > &h1, const Matrix_< FPT3 > &h2)
	Implementation of product 3x3 by 3x3. More...
template<typename T1 , typename T2 , typename FPT1 , typename FPT2 >
void	product (base::LPBase< T1, FPT1 > &out, const Matrix_< FPT2 > &h, const base::LPBase< T2, FPT1 > &in)
	Implementation of product 3x3 by 3x1. More...
template<typename FPT1 , typename FPT2 >
bool	ptIsInside (const Point2d_< FPT1 > &pt, const Point2d_< FPT2 > &p00, const Point2d_< FPT2 > &p11)
	Private free function, returns true if point pt is inside the rectangle defined by (p00 , p11) More...
template<typename FPT1 , typename FPT2 >
bool	shareCommonCoord (const Point2d_< FPT1 > &p1, const Point2d_< FPT2 > &p2)
	Returns true if one of the points share a common coordinate (thus making them unable to define a bounding box) More...
template<typename FPT1 , typename FPT2 >
bool	shareCommonCoord (const std::pair< Point2d_< FPT1 >, Point2d_< FPT2 >> &ppts)
	Returns true if one of the points share a common coordinate (thus making them unable to define a bounding box) More...

Detailed Description

This namespace holds some private stuff, types here are not to be used directly by end-user code.

Inner implementation details.

Typedef Documentation

matrix_t

template<typename T >

using h2d::detail::matrix_t = typedef std::array<std::array<T,3>,3>

An alias used to hold data of a 3x3 matrix, see detail::Matrix_.

Enumeration Type Documentation

PtTag

enum h2d::detail::PtTag : uint8_t

strong

See getPtLabel( const Point2d_<FPT>& pt, const Circle_<FPT2>& circle )

Enumerator
Inside
Outside
OnEdge

                : uint8_t
{
    Inside, Outside, OnEdge
};

Function Documentation

buildFrom4Points_Opencv()

template<typename FPT >

Homogr_<FPT> h2d::detail::buildFrom4Points_Opencv	(	const std::vector< Point2d_< FPT >> &	vpt1,
		const std::vector< Point2d_< FPT >> &	vpt2
	)

Build Homography from 2 sets of 4 points, using Opencv.

• see https://docs.opencv.org/master/d9/d0c/group__calib3d.html#ga4abc2ece9fab9398f2e560d53c8c9780

Note

With current Opencv installed on current machine, it seems that cv::getPerspectiveTransform() requires that the points are "CV_32F" (float), and NOT double.

Parameters

vpt1	source points
vpt2	destination points

{
    const auto& src = getPts<cv::Point2f>( vpt1 );
    const auto& dst = getPts<cv::Point2f>( vpt2 );
    return cv::getPerspectiveTransform( src, dst ); // automatic type conversion to Hmatrix_
}

Here is the caller graph for this function:

crossProduct() [1/2]

template<typename T1 , typename T2 , typename FPT1 , typename FPT2 >

base::LPBase<T1,FPT1> h2d::detail::crossProduct	(	const base::LPBase< T2, FPT1 > &	,
		const base::LPBase< T2, FPT2 > &
	)

crossProduct() [2/2]

template<typename Out , typename In , typename FPT1 , typename FPT2 >

base::LPBase<Out,FPT1> h2d::detail::crossProduct	(	const base::LPBase< In, FPT1 > &	r1,
		const base::LPBase< In, FPT2 > &	r2
	)

Cross product of points * points or line * line.

• https://en.wikipedia.org/wiki/Cross_product#Coordinate_notation

{
    auto r1_a = static_cast<HOMOG2D_INUMTYPE>(r1._v[0]);
    auto r1_b = static_cast<HOMOG2D_INUMTYPE>(r1._v[1]);
    auto r1_c = static_cast<HOMOG2D_INUMTYPE>(r1._v[2]);
    auto r2_a = static_cast<HOMOG2D_INUMTYPE>(r2._v[0]);
    auto r2_b = static_cast<HOMOG2D_INUMTYPE>(r2._v[1]);
    auto r2_c = static_cast<HOMOG2D_INUMTYPE>(r2._v[2]);

    base::LPBase<Out,FPT1> res;
    res._v[0] = static_cast<FPT1>( r1_b * r2_c  - r1_c * r2_b );
    res._v[1] = static_cast<FPT1>( r1_c * r2_a  - r1_a * r2_c );
    res._v[2] = static_cast<FPT1>( r1_a * r2_b  - r1_b * r2_a );

    return res;
}

Here is the caller graph for this function:

crossProductV()

template<typename FPT1 , typename FPT2 >

HOMOG2D_INUMTYPE h2d::detail::crossProductV	(	const base::SegVec< typ::IsOSeg, FPT1 > &	v1,
		const base::SegVec< typ::IsOSeg, FPT2 > &	v2
	)

Cross product of two oriented segments, return a scalar.

{
    auto ppts1 = v1.getPts();
    auto ppts2 = v2.getPts();

    auto dx1 =
        static_cast<HOMOG2D_INUMTYPE>( ppts1.second.getX()  )
        - static_cast<HOMOG2D_INUMTYPE>( ppts1.first.getX() );
    auto dy1 =
        static_cast<HOMOG2D_INUMTYPE>(   ppts1.second.getY() )
        - static_cast<HOMOG2D_INUMTYPE>( ppts1.first.getY()  );
    auto dx2 =
        static_cast<HOMOG2D_INUMTYPE>(   ppts2.second.getX() )
        - static_cast<HOMOG2D_INUMTYPE>( ppts2.first.getX()  );
    auto dy2 =
        static_cast<HOMOG2D_INUMTYPE>(   ppts2.second.getY() )
        - static_cast<HOMOG2D_INUMTYPE>( ppts2.first.getY()  );

    return dx1 * dy2 - dy1 * dx2;
}

Here is the call graph for this function:

Here is the caller graph for this function:

drawPt()

template<typename T >

void h2d::detail::drawPt	(	img::Image< T > &	img,
		img::PtStyle	ps,
		std::vector< Point2d_< float >>	vpt,
		const img::DrawParams &	dp,
		bool	drawDiag = false
	)

Private helper function, used by LPBase<IsPoint>::draw(). Draw point on image.

{
    auto delta  = dp._dpValues._ptDelta;
    auto delta2 = std::round( 0.7 * delta);
    switch( ps )
    {
        case img::PtStyle::Times:
        case img::PtStyle::Squ:
            vpt[0].translate( -delta2, +delta2 );
            vpt[1].translate( +delta2, -delta2 );
            vpt[2].translate( +delta2, +delta2 );
            vpt[3].translate( -delta2, -delta2 );
        break;

        case img::PtStyle::Plus:
        case img::PtStyle::Diam:
            vpt[0].translate( -delta, 0.      );
            vpt[1].translate( +delta, 0.      );
            vpt[2].translate( 0.,      -delta );
            vpt[3].translate( 0.,      +delta );
        break;
        default: assert(0);
    }
    auto dp2(dp);          // we need to do this, because this is called by the
    dp2.showPoints(false); //  segment drawing function. If not, infinite recursion
    if( !drawDiag )
    {
        if( ps == img::PtStyle::Squ )
        {
            std::vector<Segment_<float>> vseg{
                {vpt[0], vpt[1]},
                {vpt[2], vpt[1]},
                {vpt[2], vpt[3]},
                {vpt[0], vpt[3]}
            };
            for( const auto& s:vseg )
                s.draw( img, dp2 );
        }
        else
        {
            Segment_<float> s1( vpt[0], vpt[1] );
            Segment_<float> s2( vpt[2], vpt[3] );
            s1.draw( img, dp2 );
            s2.draw( img, dp2 );
        }
    }
    else // draw 4 diagonal lines
    {
        Segment_<float>( vpt[0], vpt[2] ).draw( img, dp2 );
        Segment_<float>( vpt[2], vpt[1] ).draw( img, dp2 );
        Segment_<float>( vpt[1], vpt[3] ).draw( img, dp2 );
        Segment_<float>( vpt[0], vpt[3] ).draw( img, dp2 );
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

getCorrectPoints()

template<typename FPT >

PointPair_<FPT> h2d::detail::getCorrectPoints	(	const Point2d_< FPT > &	p0,
		const Point2d_< FPT > &	p1
	)

Private free function, get top-left and bottom-right points from two arbitrary points.

Throws if one of the coordinates is equal to the other (x1=x2 or y1=y2)

{
#ifndef HOMOG2D_NOCHECKS
    if( shareCommonCoord( p0, p1 ) )
        HOMOG2D_THROW_ERROR_1(
            "a coordinate of the 2 points is identical, does not define a rectangle:\n p0=" << p0 << " p1=" << p1
        );
#endif
    Point2d_<FPT> p00( std::min(p0.getX(), p1.getX()), std::min(p0.getY(), p1.getY()) );
    Point2d_<FPT> p11( std::max(p0.getX(), p1.getX()), std::max(p0.getY(), p1.getY()) );
    return std::make_pair( p00, p11 );
}

Here is the call graph for this function:

Here is the caller graph for this function:

getPtLabel()

template<typename FPT , typename FPT2 >

PtTag h2d::detail::getPtLabel	(	const Point2d_< FPT > &	pt,
		const Circle_< FPT2 > &	circle
	)

Returns a label characterizing point pt, related to circle: inside, outside, or on edge of circle.

{
    if( pt.isInside( circle ) )
        return PtTag::Inside;
    if(
        homog2d_abs( pt.distTo( circle.center() ) - circle.radius() )
            < thr::nullDistance()
    )
        return PtTag::OnEdge;
    return PtTag::Outside;
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator*()

template<typename T1 , typename T2 >

Matrix_<T1> h2d::detail::operator*	(	const Matrix_< T1 > &	h1,
		const Matrix_< T2 > &	h2
	)

{
//  HOMOG2D_START;
    Matrix_<T1> out;
    product( out, h1, h2 );
    return out;
}

Here is the call graph for this function:

operator<<()

template<typename U >

std::ostream& h2d::detail::operator<<	(	std::ostream &	f,
		const EllParams< U > &	par
	)

{
    f << "EllParams: origin=" << par.x0 << "," << par.y0
        << " angle=" << par.theta *180./M_PI
        << " a=" << par.a << " b=" << par.b
        << ' ';
    return f;
}

product() [1/2]

template<typename FPT1 , typename FPT2 , typename FPT3 >

void h2d::detail::product	(	Matrix_< FPT1 > &	out,
		const Matrix_< FPT2 > &	h1,
		const Matrix_< FPT3 > &	h2
	)

Implementation of product 3x3 by 3x3.

{
    out.p_fillZero();
    for( int i=0; i<3; i++ )
        for( int j=0; j<3; j++ )
            for( int k=0; k<3; k++ )
                out.value(i,j) +=
                    static_cast<HOMOG2D_INUMTYPE>( h1.value(i,k) ) * h2.value(k,j);
}

Here is the caller graph for this function:

product() [2/2]

template<typename T1 , typename T2 , typename FPT1 , typename FPT2 >

void h2d::detail::product	(	base::LPBase< T1, FPT1 > &	out,
		const Matrix_< FPT2 > &	h,
		const base::LPBase< T2, FPT1 > &	in
	)

Implementation of product 3x3 by 3x1.

• T1 and T2: typ::IsLine or typ::IsPoint (same but also different)

{
    for( int i=0; i<3; i++ )
    {
        auto sum  = static_cast<HOMOG2D_INUMTYPE>(h._mdata[i][0]) * in._v[0];
        sum      += h._mdata[i][1] * in._v[1];
        sum      += h._mdata[i][2] * in._v[2];
        out._v[i] = sum;
    }
}

Here is the caller graph for this function:

ptIsInside()

template<typename FPT1 , typename FPT2 >

bool h2d::detail::ptIsInside	(	const Point2d_< FPT1 > &	pt,
		const Point2d_< FPT2 > &	p00,
		const Point2d_< FPT2 > &	p11
	)

Private free function, returns true if point pt is inside the rectangle defined by (p00 , p11)

{
    if( pt.getX() > p00.getX() && pt.getX() < p11.getX() )
        if( pt.getY() > p00.getY() && pt.getY() < p11.getY() )
            return true;
    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

shareCommonCoord() [1/2]

template<typename FPT1 , typename FPT2 >

bool h2d::detail::shareCommonCoord	(	const Point2d_< FPT1 > &	p1,
		const Point2d_< FPT2 > &	p2
	)

Returns true if one of the points share a common coordinate (thus making them unable to define a bounding box)

{
    if(
           homog2d_abs( p1.getX() - p2.getX() ) < thr::nullOrthogDistance()
        || homog2d_abs( p1.getY() - p2.getY() ) < thr::nullOrthogDistance()
    )
        return true;
    return false;
}

Here is the call graph for this function:

shareCommonCoord() [2/2]

template<typename FPT1 , typename FPT2 >

bool h2d::detail::shareCommonCoord

(

const std::pair< Point2d_< FPT1 >, Point2d_< FPT2 >> &

ppts

)

Returns true if one of the points share a common coordinate (thus making them unable to define a bounding box)

{
    return shareCommonCoord( ppts.first , ppts.second );
}

Here is the caller graph for this function: