The function computes a minimum area enclosing rectangle R(P) of a given convex point set P. Note that R(P) is not necessarily axis-parallel, and it is in general not unique. The focus on convex sets is no restriction, since any rectangle enclosing P - as a convex set - contains the convex hull of P. For general point sets one has to compute the convex hull as a preprocessing step.

#include <CGAL/min_quadrilateral_2.h>

template < class ForwardIterator, class OutputIterator, class Traits >
min_rectangle_2 (
ForwardIterator points_begin,
ForwardIterator points_end,
OutputIterator o,
Traits& t = Default_traits)

computes a minimum area enclosing rectangle of the point set described by [points_begin, points_end), writes its vertices (counterclockwise) to o, and returns the past-the-end iterator of this sequence.
If the input range is empty, o remains unchanged.
If the input range consists of one element only, this point is written to o four times.

Precondition: The points denoted by the range [points_begin, points_end) form the boundary of a simple convex polygon P in counterclockwise orientation.

The geometric types and operations to be used for the computation are specified by the traits class parameter t. The parameter can be omitted, if ForwardIterator refers to a two-dimensional point type from one the CGAL Kernels. In this case, a default traits class (Min_quadrilateral_default_traits_2<Kernel>) is used.


  1. If Traits is specified, it is a model for MinQuadrilateralTraits_2 and the value type VT of ForwardIterator is Traits::Point_2. Otherwise VT is CGAL::Point_2<Kernel> for some kernel Kernel.
  2. OutputIterator accepts VT as value type.

See Also



We use a rotating caliper algorithm [Tou83] with worst case running time linear in the number of input points.


The following code generates a random convex polygon P with 20 vertices and computes the minimum enclosing rectangle of P.

#include <CGAL/Cartesian.h>
#include <CGAL/Polygon_2.h>
#include <CGAL/point_generators_2.h>
#include <CGAL/random_convex_set_2.h>
#include <CGAL/min_quadrilateral_2.h>
#include <iostream>

struct Kernel : public CGAL::Cartesian<double> {};

typedef Kernel::Point_2                           Point_2;
typedef Kernel::Line_2                            Line_2;
typedef CGAL::Polygon_2<Kernel>                   Polygon_2;
typedef CGAL::Random_points_in_square_2<Point_2>  Generator;

int main()
  // build a random convex 20-gon p
  Polygon_2 p;
  CGAL::random_convex_set_2(20, std::back_inserter(p), Generator(1.0));
  std::cout << p << std::endl;

  // compute the minimal enclosing rectangle p_m of p
  Polygon_2 p_m;
    p.vertices_begin(), p.vertices_end(), std::back_inserter(p_m));
  std::cout << p_m << std::endl;

  return 0;