songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

clean up Mesh_3 internal parameters

This commit is contained in:
Sébastien Loriot 2022-09-21 15:45:14 +02:00
parent 6505bb7d39
commit 6b07cbdadd
5 changed files with 176 additions and 181 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

67
Mesh_3/include/CGAL/Mesh_3/parameters.h
View File

@ -206,47 +206,24 @@ struct Domain_features_generator< MeshDomain, true >
} // end namespace internal } // end namespace internal
// Undocumented parameter for refine_mesh_3 and make_mesh_3.
// Default Mesh_3_options: dump at every stage of the mesh generation.
inline internal::Mesh_3_options mesh_3_dump()
{
internal::Mesh_3_options options;
options.dump_after_init_prefix = "mesh_dump_after_init";
options.dump_after_refine_surface_prefix = "mesh_dump_after_refine_surface";
options.dump_after_refine_prefix = "mesh_dump_after_refine";
options.dump_after_glob_opt_prefix = "mesh_dump_after_glob_opt";
options.dump_after_perturb_prefix = "mesh_dump_after_perturb";
options.dump_after_exude_prefix = "mesh_dump_after_exude";
return options;
}
template <typename T>
struct Base
{
Base(T t) : t_(t) {}
T operator()() const { return t_; }
private:
T t_;
};
// ----------------------------------- // -----------------------------------
// Reset_c3t3 (undocumented) // Reset_c3t3 (undocumented)
// ----------------------------------- // -----------------------------------
inline
Named_function_parameters<bool, internal_np::do_reset_c3t3_t>
reset_c3t3()
{
return Named_function_parameters<bool, internal_np::do_reset_c3t3_t>(true);
}
#define CGAL_BOOLEAN_PARAMETER(Class, function_true, function_false) \ inline
struct Class : public Base<bool> { Class(bool b) : Base<bool>(b){} }; \ Named_function_parameters<bool, internal_np::do_reset_c3t3_t>
inline Named_function_parameters<Class, internal_np::reset_options_param_t> function_true() { \ no_reset_c3t3()
typedef Named_function_parameters<Class, internal_np::reset_options_param_t> Param; \ {
return Param(Class(true)); } \ return Named_function_parameters<bool, internal_np::do_reset_c3t3_t>(false);
inline Named_function_parameters<Class, internal_np::reset_options_param_t> function_false() {\ }
typedef Named_function_parameters<Class, internal_np::reset_options_param_t> Param; \
return Param(Class(false)); }
CGAL_BOOLEAN_PARAMETER(Reset,reset_c3t3,no_reset_c3t3)
#undef CGAL_BOOLEAN_PARAMETER
// ----------------------------------- // -----------------------------------
// Perturb // Perturb
@ -507,7 +484,6 @@ non_manifold()
// Undocumented parameter for refine_mesh_3 and make_mesh_3. // Undocumented parameter for refine_mesh_3 and make_mesh_3.
// Allows to dump the mesh at given stage of the mesh generation // Allows to dump the mesh at given stage of the mesh generation
// algorithm. // algorithm.
template<typename CGAL_NP_TEMPLATE_PARAMETERS> template<typename CGAL_NP_TEMPLATE_PARAMETERS>
Named_function_parameters<internal::Mesh_3_options, internal_np::mesh_param_t> Named_function_parameters<internal::Mesh_3_options, internal_np::mesh_param_t>
mesh_3_options(const CGAL_NP_CLASS& np = parameters::default_values()) mesh_3_options(const CGAL_NP_CLASS& np = parameters::default_values())
@ -542,6 +518,25 @@ mesh_3_options(const CGAL_NP_CLASS& ... nps)
return mesh_3_options(internal_np::combine_named_parameters(nps...)); return mesh_3_options(internal_np::combine_named_parameters(nps...));
} }
// Undocumented parameter for refine_mesh_3 and make_mesh_3.
// Default Mesh_3_options: dump at every stage of the mesh generation.
inline
Named_function_parameters<internal::Mesh_3_options, internal_np::mesh_param_t>
mesh_3_dump()
{
typedef Named_function_parameters<internal::Mesh_3_options, internal_np::mesh_param_t> Param;
internal::Mesh_3_options options;
options.dump_after_init_prefix = "mesh_dump_after_init";
options.dump_after_refine_surface_prefix = "mesh_dump_after_refine_surface";
options.dump_after_refine_prefix = "mesh_dump_after_refine";
options.dump_after_glob_opt_prefix = "mesh_dump_after_glob_opt";
options.dump_after_perturb_prefix = "mesh_dump_after_perturb";
options.dump_after_exude_prefix = "mesh_dump_after_exude";
return Param(options);
}
// ----------------------------------- // -----------------------------------
// Features_options // Features_options
// ----------------------------------- // -----------------------------------

4
Mesh_3/include/CGAL/refine_mesh_3.h
View File

@ -269,7 +269,7 @@ void refine_mesh_3(C3T3& c3t3, MeshDomain& domain, MeshCriteria& criteria, const
parameters::internal::Perturb_options perturb_param = choose_parameter(get_parameter(np, internal_np::perturb_options_param), parameters::perturb().v); parameters::internal::Perturb_options perturb_param = choose_parameter(get_parameter(np, internal_np::perturb_options_param), parameters::perturb().v);
parameters::internal::Odt_options odt_param = choose_parameter(get_parameter(np, internal_np::odt_options_param), parameters::no_odt().v); parameters::internal::Odt_options odt_param = choose_parameter(get_parameter(np, internal_np::odt_options_param), parameters::no_odt().v);
parameters::internal::Lloyd_options lloyd_param = choose_parameter(get_parameter(np, internal_np::lloyd_options_param), parameters::no_lloyd().v); parameters::internal::Lloyd_options lloyd_param = choose_parameter(get_parameter(np, internal_np::lloyd_options_param), parameters::no_lloyd().v);
parameters::Reset reset_param = choose_parameter(get_parameter(np, internal_np::reset_options_param), parameters::reset_c3t3().v); bool reset = choose_parameter(get_parameter(np, internal_np::do_reset_c3t3), false);
parameters::internal::Mesh_3_options mesh_options_param = choose_parameter(get_parameter(np, internal_np::mesh_param), parameters::internal::Mesh_3_options()); parameters::internal::Mesh_3_options mesh_options_param = choose_parameter(get_parameter(np, internal_np::mesh_param), parameters::internal::Mesh_3_options());
parameters::internal::Manifold_options manifold_options_param = choose_parameter(get_parameter(np, internal_np::manifold_param), parameters::internal::Manifold_options()); parameters::internal::Manifold_options manifold_options_param = choose_parameter(get_parameter(np, internal_np::manifold_param), parameters::internal::Manifold_options());
@ -280,7 +280,7 @@ void refine_mesh_3(C3T3& c3t3, MeshDomain& domain, MeshCriteria& criteria, const
perturb_param, perturb_param,
odt_param, odt_param,
lloyd_param, lloyd_param,
reset_param(), reset,
mesh_options_param, mesh_options_param,
manifold_options_param); manifold_options_param);
} }

280
Mesh_3/test/Mesh_3/test_labeled_mesh_domain_3.cpp
View File

@ -42,8 +42,8 @@ struct LM3_tester
static FT shape_function (const Point_3& p) static FT shape_function (const Point_3& p)
{ {
if (p.x() < 0) if (p.x() < 0)
return -1; return -1;
const FT x2=p.x()*p.x(), y2=p.y()*p.y(), z2=p.z()*p.z(); const FT x2=p.x()*p.x(), y2=p.y()*p.y(), z2=p.z()*p.z();
return x2 + y2 + z2 - 1; return x2 + y2 + z2 - 1;
} }
@ -56,12 +56,12 @@ struct LM3_tester
void operator() () const void operator() () const
{ {
typedef typename K::Sphere_3 Sphere_3; typedef typename K::Sphere_3 Sphere_3;
typedef typename K::Iso_cuboid_3 Iso_cuboid_3; typedef typename K::Iso_cuboid_3 Iso_cuboid_3;
test_domain(Sphere_3(CGAL::ORIGIN, 4.)); test_domain(Sphere_3(CGAL::ORIGIN, 4.));
test_domain(CGAL::Bbox_3(-2.,-2.,-2., 2.,2.,2.)); test_domain(CGAL::Bbox_3(-2.,-2.,-2., 2.,2.,2.));
test_domain(Iso_cuboid_3(Point_3(-2.,-2.,-2.), Point_3(2.,2.,2.))); test_domain(Iso_cuboid_3(Point_3(-2.,-2.,-2.), Point_3(2.,2.,2.)));
} }
private: private:
@ -72,12 +72,12 @@ private:
Function f_sphere(&sphere_function); Function f_sphere(&sphere_function);
Function_wrapper wrapper_1(f_sphere); Function_wrapper wrapper_1(f_sphere);
Mesh_domain domain(wrapper_1, bounding_shape, error_bound); Mesh_domain domain(wrapper_1, bounding_shape, CGAL::parameters::relative_error_bound(error_bound));
test_construct_initial_points(domain, error_bound); test_construct_initial_points(domain, error_bound);
Function f_shape(&shape_function); Function f_shape(&shape_function);
Function_wrapper wrapper_2(f_shape); Function_wrapper wrapper_2(f_shape);
Mesh_domain domain_2(wrapper_2, bounding_shape, error_bound); Mesh_domain domain_2(wrapper_2, bounding_shape, CGAL::parameters::relative_error_bound(error_bound));
test_is_in_domain(domain_2); test_is_in_domain(domain_2);
test_do_intersect_surface(domain_2); test_do_intersect_surface(domain_2);
test_construct_intersection(domain_2); test_construct_intersection(domain_2);
@ -85,171 +85,171 @@ private:
void test_construct_initial_points (const Mesh_domain& domain, FT error_bound) const void test_construct_initial_points (const Mesh_domain& domain, FT error_bound) const
{ {
typedef typename Mesh_domain::Construct_initial_points Construct_initial_points; typedef typename Mesh_domain::Construct_initial_points Construct_initial_points;
typedef typename Mesh_domain::Index Index; typedef typename Mesh_domain::Index Index;
typedef typename std::vector<std::pair<Point_3, Index> >::const_iterator Points_const_iterator; typedef typename std::vector<std::pair<Point_3, Index> >::const_iterator Points_const_iterator;
typedef typename K::Compute_squared_distance_3 Compute_squared_distance_3; typedef typename K::Compute_squared_distance_3 Compute_squared_distance_3;
Compute_squared_distance_3 squared_distance = K().compute_squared_distance_3_object(); Compute_squared_distance_3 squared_distance = K().compute_squared_distance_3_object();
Construct_initial_points construct_initial_points = domain.construct_initial_points_object(); Construct_initial_points construct_initial_points = domain.construct_initial_points_object();
std::vector<std::pair<Point_3, Index> > points; std::vector<std::pair<Point_3, Index> > points;
int point_count = 12; int point_count = 12;
construct_initial_points(std::back_inserter(points), point_count); construct_initial_points(std::back_inserter(points), point_count);
for (Points_const_iterator iter = points.begin(), end_iter = points.end(); iter != end_iter; ++iter) for (Points_const_iterator iter = points.begin(), end_iter = points.end(); iter != end_iter; ++iter)
{ {
const Point_3& p = iter->first; const Point_3& p = iter->first;
FT sd = squared_distance(CGAL::ORIGIN, p); FT sd = squared_distance(CGAL::ORIGIN, p);
FT diff = sd - 1; FT diff = sd - 1;
if (diff < FT(0.)) if (diff < FT(0.))
diff = -diff; diff = -diff;
assert(diff <= error_bound); assert(diff <= error_bound);
} }
} }
void test_is_in_domain (const Mesh_domain& domain) const void test_is_in_domain (const Mesh_domain& domain) const
{ {
typedef typename Mesh_domain::Is_in_domain Is_in_domain; typedef typename Mesh_domain::Is_in_domain Is_in_domain;
typedef typename Mesh_domain::Subdomain Subdomain; typedef typename Mesh_domain::Subdomain Subdomain;
typedef typename Mesh_domain::Subdomain_index Subdomain_index; typedef typename Mesh_domain::Subdomain_index Subdomain_index;
Is_in_domain is_in_domain = domain.is_in_domain_object(); Is_in_domain is_in_domain = domain.is_in_domain_object();
{ {
Subdomain subdomain = is_in_domain(Point_3(CGAL::ORIGIN)); Subdomain subdomain = is_in_domain(Point_3(CGAL::ORIGIN));
assert(subdomain); assert(subdomain);
Subdomain_index subdomain_index = *subdomain; Subdomain_index subdomain_index = *subdomain;
assert(subdomain_index == 1); assert(subdomain_index == 1);
} }
{ {
Subdomain subdomain = is_in_domain(Point_3(1.5, 0., 0.)); Subdomain subdomain = is_in_domain(Point_3(1.5, 0., 0.));
assert(!subdomain); assert(!subdomain);
} }
} }
void test_do_intersect_surface (const Mesh_domain& domain) const void test_do_intersect_surface (const Mesh_domain& domain) const
{ {
typedef typename Mesh_domain::Do_intersect_surface Do_intersect_surface; typedef typename Mesh_domain::Do_intersect_surface Do_intersect_surface;
typedef typename Mesh_domain::Surface_patch Surface_patch; typedef typename Mesh_domain::Surface_patch Surface_patch;
typedef typename Mesh_domain::Surface_patch_index Surface_patch_index; typedef typename Mesh_domain::Surface_patch_index Surface_patch_index;
typedef typename Mesh_domain::Segment_3 Segment_3; typedef typename Mesh_domain::Segment_3 Segment_3;
typedef typename Mesh_domain::Ray_3 Ray_3; typedef typename Mesh_domain::Ray_3 Ray_3;
typedef typename Mesh_domain::Line_3 Line_3; typedef typename Mesh_domain::Line_3 Line_3;
typedef typename Mesh_domain::Vector_3 Vector_3; typedef typename Mesh_domain::Vector_3 Vector_3;
Do_intersect_surface do_intersect_surface = domain.do_intersect_surface_object(); Do_intersect_surface do_intersect_surface = domain.do_intersect_surface_object();
{ {
Segment_3 s(Point_3(CGAL::ORIGIN), Point_3(1.5, 0., 0.)); Segment_3 s(Point_3(CGAL::ORIGIN), Point_3(1.5, 0., 0.));
Surface_patch p = do_intersect_surface(s); Surface_patch p = do_intersect_surface(s);
assert(p); assert(p);
Surface_patch_index pi = *p; Surface_patch_index pi = *p;
assert(pi.first == 0 && pi.second == 1); assert(pi.first == 0 && pi.second == 1);
} }
{ {
Segment_3 s(Point_3(1.5, 1.5, 0.), Point_3(1.5, 0., 0.)); Segment_3 s(Point_3(1.5, 1.5, 0.), Point_3(1.5, 0., 0.));
Surface_patch p = do_intersect_surface(s); Surface_patch p = do_intersect_surface(s);
assert(!p); assert(!p);
} }
{ {
Ray_3 r(Point_3(CGAL::ORIGIN), Vector_3(1., 0., 0.)); Ray_3 r(Point_3(CGAL::ORIGIN), Vector_3(1., 0., 0.));
Surface_patch p = do_intersect_surface(r); Surface_patch p = do_intersect_surface(r);
assert(p); assert(p);
Surface_patch_index pi = *p; Surface_patch_index pi = *p;
assert(pi.first == 0 && pi.second == 1); assert(pi.first == 0 && pi.second == 1);
} }
{ {
Ray_3 r(Point_3(1.5, 0., 0.), Vector_3(0., 1., 0.)); Ray_3 r(Point_3(1.5, 0., 0.), Vector_3(0., 1., 0.));
Surface_patch p = do_intersect_surface(r); Surface_patch p = do_intersect_surface(r);
assert(!p); assert(!p);
} }
{ {
Line_3 l(Point_3(CGAL::ORIGIN), Point_3(1.5, 0., 0.)); Line_3 l(Point_3(CGAL::ORIGIN), Point_3(1.5, 0., 0.));
Surface_patch p = do_intersect_surface(l); Surface_patch p = do_intersect_surface(l);
assert(p); assert(p);
Surface_patch_index pi = *p; Surface_patch_index pi = *p;
assert(pi.first == 0 && pi.second == 1); assert(pi.first == 0 && pi.second == 1);
} }
{ {
Line_3 l(Point_3(1.5, 0., 0.), Point_3(1.5, 0.5, 0.)); Line_3 l(Point_3(1.5, 0., 0.), Point_3(1.5, 0.5, 0.));
Surface_patch p = do_intersect_surface(l); Surface_patch p = do_intersect_surface(l);
assert(!p); assert(!p);
} }
} }
void test_construct_intersection (const Mesh_domain& domain) const void test_construct_intersection (const Mesh_domain& domain) const
{ {
typedef typename Mesh_domain::Construct_intersection Construct_intersection; typedef typename Mesh_domain::Construct_intersection Construct_intersection;
typedef typename Mesh_domain::Intersection Intersection; typedef typename Mesh_domain::Intersection Intersection;
typedef typename Mesh_domain::Subdomain_index Subdomain_index; typedef typename Mesh_domain::Subdomain_index Subdomain_index;
typedef typename Mesh_domain::Surface_patch_index Surface_patch_index; typedef typename Mesh_domain::Surface_patch_index Surface_patch_index;
typedef typename Mesh_domain::Index Index; typedef typename Mesh_domain::Index Index;
typedef typename Mesh_domain::Segment_3 Segment_3; typedef typename Mesh_domain::Segment_3 Segment_3;
typedef typename Mesh_domain::Ray_3 Ray_3; typedef typename Mesh_domain::Ray_3 Ray_3;
typedef typename Mesh_domain::Line_3 Line_3; typedef typename Mesh_domain::Line_3 Line_3;
typedef typename Mesh_domain::Vector_3 Vector_3; typedef typename Mesh_domain::Vector_3 Vector_3;
Construct_intersection construct_intersection = domain.construct_intersection_object(); Construct_intersection construct_intersection = domain.construct_intersection_object();
{ {
Segment_3 s(Point_3(CGAL::ORIGIN), Point_3(1.5, 0., 0.)); Segment_3 s(Point_3(CGAL::ORIGIN), Point_3(1.5, 0., 0.));
Intersection i = construct_intersection(s); Intersection i = construct_intersection(s);
assert(std::get<0>(i) != Point_3(1., 0., 0.)); assert(std::get<0>(i) != Point_3(1., 0., 0.));
Index ii = std::get<1>(i); Index ii = std::get<1>(i);
assert(boost::get<Surface_patch_index>(&ii)); assert(boost::get<Surface_patch_index>(&ii));
assert(std::get<2>(i) == 2); assert(std::get<2>(i) == 2);
} }
{ {
Segment_3 s(Point_3(1.5, 1.5, 0.), Point_3(1.5, 0., 0.)); Segment_3 s(Point_3(1.5, 1.5, 0.), Point_3(1.5, 0., 0.));
Intersection i = construct_intersection(s); Intersection i = construct_intersection(s);
Index ii = std::get<1>(i); Index ii = std::get<1>(i);
assert(boost::get<Subdomain_index>(&ii)); assert(boost::get<Subdomain_index>(&ii));
assert(std::get<2>(i) == 0); assert(std::get<2>(i) == 0);
} }
{ {
Ray_3 r(Point_3(CGAL::ORIGIN), Vector_3(1., 0., 0.)); Ray_3 r(Point_3(CGAL::ORIGIN), Vector_3(1., 0., 0.));
Intersection i = construct_intersection(r); Intersection i = construct_intersection(r);
assert(std::get<0>(i) != Point_3(1., 0., 0.)); assert(std::get<0>(i) != Point_3(1., 0., 0.));
Index ii = std::get<1>(i); Index ii = std::get<1>(i);
assert(boost::get<Surface_patch_index>(&ii)); assert(boost::get<Surface_patch_index>(&ii));
assert(std::get<2>(i) == 2); assert(std::get<2>(i) == 2);
} }
{ {
Ray_3 r(Point_3(1.5, 0., 0.), Vector_3(0., 1., 0.)); Ray_3 r(Point_3(1.5, 0., 0.), Vector_3(0., 1., 0.));
Intersection i = construct_intersection(r); Intersection i = construct_intersection(r);
Index ii = std::get<1>(i); Index ii = std::get<1>(i);
assert(boost::get<Subdomain_index>(&ii)); assert(boost::get<Subdomain_index>(&ii));
assert(std::get<2>(i) == 0); assert(std::get<2>(i) == 0);
} }
{ {
Line_3 l(Point_3(CGAL::ORIGIN), Point_3(1.5, 0., 0.)); Line_3 l(Point_3(CGAL::ORIGIN), Point_3(1.5, 0., 0.));
Intersection i = construct_intersection(l); Intersection i = construct_intersection(l);
assert(std::get<0>(i) != Point_3(1., 0., 0.)); assert(std::get<0>(i) != Point_3(1., 0., 0.));
Index ii = std::get<1>(i); Index ii = std::get<1>(i);
assert(boost::get<Surface_patch_index>(&ii)); assert(boost::get<Surface_patch_index>(&ii));
assert(std::get<2>(i) == 2); assert(std::get<2>(i) == 2);
} }
{ {
Line_3 l(Point_3(1.5, 0., 0.), Point_3(1.5, 0.5, 0.)); Line_3 l(Point_3(1.5, 0., 0.), Point_3(1.5, 0.5, 0.));
Intersection i = construct_intersection(l); Intersection i = construct_intersection(l);
Index ii = std::get<1>(i); Index ii = std::get<1>(i);
assert(boost::get<Subdomain_index>(&ii)); assert(boost::get<Subdomain_index>(&ii));
assert(std::get<2>(i) == 0); assert(std::get<2>(i) == 0);
} }
} }
}; };

4
Periodic_3_mesh_3/include/CGAL/refine_periodic_3_mesh_3.h
View File

@ -311,7 +311,7 @@ void refine_periodic_3_mesh_3(C3T3& c3t3, MeshDomain& domain, MeshCriteria& crit
parameters::internal::Perturb_options perturb_param = choose_parameter(get_parameter(np, internal_np::perturb_options_param), parameters::no_perturb().v); parameters::internal::Perturb_options perturb_param = choose_parameter(get_parameter(np, internal_np::perturb_options_param), parameters::no_perturb().v);
parameters::internal::Odt_options odt_param = choose_parameter(get_parameter(np, internal_np::odt_options_param), parameters::no_odt().v); parameters::internal::Odt_options odt_param = choose_parameter(get_parameter(np, internal_np::odt_options_param), parameters::no_odt().v);
parameters::internal::Lloyd_options lloyd_param = choose_parameter(get_parameter(np, internal_np::lloyd_options_param), parameters::no_lloyd().v); parameters::internal::Lloyd_options lloyd_param = choose_parameter(get_parameter(np, internal_np::lloyd_options_param), parameters::no_lloyd().v);
parameters::Reset reset_param = choose_parameter(get_parameter(np, internal_np::reset_options_param), parameters::reset_c3t3().v); bool reset = choose_parameter(get_parameter(np, internal_np::do_reset_c3t3), false);
parameters::internal::Mesh_3_options mesh_options_param = choose_parameter(get_parameter(np, internal_np::mesh_param), parameters::internal::Mesh_3_options()); parameters::internal::Mesh_3_options mesh_options_param = choose_parameter(get_parameter(np, internal_np::mesh_param), parameters::internal::Mesh_3_options());
parameters::internal::Manifold_options manifold_options_param = choose_parameter(get_parameter(np, internal_np::manifold_param), parameters::internal::Manifold_options()); parameters::internal::Manifold_options manifold_options_param = choose_parameter(get_parameter(np, internal_np::manifold_param), parameters::internal::Manifold_options());
@ -322,7 +322,7 @@ void refine_periodic_3_mesh_3(C3T3& c3t3, MeshDomain& domain, MeshCriteria& crit
perturb_param, perturb_param,
odt_param, odt_param,
lloyd_param, lloyd_param,
reset_param(), reset,
mesh_options_param, mesh_options_param,
manifold_options_param); manifold_options_param);
} }

2
STL_Extension/include/CGAL/STL_Extension/internal/parameters_interface.h
View File

@ -297,7 +297,7 @@ CGAL_add_named_parameter_with_compatibility(exude_options_param_t, exude_options
CGAL_add_named_parameter_with_compatibility(perturb_options_param_t, perturb_options_param, perturb_options) CGAL_add_named_parameter_with_compatibility(perturb_options_param_t, perturb_options_param, perturb_options)
CGAL_add_named_parameter_with_compatibility(odt_options_param_t, odt_options_param, odt_options) CGAL_add_named_parameter_with_compatibility(odt_options_param_t, odt_options_param, odt_options)
CGAL_add_named_parameter_with_compatibility(lloyd_options_param_t, lloyd_options_param, lloyd_options) CGAL_add_named_parameter_with_compatibility(lloyd_options_param_t, lloyd_options_param, lloyd_options)
CGAL_add_named_parameter_with_compatibility(reset_options_param_t, reset_options_param, reset_options) CGAL_add_named_parameter_with_compatibility(do_reset_c3t3_t, do_reset_c3t3, do_reset_c3t3)
CGAL_add_named_parameter_with_compatibility(mesh_param_t, mesh_param, mesh_options) CGAL_add_named_parameter_with_compatibility(mesh_param_t, mesh_param, mesh_options)
CGAL_add_named_parameter_with_compatibility(manifold_param_t, manifold_param, manifold_option) CGAL_add_named_parameter_with_compatibility(manifold_param_t, manifold_param, manifold_option)
CGAL_add_named_parameter_with_compatibility(features_option_param_t,features_options_param,features_options) CGAL_add_named_parameter_with_compatibility(features_option_param_t,features_options_param,features_options)