Tulip  5.2.0
Large graphs analysis and drawing
Circle.cxx
1 /*
2  *
3  * This file is part of Tulip (http://tulip.labri.fr)
4  *
5  * Authors: David Auber and the Tulip development Team
6  * from LaBRI, University of Bordeaux
7  *
8  * Tulip is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU Lesser General Public License
10  * as published by the Free Software Foundation, either version 3
11  * of the License, or (at your option) any later version.
12  *
13  * Tulip is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
16  * See the GNU General Public License for more details.
17  *
18  */
19 #include <cstdlib>
20 #include <tulip/TlpTools.h>
21 
22 template <typename Obj, typename OTYPE>
23 tlp::Circle<Obj, OTYPE> &tlp::Circle<Obj, OTYPE>::merge(const tlp::Circle<Obj, OTYPE> &c) {
24  Vector<Obj, 2, OTYPE> p1(*this);
25  Vector<Obj, 2, OTYPE> p2(c);
26  Vector<Obj, 2, OTYPE> c12 = p2 - p1;
27  double norm = c12.norm();
28 
29  if (norm < 0.0000001) {
30  if (radius < c.radius)
31  return (*this) = c;
32  else
33  return *this;
34  }
35 
36  double dx = c12[0] / norm;
37  double dy = c12[1] / norm;
38  p1[0] -= dx * radius;
39  p1[1] -= dy * radius;
40  p2[0] += dx * c.radius;
41  p2[1] += dy * c.radius;
42  Obj tmpDist = p1.dist(p2) / 2.;
43 
44  if ((tmpDist < radius) || (tmpDist < c.radius)) {
45  if (radius > c.radius)
46  return *this;
47  else
48  return (*this) = c;
49  } else {
50  p1 += p2;
51  p1 /= 2.;
52  (*this)[0] = p1[0];
53  (*this)[1] = p1[1];
54  radius = tmpDist;
55  return *this;
56  }
57 }
58 
59 template <typename Obj, typename OTYPE>
60 bool tlp::Circle<Obj, OTYPE>::isIncludeIn(const tlp::Circle<Obj, OTYPE> &c) const {
61  Vector<Obj, 2, OTYPE> dir = c - *this;
62  return (dir.norm() + radius) <= c.radius;
63 }
64 
65 template <typename Obj, typename OTYPE>
66 tlp::Circle<Obj, OTYPE> tlp::enclosingCircle(const tlp::Circle<Obj, OTYPE> &c1,
67  const tlp::Circle<Obj, OTYPE> &c2) {
68  Vector<Obj, 2, OTYPE> dir = c2 - c1;
69  Obj n = dir.norm();
70 
71  if (n == 0)
72  return Circle<Obj, OTYPE>(c1, std::max(c1.radius, c2.radius));
73 
74  dir /= n;
75  Vector<Obj, 2, OTYPE> ext1 = c1 - dir * c1.radius;
76  Vector<Obj, 2, OTYPE> ext2 = c2 + dir * c2.radius;
77  return Circle<Obj, OTYPE>((ext1 + ext2) / Obj(2), (ext2 - ext1).norm() / Obj(2));
78 }
79 
80 template <typename Obj, typename OTYPE>
81 tlp::Circle<Obj, OTYPE>
82 tlp::lazyEnclosingCircle(const std::vector<tlp::Circle<Obj, OTYPE>> &circles) {
83  // compute bounding box of a
84  tlp::Vector<Obj, 4, OTYPE> boundingBox;
85  // for (int i=0;i<4;++i) boundingBox[i]=0;
86  typename std::vector<tlp::Circle<Obj, OTYPE>>::const_iterator it = circles.begin();
87  boundingBox[0] = (*it)[0] - (*it).radius;
88  boundingBox[1] = (*it)[1] - (*it).radius;
89  boundingBox[2] = (*it)[0] + (*it).radius;
90  boundingBox[3] = (*it)[1] + (*it).radius;
91  ++it;
92 
93  for (; it != circles.end(); ++it) {
94  boundingBox[0] = std::min(boundingBox[0], ((*it)[0] - (*it).radius));
95  boundingBox[1] = std::min(boundingBox[1], ((*it)[1] - (*it).radius));
96  boundingBox[2] = std::max(boundingBox[2], ((*it)[0] + (*it).radius));
97  boundingBox[3] = std::max(boundingBox[3], ((*it)[1] + (*it).radius));
98  }
99 
100  tlp::Vector<Obj, 2, OTYPE> center;
101  center[0] = (boundingBox[0] + boundingBox[2]) / 2.;
102  center[1] = (boundingBox[1] + boundingBox[3]) / 2.;
103  Obj radius =
104  std::max((boundingBox[2] - boundingBox[0]) / 2., (boundingBox[3] - boundingBox[1]) / 2.);
105  tlp::Circle<Obj, OTYPE> result(center, radius);
106 
107  // compute circle hull
108  for (typename std::vector<tlp::Circle<Obj, OTYPE>>::const_iterator it = circles.begin();
109  it != circles.end(); ++it)
110  result.merge(*it);
111 
112  return result;
113 }
114 
115 template <typename Obj, typename OTYPE>
116 tlp::Circle<Obj, OTYPE> tlp::enclosingCircle(const std::vector<tlp::Circle<Obj, OTYPE>> &circles) {
117  class OptimumCircleHull {
118  const std::vector<tlp::Circle<Obj, OTYPE>> *circles;
119  std::vector<unsigned> enclosedCircles;
120  unsigned first, last;
121  unsigned b1, b2;
122  tlp::Circle<Obj, OTYPE> result;
123 
124  static tlp::Circle<Obj, OTYPE> enclosingCircle(const tlp::Circle<Obj, OTYPE> &c1,
125  const tlp::Circle<Obj, OTYPE> &c2,
126  const tlp::Circle<Obj, OTYPE> &c3) {
127  Obj a1 = c1[0];
128  Obj b1 = c1[1];
129  Obj r1 = c1.radius;
130  Obj a2 = c2[0];
131  Obj b2 = c2[1];
132  Obj r2 = c2.radius;
133  Obj a3 = c3[0];
134  Obj b3 = c3[1];
135  Obj r3 = c3.radius;
136  Obj b = -b1 * r2 * a1 * a1 * b3 + a3 * a3 * r2 * r2 * r2 + b2 * b2 * r3 * r3 * r3 +
137  b1 * b1 * r3 * r3 * r3 + b1 * b1 * r2 * r2 * r2 + r1 * r1 * r1 * b3 * b3 +
138  r1 * r1 * r1 * b2 * b2 + r2 * r2 * r2 * b3 * b3 + a1 * a1 * r3 * r3 * r3 +
139  a2 * a2 * r1 * r1 * r1 + a2 * a2 * r3 * r3 * r3 + a1 * a1 * r2 * r2 * r2 +
140  a3 * a3 * r1 * r1 * r1 - b2 * b2 * r3 * a3 * a3 - b2 * b2 * r3 * b3 * b3 -
141  2 * b2 * r3 * r3 * r3 * b1 - b1 * b1 * r3 * a3 * a3 - b1 * b1 * r3 * b3 * b3 -
142  b1 * b1 * r2 * a2 * a2 + 2 * b1 * b1 * r2 * b3 * b3 - b1 * b1 * r2 * r3 * r3 -
143  r1 * b3 * b3 * b3 * b2 + r1 * b3 * b3 * b3 * b1 + 2 * r1 * b2 * b2 * b3 * b3 -
144  r1 * b2 * b2 * r3 * r3 + r2 * b3 * b3 * b3 * b2 - r2 * b3 * b3 * b3 * b1 -
145  b2 * b2 * b2 * r3 * b1 + 2 * b2 * b2 * r3 * b1 * b1 + b2 * b2 * b2 * r3 * b3 -
146  b2 * b2 * r3 * r1 * r1 + b1 * b1 * b1 * r3 * b3 - b1 * b1 * b1 * r3 * b2 -
147  b1 * b1 * r3 * r2 * r2 - b1 * b1 * r2 * b2 * b2 - b1 * b1 * b1 * r2 * b3 +
148  b1 * b1 * b1 * r2 * b2 - 2 * b1 * r2 * r2 * r2 * b3 - r1 * b3 * b3 * b1 * b1 -
149  2 * r1 * r1 * r1 * b3 * b2 - r1 * b3 * b3 * r2 * r2 - r1 * b3 * b3 * a1 * a1 +
150  r1 * b2 * b2 * b2 * b1 - r1 * b2 * b2 * b1 * b1 - r1 * b2 * b2 * b2 * b3 -
151  r1 * b2 * b2 * a1 * a1 - r2 * b3 * b3 * a2 * a2 - r2 * b3 * b3 * b2 * b2 -
152  r2 * b3 * b3 * r1 * r1 - b2 * r3 * b1 * b1 * b3 + b2 * r3 * a2 * a2 * b3 +
153  b2 * r3 * r1 * r1 * b3 - b2 * r3 * r2 * r2 * b3 + b2 * r3 * a1 * a1 * b3 -
154  2 * b2 * r3 * a1 * a2 * b3 + a1 * a3 * b2 * b2 * r3 - 2 * a1 * a3 * b2 * b1 * r3 -
155  2 * a1 * a3 * b2 * b1 * r2 - 2 * a1 * a3 * b2 * r1 * b3 + a1 * a3 * b2 * b2 * r1 -
156  2 * a1 * a3 * b2 * r2 * b3 - b2 * r3 * b1 * a2 * a2 + 2 * b2 * r3 * b1 * a3 * a3 +
157  2 * b2 * r3 * b1 * b3 * b3 + b1 * r2 * b2 * a3 * a3 - b1 * r2 * b2 * b3 * b3 +
158  b1 * r2 * b2 * r3 * r3 + r1 * b3 * b1 * a2 * a2 - r1 * b3 * b2 * a3 * a3 +
159  r1 * b3 * b2 * r3 * r3 + r1 * b3 * b1 * a3 * a3 - r1 * b3 * b1 * r3 * r3 +
160  r1 * b2 * b1 * a2 * a2 + r1 * b2 * b1 * a3 * a3 - r1 * b2 * b1 * b3 * b3 +
161  r1 * b2 * b1 * r3 * r3 + 2 * r2 * b3 * b1 * a2 * a2 + r2 * b3 * b2 * a3 * a3 -
162  r2 * b3 * b2 * r3 * r3 - r2 * b3 * b1 * a3 * a3 + r2 * b3 * b1 * r3 * r3 +
163  b2 * r3 * b1 * r2 * r2 + 4 * b2 * r3 * a1 * a2 * b1 + b1 * r3 * a2 * a2 * b3 -
164  b1 * r3 * b2 * b2 * b3 - b1 * r3 * r1 * r1 * b3 + b1 * r3 * r1 * r1 * b2 +
165  b1 * r3 * r2 * r2 * b3 + b1 * r3 * a1 * a1 * b3 - b1 * r3 * a1 * a1 * b2 -
166  2 * b1 * r3 * a1 * a2 * b3 - b1 * b1 * r3 * a1 * a2 + b1 * b1 * r3 * a1 * a3 +
167  2 * b1 * r2 * b2 * b2 * b3 + b1 * r2 * r1 * r1 * b3 - b1 * r2 * r1 * r1 * b2 +
168  b1 * r2 * a1 * a1 * b2 - 2 * b1 * r2 * a1 * a2 * b3 + b1 * b1 * r2 * a1 * a2 -
169  b1 * b1 * r2 * a1 * a3 - r1 * b3 * b1 * b2 * b2 + 2 * r1 * b3 * b1 * b1 * b2 +
170  2 * r1 * b3 * a1 * a1 * b2 + r1 * b3 * b1 * r2 * r2 + r1 * b3 * b3 * a1 * a2 -
171  r1 * b2 * a2 * a2 * b3 + r1 * b2 * r2 * r2 * b3 - r1 * b2 * b1 * r2 * r2 -
172  2 * r1 * b2 * a1 * a2 * b3 - r2 * b3 * b1 * b1 * b2 + r2 * b3 * r1 * r1 * b2 +
173  r2 * b3 * a1 * a1 * b2 + r2 * b3 * b3 * a1 * a2 + 4 * r2 * b3 * a1 * a3 * b1 -
174  a1 * a1 * a3 * a3 * r3 + 2 * a1 * a1 * a3 * a3 * r2 + a1 * a3 * a3 * a3 * r1 -
175  a1 * a1 * b3 * b3 * r3 - a1 * b3 * b3 * a3 * r2 + a1 * r3 * r3 * a3 * r2 -
176  a2 * a1 * a1 * a3 * r2 + a2 * b1 * b1 * a3 * r2 + a2 * b3 * b3 * a3 * r2 -
177  a1 * a3 * a3 * a2 * r1 + 2 * a1 * a3 * a3 * a2 * r3 + 2 * a1 * b3 * b3 * a2 * r3 +
178  a1 * b3 * b3 * a3 * r1 - 2 * a1 * r3 * r3 * r3 * a2 - a1 * a1 * r3 * r3 * r2 -
179  a2 * a1 * a1 * a1 * r3 - a2 * a2 * a1 * a1 * r1 + 2 * a2 * a2 * a1 * a1 * r3 +
180  a2 * a1 * a1 * a1 * r2 - a2 * a2 * b1 * b1 * r1 + 2 * a2 * a2 * a3 * a3 * r1 -
181  a2 * a2 * a3 * a3 * r3 - a2 * a3 * a3 * a3 * r1 - a2 * a2 * b3 * b3 * r3 -
182  a2 * a2 * r1 * r1 * r3 - 2 * a2 * r1 * r1 * r1 * a3 + a1 * r3 * r3 * a2 * r1 -
183  a1 * r3 * r3 * a3 * r1 + 2 * a2 * a1 * a1 * a3 * r1 + 2 * a2 * b1 * b1 * a3 * r1 -
184  a2 * a3 * a3 * a1 * r2 - a2 * b3 * b3 * a3 * r1 + a2 * r1 * r1 * a1 * r3 -
185  a2 * r1 * r1 * a1 * r2 - a2 * a2 * r3 * r3 * r1 - a1 * a3 * a3 * a3 * r2 +
186  a2 * a3 * a3 * a3 * r2 - a1 * a1 * r3 * r2 * r2 + a1 * a1 * a1 * r3 * a3 +
187  a2 * a2 * a2 * r1 * a1 - a2 * a2 * a2 * r1 * a3 - a2 * a2 * a2 * r3 * a1 +
188  a2 * a2 * a2 * r3 * a3 - a1 * a1 * r2 * a2 * a2 - a1 * a1 * r2 * b2 * b2 -
189  a1 * a1 * a1 * r2 * a3 - 2 * a1 * r2 * r2 * r2 * a3 - a3 * a3 * r1 * a1 * a1 -
190  a3 * a3 * r1 * b1 * b1 - a3 * a3 * r1 * r2 * r2 - a3 * a3 * r2 * a2 * a2 -
191  a3 * a3 * r2 * b2 * b2 - a3 * a3 * r2 * r1 * r1 + a2 * r3 * r3 * a1 * r2 +
192  a2 * r3 * r3 * a3 * r1 - 2 * a3 * r2 * b1 * a2 * b3 + a2 * r1 * r1 * a3 * r2 -
193  a2 * r3 * r3 * a3 * r2 - a1 * r3 * a3 * a2 * a2 - a1 * r3 * a3 * r1 * r1 +
194  a1 * r3 * a3 * r2 * r2 + a2 * r1 * a1 * b2 * b2 - a2 * r1 * a1 * r2 * r2 -
195  a2 * r1 * a3 * b2 * b2 + a2 * r1 * a3 * r2 * r2 - 2 * a2 * r1 * b1 * a3 * b2 -
196  a2 * r3 * a1 * b2 * b2 + a2 * r3 * a1 * r2 * r2 - a2 * r3 * a3 * a1 * a1 +
197  a2 * r3 * a3 * b1 * b1 + a2 * r3 * a3 * b2 * b2 + a2 * r3 * a3 * r1 * r1 -
198  a2 * r3 * a3 * r2 * r2 - 2 * a2 * r3 * b1 * a3 * b2 + 2 * a1 * r2 * a3 * a2 * a2 +
199  2 * a1 * r2 * a3 * b2 * b2 + a1 * r2 * a3 * r1 * r1 - a3 * r1 * a1 * a2 * a2 +
200  a3 * r1 * a1 * r2 * r2 - 2 * a3 * r1 * b1 * a2 * b3 + 4 * r1 * a3 * b2 * a2 * b3;
201  Obj tmp = a2 * b3 - a3 * b2 - a2 * b1 - a1 * b3 + a1 * b2 + a3 * b1;
202  Obj d = sqrt((a2 * a2 + b2 * b2 - r2 * r2 - 2 * a2 * a3 + a3 * a3 - r3 * r3 - 2 * b3 * b2 +
203  b3 * b3 + 2 * r3 * r2) *
204  (b3 * b3 + b1 * b1 - r1 * r1 - r3 * r3 - 2 * b1 * b3 + 2 * r3 * r1 + a3 * a3 -
205  2 * a1 * a3 + a1 * a1) *
206  (a1 * a1 - 2 * a1 * a2 - r1 * r1 + b1 * b1 + b2 * b2 - r2 * r2 - 2 * b2 * b1 +
207  2 * r2 * r1 + a2 * a2) *
208  tmp * tmp);
209  Obj v = d - b;
210 
211  if (v < 0)
212  return tlp::Circle<Obj, OTYPE>(0, 0, 0);
213 
214  Obj aa = -2 * a3 * b2 * b2 * a1 - 2 * a2 * b3 * b3 * a1 - 2 * a1 * a1 * b3 * b2 +
215  a3 * a3 * b2 * b2 + a2 * a2 * b3 * b3 - r1 * r1 * b3 * b3 - r1 * r1 * b2 * b2 +
216  a2 * a2 * b1 * b1 + a3 * a3 * b1 * b1 - a2 * a2 * r1 * r1 - a2 * a2 * r3 * r3 -
217  a3 * a3 * r2 * r2 - 2 * a3 * b2 * a2 * b3 + 2 * a3 * b2 * a2 * b1 +
218  2 * a2 * b3 * a3 * b1 - 2 * b1 * a2 * a2 * b3 - a3 * a3 * r1 * r1 -
219  2 * a3 * a3 * b2 * b1 + 2 * b1 * r3 * r3 * b2 + 2 * r1 * r1 * b3 * b2 +
220  2 * b3 * b1 * r2 * r2 - 2 * a2 * b1 * b1 * a3 + 2 * a2 * a3 * r1 * r1 -
221  b2 * b2 * r3 * r3 - b1 * b1 * r3 * r3 - b1 * b1 * r2 * r2 - r2 * r2 * b3 * b3 -
222  a1 * a1 * r3 * r3 - a1 * a1 * r2 * r2 + a1 * a1 * b3 * b3 + a1 * a1 * b2 * b2 +
223  2 * b2 * b2 * r3 * r1 + 2 * b1 * b1 * r3 * r2 + 2 * r1 * b3 * b3 * r2 -
224  2 * b2 * r3 * b1 * r2 - 2 * b2 * r3 * r1 * b3 + 2 * b2 * r3 * r2 * b3 +
225  2 * b1 * r3 * r1 * b3 - 2 * b1 * r3 * r1 * b2 - 2 * b1 * r3 * r2 * b3 -
226  2 * b1 * r2 * r1 * b3 + 2 * b1 * r2 * r1 * b2 - 2 * r1 * b2 * r2 * b3 +
227  2 * a1 * r3 * r3 * a2 + 2 * a1 * a1 * r3 * r2 + 2 * a2 * a2 * r1 * r3 +
228  2 * a1 * r2 * r2 * a3 + 2 * a3 * a3 * r1 * r2 - 2 * a1 * r3 * a2 * r1 +
229  2 * a1 * r3 * a3 * r1 + 2 * a2 * r1 * a1 * r2 - 2 * a2 * r3 * a1 * r2 -
230  2 * a2 * r3 * a3 * r1 - 2 * a1 * r2 * a3 * r1 - 2 * a1 * r3 * a3 * r2 -
231  2 * a2 * r1 * a3 * r2 + 2 * a2 * r3 * a3 * r2 + 2 * a2 * b3 * a1 * b2 +
232  2 * a3 * b2 * a1 * b3 + 2 * a2 * b1 * a1 * b3 - 2 * a2 * b1 * a1 * b2 -
233  2 * a1 * b3 * a3 * b1 + 2 * a1 * b2 * a3 * b1;
234  Obj R = 0.5 * v / aa;
235  Obj y = -0.5 * (-2 * a1 * R * r2 - 2 * a3 * R * r1 + 2 * a2 * R * r1 + 2 * a3 * R * r2 -
236  2 * a2 * R * r3 + a1 * a3 * a3 + a1 * b3 * b3 - a1 * r3 * r3 + a2 * a1 * a1 +
237  a2 * b1 * b1 + a1 * r2 * r2 + 2 * a1 * R * r3 - a3 * b1 * b1 + a3 * a2 * a2 +
238  a3 * b2 * b2 + a3 * r1 * r1 - a3 * r2 * r2 - a2 * a3 * a3 - a2 * b3 * b3 -
239  a2 * r1 * r1 + a2 * r3 * r3 - a1 * a2 * a2 - a1 * b2 * b2 - a3 * a1 * a1) /
240  (a2 * b3 + a3 * b1 - a2 * b1 - a1 * b3 + a1 * b2 - a3 * b2);
241  Obj x = 0.5 * (-a1 * a1 * b3 + a1 * a1 * b2 + 2 * R * r2 * b3 + b1 * a3 * a3 + b1 * b3 * b3 +
242  2 * b1 * R * r3 - 2 * R * r1 * b3 + 2 * R * r1 * b2 + b1 * r2 * r2 -
243  b2 * a3 * a3 - b2 * b3 * b3 + b2 * r3 * r3 - 2 * b2 * R * r3 - b1 * r3 * r3 -
244  r2 * r2 * b3 + a2 * a2 * b3 - r1 * r1 * b2 - b1 * b2 * b2 + b1 * b1 * b2 -
245  b1 * b1 * b3 - b1 * a2 * a2 + b2 * b2 * b3 + r1 * r1 * b3 - 2 * b1 * R * r2) /
246  (a2 * b3 + a3 * b1 - a2 * b1 - a1 * b3 + a1 * b2 - a3 * b2);
247  return tlp::Circle<Obj, OTYPE>(x, y, R);
248  }
249 
250  void process2() {
251  if (isEmpty()) {
252  result = tlp::enclosingCircle((*circles)[b1], (*circles)[b2]);
253  } else {
254  unsigned selectedCircle = popBack();
255  process2();
256 
257  if (!(*circles)[selectedCircle].isIncludeIn(result)) {
258  result = enclosingCircle((*circles)[b1], (*circles)[b2], (*circles)[selectedCircle]);
259  pushFront(selectedCircle);
260  } else {
261  pushBack(selectedCircle);
262  }
263  }
264  }
265 
266  void process1() {
267  if (isEmpty()) {
268  result = (*circles)[b1];
269  } else {
270  unsigned selectedCircle = popBack();
271  process1();
272 
273  if (!(*circles)[selectedCircle].isIncludeIn(result)) {
274  b2 = selectedCircle;
275  process2();
276  pushFront(selectedCircle);
277  } else {
278  pushBack(selectedCircle);
279  }
280  }
281  }
282  void process0() {
283  if (isEmpty()) {
284  result = Circle<Obj, OTYPE>(0, 0, 0);
285  } else {
286  unsigned selectedCircle = popBack();
287  process0();
288 
289  if (!(*circles)[selectedCircle].isIncludeIn(result)) {
290  b1 = selectedCircle;
291  process1();
292  pushFront(selectedCircle);
293  } else {
294  pushBack(selectedCircle);
295  }
296  }
297  }
298  bool isEmpty() const {
299  return first == (last + 1) % enclosedCircles.size();
300  }
301  void pushFront(unsigned c) {
302  first = (first + enclosedCircles.size() - 1) % enclosedCircles.size();
303  enclosedCircles[first] = c;
304  }
305  unsigned popBack() {
306  unsigned result = enclosedCircles[last];
307  last = (last + enclosedCircles.size() - 1) % enclosedCircles.size();
308  return result;
309  }
310  void pushBack(unsigned c) {
311  last = (last + 1) % enclosedCircles.size();
312  enclosedCircles[last] = c;
313  }
314 
315  public:
316  OptimumCircleHull() : circles(nullptr), first(0), last(0), b1(0), b2(0) {}
317 
318  tlp::Circle<Obj, OTYPE> operator()(const std::vector<tlp::Circle<Obj, OTYPE>> &circlesSet) {
319  circles = &circlesSet;
320  enclosedCircles.resize(circlesSet.size() + 1);
321  first = 0;
322  last = circlesSet.size() - 1;
323 
324  for (unsigned i = 0; i < circlesSet.size(); ++i)
325  enclosedCircles[i] = i;
326 
327  for (unsigned i = circlesSet.size(); i > 0;) {
328  unsigned idx = tlp::randomUnsignedInteger(i - 1);
329  --i;
330  std::swap(enclosedCircles[idx], enclosedCircles[i]);
331  }
332 
333  process0();
334  return result;
335  }
336  };
337  return OptimumCircleHull()(circles);
338 }
339 
340 template <typename Obj, typename OTYPE>
341 std::ostream &tlp::operator<<(std::ostream &os, const tlp::Circle<Obj, OTYPE> &a) {
342  os << "((" << a[0] << "," << a[1] << ")," << a.radius << ")";
343  return os;
344 }
unsigned int randomUnsignedInteger(unsigned int max)
Returns a random unsigned integer in the range [0, max].