An object of the class Min_circle_2<Traits> is the unique circle of smallest area enclosing a finite (multi)set of points in twodimensional Euclidean space ^{2}. For a point set P we denote by mc(P) the smallest circle that contains all points of P. Note that mc(P) can be degenerate, i.e. mc(P)=∅ if P=∅ and mc(P)={p} if P={p}.
An inclusionminimal subset S of P with mc(S)=mc(P) is called a support set, the points in S are the support points. A support set has size at most three, and all its points lie on the boundary of mc(P). In general, neither the support set nor its size are necessarily unique.
The underlying algorithm can cope with all kinds of input, e.g. P may be empty or points may occur more than once. The algorithm computes a support set S which remains fixed until the next insert or clear operation.
Please note: This class is (almost) obsolete. The class CGAL::Min_sphere_of_spheres_d<Traits> solves a more general problem and is faster then Min_circle_2<Traits> even if used only for points in two dimensions as input. Most importantly, CGAL::Min_sphere_of_spheres_d<Traits> has a specialized implementation for floatingpoint arithmetic which ensures correct results in a large number of cases (including highly degenerate ones). In contrast, Min_circle_2<Traits> is not tuned for floatingpoint computations. The only advantage of Min_circle_2<Traits> over CGAL::Min_sphere_of_spheres_d<Traits> is that the former can deal with points in homogeneous coordinates, in which case the algorithm is divisionfree. Thus, Min_circle_2<Traits> might still be an option in case your input number type cannot (efficiently) divide.
#include <CGAL/Min_circle_2.h>
The template parameter Traits is a model for MinCircle2Traits.
We provide the model CGAL::Min_circle_2_traits_2 using the twodimensional Cgal kernel.
A Min_circle_2<Traits> object can be created from an arbitrary point set P and by specialized construction methods expecting no, one, two or three points as arguments. The latter methods can be useful for reconstructing mc(P) from a given support set S of P.
template < class InputIterator >  
 
initializes min_circle to mc(P) with P being the set of points
in the range [first,last). If randomize is
true, a random permutation of P is computed in
advance, using the random numbers generator random.
Usually, this will not be necessary, however, the algorithm's
efficiency depends on the order in which the points are
processed, and a bad order might lead to extremely poor
performance (see example below).
 
Min_circle_2<Traits> min_circle ( Traits traits = Traits());  
initializes min_circle to
mc(∅), the empty set.
 
Min_circle_2<Traits> min_circle ( Point p, Traits traits = Traits());  
initializes min_circle to mc({p}), the set {p}.
 
Min_circle_2<Traits> min_circle ( Point p1, Point p2, Traits traits = Traits());  
initializes min_circle to mc({p1,p2}), the circle with diameter
equal to the segment connecting p1 and p2.
 
Min_circle_2<Traits> min_circle ( Point p1, Point p2, Point p3, Traits traits = Traits());  
initializes min_circle to mc({p1,p2,p3}).

int  min_circle.number_of_points () const  
returns the number of points of min_circle, i.e. P.  
int  min_circle.number_of_support_points () const  
returns the number of support points of min_circle, i.e. S.  
Point_iterator  min_circle.points_begin () const  returns an iterator referring to the first point of min_circle.  
Point_iterator  min_circle.points_end () const  returns the corresponding pasttheend iterator.  
Support_point_iterator  min_circle.support_points_begin () const  
returns an iterator referring to the first support point of min_circle.  
Support_point_iterator  min_circle.support_points_end () const  
returns the corresponding pasttheend iterator.  
Point  min_circle.support_point ( int i) const  
returns the ith support point of min_circle. Between two
modifying operations (see below) any call to
min_circle.support_point(i) with the same i returns
the same point.
 
Circle  min_circle.circle () const  returns the current circle of min_circle. 
By definition, an empty Min_circle_2<Traits> has no boundary and no bounded side, i.e. its unbounded side equals the whole space ^{2}.
CGAL::Bounded_side  min_circle.bounded_side ( Point p) const  
returns CGAL::ON_BOUNDED_SIDE, CGAL::ON_BOUNDARY, or CGAL::ON_UNBOUNDED_SIDE iff p lies properly inside, on the boundary of, or properly outside of min_circle, resp.  
bool  min_circle.has_on_bounded_side ( Point p) const  
returns true, iff p lies properly inside min_circle.  
bool  min_circle.has_on_boundary ( Point p) const  
returns true, iff p lies on the boundary of min_circle.  
bool  min_circle.has_on_unbounded_side ( Point p) const  
returns true, iff p lies properly outside of min_circle.  
bool  min_circle.is_empty () const  returns true, iff min_circle is empty (this implies degeneracy). 
bool  min_circle.is_degenerate () const  returns true, iff min_circle is degenerate, i.e. if min_circle is empty or equal to a single point, equivalently if the number of support points is less than 2. 
New points can be added to an existing min_circle, allowing to build mc(P) incrementally, e.g. if P is not known in advance. Compared to the direct creation of mc(P), this is not much slower, because the construction method is incremental itself.
void  min_circle.insert ( Point p)  inserts p into min_circle and recomputes the smallest enclosing circle.  
template < class InputIterator >  
void  min_circle.insert ( InputIterator first, InputIterator last)  
inserts the points in the range [first,last)
into min_circle and recomputes the smallest enclosing circle by
calling insert(p) for each point p in
[first,last).
 
void  min_circle.clear () 
deletes all points in min_circle and sets min_circle to the empty set.

An object min_circle is valid, iff
bool  min_circle.is_valid ( bool verbose = false, int level = 0) const  
returns true, iff min_circle is valid. If verbose is true, some messages concerning the performed checks are written to standard error stream. The second parameter level is not used, we provide it only for consistency with interfaces of other classes. 
const Traits&  min_circle.traits () const  returns a const reference to the traits class object. 
std::ostream&  std::ostream& os << min_circle 
writes min_circle to output stream os.

std::istream&  std::istream& is >> min_circle& 
reads min_circle from input stream is.

CGAL::Min_ellipse_2<Traits>
CGAL::Min_sphere_d<Traits>
CGAL::Min_sphere_of_spheres_d<Traits>
CGAL::Min_circle_2_traits_2<K>
MinCircle2Traits
We implement the incremental algorithm of Welzl, with movetofront heuristic [Wel91]. The whole implementation is described in [GS98a].
If randomization is chosen, the creation time is almost always linear in the number of points. Access functions and predicates take constant time, inserting a point might take up to linear time, but substantially less than computing the new smallest enclosing circle from scratch. The clear operation and the check for validity each takes linear time.
To illustrate the creation of Min_circle_2<Traits> and to show that randomization can be useful in certain cases, we give an example.
File: examples/Min_circle_2/min_circle_2.cpp
#include <CGAL/Exact_predicates_exact_constructions_kernel.h> #include <CGAL/Min_circle_2.h> #include <CGAL/Min_circle_2_traits_2.h> #include <iostream> // typedefs typedef CGAL::Exact_predicates_exact_constructions_kernel K; typedef CGAL::Min_circle_2_traits_2<K> Traits; typedef CGAL::Min_circle_2<Traits> Min_circle; typedef K::Point_2 Point; int main( int, char**) { const int n = 100; Point P[n]; for ( int i = 0; i < n; ++i) P[ i] = Point( (i%2 == 0 ? i : i), 0); // (0,0), (1,0), (2,0), (3,0), ... Min_circle mc1( P, P+n, false); // very slow Min_circle mc2( P, P+n, true); // fast CGAL::set_pretty_mode( std::cout); std::cout << mc2; return 0; }