The function rectangular_p_center_2 computes rectilinear p-centers of a planar point set, i.e. a set of p points such that the maximum minimal L -distance between both sets is minimized.

More formally the problem can be defined as follows.

Given a finite set tex2html_wrap_inline17 of points, compute a point set tex2html_wrap_inline19 with tex2html_wrap_inline21 such that the p-radius of tex2html_wrap_inline17 ,


is minimized. We can interpret tex2html_wrap_inline19 as the best approximation (with respect to the given metric) for tex2html_wrap_inline17 with at most p points.

#include <CGAL/rectangular_p_center_2.h>

template < class ForwardIterator, class OutputIterator, class FT, class Traits >
rectangular_p_center_2 (
ForwardIterator f,
ForwardIterator l,
OutputIterator o,
FT& r,
int p,
Traits t = Default_traits)

computes rectilinear p-centers for the point set described by the range [f, l), sets r to the corresponding p-radius, writes the at most p center points to o and returns the past-the-end iterator of this sequence.


  1. The range [f, l) is not empty.
  2. 2 p 4.

The geometric types and operations to be used for the computation are specified by the traits class parameter t. This parameter can be omitted if ForwardIterator refers to a point type from the 2D-Kernel. In this case, a default traits class (Rectangular_p_center_default_traits_2<K>) is used.


  1. Either: (if no traits parameter is given) Value type of ForwardIterator is CGAL::Point_2<K> for some representation class K and FT is equivalent to K::FT,
  2. Or: (if a traits parameter is specified) Traits is a model for RectangularPCenterTraits_2.
  3. OutputIterator accepts the value type of ForwardIterator as value type.

See Also



The runtime is linear for p in {2,3} and (n · logn) for p = 4 where n is the number of input points. These runtimes are worst case optimal. The 3-center algorithm uses a prune-and-search technique described in [Hof99]. The 4-center implementation uses sorted matrix search [FJ83, FJ84] and fast algorithms for piercing rectangles [SW96].


The following code generates a random set of ten points and computes its two-centers.

File: examples/Matrix_search/rectangular_p_center_2.cpp
#include <CGAL/Cartesian.h>
#include <CGAL/point_generators_2.h>
#include <CGAL/rectangular_p_center_2.h>
#include <CGAL/IO/Ostream_iterator.h>
#include <CGAL/algorithm.h>
#include <iostream>
#include <algorithm>
#include <vector>

typedef double                                      FT;

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

typedef Kernel::Point_2                             Point;
typedef std::vector<Point>                          Cont;
typedef CGAL::Random_points_in_square_2<Point>      Generator;
typedef CGAL::Ostream_iterator<Point,std::ostream>  OIterator;

int main()
  int n = 10;
  int p = 2;
  OIterator cout_ip(std::cout);

  Cont points;
  CGAL::copy_n(Generator(1), n, std::back_inserter(points));
  std::cout << "Generated Point Set:\n";
  std::copy(points.begin(), points.end(), cout_ip);

  FT p_radius;
  std::cout << "\n\n" << p << "-centers:\n";
    points.begin(), points.end(), cout_ip, p_radius, 3);
  std::cout << "\n\n" << p << "-radius = " << p_radius << std::endl;

  return 0;
// ----------------------------------------------------------------------------
// ** EOF
// ----------------------------------------------------------------------------