1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
|
// Copyright (c) 2005,2006 INRIA Sophia-Antipolis (France).
// All rights reserved.
//
// This file is part of CGAL (www.cgal.org)
//
// $URL: https://github.com/CGAL/cgal/blob/v6.1/Filtered_kernel/include/CGAL/Lazy_kernel.h $
// $Id: include/CGAL/Lazy_kernel.h b26b07a1242 $
// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-Commercial
//
//
// Author(s) : Andreas Fabri, Sylvain Pion
#ifndef CGAL_LAZY_KERNEL_H
#define CGAL_LAZY_KERNEL_H
#include <CGAL/basic.h>
//#include <CGAL/Filtered_predicate.h>
#include <CGAL/EPIC_predicate_if_convertible.h>
#include <CGAL/Filtered_kernel.h>
#include <CGAL/Cartesian_converter.h>
#include <CGAL/Simple_cartesian.h>
#include <CGAL/Interval_nt.h>
#include <CGAL/Kernel/Type_equality_wrapper.h>
#include <CGAL/Filtered_kernel/Cartesian_coordinate_iterator_2.h>
#include <CGAL/Filtered_kernel/Cartesian_coordinate_iterator_3.h>
#include <CGAL/Lazy.h>
#include <CGAL/Filtered_kernel/internal/Static_filters/tools.h>
#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
#include <boost/none.hpp>
#include <boost/mpl/or.hpp>
#include <CGAL/Lazy_exact_nt.h>
#if defined(BOOST_MSVC)
# pragma warning(push)
# pragma warning(disable:4348) // redefinition of default parameter in nested template class
#endif
namespace CGAL {
// Exact_kernel = exact kernel that will be made lazy
// Kernel = lazy kernel
// `Lazy_kernel_generic_base` applies the generic magic functor stupidly.
// `Lazy_kernel_base` fixes up a few special cases.
template < typename EK_, typename AK_, typename E2A_, typename Kernel_ >
class Lazy_kernel_generic_base
// : public Filtered_kernel_base<EK_>
{
public:
typedef AK_ Approximate_kernel;
typedef EK_ Exact_kernel;
typedef E2A_ E2A;
typedef Kernel_ Kernel;
typedef Lazy_kernel_generic_base<EK_, AK_, E2A_, Kernel_> Self;
// synonym identical to Filtered_kernel
typedef AK_ FK;
// Note: Approx_converter and Exact_converter are defined in <CGAL/Lazy.h>
typedef Approx_converter<Kernel, Approximate_kernel> C2F;
typedef Exact_converter<Kernel, Exact_kernel> C2E;
template < typename Kernel2 >
struct Base { typedef Lazy_kernel_generic_base<Exact_kernel, Approximate_kernel, E2A, Kernel2> Type; };
template < typename T >
struct Ambient_dimension {
typedef typename T::Ambient_dimension type;
};
template < typename T >
struct Feature_dimension {
typedef typename T::Feature_dimension type;
};
typedef typename Exact_kernel::Kernel_tag Kernel_tag;
typedef typename Exact_kernel::Rep_tag Rep_tag;
enum { Has_filtered_predicates = true };
typedef Boolean_tag<Has_filtered_predicates> Has_filtered_predicates_tag;
#ifdef CGAL_NO_STATIC_FILTERS_FOR_LAZY_KERNEL
enum { Has_static_filters = false };
#else
// @fixme, this should be 'true' but it's broken because EPIC_predicate_if_convertible
// assumes the static filtered predicate and the (non-static) filtered predicate
// have the same signature, which is not always the case, for example in
// Do_intersect_3(Sphere_3, Bbox_3, *bool*)
enum { Has_static_filters = false };
#endif
// Types
typedef CGAL::Lazy_exact_nt<typename Exact_kernel::FT> FT;
typedef FT RT;
typedef typename Same_uncertainty_nt<bool, FT>::type
Boolean;
typedef typename Same_uncertainty_nt<CGAL::Sign, FT>::type
Sign;
typedef typename Same_uncertainty_nt<CGAL::Comparison_result, FT>::type
Comparison_result;
typedef typename Same_uncertainty_nt<CGAL::Orientation, FT>::type
Orientation;
typedef typename Same_uncertainty_nt<CGAL::Oriented_side, FT>::type
Oriented_side;
typedef typename Same_uncertainty_nt<CGAL::Bounded_side, FT>::type
Bounded_side;
typedef typename Same_uncertainty_nt<CGAL::Angle, FT>::type
Angle;
typedef CGAL::Object Object_2;
typedef CGAL::Object Object_3;
#define CGAL_Kernel_obj(X) \
typedef Lazy<typename Approximate_kernel::X, typename Exact_kernel::X, E2A> X;
CGAL_Kernel_obj(Data_accessor_2)
CGAL_Kernel_obj(Conic_2)
typedef Cartesian_coordinate_iterator_2<Kernel> Cartesian_const_iterator_2;
typedef Cartesian_coordinate_iterator_3<Kernel> Cartesian_const_iterator_3;
// Aff_transformation_2/3 operations are not functorized, so treat it as
// an exterior object for now.
// CGAL_Kernel_obj(Aff_transformation_2)
// CGAL_Kernel_obj(Aff_transformation_3)
typedef CGAL::Aff_transformationC2<Kernel> Aff_transformation_2;
typedef CGAL::Aff_transformationC3<Kernel> Aff_transformation_3;
public:
#ifdef CGAL_NO_STATIC_FILTERS_FOR_LAZY_KERNEL
#define CGAL_Kernel_pred(P, Pf) \
typedef Filtered_predicate<typename Exact_kernel::P, typename Approximate_kernel::P, C2E, C2F> P; \
P Pf() const { return P(); }
#else
// - the first template parameter is because either it fits in a double, or not, so
// we might as well use the approximate kernel directly rather than the complete lazy kernel
// - the second is the predicate to be called if EPICK is not usable
// - the third is the equivalent predicate in EPICK
#define CGAL_Kernel_pred(P, Pf) \
typedef EPIC_predicate_if_convertible<Approximate_kernel, \
Filtered_predicate<typename Exact_kernel::P, \
typename Approximate_kernel::P, C2E, C2F>, \
Exact_predicates_inexact_constructions_kernel::P> P; \
P Pf() const { return P(); }
#endif
#define CGAL_Kernel_cons(C, Cf) \
typedef Lazy_construction<Kernel, typename Approximate_kernel::C, typename Exact_kernel::C> C; \
C Cf() const { return C(); }
#include <CGAL/Kernel/interface_macros.h>
// Useless meta-function, added to workaround a bug with Visual C++ 2022 and before
// See issue https://github.com/CGAL/cgal/issues/8140
template < typename T >
struct Handle { typedef T type; };
};
template < typename EK_, typename AK_, typename E2A_, typename Kernel_ >
class Lazy_kernel_base
: public Lazy_kernel_generic_base<EK_, AK_, E2A_, Kernel_>
{
public:
typedef Kernel_ Kernel;
typedef AK_ Approximate_kernel;
typedef EK_ Exact_kernel;
typedef E2A_ E2A;
typedef Lazy_kernel_generic_base<EK_, AK_, E2A_, Kernel_> BaseClass;
template < typename Kernel2 >
struct Base { typedef Lazy_kernel_base<Exact_kernel, Approximate_kernel, E2A, Kernel2> Type; };
typedef CommonKernelFunctors::Assign_2<Kernel> Assign_2;
typedef CommonKernelFunctors::Assign_3<Kernel> Assign_3;
typedef Lazy_cartesian_const_iterator_2<Kernel, typename Approximate_kernel::Construct_cartesian_const_iterator_2, typename Exact_kernel::Construct_cartesian_const_iterator_2> Construct_cartesian_const_iterator_2;
typedef Lazy_cartesian_const_iterator_3<Kernel, typename Approximate_kernel::Construct_cartesian_const_iterator_3, typename Exact_kernel::Construct_cartesian_const_iterator_3> Construct_cartesian_const_iterator_3;
typedef CGAL::CartesianKernelFunctors::Compute_approximate_squared_length_3<Kernel> Compute_approximate_squared_length_3;
typedef CGAL::CartesianKernelFunctors::Compute_approximate_area_3<Kernel> Compute_approximate_area_3;
typedef CGAL::Lazy_construction_optional_for_polyhedral_envelope<
Kernel,
typename Approximate_kernel::Intersect_point_3_for_polyhedral_envelope,
typename Exact_kernel::Intersect_point_3_for_polyhedral_envelope> Intersect_point_3_for_polyhedral_envelope;
struct Compute_weight_2 : public BaseClass::Compute_weight_2
{
typedef typename Kernel_::FT FT;
typedef typename Kernel_::Point_2 Point_2;
typedef typename Kernel_::Weighted_point_2 Weighted_point_2;
FT operator()(const Weighted_point_2& p) const
{
typedef Lazy_rep_n<typename Approximate_kernel::Weighted_point_2,
typename Exact_kernel::Weighted_point_2,
typename Approximate_kernel::Construct_weighted_point_2,
typename Exact_kernel::Construct_weighted_point_2,
E2A_,
true,
Return_base_tag,
Point_2,
FT
> LR;
typedef Lazy_rep_n<typename Approximate_kernel::Weighted_point_2,
typename Exact_kernel::Weighted_point_2,
typename Approximate_kernel::Construct_weighted_point_2,
typename Exact_kernel::Construct_weighted_point_2,
E2A_,
true,
Return_base_tag,
Point_2,
int
> LRint;
auto& obj = *p.ptr();
const char* tn = typeid(obj).name();
if(tn == typeid(LR).name()){
LR * lr = static_cast<LR*>(p.ptr());
if(lr->is_lazy()){
// Another thread could reset lr->l before this line, so we disable reset for Construct_weighted_point_2 in MT-mode.
// We could also always disable reset for Construct_weighted_point_2 and return lr->l here even if update_exact has run.
return std::get<2>(lr->l);
}
}else{
if(tn == typeid(LRint).name()){
LRint* lrint = static_cast<LRint*>(p.ptr());
if(lrint->is_lazy()){
return std::get<2>(lrint->l);
}
}
}
return BaseClass().compute_weight_2_object()(p);
}
};
struct Compute_weight_3 : public BaseClass::Compute_weight_3
{
typedef typename Kernel_::FT FT;
typedef typename Kernel_::Point_3 Point_3;
typedef typename Kernel_::Weighted_point_3 Weighted_point_3;
FT operator()(const Weighted_point_3& p) const
{
typedef Lazy_rep_n<typename Approximate_kernel::Weighted_point_3,
typename Exact_kernel::Weighted_point_3,
typename Approximate_kernel::Construct_weighted_point_3,
typename Exact_kernel::Construct_weighted_point_3,
E2A_,
true,
Return_base_tag,
Point_3,
FT
> LR;
typedef Lazy_rep_n<typename Approximate_kernel::Weighted_point_3,
typename Exact_kernel::Weighted_point_3,
typename Approximate_kernel::Construct_weighted_point_3,
typename Exact_kernel::Construct_weighted_point_3,
E2A_,
true,
Return_base_tag,
Point_3,
int
> LRint;
auto& obj = *p.ptr();
const char* tn = typeid(obj).name();
if(tn == typeid(LR).name()){
LR * lr = static_cast<LR*>(p.ptr());
if(lr->is_lazy()){
return std::get<2>(lr->l);
}
}else{
if(tn == typeid(LRint).name()){
LRint* lrint = static_cast<LRint*>(p.ptr());
if(lrint->is_lazy()){
return std::get<2>(lrint->l);
}
}
}
return BaseClass().compute_weight_3_object()(p);
}
};
struct Construct_point_2 : public BaseClass::Construct_point_2
{
typedef typename Kernel_::FT FT;
typedef typename Kernel_::Point_2 Point_2;
typedef typename Kernel_::Weighted_point_2 Weighted_point_2;
using BaseClass::Construct_point_2::operator();
const Point_2& operator()(const Point_2& p) const
{
return p;
}
Point_2 operator()(const Weighted_point_2& p) const
{
typedef Lazy_rep_n<typename Approximate_kernel::Weighted_point_2,
typename Exact_kernel::Weighted_point_2,
typename Approximate_kernel::Construct_weighted_point_2,
typename Exact_kernel::Construct_weighted_point_2,
E2A_,
true,
Return_base_tag,
Point_2,
FT
> LR;
typedef Lazy_rep_n<typename Approximate_kernel::Weighted_point_2,
typename Exact_kernel::Weighted_point_2,
typename Approximate_kernel::Construct_weighted_point_2,
typename Exact_kernel::Construct_weighted_point_2,
E2A_,
true,
Return_base_tag,
Point_2,
int
> LRint;
auto& obj = *p.ptr();
const char* tn = typeid(obj).name();
if(tn == typeid(LR).name()){
LR * lr = static_cast<LR*>(p.ptr());
if(lr->is_lazy()){
return std::get<1>(lr->l);
}
}else{
if(tn == typeid(LRint).name()){
LRint* lrint = static_cast<LRint*>(p.ptr());
if(lrint->is_lazy()){
return std::get<1>(lrint->l);
}
}
}
return BaseClass().construct_point_2_object()(p);
}
};
struct Construct_point_3 : public BaseClass::Construct_point_3
{
typedef typename Kernel_::FT FT;
typedef typename Kernel_::Point_3 Point_3;
typedef typename Kernel_::Weighted_point_3 Weighted_point_3;
using BaseClass::Construct_point_3::operator();
const Point_3& operator()(const Point_3& p) const
{
return p;
}
Point_3 operator()(const Weighted_point_3& p) const
{
typedef Lazy_rep_n<typename Approximate_kernel::Weighted_point_3,
typename Exact_kernel::Weighted_point_3,
typename Approximate_kernel::Construct_weighted_point_3,
typename Exact_kernel::Construct_weighted_point_3,
E2A_,
true,
Return_base_tag,
Point_3,
FT
> LR;
typedef Lazy_rep_n<typename Approximate_kernel::Weighted_point_3,
typename Exact_kernel::Weighted_point_3,
typename Approximate_kernel::Construct_weighted_point_3,
typename Exact_kernel::Construct_weighted_point_3,
E2A_,
true,
Return_base_tag,
Point_3,
int
> LRint;
auto& obj = *p.ptr();
const char* tn = typeid(obj).name();
if(tn == typeid(LR).name()){
LR * lr = static_cast<LR*>(p.ptr());
if(lr->is_lazy()){
return std::get<1>(lr->l);
}
}else{
if(tn == typeid(LRint).name()){
LRint* lrint = static_cast<LRint*>(p.ptr());
if(lrint->is_lazy()){
return std::get<1>(lrint->l);
}
}
}
return BaseClass().construct_point_3_object()(p);
}
};
struct Less_xyz_3 : public BaseClass::Less_xyz_3
{
typedef typename Kernel_::Point_3 Point_3;
bool operator()(const Point_3& p, const Point_3& q) const
{
if (p.rep().identical(q.rep())) { return false; }
return BaseClass::Less_xyz_3::operator()(p,q);
}
};
Construct_point_2 construct_point_2_object() const
{
return Construct_point_2();
}
Construct_point_3 construct_point_3_object() const
{
return Construct_point_3();
}
Compute_weight_2 compute_weight_2_object() const
{
return Compute_weight_2();
}
Compute_weight_3 compute_weight_3_object() const
{
return Compute_weight_3();
}
Assign_2
assign_2_object() const
{ return Assign_2(); }
Assign_3
assign_3_object() const
{ return Assign_3(); }
Construct_cartesian_const_iterator_2
construct_cartesian_const_iterator_2_object() const
{ return Construct_cartesian_const_iterator_2(); }
Construct_cartesian_const_iterator_3
construct_cartesian_const_iterator_3_object() const
{ return Construct_cartesian_const_iterator_3(); }
Compute_approximate_squared_length_3
compute_approximate_squared_length_3_object() const
{ return Compute_approximate_squared_length_3(); }
Compute_approximate_area_3
compute_approximate_area_3_object() const
{ return Compute_approximate_area_3(); }
Intersect_point_3_for_polyhedral_envelope
intersect_point_3_for_polyhedral_envelope_object() const
{ return Intersect_point_3_for_polyhedral_envelope(); }
Less_xyz_3
less_xyz_3_object() const
{ return Less_xyz_3(); }
}; // end class Lazy_kernel_base<EK_, AK_, E2A_, Kernel_2>
template <class Exact_kernel, class Approximate_kernel, class E2A>
struct Lazy_kernel_without_type_equality
: public Lazy_kernel_base< Exact_kernel, Approximate_kernel, E2A, Lazy_kernel_without_type_equality<Exact_kernel,Approximate_kernel, E2A> >
{};
template <class Exact_kernel,
class Approximate_kernel = Simple_cartesian<Interval_nt_advanced>,
class E2A = Cartesian_converter<Exact_kernel, Approximate_kernel> >
struct Lazy_kernel
: public Type_equality_wrapper<
Lazy_kernel_base< Exact_kernel, Approximate_kernel, E2A, Lazy_kernel<Exact_kernel, Approximate_kernel, E2A> >,
Lazy_kernel<Exact_kernel, Approximate_kernel, E2A> >
{
// WARNING: If you change the definition of Lazy_kernel, then you need to
// change also the definition of Epeck in
// <CGAL/Exact_predicate_exact_constructions_kernel.h>.
};
} //namespace CGAL
#if defined(BOOST_MSVC)
# pragma warning(pop)
#endif
#endif // CGAL_LAZY_KERNEL_H
|
