template<class InputMesh , class OutputMesh , class BottomFunctor , class TopFunctor , class NamedParameters1 , class NamedParameters2 >
void CGAL::Polygon_mesh_processing::extrude_mesh
(
const InputMesh &
input,
OutputMesh &
output,
const BottomFunctor &
bot,
const TopFunctor &
top,
const NamedParameters1 &
np_in,
const NamedParameters2 &
np_out
)
#include <CGAL/Polygon_mesh_processing/extrude.h>
performs a generalized extrusion of input and puts it in output.
This function extrudes the open surface mesh input and puts the result in output. The mesh generated is a closed surface mesh with a bottom and top part, both having the same graph combinatorics as input (except that the orientation of the faces of the bottom part is reversed). The bottom and the top parts are connected by a triangle strip between boundary cycles. The coordinates of the points associated to the vertices of the bottom and top part are first initialized to the same value as the corresponding vertices of input. Then for each vertex, a call to bot and top is done for the vertices of the bottom part and the top part, respectively.
The points of the selected vertices are relocated to yield an as-smooth-as-possible surface patch, based on solving a linear bi-Laplacian system with boundary constraints, described in [3]. The optional parameter fairing_continuity gives the ability to control the tangential continuity C n of the output mesh.
The region described by vertices might contain multiple disconnected components. Note that the mesh connectivity is not altered in any way, only vertex locations get updated.
Fairing might fail if fixed vertices, which are used as boundary conditions, do not suffice to solve constructed linear system.
Note that if the vertex range to which fairing is applied contains all the vertices of the triangle mesh, fairing does not fail, but the mesh gets shrinked to CGAL::ORIGIN.
the vertices of the patches to be faired (the positions of only those vertices will be changed)
np
an optional sequence of Named Parameters among the ones listed below
Optional Named Parameters
a property map associating points to the vertices of tmesh
Type: a class model of ReadablePropertyMap with boost::graph_traits<TriangleMesh>::vertex_descriptor as key type and Point_3 as value type
Default: boost::get(CGAL::vertex_point, tmesh)
Extra: If this parameter is omitted, an internal property map for CGAL::vertex_point_t should be available for the vertices of tmesh.
A value controling the tangential continuity of the output surface patch. The possible values are 0, 1 and 2, refering to the C0, C1 and C2 continuity.
Type: unsigned int
Default: 1
Extra: The larger fairing_continuity gets, the more fixed vertices are required.
an instance of the sparse linear solver used for fairing
This operation sequentially performs edge splits, edge collapses, edge flips, tangential relaxation and projection to the initial surface to generate a smooth mesh with a prescribed edge length.
Template Parameters
PolygonMesh
model of MutableFaceGraph. The descriptor types boost::graph_traits<PolygonMesh>::face_descriptor and boost::graph_traits<PolygonMesh>::halfedge_descriptor must be models of Hashable.
FaceRange
range of boost::graph_traits<PolygonMesh>::face_descriptor, model of Range. Its iterator type is ForwardIterator.
a polygon mesh with triangulated surface patches to be remeshed
faces
the range of triangular faces defining one or several surface patches to be remeshed
target_edge_length
the edge length that is targeted in the remeshed patch. If 0 is passed then only the edge-flip, tangential relaxation, and projection steps will be done.
np
an optional sequence of Named Parameters among the ones listed below
Precondition
if constraints protection is activated, the constrained edges must not be longer than 4/3*target_edge_length
Optional Named Parameters
a property map associating points to the vertices of pmesh
Type: a class model of ReadWritePropertyMap with boost::graph_traits<PolygonMesh>::vertex_descriptor as key type and Point_3 as value type
Default: boost::get(CGAL::vertex_point, pmesh)
Extra: If this parameter is omitted, an internal property map for CGAL::vertex_point_t must be available in PolygonMesh.
Extra: The geometric traits class must be compatible with the vertex point type.
Extra: Exact constructions kernels are not supported by this function.
a property map associating to each face of pmesh a unique index between 0 and num_faces(pmesh) - 1
Type: a class model of ReadablePropertyMap with boost::graph_traits<PolygonMesh>::face_descriptor as key type and std::size_t as value type
Default: an automatically indexed internal map
the number of iterations for the sequence of atomic operations performed (listed in the above description)
Type: unsigned int
Default: 1
a property map containing the constrained-or-not status of each edge of pmesh
Type: a class model of ReadWritePropertyMap with boost::graph_traits<PolygonMesh>::edge_descriptor as key type and bool as value type. It must be default constructible.
Default: a default property map where no edge is constrained
Extra: A constrained edge can be split or collapsed, but not flipped, nor its endpoints moved by smoothing.
Extra: Sub-edges generated by splitting are set to be constrained.
Extra: Patch boundary edges (i.e. incident to only one face in the range) are always considered as constrained edges.
a property map containing the constrained-or-not status of each vertex of pmesh.
Type: a class model of ReadWritePropertyMap with boost::graph_traits<PolygonMesh>::vertex_descriptor as key type and bool as value type. It must be default constructible.
Default: a default property map where no vertex is constrained
Extra: A constrained vertex cannot be modified during remeshing.
If true, the edges set as constrained in edge_is_constrained_map (or by default the boundary edges) are not split nor collapsed during remeshing.
Type: Boolean
Default: false
Extra: Note that around constrained edges that have their length higher than twice target_edge_length, remeshing will fail to provide good quality results. It can even fail to terminate because of cascading vertex insertions.
If true, the edges set as constrained in edge_is_constrained_map (or by default the boundary edges) are collapsed during remeshing.
Type: Boolean
Default: true
Extra: This value is ignored if protect_constraints is true.
a property map with the patch id's associated to the faces of faces
Default: a default property map where each face is associated with the ID of the connected component it belongs to. Connected components are computed with respect to the constrained edges listed in the property map edge_is_constrained_map
Extra: The map is updated during the remeshing process while new faces are created.
whether edges that are too long with respect to the given sizing are split
Type: Boolean
Default: true
whether edges that are too short with respect to the given sizing are collapsed
Type: Boolean
Default: true
whether edge flips are performed to improve shape and valence
Type: Boolean
Default: true
the number of iterations of tangential relaxation that are performed at each iteration of the remeshing process
Type: unsigned int
Default: 1
If true, the end vertices of the edges set as constrained in edge_is_constrained_map and boundary edges move along the constrained polylines they belong to.}
Type: Boolean
Default: false
whether vertices should be reprojected on the input surface after creation or displacement
Type: Boolean
Default: true
A function object used to project input vertices (moved by the smoothing) and created vertices
Type: Unary functor that provides Point_3 operator()(vertex_descriptor), Point_3 being the value type of the vertex point map.
Default: If not provided, vertices are projected on the input surface mesh.
Deal with exact constructions Kernel. The only thing that makes sense is to guarantee that the output vertices are exactly on the input surface. To do so, we can do every construction in double, and use an exact process for projection. For each vertex, the AABB_tree would be used in an inexact manner to find the triangle on which projection has to be done. Then, use CGAL::intersection(triangle, line) in the exact constructions kernel to get a point which is exactly on the surface.
remeshes a triangule mesh using a minimal angle optimization approach.
This operation applies carefully prioritized local operations to greedily search for the coarsest mesh with minimal interior angle threshold and the approximation error threshold defined by the user. The local operations include edge split, edge collapse, edge flip (optional), vertex relocation, and projection to the initial triangular mesh.
Template Parameters
TriangleMesh
model of MutableFaceGraph. The descriptor types boost::graph_traits<PolygonMesh>::face_descriptor and boost::graph_traits<TriangleMesh>::halfedge_descriptor must be models of Hashable. If TriangleMesh has an internal property map for CGAL::face_index_t, and no face_index_map is given as a named parameter, then the internal one must be initialized
Extra: The geometric traits class must be compatible with the vertex point type.
Extra: Exact constructions kernels are not supported by this function.
The approximation error, expressed as the percentage of diagonal length of the input surface mesh.
Type: double
Default: 0.2
The minimal angle that the remesh surface mesh should achieve.
Type: double
Default: 30
The maximal mesh complexity that the remesh surface mesh should maintain, expressed as the number of vertices of the remesh surface mesh.
Type: unsigned int
Default: 100000000
The minimal step for angle improvement. If a local operator improves the minimal angle less than this value, then it is considered the minimal angle has not been improved.
Type: double
Default: 0.1
Indicates whether we apply the local operator Edge_flip when improving the minimal angle. Experiments show that enable the edge flipping achieves much better results
Type: Boolean
Default: true
Indicates whether we want to improve the minimal angle, or the vertex valences when flipping an edge. Experiments show that Improve_the_minimal_angle is better.
Type: EdgeFlipStrategy
Default: EdgeFlipStrategy::k_improve_angle
Indicates whether we perform Edge_flip after applying edge split or edge collapse, such that the local valance of the new generated vertex can be improved. Experiments show that enabling this is better.
Type: Boolean
Default: true
Indicates whether we perform Vertex_relocate after applying other local operators, such as edge split, edge collapse. Note we do not perform Vertex_relocate after edge flip in order to perverse sharp features. Experiments show that enabling this is better than not.
Type: Boolean
Default: true
The options for Vertex_relocation, we now have barycenter or CVT barycenter. Barycenter is simply the average of the one-ring vertices, which is also called Laplacian-operation. Instead, the CVT barycenter is the Centroid Voronoi Tessellation center of the one-ring vertices. Experiments show that the CVT barycenter is better.
Type: RelocateStrategy
Default: RelocateStrategy::k_cvt_barycenter
Indicate whether we want to keep the vertex in one-ring region when performing Edge_collapse or Vertex_relocate. This was indicated in Fig. 4 of our paper. Experiments show that disabling this is much better. However, we may have some folder-overs in some results.
Type: Boolean
Default: false
Indicates whether we construct the local AABB tree or not when simulating the edge collapse operator. If it is true, we use the constructed local AABB tree to update the links from input surface mesh to remesh surface mesh; Otherwise, we update the links directly. Experiments show that the efficiencies for both cases are almost the same.
Type: Boolean
Default: true
In some rare cases, the software traps into local dead loops (e.g., edge split -> edge collapse -> edge split ->edge collapse...). Hence, we maintain a global collapse list, such that if an edge is collapsed not long ago (recorded in the list), we deny the edge collapse when it can be in later steps. This parameter indicates the maximum size of the collapse list. The larger this value is, the less possibility that the software traps into local dead loops, but higher computational and memory cost. Experiments show that this strategy is really effective.
Type: unsigned int
Default: 10
Due to the randomness of sampling, sometimes the max error threshold cannot be strictly bounded to the threshold. If this parameter is enabled, we explicitly decrease the max error as long as we find the Hausdorff distance between the input and the remesh exceeds the threshold. This will make sure the approximation error is strictly bounded regardless of the sampling randomness.
Type: Boolean
Default: true
If this parameter is enabled, we output the detailed information when each local operator is applied. The detailed information may include current maximal error, minimal angle, or the size of the dynamic priority queue.
Type: Boolean
Default: true
If this parameter is enabled, we apply the initial mesh simplification before improving the minimal angles. This reduces the mesh complexity around 20-30% on average.
Type: Boolean
Default: true
If this parameter is enabled, we apply the final vertex relocation after improving the minimal angles to the min angle threshold. This will improve the average quality of the triangles with respect to the parameter Smooth angle delta. The smaller Smooth angle delta is set, the better results we get along with the higher computational cost.
Type: Boolean
Default: true
The number of samples per facet on input surface mesh.
Type: unsigned int
Default: 10
The number of samples per facet on remesh surface mesh.
Type: unsigned int
Default: 10
The maximal number of samplers per unit area. This parameter is used to avoid too dense sampling.
Type: unsigned int
Default: 10000
The minimal number of samples per triangle. This parameter is used to guarantee that each triangle, no matter how small it is, has certain number of samples on it.
Type: unsigned int
Default: 1
The large this parameter is, the more uniform the samples in the facets are. However, the computational cost will be dramatically higher as well.
Type: unsigned int
Default: 1
The option of sample number strategy on remesh surface mesh. If it is Fixed, then the number of samples per facet is roughly the same as the one on the input surface mesh; If it is Variable, then the number of samples per facet is variable with respect to the size of facets of the remesh surface mesh: the more facets the remesh surface mesh has, the smaller number of samples we generate on each facet of the remesh surface mesh. The Variable option makes the total samples on the input surface mesh and remesh surface mesh roughly the same.
Type: SampleNumberStrategy
Default: SampleNumberStrategy::k_fixed
The option of sample strategy. If it is uniform, then the number of samples per facet is proportional to its area; If it is adaptive, then the number of samples per facet is roughly the same.
Type: SampleStrategy
Default: SampleStrategy::k_adaptive
If this parameter is enabled, the vertex samples, edge samples and the facet samples partition the area of the surface mesh, respectively (we call the partition area as the capacity of each sample); If it is disabled, all the three types of samples will partition the area of the surface mesh together. In the former case, the feature samples (include the vertex samples and the edge samples) own higher area weights; while in the latter case, all the samples have the same area weights. Enabling this parameter preserves features better, but sacrifices the overall approximation error, because the facet samples dominates all the samples.
Type: Boolean
Default: false
The maximal value of Gaussian curvature, expressed as the times of PI. If a Gaussian curvature exceeds some value, it will be clamped to this value.
Type: double
Default: 1.0
The scale of the Gaussian curvature. If dividing a Gaussian curvature with this scale and the result exceeds Sum theta (PI), then it is clamped to Sum theta (PI).
Type: double
Default: 0.5
The maximal value of large dihedral angle value, expressed as the times of PI. If the large dihedral angle exceeds some value, it will be clamped to this value.
Type: double
Default: 1.0
The scale of the large dihedral angle. If dividing the large dihedral angle with this scale and the result exceeds Dihedral theta (PI), then it is clamped to Dihedral theta (PI).
Type: double
Default: 0.5
This parameter is only used when getting the initial position of the vertex after applying edge collapse. If the feature intensity difference between the two end points is smaller than their maximal value multiplied with this parameter, then the midpoint will be selected as the initial position; otherwise, the end point with higher feature intensity will be selected.
Type: double
Default: 0.15
This parameter is used for vertex classification. Please refer to Fig. 10 in the paper for more detailed explanation.
Type: double
Default: 0.5
If this parameter is enabled, we calculate the edge types (crease edge or non-crease edge) of the remesh surface mesh in advance, and then maintain the edge types explicitly during the whole remeshing process. Otherwise, we calculate the edge types according to the given parameters each time when a local operator is applied.
Type: Boolean
Default: false
If this parameter is enabled, the weight for each sample is its according area multiplied by its feature intensity; Otherwise, the weight is its according area. Enabling this parameter keeps the features better.
Type: Boolean
Default: false
The number of iterations we perform when optimizing a vertex position. Please refer to the first row of Fig. 15 in the paper for more details.
Type: unsigned int
Default: 2
The ratio to get to the optimal position when optimizing a vertex position. Refer to the second row of Fig. 15 in the paper for more details.
Type: double
Default: 0.9
The stencil ring size when collecting the samples from input surface mesh to remesh surface mesh. Please refer to the gray region of Fig. 3 as well as the discussion in Sec. 6.1 in the paper for more details.
Type: unsigned int
Default: 1
Options for vertex position optimization. If it is Approximation, then the vertex position is just the optimal position we calculated; otherwise, the vertex position is the projection of the optimal position to the input surface mesh. Please refer to Sec. 6.2 in the paper for more details.
Type: OptimizeStrategy
Default: OptimizeStrategy::k_approximation
The facet sample types used for optimizing a vertex position.
Type: OptimizeType
Default: OptimizeType::k_both
The edge sample types used for optimizing a vertex position.
Type: OptimizeType
Default: OptimizeType::k_both
The vertex sample types used for optimizing a vertex position. Optimize after local operations: If this parameter is enabled, we perform the vertex position optimization after each local operator is applied.
Type: OptimizeType
Default: OptimizeType::k_both
If this parameter is enabled, we perform the vertex position optimization after each local operator is applied.
randomly perturbs the locations of vertices of a triangulated surface mesh.
By default, the vertices are re-projected onto the input surface after perturbation. Note that no geometric checks are done after the perturbation (face orientation might become incorrect and self-intersections might be introduced).
Template Parameters
VertexRange
model of Range, holding vertices of type boost::graph_traits<TriangleMesh>::vertex_descriptor. Its iterator type is ForwardIterator.
Extra: The geometric traits class must be compatible with the vertex point type.
a property map containing the constrained-or-not status of each vertex of tmesh
Type: a class model of ReadWritePropertyMap with boost::graph_traits<TriangleMesh>::vertex_descriptor as key type and bool as value type. It must be default constructible.
Default: a default property map where no vertex is constrained
Extra: A constrained vertex cannot be modified at all during perturbation
indicates whether vertices are reprojected on the input surface after their coordinates random perturbation
Type: Boolean
Default: true
a value to seed the random number generator, and make the perturbation deterministic
This function attempts to make the triangle angle and area distributions as uniform as possible by moving (non-constrained) vertices.
Angle-based smoothing does not change the combinatorial information of the mesh. Area-based smoothing might change the combinatorial information, unless specified otherwise. It is also possible to make the smoothing algorithm "safer" by rejecting moves that, when applied, would worsen the quality of the mesh, e.g. that would decrease the value of the smallest angle around a vertex or create self-intersections.
Optionally, the points are reprojected after each iteration.
Extra: The geometric traits class must be compatible with the vertex point type.
If true, vertex moves that would worsen the mesh are ignored.
Type: Boolean
Default: false
If true, area-based smoothing will be completed by a phase of Delaunay-based edge-flips to prevent the creation of elongated triangles.
Type: Boolean
Default: true
If true, points are projected onto the initial surface after each iteration.
Type: Boolean
Default: true
a property map containing the constrained-or-not status of each vertex of tmesh.
Type: a class model of ReadWritePropertyMap with boost::graph_traits<TriangleMesh>::vertex_descriptor as key type and bool as value type. It must be default constructible.
Default: a default property map where no vertex is constrained
Extra: A constrained vertex cannot be modified at all during smoothing.
a property map containing the constrained-or-not status of each edge of tmesh.
Type: a class model of ReadWritePropertyMap with boost::graph_traits<TriangleMesh>::edge_descriptor as key type and bool as value type. It must be default constructible.
Default: a default property map where no edge is constrained
Extra: A constrained edge cannot be modified at all during smoothing.
Warning
The third party library Ceres is required to use area-based smoothing.
smooths the overall shape of the mesh by using the mean curvature flow.
The effect depends on the curvature of each area and on a time step which represents the amount by which vertices are allowed to move. The result conformally maps the initial surface to a sphere.
a polygon mesh with triangulated surface patches to be smoothed.
faces
the range of triangular faces defining one or several surface patches to be smoothed.
time
a time step that corresponds to the speed by which the surface is smoothed. A larger time step results in faster convergence but details may be distorted to have a larger extent compared to more iterations with a smaller step. Typical values scale in the interval (1e-6, 1].
np
an optional sequence of Named Parameters among the ones listed below
Optional Named Parameters
the number of iterations for the sequence of the smoothing iterations performed
Type: unsigned int
Default: 1
a property map associating points to the vertices of tmesh
Type: a class model of ReadWritePropertyMap with boost::graph_traits<TriangleMesh>::vertex_descriptor as key type and Point_3 as value type
Default: boost::get(CGAL::vertex_point, tmesh)
Extra: If this parameter is omitted, an internal property map for CGAL::vertex_point_t must be available in TriangleMesh.
Extra: The geometric traits class must be compatible with the vertex point type.
a property map containing the constrained-or-not status of each vertex of tmesh.
Type: a class model of ReadWritePropertyMap with boost::graph_traits<TriangleMesh>::vertex_descriptor as key type and bool as value type. It must be default constructible.
Default: a default property map where no vertex is constrained
Extra: A constrained vertex cannot be modified at all during smoothing.
an instance of the sparse linear solver used for smoothing
splits the edges listed in edges into sub-edges that are not longer than the given threshold max_length.
Note this function is useful to split constrained edges before calling isotropic_remeshing() with protection of constraints activated (to match the constrained edge length required by the remeshing algorithm to be guaranteed to terminate)
Template Parameters
PolygonMesh
model of MutableFaceGraph that has an internal property map for CGAL::vertex_point_t.
EdgeRange
range of boost::graph_traits<PolygonMesh>::edge_descriptor, model of Range. Its iterator type is InputIterator.
the range of edges to be split if they are longer than given threshold
max_length
the edge length above which an edge from edges is split into to sub-edges
np
an optional sequence of Named Parameters among the ones listed below
Optional Named Parameters
a property map associating points to the vertices of pmesh
Type: a class model of ReadWritePropertyMap with boost::graph_traits<PolygonMesh>::vertex_descriptor as key type and Point_3 as value type
Default: boost::get(CGAL::vertex_point, pmesh)
Extra: If this parameter is omitted, an internal property map for CGAL::vertex_point_t must be available in PolygonMesh.
a property map associating to each face of pmesh a unique index between 0 and num_faces(pmesh) - 1
Type: a class model of ReadablePropertyMap with boost::graph_traits<PolygonMesh>::face_descriptor as key type and std::size_t as value type
Default: an automatically indexed internal map
a property map containing the constrained-or-not status of each edge of pmesh
Type: a class model of ReadWritePropertyMap with boost::graph_traits<PolygonMesh>::edge_descriptor as key type and bool as value type. It must be default constructible.
Default: a default property map where no edge is constrained
Extra: A constrained edge can be split or collapsed, but not flipped, nor its endpoints moved by smoothing.
1.8.13