h2d::Circle_< FPT > Class Template Reference

A circle. More...

#include <homog2d.hpp>

Inheritance diagram for h2d::Circle_< FPT >:

Collaboration diagram for h2d::Circle_< FPT >:

Public Types
using	FType = FPT
using	SType = typ::T_Circle

Public Member Functions
void	draw (img::Image< cv::Mat > &, img::DrawParams=img::DrawParams()) const
	Draw Circle (Opencv implementation) More...
void	draw (img::Image< img::SvgImage > &, img::DrawParams=img::DrawParams()) const
	Draw Circle (SVG implementation) More...
Type	type () const
Constructors
	Circle_ ()
	Default constructor, unit-radius circle at (0,0) More...
template<typename T , typename std::enable_if< std::is_arithmetic< T >::value, T >::type * = nullptr>
	Circle_ (T rad)
	1-arg constructor 1, given radius circle at (0,0) More...
template<typename FPT2 >
	Circle_ (Point2d_< FPT2 > center)
	1-arg constructor 2, given center point, radius = 1.0 More...
template<typename T , typename std::enable_if< trait::IsContainer< T >::value, T >::type * = nullptr>
	Circle_ (const T &pts)
	1-arg constructor 3, build circle from a set of 2, 3, or more points (Minimum Enclosing Circle, aka MEC) More...
template<typename T1 , typename T2 >
	Circle_ (const Point2d_< T1 > &center, T2 rad=1.0)
	2-arg constructor 1: point and radius More...
template<typename T1 , typename T2 >
	Circle_ (const Point2d_< T1 > &pt1, const Point2d_< T2 > &pt2)
	2-arg constructor 2: circle from 2 points (may be of different types) More...
template<typename T1 , typename T2 , typename std::enable_if<(std::is_arithmetic< T1 >::value &&!std::is_same< T1, bool >::value), T1 >::type * = nullptr>
	Circle_ (T1 x, T1 y, T2 rad)
	3-arg constructor 1: build circle from 3 floating-point values: x, y, radius More...
template<typename T1 , typename T2 , typename T3 >
	Circle_ (const Point2d_< T1 > &pt1, const Point2d_< T2 > &pt2, const Point2d_< T3 > &pt3)
	3-arg constructor 2: builds a circle from 3 points More...
template<typename FPT2 >
	Circle_ (const Circle_< FPT2 > &other)
	Copy-Constructor. More...
Attributes access
FPT &	radius ()
const FPT &	radius () const
Point2d_< FPT > &	center ()
const Point2d_< FPT > &	center () const
const Point2d_< FPT > &	getCenter () const
constexpr size_t	size () const
HOMOG2D_INUMTYPE	area () const
	Area of circle. More...
HOMOG2D_INUMTYPE	length () const
	Perimeter of circle. More...
auto	getBB () const
	Returns Bounding Box of circle. More...
Enclosing functions
template<typename FPT2 >
bool	isInside (const Circle_< FPT2 > &other) const
	Returns true if circle is inside other circle. More...
template<typename FPT2 >
bool	isInside (const Point2d_< FPT2 > &p1, const Point2d_< FPT2 > &p2) const
	Returns true if circle is inside rectangle defined by p1 and p2. More...
template<typename FPT2 >
bool	isInside (const FRect_< FPT2 > &rect) const
	Returns true if circle is inside flat rectangle rect. More...
template<typename FPT2 , typename PTYPE >
bool	isInside (const base::PolylineBase< PTYPE, FPT2 > &poly) const
	Returns true if circle is inside polyline. More...
Intersection functions
template<typename FPT2 >
detail::Intersect< detail::Inters_2, FPT >	intersects (const Line2d_< FPT2 > &li) const
	Circle/Line intersection. More...
template<typename FPT2 >
detail::IntersectM< FPT >	intersects (const Segment_< FPT2 > &seg) const
	Circle/Segment intersection. More...
template<typename FPT2 >
detail::IntersectM< FPT >	intersects (const Circle_< FPT2 > &) const
	Circle/Circle intersection. More...
template<typename FPT2 >
detail::IntersectM< FPT >	intersects (const FRect_< FPT2 > &rect) const
	Circle/FRect intersection. More...
template<typename PLT , typename FPT2 >
detail::IntersectM< FPT >	intersects (const base::PolylineBase< PLT, FPT2 > &pl) const
	Circle/Polyline intersection. More...
Operators
template<typename FPT2 >
bool	operator== (const Circle_< FPT2 > &other) const
template<typename FPT2 >
bool	operator!= (const Circle_< 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 T >
class	Circle_
template<typename T >
std::ostream &	operator<< (std::ostream &f, const Circle_< T > &r)

Edit values
template<typename PT >
void	set (const Point2d_< PT > &center)
	Set circle center point, radius unchanged. More...
template<typename T , typename std::enable_if<(std::is_arithmetic< T >::value &&!std::is_same< T, bool >::value), T >::type * = nullptr>
void	set (T rad)
	Set circle radius, center point unchanged. More...
template<typename FPT2 , typename FPT3 >
void	set (const Point2d_< FPT2 > &center, FPT3 rad)
	Set circle from center point and radius. More...
template<typename FPT2 , typename std::enable_if< std::is_arithmetic< FPT2 >::value, FPT2 >::type * = nullptr>
void	set (FPT2 x, FPT2 y, FPT2 rad)
	Set circle from 3 values (x0,y0,radius) More...
template<typename T1 , typename T2 >
void	set (const Point2d_< T1 > &, const Point2d_< T2 > &)
	Set circle from 2 points. More...
template<typename T1 , typename T2 , typename T3 >
void	set (const Point2d_< T1 > &, const Point2d_< T2 > &, const Point2d_< T3 > &)
	Set circle from 3 points. More...
template<typename T , typename std::enable_if< trait::IsContainer< T >::value, T >::type * = nullptr>
void	set (const T &)
	Compute circle from a set of points (Minimum Enclosing Circle, aka MEC) using the Welzl algorithm. More...
template<typename TX , typename TY >
void	translate (TX dx, TY dy)
	Translate Circle. More...
template<typename T1 , typename T2 >
void	translate (const std::pair< T1, T2 > &pa)
	Translate Circle. More...
template<typename TX , typename TY >
void	moveTo (TX x, TY y)
	Move Circle to other location. More...
template<typename T1 >
void	moveTo (const Point2d_< T1 > &pt)
	Move Circle to other location, geiven by pt. More...

Detailed Description

template<typename FPT>
class h2d::Circle_< FPT >

A circle.

Member Typedef Documentation

FType

template<typename FPT>

using h2d::Circle_< FPT >::FType = FPT

SType

template<typename FPT>

using h2d::Circle_< FPT >::SType = typ::T_Circle

Constructor & Destructor Documentation

Circle_() [1/9]

template<typename FPT>

h2d::Circle_< FPT >::Circle_ ( )

inline

Default constructor, unit-radius circle at (0,0)

              : _radius(1.)
    {}

Here is the call graph for this function:

Circle_() [2/9]

template<typename FPT>

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

h2d::Circle_< FPT >::Circle_ ( T  rad )

inlineexplicit

1-arg constructor 1, given radius circle at (0,0)

        : Circle_( Point2d_<FPT>(), rad )
    {}

Circle_() [3/9]

template<typename FPT>

template<typename FPT2 >

h2d::Circle_< FPT >::Circle_ ( Point2d_< FPT2 >  center )

inlineexplicit

1-arg constructor 2, given center point, radius = 1.0

        : Circle_( center, 1. )
    {}

Circle_() [4/9]

template<typename FPT>

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

h2d::Circle_< FPT >::Circle_ ( const T &  pts )

inlineexplicit

1-arg constructor 3, build circle from a set of 2, 3, or more points (Minimum Enclosing Circle, aka MEC)

    {
        set( pts );
    }

Circle_() [5/9]

template<typename FPT>

template<typename T1 , typename T2 >

h2d::Circle_< FPT >::Circle_ ( const Point2d_< T1 > &  center, T2  rad = 1.0  )

inline

2-arg constructor 1: point and radius

        : _radius(rad), _center(center)
    {
#ifndef HOMOG2D_NOCHECKS
        if( homog2d_abs(rad) < thr::nullDistance() && !h2d::thr::doNotCheckRadius() )
            HOMOG2D_THROW_ERROR_1( "radius value too small: " << std::scientific << homog2d_abs(rad) );
        if( rad < 0. )
            HOMOG2D_THROW_ERROR_1( "radius must not be <0" );
#endif
    }

Here is the call graph for this function:

Circle_() [6/9]

template<typename FPT>

template<typename T1 , typename T2 >

h2d::Circle_< FPT >::Circle_ ( const Point2d_< T1 > &  pt1, const Point2d_< T2 > &  pt2  )

inline

2-arg constructor 2: circle from 2 points (may be of different types)

    {
        set( pt1, pt2 );
    }

Here is the call graph for this function:

Circle_() [7/9]

template<typename FPT>

template<typename T1 , typename T2 , typename std::enable_if<(std::is_arithmetic< T1 >::value &&!std::is_same< T1, bool >::value), T1 >::type * = nullptr>

h2d::Circle_< FPT >::Circle_ ( T1  x, T1  y, T2  rad  )

inline

3-arg constructor 1: build circle from 3 floating-point values: x, y, radius

We need Sfinae because there is another 3-args constructor (circle from 3 points)

        : Circle_( Point2d_<FPT>(x,y), rad )
    {
//      HOMOG2D_CHECK_IS_NUMBER(T1); // not needed, done by sfinae above
        HOMOG2D_CHECK_IS_NUMBER(T2);
    }

Circle_() [8/9]

template<typename FPT>

template<typename T1 , typename T2 , typename T3 >

h2d::Circle_< FPT >::Circle_ ( const Point2d_< T1 > &  pt1, const Point2d_< T2 > &  pt2, const Point2d_< T3 > &  pt3  )

inline

3-arg constructor 2: builds a circle from 3 points

    {
        set( pt1, pt2, pt3 );
    }

Circle_() [9/9]

template<typename FPT>

template<typename FPT2 >

h2d::Circle_< FPT >::Circle_ ( const Circle_< FPT2 > &  other )

inline

Copy-Constructor.

        : _radius(other._radius), _center(other._center)
    {}

Member Function Documentation

area()

template<typename FPT>

HOMOG2D_INUMTYPE h2d::Circle_< FPT >::area ( ) const

inlinevirtual

Area of circle.

Implements h2d::rtp::Root.

    {
        return static_cast<HOMOG2D_INUMTYPE>(_radius) * _radius * M_PI;
    }

Here is the caller graph for this function:

center() [1/2]

template<typename FPT>

Point2d_<FPT>& h2d::Circle_< FPT >::center ( )

inline

{ return _center; }

Here is the caller graph for this function:

center() [2/2]

template<typename FPT>

const Point2d_<FPT>& h2d::Circle_< FPT >::center ( ) const

inline

{ return _center; }

draw() [1/2]

template<typename FPT >

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

virtual

Draw Circle (Opencv implementation)

Implements h2d::rtp::Root.

{
    cv::circle(
        im.getReal(),
        _center.getCvPti(),
        static_cast<int>(_radius),
        dp.cvColor(),
        dp._dpValues._lineThickness,
        dp._dpValues._lineType==1?cv::LINE_AA:cv::LINE_8
    );
    if( dp._dpValues._showPoints )
 // WARNING: can't use the "Dot" style here, because it call this function, so infinite recursion
        _center.draw( im, dp.setPointStyle( img::PtStyle::Plus) );
}

Here is the call graph for this function:

Here is the caller graph for this function:

draw() [2/2]

template<typename FPT >

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

virtual

Draw Circle (SVG implementation)

Implements h2d::rtp::Root.

{
    im.getReal()._svgString
        << "<circle cx=\"" << center().getX()
        << "\" cy=\"" << center().getY()
        << "\" r=\"" << radius()
        << "\" stroke=\""
        << dp.getSvgRgbColor()
        << "\" stroke-width=\"" << dp._dpValues._lineThickness << "\" ";
    if( !dp.holdsFill() )
        im.getReal()._svgString << "fill=\"none\" ";
    im.getReal()._svgString << dp.getAttrString()
        << "/>\n";
}

Here is the call graph for this function:

getBB()

template<typename FPT>

auto h2d::Circle_< FPT >::getBB ( ) const

inline

Returns Bounding Box of circle.

    {
        return FRect_<HOMOG2D_INUMTYPE>(
            static_cast<HOMOG2D_INUMTYPE>( _center.getX() ) - _radius,
            static_cast<HOMOG2D_INUMTYPE>( _center.getY() ) - _radius,
            static_cast<HOMOG2D_INUMTYPE>( _center.getX() ) + _radius,
            static_cast<HOMOG2D_INUMTYPE>( _center.getY() ) + _radius
        );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

getCenter()

template<typename FPT>

const Point2d_<FPT>& h2d::Circle_< FPT >::getCenter ( ) const

inline

{ return _center; }

intersects() [1/5]

template<typename FPT>

template<typename FPT2 >

detail::Intersect<detail::Inters_2,FPT> h2d::Circle_< FPT >::intersects ( const Line2d_< FPT2 > &  li ) const

inline

Circle/Line intersection.

    {
        return li.intersects( *this );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

intersects() [2/5]

template<typename FPT>

template<typename FPT2 >

detail::IntersectM<FPT> h2d::Circle_< FPT >::intersects ( const Segment_< FPT2 > &  seg ) const

inline

Circle/Segment intersection.

    {
        return seg.intersects( *this );
    }

Here is the call graph for this function:

intersects() [3/5]

template<typename FPT >

template<typename FPT2 >

detail::IntersectM< FPT > h2d::Circle_< FPT >::intersects

(

const Circle_< FPT2 > &

other

)

const

Circle/Circle intersection.

Ref:

• https://stackoverflow.com/questions/3349125/

Can return 0, 1, or 2 intersection points

Todo:

20230219: in some situation, the difference below (x2 - x1) can be numericaly instable. Check if things would get improved by multiplying first (by a/d and h/d), before proceeding the difference.

{
    if( *this == other )
        return detail::IntersectM<FPT>();

    HOMOG2D_INUMTYPE r1 = _radius;
    HOMOG2D_INUMTYPE r2 = other._radius;
    Point2d_<HOMOG2D_INUMTYPE> pt1 = _center;
    Point2d_<HOMOG2D_INUMTYPE> pt2 = other._center;

    HOMOG2D_INUMTYPE x1 = pt1.getX();
    HOMOG2D_INUMTYPE y1 = pt1.getY();
    HOMOG2D_INUMTYPE x2 = pt2.getX();
    HOMOG2D_INUMTYPE y2 = pt2.getY();
    HOMOG2D_INUMTYPE d_squared = (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2);

    if( d_squared > r1*r1 + r2*r2 + (HOMOG2D_INUMTYPE)2.*r1*r2 )              // no intersection
        return detail::IntersectM<FPT>();

    if( d_squared < ( r1*r1 + r2*r2 - (HOMOG2D_INUMTYPE)2.*r1*r2 ) )          // no intersection: one circle inside the other
        return detail::IntersectM<FPT>();

    auto d = homog2d_sqrt( d_squared );
    auto a = (r1*r1 - r2*r2 + d_squared) / (HOMOG2D_INUMTYPE)2. / d;
    auto h = homog2d_sqrt( r1*r1 - a*a );

    Point2d_<FPT> P0(
        ( x2 - x1 ) * a / d + x1,
        ( y2 - y1 ) * a / d + y1
    );

    Point2d_<FPT> pt3(
        P0.getX() + ( y1 - y2 ) * h / d,
        P0.getY() - ( x1 - x2 ) * h / d
    );
    Point2d_<FPT> pt4(
        P0.getX() - ( y1 - y2 ) * h / d,
        P0.getY() + ( x1 - x2 ) * h / d
    );

    detail::IntersectM<FPT> out;
    out.add( pt3 );
    if( pt3 != pt4 )
        out.add( pt4 );
    return out;
}

Here is the call graph for this function:

intersects() [4/5]

template<typename FPT>

template<typename FPT2 >

detail::IntersectM<FPT> h2d::Circle_< FPT >::intersects ( const FRect_< FPT2 > &  rect ) const

inline

Circle/FRect intersection.

    {
        return rect.intersects( * this );
    }

Here is the call graph for this function:

intersects() [5/5]

template<typename FPT>

template<typename PLT , typename FPT2 >

detail::IntersectM<FPT> h2d::Circle_< FPT >::intersects ( const base::PolylineBase< PLT, FPT2 > &  pl ) const

inline

Circle/Polyline intersection.

    {
        return pl.intersects( * this );
    }

Here is the call graph for this function:

isInside() [1/4]

template<typename FPT>

template<typename FPT2 >

bool h2d::Circle_< FPT >::isInside ( const Circle_< FPT2 > &  other ) const

inline

Returns true if circle is inside other circle.

    {
        return( _radius + _center.distTo( other.center() ) < other.radius() );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

isInside() [2/4]

template<typename FPT>

template<typename FPT2 >

bool h2d::Circle_< FPT >::isInside ( const Point2d_< FPT2 > &  p1, const Point2d_< FPT2 > &  p2  ) const

inline

Returns true if circle is inside rectangle defined by p1 and p2.

    {
        return implC_isInside( detail::getCorrectPoints( p1, p2 ) );
    }

Here is the call graph for this function:

isInside() [3/4]

template<typename FPT>

template<typename FPT2 >

bool h2d::Circle_< FPT >::isInside ( const FRect_< FPT2 > &  rect ) const

inline

Returns true if circle is inside flat rectangle rect.

    {
        return implC_isInside( rect.getPts() );
    }

Here is the call graph for this function:

isInside() [4/4]

template<typename FPT >

template<typename FPT2 , typename PTYPE >

bool h2d::Circle_< FPT >::isInside

(

const base::PolylineBase< PTYPE, FPT2 > &

poly

)

const

Returns true if circle is inside polyline.

Will be true if all these four conditions are met:

• the polyline object must be of type "closed" AND a polygon (no intersection points)
• center point is inside the polygon
• no intersection points
• any point of the polygon must be outside of the circle

{
    HOMOG2D_START;
    if( !poly.isSimple() )
        return false;
    if( poly.getPts()[0].isInside(*this) ) // if a point of the polygon is inside the circle,
        return false;                      //  then the circle cannot be inside the polygon

    if( !_center.isInside( poly ) )
        return false;

    auto inters = intersects( poly );
    return( inters() == 0 );
}

Here is the call graph for this function:

length()

template<typename FPT>

HOMOG2D_INUMTYPE h2d::Circle_< FPT >::length ( ) const

inlinevirtual

Perimeter of circle.

Implements h2d::rtp::Root.

    {
        return static_cast<HOMOG2D_INUMTYPE>(_radius) * M_PI * 2.0;
    }

Here is the caller graph for this function:

moveTo() [1/2]

template<typename FPT>

template<typename TX , typename TY >

void h2d::Circle_< FPT >::moveTo ( TX  x, TY  y  )

inline

Move Circle to other location.

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

Here is the caller graph for this function:

moveTo() [2/2]

template<typename FPT>

template<typename T1 >

void h2d::Circle_< FPT >::moveTo ( const Point2d_< T1 > &  pt )

inline

Move Circle to other location, geiven by pt.

    {
        set( pt );
    }

operator!=()

template<typename FPT>

template<typename FPT2 >

bool h2d::Circle_< FPT >::operator!= ( const Circle_< FPT2 > &  other ) const

inline

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

Here is the call graph for this function:

operator==()

template<typename FPT>

template<typename FPT2 >

bool h2d::Circle_< FPT >::operator== ( const Circle_< FPT2 > &  other ) const

inline

    {
        if( _radius != other._radius )
            return false;
        if( _center != other._center )
            return false;
        return true;
    }

radius() [1/2]

template<typename FPT>

FPT& h2d::Circle_< FPT >::radius ( )

inline

{ return _radius; }

Here is the caller graph for this function:

radius() [2/2]

template<typename FPT>

const FPT& h2d::Circle_< FPT >::radius ( ) const

inline

{ return _radius; }

set() [1/7]

template<typename FPT>

template<typename PT >

void h2d::Circle_< FPT >::set ( const Point2d_< PT > &  center )

inline

Set circle center point, radius unchanged.

    {
        _center = center;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

set() [2/7]

template<typename FPT>

template<typename T , typename std::enable_if<(std::is_arithmetic< T >::value &&!std::is_same< T, bool >::value), T >::type * = nullptr>

void h2d::Circle_< FPT >::set ( T  rad )

inline

Set circle radius, center point unchanged.

Use of Sfinae so it can be selected only for arithmetic types

    {
        _radius = rad;
    }

set() [3/7]

template<typename FPT>

template<typename FPT2 , typename FPT3 >

void h2d::Circle_< FPT >::set ( const Point2d_< FPT2 > &  center, FPT3  rad  )

inline

Set circle from center point and radius.

Todo:

20211216: replace with move

    {
        Circle_<FPT> c( center, rad );
        std::swap( c, *this ); 
    }

set() [4/7]

template<typename FPT>

template<typename FPT2 , typename std::enable_if< std::is_arithmetic< FPT2 >::value, FPT2 >::type * = nullptr>

void h2d::Circle_< FPT >::set ( FPT2  x, FPT2  y, FPT2  rad  )

inline

Set circle from 3 values (x0,y0,radius)

    {
        set( Point2d_<FPT2>(x,y), rad );
    }

set() [5/7]

template<typename FPT >

template<typename T1 , typename T2 >

void h2d::Circle_< FPT >::set	(	const Point2d_< T1 > &	pt1,
		const Point2d_< T2 > &	pt2
	)

Set circle from 2 points.

{
#ifndef HOMOG2D_NOCHECKS
    if( pt1 == pt2 )
        HOMOG2D_THROW_ERROR_1( "Unable, some points are identical" );
#endif

    Segment_<HOMOG2D_INUMTYPE> seg( pt1, pt2 );
    _center = seg.getCenter();
    _radius = seg.length() / 2.0;
}

Here is the call graph for this function:

set() [6/7]

template<typename FPT >

template<typename T1 , typename T2 , typename T3 >

void h2d::Circle_< FPT >::set	(	const Point2d_< T1 > &	pt1,
		const Point2d_< T2 > &	pt2,
		const Point2d_< T3 > &	pt3
	)

Set circle from 3 points.

Algorithm: we get the two largest segments and compute their bisector line. Their intersection point will be the center of circle, and the radius is the distance between center and any of the three points.

We consider the the largest segments to improve numerical stability.

Will throw if unable (numerical issue)

One could think that the first checking would be enough, but experience shows that some times, the point are not colinear, but the two bisector lines are still parallel. Thus the second checking.

Todo:

Check this other technique: https://www.johndcook.com/blog/2023/06/18/circle-through-three-points/

{
#ifndef HOMOG2D_NOCHECKS
    if( areCollinear( pt1, pt2, pt3 ) )
        HOMOG2D_THROW_ERROR_1( "Unable, points are colinear" );
#endif
    auto pts = priv::getLargestDistancePoints( pt1, pt2, pt3 );

    auto seg1 = Segment_<HOMOG2D_INUMTYPE>( pts[0], pts[1] );
    auto seg2 = Segment_<HOMOG2D_INUMTYPE>( pts[0], pts[2] );
    auto li1 = seg1.getBisector();
    auto li2 = seg2.getBisector();
#ifndef HOMOG2D_NOCHECKS
    if( li1.isParallelTo(li2) )
        HOMOG2D_THROW_ERROR_1( "unable, bisector lines are parallel" )
#endif
    center() = li1 * li2;
    radius() = center().distTo(pt1);
}

Here is the call graph for this function:

set() [7/7]

template<typename FPT >

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

void h2d::Circle_< FPT >::set

(

const T &

pts

)

Compute circle from a set of points (Minimum Enclosing Circle, aka MEC) using the Welzl algorithm.

T may be std::vector, std::array or std::list holding points

References:

• https://en.wikipedia.org/wiki/Smallest-circle_problem
• https://www.geeksforgeeks.org/minimum-enclosing-circle-using-welzls-algorithm/

{
    if( pts.size() < 2 )
        HOMOG2D_THROW_ERROR_1( "unable to build a circle from a single point" );

    if( pts.size() == 2 )
    {
        set( pts[0], pts[1] );
        return;
    }

    if( pts.size() == 3 ) // todo: convert pts to HOMOG2D_INUMTYPE
    {
        set( pts[0], pts[1], pts[2] );
        return;
    }

    std::vector<Point2d_<HOMOG2D_INUMTYPE>> P_copy( std::begin(pts), std::end(pts) );
//  std::random_shuffle( P_copy.begin(), P_copy.end() ); // ? check: what happens if removed?
    std::vector<Point2d_<HOMOG2D_INUMTYPE>> R;

    h2d::thr::doNotCheckRadius() = true;
    auto cir = p_WelzlHelper( P_copy, R, P_copy.size() );
    set( cir.center(), cir.radius() );
    h2d::thr::doNotCheckRadius() = false;
}

Here is the call graph for this function:

size()

template<typename FPT>

constexpr size_t h2d::Circle_< FPT >::size ( ) const

inlinevirtual

Implements h2d::rtp::Root.

    {
        return 1;
    }

translate() [1/2]

template<typename FPT>

template<typename TX , typename TY >

void h2d::Circle_< FPT >::translate ( TX  dx, TY  dy  )

inline

Translate Circle.

    {
        HOMOG2D_CHECK_IS_NUMBER( TX );
        HOMOG2D_CHECK_IS_NUMBER( TY );
        _center.translate( dx, dy );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

translate() [2/2]

template<typename FPT>

template<typename T1 , typename T2 >

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

inline

Translate Circle.

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

Here is the call graph for this function:

type()

template<typename FPT>

Type h2d::Circle_< FPT >::type ( ) const

inlinevirtual

Implements h2d::rtp::Root.

    {
        return Type::Circle;
    }

Friends And Related Function Documentation

Circle_

template<typename FPT>

template<typename T >

friend class Circle_

friend

operator<<

template<typename FPT>

template<typename T >

std::ostream& operator<< ( std::ostream &  f, const Circle_< T > &  r  )

friend

{
    f << "center: " << r._center << ", radius=" << r._radius;
    return f;
}

---

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

• homog2d.hpp