CGAL 5.0  3D Mesh Generation

The two main functions to generate a mesh are make_mesh_3()
and refine_mesh_3()
.
The other functions allow to optimize an existing mesh.
Functions  
template<typename C3T3 >  
Mesh_optimization_return_code  CGAL::exude_mesh_3 (C3T3 &c3t3, double parameters::time_limit=0, double parameters::sliver_bound=0) 
The function exude_mesh_3() performs a sliver exudation process on a Delaunay mesh. More...  
template<class C3T3 , class TriangleMesh >  
void  CGAL::facets_in_complex_3_to_triangle_mesh (const C3T3 &c3t3, TriangleMesh &graph) 
builds a TriangleMesh from the surface facets, with a consistent orientation at the interface of two subdomains. More...  
template<typename C3T3 , typename MD >  
Mesh_optimization_return_code  CGAL::lloyd_optimize_mesh_3 (C3T3 &c3t3, const MD &domain, double parameters::time_limit=0, std::size_t parameters::max_iteration_number=0, double parameters::convergence=0.02, double parameters::freeze_bound=0.01, bool parameters::do_freeze=true) 
The function lloyd_optimize_mesh_3() is a mesh optimization process based on the minimization of a global energy function. More...  
template<class C3T3 , class MD , class MC >  
C3T3  CGAL::make_mesh_3 (const MD &domain, const MC &criteria, parameters::internal::Features_options features=parameters::features(domain), parameters::internal::Lloyd_options lloyd=parameters::no_lloyd(), parameters::internal::Odt_options odt=parameters::no_odt(), parameters::internal::Perturb_options perturb=parameters::perturb(), parameters::internal::Exude_options exude=parameters::exude(), parameters::internal::Manifold_options manifold=parameters::non_manifold()) 
The function make_mesh_3() is a 3D mesh generator. More...  
template<typename C3T3 , typename MD >  
Mesh_optimization_return_code  CGAL::odt_optimize_mesh_3 (C3T3 &c3t3, const MD &domain, double parameters::time_limit=0, std::size_t parameters::max_iteration_number=0, double parameters::convergence=0.02, double parameters::freeze_bound=0.01, bool parameters::do_freeze=true) 
The function odt_optimize_mesh_3() is a mesh optimization process based on the minimization of a global energy function. More...  
template<typename C3T3 , typename MD >  
Mesh_optimization_return_code  CGAL::perturb_mesh_3 (C3T3 &c3t3, const MD &domain, double parameters::time_limit=0, double parameters::sliver_bound=0) 
The function perturb_mesh_3() is a mesh optimizer that improves the quality of a Delaunay mesh by changing the positions of some vertices of the mesh. More...  
template<class C3T3 , class MD , class MC >  
void  CGAL::refine_mesh_3 (C3T3 &c3t3, const MD &mesh_domain, const MC &mesh_criteria, parameters::internal::Lloyd_options lloyd=parameters::no_lloyd(), parameters::internal::Odt_options odt=parameters::no_odt(), parameters::internal::Perturb_options perturb=parameters::perturb(), parameters::internal::Exude_options exude=parameters::exude(), parameters::internal::Manifold_options manifold=parameters::non_manifold()) 
The function refine_mesh_3() is a 3D mesh generator. More...  
Mesh_optimization_return_code CGAL::exude_mesh_3  (  C3T3 &  c3t3, 
double parameters::time_limit  = 0 , 

double parameters::sliver_bound  = 0 

) 
#include <CGAL/exude_mesh_3.h>
The function exude_mesh_3()
performs a sliver exudation process on a Delaunay mesh.
The sliver exudation process consists in optimizing the weights of vertices of the weighted Delaunay triangulation in such a way that slivers disappear and the quality of the mesh improves.
time_limit
\( \geq\) 0 and 0 \( \leq\) sliver_bound
\( \leq\) 180C3T3  is required to be a model of the concept MeshComplex_3InTriangulation_3 . The argument c3t3 , passed by reference, provides the initial mesh and is modified by the algorithm to represent the final optimized mesh. 
The function has two optional parameters which are named parameters (we use the Boost.Parameter library). Therefore, when calling the function, the parameters can be provided in any order provided that the names of the parameters are used (see example at the bottom of this page).
Named Parameters
parameters::time_limit
is used to set up, in seconds, a CPU time limit after which the optimization process is stopped. This time is measured using the Real_timer
class. The default value is 0 and means that there is no time limit.parameters::sliver_bound
is designed to give, in degrees, a targeted lower bound on dihedral angles of mesh cells. The exudation process considers in turn all the mesh cells that have a smallest dihedral angle less than sliver_bound
and tries to make them disappear by weighting their vertices. The optimization process stops when every cell in the mesh achieves this quality. The default value is 0 and means that there is no targeted bound: the exuder then runs as long as it can improve the smallest dihedral angles of the set of cells incident to some vertices.exude_mesh_3()
returns a value of type CGAL::Mesh_optimization_return_code
which is: CGAL::BOUND_REACHED
when the targeted bound for the smallest dihedral angle in the mesh is reached. CGAL::TIME_LIMIT_REACHED
when the time limit is reached. CGAL::CANT_IMPROVE_ANYMORE
when exudation process stops because it can no longer improve the smallest dihedral angle of the set of cells incident to some vertex in the mesh. Example
void CGAL::facets_in_complex_3_to_triangle_mesh  (  const C3T3 &  c3t3, 
TriangleMesh &  graph  
) 
#include <CGAL/IO/facets_in_complex_3_to_triangle_mesh.h>
builds a TriangleMesh
from the surface facets, with a consistent orientation at the interface of two subdomains.
This function exports the surface as a TriangleMesh
and appends it to graph
, using orient_polygon_soup()
.
C3T3  a model of MeshComplexWithFeatures_3InTriangulation_3 . 
TriangleMesh  a model of MutableFaceGraph with an internal point property map. The point type should be compatible with the one used in C3T3 . 
c3t3  an instance of C3T3 . 
graph  an instance of TriangleMesh . 
Mesh_optimization_return_code CGAL::lloyd_optimize_mesh_3  (  C3T3 &  c3t3, 
const MD &  domain,  
double parameters::time_limit  = 0 , 

std::size_t parameters::max_iteration_number  = 0 , 

double parameters::convergence  = 0.02 , 

double parameters::freeze_bound  = 0.01 , 

bool parameters::do_freeze  = true 

) 
#include <CGAL/lloyd_optimize_mesh_3.h>
The function lloyd_optimize_mesh_3()
is a mesh optimization process based on the minimization of a global energy function.
In lloyd_optimize_mesh_3()
, the minimized global energy may be interpreted as the \( L^1\)norm of the error achieved when the function \( x^2\) is interpolated on the mesh domain using a piecewise linear function which is linear in each cell of the Voronoi diagram of the mesh vertices.
The optimizer lloyd_optimize_mesh_3()
works in iterative steps. At each iteration, mesh vertices are moved into positions that bring to zero the energy gradient and the Delaunay triangulation is updated. Vertices on the mesh boundaries are handled in a special way so as to preserve an accurate representation of the domain boundaries.
time_limit
\( \geq\) 0 and 0 \( \leq\) convergence
\( \leq\) 1 and 0 \( \leq\) freeze_bound
\( \leq\) 1C3T3  is required to be a model of the concept MeshComplex_3InTriangulation_3 . The argument c3t3 , passed by reference, provides the initial mesh and is modified by the algorithm to represent the final optimized mesh. 
MD  is required to be a model of the concept MeshDomain_3 . The argument domain must be the MD object used to create the c3t3 parameter. 
The function has four optional parameters which are named parameters (we use the Boost.Parameter library). Therefore, when calling the function, the parameters can be provided in any order provided that the names of the parameters are used (see example at the bottom of this page).
Named Parameters
parameters::time_limit
is used to set up, in seconds, a CPU time limit after which the optimization process is stopped. This time is measured using Real_timer
. The default value is 0 and means that there is no time limit.parameters::max_iteration_number
sets a limit on the number of performed iterations. The default value of 0 means that there is no limit on the number of performed iterations.parameters::convergence
is a stopping criterion based on convergence: the optimization process is stopped, when at the last iteration, the displacement of any vertex is less than a given percentage of the length of the shortest edge incident to that vertex. The parameter convergence
gives the threshold ratio.parameters::freeze_bound
is designed to reduce running time of each optimization iteration. Any vertex that has a displacement less than a given percentage of the length (the of its shortest incident edge, is frozen (i.e. is not relocated). The parameter freeze_bound
gives the threshold ratio.parameters::do_freeze
completes the freeze_bound
parameter. If it is set to true
(default value), frozen vertices will not move anymore in next iterations. Otherwise, at each iteration, any vertex that moves, unfreezes all its incident vertices.lloyd_optimize_mesh_3()
returns a value of type CGAL::Mesh_optimization_return_code
which is: CGAL::TIME_LIMIT_REACHED
when the time limit is reached. CGAL::MAX_ITERATION_NUMBER_REACHED
when lloyd_optimize_mesh_3()
stops because it has performed max_iteration_number
iterations. CGAL::CONVERGENCE_REACHED
when lloyd_optimize_mesh_3()
stops because the convergence criterion is achieved. CGAL::ALL_VERTICES_FROZEN
when all vertices have been frozen, when the do_freeze
parameter is set to true. CGAL::CANT_IMPROVE_ANYMORE
when lloyd_optimize_mesh_3()
stops because most vertices have been frozen, and no better convergence can be reached. Example
CGAL::Mesh_optimization_return_code
CGAL::make_mesh_3()
CGAL::refine_mesh_3()
CGAL::exude_mesh_3()
CGAL::perturb_mesh_3()
CGAL::odt_optimize_mesh_3()
C3T3 CGAL::make_mesh_3  (  const MD &  domain, 
const MC &  criteria,  
parameters::internal::Features_options  features = parameters::features(domain) , 

parameters::internal::Lloyd_options  lloyd = parameters::no_lloyd() , 

parameters::internal::Odt_options  odt = parameters::no_odt() , 

parameters::internal::Perturb_options  perturb = parameters::perturb() , 

parameters::internal::Exude_options  exude = parameters::exude() , 

parameters::internal::Manifold_options  manifold = parameters::non_manifold() 

) 
#include <CGAL/make_mesh_3.h>
The function make_mesh_3()
is a 3D mesh generator.
It produces simplicial meshes which discretize 3D domains.
The mesh generation algorithm is a Delaunay refinement process followed by an optimization phase. The criteria driving the Delaunay refinement process may be tuned to achieve the user needs with respect to the size of mesh elements, the accuracy of boundaries approximation, etc.
The optimization phase is a sequence of optimization processes, amongst the following available optimizers: an ODTsmoothing, a Lloydsmoothing, a sliver perturber, and a sliver exuder. Each optimization process can be activated or not, according to the user requirements and available time. By default, only the perturber and the exuder are activated. Note that the benefits of the exuder will be lost if the mesh is further refined afterward, and that ODTsmoothing, Lloydsmoothing, and sliver perturber should never be called after the sliver exuder. In the case of further refinement, only the sliver exuder can be used.
The function outputs the mesh to an object which provides iterators to traverse the resulting mesh data structure or can be written to a file (see Examples ).
C3T3  is required to be a model of the concept MeshComplex_3InTriangulation_3 . This is the return type. The type C3T3 is in particular required to provide a nested type C3T3::Triangulation for the 3D triangulation embedding the mesh. The vertex and cell base classes of the triangulation C3T3::Triangulation are required to be models of the concepts MeshVertexBase_3 and MeshCellBase_3 respectively. 
MD  is required to be a model of the concept MeshDomain_3 , or of the refined concept MeshDomainWithFeatures_3 if the domain has corners and curves that need to be accurately represented in the mesh. The argument domain is the sole link through which the domain to be discretized is known by the mesh generation algorithm. 
MC  has to be a model of the concept MeshCriteria_3 , or a model of the refined concept MeshCriteriaWithFeatures_3 if the domain has exposed features. The argument criteria of type MC specifies the size and shape requirements for mesh tetrahedra and surface facets. These criteria form the rules which drive the refinement process. All mesh elements satisfy those criteria at the end of the refinement process. In addition, if the domain has features, the argument criteria provides a sizing field to guide the discretization of 1dimensional exposed features. 
Named Parameters
features
allows the user to specify whether 0 and 1dimensional features have to be taken into account or not when the domain is a model of MeshDomainWithFeatures_3
. The type Features
of this parameter is an internal undescribed type. The library provides functions to construct appropriate values of that type. parameters::features(domain)
sets features
according to the domain, i.e. 0 and 1dimensional features are taken into account if domain
is a MeshDomainWithFeatures_3
. This is the default behavior if parameter features
is not specified. parameters::no_features()
prevents the representation of 0 and 1dimensional features in the mesh. manifold
allows the user to drive the meshing algorithm, and ensure that the output mesh surface follows the given manifold criterion. It can be activated with parameters::manifold()
, parameters::manifold_with_boundary()
and parameters::non_manifold()
. Note that the meshing algorithm cannot generate a manifold surface if the input surface is not manifold.The four additional parameters are optimization parameters. They control which optimization processes are performed and allow the user to tune the parameters of the optimization processes. Individual optimization parameters are not described here as they are internal types (see instead the documentation page of each optimizer). For each optimization algorithm, there exist two global functions that allow to enable or disable the optimizer:
lloyd
: parameters::lloyd()
and parameters::no_lloyd()
are designed to trigger or not a call to lloyd_optimize_mesh_3()
function and to set the parameters of this optimizer. If one parameter is not set, the default value of lloyd_optimize_mesh_3()
is used for this parameter.ODT
: parameters::odt()
and parameters::no_odt()
are designed to trigger or not a call to odt_optimize_mesh_3
function and to set the parameters of this optimizer. If one parameter is not set, the default value of odt_optimize_mesh_3()
is used for this parameter.perturb
: parameters::perturb()
and parameters::no_perturb()
are designed to trigger or not a call to perturb_mesh_3
function and to set the parameters of this optimizer. If one parameter is not set, the default value of CGAL::perturb_mesh_3
is used for this parameter, except for the time bound which is set to be equal to the refinement CPU time.exude
: parameters::exude()
and parameters::no_exude()
are designed to trigger or not a call to exude_mesh_3()
function and to override to set the parameters of this optimizer. If one parameter is not set, the default value of exude_mesh_3()
is used for this parameter, except for the time bound which is set to be equal to the refinement CPU time.The optimization parameters can be passed in an arbitrary order. If one parameter is not passed, its default value is used. The default values are no_lloyd()
, no_odt()
, perturb()
and exude()
.
Note that whatever may be the optimization processes activated, they are always launched in the order that is a suborder of the following (see user manual for further details): ODTsmoother, Lloydsmoother, perturber, and exuder.
Beware that optimization of the mesh is obtained by perturbing mesh vertices and modifying the mesh connectivity and that this has an impact on the strict compliance to the refinement criteria. Though a strict compliance to mesh criteria is guaranteed at the end of the Delaunay refinement, this may no longer be true after some optimization processes. Also beware that the default behavior does involve some optimization processes.
refine_mesh_3()
parameters::features()
parameters::no_features()
parameters::manifold()
parameters::manifold_with_boundary()
parameters::non_manifold()
exude_mesh_3()
perturb_mesh_3()
lloyd_optimize_mesh_3()
odt_optimize_mesh_3()
parameters::exude()
parameters::no_exude()
parameters::perturb()
parameters::no_perturb()
parameters::lloyd()
parameters::no_lloyd()
parameters::odt()
parameters::no_odt()
Mesh_optimization_return_code CGAL::odt_optimize_mesh_3  (  C3T3 &  c3t3, 
const MD &  domain,  
double parameters::time_limit  = 0 , 

std::size_t parameters::max_iteration_number  = 0 , 

double parameters::convergence  = 0.02 , 

double parameters::freeze_bound  = 0.01 , 

bool parameters::do_freeze  = true 

) 
#include <CGAL/odt_optimize_mesh_3.h>
The function odt_optimize_mesh_3()
is a mesh optimization process based on the minimization of a global energy function.
In odt_optimize_mesh_3()
, the minimized global energy may be interpreted as the \( L^1\)norm of the error achieved when the function \( x^2\) is interpolated on the mesh domain using a piecewise linear function which is linear in each mesh cell.
The optimizer odt_optimize_mesh_3()
works in iterative steps. At each iteration, mesh vertices are moved into positions that bring to zero the energy gradient and the Delaunay triangulation is updated. Vertices on the mesh boundaries are handled in a special way so as to preserve an accurate representation of the domain boundaries.
time_limit
\( \geq\) 0 and 0 \( \leq\) convergence
\( \leq\) 1 and 0 \( \leq\) freeze_bound
\( \leq\) 1C3T3  is required to be a model of the concept MeshComplex_3InTriangulation_3 . The argument c3t3 , passed by reference, provides the initial mesh and is modified by the algorithm to represent the final optimized mesh. 
MD  is required to be a model of the concept MeshDomain_3 . The argument domain must be the MD object used to create the c3t3 parameter. 
The function has four optional parameters which are named parameters (we use the Boost.Parameter library). Therefore, when calling the function, the parameters can be provided in any order provided that the names of the parameters are used (see example at the bottom of this page).
Named Parameters
parameters::time_limit
is used to set up, in seconds, a CPU time limit after which the optimization process is stopped. This time is measured using Real_timer
. The default value is 0 and means that there is no time limit.parameters::max_iteration_number
sets a limit on the number of performed iterations. The default value of 0 means that there is no limit on the number of performed iterations.parameters::convergence
is a stopping criterion based on convergence: the optimization process is stopped, when at the last iteration, the displacement of any vertex is less than a given percentage of the length the shortest edge incident to that vertex. The parameter convergence
gives the threshold ratio.parameters::freeze_bound
is designed to reduce running time of each optimization iteration. Any vertex that has a displacement less than a given percentage of the length (the of its shortest incident edge, is frozen (i.e. is not relocated). The parameter freeze_bound
gives the threshold ratio.parameters::do_freeze
completes the freeze_bound
parameter. If it is set to true
(default value), frozen vertices will not move anymore in next iterations. Otherwise, at each iteration, any vertex that moves, unfreezes all its incident vertices.odt_optimize_mesh_3()
returns a value of type CGAL::Mesh_optimization_return_code
which is: CGAL::TIME_LIMIT_REACHED
when the time limit is reached. CGAL::MAX_ITERATION_NUMBER_REACHED
when odt_optimize_mesh_3()
stops because it has performed max_iteration_number
iterations. CGAL::CONVERGENCE_REACHED
when odt_optimize_mesh_3()
stops because the convergence criterion is achieved. CGAL::ALL_VERTICES_FROZEN
when all vertices have been frozen, when the do_freeze
parameter is set to true. CGAL::CANT_IMPROVE_ANYMORE
when odt_optimize_mesh_3()
stops because most vertices have been frozen, and no better convergence can be reached. Example
Mesh_optimization_return_code CGAL::perturb_mesh_3  (  C3T3 &  c3t3, 
const MD &  domain,  
double parameters::time_limit  = 0 , 

double parameters::sliver_bound  = 0 

) 
#include <CGAL/perturb_mesh_3.h>
The function perturb_mesh_3()
is a mesh optimizer that improves the quality of a Delaunay mesh by changing the positions of some vertices of the mesh.
The perturber tries to improve the dihedral angles of the worst cells in the mesh degree by degree: the step number n
is considered as successful if after this step the worst tetrahedron of the mesh has a minimal dihedral angle larger than n
degrees. The perturber exits if this is not the case.
time_limit
\( \geq\) 0 and 0 \( \leq\) sliver_bound
\( \leq\) 180C3T3  is required to be a model of the concept MeshComplex_3InTriangulation_3 . The argument c3t3 , passed by reference, provides the initial mesh and is modified by the algorithm to represent the final optimized mesh. 
MD  is required to be a model of the concept MeshDomain_3 . The argument domain must be the MD object used to create the c3t3 parameter. 
The function has two optional parameters which are named parameters (we use the Boost.Parameter library). Therefore, when calling the function, the parameters can be provided in any order provided that the names of the parameters are used (see example at the bottom of this page).
Named Parameters
parameters::time_limit
is used to set up, in seconds, a CPU time limit after which the optimization process is stopped. This time is measured using Real_timer
. The default value is 0 and means that there is no time limit.parameters::sliver_bound
is designed to give, in degrees, a targeted lower bound on dihedral angles of mesh cells. The function perturb_mesh_3()
runs as long as steps are successful and step number sliver_bound
(after which the worst tetrahedron in the mesh has a smallest angle larger than sliver_bound
degrees) has not been reached. The default value is 0 and means that there is no targeted bound: the perturber then runs as long as steps are successful.perturb_mesh_3()
returns a value of type CGAL::Mesh_optimization_return_code
which is: CGAL::BOUND_REACHED
when the targeted bound for the smallest dihedral angle in the mesh is reached. CGAL::TIME_LIMIT_REACHED
when the time limit is reached. CGAL::CANT_IMPROVE_ANYMORE
when the perturbation process stops because the last step is unsuccessful. Example
void CGAL::refine_mesh_3  (  C3T3 &  c3t3, 
const MD &  mesh_domain,  
const MC &  mesh_criteria,  
parameters::internal::Lloyd_options  lloyd = parameters::no_lloyd() , 

parameters::internal::Odt_options  odt = parameters::no_odt() , 

parameters::internal::Perturb_options  perturb = parameters::perturb() , 

parameters::internal::Exude_options  exude = parameters::exude() , 

parameters::internal::Manifold_options  manifold = parameters::non_manifold() 

) 
#include <CGAL/refine_mesh_3.h>
The function refine_mesh_3()
is a 3D mesh generator.
It produces simplicial meshes which discretize 3D domains.
The mesh generation algorithm is a Delaunay refinement process followed by an optimization phase. The criteria driving the Delaunay refinement process may be tuned to achieve the user needs with respect to the size of mesh elements, the accuracy of boundaries approximation, etc.
The optimization phase is a sequence of optimization processes, amongst the following available optimizers: an ODTsmoothing, a Lloyd smoothing, a sliver perturber, and a sliver exuder. Each optimization process can be activated or not, according to the user requirements and available time. By default, only the perturber and the exuder are activated. Note that the benefits of the exuder will be lost if the mesh is further refined afterward.
refine_mesh_3()
may be used to refine a previously computed mesh, e.g.: Please note that we guarantee the result if and only if the domain does not change from one refinement to the next one.
C3T3  is required to be a model of the concept MeshComplex_3InTriangulation_3 . The argument c3t3 is passed by reference as this object is modified by the refinement process. As the refinement process only adds points to the triangulation, all vertices of the triangulation of c3t3 remain in the mesh during the refinement process. Object c3t3 can be used to insert specific points in the domain to ensure that they will be contained in the final triangulation. The type C3T3 is in particular required to provide a nested type C3T3::Triangulation for the 3D triangulation embedding the mesh. The vertex and cell base classes of the triangulation C3T3::Triangulation are required to be models of the concepts MeshVertexBase_3 and MeshCellBase_3 respectively. 
MD  is required to be a model of the concept MeshDomain_3 or of the refined concept MeshDomainWithFeatures_3 if 0 and 1dimensional features of the input complex have to be accurately represented in the mesh. The argument domain is the sole link through which the domain to be discretized is known by the mesh generation algorithm. 
MC  is required to be a model of the concept MeshCriteria_3 , or a model of the refined concept MeshCriteriaWithFeatures_3 if the domain has exposed features. The argument criteria of type MC specifies the size and shape requirements for mesh tetrahedra and surface facets. These criteria form the rules which drive the refinement process. All mesh elements satisfy those criteria at the end of the refinement process. In addition, if the domain has features, the argument criteria provides a sizing field to guide the discretization of 1dimensional exposed features. 
The four additional parameters are optimization parameters. They control which optimization processes are performed and allow the user to tune the parameters of the optimization processes. Individual optimization parameters are not described here as they are internal types (see instead the documentation page of each optimizer). For each optimization algorithm, there exist two global functions that allow to enable or disable the optimizer:
Named Parameters
manifold
allows the user to drive the meshing algorithm, and ensure that the output mesh surface follows the given manifold criterion. It can be activated with parameters::manifold()
, parameters::manifold_with_boundary()
and parameters::non_manifold()
. Note that the meshing algorithm cannot generate a manifold surface if the input surface is not manifold.lloyd
parameters::lloyd()
and parameters::no_lloyd()
are designed to trigger or not a call to lloyd_optimize_mesh_3()
function and to set the parameters of this optimizer. If one parameter is not set, the default value of lloyd_optimize_mesh_3()
is used for this parameter.ODT
parameters::odt()
and parameters::no_odt()
are designed to trigger or not a call to odt_optimize_mesh_3()
function and to set the parameters of this optimizer. If one parameter is not set, the default value of odt_optimize_mesh_3()
is used for this parameter.perturb
parameters::perturb()
and parameters::no_perturb()
are designed to trigger or not a call to perturb_mesh_3()
function and to set the parameters of this optimizer. If one parameter is not set, the default value of perturb_mesh_3()
is used for this parameter, except for the time bound which is set to be equal to the refinement CPU time.exude
parameters::exude()
and parameters::no_exude()
are designed to trigger or not a call to exude_mesh_3()
function and to override to set the parameters of this optimizer. If one parameter is not set, the default value of exude_mesh_3()
is used for this parameter, except for the time bound which is set to be equal to the refinement CPU time.The optimization parameters can be passed in arbitrary order. If one parameter is not passed, its default value is used. The default values are no_lloyd()
, no_odt()
, perturb()
and exude()
. Note that whatever may be the optimization processes activated, they are always launched in the order that is a suborder of the following (see user manual for further details): ODTsmoother, Lloydsmoother, perturber, and exuder.
Beware that optimization of the mesh is obtained by perturbing mesh vertices and modifying the mesh connectivity and that this has an impact on the strict compliance to the refinement criteria. Though a strict compliance to mesh criteria is guaranteed at the end of the Delaunay refinement, this may no longer be true after some optimization processes. Also beware that the default behavior does involve some optimization processes.
CGAL::make_mesh_3()
CGAL::parameters::manifold
CGAL::parameters::manifold_with_boundary
CGAL::parameters::non_manifold
CGAL::exude_mesh_3()
CGAL::perturb_mesh_3()
CGAL::lloyd_optimize_mesh_3()
CGAL::odt_optimize_mesh_3()
CGAL::parameters::exude
CGAL::parameters::no_exude
CGAL::parameters::perturb
CGAL::parameters::no_perturb
CGAL::parameters::lloyd
CGAL::parameters::no_lloyd
CGAL::parameters::odt
CGAL::parameters::no_odt