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

Named parameter for mandatory parameters DRAFT

This commit is contained in:
GYuvanShankar 2022-07-19 13:10:35 +05:30
parent 78afe0c76e
commit 520545d543
12 changed files with 384 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

119
Mesh_3/include/CGAL/Labeled_mesh_domain_3.h
View File

@ -437,12 +437,47 @@ public:
create_construct_surface_patch_index(construct_surface_patch_index_));
}
template<typename CGAL_NP_TEMPLATE_PARAMETERS_NO_DEFAULT>
static Labeled_mesh_domain_3 create_gray_image_mesh_domain(const CGAL_NP_CLASS& np)
{
static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::image_3_param_t>::value, "Value for required parameter not found");
using parameters::get_parameter;
using parameters::choose_parameter;
const CGAL::Image_3& image_ = get_parameter(np,internal_np::image_3_param);
auto iso_value_ = choose_parameter(get_parameter(np, internal_np::iso_value_param), 0);
auto value_outside_ = choose_parameter(get_parameter(np, internal_np::voxel_value), 0);
FT relative_error_bound_ = choose_parameter(get_parameter(np, internal_np::error_bound), FT(1e-3));
auto image_values_to_subdomain_indices_ = choose_parameter(get_parameter(np, internal_np::image_subdomain_index), Null_functor());
CGAL::Random* p_rng_ = choose_parameter(get_parameter(np, internal_np::rng), (CGAL::Random*)(0));
auto null_subdomain_index_ = choose_parameter(get_parameter(np, internal_np::null_subdomain_index_param), Null_functor());
auto construct_surface_patch_index_ = choose_parameter(get_parameter(np, internal_np::surface_patch_index), Null_functor());
namespace p = CGAL::parameters;
return Labeled_mesh_domain_3
(create_gray_image_wrapper
(image_,
iso_value_,
image_values_to_subdomain_indices_,
value_outside_),
Mesh_3::internal::compute_bounding_box(image_),
p::relative_error_bound = relative_error_bound_,
p::p_rng = p_rng_,
p::null_subdomain_index =
create_null_subdomain_index(null_subdomain_index_),
p::construct_surface_patch_index =
create_construct_surface_patch_index(construct_surface_patch_index_));
}
#ifndef CGAL_NO_DEPRECATED_CODE
template<typename... NP_Pack>
static Labeled_mesh_domain_3 create_gray_image_mesh_domain(const CGAL::Image_3& image_, const NP_Pack& ...nps)
{
return create_gray_image_mesh_domain(image_, internal_np::combine_named_parameters(nps...));
}
template<typename ... NP_PACK>
static Labeled_mesh_domain_3 create_gray_image_mesh_domain(const NP_PACK& ...nps)
{
return create_gray_image_mesh_domain(internal_np::combine_named_parameters(nps...));
}
#endif //CGAL_NO_DEPRECATED_CODE
@ -510,6 +545,55 @@ where the labeled image is used with a precomputed 3D image of weights :
auto construct_surface_patch_index_ = choose_parameter(get_parameter(np, internal_np::surface_patch_index), Null_functor());
CGAL::Image_3 weights_ = choose_parameter(get_parameter(np, internal_np::weights_param), CGAL::Image_3());
namespace p = CGAL::parameters;
if (weights_.is_valid())
{
return Labeled_mesh_domain_3
(create_weighted_labeled_image_wrapper
(image_,
weights_,
image_values_to_subdomain_indices_,
value_outside_),
Mesh_3::internal::compute_bounding_box(image_),
p::relative_error_bound = relative_error_bound_,
p::p_rng = p_rng_,
p::null_subdomain_index =
create_null_subdomain_index(null_subdomain_index_),
p::construct_surface_patch_index =
create_construct_surface_patch_index(construct_surface_patch_index_));
}
else
{
return Labeled_mesh_domain_3
(create_labeled_image_wrapper
(image_,
image_values_to_subdomain_indices_,
value_outside_),
Mesh_3::internal::compute_bounding_box(image_),
p::relative_error_bound = relative_error_bound_,
p::p_rng = p_rng_,
p::null_subdomain_index =
create_null_subdomain_index(null_subdomain_index_),
p::construct_surface_patch_index =
create_construct_surface_patch_index(construct_surface_patch_index_));
}
}
template<typename CGAL_NP_TEMPLATE_PARAMETERS_NO_DEFAULT>
static Labeled_mesh_domain_3 create_labeled_image_mesh_domain(const CGAL_NP_CLASS& np)
{
static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::image_3_param_t>::value, "Value for required parameter not found");
using parameters::get_parameter;
using parameters::choose_parameter;
const CGAL::Image_3& image_ = get_parameter(np,internal_np::image_3_param);
auto iso_value_ = choose_parameter(get_parameter(np, internal_np::iso_value_param), FT(0));
auto value_outside_ = choose_parameter(get_parameter(np, internal_np::voxel_value), FT(0));
FT relative_error_bound_ = choose_parameter(get_parameter(np, internal_np::error_bound), FT(1e-3));
auto image_values_to_subdomain_indices_ = choose_parameter(get_parameter(np, internal_np::image_subdomain_index), Null_functor());
CGAL::Random* p_rng_ = choose_parameter(get_parameter(np, internal_np::rng), (CGAL::Random*)(0));
auto null_subdomain_index_ = choose_parameter(get_parameter(np, internal_np::null_subdomain_index_param), Null_functor());
auto construct_surface_patch_index_ = choose_parameter(get_parameter(np, internal_np::surface_patch_index), Null_functor());
CGAL::Image_3 weights_ = choose_parameter(get_parameter(np, internal_np::weights_param), CGAL::Image_3());
namespace p = CGAL::parameters;
if (weights_.is_valid())
{
@ -549,6 +633,11 @@ where the labeled image is used with a precomputed 3D image of weights :
{
return create_labeled_image_mesh_domain(image_, internal_np::combine_named_parameters(nps...));
}
template<typename ... NP_PACK>
static Labeled_mesh_domain_3 create_labeled_image_mesh_domain(const NP_PACK& ...nps)
{
return create_labeled_image_mesh_domain(internal_np::combine_named_parameters(nps...));
}
#endif //CGAL_NO_DEPRECATED_CODE
@ -614,12 +703,42 @@ From the example (\ref Mesh_3/mesh_implicit_sphere_variable_size.cpp):
create_construct_surface_patch_index(construct_surface_patch_index_));
}
template<typename CGAL_NP_TEMPLATE_PARAMETERS_NO_DEFAULT>
static Labeled_mesh_domain_3 create_implicit_mesh_domain(const CGAL_NP_CLASS& np)
{
static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::function_param_t>::value, "Value for required parameter not found");
static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::bounding_object_param_t>::value, "Value for required parameter not found");
using parameters::get_parameter;
using parameters::choose_parameter;
auto function_ = get_parameter(np, internal_np::function_param);
auto bounding_object_ = get_parameter(np, internal_np::bounding_object_param);
FT relative_error_bound_ = choose_parameter(get_parameter(np, internal_np::error_bound), FT(1e-3));
CGAL::Random* p_rng_ = choose_parameter(get_parameter(np, internal_np::rng), (CGAL::Random*)(0));
auto null_subdomain_index_ = choose_parameter(get_parameter(np, internal_np::null_subdomain_index_param), Null_functor());
auto construct_surface_patch_index_ = choose_parameter(get_parameter(np, internal_np::surface_patch_index), Null_functor());
namespace p = CGAL::parameters;
return Labeled_mesh_domain_3
(make_implicit_to_labeling_function_wrapper<BGT>(function_),
bounding_object_,
p::relative_error_bound = relative_error_bound_,
p::p_rng = p_rng_,
p::null_subdomain_index =
create_null_subdomain_index(null_subdomain_index_),
p::construct_surface_patch_index =
create_construct_surface_patch_index(construct_surface_patch_index_));
}
#ifndef CGAL_NO_DEPRECATED_CODE
template<typename Function, typename BoundingObject, typename... NP_Pack>
static Labeled_mesh_domain_3 create_implicit_mesh_domain(Function function_, BoundingObject bounding_object_, const NP_Pack& ...nps)
{
return create_implicit_mesh_domain(function_, bounding_object_, internal_np::combine_named_parameters(nps...));
}
template<typename ... NP_PACK>
static Labeled_mesh_domain_3 create_implicit_mesh_domain(const NP_PACK& ...nps)
{
return create_implicit_mesh_domain(internal_np::combine_named_parameters(nps...));
}
#endif //CGAL_NO_DEPRECATED_CODE
/// @}

15
Mesh_3/include/CGAL/Mesh_3/internal/parameters.h
View File

@ -1,3 +1,18 @@
// Copyright (c) 2009 INRIA Sophia-Antipolis (France).
// All rights reserved.
//
// This file is part of CGAL (www.cgal.org).
//
// $URL$
// $Id$
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-Commercial
//
//
//
//
//******************************************************************************
// File Description : Named Function Parameters specific code
//******************************************************************************
#ifndef CGAL_PARAMETERS_H
#define CGAL_PARAMETERS_H

19
Mesh_3/include/CGAL/exude_mesh_3.h
View File

@ -108,6 +108,17 @@ Mesh_optimization_return_code exude_mesh_3(C3T3& c3t3,const CGAL_NP_CLASS& np =
}
template<typename CGAL_NP_TEMPLATE_PARAMETERS_NO_DEFAULT>
Mesh_optimization_return_code exude_mesh_3(const CGAL_NP_CLASS& np)
{
static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::c3t3_param_t>::value, "Value for required parameter not found");
using parameters::choose_parameter;
using parameters::get_parameter;
int time_limit=choose_parameter(get_parameter(np,internal_np::maximum_running_time),0);
double sliver_bound= choose_parameter(get_parameter(np,internal_np::lower_sliver_bound),parameters::default_values_for_mesh_3::exude_sliver_bound);
auto c3t3 = get_parameter(np,internal_np::c3t3_param);
return exude_mesh_3_impl(c3t3,time_limit,sliver_bound);
}
#ifndef DOXYGEN_RUNNING
#ifndef CGAL_NO_DEPRECATED_CODE
template<typename C3T3, typename ... NP_PACK>
@ -115,6 +126,14 @@ Mesh_optimization_return_code exude_mesh_3(C3T3& c3t3,const CGAL_NP_CLASS& np =
{
return exude_mesh_3(c3t3,internal_np::combine_named_parameters(nps...));
}
template<typename ... NP_PACK>
Mesh_optimization_return_code exude_mesh_3(const NP_PACK& ...nps)
{
return exude_mesh_3(internal_np::combine_named_parameters(nps...));
}
#endif //CGAL_NO_DEPRECATED_CODE

24
Mesh_3/include/CGAL/lloyd_optimize_mesh_3.h
View File

@ -161,6 +161,24 @@ Mesh_optimization_return_code lloyd_optimize_mesh_3(C3T3& c3t3, MeshDomain& doma
bool do_freeze = choose_parameter(get_parameter(np,internal_np::freeze),true);
return lloyd_optimize_mesh_3_impl(c3t3, domain, time_limit, max_iterations, convergence_ratio, freeze_bound, do_freeze);
}
template<typename CGAL_NP_TEMPLATE_PARAMETERS_NO_DEFAULT>
Mesh_optimization_return_code lloyd_optimize_mesh_3(const CGAL_NP_CLASS& np)
{
static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::c3t3_param_t>::value, "Value for required parameter not found");
static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::mesh_domain_param_t>::value, "Value for required parameter not found");
using parameters::choose_parameter;
using parameters::get_parameter;
int max_iterations = choose_parameter(get_parameter(np, internal_np::number_of_iterations), 0);
const double convergence_ratio = choose_parameter(get_parameter(np, internal_np::convergence_ratio), 0.001);
const double freeze_bound = choose_parameter(get_parameter(np, internal_np::vertex_freeze_bound), 0.001);
const double time_limit = choose_parameter(get_parameter(np, internal_np::maximum_running_time), 0.);
bool do_freeze = choose_parameter(get_parameter(np,internal_np::freeze),true);
auto c3t3 = get_parameter(np,internal_np::c3t3_param);
auto domain = get_parameter(np,internal_np::mesh_domain_param);
return lloyd_optimize_mesh_3_impl(c3t3, domain, time_limit, max_iterations, convergence_ratio, freeze_bound, do_freeze);
}
#ifndef DOXYGEN_RUNNING
#ifndef CGAL_NO_DEPRECATED_CODE
template<typename C3T3, typename MeshDomain,typename ... NP_PACK>
@ -168,6 +186,12 @@ Mesh_optimization_return_code lloyd_optimize_mesh_3(C3T3& c3t3,MeshDomain& domai
{
return lloyd_optimize_mesh_3(c3t3,domain, internal_np::combine_named_parameters(nps...));
}
template<typename ... NP_PACK>
Mesh_optimization_return_code lloyd_optimize_mesh_3(const NP_PACK& ...nps)
{
return lloyd_optimize_mesh_3(internal_np::combine_named_parameters(nps...));
}
#endif //CGAL_NO_DEPRECATED_CODE
template <typename C3T3, typename MeshDomain>

2
Mesh_3/include/CGAL/make_mesh_3.h
View File

@ -545,7 +545,6 @@ C3T3 make_mesh_3(MeshDomain& domain, MeshCriteria& criteria, const CGAL_NP_CLASS
return c3t3;
}
#ifndef DOXYGEN_RUNNING
#ifndef CGAL_NO_DEPRECATED_CODE
template<typename C3T3, typename MeshDomain, typename MeshCriteria, typename ... NP_PACK>
@ -554,6 +553,7 @@ C3T3 make_mesh_3(MeshDomain& domain, MeshCriteria& criteria, const NP_PACK&...np
return make_mesh_3<C3T3>(domain, criteria, internal_np::combine_named_parameters(nps...));
}
#endif //CGAL_NO_DEPRECATED_CODE

23
Mesh_3/include/CGAL/odt_optimize_mesh_3.h
View File

@ -151,6 +151,24 @@ Mesh_optimization_return_code odt_optimize_mesh_3(C3T3& c3t3, MeshDomain& domain
bool do_freeze=choose_parameter(get_parameter(np,internal_np::freeze),true);
return odt_optimize_mesh_3_impl(c3t3, domain, time_limit, max_iteration_number, convergence, freeze_bound, do_freeze);
}
template<typename CGAL_NP_TEMPLATE_PARAMETERS_NO_DEFAULT>
Mesh_optimization_return_code odt_optimize_mesh_3(const CGAL_NP_CLASS& np)
{
static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::c3t3_param_t>::value, "Value for required parameter not found");
static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::mesh_domain_param_t>::value, "Value for required parameter not found");
using parameters::choose_parameter;
using parameters::get_parameter;
double time_limit=choose_parameter(get_parameter(np,internal_np::maximum_running_time),0);
std::size_t max_iteration_number=choose_parameter(get_parameter(np,internal_np::number_of_iterations),0);
double convergence=choose_parameter(get_parameter(np,internal_np::convergence_ratio),0.02);
double freeze_bound=choose_parameter(get_parameter(np,internal_np::vertex_freeze_bound),0.01);
bool do_freeze=choose_parameter(get_parameter(np,internal_np::freeze),true);
auto c3t3 = get_parameter(np,internal_np::c3t3_param);
auto domain = get_parameter(np,internal_np::mesh_domain_param);
return odt_optimize_mesh_3_impl(c3t3, domain, time_limit, max_iteration_number, convergence, freeze_bound, do_freeze);
}
#ifndef DOXYGEN_RUNNING
#ifndef CGAL_NO_DEPRECATED_CODE
template<typename C3T3, typename MeshDomain, typename... NP_Pack>
@ -158,6 +176,11 @@ Mesh_optimization_return_code odt_optimize_mesh_3(C3T3& c3t3, MeshDomain& domain
{
return odt_optimize_mesh_3(c3t3, domain, internal_np::combine_named_parameters(nps...));
}
template<typename ... NP_PACK>
Mesh_optimization_return_code odt_optimize_mesh_3(const NP_PACK& ...nps)
{
return odt_optimize_mesh_3(internal_np::combine_named_parameters(nps...));
}
#endif //CGAL_NO_DEPRECATED_CODE
template <typename C3T3, typename MeshDomain>

22
Mesh_3/include/CGAL/perturb_mesh_3.h
View File

@ -126,6 +126,23 @@ Mesh_optimization_return_code perturb_mesh_3(C3T3& c3t3, MeshDomain& domain, con
return perturb_mesh_3_impl(c3t3, domain, time_limit, sliver_criterion, perturbation_vector);
}
template<typename CGAL_NP_TEMPLATE_PARAMETERS_NO_DEFAULT>
Mesh_optimization_return_code perturb_mesh_3(const CGAL_NP_CLASS& np)
{
static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::c3t3_param_t>::value, "Value for required parameter not found");
static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::mesh_domain_param_t>::value, "Value for required parameter not found");
using parameters::choose_parameter;
using parameters::get_parameter;
auto c3t3 = get_parameter(np,internal_np::c3t3_param);
auto domain = get_parameter(np,internal_np::mesh_domain_param);
double time_limit = choose_parameter(get_parameter(np,internal_np::maximum_running_time),0);
auto sliver_bound = choose_parameter(get_parameter(np,internal_np::lower_sliver_bound), parameters::default_values_for_mesh_3::perturb_sliver_bound);
auto sliver_criterion = choose_parameter(get_parameter(np, internal_np::sliver_criteria), parameters::default_values_for_mesh_3::default_sliver_criterion(c3t3,sliver_bound));
auto perturbation_vector = choose_parameter(get_parameter(np,internal_np::perturb_vector), default_perturbation_vector(c3t3,domain,sliver_criterion));
return perturb_mesh_3_impl(c3t3, domain, time_limit, sliver_criterion, perturbation_vector);
}
#ifndef DOXYGEN_RUNNING
#ifndef CGAL_NO_DEPRECATED_CODE
template<typename C3T3, typename MeshDomain, typename ... NP_PACK>
@ -133,6 +150,11 @@ Mesh_optimization_return_code perturb_mesh_3(C3T3& c3t3, MeshDomain& domain, con
{
return perturb_mesh_3(c3t3,domain, internal_np::combine_named_parameters(nps...));
}
template<typename ... NP_PACK>
Mesh_optimization_return_code perturb_mesh_3(const NP_PACK& ...nps)
{
return perturb_mesh_3(internal_np::combine_named_parameters(nps...));
}
#endif //CGAL_NO_DEPRECATED_CODE
template <typename C3T3,

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

@ -465,6 +465,38 @@ void refine_mesh_3(C3T3& c3t3, MeshDomain& domain, MeshCriteria& criteria, const
mesh_options_param,
manifold_options_param);
}
template<typename CGAL_NP_TEMPLATE_PARAMETERS_NO_DEFAULT>
Mesh_optimization_return_code refine_mesh_3(const CGAL_NP_CLASS& np)
{
static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::c3t3_param_t>::value, "Value for required parameter not found");
static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::mesh_domain_param_t>::value, "Value for required parameter not found");
static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::mesh_criteria_param_t>::value, "Value for required parameter not found");
using parameters::choose_parameter;
using parameters::get_parameter;
auto c3t3 = get_parameter(np,internal_np::c3t3_param);
auto domain = get_parameter(np,internal_np::mesh_domain_param);
auto criteria = get_parameter(np, internal_np::mesh_criteria_param);
parameters::internal::Exude_options exude_param = choose_parameter(get_parameter(np, internal_np::exude_options_param), parameters::exude().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::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);
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());
return refine_mesh_3_impl(c3t3,
domain,
criteria,
exude_param,
perturb_param,
odt_param,
lloyd_param,
reset_param(),
mesh_options_param,
manifold_options_param);
}
#ifndef DOXYGEN_RUNNING
#ifndef CGAL_NO_DEPRECATED_CODE
template<typename C3T3, typename MeshDomain, typename MeshCriteria, typename... NP_Pack>
@ -472,6 +504,11 @@ void refine_mesh_3(C3T3& c3t3, MeshDomain& domain, MeshCriteria& criteria, const
{
return refine_mesh_3(c3t3, domain, criteria, internal_np::combine_named_parameters(nps...));
}
template<typename ... NP_PACK>
void refine_mesh_3(const NP_PACK& ...nps)
{
return refine_mesh_3(internal_np::combine_named_parameters(nps...));
}
#endif
/**

82
Periodic_3_mesh_3/include/CGAL/optimize_periodic_3_mesh_3.h
View File

@ -35,13 +35,32 @@ Mesh_optimization_return_code perturb_periodic_3_mesh_3(C3T3& c3t3, MeshDomain&
auto perturbation_vector = choose_parameter(get_parameter(np,internal_np::perturb_vector), default_perturbation_vector(c3t3,domain,sliver_criterion));
return perturb_mesh_3_impl(c3t3, domain, time_limit, sliver_criterion, perturbation_vector);
}
template<typename CGAL_NP_TEMPLATE_PARAMETERS_NO_DEFAULT>
Mesh_optimization_return_code perturb_periodic_3_mesh_3(const CGAL_NP_CLASS& np)
{
static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::c3t3_param_t>::value, "Value for required parameter not found");
static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::mesh_domain_param_t>::value, "Value for required parameter not found");
using parameters::choose_parameter;
using parameters::get_parameter;
auto c3t3 = get_parameter(np,internal_np::c3t3_param);
auto domain = get_parameter(np,internal_np::mesh_domain_param);
double time_limit = choose_parameter(get_parameter(np,internal_np::maximum_running_time),0);
auto sliver_bound = choose_parameter(get_parameter(np,internal_np::lower_sliver_bound), parameters::default_values_for_mesh_3::perturb_sliver_bound);
auto sliver_criterion = choose_parameter(get_parameter(np, internal_np::sliver_criteria), parameters::default_values_for_mesh_3::default_sliver_criterion(c3t3,sliver_bound));
auto perturbation_vector = choose_parameter(get_parameter(np,internal_np::perturb_vector), default_perturbation_vector(c3t3,domain,sliver_criterion));
return perturb_mesh_3_impl(c3t3, domain, time_limit, sliver_criterion, perturbation_vector);
}
#ifndef CGAL_NO_DEPRECATED_CODE
template<typename C3T3, typename MeshDomain, typename ... NP_PACK>
Mesh_optimization_return_code perturb_periodic_3_mesh_3(C3T3& c3t3, MeshDomain& domain, const NP_PACK& ... nps)
{
return perturb_periodic_3_mesh_3(c3t3,domain, internal_np::combine_named_parameters(nps...));
}
template<typename ... NP_PACK>
Mesh_optimization_return_code perturb_periodic_3_mesh_3(const NP_PACK& ...nps)
{
return perturb_periodic_3_mesh_3(internal_np::combine_named_parameters(nps...));
}
#endif //CGAL_NO_DEPRECATED_CODE
// ---------------------------------- exuder -----------------------------------
@ -55,13 +74,28 @@ Mesh_optimization_return_code exude_periodic_3_mesh_3(C3T3& c3t3,const CGAL_NP_C
return exude_mesh_3_impl(c3t3,time_limit,sliver_bound);
}
template<typename CGAL_NP_TEMPLATE_PARAMETERS_NO_DEFAULT>
Mesh_optimization_return_code exude_periodic_3_mesh_3(const CGAL_NP_CLASS& np)
{
static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::c3t3_param_t>::value, "Value for required parameter not found");
using parameters::choose_parameter;
using parameters::get_parameter;
auto c3t3 = get_parameter(np,internal_np::c3t3_param);
int time_limit=choose_parameter(get_parameter(np,internal_np::maximum_running_time),0);
double sliver_bound= choose_parameter(get_parameter(np,internal_np::lower_sliver_bound),parameters::default_values_for_mesh_3::exude_sliver_bound);
return exude_mesh_3_impl(c3t3,time_limit,sliver_bound);
}
#ifndef CGAL_NO_DEPRECATED_CODE
template<typename C3T3, typename ... NP_PACK>
Mesh_optimization_return_code exude_periodic_3_mesh_3(C3T3& c3t3, const NP_PACK& ...nps)
{
return exude_periodic_3_mesh_3(c3t3,internal_np::combine_named_parameters(nps...));
}
template<typename ... NP_PACK>
Mesh_optimization_return_code exude_periodic_3_mesh_3(const NP_PACK& ...nps)
{
return exude_periodic_3_mesh_3(internal_np::combine_named_parameters(nps...));
}
#endif //CGAL_NO_DEPRECATED_CODE
// ------------------------------ odt optimizer --------------------------------
@ -78,13 +112,33 @@ Mesh_optimization_return_code odt_optimize_periodic_3_mesh_3(C3T3& c3t3, MeshDom
bool do_freeze=choose_parameter(get_parameter(np,internal_np::freeze),true);
return odt_optimize_mesh_3_impl(c3t3, domain, time_limit, max_iteration_number, convergence, freeze_bound, do_freeze);
}
template<typename CGAL_NP_TEMPLATE_PARAMETERS_NO_DEFAULT>
Mesh_optimization_return_code odt_optimize_periodic_3_mesh_3(const CGAL_NP_CLASS& np)
{
static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::c3t3_param_t>::value, "Value for required parameter not found");
static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::mesh_domain_param_t>::value, "Value for required parameter not found");
using parameters::choose_parameter;
using parameters::get_parameter;
auto c3t3 = get_parameter(np,internal_np::c3t3_param);
auto domain = get_parameter(np,internal_np::mesh_domain_param);
double time_limit=choose_parameter(get_parameter(np,internal_np::maximum_running_time),0);
std::size_t max_iteration_number=choose_parameter(get_parameter(np,internal_np::number_of_iterations),0);
double convergence=choose_parameter(get_parameter(np,internal_np::convergence_ratio),0.02);
double freeze_bound=choose_parameter(get_parameter(np,internal_np::vertex_freeze_bound),0.01);
bool do_freeze=choose_parameter(get_parameter(np,internal_np::freeze),true);
return odt_optimize_mesh_3_impl(c3t3, domain, time_limit, max_iteration_number, convergence, freeze_bound, do_freeze);
}
#ifndef CGAL_NO_DEPRECATED_CODE
template<typename C3T3, typename MeshDomain, typename... NP_Pack>
Mesh_optimization_return_code odt_optimize_periodic_3_mesh_3(C3T3& c3t3, MeshDomain& domain, const NP_Pack& ...nps)
{
return odt_optimize_periodic_3_mesh_3(c3t3, domain, internal_np::combine_named_parameters(nps...));
}
template<typename ... NP_PACK>
Mesh_optimization_return_code odt_optimize_periodic_3_mesh_3(const NP_PACK& ...nps)
{
return odt_optimize_periodic_3_mesh_3(internal_np::combine_named_parameters(nps...));
}
#endif //CGAL_NO_DEPRECATED_CODE
@ -101,13 +155,33 @@ Mesh_optimization_return_code lloyd_optimize_periodic_3_mesh_3(C3T3& c3t3, MeshD
bool do_freeze = choose_parameter(get_parameter(np,internal_np::freeze),true);
return lloyd_optimize_mesh_3_impl(c3t3, domain, time_limit, max_iterations, convergence_ratio, freeze_bound, do_freeze);
}
template<typename CGAL_NP_TEMPLATE_PARAMETERS_NO_DEFAULT>
Mesh_optimization_return_code lloyd_optimize_periodic_3_mesh_3(const CGAL_NP_CLASS& np)
{
static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::c3t3_param_t>::value, "Value for required parameter not found");
static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::mesh_domain_param_t>::value, "Value for required parameter not found");
using parameters::choose_parameter;
using parameters::get_parameter;
auto c3t3 = get_parameter(np,internal_np::c3t3_param);
auto domain = get_parameter(np,internal_np::mesh_domain_param);
int max_iterations = choose_parameter(get_parameter(np, internal_np::number_of_iterations), 0);
const double convergence_ratio = choose_parameter(get_parameter(np, internal_np::convergence_ratio), 0.001);
const double freeze_bound = choose_parameter(get_parameter(np, internal_np::vertex_freeze_bound), 0.001);
const double time_limit = choose_parameter(get_parameter(np, internal_np::maximum_running_time), 0.);
bool do_freeze = choose_parameter(get_parameter(np,internal_np::freeze),true);
return lloyd_optimize_mesh_3_impl(c3t3, domain, time_limit, max_iterations, convergence_ratio, freeze_bound, do_freeze);
}
#ifndef CGAL_NO_DEPRECATED_CODE
template<typename C3T3, typename MeshDomain,typename ... NP_PACK>
Mesh_optimization_return_code lloyd_optimize_periodic_3_mesh_3(C3T3& c3t3,MeshDomain& domain, const NP_PACK& ...nps)
{
return lloyd_optimize_periodic_3_mesh_3(c3t3,domain, internal_np::combine_named_parameters(nps...));
}
template<typename ... NP_PACK>
Mesh_optimization_return_code lloyd_optimize_periodic_3_mesh_3(const NP_PACK& ...nps)
{
return lloyd_optimize_periodic_3_mesh_3(internal_np::combine_named_parameters(nps...));
}
#endif //CGAL_NO_DEPRECATED_CODE
} // namespace CGAL

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

@ -322,6 +322,37 @@ void refine_periodic_3_mesh_3(C3T3& c3t3, MeshDomain& domain, MeshCriteria& crit
manifold_options_param);
}
template<typename CGAL_NP_TEMPLATE_PARAMETERS_NO_DEFAULT>
void refine_periodic_3_mesh_3(const CGAL_NP_CLASS& np)
{
static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::c3t3_param_t>::value, "Value for required parameter not found");
static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::mesh_domain_param_t>::value, "Value for required parameter not found");
static_assert(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::mesh_criteria_param_t>::value, "Value for required parameter not found");
using parameters::choose_parameter;
using parameters::get_parameter;
auto c3t3 = get_parameter(np,internal_np::c3t3_param);
auto domain = get_parameter(np,internal_np::mesh_domain_param);
auto criteria = get_parameter(np, internal_np::mesh_criteria_param);
parameters::internal::Exude_options exude_param = choose_parameter(get_parameter(np, internal_np::exude_options_param), parameters::no_exude());
parameters::internal::Perturb_options perturb_param = choose_parameter(get_parameter(np, internal_np::perturb_options_param), parameters::no_perturb());
parameters::internal::Odt_options odt_param = choose_parameter(get_parameter(np, internal_np::odt_options_param), parameters::no_odt());
parameters::internal::Lloyd_options lloyd_param = choose_parameter(get_parameter(np, internal_np::lloyd_options_param), parameters::no_lloyd());
parameters::Reset reset_param = choose_parameter(get_parameter(np, internal_np::reset_options_param), parameters::reset_c3t3());
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());
return refine_periodic_3_mesh_3_impl(c3t3,
domain,
criteria,
exude_param,
perturb_param,
odt_param,
lloyd_param,
reset_param(),
mesh_options_param,
manifold_options_param);
}
#ifndef DOXYGEN_RUNNING
#ifndef CGAL_NO_DEPRECATED_CODE
template<typename C3T3, typename MeshDomain, typename MeshCriteria, typename... NP_Pack>
@ -329,6 +360,11 @@ void refine_periodic_3_mesh_3(C3T3& c3t3, MeshDomain& domain, MeshCriteria& crit
{
return refine_periodic_3_mesh_3(c3t3, domain, criteria, internal_np::combine_named_parameters(nps...));
}
template<typename ... NP_PACK>
void refine_periodic_3_mesh_3(const NP_PACK& ...nps)
{
return refine_periodic_3_mesh_3(internal_np::combine_named_parameters(nps...));
}
#endif
/**
* @brief This function refines the mesh c3t3 wrt domain & criteria

5
STL_Extension/include/CGAL/Named_function_parameters.h
View File

@ -347,6 +347,9 @@ const Boost_parameter_compatibility_wrapper<internal_np::sliver_criteria_t> sliv
const Boost_parameter_compatibility_wrapper<internal_np::perturb_vector_t> perturbation_vector;
//Compatibility wrappers for exude_mesh_3.h
const Boost_parameter_compatibility_wrapper<internal_np::lower_sliver_bound_t> sliver_bound;
const Boost_parameter_compatibility_wrapper<internal_np::c3t3_param_t> c3t3_named_param;
const Boost_parameter_compatibility_wrapper<internal_np::mesh_domain_param_t> mesh_domain;
const Boost_parameter_compatibility_wrapper<internal_np::mesh_criteria_param_t> mesh_criteria;
const Boost_parameter_compatibility_wrapper<internal_np::mesh_topology_number_t> mesh_topology;
const Boost_parameter_compatibility_wrapper<internal_np::dump_after_init_prefix_param_t> dump_after_init_prefix;
const Boost_parameter_compatibility_wrapper<internal_np::dump_after_refine_surface_prefix_param_t> dump_after_refine_surface_prefix;
@ -368,6 +371,8 @@ const Boost_parameter_compatibility_wrapper<internal_np::mesh_param_t> mesh_opti
const Boost_parameter_compatibility_wrapper<internal_np::manifold_param_t> manifold_options_param;
const Boost_parameter_compatibility_wrapper<internal_np::features_option_param_t> features_param;
const Boost_parameter_compatibility_wrapper<internal_np::function_param_t> function;
const Boost_parameter_compatibility_wrapper<internal_np::bounding_object_param_t> bounding_object;
const Boost_parameter_compatibility_wrapper<internal_np::image_3_param_t> image;
const Boost_parameter_compatibility_wrapper<internal_np::iso_value_param_t> iso_value;
const Boost_parameter_compatibility_wrapper<internal_np::image_subdomain_index_t> image_values_to_subdomain_indices;

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

@ -252,7 +252,9 @@ CGAL_add_named_parameter(i_seed_end_iterator_t, i_seed_end_iterator, i_seed_end_
//List of named parameters used in exude_mesh_3.h
CGAL_add_named_parameter(lower_sliver_bound_t,lower_sliver_bound,lower_sliver_bound)
CGAL_add_named_parameter(freeze_t,freeze,freeze)
CGAL_add_named_parameter(c3t3_param_t, c3t3_param, c3t3_param)
CGAL_add_named_parameter(mesh_domain_param_t, mesh_domain_param, mesh_domain_param)
CGAL_add_named_parameter(mesh_criteria_param_t, mesh_criteria_param, mesh_criteria_param)
//List of named parameters used in perturb_mesh_3.h
CGAL_add_named_parameter(sliver_criteria_t, sliver_criteria, sliver_criteria)
CGAL_add_named_parameter(perturb_vector_t, perturb_vector, perturb_vector)
@ -302,5 +304,5 @@ CGAL_add_named_parameter(cell_size_param_t, cell_size_param, cell_size_param)
CGAL_add_named_parameter(cell_sizing_field_param_t, cell_sizing_field_param, cell_sizing_field_param)
CGAL_add_named_parameter(sizing_field_param_t, sizing_field_param, sizing_field_param)
CGAL_add_named_parameter(function_param_t, function_param, function_param)
CGAL_add_named_parameter(bounding_object_param_t, bounding_object_param, bounding_object_param)