From 54a6462273c7f4ec7f9f2b0be19a5620b2ea1baa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Loriot?= Date: Mon, 26 Sep 2022 20:09:58 +0200 Subject: [PATCH] move code so that we can reinject mesh_3 parameters functions into NFP class --- ...tialize_triangulation_from_labeled_image.h | 2 +- .../CGAL/Mesh_3/internal/check_weights.h | 4 +- Mesh_3/include/CGAL/Mesh_3/parameters.h | 552 +----------------- .../include/CGAL/Mesh_3/parameters_defaults.h | 12 +- Mesh_3/include/CGAL/Mesh_error_code.h | 8 +- Mesh_3/include/CGAL/make_mesh_3.h | 4 +- .../include/CGAL/make_periodic_3_mesh_3.h | 10 +- .../Polyhedron/Plugins/Mesh_3/Mesh_function.h | 2 +- .../CGAL/SMDS_3/internal/indices_management.h | 8 +- .../include/CGAL/Named_function_parameters.h | 182 +++--- .../STL_Extension/internal}/Has_features.h | 11 +- .../internal/mesh_option_classes.h | 229 ++++++++ .../internal/mesh_parameters_interface.h | 370 ++++++++++++ 13 files changed, 731 insertions(+), 663 deletions(-) rename {SMDS_3/include/CGAL/SMDS_3 => STL_Extension/include/CGAL/STL_Extension/internal}/Has_features.h (82%) create mode 100644 STL_Extension/include/CGAL/STL_Extension/internal/mesh_option_classes.h create mode 100644 STL_Extension/include/CGAL/STL_Extension/internal/mesh_parameters_interface.h diff --git a/Mesh_3/include/CGAL/Mesh_3/initialize_triangulation_from_labeled_image.h b/Mesh_3/include/CGAL/Mesh_3/initialize_triangulation_from_labeled_image.h index 74bb943f76e..2b1aa1d4757 100644 --- a/Mesh_3/include/CGAL/Mesh_3/initialize_triangulation_from_labeled_image.h +++ b/Mesh_3/include/CGAL/Mesh_3/initialize_triangulation_from_labeled_image.h @@ -107,7 +107,7 @@ void initialize_triangulation_from_labeled_image(C3T3& c3t3, if(protect_features) { init_tr_from_labeled_image_call_init_features (c3t3, domain, criteria, - CGAL::Mesh_3::internal::Has_features()); + CGAL::internal::Has_features()); } const double max_v = (std::max)((std::max)(image.vx(), diff --git a/Mesh_3/include/CGAL/Mesh_3/internal/check_weights.h b/Mesh_3/include/CGAL/Mesh_3/internal/check_weights.h index 4d228953ad5..b1c6080f30c 100644 --- a/Mesh_3/include/CGAL/Mesh_3/internal/check_weights.h +++ b/Mesh_3/include/CGAL/Mesh_3/internal/check_weights.h @@ -22,7 +22,7 @@ #include #include -#include +#include #include namespace CGAL { @@ -33,7 +33,7 @@ template bool has_non_protecting_weights(const Triangulation& tr, const MeshDomain&) { - const bool with_features = Has_features::value; + const bool with_features = ::CGAL::internal::Has_features::value; typedef typename Triangulation::FT FT; typedef typename Triangulation::Weighted_point Weighted_point; diff --git a/Mesh_3/include/CGAL/Mesh_3/parameters.h b/Mesh_3/include/CGAL/Mesh_3/parameters.h index 0c89e18a278..39146e8e5e9 100644 --- a/Mesh_3/include/CGAL/Mesh_3/parameters.h +++ b/Mesh_3/include/CGAL/Mesh_3/parameters.h @@ -13,556 +13,22 @@ #include #include -#include +#include #include -#include +#include namespace CGAL { - namespace parameters { -namespace internal { +#define CGAL_NP_BASE internal_np::No_property +#define CGAL_NP_BUILD(P, V) P(V) + +#include -const int undef_parameter = -1; +#undef CGAL_NP_BASE +#undef CGAL_NP_BUILD -// Helpers -struct Optimization_options_base -{ - Optimization_options_base(bool b) - : b_(b), time_limit_(undef_parameter), bound_(undef_parameter) {} +} } // end of CGAL::parameters namespace - operator bool() const { return b_; } - - bool is_time_limit_set() const { return time_limit_ != undef_parameter; } - void set_time_limit(double d) { time_limit_ = d; } - double time_limit() const { return time_limit_; } - - bool is_bound_set() const { return bound_ != undef_parameter; } - void set_bound(double d) { bound_ = d; } - double bound() const { return bound_; } - -private: - bool b_; - double time_limit_; - double bound_; -}; - -struct Global_optimization_options_base -{ - Global_optimization_options_base() - : convergence_(undef_parameter), max_it_nb_(undef_parameter) {} - - bool is_convergence_set() const { return convergence_ != undef_parameter; } - void set_convergence(double d) { convergence_ = d; } - double convergence() const { return convergence_; } - - bool is_max_iteration_number_set() const { return max_it_nb_ != undef_parameter; } - void set_max_iteration_number(int i) { max_it_nb_ = i; } - int max_iteration_number() const { return max_it_nb_; } - -private: - double convergence_; - int max_it_nb_; -}; - -// Perturb -struct Perturb_options : public Optimization_options_base -{ - Perturb_options(bool b) : Optimization_options_base(b) {} -}; - -// Exude -struct Exude_options : public Optimization_options_base -{ - Exude_options(bool b) : Optimization_options_base(b) {} -}; - -// Odt -struct Odt_options : public Optimization_options_base -, public Global_optimization_options_base -{ - Odt_options(bool b) : Optimization_options_base(b) - , Global_optimization_options_base() {} -}; - -// Lloyd -struct Lloyd_options : public Optimization_options_base -, public Global_optimization_options_base -{ - Lloyd_options(bool b) : Optimization_options_base(b) - , Global_optimization_options_base() {} -}; - -// Manifold -struct Manifold_options { - enum { - NON_MANIFOLD = 0, - MANIFOLD_WITH_BOUNDARY = 8, - NO_BOUNDARY = 16, - MANIFOLD = 24 - }; - - Manifold_options(const int topology) - : mesh_topology(topology) - {} - Manifold_options() - : mesh_topology(NON_MANIFOLD) - {} - - int mesh_topology; -}; - -// Various Mesh_3 option -struct Mesh_3_options { -#ifndef CGAL_NO_ATOMIC - typedef std::atomic* Pointer_to_stop_atomic_boolean_t; -#else - typedef bool* Pointer_to_stop_atomic_boolean_t; -#endif - Mesh_3_options(bool nonlinear = false) - // This parameter `nonlinear` adds a compatibility with previous - // API of the constructor of `C3t3_initializer`. - // -- Laurent Rineau, 2019/05/03 - : dump_after_init_prefix() - , dump_after_refine_surface_prefix() - , dump_after_refine_prefix() - , dump_after_glob_opt_prefix() - , dump_after_perturb_prefix() - , dump_after_exude_prefix() - , number_of_initial_points(-1) - , nonlinear_growth_of_balls(nonlinear) - , maximal_number_of_vertices(0) - , pointer_to_error_code(0) -#ifndef CGAL_NO_ATOMIC - , pointer_to_stop_atomic_boolean(0) -#endif - {} - - std::string dump_after_init_prefix; - std::string dump_after_refine_surface_prefix; - std::string dump_after_refine_prefix; - std::string dump_after_glob_opt_prefix; - std::string dump_after_perturb_prefix; - std::string dump_after_exude_prefix; - int number_of_initial_points; - bool nonlinear_growth_of_balls; - std::size_t maximal_number_of_vertices; - Mesh_error_code* pointer_to_error_code; -#ifndef CGAL_NO_ATOMIC - Pointer_to_stop_atomic_boolean_t pointer_to_stop_atomic_boolean; -#endif - -}; // end struct Mesh_3_options - -// Features -struct Features_options -{ - Features_options(bool b) : b_(b) {} - bool features() const { return b_; } -private: - bool b_; -}; - -// ----------------------------------- -// Features generator -// ----------------------------------- -// struct Features_option_generator -template -struct Features_options_generator {}; - -template<> -struct Features_options_generator -{ - Features_options operator()() { return Features_options(true); } -}; - -template<> -struct Features_options_generator -{ - Features_options operator()() { return Features_options(false); } -}; - -// struct Domain_features_generator is designed to handle cases where -// MeshDomain::Has_features is not a valid type -template< typename MeshDomain, bool MeshDomainHasHasFeatures > -struct Domain_features_generator {}; - -template< typename MeshDomain > -struct Domain_features_generator< MeshDomain, false > -{ - Features_options operator()() - { - return Features_options_generator()(); - } -}; - -template< typename MeshDomain > -struct Domain_features_generator< MeshDomain, true > -{ - Features_options operator()() - { - return Features_options_generator()(); - } -}; - -} // end namespace internal - - - -// ----------------------------------- -// Reset_c3t3 (undocumented) -// ----------------------------------- -inline -Named_function_parameters -reset_c3t3() -{ - return Named_function_parameters(true); -} - -inline -Named_function_parameters -no_reset_c3t3() -{ - return Named_function_parameters(false); -} - -// ----------------------------------- -// Perturb -// ----------------------------------- -template -Named_function_parameters -perturb(const CGAL_NP_CLASS& np = parameters::default_values()) -{ - using parameters::choose_parameter; - using parameters::get_parameter; - double time_limit = choose_parameter(get_parameter(np,internal_np::maximum_running_time),internal::undef_parameter); - double sliver_bound = choose_parameter(get_parameter(np,internal_np::lower_sliver_bound),default_values_for_mesh_3::perturb_sliver_bound); - - internal::Perturb_options options(true); - - if ( internal::undef_parameter != time_limit) - options.set_time_limit(time_limit); - - options.set_bound(sliver_bound); - typedef Named_function_parameters Param; - return Param(options); -} - -template -Named_function_parameters -perturb(const CGAL_NP_CLASS& ... nps) -{ - return perturb(internal_np::combine_named_parameters(nps...)); -} - - -inline Named_function_parameters -no_perturb() -{ - typedef Named_function_parameters Param; - return Param(internal::Perturb_options(false)); -} - -#ifndef CGAL_NO_DEPRECATED_CODE -CGAL_DEPRECATED -inline -Named_function_parameters -perturb(double time_limit_, - double sliver_bound_=0) -{ - return perturb(time_limit(time_limit_). - sliver_bound(sliver_bound_)); -} -#endif - -// ----------------------------------- -// Exude -// ----------------------------------- -template -Named_function_parameters -exude(const CGAL_NP_CLASS& np = parameters::default_values()) -{ - using parameters::choose_parameter; - using parameters::get_parameter; - double time_limit = choose_parameter(get_parameter(np,internal_np::maximum_running_time),internal::undef_parameter); - double sliver_bound = choose_parameter(get_parameter(np,internal_np::lower_sliver_bound),default_values_for_mesh_3::perturb_sliver_bound); - - internal::Exude_options options(true); - - if ( internal::undef_parameter != time_limit) - options.set_time_limit(time_limit); - options.set_bound(sliver_bound); - typedef Named_function_parameters Param; - - return Param(options); -} - -template -Named_function_parameters -exude(const CGAL_NP_CLASS& ... nps) -{ - return exude(internal_np::combine_named_parameters(nps...)); -} - -inline Named_function_parameters -no_exude() -{ - typedef Named_function_parameters Param; - return Param(internal::Exude_options(false)); -} - -#ifndef CGAL_NO_DEPRECATED_CODE -CGAL_DEPRECATED -inline -Named_function_parameters -exude(double time_limit_, - double sliver_bound_ = 0) -{ - return exude(time_limit(time_limit_).sliver_bound(sliver_bound_)); -} -#endif - -// ----------------------------------- -// Odt -// ----------------------------------- -template -Named_function_parameters -odt(const CGAL_NP_CLASS& np = parameters::default_values()) -{ - using parameters::choose_parameter; - using parameters::get_parameter; - double time_limit = choose_parameter(get_parameter(np,internal_np::maximum_running_time),0); - double freeze_bound = choose_parameter(get_parameter(np,internal_np::vertex_freeze_bound),default_values_for_mesh_3::odt_freeze_ratio); - double convergence = choose_parameter(get_parameter(np,internal_np::convergence_ratio), default_values_for_mesh_3::odt_convergence_ratio); - int max_iteration_number = choose_parameter(get_parameter(np,internal_np::number_of_iterations), 0); - internal::Odt_options options(true); - - options.set_time_limit(time_limit); - options.set_bound(freeze_bound); - options.set_convergence(convergence); - options.set_max_iteration_number(max_iteration_number); - typedef Named_function_parameters Param; - return Param(options); -} - -template -Named_function_parameters -odt(const CGAL_NP_CLASS& ... nps) -{ - return odt(internal_np::combine_named_parameters(nps...)); -} - -inline Named_function_parameters -no_odt() -{ - typedef Named_function_parameters Param; - return Param(internal::Odt_options(false)); -} - -#ifndef CGAL_NO_DEPRECATED_CODE -CGAL_DEPRECATED -inline -Named_function_parameters -odt(double time_limit_, - std::size_t max_iteration_number_ = 0, - double convergence_ = 0.02, - double freeze_bound_ = 0.01, - bool do_freeze_ = true) -{ - return odt(time_limit(time_limit_). - max_iteration_number(max_iteration_number_). - convergence(convergence_). - freeze_bound(freeze_bound_). - do_freeze(do_freeze_)); -} -#endif - -// ----------------------------------- -// Lloyd -// ----------------------------------- -template -Named_function_parameters -lloyd(const CGAL_NP_CLASS& np = parameters::default_values()) -{ - using parameters::choose_parameter; - using parameters::get_parameter; - double time_limit = choose_parameter(get_parameter(np,internal_np::maximum_running_time),0); - double freeze_bound = choose_parameter(get_parameter(np,internal_np::vertex_freeze_bound),default_values_for_mesh_3::lloyd_freeze_ratio); - double convergence = choose_parameter(get_parameter(np,internal_np::convergence_ratio), default_values_for_mesh_3::lloyd_convergence_ratio); - int max_iteration_number = choose_parameter(get_parameter(np,internal_np::number_of_iterations), 0); - internal::Lloyd_options options(true); - - options.set_time_limit(time_limit); - options.set_bound(freeze_bound); - options.set_convergence(convergence); - options.set_max_iteration_number(max_iteration_number); - - typedef Named_function_parameters Param; - return Param(options); -} - -template -Named_function_parameters -lloyd(const CGAL_NP_CLASS& ... nps) -{ - return lloyd(internal_np::combine_named_parameters(nps...)); -} - -inline Named_function_parameters -no_lloyd() -{ - typedef Named_function_parameters Param; - return Param(internal::Lloyd_options(false)); -} - -#ifndef CGAL_NO_DEPRECATED_CODE -CGAL_DEPRECATED -inline -Named_function_parameters -lloyd(double time_limit_, - std::size_t max_iteration_number_ = 0, - double convergence_ = 0.02, - double freeze_bound_ = 0.01, - bool do_freeze_= true) -{ - return lloyd(time_limit(time_limit_). - max_iteration_number(max_iteration_number_). - convergence(convergence_). - freeze_bound(freeze_bound_). - do_freeze(do_freeze_)); -} -#endif - -// ----------------------------------- -// Manifold options -// ----------------------------------- -template -Named_function_parameters -manifold_options(const CGAL_NP_CLASS& np = parameters::default_values()) -{ - using parameters::choose_parameter; - using parameters::get_parameter; - int mesh_topology = choose_parameter(get_parameter(np, internal_np::mesh_topology_number), -1); - internal::Manifold_options options; - options.mesh_topology = mesh_topology; - - typedef Named_function_parameters Param; - return Param(options); -} - - -template -Named_function_parameters -manifold_options(const CGAL_NP_CLASS& ... nps) -{ - return manifold_options(internal_np::combine_named_parameters(nps...)); -} - -inline Named_function_parameters -manifold() -{ - typedef Named_function_parameters Param; - return Param(internal::Manifold_options(internal::Manifold_options::MANIFOLD)); -} -inline Named_function_parameters -manifold_with_boundary() -{ - typedef Named_function_parameters Param; - return Param(internal::Manifold_options( - internal::Manifold_options::MANIFOLD_WITH_BOUNDARY)); -} -inline Named_function_parameters -non_manifold() -{ - typedef Named_function_parameters Param; - return Param(internal::Manifold_options(internal::Manifold_options::NON_MANIFOLD)); -} - -// ----------------------------------- -// Mesh options -// ----------------------------------- - -// Undocumented parameter for refine_mesh_3 and make_mesh_3. -// Allows to dump the mesh at given stage of the mesh generation -// algorithm. -template -Named_function_parameters -mesh_3_options(const CGAL_NP_CLASS& np = parameters::default_values()) -{ - using parameters::choose_parameter; - using parameters::get_parameter; - internal::Mesh_3_options options; - - options.dump_after_init_prefix=choose_parameter(get_parameter(np, internal_np::dump_after_init_prefix_param), ""); - options.dump_after_refine_surface_prefix=choose_parameter(get_parameter(np, internal_np::dump_after_refine_surface_prefix_param), ""); - options.dump_after_refine_prefix=choose_parameter(get_parameter(np, internal_np::dump_after_refine_prefix_param), ""); - options.dump_after_glob_opt_prefix=choose_parameter(get_parameter(np, internal_np::dump_after_glob_opt_prefix_param), ""); - options.dump_after_perturb_prefix=choose_parameter(get_parameter(np, internal_np::dump_after_perturb_prefix_param), ""); - options.dump_after_exude_prefix=choose_parameter(get_parameter(np, internal_np::dump_after_refine_surface_prefix_param), ""); - options.number_of_initial_points=choose_parameter(get_parameter(np, internal_np::number_of_initial_points_param), -1); - options.nonlinear_growth_of_balls = choose_parameter(get_parameter(np, internal_np::nonlinear_growth_of_balls_param), false); - options.maximal_number_of_vertices=choose_parameter(get_parameter(np, internal_np::maximal_number_of_vertices_param), 0); - options.pointer_to_error_code=choose_parameter(get_parameter(np, internal_np::pointer_to_error_code_param), ((Mesh_error_code*)0)); -#ifndef CGAL_NO_ATOMIC - options.pointer_to_stop_atomic_boolean=choose_parameter(get_parameter(np, internal_np::pointer_to_stop_atomic_boolean_param), - ((internal::Mesh_3_options::Pointer_to_stop_atomic_boolean_t)0)); -#endif - - typedef Named_function_parameters Param; - return Param(options); -} - -template -Named_function_parameters -mesh_3_options(const CGAL_NP_CLASS& ... 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 -mesh_3_dump() -{ - typedef Named_function_parameters 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 -// ----------------------------------- -inline Named_function_parameters -features() { - typedef Named_function_parameters Param; - return Param(internal::Features_options(true)); -} - -inline Named_function_parameters -no_features() { - typedef Named_function_parameters Param; - return Param(internal::Features_options(false)); } - -template < typename MeshDomain > -inline Named_function_parameters -features(const MeshDomain& /*domain*/) -{ - typedef typename internal::Domain_features_generator::value > Generator; - -typedef Named_function_parameters Param; -return Param(Generator()()); -} - -} } //namespace CGAL::parameters #endif //CGAL_MESH_3_PARAMETERS_H \ No newline at end of file diff --git a/Mesh_3/include/CGAL/Mesh_3/parameters_defaults.h b/Mesh_3/include/CGAL/Mesh_3/parameters_defaults.h index e9f06c9c590..6914525417e 100644 --- a/Mesh_3/include/CGAL/Mesh_3/parameters_defaults.h +++ b/Mesh_3/include/CGAL/Mesh_3/parameters_defaults.h @@ -23,6 +23,9 @@ #include +// see also default_values_for_mesh_3 namespace +// in CGAL/STL_Extension/internal/mesh_option_classes.h + namespace CGAL { namespace parameters { namespace default_values_for_mesh_3 { @@ -30,7 +33,6 @@ namespace parameters { namespace default_values_for_mesh_3 { const double exude_sliver_bound = 0.; // perturb_mesh_3 -const double perturb_sliver_bound = 0.; template CGAL::Mesh_3::Min_dihedral_angle_criterion @@ -43,14 +45,6 @@ CGAL::Mesh_3::Min_dihedral_angle_criterion // global optimizers const bool do_freeze = true; -// lloyd_optimize_mesh_3 -const double lloyd_freeze_ratio = 0.01; -const double lloyd_convergence_ratio = 0.02; - -// odt_optimize_mesh_3 -const double odt_freeze_ratio = 0.01; -const double odt_convergence_ratio = 0.02; - } } // end namespace parameters::default_values_for_mesh_3 } // end namespace CGAL diff --git a/Mesh_3/include/CGAL/Mesh_error_code.h b/Mesh_3/include/CGAL/Mesh_error_code.h index 2bbf47a451a..6c8f417e68a 100644 --- a/Mesh_3/include/CGAL/Mesh_error_code.h +++ b/Mesh_3/include/CGAL/Mesh_error_code.h @@ -14,17 +14,13 @@ #include +#include + #include #include namespace CGAL { -enum Mesh_error_code { - CGAL_MESH_3_NO_ERROR = 0, - CGAL_MESH_3_MAXIMAL_NUMBER_OF_VERTICES_REACHED, - CGAL_MESH_3_STOPPED -}; - inline std::string mesh_error_string(const Mesh_error_code& error_code) { switch(error_code) { diff --git a/Mesh_3/include/CGAL/make_mesh_3.h b/Mesh_3/include/CGAL/make_mesh_3.h index 6ebd6ab8166..29a4ede1ff3 100644 --- a/Mesh_3/include/CGAL/make_mesh_3.h +++ b/Mesh_3/include/CGAL/make_mesh_3.h @@ -25,7 +25,7 @@ #include #include #include -#include +#include #include #include @@ -494,7 +494,7 @@ void make_mesh_3_impl(C3T3& c3t3, C3T3, MeshDomain, MeshCriteria, - Mesh_3::internal::has_Has_features::value > () (c3t3, + ::CGAL::internal::has_Has_features::value > () (c3t3, domain, criteria, with_features, diff --git a/Periodic_3_mesh_3/include/CGAL/make_periodic_3_mesh_3.h b/Periodic_3_mesh_3/include/CGAL/make_periodic_3_mesh_3.h index 8870e19a591..2698c5e5373 100644 --- a/Periodic_3_mesh_3/include/CGAL/make_periodic_3_mesh_3.h +++ b/Periodic_3_mesh_3/include/CGAL/make_periodic_3_mesh_3.h @@ -382,11 +382,11 @@ void make_periodic_3_mesh_3_impl(C3T3& c3t3, // Initialize c3t3 Periodic_3_mesh_3::internal::C3t3_initializer< C3T3, MeshDomain, MeshCriteria, - Mesh_3::internal::has_Has_features::value>()(c3t3, - domain, - criteria, - with_features, - mesh_options); + internal::has_Has_features::value>()(c3t3, + domain, + criteria, + with_features, + mesh_options); // Build mesher and launch refinement process refine_periodic_3_mesh_3(c3t3, domain, criteria, diff --git a/Polyhedron/demo/Polyhedron/Plugins/Mesh_3/Mesh_function.h b/Polyhedron/demo/Polyhedron/Plugins/Mesh_3/Mesh_function.h index 9681a52738b..8a7c309017c 100644 --- a/Polyhedron/demo/Polyhedron/Plugins/Mesh_3/Mesh_function.h +++ b/Polyhedron/demo/Polyhedron/Plugins/Mesh_3/Mesh_function.h @@ -226,7 +226,7 @@ initialize(const Mesh_criteria& criteria, Mesh_fnt::Domain_tag) C3t3, Domain, Mesh_criteria, - CGAL::Mesh_3::internal::has_Has_features::value >() + CGAL::internal::has_Has_features::value >() (c3t3_, *domain_, criteria, diff --git a/SMDS_3/include/CGAL/SMDS_3/internal/indices_management.h b/SMDS_3/include/CGAL/SMDS_3/internal/indices_management.h index b98528cace4..3ce7402e685 100644 --- a/SMDS_3/include/CGAL/SMDS_3/internal/indices_management.h +++ b/SMDS_3/include/CGAL/SMDS_3/internal/indices_management.h @@ -26,7 +26,7 @@ #include #include #include -#include +#include #include #include @@ -53,7 +53,7 @@ struct Index_generator typedef Index type; }; -template ::value> +template ::value> struct Indices_tuple_generator { using type = std::tuple const T& get_index(const T& x) { return x; } template ::value> + bool has_feature = ::CGAL::internal::Has_features::value> struct Read_mesh_domain_index { // here we have has_feature==true @@ -181,7 +181,7 @@ struct Read_mesh_domain_index { // Read_mesh_domain_index template ::value> + bool has_feature = ::CGAL::internal::Has_features::value> struct Write_mesh_domain_index { // here we have has_feature==true diff --git a/STL_Extension/include/CGAL/Named_function_parameters.h b/STL_Extension/include/CGAL/Named_function_parameters.h index 75db8c5ca11..a943d5513be 100644 --- a/STL_Extension/include/CGAL/Named_function_parameters.h +++ b/STL_Extension/include/CGAL/Named_function_parameters.h @@ -17,6 +17,7 @@ #endif #include +#include #include #include @@ -242,11 +243,93 @@ get_parameter_reference_impl(const Named_params_impl& np, Query_ta return get_parameter_reference_impl(static_cast(np), tag); } +} // end of internal_np namespace + +template +struct Named_function_parameters; + +namespace parameters{ + +typedef Named_function_parameters Default_named_parameters; + +Default_named_parameters +inline default_values(); + +// function to extract a parameter +template +typename internal_np::Get_param, Query_tag>::type +get_parameter(const Named_function_parameters& np, Query_tag tag) +{ + return internal_np::get_parameter_impl(static_cast&>(np), tag); +} + +template +typename internal_np::Get_param, Query_tag>::reference +get_parameter_reference(const Named_function_parameters& np, Query_tag tag) +{ + return internal_np::get_parameter_reference_impl( + static_cast&>(np), + tag); +} + +// Two parameters, non-trivial default value +template +D& choose_parameter(const internal_np::Param_not_found&, D& d) +{ + return d; +} + +template +const D& choose_parameter(const internal_np::Param_not_found&, const D& d) +{ + return d; +} + +template +D choose_parameter(const internal_np::Param_not_found&, D&& d) +{ + return std::forward(d); +} + +template +T& choose_parameter(T& t, D&) +{ + return t; +} + +template +const T& choose_parameter(const T& t, const D&) +{ + return t; +} + +// single parameter so that we can avoid a default construction +template +D choose_parameter(const internal_np::Param_not_found&) +{ + return D(); +} + +template +const T& choose_parameter(const T& t) +{ + return t; +} + +} // parameters namespace + +namespace internal_np { + +template +auto +combine_named_parameters(const Named_function_parameters& np, const NPS& ... nps) +{ + return np.combine(nps ...); +} } // end of internal_np namespace - -template +template struct Named_function_parameters : internal_np::Named_params_impl { @@ -299,6 +382,15 @@ struct Named_function_parameters #undef CGAL_add_named_parameter_with_compatibility_ref_only #undef CGAL_add_extra_named_parameter_with_compatibility +// inject mesh specific named parameter functions +#define CGAL_NP_BASE self +#define CGAL_NP_BUILD(P, V) P(V, *this) + +#include + +#undef CGAL_NP_BASE +#undef CGAL_NP_BUILD + template Named_function_parameters combine(const Named_function_parameters& np) const @@ -319,7 +411,11 @@ struct Named_function_parameters namespace parameters { -typedef Named_function_parameters Default_named_parameters; +Default_named_parameters +inline default_values() +{ + return Default_named_parameters(); +} #ifndef CGAL_NO_DEPRECATED_CODE Default_named_parameters @@ -329,12 +425,6 @@ inline all_default() } #endif -Default_named_parameters -inline default_values() -{ - return Default_named_parameters(); -} - template Named_function_parameters inline no_parameters(Named_function_parameters) @@ -405,67 +495,6 @@ struct Boost_parameter_compatibility_wrapper #undef CGAL_add_named_parameter_with_compatibility #undef CGAL_add_named_parameter_with_compatibility_ref_only -// function to extract a parameter -template -typename internal_np::Get_param, Query_tag>::type -get_parameter(const Named_function_parameters& np, Query_tag tag) -{ - return internal_np::get_parameter_impl(static_cast&>(np), tag); -} - -template -typename internal_np::Get_param, Query_tag>::reference -get_parameter_reference(const Named_function_parameters& np, Query_tag tag) -{ - return internal_np::get_parameter_reference_impl( - static_cast&>(np), - tag); -} - -// Two parameters, non-trivial default value -template -D& choose_parameter(const internal_np::Param_not_found&, D& d) -{ - return d; -} - -template -const D& choose_parameter(const internal_np::Param_not_found&, const D& d) -{ - return d; -} - -template -D choose_parameter(const internal_np::Param_not_found&, D&& d) -{ - return std::forward(d); -} - -template -T& choose_parameter(T& t, D&) -{ - return t; -} - -template -const T& choose_parameter(const T& t, const D&) -{ - return t; -} - -// single parameter so that we can avoid a default construction -template -D choose_parameter(const internal_np::Param_not_found&) -{ - return D(); -} - -template -const T& choose_parameter(const T& t) -{ - return t; -} - // Version with three parameters for dynamic property maps template D choose_parameter(const internal_np::Param_not_found&, Dynamic_tag tag, PolygonMesh& pm) @@ -493,17 +522,6 @@ struct is_default_parameter } // end of parameters namespace -namespace internal_np { - -template -auto -combine_named_parameters(const Named_function_parameters& np, const NPS& ... nps) -{ - return np.combine(nps ...); -} - -} // end of internal_np namespace - #ifndef CGAL_NO_DEPRECATED_CODE namespace Polygon_mesh_processing { @@ -526,7 +544,7 @@ namespace boost } #endif -// For disambiguation using SFINAR +// For disambiguation using SFINAE BOOST_MPL_HAS_XXX_TRAIT_DEF(CGAL_Named_function_parameters_class) template CGAL_CPP17_INLINE constexpr bool is_named_function_parameter = has_CGAL_Named_function_parameters_class::value; diff --git a/SMDS_3/include/CGAL/SMDS_3/Has_features.h b/STL_Extension/include/CGAL/STL_Extension/internal/Has_features.h similarity index 82% rename from SMDS_3/include/CGAL/SMDS_3/Has_features.h rename to STL_Extension/include/CGAL/STL_Extension/internal/Has_features.h index e2c322fc0f6..d9681f1579c 100644 --- a/SMDS_3/include/CGAL/SMDS_3/Has_features.h +++ b/STL_Extension/include/CGAL/STL_Extension/internal/Has_features.h @@ -6,21 +6,17 @@ // // $URL$ // $Id$ -// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-Commercial +// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-Commercial // // Author(s) : Stéphane Tayeb, Laurent Rineau -#ifndef CGAL_MESH_3_HAS_FEATURES_H -#define CGAL_MESH_3_HAS_FEATURES_H - -#include - +#ifndef CGAL_HAS_FEATURES_H +#define CGAL_HAS_FEATURES_H #include #include namespace CGAL { -namespace Mesh_3 { namespace internal { // A type has_Has_features to check if type 'Has_features' is a nested @@ -40,7 +36,6 @@ namespace internal { {}; } // end namespace internal -} // end namespace Mesh_3 } // end namespace CGAL #endif // CGAL_MESH_3_HAS_FEATURES_H diff --git a/STL_Extension/include/CGAL/STL_Extension/internal/mesh_option_classes.h b/STL_Extension/include/CGAL/STL_Extension/internal/mesh_option_classes.h new file mode 100644 index 00000000000..4b60d895a87 --- /dev/null +++ b/STL_Extension/include/CGAL/STL_Extension/internal/mesh_option_classes.h @@ -0,0 +1,229 @@ +// Copyright (c) 2009 INRIA Sophia-Antipolis (France). +// All rights reserved. +// +// This file is part of CGAL (www.cgal.org). +// +// $URL$ +// $Id$ +// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-Commercial +// + +#ifndef CGAL_MESH_OPTION_CLASSES_H +#define CGAL_MESH_OPTION_CLASSES_H + +#include + +namespace CGAL { + +enum Mesh_error_code { + CGAL_MESH_3_NO_ERROR = 0, + CGAL_MESH_3_MAXIMAL_NUMBER_OF_VERTICES_REACHED, + CGAL_MESH_3_STOPPED +}; + +namespace parameters { + +namespace internal { + +const int undef_parameter = -1; + +// Helpers +struct Optimization_options_base +{ + Optimization_options_base(bool b) + : b_(b), time_limit_(undef_parameter), bound_(undef_parameter) {} + + operator bool() const { return b_; } + + bool is_time_limit_set() const { return time_limit_ != undef_parameter; } + void set_time_limit(double d) { time_limit_ = d; } + double time_limit() const { return time_limit_; } + + bool is_bound_set() const { return bound_ != undef_parameter; } + void set_bound(double d) { bound_ = d; } + double bound() const { return bound_; } + +private: + bool b_; + double time_limit_; + double bound_; +}; + +struct Global_optimization_options_base +{ + Global_optimization_options_base() + : convergence_(undef_parameter), max_it_nb_(undef_parameter) {} + + bool is_convergence_set() const { return convergence_ != undef_parameter; } + void set_convergence(double d) { convergence_ = d; } + double convergence() const { return convergence_; } + + bool is_max_iteration_number_set() const { return max_it_nb_ != undef_parameter; } + void set_max_iteration_number(int i) { max_it_nb_ = i; } + int max_iteration_number() const { return max_it_nb_; } + +private: + double convergence_; + int max_it_nb_; +}; + +// Perturb +struct Perturb_options : public Optimization_options_base +{ + Perturb_options(bool b) : Optimization_options_base(b) {} +}; + +// Exude +struct Exude_options : public Optimization_options_base +{ + Exude_options(bool b) : Optimization_options_base(b) {} +}; + +// Odt +struct Odt_options : public Optimization_options_base +, public Global_optimization_options_base +{ + Odt_options(bool b) : Optimization_options_base(b) + , Global_optimization_options_base() {} +}; + +// Lloyd +struct Lloyd_options : public Optimization_options_base +, public Global_optimization_options_base +{ + Lloyd_options(bool b) : Optimization_options_base(b) + , Global_optimization_options_base() {} +}; + +// Manifold +struct Manifold_options { + enum { + NON_MANIFOLD = 0, + MANIFOLD_WITH_BOUNDARY = 8, + NO_BOUNDARY = 16, + MANIFOLD = 24 + }; + + Manifold_options(const int topology) + : mesh_topology(topology) + {} + Manifold_options() + : mesh_topology(NON_MANIFOLD) + {} + + int mesh_topology; +}; + +// Various Mesh_3 option +struct Mesh_3_options { +#ifndef CGAL_NO_ATOMIC + typedef std::atomic* Pointer_to_stop_atomic_boolean_t; +#else + typedef bool* Pointer_to_stop_atomic_boolean_t; +#endif + Mesh_3_options(bool nonlinear = false) + // This parameter `nonlinear` adds a compatibility with previous + // API of the constructor of `C3t3_initializer`. + // -- Laurent Rineau, 2019/05/03 + : dump_after_init_prefix() + , dump_after_refine_surface_prefix() + , dump_after_refine_prefix() + , dump_after_glob_opt_prefix() + , dump_after_perturb_prefix() + , dump_after_exude_prefix() + , number_of_initial_points(-1) + , nonlinear_growth_of_balls(nonlinear) + , maximal_number_of_vertices(0) + , pointer_to_error_code(0) +#ifndef CGAL_NO_ATOMIC + , pointer_to_stop_atomic_boolean(0) +#endif + {} + + std::string dump_after_init_prefix; + std::string dump_after_refine_surface_prefix; + std::string dump_after_refine_prefix; + std::string dump_after_glob_opt_prefix; + std::string dump_after_perturb_prefix; + std::string dump_after_exude_prefix; + int number_of_initial_points; + bool nonlinear_growth_of_balls; + std::size_t maximal_number_of_vertices; + Mesh_error_code* pointer_to_error_code; +#ifndef CGAL_NO_ATOMIC + Pointer_to_stop_atomic_boolean_t pointer_to_stop_atomic_boolean; +#endif + +}; // end struct Mesh_3_options + +// Features +struct Features_options +{ + Features_options(bool b) : b_(b) {} + bool features() const { return b_; } +private: + bool b_; +}; + +// ----------------------------------- +// Features generator +// ----------------------------------- +// struct Features_option_generator +template +struct Features_options_generator {}; + +template<> +struct Features_options_generator +{ + Features_options operator()() { return Features_options(true); } +}; + +template<> +struct Features_options_generator +{ + Features_options operator()() { return Features_options(false); } +}; + +// struct Domain_features_generator is designed to handle cases where +// MeshDomain::Has_features is not a valid type +template< typename MeshDomain, bool MeshDomainHasHasFeatures > +struct Domain_features_generator {}; + +template< typename MeshDomain > +struct Domain_features_generator< MeshDomain, false > +{ + Features_options operator()() + { + return Features_options_generator()(); + } +}; + +template< typename MeshDomain > +struct Domain_features_generator< MeshDomain, true > +{ + Features_options operator()() + { + return Features_options_generator()(); + } +}; + +} // end namespace internal + + +namespace default_values_for_mesh_3 { + +// perturb_mesh_3 +const double perturb_sliver_bound = 0.; + +// lloyd_optimize_mesh_3 +const double lloyd_freeze_ratio = 0.01; +const double lloyd_convergence_ratio = 0.02; + +// odt_optimize_mesh_3 +const double odt_freeze_ratio = 0.01; +const double odt_convergence_ratio = 0.02; + + +} } } //namespace CGAL::parameters::def + +#endif diff --git a/STL_Extension/include/CGAL/STL_Extension/internal/mesh_parameters_interface.h b/STL_Extension/include/CGAL/STL_Extension/internal/mesh_parameters_interface.h new file mode 100644 index 00000000000..5a8e8be90e3 --- /dev/null +++ b/STL_Extension/include/CGAL/STL_Extension/internal/mesh_parameters_interface.h @@ -0,0 +1,370 @@ +// Copyright (c) 2017 GeometryFactory (France). All rights reserved. +// +// This file is part of CGAL (www.cgal.org) +// +// $URL$ +// $Id$ +// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-Commercial +// +// + +// List of named parameters special functions used in meshing packages of CGAL +// no guard on purpose as they are injected both in the parameter namespace +// and the Named_function_parameters class. + + +// ----------------------------------- +// Reset_c3t3 (undocumented) +// ----------------------------------- +inline +Named_function_parameters +reset_c3t3() +{ + typedef Named_function_parameters Param; + return CGAL_NP_BUILD(Param, true); +} + +inline +Named_function_parameters +no_reset_c3t3() +{ + typedef Named_function_parameters Param; + return CGAL_NP_BUILD(Param, false); +} + +// ----------------------------------- +// Perturb +// ----------------------------------- +template +Named_function_parameters<::CGAL::parameters::internal::Perturb_options, ::CGAL::internal_np::perturb_options_param_t, CGAL_NP_BASE> +perturb(const CGAL_NP_CLASS& np = parameters::default_values()) +{ + using ::CGAL::parameters::choose_parameter; + using ::CGAL::parameters::get_parameter; + double time_limit = choose_parameter(get_parameter(np,::CGAL::internal_np::maximum_running_time),::CGAL::parameters::internal::undef_parameter); + double sliver_bound = choose_parameter(get_parameter(np,::CGAL::internal_np::lower_sliver_bound),::CGAL::parameters::default_values_for_mesh_3::perturb_sliver_bound); + + ::CGAL::parameters::internal::Perturb_options options(true); + + if ( ::CGAL::parameters::internal::undef_parameter != time_limit) + options.set_time_limit(time_limit); + + options.set_bound(sliver_bound); + typedef Named_function_parameters<::CGAL::parameters::internal::Perturb_options, ::CGAL::internal_np::perturb_options_param_t, CGAL_NP_BASE> Param; + return CGAL_NP_BUILD(Param, options); +} + +template +Named_function_parameters<::CGAL::parameters::internal::Perturb_options, ::CGAL::internal_np::perturb_options_param_t, CGAL_NP_BASE> +perturb(const CGAL_NP_CLASS& ... nps) +{ + return perturb(::CGAL::internal_np::combine_named_parameters(nps...)); +} + + +inline Named_function_parameters<::CGAL::parameters::internal::Perturb_options, ::CGAL::internal_np::perturb_options_param_t, CGAL_NP_BASE> +no_perturb() +{ + typedef Named_function_parameters<::CGAL::parameters::internal::Perturb_options, ::CGAL::internal_np::perturb_options_param_t, CGAL_NP_BASE> Param; + return CGAL_NP_BUILD(Param,::CGAL::parameters::internal::Perturb_options(false)); +} + +#ifndef CGAL_NO_DEPRECATED_CODE +CGAL_DEPRECATED +inline +Named_function_parameters<::CGAL::parameters::internal::Perturb_options, ::CGAL::internal_np::perturb_options_param_t, CGAL_NP_BASE> +perturb(double time_limit_, + double sliver_bound_=0) +{ + return perturb(time_limit(time_limit_). + sliver_bound(sliver_bound_)); +} +#endif + +// ----------------------------------- +// Exude +// ----------------------------------- +template +Named_function_parameters<::CGAL::parameters::internal::Exude_options, ::CGAL::internal_np::exude_options_param_t, CGAL_NP_BASE> +exude(const CGAL_NP_CLASS& np = parameters::default_values()) +{ + using ::CGAL::parameters::choose_parameter; + using ::CGAL::parameters::get_parameter; + double time_limit = choose_parameter(get_parameter(np,::CGAL::internal_np::maximum_running_time),::CGAL::parameters::internal::undef_parameter); + double sliver_bound = choose_parameter(get_parameter(np,::CGAL::internal_np::lower_sliver_bound),::CGAL::parameters::default_values_for_mesh_3::perturb_sliver_bound); + + ::CGAL::parameters::internal::Exude_options options(true); + + if ( ::CGAL::parameters::internal::undef_parameter != time_limit) + options.set_time_limit(time_limit); + options.set_bound(sliver_bound); + typedef Named_function_parameters<::CGAL::parameters::internal::Exude_options, ::CGAL::internal_np::exude_options_param_t, CGAL_NP_BASE> Param; + + return CGAL_NP_BUILD(Param, options); +} + +template +Named_function_parameters<::CGAL::parameters::internal::Exude_options, ::CGAL::internal_np::exude_options_param_t, CGAL_NP_BASE> +exude(const CGAL_NP_CLASS& ... nps) +{ + return exude(::CGAL::internal_np::combine_named_parameters(nps...)); +} + +inline Named_function_parameters<::CGAL::parameters::internal::Exude_options, ::CGAL::internal_np::exude_options_param_t, CGAL_NP_BASE> +no_exude() +{ + typedef Named_function_parameters<::CGAL::parameters::internal::Exude_options, ::CGAL::internal_np::exude_options_param_t, CGAL_NP_BASE> Param; + return CGAL_NP_BUILD(Param,::CGAL::parameters::internal::Exude_options(false)); +} + +#ifndef CGAL_NO_DEPRECATED_CODE +CGAL_DEPRECATED +inline +Named_function_parameters<::CGAL::parameters::internal::Exude_options, ::CGAL::internal_np::exude_options_param_t, CGAL_NP_BASE> +exude(double time_limit_, + double sliver_bound_ = 0) +{ + return exude(time_limit(time_limit_).sliver_bound(sliver_bound_)); +} +#endif + +// ----------------------------------- +// Odt +// ----------------------------------- +template +Named_function_parameters<::CGAL::parameters::internal::Odt_options, ::CGAL::internal_np::odt_options_param_t, CGAL_NP_BASE> +odt(const CGAL_NP_CLASS& np = parameters::default_values()) +{ + using ::CGAL::parameters::choose_parameter; + using ::CGAL::parameters::get_parameter; + double time_limit = choose_parameter(get_parameter(np,::CGAL::internal_np::maximum_running_time),0); + double freeze_bound = choose_parameter(get_parameter(np,::CGAL::internal_np::vertex_freeze_bound),::CGAL::parameters::default_values_for_mesh_3::odt_freeze_ratio); + double convergence = choose_parameter(get_parameter(np,::CGAL::internal_np::convergence_ratio), ::CGAL::parameters::default_values_for_mesh_3::odt_convergence_ratio); + int max_iteration_number = choose_parameter(get_parameter(np,::CGAL::internal_np::number_of_iterations), 0); + ::CGAL::parameters::internal::Odt_options options(true); + + options.set_time_limit(time_limit); + options.set_bound(freeze_bound); + options.set_convergence(convergence); + options.set_max_iteration_number(max_iteration_number); + typedef Named_function_parameters<::CGAL::parameters::internal::Odt_options, ::CGAL::internal_np::odt_options_param_t, CGAL_NP_BASE> Param; + return CGAL_NP_BUILD(Param,options); +} + +template +Named_function_parameters<::CGAL::parameters::internal::Odt_options, ::CGAL::internal_np::odt_options_param_t, CGAL_NP_BASE> +odt(const CGAL_NP_CLASS& ... nps) +{ + return odt(::CGAL::internal_np::combine_named_parameters(nps...)); +} + +inline Named_function_parameters<::CGAL::parameters::internal::Odt_options, ::CGAL::internal_np::odt_options_param_t, CGAL_NP_BASE> +no_odt() +{ + typedef Named_function_parameters<::CGAL::parameters::internal::Odt_options, ::CGAL::internal_np::odt_options_param_t, CGAL_NP_BASE> Param; + return CGAL_NP_BUILD(Param,::CGAL::parameters::internal::Odt_options(false)); +} + +#ifndef CGAL_NO_DEPRECATED_CODE +CGAL_DEPRECATED +inline +Named_function_parameters<::CGAL::parameters::internal::Odt_options, ::CGAL::internal_np::odt_options_param_t, CGAL_NP_BASE> +odt(double time_limit_, + std::size_t max_iteration_number_ = 0, + double convergence_ = 0.02, + double freeze_bound_ = 0.01, + bool do_freeze_ = true) +{ + return odt(time_limit(time_limit_). + max_iteration_number(max_iteration_number_). + convergence(convergence_). + freeze_bound(freeze_bound_). + do_freeze(do_freeze_)); +} +#endif + +// ----------------------------------- +// Lloyd +// ----------------------------------- +template +Named_function_parameters<::CGAL::parameters::internal::Lloyd_options, ::CGAL::internal_np::lloyd_options_param_t, CGAL_NP_BASE> +lloyd(const CGAL_NP_CLASS& np = parameters::default_values()) +{ + using ::CGAL::parameters::choose_parameter; + using ::CGAL::parameters::get_parameter; + double time_limit = choose_parameter(get_parameter(np,::CGAL::internal_np::maximum_running_time),0); + double freeze_bound = choose_parameter(get_parameter(np,::CGAL::internal_np::vertex_freeze_bound),::CGAL::parameters::default_values_for_mesh_3::lloyd_freeze_ratio); + double convergence = choose_parameter(get_parameter(np,::CGAL::internal_np::convergence_ratio), ::CGAL::parameters::default_values_for_mesh_3::lloyd_convergence_ratio); + int max_iteration_number = choose_parameter(get_parameter(np,::CGAL::internal_np::number_of_iterations), 0); + ::CGAL::parameters::internal::Lloyd_options options(true); + + options.set_time_limit(time_limit); + options.set_bound(freeze_bound); + options.set_convergence(convergence); + options.set_max_iteration_number(max_iteration_number); + + typedef Named_function_parameters<::CGAL::parameters::internal::Lloyd_options, ::CGAL::internal_np::lloyd_options_param_t, CGAL_NP_BASE> Param; + return CGAL_NP_BUILD(Param, options); +} + +template +Named_function_parameters<::CGAL::parameters::internal::Lloyd_options, ::CGAL::internal_np::lloyd_options_param_t, CGAL_NP_BASE> +lloyd(const CGAL_NP_CLASS& ... nps) +{ + return lloyd(::CGAL::internal_np::combine_named_parameters(nps...)); +} + +inline Named_function_parameters<::CGAL::parameters::internal::Lloyd_options, ::CGAL::internal_np::lloyd_options_param_t, CGAL_NP_BASE> +no_lloyd() +{ + typedef Named_function_parameters<::CGAL::parameters::internal::Lloyd_options, ::CGAL::internal_np::lloyd_options_param_t, CGAL_NP_BASE> Param; + return CGAL_NP_BUILD(Param, ::CGAL::parameters::internal::Lloyd_options(false)); +} + +#ifndef CGAL_NO_DEPRECATED_CODE +CGAL_DEPRECATED +inline +Named_function_parameters<::CGAL::parameters::internal::Lloyd_options, ::CGAL::internal_np::lloyd_options_param_t, CGAL_NP_BASE> +lloyd(double time_limit_, + std::size_t max_iteration_number_ = 0, + double convergence_ = 0.02, + double freeze_bound_ = 0.01, + bool do_freeze_= true) +{ + return lloyd(time_limit(time_limit_). + max_iteration_number(max_iteration_number_). + convergence(convergence_). + freeze_bound(freeze_bound_). + do_freeze(do_freeze_)); +} +#endif + +// ----------------------------------- +// Manifold options +// ----------------------------------- +template +Named_function_parameters<::CGAL::parameters::internal::Manifold_options, ::CGAL::internal_np::manifold_param_t, CGAL_NP_BASE> +manifold_options(const CGAL_NP_CLASS& np = parameters::default_values()) +{ + using ::CGAL::parameters::choose_parameter; + using ::CGAL::parameters::get_parameter; + int mesh_topology = choose_parameter(get_parameter(np, ::CGAL::internal_np::mesh_topology_number), -1); + ::CGAL::parameters::internal::Manifold_options options; + options.mesh_topology = mesh_topology; + + typedef Named_function_parameters<::CGAL::parameters::internal::Manifold_options, ::CGAL::internal_np::manifold_param_t, CGAL_NP_BASE> Param; + return CGAL_NP_BUILD(Param, options); +} + + +template +Named_function_parameters<::CGAL::parameters::internal::Manifold_options, ::CGAL::internal_np::manifold_param_t, CGAL_NP_BASE> +manifold_options(const CGAL_NP_CLASS& ... nps) +{ + return manifold_options(::CGAL::internal_np::combine_named_parameters(nps...)); +} + +inline Named_function_parameters<::CGAL::parameters::internal::Manifold_options, ::CGAL::internal_np::manifold_param_t, CGAL_NP_BASE> +manifold() +{ + typedef Named_function_parameters<::CGAL::parameters::internal::Manifold_options, ::CGAL::internal_np::manifold_param_t, CGAL_NP_BASE> Param; + return CGAL_NP_BUILD(Param, ::CGAL::parameters::internal::Manifold_options(::CGAL::parameters::internal::Manifold_options::MANIFOLD)); +} +inline Named_function_parameters<::CGAL::parameters::internal::Manifold_options, ::CGAL::internal_np::manifold_param_t, CGAL_NP_BASE> +manifold_with_boundary() +{ + typedef Named_function_parameters<::CGAL::parameters::internal::Manifold_options, ::CGAL::internal_np::manifold_param_t, CGAL_NP_BASE> Param; + return CGAL_NP_BUILD(Param,::CGAL::parameters::internal::Manifold_options( + ::CGAL::parameters::internal::Manifold_options::MANIFOLD_WITH_BOUNDARY)); +} +inline Named_function_parameters<::CGAL::parameters::internal::Manifold_options, ::CGAL::internal_np::manifold_param_t, CGAL_NP_BASE> +non_manifold() +{ + typedef Named_function_parameters<::CGAL::parameters::internal::Manifold_options, ::CGAL::internal_np::manifold_param_t, CGAL_NP_BASE> Param; + return CGAL_NP_BUILD(Param, ::CGAL::parameters::internal::Manifold_options(::CGAL::parameters::internal::Manifold_options::NON_MANIFOLD)); +} + +// ----------------------------------- +// Mesh options +// ----------------------------------- + +// Undocumented parameter for refine_mesh_3 and make_mesh_3. +// Allows to dump the mesh at given stage of the mesh generation +// algorithm. +template +Named_function_parameters<::CGAL::parameters::internal::Mesh_3_options, ::CGAL::internal_np::mesh_param_t, CGAL_NP_BASE> +mesh_3_options(const CGAL_NP_CLASS& np = parameters::default_values()) +{ + using ::CGAL::parameters::choose_parameter; + using ::CGAL::parameters::get_parameter; + ::CGAL::parameters::internal::Mesh_3_options options; + + options.dump_after_init_prefix=choose_parameter(get_parameter(np, ::CGAL::internal_np::dump_after_init_prefix_param), ""); + options.dump_after_refine_surface_prefix=choose_parameter(get_parameter(np, ::CGAL::internal_np::dump_after_refine_surface_prefix_param), ""); + options.dump_after_refine_prefix=choose_parameter(get_parameter(np, ::CGAL::internal_np::dump_after_refine_prefix_param), ""); + options.dump_after_glob_opt_prefix=choose_parameter(get_parameter(np, ::CGAL::internal_np::dump_after_glob_opt_prefix_param), ""); + options.dump_after_perturb_prefix=choose_parameter(get_parameter(np, ::CGAL::internal_np::dump_after_perturb_prefix_param), ""); + options.dump_after_exude_prefix=choose_parameter(get_parameter(np, ::CGAL::internal_np::dump_after_refine_surface_prefix_param), ""); + options.number_of_initial_points=choose_parameter(get_parameter(np, ::CGAL::internal_np::number_of_initial_points_param), -1); + options.nonlinear_growth_of_balls = choose_parameter(get_parameter(np, ::CGAL::internal_np::nonlinear_growth_of_balls_param), false); + options.maximal_number_of_vertices=choose_parameter(get_parameter(np, ::CGAL::internal_np::maximal_number_of_vertices_param), 0); + options.pointer_to_error_code=choose_parameter(get_parameter(np, ::CGAL::internal_np::pointer_to_error_code_param), ((Mesh_error_code*)0)); +#ifndef CGAL_NO_ATOMIC + options.pointer_to_stop_atomic_boolean=choose_parameter(get_parameter(np, ::CGAL::internal_np::pointer_to_stop_atomic_boolean_param), + ((::CGAL::parameters::internal::Mesh_3_options::Pointer_to_stop_atomic_boolean_t)0)); +#endif + + typedef Named_function_parameters<::CGAL::parameters::internal::Mesh_3_options, ::CGAL::internal_np::mesh_param_t, CGAL_NP_BASE> Param; + return CGAL_NP_BUILD(Param, options); +} + +template +Named_function_parameters<::CGAL::parameters::internal::Mesh_3_options, ::CGAL::internal_np::mesh_param_t, CGAL_NP_BASE> +mesh_3_options(const CGAL_NP_CLASS& ... nps) +{ + return mesh_3_options(::CGAL::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<::CGAL::parameters::internal::Mesh_3_options, ::CGAL::internal_np::mesh_param_t, CGAL_NP_BASE> +mesh_3_dump() +{ + typedef Named_function_parameters<::CGAL::parameters::internal::Mesh_3_options, ::CGAL::internal_np::mesh_param_t, CGAL_NP_BASE> Param; + ::CGAL::parameters::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 CGAL_NP_BUILD(Param, options); +} + +// ----------------------------------- +// Features_options +// ----------------------------------- +inline Named_function_parameters<::CGAL::parameters::internal::Features_options, ::CGAL::internal_np::features_option_param_t, CGAL_NP_BASE> +features() { + typedef Named_function_parameters<::CGAL::parameters::internal::Features_options, ::CGAL::internal_np::features_option_param_t, CGAL_NP_BASE> Param; + return CGAL_NP_BUILD(Param, ::CGAL::parameters::internal::Features_options(true)); +} + +inline Named_function_parameters<::CGAL::parameters::internal::Features_options, ::CGAL::internal_np::features_option_param_t, CGAL_NP_BASE> +no_features() { + typedef Named_function_parameters<::CGAL::parameters::internal::Features_options, ::CGAL::internal_np::features_option_param_t, CGAL_NP_BASE> Param; + return CGAL_NP_BUILD(Param, ::CGAL::parameters::internal::Features_options(false)); } + +template < typename MeshDomain > +inline Named_function_parameters<::CGAL::parameters::internal::Features_options, ::CGAL::internal_np::features_option_param_t, CGAL_NP_BASE> +features(const MeshDomain& /*domain*/) +{ + typedef typename ::CGAL::parameters::internal::Domain_features_generator::value > Generator; + + typedef Named_function_parameters<::CGAL::parameters::internal::Features_options, ::CGAL::internal_np::features_option_param_t, CGAL_NP_BASE> Param; + return CGAL_NP_BUILD(Param,Generator()()); +}