h2d::priv Namespace Reference

Holds private stuff. More...

Namespaces
	chull
	Holds convex hull code.
	runion
	Common stuff for FRect_ union, see FRect_::unionArea()

Classes
class	ClosestPoints
	Used in getClosestPoints() More...
struct	F_MAX
struct	F_MIN
	used in findPoint() More...
struct	PolylineAttribs
	Holds attribute of a Polyline, allows storage of last computed value through the use of ValueFlag. More...
class	ValueFlag
	A POD value that needs some computing, associated with its flag. Used to be able to retain a value needing complex calculation. More...

Functions
template<typename Cont , typename std::enable_if< trait::IsArray< Cont >::value, Cont >::type * = nullptr>
Cont	alloc (std::size_t)
	Allocation for std::array container. More...
template<typename T >
void	drawSvgSeg (img::Image< img::SvgImage > &im, const Point2d_< T > &pt1, const Point2d_< T > &pt2, std::string color, int thickness, std::string attribs=std::string())
	Helper function to draw SVG segment. More...
template<typename T >
void	drawSvgSeg (img::Image< img::SvgImage > &im, const std::pair< Point2d_< T >, Point2d_< T >> &ppts, std::string color, int thickness, std::string attribs=std::string())
template<typename FPT , typename CONT , typename S_WHAT >
size_t	findPoint (const Point2d_< FPT > &qpt, const CONT &cont, const S_WHAT &)
	Private. Common function for searching nearest of farthest point. More...
template<typename FPT >
void	fix_order (Point2d_< FPT > &ptA, Point2d_< FPT > &ptB)
	Private free function, swap the points so that ptA.x <= ptB.x, and if equal, sorts on y. More...
template<typename FPT >
std::array< PointPair_< double >, 3 >	getArrowSegments (const base::SegVec< typ::IsOSeg, FPT > &vec)
template<typename FPT >
auto	getBB_CommonType (const std::vector< CommonType_< FPT >> &v_var)
	Get Bounding Box for a container holding variant objects. More...
template<typename FPT >
auto	getBB_FRect (const std::vector< FRect_< FPT >> &v_rects)
	get BB for a set of FRect_ objects More...
template<typename T , typename std::enable_if< trait::IsContainer< T >::value, T >::type * = nullptr>
PointPair_< typename T::value_type::FType >	getBB_Points (const T &vpts)
	Returns the bounding box of points in vector/list/array of points vpts (free function) More...
template<typename T , typename std::enable_if< trait::IsContainer< T >::value, T >::type * = nullptr>
FRect_< typename T::value_type::FType >	getBB_Segments (const T &vsegs)
	Returns the bounding box of segments in vector/list/array of points vsegs. More...
template<typename T >
auto	getBmPoint_helper (const T &t)
	Return iterator on Bottom-most point of container holding points. More...
template<typename PT >
std::array< PT, 3 >	getLargestDistancePoints (PT pt1, PT pt2, PT pt3)
	Helper function, used to check for colinearity of three points. More...
template<typename T1 , typename T2 >
Line2d_< T1 >	getOrthogonalLine_B2 (const Point2d_< T2 > &pt, const Line2d_< T1 > &li)
	Helper function for impl_getOrthogonalLine_A() and impl_getOrthogonalLine_B(), Compute orthogonal line to li at point pt (that must lie on the line) More...
template<typename FPT , typename FPT2 , typename FPT3 >
auto	getPoints_B2 (const Point2d_< FPT > &pt, FPT2 dist, const Line2d_< FPT3 > &li)
	Helper function, factorized here for the two impl_getPoints_A() implementations. More...
template<typename IMG , typename FPT >
void	impl_drawIndexes (img::Image< IMG > &img, size_t c, const img::DrawParams &dp, const Point2d_< FPT > &pt)
	Draw indexes for points. More...
template<typename IMG , typename FPT >
void	impl_drawIndexes (img::Image< IMG > &img, size_t c, const img::DrawParams &dp, const Segment_< FPT > &seg)
	Draw indexes for segment. More...
template<typename IMG , typename DUMMY >
void	impl_drawIndexes (img::Image< IMG > &, size_t, const img::DrawParams &, const DUMMY &)
	Default signature, will be instanciated if no other fits (and does nothing) More...
template<typename T >
std::pair< int, int >	impl_dsize (const detail::DataFpType< T > &)
	Implementation of dsize(), returns nb of bits of mantissa and exponent (default implementation) More...
template<long unsigned int M, long unsigned int E>
std::pair< int, int >	impl_dsize (const detail::DataFpType< ttmath::Big< M, E >> &)
	Implementation for ttmath types. More...
Dtype	impl_dtype (const detail::DataFpType< float > &)
Dtype	impl_dtype (const detail::DataFpType< double > &)
Dtype	impl_dtype (const detail::DataFpType< long double > &)
template<typename T >
Dtype	impl_dtype (const detail::DataFpType< T > &)
template<long unsigned int M, long unsigned int E>
Dtype	impl_dtype (const detail::DataFpType< ttmath::Big< M, E >> &)
	Implementation for ttmath types. More...
template<typename FPT1 , typename PT >
bool	is_valid_circle (const Circle_< FPT1 > &circ, const std::vector< PT > &pts)
	Free Function to check whether a circle encloses the given points. More...
template<typename ST , typename PLT , typename FPT >
std::vector< ST >	p_getSegs (const base::PolylineBase< PLT, FPT > &pl, const ST &)
	Private helper function for base::PolylineBase::getSegs() and base::PolylineBase::getOSegs() More...
template<typename T >
int	sign (T val)
	Get sign of value. More...
template<typename FPT1 , typename FPT2 >
HOMOG2D_INUMTYPE	sqDist (const Point2d_< FPT1 > &pt1, const Point2d_< FPT2 > &pt2)
	Free function, squared distance between points (sqrt not needed for comparisons, and can save some time) More...

Detailed Description

Holds private stuff.

Helper function used by the draw(OSegment) function, returns the 3 segment corresponding to the "arrows" as 3 pairs of points.

Used both in the SVG and the Opencv backends

   /|\
    |
    |
    |
   ---

Function Documentation

alloc()

template<typename Cont , typename std::enable_if< trait::IsArray< Cont >::value, Cont >::type * = nullptr>

Cont h2d::priv::alloc

(

std::size_t

nb

)

Allocation for std::array container.

Allocation for std::vector and std::list container.

See also

operator * ( const Hmatrix_&, const Cont& );

{
    return Cont();
}

drawSvgSeg() [1/2]

template<typename T >

void h2d::priv::drawSvgSeg	(	img::Image< img::SvgImage > &	im,
		const Point2d_< T > &	pt1,
		const Point2d_< T > &	pt2,
		std::string	color,
		int	thickness,
		std::string	attribs = std::string()
	)

Helper function to draw SVG segment.

{
    im.getReal()._svgString << "<line x1=\""
        << pt1.getX()
        << "\" y1=\""
        << pt1.getY()
        << "\" x2=\""
        << pt2.getX()
        << "\" y2=\""
        << pt2.getY()
        << "\" stroke=\"" << color
        << "\" stroke-width=\"" << thickness << "\" "
        << attribs << "/>\n";
}

Here is the call graph for this function:

Here is the caller graph for this function:

drawSvgSeg() [2/2]

template<typename T >

void h2d::priv::drawSvgSeg	(	img::Image< img::SvgImage > &	im,
		const std::pair< Point2d_< T >, Point2d_< T >> &	ppts,
		std::string	color,
		int	thickness,
		std::string	attribs = std::string()
	)

{
    drawSvgSeg( im, ppts.first, ppts.second, color, thickness, attribs );
}

findPoint()

template<typename FPT , typename CONT , typename S_WHAT >

size_t h2d::priv::findPoint	(	const Point2d_< FPT > &	qpt,
		const CONT &	cont,
		const S_WHAT &
	)

Private. Common function for searching nearest of farthest point.

Parameters

qpt	query point
cont	container

{
    if( cont.size() < 2 )
        HOMOG2D_THROW_ERROR_1( "container holds " << cont.size() \
            << " points, minimum is 2" );

    decltype( priv::sqDist( qpt, qpt ) ) resDist;
    size_t startIdx = 1;
    size_t resIdx = 0;

// if point is the first one of the container, then
// initialize with the second one
    if( cont[0] == qpt )
    {
        startIdx++;
        resIdx++;
        resDist = priv::sqDist( qpt, cont[1] );
    }
    else // initialize with first point
    {
        resDist = priv::sqDist( qpt, cont[0] );
    }

    for( size_t i=startIdx; i<cont.size(); i++ )
    {
        if( qpt != cont[i] )
        {
            auto currentDist = priv::sqDist( qpt, cont[i] );
            if constexpr( std::is_same_v<S_WHAT, F_MIN> )
            {
                if( currentDist < resDist )
                {
                    resIdx  = i;
                    resDist = currentDist;
                }
            }
            else
            {
                if( currentDist > resDist )
                {
                    resIdx  = i;
                    resDist = currentDist;
                }
            }
        }
    }
    return resIdx;
}

Here is the call graph for this function:

Here is the caller graph for this function:

fix_order()

template<typename FPT >

void h2d::priv::fix_order	(	Point2d_< FPT > &	ptA,
		Point2d_< FPT > &	ptB
	)

Private free function, swap the points so that ptA.x <= ptB.x, and if equal, sorts on y.

{
    if( !(ptA < ptB) )
        std::swap( ptA, ptB );
}

Here is the caller graph for this function:

getArrowSegments()

template<typename FPT >

std::array<PointPair_<double>,3> h2d::priv::getArrowSegments

(

const base::SegVec< typ::IsOSeg, FPT > &

vec

)

{
    std::array<std::pair<Point2d_<double>,Point2d_<double>>,3> out;
    auto ppts = vec.getPts();
    auto pt1 = ppts.first;
    auto pt2 = ppts.second;

    const int arSize = 8;

    Line2d_<double> liA = vec.getLine().getOrthogLine( pt1 );
    out[0] = liA.getPoints( pt1, arSize );

    auto ppts_B = vec.getLine().getPoints( pt2, arSize );

    Point2d_<double> p0 = ppts_B.first;
    if( dist( pt1, ppts_B.first) >  dist(pt1, ppts_B.second) )
        p0 = ppts_B.second;

    Line2d_<double> liB = vec.getLine().getOrthogLine( p0 );
    auto ppts_C = liB.getPoints( p0, arSize );

    out[1] = std::make_pair(ppts_C.first, pt2);
    out[2] = std::make_pair(ppts_C.second, pt2);

    return out;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getBB_CommonType()

template<typename FPT >

auto h2d::priv::getBB_CommonType

(

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

v_var

)

Get Bounding Box for a container holding variant objects.

Note

Here, we DO NOT preallocate the vector, because if the container holds lines, then no point pair will be added for these elements. If we would have preallocate with 2 x size of input vector, then some default-constructed points could sneak in, and introduce an error.

Todo:

20240513: At present, this is only implemented for std::vector. Let it handle std::list and std::array.

{
    HOMOG2D_START;
    HOMOG2D_DEBUG_ASSERT( v_var.size(), "cannot compute bounding box of empty set of variant" );

    std::vector<Point2d_<FPT>> vpts;
    vpts.reserve( v_var.size()*2 );
    PointPair_<FPT> ppair;
    for( const auto& elem: v_var )
    {
        try
        {
            ppair = std::visit( fct::PtPairFunct{}, elem );
        }
        catch( const std::exception& err )
        {
            HOMOG2D_LOG_WARNING( "unable to compute point pair\n -msg=" << err.what() );
        }
        vpts.push_back( ppair.first );
        vpts.push_back( ppair.second );
    }
    return FRect_<FPT>( getBB_Points( vpts ) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

getBB_FRect()

template<typename FPT >

auto h2d::priv::getBB_FRect

(

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

v_rects

)

get BB for a set of FRect_ objects

Todo:

same as getBB_Segments() ???

{
    HOMOG2D_START;
    HOMOG2D_DEBUG_ASSERT( v_rects.size(), "cannot compute bounding box of empty set of rectangles" );

    std::vector<Point2d_<FPT>> vpts( v_rects.size()*2 );
    auto it = vpts.begin();
    for( const auto& seg: v_rects )
    {
        auto ppts = seg.getPts();
        *it++ = ppts.first;
        *it++ = ppts.second;
    }
    return FRect_<FPT>( getBB_Points( vpts ) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

getBB_Points()

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

PointPair_<typename T::value_type::FType> h2d::priv::getBB_Points

(

const T &

vpts

)

Returns the bounding box of points in vector/list/array of points vpts (free function)

Todo:

This loops twice on the points. Maybe some improvement here.

{
    HOMOG2D_START;
    using FPT = typename T::value_type::FType;
    HOMOG2D_DEBUG_ASSERT( static_cast<bool>(vpts.size()), "cannot run with no points" );

    auto mm_x = std::minmax_element(
        std::begin( vpts ),
        std::end( vpts ),
        []                  // lambda
        ( const Point2d_<FPT>& pt1, const Point2d_<FPT>& pt2 )
        {
            return pt1.getX() < pt2.getX();
        }
    );
    auto mm_y = std::minmax_element(
        std::begin( vpts ),
        std::end( vpts ),
        []                  // lambda
        ( const Point2d_<FPT>& pt1, const Point2d_<FPT>& pt2 )
        {
            return pt1.getY() < pt2.getY();
        }
    );

    auto p1 = Point2d_<HOMOG2D_INUMTYPE>( mm_x.first->getX(),   mm_y.first->getY()  );
    auto p2 = Point2d_<HOMOG2D_INUMTYPE>( mm_x.second->getX(),  mm_y.second->getY() );

#ifndef HOMOG2D_NOCHECKS
    if( p1.distTo( p2 ) < thr::nullDistance() )
        HOMOG2D_THROW_ERROR_1(
            "unable to compute bounding box of set, identical points:\n -p1:"<< p1 << "\n -p2:" << p2
        );
    if( shareCommonCoord( p1, p2 ) )
        HOMOG2D_THROW_ERROR_1(
            "unable to compute bounding box of set, points share common coordinate:\n -p1:"
            << p1 << "\n -p2:" << p2
        );
#endif // HOMOG2D_NOCHECKS

    return std::make_pair( p1, p2 );
}

Here is the call graph for this function:

Here is the caller graph for this function:

getBB_Segments()

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

FRect_<typename T::value_type::FType> h2d::priv::getBB_Segments

(

const T &

vsegs

)

Returns the bounding box of segments in vector/list/array of points vsegs.

{
    HOMOG2D_START;
    using FPT = typename T::value_type::FType;

    HOMOG2D_DEBUG_ASSERT( vsegs.size(), "cannot compute bounding box of empty set of segments" );
    std::vector<Point2d_<FPT>> vpts( vsegs.size()*2 );
    auto it = vpts.begin();
    for( const auto& seg: vsegs )
    {
        auto ppts = seg.getPts();
        *it++ = ppts.first;
        *it++ = ppts.second;
    }
    return FRect_<typename T::value_type::FType>( getBB_Points( vpts ) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

getBmPoint_helper()

template<typename T >

auto h2d::priv::getBmPoint_helper

(

const T &

t

)

Return iterator on Bottom-most point of container holding points.

Used by

• getBmPoint()
• priv::chull::getPivotPoint()

{
    using FPT = typename T::value_type::FType;
#ifndef HOMOG2D_NOCHECKS
    if( t.size() == 0 )
        HOMOG2D_THROW_ERROR_1( "invalid call, container is empty" );
#endif

    return std::min_element(
        std::begin(t),
        std::end(t),
        []                  // lambda
        ( const Point2d_<FPT>& pt1, const Point2d_<FPT>& pt2 )
        {
            if( pt1.getY() < pt2.getY() )
                return true;
            if( pt1.getY() > pt2.getY() )
                return false;
            return( pt1.getX() < pt2.getX() );
        }
    );
}

Here is the call graph for this function:

Here is the caller graph for this function:

getLargestDistancePoints()

template<typename PT >

std::array<PT,3> h2d::priv::getLargestDistancePoints	(	PT	pt1,
		PT	pt2,
		PT	pt3
	)

Helper function, used to check for colinearity of three points.

This will return the same points as given in input but ordered as:

• the pair that has the largest distance in [0] and [1]
• the third point in [2]
• the point closest to the third point in [1], the farthest in [0]

See also

bool areCollinear()

Todo:

20220520: needs some optimization, once it has been extensively tested

We have theses 6 situations described on below diagrams A through F, with the desired output order:

 1 +                       1 +
   |    A => 3,1,2           |     B => 2,1,3
   |                         |
 2 +---------------+ 3     3 +---------------+ 2

 2 +                       2 +
   |    C => 3,2,1           |     D => 1,2,3
   |                         |
 1 +---------------+ 3     3 +---------------+ 1

 3 +                       3 +
   |    E => 2,3,1           |     F => 1,3,2
   |                         |
 1 +---------------+ 2     2 +---------------+ 1

{
    auto d12 = sqDist( pt1, pt2 );
    auto d13 = sqDist( pt1, pt3 );
    auto d23 = sqDist( pt2, pt3 );

    PT* pA = 0;
    PT* pB = 0;
    PT* pM = 0;

    if( d12 > d13 ) // case B, D, E
    {
        pA = &pt2;
        if( d12 > d23 ) // case B, D
        {
            pB = &pt1;
            pM = &pt3;
            if( d13 > d23 )
                std::swap( *pA, *pB );
        }
        else          // case E
        {
            pB = &pt3;
            pM = &pt1;
        }
    }
    else             // case A, C, F
    {
        pA = &pt3;
        if( d13 > d23 ) // A, F
        {
            pB = &pt1;
            pM = &pt2;
            if( d12 > d23 )
                std::swap( *pA, *pB );
        }
        else           // case C
        {
            pB = &pt2;
            pM = &pt1;
        }
    }

    return std::array<PT,3>{ *pA, *pB, *pM };
}

Here is the call graph for this function:

Here is the caller graph for this function:

getOrthogonalLine_B2()

template<typename T1 , typename T2 >

Line2d_<T1> h2d::priv::getOrthogonalLine_B2	(	const Point2d_< T2 > &	pt,
		const Line2d_< T1 > &	li
	)

Helper function for impl_getOrthogonalLine_A() and impl_getOrthogonalLine_B(), Compute orthogonal line to li at point pt (that must lie on the line)

{
    auto arr = li.get(); // get array of 3 values
    Line2d_<T1> out(
        -arr[1],
        arr[0],
        arr[1] * pt.getX() - arr[0] * pt.getY()
    );
    out.p_normalizePL();
    return out;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getPoints_B2()

template<typename FPT , typename FPT2 , typename FPT3 >

auto h2d::priv::getPoints_B2	(	const Point2d_< FPT > &	pt,
		FPT2	dist,
		const Line2d_< FPT3 > &	li
	)

Helper function, factorized here for the two impl_getPoints_A() implementations.

{
    auto arr = li.get();
    const HOMOG2D_INUMTYPE a = static_cast<HOMOG2D_INUMTYPE>(arr[0]);
    const HOMOG2D_INUMTYPE b = static_cast<HOMOG2D_INUMTYPE>(arr[1]);
    auto coeff = static_cast<HOMOG2D_INUMTYPE>(dist) / homog2d_sqrt( a*a + b*b );

    Point2d_<FPT> pt1(
        pt.getX() -  b * coeff,
        pt.getY() +  a * coeff
    );
    Point2d_<FPT> pt2(
        pt.getX() +  b * coeff,
        pt.getY() -  a * coeff
    );
    fix_order( pt1, pt2 );
    return std::make_pair( pt1, pt2 );
}

Here is the call graph for this function:

Here is the caller graph for this function:

impl_drawIndexes() [1/3]

template<typename IMG , typename FPT >

void h2d::priv::impl_drawIndexes	(	img::Image< IMG > &	img,
		size_t	c,
		const img::DrawParams &	dp,
		const Point2d_< FPT > &	pt
	)

Draw indexes for points.

{
    if( dp._dpValues._showIndex )
        drawText( img, std::to_string(c), pt, dp );
}

Here is the call graph for this function:

Here is the caller graph for this function:

impl_drawIndexes() [2/3]

template<typename IMG , typename FPT >

void h2d::priv::impl_drawIndexes	(	img::Image< IMG > &	img,
		size_t	c,
		const img::DrawParams &	dp,
		const Segment_< FPT > &	seg
	)

Draw indexes for segment.

{
    if( dp._dpValues._showIndex )
        drawText( img, std::to_string(c), seg.getCenter(), dp );
}

Here is the call graph for this function:

impl_drawIndexes() [3/3]

template<typename IMG , typename DUMMY >

void h2d::priv::impl_drawIndexes	(	img::Image< IMG > &	,
		size_t	,
		const img::DrawParams &	,
		const DUMMY &
	)

Default signature, will be instanciated if no other fits (and does nothing)

{}

impl_dsize() [1/2]

template<typename T >

std::pair<int,int> h2d::priv::impl_dsize ( const detail::DataFpType< T > &  )

inline

Implementation of dsize(), returns nb of bits of mantissa and exponent (default implementation)

    {
        return std::make_pair(
            std::numeric_limits<T>::digits,
            sizeof(T)*8-std::numeric_limits<T>::digits-1
        );
    }

Here is the caller graph for this function:

impl_dsize() [2/2]

template<long unsigned int M, long unsigned int E>

std::pair<int,int> h2d::priv::impl_dsize ( const detail::DataFpType< ttmath::Big< M, E >> &  )

inline

Implementation for ttmath types.

    {
        return std::make_pair( M*sizeof(size_t)*8, E*sizeof(size_t)*8 );
    }

impl_dtype() [1/5]

Dtype h2d::priv::impl_dtype ( const detail::DataFpType< float > &  )

inline

    {
        return Dtype::Float;
    }

Here is the caller graph for this function:

impl_dtype() [2/5]

Dtype h2d::priv::impl_dtype ( const detail::DataFpType< double > &  )

inline

    {
        return Dtype::Double;
    }

impl_dtype() [3/5]

Dtype h2d::priv::impl_dtype ( const detail::DataFpType< long double > &  )

inline

    {
        return Dtype::LongDouble;
    }

impl_dtype() [4/5]

template<typename T >

Dtype h2d::priv::impl_dtype ( const detail::DataFpType< T > &  )

inline

    {
        return Dtype::Other;
    }

impl_dtype() [5/5]

template<long unsigned int M, long unsigned int E>

Dtype h2d::priv::impl_dtype ( const detail::DataFpType< ttmath::Big< M, E >> &  )

inline

Implementation for ttmath types.

    {
        return Dtype::Ttmath;
    }

is_valid_circle()

template<typename FPT1 , typename PT >

bool h2d::priv::is_valid_circle	(	const Circle_< FPT1 > &	circ,
		const std::vector< PT > &	pts
	)

Free Function to check whether a circle encloses the given points.

{
    for( const auto& pt: pts )
        if( !pt.isInside( circ ) )
            return false;
    return true;
}

Here is the call graph for this function:

p_getSegs()

template<typename ST , typename PLT , typename FPT >

std::vector<ST> h2d::priv::p_getSegs	(	const base::PolylineBase< PLT, FPT > &	pl,
		const ST &
	)

Private helper function for base::PolylineBase::getSegs() and base::PolylineBase::getOSegs()

{
    auto siz = pl.size();
    if( siz < 2 ) // nothing to return
        return std::vector<ST>();

    std::vector<ST> out;
    out.reserve( siz );
    for( size_t i=0; i<siz-1; i++ )
    {
        const auto& pt1 = pl.getPoint(i);
        const auto& pt2 = pl.getPoint(i+1);
        out.emplace_back( ST(pt1,pt2) );
    }
    if constexpr( std::is_same_v<PLT,typ::IsClosed> )
        out.push_back( ST(pl.getPoint(siz-1), pl.getPoint(0) ) );
    return out;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sign()

template<typename T >

int h2d::priv::sign

(

T

val

)

Get sign of value.

source: https://stackoverflow.com/a/4609795/

                {
    return (T(0) < val) - (val < T(0));
}

Here is the caller graph for this function:

sqDist()

template<typename FPT1 , typename FPT2 >

HOMOG2D_INUMTYPE h2d::priv::sqDist	(	const Point2d_< FPT1 > &	pt1,
		const Point2d_< FPT2 > &	pt2
	)

Free function, squared distance between points (sqrt not needed for comparisons, and can save some time)

See also

Point2d_::distTo()

dist( const Point2d_&, const Point2d_& )

{
    auto dx = (HOMOG2D_INUMTYPE)pt1.getX() - pt2.getX();
    auto dy = (HOMOG2D_INUMTYPE)pt1.getY() - pt2.getY();
    return dx*dx + dy*dy;
}

Here is the call graph for this function:

Here is the caller graph for this function: