Functions
unspecified_type	CGAL::parameters::manifold ()
	The function `parameters::manifold()` is used to drive the meshing algorithm for surfaces.

unspecified_type	CGAL::parameters::non_manifold ()
	The function `parameters::non_manifold()` is used to drive the meshing algorithm for surfaces.

unspecified_type	CGAL::parameters::manifold_with_boundary ()
	The function `parameters::manifold_with_boundary()` is used to drive the meshing algorithm for surfaces.

template<class NamedParameters = parameters::Default_named_parameters>
unspecified_type	CGAL::parameters::exude (const Named_function_parameters &np=parameters::default_values())
	The function `parameters::exude()` enables the user to trigger a call to `exude_mesh_3()` in the `make_mesh_3()` and `refine_mesh_3()` mesh generation functions.

unspecified_type	CGAL::parameters::features ()
	Provides an option indicating that 0 and 1-dimensional features have to be taken into account (the domain must be a model of `MeshDomainWithFeatures_3`).

template<class NamedParameters = parameters::Default_named_parameters>
unspecified_type	CGAL::parameters::lloyd (const Named_function_parameters &np=parameters::default_values())
	The function `parameters::lloyd()` enables the user to trigger a call of `lloyd_optimize_mesh_3()` in the mesh generation functions `make_mesh_3()` and `refine_mesh_3()`.

unspecified_type	CGAL::parameters::no_exude ()
	The function `parameters::no_exude()` enables the user to tell the mesh generation functions `make_mesh_3()` and `refine_mesh_3()` that no exudation must be done.

unspecified_type	CGAL::parameters::no_features ()
	Provides an option indicating no special treatment should be done with 0 and 1-dimensional features.

unspecified_type	CGAL::parameters::surface_only ()
	The function `parameters::surface_only()` enables the meshing algorithm to mesh the input surface only and not take the volume into account.

unspecified_type	CGAL::parameters::no_lloyd ()
	The function `parameters::no_lloyd()` enables the user to tell the mesh generation functions `make_mesh_3()` and `refine_mesh_3()` that no lloyd optimization must be done.

unspecified_type	CGAL::parameters::no_odt ()
	The function `parameters::no_odt()` enables the user to tell the mesh generation functions `make_mesh_3()` and `refine_mesh_3()` that no ODT optimization must be done.

unspecified_type	CGAL::parameters::no_perturb ()
	The function `parameters::no_perturb()` enables the user to tell mesh generation global functions `make_mesh_3()` and `refine_mesh_3()` that no perturbation must be done.

template<class NamedParameters = parameters::Default_named_parameters>
unspecified_type	CGAL::parameters::odt (const Named_function_parameters &np=parameters::default_values())
	The function `parameters::odt()` enables the user to trigger a call to `CGAL::odt_optimize_mesh_3()` in `CGAL::make_mesh_3()` and `CGAL::refine_mesh_3()` mesh optimization functions.

template<class NamedParameters = parameters::Default_named_parameters>
unspecified_type	CGAL::parameters::perturb (const Named_function_parameters &np=parameters::default_values())
	The function `parameters::perturb()` enables the user to trigger a call to `perturb_mesh_3()` in `make_mesh_3()` and `refine_mesh_3()` mesh generation functions.

template<typename InitialPointsGenerator >
unspecified_type	CGAL::parameters::initial_points_generator (const InitialPointsGenerator &generator)
	The function `parameters::initial_points_generator()` enables the user to specify a functor that follows the `InitialPointsGenerator_3` concept to the mesh generation function `make_mesh_3()`.

template<typename MeshDomain , typename C3t3 , typename InitialPointsRange >
unspecified_type	CGAL::parameters::initial_points (const InitialPointsRange &initial_points)
	The function `parameters::initial_points()` enables the user to specify a container, model of `Range`, that contains initial points constructed on surfaces, to be used in the `make_mesh_3()` function for mesh generation.

Function Documentation

◆ exude()

template<class NamedParameters = parameters::Default_named_parameters>

unspecified_type CGAL::parameters::exude ( const Named_function_parameters & np = parameters::default_values() )

#include <CGAL/Mesh_3/parameters.h>

The function parameters::exude() enables the user to trigger a call to exude_mesh_3() in the make_mesh_3() and refine_mesh_3() mesh generation functions.

It also enables the user to pass parameters to the optimization function exude_mesh_3() through these mesh generation functions.

Template Parameters

NamedParameters a sequence of Named Parameters

Parameters

np	an optional sequence of Named Parameters among the ones listed below:

Optional Named Parameters

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.
Type: double
Precondition: time_limit >= 0
Default: 0

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.
Type: double
Precondition: 0 <= sliver_bound <= 180
Default: 0

Example

// Mesh generation with an exudation step
C3t3 c3t3 = make_mesh_3<c3t3>(domain,
                              criteria,
                              parameters::exude());
 
refine_mesh_3(c3t3,
              domain,
              criteria,
              parameters::exude(parameters::time_limit(10)));

See also: CGAL::parameters::no_exude(); CGAL::exude_mesh_3(); CGAL::make_mesh_3(); CGAL::refine_mesh_3()

◆ features()

unspecified_type CGAL::parameters::features ( )

#include <CGAL/Mesh_3/parameters.h>

Provides an option indicating that 0 and 1-dimensional features have to be taken into account (the domain must be a model of MeshDomainWithFeatures_3).

This is the default behavior when the domain is a model of MeshDomainWithFeatures_3.

See also: CGAL::make_mesh_3(); CGAL::refine_mesh_3(); CGAL::parameters::no_features()

◆ initial_points()

template<typename MeshDomain , typename C3t3 , typename InitialPointsRange >

unspecified_type CGAL::parameters::initial_points ( const InitialPointsRange & initial_points )

#include <CGAL/Mesh_3/parameters.h>

The function parameters::initial_points() enables the user to specify a container, model of Range, that contains initial points constructed on surfaces, to be used in the make_mesh_3() function for mesh generation.

Items in the container are tuple-like objects containing a Weighted_point_3, an int, and a MeshDomain::Index, where Weighted_point_3 represents the position and the weight of the point, int the dimension of the minimal subcomplex on which the point lies, and MeshDomain::Index the corresponding subcomplex index. These initial points are inserted after one dimensional features initialization.

Initialization is considered to be complete if the triangulation is a 3D triangulation with at least one facet in the restricted Delaunay triangulation (i.e., its dual intersects the input surface).

If the parameter parameters::initial_points_generator() is set, the points from this parameter will be inserted before calling the initial points generator.

If after the insertion of initial points (possibly together with the input generator), the initialization is not complete, the domain's construct_initial_points_object() will be called.

Template Parameters

MeshDomain	a model of `MeshDomain_3`
C3t3	a model of `MeshComplex_3InTriangulation_3`
InitialPointsRange	a model of `Range` containing tuple-like objects of `C3t3::Triangulation::Geom_traits::Weighted_point_3, int, MeshDomain::Index`.

Parameters

initial_points an instance of InitialPointsRange

Example

// Create the initial_points vector
std::vector<std::tuple<K::Weighted_point_3, int, Mesh_domain::Index>> initial_points;
// Perform mesh generation from a labeled image with initial points
C3t3 c3t3 = make_mesh_3<c3t3>(domain,
                              criteria,
                              parameters::initial_points(std::cref(initial_points))); // Use std::cref to avoid a copy

See also: CGAL::make_mesh_3(); CGAL::parameters::initial_points_generator(); MeshDomain_3::Construct_initial_points

◆ initial_points_generator()

template<typename InitialPointsGenerator >

unspecified_type CGAL::parameters::initial_points_generator ( const InitialPointsGenerator & generator )

#include <CGAL/Mesh_3/parameters.h>

The function parameters::initial_points_generator() enables the user to specify a functor that follows the InitialPointsGenerator_3 concept to the mesh generation function make_mesh_3().

This functor is called for the initialization of the meshing process, by inserting well-distributed surface vertices. If this parameter is not specified, the default behavior is executed, which calls the domain's construct_initial_points_object() for the initialization of the meshing process.

Initialization is considered to be complete if the triangulation is a 3D triangulation with at least one facet in the restricted Delaunay triangulation (i.e., its dual intersects the input surface).

If one dimensional features are requested, their initialization is performed first. If provided, the points of parameters::initial_points() are inserted next. Then, parameters::initial_points_generator() is used to generate more initial points and complete the initialization. If the generator does not generate enough points for the initialization to be complete, the domain's construct_initial_points_object() will be called to generate enough input points.

Template Parameters

InitialPointsGenerator a model of the InitialPointsGenerator_3 concept

Parameters

generator an instance of InitialPointsGenerator

Example

  // Mesh generation with a custom initialization that places points
  // on the surface of each connected component of the image.
  CGAL::Construct_initial_points_labeled_image<C3t3, Mesh_domain> img_pts_generator(image, domain);
 
  C3t3 c3t3 = CGAL::make_mesh_3<C3t3>(domain, criteria,
                                      params::initial_points_generator(img_pts_generator));

See also: CGAL::make_mesh_3(); CGAL::parameters::initial_points(); MeshDomain_3::Construct_initial_points

◆ lloyd()

template<class NamedParameters = parameters::Default_named_parameters>

unspecified_type CGAL::parameters::lloyd ( const Named_function_parameters & np = parameters::default_values() )

#include <CGAL/Mesh_3/parameters.h>

The function parameters::lloyd() enables the user to trigger a call of lloyd_optimize_mesh_3() in the mesh generation functions make_mesh_3() and refine_mesh_3().

It also enables the user to pass parameters to the optimization function lloyd_optimize_mesh_3() through these mesh generation functions.

Template Parameters

NamedParameters a sequence of Named Parameters

Parameters

np	an optional sequence of Named Parameters among the ones listed below:

Optional Named Parameters

to set up, in seconds, a CPU time limit after which the optimization process is stopped. This time is measured using `CGAL::Real_timer`. 0 means that there is no time limit. Type: `double` Precondition: `time_limit >= 0` Default: 0
limit on the number of performed iterations. 0 means that there is no limit on the number of performed iterations. Precondition: `max_iteration_number >=0` Type: `int` Default: 0
designed to reduce running time of each optimization iteration. Any vertex that has a displacement less than a given fraction of the length of its shortest incident edge, is frozen (i.e. is not relocated). The parameter `freeze_bound` gives the threshold ratio. If it is set to 0, freezing of vertices is disabled. Precondition: `0<= freeze_bound <=1` Type: `double` Default: 0.01
threshold ratio of 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 fraction of the length of the shortest edge incident to that vertex. Precondition: `0 <=convergence <= 1` Type: `double` Default: 0.02
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. Type: `bool` Default: true

Example

// Mesh generation with lloyd optimization step
C3t3 c3t3 = make_mesh_3<c3t3>(domain,
                              criteria,
                              parameters::lloyd());
 
refine_mesh_3(c3t3,
              domain,
              criteria,
              parameters::lloyd(parameters::time_limit(10)));

See also: CGAL::parameters::no_lloyd(); CGAL::lloyd_optimize_mesh_3(); CGAL::make_mesh_3(); CGAL::refine_mesh_3()

◆ manifold()

unspecified_type CGAL::parameters::manifold ( )

#include <CGAL/Mesh_3/parameters.h>

The function parameters::manifold() is used to drive the meshing algorithm for surfaces.

It ensures that the surface of the output mesh is a manifold surface without boundaries. The manifold property of the output mesh can be achieved only if the input surface is a manifold. Note that the meshing algorithm provably terminates only if the input sharp edges have been protected, using the feature protection (see Protection of 0 and 1-dimensional Exposed Features).

See also: CGAL::make_mesh_3(); CGAL::refine_mesh_3(); CGAL::parameters::manifold_with_boundary(); CGAL::parameters::non_manifold()

◆ manifold_with_boundary()

unspecified_type CGAL::parameters::manifold_with_boundary ( )

#include <CGAL/Mesh_3/parameters.h>

The function parameters::manifold_with_boundary() is used to drive the meshing algorithm for surfaces.

It ensures that the surface of the output mesh is a manifold surface which may have boundaries. The manifold property of the output mesh can be achieved only if the input surface is a manifold. Note that the meshing algorithm provably terminates only if the input sharp edges have been protected, using the feature protection (see Protection of 0 and 1-dimensional Exposed Features).

See also: CGAL::make_mesh_3(); CGAL::refine_mesh_3(); CGAL::parameters::non_manifold(); CGAL::parameters::manifold()

◆ no_exude()

unspecified_type CGAL::parameters::no_exude ( )

#include <CGAL/Mesh_3/parameters.h>

The function parameters::no_exude() enables the user to tell the mesh generation functions make_mesh_3() and refine_mesh_3() that no exudation must be done.

Example

// Mesh generation without exudation
C3t3 c3t3 = make_mesh_3<c3t3>(domain,
                              criteria,
                              parameters::no_exude());

See also: CGAL::parameters::exude(); CGAL::exude_mesh_3(); CGAL::make_mesh_3(); CGAL::refine_mesh_3()

Examples: Mesh_3/mesh_3D_weighted_image_with_detection_of_features.cpp.

◆ no_features()

unspecified_type CGAL::parameters::no_features ( )

#include <CGAL/Mesh_3/parameters.h>

Provides an option indicating no special treatment should be done with 0 and 1-dimensional features.

See also: CGAL::make_mesh_3(); CGAL::refine_mesh_3(); CGAL::parameters::features()

◆ no_lloyd()

unspecified_type CGAL::parameters::no_lloyd ( )

#include <CGAL/Mesh_3/parameters.h>

The function parameters::no_lloyd() enables the user to tell the mesh generation functions make_mesh_3() and refine_mesh_3() that no lloyd optimization must be done.

Example

// Mesh generation without lloyd optimization
C3t3 c3t3 = make_mesh_3<c3t3>(domain,
                              criteria,
                              parameters::no_lloyd());

See also: CGAL::parameters::lloyd(); CGAL::lloyd_optimize_mesh_3(); CGAL::make_mesh_3(); CGAL::refine_mesh_3()

◆ no_odt()

unspecified_type CGAL::parameters::no_odt ( )

#include <CGAL/Mesh_3/parameters.h>

The function parameters::no_odt() enables the user to tell the mesh generation functions make_mesh_3() and refine_mesh_3() that no ODT optimization must be done.

Example

// Mesh generation without odt optimization
C3t3 c3t3 = make_mesh_3<c3t3>(domain,
                              criteria,
                              parameters::no_odt());

See also: CGAL::parameters::odt(); CGAL::odt_optimize_mesh_3(); CGAL::make_mesh_3(); CGAL::refine_mesh_3()

◆ no_perturb()

unspecified_type CGAL::parameters::no_perturb ( )

#include <CGAL/Mesh_3/parameters.h>

The function parameters::no_perturb() enables the user to tell mesh generation global functions make_mesh_3() and refine_mesh_3() that no perturbation must be done.

Example

// Mesh generation without perturbation
C3t3 c3t3 = make_mesh_3<c3t3>(domain,
                              criteria,
                              parameters::no_perturb());

See also: CGAL::parameters::perturb(); CGAL::perturb_mesh_3(); CGAL::make_mesh_3(); CGAL::refine_mesh_3()

Examples: Mesh_3/mesh_3D_weighted_image_with_detection_of_features.cpp.

◆ non_manifold()

unspecified_type CGAL::parameters::non_manifold ( )

#include <CGAL/Mesh_3/parameters.h>

The function parameters::non_manifold() is used to drive the meshing algorithm for surfaces.

It does not ensure that the surface of the output mesh is a manifold surface. The manifold property of the output mesh might nevertheless result from an appropriate choice of meshing criteria.

See also: CGAL::make_mesh_3(); CGAL::refine_mesh_3(); CGAL::parameters::manifold_with_boundary(); CGAL::parameters::manifold()

◆ odt()

template<class NamedParameters = parameters::Default_named_parameters>

unspecified_type CGAL::parameters::odt ( const Named_function_parameters & np = parameters::default_values() )

#include <CGAL/Mesh_3/parameters.h>

The function parameters::odt() enables the user to trigger a call to CGAL::odt_optimize_mesh_3() in CGAL::make_mesh_3() and CGAL::refine_mesh_3() mesh optimization functions.

It also enables the user to pass parameters to the optimization function odt_optimize_mesh_3() through these mesh generation functions.

Template Parameters

NamedParameters a sequence of Named Parameters

Parameters

np	an optional sequence of Named Parameters among the ones listed below:

Optional Named Parameters

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. Type: `double` Precondition: `time_limit >= 0` Default: 0
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. Type: `std::size_t` Default: 0
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. Type: `double` Precondition: `0 <= convergence <= 1` Default: 0.02
is designed to reduce running time of each optimization iteration. Any vertex that has a displacement less than a given percentage of the length of its shortest incident edge, is frozen (i.e. is not relocated). The parameter `freeze_bound` gives the threshold ratio. Type: `double` Precondition: `0 <= freeze_bound <= 1` Default: 0.01
completes the `freeze_bound` parameter. If it is set to `true`, frozen vertices will not move anymore in next iterations. Otherwise, at each iteration, any vertex that moves, unfreezes all its incident vertices. Type: `bool` Default: true

Example

// Mesh generation with odt optimization step
C3t3 c3t3 = make_mesh_3<c3t3>(domain,
                              criteria,
                              parameters::odt());
 
refine_mesh_3(c3t3,
              domain,
              criteria,
              parameters::odt(parameters::time_limit(10)));

See also: CGAL::parameters::no_odt(); CGAL::odt_optimize_mesh_3(); CGAL::make_mesh_3(); CGAL::refine_mesh_3()

◆ perturb()

template<class NamedParameters = parameters::Default_named_parameters>

unspecified_type CGAL::parameters::perturb ( const Named_function_parameters & np = parameters::default_values() )

#include <CGAL/Mesh_3/parameters.h>

The function parameters::perturb() enables the user to trigger a call to perturb_mesh_3() in make_mesh_3() and refine_mesh_3() mesh generation functions.

It also enables the user to pass parameters to the optimization function perturb_mesh_3() through these mesh generation functions.

Template Parameters

NamedParameters a sequence of Named Parameters

Parameters

np	an optional sequence of Named Parameters among the ones listed below:

Optional Named Parameters

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.
Type: double
Precondition: time_limit >= 0
Default: 0

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.
Type: double
Precondition: 0 <= sliver_bound <= 180
Default: 0

Example

// Mesh generation with a perturbation step
C3t3 c3t3 = make_mesh_3<c3t3>(domain,
                              criteria,
                              parameters::perturb());
 
refine_mesh_3(c3t3,
              domain,
              criteria,
              parameters::perturb(parameters::time_limit(10)));

See also: CGAL::parameters::no_perturb(); CGAL::perturb_mesh_3(); CGAL::make_mesh_3(); CGAL::refine_mesh_3()

◆ surface_only()

unspecified_type CGAL::parameters::surface_only ( )

#include <CGAL/Mesh_3/parameters.h>

The function parameters::surface_only() enables the meshing algorithm to mesh the input surface only and not take the volume into account.

When this option is enabled, the ouput mesh has no cells in the 3D complex, only facets, edges and vertices. Full-3D optimization steps such as mesh perturbation and mesh exudation are automatically disabled.

See also: CGAL::make_mesh_3(); CGAL::refine_mesh_3()

Functions

Function Documentation

◆ exude()

◆ features()

◆ initial_points()

◆ initial_points_generator()

◆ lloyd()

◆ manifold()

◆ manifold_with_boundary()

◆ no_exude()

◆ no_features()

◆ no_lloyd()

◆ no_odt()

◆ no_perturb()

◆ non_manifold()

◆ odt()

◆ perturb()

◆ surface_only()