← Back to branch summary

~ubuntu-branches/debian/stretch/cgal/stretch

« back to all changes in this revision

Viewing changes to include/CGAL/Filtered_bbox_circular_kernel_2/bbox_filtered_predicates.h

  • Committer: Package Import Robot
  • Author(s): Joachim Reichel
  • Date: 2014-04-05 10:56:43 UTC
  • mfrom: (1.2.4)
  • Revision ID: package-import@ubuntu.com-20140405105643-jgnrpu2thtx23zfs
Tags: 4.4-1
* New upstream release.
* Remove patches do-not-link-example-with-qt4-support-library.patch and
  fix_jet_fitting_3.patch (applied upstream).

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/CGAL/Filtered_bbox_circular_kernel_2/bbox_filtered_predicates.h
42
42
  typedef typename BK::Point_2                                 Point_2;
43
43
  typedef typename BK::Circular_kernel:: 
44
44
    template Base< BK >::Type::Compare_x_2                     CK_Compare_x_2;
 
45
  typedef CK_Compare_x_2 Base;
45
46
 
46
47
public:
47
48
 
48
 
  typedef typename CK_Compare_x_2::result_type result_type; 
49
 
 
50
 
  result_type
51
 
  operator() (const Point_2 &p0,
52
 
              const Point_2 &p1) const
53
 
  {
54
 
    return CK_Compare_x_2()(p0, p1);
55
 
  }
 
49
  typedef typename CK_Compare_x_2::result_type result_type;
56
50
 
57
51
#ifndef CGAL_CFG_MATCHING_BUG_6
58
 
  using CK_Compare_x_2::operator();
 
52
  using Base::operator();
59
53
#else
60
 
  typedef typename BK::Line_2 Line_2;
61
 
 
62
 
  result_type
63
 
  operator() (const Point_2 &p0,
64
 
              const Line_2 &p1,
65
 
              const Line_2 &p2) const
66
 
  {
67
 
    return CK_Compare_x_2()(p0, p1,p2);
68
 
  }
69
 
 
70
 
  result_type
71
 
  operator() (const Line_2 &p0,
72
 
              const Line_2 &p1,
73
 
              const Line_2 &p2) const
74
 
  {
75
 
    return CK_Compare_x_2()(p0, p1,p2);
76
 
  }
77
 
 
78
 
  result_type
79
 
  operator() (const Line_2 &p0,
80
 
              const Line_2 &p1,
81
 
              const Line_2 &p2,
82
 
              const Line_2 &p3) const
83
 
  {
84
 
    return CK_Compare_x_2()(p0, p1,p2,p3);
85
 
  }
 
54
 template <typename T1, typename T2>
 
55
  result_type
 
56
  operator()(const T1& t1, const T2& t2) const
 
57
  {
 
58
    return Base()(t1,t2);
 
59
  }
 
60
  template <typename T1, typename T2, typename T3>
 
61
  result_type
 
62
  operator()(const T1& t1, const T2& t2, const T3& t3) const
 
63
  {
 
64
    return Base()(t1,t2,t3);
 
65
  }
 
66
 
 
67
  template <typename T1, typename T2, typename T3, typename T4>
 
68
  result_type
 
69
  operator()(const T1& t1, const T2& t2, const T3& t3, const T4& t4) const
 
70
  {
 
71
    return Base()(t1,t2,t3,t4);
 
72
  }
 
73
 
86
74
#endif
87
75
  
88
76
        
110
98
  typedef typename BK::Point_2                                 Point_2;
111
99
  typedef typename BK::Circular_kernel:: 
112
100
    template Base< BK >::Type::Compare_y_2                     CK_Compare_y_2;
113
 
 
 
101
  typedef CK_Compare_y_2 Base;
114
102
public:
115
103
 
116
 
  typedef typename CK_Compare_y_2::result_type result_type; 
 
104
  typedef typename CK_Compare_y_2::result_type result_type;
117
105
 
118
106
  result_type
119
107
  operator() (const Point_2 &p0,
123
111
  }
124
112
 
125
113
#ifndef CGAL_CFG_MATCHING_BUG_6
126
 
  using CK_Compare_y_2::operator();
 
114
  using Base::operator();
127
115
#else
128
 
  typedef typename BK::Line_2 Line_2;
129
 
 
130
 
  result_type
131
 
  operator() (const Point_2 &p0,
132
 
              const Line_2 &p1,
133
 
              const Line_2 &p2) const
134
 
  {
135
 
    return CK_Compare_y_2()(p0, p1,p2);
136
 
  }
137
 
 
138
 
  result_type
139
 
  operator() (const Line_2 &p0,
140
 
              const Line_2 &p1,
141
 
              const Line_2 &p2) const
142
 
  {
143
 
    return CK_Compare_y_2()(p0, p1,p2);
144
 
  }
145
 
 
146
 
  result_type
147
 
  operator() (const Line_2 &p0,
148
 
              const Line_2 &p1,
149
 
              const Line_2 &p2,
150
 
              const Line_2 &p3) const
151
 
  {
152
 
    return CK_Compare_y_2()(p0, p1,p2,p3);
 
116
  template <typename T1, typename T2>
 
117
  result_type
 
118
  operator()(const T1& t1, const T2& t2) const
 
119
  {
 
120
    return Base()(t1,t2);
 
121
  }
 
122
  template <typename T1, typename T2, typename T3>
 
123
  result_type
 
124
  operator()(const T1& t1, const T2& t2, const T3& t3) const
 
125
  {
 
126
    return Base()(t1,t2,t3);
 
127
  }
 
128
 
 
129
  template <typename T1, typename T2, typename T3, typename T4>
 
130
  result_type
 
131
  operator()(const T1& t1, const T2& t2, const T3& t3, const T4& t4) const
 
132
  {
 
133
    return Base()(t1,t2,t3,t4);
153
134
  }
154
135
#endif
155
136
  
158
139
  {
159
140
    Bbox_2 bb1=a.bbox(),bb2=b.bbox();
160
141
 
161
 
 
162
142
    if( bb1.ymin()>bb2.ymax() )
163
143
      return LARGER;
164
144
 
174
154
class Compare_xy_2 : public BK::Circular_kernel:: template Base< BK >::Type::Compare_xy_2
175
155
{
176
156
  typedef typename BK::Circular_kernel::
177
 
    template Base< BK >::Type::Compare_xy_2                    CK_Compare_xy_2;
 
157
  template Base< BK >::Type::Compare_xy_2                      CK_Compare_xy_2;
 
158
  typedef CK_Compare_xy_2 Base;
178
159
  typedef typename BK::Circular_arc_point_2                    Circular_arc_point_2;
179
160
  typedef typename BK::Point_2                                 Point_2;
180
161
 
181
162
public:
182
163
 
183
 
  typedef typename CK_Compare_xy_2::result_type result_type; 
184
 
  using CK_Compare_xy_2::operator();
185
 
 
186
 
public:
187
 
        
 
164
  typedef typename Base::result_type result_type;
 
165
 
 
166
 
 
167
#ifndef CGAL_CFG_MATCHING_BUG_6
 
168
  using Base::operator();
 
169
#else
 
170
 template <typename T1, typename T2>
188
171
  result_type
189
 
  operator()( const Point_2 &a, const Point_2 &b) const
 
172
  operator()(const T1& t1, const T2& t2) const
190
173
  {
191
 
    return CK_Compare_xy_2()(a,b);
 
174
    return Base()(t1,t2);
192
175
  }
 
176
#endif
 
177
public:
193
178
 
194
179
  result_type
195
180
  operator()( const Circular_arc_point_2 &a, const Circular_arc_point_2 &b) const
212
197
{
213
198
  typedef typename BK::Circular_kernel:: 
214
199
    template Base< BK >::Type::In_x_range_2                    CK_In_x_range_2;
 
200
  typedef CK_In_x_range_2 Base;
215
201
  typedef typename BK::Circular_arc_point_2                    Circular_arc_point_2;
216
202
  typedef typename BK::Circular_arc_2                          Circular_arc_2;
217
203
  typedef typename BK::Line_arc_2                              Line_arc_2;
218
204
 
219
205
public:
220
206
 
221
 
  typedef typename CK_In_x_range_2::result_type result_type; 
222
 
  using CK_In_x_range_2::operator();
 
207
  typedef typename CK_In_x_range_2::result_type result_type;
223
208
 
 
209
#ifndef CGAL_CFG_MATCHING_BUG_6
 
210
  using Base::operator();
 
211
#else
 
212
 template <typename T1, typename T2>
 
213
  result_type
 
214
  operator()(const T1& t1, const T2& t2) const
 
215
  {
 
216
    return Base()(t1,t2);
 
217
  }
 
218
#endif
224
219
private:
225
220
 
226
221
  template <class Arc_2>
274
269
{
275
270
  typedef typename BK::Circular_kernel:: 
276
271
    template Base< BK >::Type::Compare_y_at_x_2                         CK_Compare_y_at_x_2;
 
272
  typedef CK_Compare_y_at_x_2 Base;
277
273
  typedef typename BK::Circular_arc_2                                   Circular_arc_2;
278
274
  typedef typename BK::Circular_arc_point_2                             Circular_arc_point_2;
279
275
  typedef typename BK::Line_arc_2                                       Line_arc_2;
280
276
 
281
277
public:
282
278
 
283
 
  typedef typename CK_Compare_y_at_x_2::result_type result_type; 
284
 
  using CK_Compare_y_at_x_2::operator();
285
 
 
 
279
  typedef typename CK_Compare_y_at_x_2::result_type result_type;
 
280
 
 
281
#ifndef CGAL_CFG_MATCHING_BUG_6
 
282
  using Base::operator();
 
283
#else
 
284
  template <typename T1, typename T2>
 
285
  result_type
 
286
  operator()(const T1& t1, const T2& t2) const
 
287
  {
 
288
    return Base()(t1,t2);
 
289
  } 
 
290
 
 
291
  template <typename T1, typename T2, typename T3>
 
292
  result_type
 
293
  operator()(const T1& t1, const T2& t2, const T3& t3) const
 
294
  {
 
295
    return Base()(t1,t2,t3);
 
296
  }
 
297
 
 
298
  template <typename T1, typename T2, typename T3, typename T4>
 
299
  result_type
 
300
  operator()(const T1& t1, const T2& t2, const T3& t3, const T4& t4) const
 
301
  {
 
302
    return Base()(t1,t2,t3,t4);
 
303
  }
 
304
 
 
305
  template <typename T1, typename T2, typename T3, typename T4, typename T5>
 
306
  result_type
 
307
  operator()(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5) const
 
308
  {
 
309
    return Base()(t1,t2,t3,t4,t5);
 
310
  }
 
311
#endif
286
312
private:
287
313
 
288
314
  template <class Arc_2>
324
350
{
325
351
  typedef typename BK::Circular_kernel:: 
326
352
    template Base< BK >::Type::Has_on_2                                 CK_Has_on_2;
 
353
  typedef CK_Has_on_2 Base;
327
354
  typedef typename BK::Circular_arc_2                                   Circular_arc_2;
328
355
  typedef typename BK::Circular_arc_point_2                             Circular_arc_point_2;
329
356
  typedef typename BK::Line_arc_2                                       Line_arc_2;
330
357
 
331
358
public:
332
359
 
333
 
  typedef typename CK_Has_on_2::result_type result_type; 
334
 
  using CK_Has_on_2::operator();
335
 
 
 
360
  typedef typename CK_Has_on_2::result_type result_type;
 
361
  #ifndef CGAL_CFG_MATCHING_BUG_6
 
362
  using Base::operator();
 
363
#else
 
364
 template <typename T1, typename T2>
 
365
  result_type
 
366
  operator()(const T1& t1, const T2& t2) const
 
367
  {
 
368
    return Base()(t1,t2);
 
369
  }
 
370
#endif
336
371
private:
337
372
 
338
373
  template <class Arc_2>
384
419
  typedef typename BK::Circular_arc_point_2                             Circular_arc_point_2;
385
420
  typedef typename BK::Line_arc_2                                       Line_arc_2;
386
421
 
 
422
  typedef CK_Equal_2 Base;
 
423
 
387
424
public:
388
425
 
389
 
  typedef typename CK_Equal_2::result_type result_type; 
390
 
 
391
 
  result_type
392
 
  operator() (const Point_2 &p0,
393
 
              const Point_2 &p1) const
394
 
  { return CK_Equal_2()(p0,p1); }
 
426
  typedef typename CK_Equal_2::result_type result_type;
395
427
 
396
428
#ifndef CGAL_CFG_MATCHING_BUG_6
397
 
  using CK_Equal_2::operator();
 
429
  using Base::operator();
398
430
#else  
399
 
  result_type
400
 
  operator() (const Vector_2 &p0,
401
 
              const Vector_2 &p1) const
402
 
  { return CK_Equal_2()(p0,p1); }
403
 
       
404
 
  result_type
405
 
  operator() (const Vector_2 &p0,
406
 
              const Null_vector &p1) const
407
 
  { return CK_Equal_2()(p0,p1); }
408
 
      
409
 
  result_type
410
 
  operator() (const Null_vector &p0,
411
 
              const Vector_2 &p1) const
412
 
  { return CK_Equal_2()(p0,p1); }
413
 
      
414
 
  result_type
415
 
  operator() (const Direction_2 &p0,
416
 
              const Direction_2 &p1) const
417
 
  { return CK_Equal_2()(p0,p1); }
418
 
    
419
 
  
420
 
  result_type
421
 
  operator() (const Segment_2 &p0,
422
 
              const Segment_2 &p1) const
423
 
  { return CK_Equal_2()(p0,p1); }
424
 
    
425
 
 
426
 
  result_type
427
 
  operator() (const Ray_2 &p0,
428
 
              const Ray_2 &p1) const
429
 
  { return CK_Equal_2()(p0,p1); }
430
 
    
431
 
  result_type
432
 
  operator() (const Line_2 &p0,
433
 
              const Line_2 &p1) const
434
 
  { return CK_Equal_2()(p0,p1); }
435
 
    
436
 
 
437
 
 
438
 
  result_type
439
 
  operator() (const Triangle_2 &p0,
440
 
              const Triangle_2 &p1) const
441
 
  { return CK_Equal_2()(p0,p1); }
442
 
    
443
 
 
444
 
  result_type
445
 
  operator() (const Iso_rectangle_2 &p0,
446
 
              const Iso_rectangle_2 &p1) const
447
 
  { return CK_Equal_2()(p0,p1); }
448
 
    
449
 
 
450
 
  result_type
451
 
  operator() (const Circle_2 &p0,
452
 
              const Circle_2 &p1) const
453
 
  { return CK_Equal_2()(p0,p1); }
 
431
 template <typename T1, typename T2>
 
432
  result_type
 
433
  operator()(const T1& t1, const T2& t2) const
 
434
  {
 
435
    return Base()(t1,t2);
 
436
  }
454
437
#endif
455
438
 
456
439
private:
533
516
{
534
517
  typedef typename BK::Circular_kernel:: 
535
518
    template Base< BK >::Type::Do_overlap_2                           CK_Do_overlap_2;
 
519
  typedef CK_Do_overlap_2 Base;
536
520
  typedef typename BK::Circular_arc_2                                 Circular_arc_2;
537
521
  typedef typename BK::Line_arc_2                                     Line_arc_2;
538
522
 
539
523
public:
540
524
 
541
 
  typedef typename CK_Do_overlap_2::result_type result_type; 
542
 
  using CK_Do_overlap_2::operator();
 
525
  typedef typename CK_Do_overlap_2::result_type result_type;
 
526
 
 
527
#ifndef CGAL_CFG_MATCHING_BUG_6
 
528
  using Base::operator();
 
529
#else
 
530
 template <typename T1, typename T2>
 
531
  result_type
 
532
  operator()(const T1& t1, const T2& t2) const
 
533
  {
 
534
    return Base()(t1,t2);
 
535
  }
 
536
#endif
543
537
 
544
538
private:
545
539