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

PMP doc fixes and enhancements

This commit is contained in:
Mael Rouxel-Labbé 2022-03-07 15:32:37 +01:00
parent a53fdc5e57
commit bb0b9a8b5a
33 changed files with 650 additions and 349 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

67
Polygon_mesh_processing/doc/Polygon_mesh_processing/PackageDescription.txt
View File

@ -2,15 +2,13 @@
/// \defgroup PkgPolygonMeshProcessingConcepts Concepts /// \defgroup PkgPolygonMeshProcessingConcepts Concepts
/// \ingroup PkgPolygonMeshProcessingRef /// \ingroup PkgPolygonMeshProcessingRef
/// \defgroup keep_connected_components_grp Connected Components /// \defgroup PMP_keep_connected_components_grp Connected Components
///
/// Two faces are in the same <em>connected component</em> if there is a path /// Two faces are in the same <em>connected component</em> if there is a path
/// of adjacent faces such that all edges between two consecutive faces of the /// of adjacent faces such that all edges between two consecutive faces of the
/// path are not marked as constrained. /// path are not marked as constrained.
///
/// \ingroup PkgPolygonMeshProcessingRef /// \ingroup PkgPolygonMeshProcessingRef
/// \defgroup hole_filling_grp Hole Filling /// \defgroup PMP_hole_filling_grp Hole Filling
/// Functions to fill holes given as a range of halfedges or as range of points. /// Functions to fill holes given as a range of halfedges or as range of points.
/// \ingroup PkgPolygonMeshProcessingRef /// \ingroup PkgPolygonMeshProcessingRef
@ -22,7 +20,7 @@
/// Functions to compute unit normals for individual/all vertices or faces. /// Functions to compute unit normals for individual/all vertices or faces.
/// \ingroup PkgPolygonMeshProcessingRef /// \ingroup PkgPolygonMeshProcessingRef
/// \defgroup measure_grp Geometric Measure Functions /// \defgroup PMP_measure_grp Geometric Measure Functions
/// Functions to compute lengths of edges and borders, areas of faces and patches, as well as volumes of closed meshes. /// Functions to compute lengths of edges and borders, areas of faces and patches, as well as volumes of closed meshes.
/// \ingroup PkgPolygonMeshProcessingRef /// \ingroup PkgPolygonMeshProcessingRef
@ -56,10 +54,8 @@
/// Functions to locate points on a mesh, and manipulate such locations. /// Functions to locate points on a mesh, and manipulate such locations.
/// \ingroup PkgPolygonMeshProcessingRef /// \ingroup PkgPolygonMeshProcessingRef
/// \defgroup PMP_predicates_grp Intersection Detection Functions /// \defgroup PMP_predicates_grp Predicates
/// Functions to detect intersections. /// Classes and functions that answer queries about a polygon mesh or its elements.
/// Note that those functions will be exact as long as the underlying do-intersect predicates used are exact.
/// In practice, it means that the 3D point type used must come from a \cgal kernel with exact predicates.
/// \ingroup PkgPolygonMeshProcessingRef /// \ingroup PkgPolygonMeshProcessingRef
/// \defgroup PMP_IO_grp I/O Functions /// \defgroup PMP_IO_grp I/O Functions
@ -94,21 +90,20 @@ ranging from basic operations on simplices, to complex geometry processing algor
\cgalCRPSection{Parameters} \cgalCRPSection{Parameters}
Optional parameters of the functions of this package Optional parameters of the functions of this package are implemented as \ref BGLNamedParameters.
are implemented as \ref BGLNamedParameters.
The page \ref bgl_namedparameters "Named Parameters" describes their usage. The page \ref bgl_namedparameters "Named Parameters" describes their usage.
\cgalCRPSection{Meshing Functions} \cgalCRPSection{Meshing Functions}
- `CGAL::Polygon_mesh_processing::fair()`
- `CGAL::Polygon_mesh_processing::refine()`
- `CGAL::Polygon_mesh_processing::smooth_mesh()`
- `CGAL::Polygon_mesh_processing::smooth_shape()`
- `CGAL::Polygon_mesh_processing::triangulate_face()`
- `CGAL::Polygon_mesh_processing::triangulate_faces()`
- \link PMP_meshing_grp `CGAL::Polygon_mesh_processing::isotropic_remeshing()` \endlink - \link PMP_meshing_grp `CGAL::Polygon_mesh_processing::isotropic_remeshing()` \endlink
- \link PMP_meshing_grp `CGAL::Polygon_mesh_processing::split_long_edges()` \endlink - \link PMP_meshing_grp `CGAL::Polygon_mesh_processing::split_long_edges()` \endlink
- `CGAL::Polygon_mesh_processing::random_perturbation()` - `CGAL::Polygon_mesh_processing::refine()`
- `CGAL::Polygon_mesh_processing::fair()`
- `CGAL::Polygon_mesh_processing::triangulate_face()`
- `CGAL::Polygon_mesh_processing::triangulate_faces()`
- `CGAL::Polygon_mesh_processing::extrude_mesh()` - `CGAL::Polygon_mesh_processing::extrude_mesh()`
- `CGAL::Polygon_mesh_processing::smooth_mesh()`
- `CGAL::Polygon_mesh_processing::smooth_shape()`
- `CGAL::Polygon_mesh_processing::random_perturbation()`
\cgalCRPSection{Hole Filling Functions} \cgalCRPSection{Hole Filling Functions}
- `CGAL::Polygon_mesh_processing::triangulate_hole()` - `CGAL::Polygon_mesh_processing::triangulate_hole()`
@ -116,11 +111,13 @@ The page \ref bgl_namedparameters "Named Parameters" describes their usage.
- `CGAL::Polygon_mesh_processing::triangulate_refine_and_fair_hole()` - `CGAL::Polygon_mesh_processing::triangulate_refine_and_fair_hole()`
- `CGAL::Polygon_mesh_processing::triangulate_hole_polyline()` - `CGAL::Polygon_mesh_processing::triangulate_hole_polyline()`
\cgalCRPSection{Predicate Functions} \cgalCRPSection{Intersection Functions}
- `CGAL::Polygon_mesh_processing::does_self_intersect()` - `CGAL::Polygon_mesh_processing::does_self_intersect()`
- `CGAL::Polygon_mesh_processing::self_intersections()` - `CGAL::Polygon_mesh_processing::self_intersections()`
- \link PMP_predicates_grp `CGAL::Polygon_mesh_processing::do_intersect()` \endlink - \link PMP_intersection_grp `CGAL::Polygon_mesh_processing::do_intersect()` \endlink
- `CGAL::Polygon_mesh_processing::intersecting_meshes()` - `CGAL::Polygon_mesh_processing::intersecting_meshes()`
\cgalCRPSection{Predicate Functions}
- `CGAL::Polygon_mesh_processing::is_degenerate_edge()` - `CGAL::Polygon_mesh_processing::is_degenerate_edge()`
- `CGAL::Polygon_mesh_processing::degenerate_edges()` - `CGAL::Polygon_mesh_processing::degenerate_edges()`
- `CGAL::Polygon_mesh_processing::is_degenerate_triangle_face()` - `CGAL::Polygon_mesh_processing::is_degenerate_triangle_face()`
@ -128,6 +125,7 @@ The page \ref bgl_namedparameters "Named Parameters" describes their usage.
- `CGAL::Polygon_mesh_processing::is_needle_triangle_face()` - `CGAL::Polygon_mesh_processing::is_needle_triangle_face()`
- `CGAL::Polygon_mesh_processing::is_cap_triangle_face()` - `CGAL::Polygon_mesh_processing::is_cap_triangle_face()`
- `CGAL::Polyhedral_envelope` - `CGAL::Polyhedral_envelope`
- `CGAL::Side_of_triangle_mesh`
\cgalCRPSection{Location Functions} \cgalCRPSection{Location Functions}
- \link PMP_locate_grp Point Location \endlink - \link PMP_locate_grp Point Location \endlink
@ -160,10 +158,10 @@ The page \ref bgl_namedparameters "Named Parameters" describes their usage.
- `CGAL::Polygon_mesh_processing::polygon_mesh_to_polygon_soup()` - `CGAL::Polygon_mesh_processing::polygon_mesh_to_polygon_soup()`
- `CGAL::Polygon_mesh_processing::remove_isolated_vertices()` - `CGAL::Polygon_mesh_processing::remove_isolated_vertices()`
- `CGAL::Polygon_mesh_processing::is_non_manifold_vertex()` - `CGAL::Polygon_mesh_processing::is_non_manifold_vertex()`
- `CGAL::Polygon_mesh_processing::non_manifold_vertices()`
- `CGAL::Polygon_mesh_processing::duplicate_non_manifold_vertices()` - `CGAL::Polygon_mesh_processing::duplicate_non_manifold_vertices()`
- `CGAL::Polygon_mesh_processing::merge_duplicated_vertices_in_boundary_cycle()` - `CGAL::Polygon_mesh_processing::merge_duplicated_vertices_in_boundary_cycle()`
- `CGAL::Polygon_mesh_processing::merge_duplicated_vertices_in_boundary_cycles()` - `CGAL::Polygon_mesh_processing::merge_duplicated_vertices_in_boundary_cycles()`
- `CGAL::Polygon_mesh_processing::remove_connected_components_of_negligible_size()`
\cgalCRPSection{Normal Computation Functions} \cgalCRPSection{Normal Computation Functions}
- `CGAL::Polygon_mesh_processing::compute_face_normal()` - `CGAL::Polygon_mesh_processing::compute_face_normal()`
@ -178,8 +176,9 @@ The page \ref bgl_namedparameters "Named Parameters" describes their usage.
- `CGAL::Polygon_mesh_processing::keep_large_connected_components()` - `CGAL::Polygon_mesh_processing::keep_large_connected_components()`
- `CGAL::Polygon_mesh_processing::keep_largest_connected_components()` - `CGAL::Polygon_mesh_processing::keep_largest_connected_components()`
- `CGAL::Polygon_mesh_processing::split_connected_components()` - `CGAL::Polygon_mesh_processing::split_connected_components()`
- \link keep_connected_components_grp `CGAL::Polygon_mesh_processing::keep_connected_components()` \endlink - \link PMP_keep_connected_components_grp `CGAL::Polygon_mesh_processing::keep_connected_components()` \endlink
- \link keep_connected_components_grp `CGAL::Polygon_mesh_processing::remove_connected_components()` \endlink - \link PMP_keep_connected_components_grp `CGAL::Polygon_mesh_processing::remove_connected_components()` \endlink
- `CGAL::Polygon_mesh_processing::remove_connected_components_of_negligible_size()`
\cgalCRPSection{Corefinement and Boolean Operation Functions} \cgalCRPSection{Corefinement and Boolean Operation Functions}
- `CGAL::Polygon_mesh_processing::corefine_and_compute_union()` - `CGAL::Polygon_mesh_processing::corefine_and_compute_union()`
@ -192,15 +191,16 @@ The page \ref bgl_namedparameters "Named Parameters" describes their usage.
- `CGAL::Polygon_mesh_processing::split()` - `CGAL::Polygon_mesh_processing::split()`
\cgalCRPSection{Geometric Measure Functions} \cgalCRPSection{Geometric Measure Functions}
- \link measure_grp `CGAL::Polygon_mesh_processing::face_area()` \endlink - \link PMP_measure_grp `CGAL::Polygon_mesh_processing::edge_length()` \endlink
- \link measure_grp `CGAL::Polygon_mesh_processing::squared_face_area()` \endlink - \link PMP_measure_grp `CGAL::Polygon_mesh_processing::squared_edge_length()` \endlink
- \link measure_grp `CGAL::Polygon_mesh_processing::area()` \endlink - \link PMP_measure_grp `CGAL::Polygon_mesh_processing::face_area()` \endlink
- \link measure_grp `CGAL::Polygon_mesh_processing::volume()` \endlink - \link PMP_measure_grp `CGAL::Polygon_mesh_processing::squared_face_area()` \endlink
- \link measure_grp `CGAL::Polygon_mesh_processing::edge_length()` \endlink - \link PMP_measure_grp `CGAL::Polygon_mesh_processing::area()` \endlink
- \link measure_grp `CGAL::Polygon_mesh_processing::squared_edge_length()` \endlink - \link PMP_measure_grp `CGAL::Polygon_mesh_processing::volume()` \endlink
- \link measure_grp `CGAL::Polygon_mesh_processing::face_border_length()` \endlink - \link PMP_measure_grp `CGAL::Polygon_mesh_processing::face_border_length()` \endlink
- \link measure_grp `CGAL::Polygon_mesh_processing::centroid()` \endlink - \link PMP_measure_grp `CGAL::Polygon_mesh_processing::longest_border()` \endlink
- \link measure_grp `CGAL::Polygon_mesh_processing::match_faces()` \endlink - \link PMP_measure_grp `CGAL::Polygon_mesh_processing::centroid()` \endlink
- \link PMP_measure_grp `CGAL::Polygon_mesh_processing::match_faces()` \endlink
\cgalCRPSection{Distance Functions} \cgalCRPSection{Distance Functions}
- `CGAL::Polygon_mesh_processing::bounded_error_Hausdorff_distance()` - `CGAL::Polygon_mesh_processing::bounded_error_Hausdorff_distance()`
@ -210,8 +210,8 @@ The page \ref bgl_namedparameters "Named Parameters" describes their usage.
- `CGAL::Polygon_mesh_processing::approximate_symmetric_Hausdorff_distance()` - `CGAL::Polygon_mesh_processing::approximate_symmetric_Hausdorff_distance()`
- `CGAL::Polygon_mesh_processing::approximate_max_distance_to_point_set()` - `CGAL::Polygon_mesh_processing::approximate_max_distance_to_point_set()`
- `CGAL::Polygon_mesh_processing::max_distance_to_triangle_mesh()` - `CGAL::Polygon_mesh_processing::max_distance_to_triangle_mesh()`
- `CGAL::Polygon_mesh_processing::sample_triangle_mesh()`
- `CGAL::Polygon_mesh_processing::sample_triangle_soup()` - `CGAL::Polygon_mesh_processing::sample_triangle_soup()`
- `CGAL::Polygon_mesh_processing::sample_triangle_mesh()`
\cgalCRPSection{Feature Detection Functions} \cgalCRPSection{Feature Detection Functions}
- `CGAL::Polygon_mesh_processing::sharp_edges_segmentation()` - `CGAL::Polygon_mesh_processing::sharp_edges_segmentation()`
@ -223,7 +223,6 @@ The page \ref bgl_namedparameters "Named Parameters" describes their usage.
\cgalCRPSection{Miscellaneous} \cgalCRPSection{Miscellaneous}
- `CGAL::Polygon_mesh_slicer` - `CGAL::Polygon_mesh_slicer`
- `CGAL::Side_of_triangle_mesh`
- `CGAL::Polygon_mesh_processing::bbox()` - `CGAL::Polygon_mesh_processing::bbox()`
- `CGAL::Polygon_mesh_processing::vertex_bbox()` - `CGAL::Polygon_mesh_processing::vertex_bbox()`
- `CGAL::Polygon_mesh_processing::edge_bbox()` - `CGAL::Polygon_mesh_processing::edge_bbox()`

3
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/IO/polygon_mesh_io.h
View File

@ -37,7 +37,8 @@ namespace IO {
/*! /*!
\ingroup PMP_IO_grp \ingroup PMP_IO_grp
* \brief reads the file as a polygon soup, repairs, and orients it as to obtain a polygon mesh. * \brief reads the file as a polygon soup, repairs (using `repair_polygon_soup()`),
* and orients it (using `orient_polygon_soup()`) as to obtain a polygon mesh.
* *
* Supported file formats are the following: * Supported file formats are the following:
* - \ref IOStreamOFF (`.off`) * - \ref IOStreamOFF (`.off`)

35
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/bbox.h
View File

@ -29,9 +29,10 @@ namespace CGAL {
/*! /*!
* \ingroup PkgPolygonMeshProcessingRef * \ingroup PkgPolygonMeshProcessingRef
*
* computes a bounding box of a polygon mesh. * computes a bounding box of a polygon mesh.
* *
* @tparam PolygonMesh a model of `HalfedgeListGraph` * @tparam PolygonMesh a model of `VertexListGraph`
* @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters" * @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
* *
* @param pmesh a polygon mesh * @param pmesh a polygon mesh
@ -50,12 +51,14 @@ namespace CGAL {
* \cgalParamNBegin{geom_traits} * \cgalParamNBegin{geom_traits}
* \cgalParamDescription{an instance of a geometric traits class providing the functor `Construct_bbox_3` * \cgalParamDescription{an instance of a geometric traits class providing the functor `Construct_bbox_3`
* and the function `Construct_bbox_3 construct_bbox_3_object()`. * and the function `Construct_bbox_3 construct_bbox_3_object()`.
* `Construct_bbox_3` must provide `Bbox_3 operator()(Point_3)` * `Construct_bbox_3` must provide the functor `Bbox_3 operator()(Point_3)`
* where `%Point_3` is the value type of the vertex point map.} * where `%Point_3` is the value type of the vertex point map.}
* \cgalParamNEnd * \cgalParamNEnd
* \cgalNamedParamsEnd * \cgalNamedParamsEnd
* *
* @return a bounding box of `pmesh` * @see `vertex_bbox()`
* @see `edge_bbox()`
* @see `face_bbox()`
*/ */
template<typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters> template<typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters>
CGAL::Bbox_3 bbox(const PolygonMesh& pmesh, CGAL::Bbox_3 bbox(const PolygonMesh& pmesh,
@ -84,9 +87,10 @@ namespace CGAL {
/*! /*!
* \ingroup PkgPolygonMeshProcessingRef * \ingroup PkgPolygonMeshProcessingRef
* computes a bounding box of a vertex of a polygon mesh.
* *
* @tparam PolygonMesh a model of `HalfedgeGraph` * computes a bounding box of the vertex of a polygon mesh.
*
* @tparam PolygonMesh a model of `Graph`
* @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters" * @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
* *
* @param vd a descriptor of a vertex in `pmesh` * @param vd a descriptor of a vertex in `pmesh`
@ -111,7 +115,9 @@ namespace CGAL {
* \cgalParamNEnd * \cgalParamNEnd
* \cgalNamedParamsEnd * \cgalNamedParamsEnd
* *
* @return a bounding box of `pmesh` * @see `edge_bbox()`
* @see `face_bbox()`
* @see `bbox()`
*/ */
template<typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters> template<typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters>
CGAL::Bbox_3 vertex_bbox(typename boost::graph_traits<PolygonMesh>::vertex_descriptor vd, CGAL::Bbox_3 vertex_bbox(typename boost::graph_traits<PolygonMesh>::vertex_descriptor vd,
@ -133,9 +139,10 @@ namespace CGAL {
/*! /*!
* \ingroup PkgPolygonMeshProcessingRef * \ingroup PkgPolygonMeshProcessingRef
*
* computes a bounding box of an edge of a polygon mesh. * computes a bounding box of an edge of a polygon mesh.
* *
* @tparam PolygonMesh a model of `HalfedgeGraph` * @tparam PolygonMesh a model of `Graph`
* @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters" * @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
* *
* @param ed a descriptor of an edge in `pmesh` * @param ed a descriptor of an edge in `pmesh`
@ -160,7 +167,9 @@ namespace CGAL {
* \cgalParamNEnd * \cgalParamNEnd
* \cgalNamedParamsEnd * \cgalNamedParamsEnd
* *
* @return a bounding box of `pmesh` * @see `vertex_bbox()`
* @see `face_bbox()`
* @see `bbox()`
*/ */
template<typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters> template<typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters>
CGAL::Bbox_3 edge_bbox(typename boost::graph_traits<PolygonMesh>::edge_descriptor ed, CGAL::Bbox_3 edge_bbox(typename boost::graph_traits<PolygonMesh>::edge_descriptor ed,
@ -184,9 +193,10 @@ namespace CGAL {
/*! /*!
* \ingroup PkgPolygonMeshProcessingRef * \ingroup PkgPolygonMeshProcessingRef
*
* computes a bounding box of a face of a polygon mesh. * computes a bounding box of a face of a polygon mesh.
* *
* @tparam PolygonMesh a model of `HalfedgeGraph` * @tparam PolygonMesh a model of `Graph`
* @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters" * @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
* *
* @param fd a descriptor of a face in `pmesh` * @param fd a descriptor of a face in `pmesh`
@ -212,7 +222,9 @@ namespace CGAL {
* \cgalParamNEnd * \cgalParamNEnd
* \cgalNamedParamsEnd * \cgalNamedParamsEnd
* *
* @return a bounding box of `pmesh` * @see `vertex_bbox()`
* @see `edge_bbox()`
* @see `bbox()`
*/ */
template<typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters> template<typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters>
CGAL::Bbox_3 face_bbox(typename boost::graph_traits<PolygonMesh>::face_descriptor fd, CGAL::Bbox_3 face_bbox(typename boost::graph_traits<PolygonMesh>::face_descriptor fd,
@ -233,8 +245,7 @@ namespace CGAL {
typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor halfedge_descriptor; typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor halfedge_descriptor;
CGAL::Bbox_3 bb; CGAL::Bbox_3 bb;
for(halfedge_descriptor h : for(halfedge_descriptor h : halfedges_around_face(halfedge(fd, pmesh), pmesh))
halfedges_around_face(halfedge(fd, pmesh), pmesh))
{ {
bb += get_bbox( get(vpm, target(h, pmesh)) ); bb += get_bbox( get(vpm, target(h, pmesh)) );
} }

11
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/border.h
View File

@ -144,8 +144,10 @@ std::size_t border_size(typename boost::graph_traits<PolygonMesh>::halfedge_desc
}//end namespace internal }//end namespace internal
/*! /*!
\ingroup PkgPolygonMeshProcessingRef * \ingroup PkgPolygonMeshProcessingRef
* collects the border halfedges of a surface patch defined as a face range. *
* \brief collects the border halfedges of a surface patch defined as a face range.
*
* For each returned halfedge `h`, `opposite(h, pmesh)` belongs to a face of the patch, * For each returned halfedge `h`, `opposite(h, pmesh)` belongs to a face of the patch,
* but `face(h, pmesh)` does not belong to the patch. * but `face(h, pmesh)` does not belong to the patch.
* *
@ -173,6 +175,8 @@ std::size_t border_size(typename boost::graph_traits<PolygonMesh>::halfedge_desc
* \cgalNamedParamsEnd * \cgalNamedParamsEnd
* *
* @returns `out` * @returns `out`
*
* @see `extract_boundary_cycles()`
*/ */
template<typename PolygonMesh template<typename PolygonMesh
, typename FaceRange , typename FaceRange
@ -233,6 +237,7 @@ std::size_t border_size(typename boost::graph_traits<PolygonMesh>::halfedge_desc
} }
/// @ingroup PkgPolygonMeshProcessingRef /// @ingroup PkgPolygonMeshProcessingRef
///
/// extracts boundary cycles as a list of halfedges, with one halfedge per border. /// extracts boundary cycles as a list of halfedges, with one halfedge per border.
/// ///
/// @tparam PolygonMesh a model of `HalfedgeListGraph` /// @tparam PolygonMesh a model of `HalfedgeListGraph`
@ -242,6 +247,8 @@ std::size_t border_size(typename boost::graph_traits<PolygonMesh>::halfedge_desc
/// @param pm a polygon mesh /// @param pm a polygon mesh
/// @param out an output iterator where the border halfedges will be put /// @param out an output iterator where the border halfedges will be put
/// ///
/// @see `border_halfedges()`
///
/// @todo It could make sense to also return the length of each cycle. /// @todo It could make sense to also return the length of each cycle.
/// @todo It should probably go into BGL package (like the rest of this file). /// @todo It should probably go into BGL package (like the rest of this file).
template <typename PolygonMesh, typename OutputIterator> template <typename PolygonMesh, typename OutputIterator>

61
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/clip.h
View File

@ -513,10 +513,11 @@ generic_clip_impl(
/** /**
* \ingroup PMP_corefinement_grp * \ingroup PMP_corefinement_grp
* *
* clips `tm` by keeping the part that is inside the volume \link coref_def_subsec bounded \endlink * \brief clips `tm` by keeping the part that is inside the volume \link coref_def_subsec bounded \endlink by `clipper`.
* by `clipper`. *
* If `tm` is closed, the clipped part can be closed too if the named parameter `clip_volume` is set to `true`. * If `tm` is closed, the clipped part can be closed too if the named parameter `clip_volume` is set to `true`.
* See Subsection \ref coref_clip for more details. * See Subsection \ref coref_clip for more details.
*
* \attention With the current implementation, `clipper` will be modified (refined with the intersection with `tm`). * \attention With the current implementation, `clipper` will be modified (refined with the intersection with `tm`).
* *
* \pre \link CGAL::Polygon_mesh_processing::does_self_intersect() `!CGAL::Polygon_mesh_processing::does_self_intersect(tm)` \endlink * \pre \link CGAL::Polygon_mesh_processing::does_self_intersect() `!CGAL::Polygon_mesh_processing::does_self_intersect(tm)` \endlink
@ -593,6 +594,8 @@ generic_clip_impl(
* *
* @return `true` if the output surface mesh is manifold. * @return `true` if the output surface mesh is manifold.
* If `false` is returned `tm` and `clipper` are only corefined. * If `false` is returned `tm` and `clipper` are only corefined.
*
* @see `split()`
*/ */
template <class TriangleMesh, template <class TriangleMesh,
class NamedParameters1 = parameters::Default_named_parameters, class NamedParameters1 = parameters::Default_named_parameters,
@ -623,12 +626,14 @@ clip(TriangleMesh& tm,
/** /**
* \ingroup PMP_corefinement_grp * \ingroup PMP_corefinement_grp
* clips `tm` by keeping the part that is on the negative side of `plane` (side opposite to its normal vector). *
* \brief clips `tm` by keeping the part that is on the negative side of `plane` (side opposite to its normal vector).
*
* If `tm` is closed, the clipped part can be closed too if the named parameter `clip_volume` is set to `true`. * If `tm` is closed, the clipped part can be closed too if the named parameter `clip_volume` is set to `true`.
* See Subsection \ref coref_clip for more details. * See Subsection \ref coref_clip for more details.
* *
* \note In the current implementation it is not possible to set the vertex point map and the default will be used. `Plane_3` must be * \note `Plane_3` must be from the same %Kernel as the point of the internal vertex point map of `TriangleMesh`.
* from the same %Kernel as the point of the vertex point map. * \note `Plane_3` must be from the same %Kernel as the point of the vertex point map of `tm`.
* *
* \pre \link CGAL::Polygon_mesh_processing::does_self_intersect() `!CGAL::Polygon_mesh_processing::does_self_intersect(tm)` \endlink * \pre \link CGAL::Polygon_mesh_processing::does_self_intersect() `!CGAL::Polygon_mesh_processing::does_self_intersect(tm)` \endlink
* *
@ -691,6 +696,8 @@ clip(TriangleMesh& tm,
* *
* @return `true` if the output surface mesh is manifold. * @return `true` if the output surface mesh is manifold.
* If `false` is returned `tm` is only refined by the intersection with `plane`. * If `false` is returned `tm` is only refined by the intersection with `plane`.
*
* @see `split()`
*/ */
template <class TriangleMesh, template <class TriangleMesh,
class NamedParameters = parameters::Default_named_parameters> class NamedParameters = parameters::Default_named_parameters>
@ -737,12 +744,15 @@ bool clip(TriangleMesh& tm,
/** /**
* \ingroup PMP_corefinement_grp * \ingroup PMP_corefinement_grp
* clips `tm` by keeping the part that is inside `iso_cuboid`. *
* \brief clips `tm` by keeping the part that is inside `iso_cuboid`.
*
* If `tm` is closed, the clipped part can be closed too if the named parameter `clip_volume` is set to `true`. * If `tm` is closed, the clipped part can be closed too if the named parameter `clip_volume` is set to `true`.
* See Subsection \ref coref_clip for more details. * See Subsection \ref coref_clip for more details.
* *
* \note In the current implementation it is not possible to set the vertex point map and the default will be used. `Iso_cuboid_3` must be * \note `Iso_cuboid_3` must be from the same %Kernel as the point of the internal vertex point map of `TriangleMesh`.
* from the same %Kernel as the point of the vertex point map. * \note `Iso_cuboid_3` must be from the same %Kernel as the point of the vertex point map of `tm`.
*
* \pre \link CGAL::Polygon_mesh_processing::does_self_intersect() `!CGAL::Polygon_mesh_processing::does_self_intersect(tm)` \endlink * \pre \link CGAL::Polygon_mesh_processing::does_self_intersect() `!CGAL::Polygon_mesh_processing::does_self_intersect(tm)` \endlink
* *
* @tparam TriangleMesh a model of `MutableFaceGraph`, `HalfedgeListGraph` and `FaceListGraph`. * @tparam TriangleMesh a model of `MutableFaceGraph`, `HalfedgeListGraph` and `FaceListGraph`.
@ -796,6 +806,8 @@ bool clip(TriangleMesh& tm,
* *
* @return `true` if the output surface mesh is manifold. * @return `true` if the output surface mesh is manifold.
* If `false` is returned `tm` is only refined by the intersection with `iso_cuboid`. * If `false` is returned `tm` is only refined by the intersection with `iso_cuboid`.
*
* @see `split()`
*/ */
template <class TriangleMesh, template <class TriangleMesh,
class NamedParameters = parameters::Default_named_parameters> class NamedParameters = parameters::Default_named_parameters>
@ -827,12 +839,13 @@ bool clip(TriangleMesh& tm,
/*! /*!
* \ingroup PMP_corefinement_grp * \ingroup PMP_corefinement_grp
*
* corefines `tm` and `splitter` and duplicates edges in `tm` that are on the intersection with `splitter`. * corefines `tm` and `splitter` and duplicates edges in `tm` that are on the intersection with `splitter`.
* *
* \pre \link CGAL::Polygon_mesh_processing::does_self_intersect() `!CGAL::Polygon_mesh_processing::does_self_intersect(tm)` \endlink * \pre \link CGAL::Polygon_mesh_processing::does_self_intersect() `!CGAL::Polygon_mesh_processing::does_self_intersect(tm)` \endlink
* \pre \link CGAL::Polygon_mesh_processing::does_self_intersect() `!CGAL::Polygon_mesh_processing::does_self_intersect(splitter)` \endlink * \pre \link CGAL::Polygon_mesh_processing::does_self_intersect() `!CGAL::Polygon_mesh_processing::does_self_intersect(splitter)` \endlink
* *
* @tparam TriangleMesh a model of `MutableFaceGraph`, `HalfedgeListGraph` and `FaceListGraph`. * @tparam TriangleMesh a model of `MutableFaceGraph`, `HalfedgeListGraph`, and `FaceListGraph`.
* *
* @tparam NamedParameters1 a sequence of \ref bgl_namedparameters "Named Parameters" * @tparam NamedParameters1 a sequence of \ref bgl_namedparameters "Named Parameters"
* @tparam NamedParameters2 a sequence of \ref bgl_namedparameters "Named Parameters" * @tparam NamedParameters2 a sequence of \ref bgl_namedparameters "Named Parameters"
@ -877,6 +890,8 @@ bool clip(TriangleMesh& tm,
* \cgalParamNEnd * \cgalParamNEnd
* *
* \cgalNamedParamsEnd * \cgalNamedParamsEnd
*
* @see `clip()`
*/ */
template <class TriangleMesh, template <class TriangleMesh,
class NamedParameters1 = parameters::Default_named_parameters, class NamedParameters1 = parameters::Default_named_parameters,
@ -918,15 +933,16 @@ void split(TriangleMesh& tm,
/** /**
* \ingroup PMP_corefinement_grp * \ingroup PMP_corefinement_grp
*
* adds intersection edges of `plane` and `tm` in `tm` and duplicates those edges. * adds intersection edges of `plane` and `tm` in `tm` and duplicates those edges.
* *
* \note In the current implementation it is not possible to set the vertex point map and the default will be used. * \note `Plane_3` must be from the same %Kernel as the point of the internal vertex point map of `TriangleMesh`.
* \note `Plane_3` must be from the same %Kernel as the point of the vertex point map of `tm`.
* *
* \pre \link CGAL::Polygon_mesh_processing::does_self_intersect() `!CGAL::Polygon_mesh_processing::does_self_intersect(tm)` \endlink * \pre \link CGAL::Polygon_mesh_processing::does_self_intersect() `!CGAL::Polygon_mesh_processing::does_self_intersect(tm)` \endlink
* *
* @tparam TriangleMesh a model of `MutableFaceGraph`, `HalfedgeListGraph` and `FaceListGraph` * @tparam TriangleMesh a model of `MutableFaceGraph`, `HalfedgeListGraph`, and `FaceListGraph`.
* An internal property map for `CGAL::vertex_point_t` must be available. * An internal property map for `CGAL::vertex_point_t` must be available.
*
* @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters" * @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
* *
* @param tm input triangulated surface mesh * @param tm input triangulated surface mesh
@ -965,6 +981,8 @@ void split(TriangleMesh& tm,
* Setting this option to `true` will automatically set `throw_on_self_intersection` to `false`.} * Setting this option to `true` will automatically set `throw_on_self_intersection` to `false`.}
* \cgalParamNEnd * \cgalParamNEnd
* \cgalNamedParamsEnd * \cgalNamedParamsEnd
*
* @see `clip()`
*/ */
template <class TriangleMesh, template <class TriangleMesh,
class NamedParameters = parameters::Default_named_parameters> class NamedParameters = parameters::Default_named_parameters>
@ -1005,16 +1023,16 @@ void split(TriangleMesh& tm,
/** /**
* \ingroup PMP_corefinement_grp * \ingroup PMP_corefinement_grp
*
* adds intersection edges of `iso_cuboid` and `tm` in `tm` and duplicates those edges. * adds intersection edges of `iso_cuboid` and `tm` in `tm` and duplicates those edges.
* *
* \note In the current implementation it is not possible to set the vertex point map and the default will be used. * \note `Iso_cuboid_3` must be from the same %Kernel as the point of the internal vertex point map of `TriangleMesh`.
* \note `Iso_cuboid_3` must be from the same %Kernel as the point of the vertex point map. * \note `Iso_cuboid_3` must be from the same %Kernel as the point of the vertex point map of `tm`.
* *
* \pre \link CGAL::Polygon_mesh_processing::does_self_intersect() `!CGAL::Polygon_mesh_processing::does_self_intersect(tm)` \endlink * \pre \link CGAL::Polygon_mesh_processing::does_self_intersect() `!CGAL::Polygon_mesh_processing::does_self_intersect(tm)` \endlink
* *
* @tparam TriangleMesh a model of `MutableFaceGraph`, `HalfedgeListGraph` and `FaceListGraph` * @tparam TriangleMesh a model of `MutableFaceGraph`, `HalfedgeListGraph`, and `FaceListGraph`.
* An internal property map for `CGAL::vertex_point_t` must be available. * An internal property map for `CGAL::vertex_point_t` must be available.
*
* @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters" * @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
* *
* @param tm input triangulated surface mesh * @param tm input triangulated surface mesh
@ -1053,7 +1071,7 @@ void split(TriangleMesh& tm,
* \cgalParamNEnd * \cgalParamNEnd
* *
* \cgalParamNBegin{use_compact_clipper} * \cgalParamNBegin{use_compact_clipper}
* \cgalParamDescription{if `false` the parts of `tm` coplanar with `iso_cuboid` will not be part of the output} * \cgalParamDescription{if `false`, the parts of `tm` coplanar with `iso_cuboid` will not be part of the output.}
* \cgalParamType{Boolean} * \cgalParamType{Boolean}
* \cgalParamDefault{`true`} * \cgalParamDefault{`true`}
* \cgalParamNEnd * \cgalParamNEnd
@ -1066,17 +1084,18 @@ void split(TriangleMesh& tm,
* Setting this option to `true` will automatically set `throw_on_self_intersection` to `false` * Setting this option to `true` will automatically set `throw_on_self_intersection` to `false`
* and `clip_volume` to `false`.} * and `clip_volume` to `false`.}
* \cgalParamNEnd * \cgalParamNEnd
*
* \cgalNamedParamsEnd * \cgalNamedParamsEnd
*
* @see `clip()`
*/ */
template <class TriangleMesh, template <class TriangleMesh,
class NamedParameters = parameters::Default_named_parameters> class NamedParameters = parameters::Default_named_parameters>
void split(TriangleMesh& tm, void split(TriangleMesh& tm,
#ifdef DOXYGEN_RUNNING #ifdef DOXYGEN_RUNNING
const Iso_cuboid_3& iso_cuboid, const Iso_cuboid_3& iso_cuboid,
#else #else
const typename GetGeomTraits<TriangleMesh, NamedParameters>::type::Iso_cuboid_3& iso_cuboid, const typename GetGeomTraits<TriangleMesh, NamedParameters>::type::Iso_cuboid_3& iso_cuboid,
#endif #endif
const NamedParameters& np = parameters::default_values()) const NamedParameters& np = parameters::default_values())
{ {
namespace PMP = CGAL::Polygon_mesh_processing; namespace PMP = CGAL::Polygon_mesh_processing;

28
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/compute_normal.h
View File

@ -121,7 +121,9 @@ void sum_normals(const PM& pmesh,
/** /**
* \ingroup PMP_normal_grp * \ingroup PMP_normal_grp
*
* computes the outward unit vector normal to face `f`. * computes the outward unit vector normal to face `f`.
*
* @tparam PolygonMesh a model of `FaceGraph` * @tparam PolygonMesh a model of `FaceGraph`
* @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters" * @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
* *
@ -149,12 +151,13 @@ void sum_normals(const PM& pmesh,
* *
* @return the computed normal. The return type is a 3D vector type. It is * @return the computed normal. The return type is a 3D vector type. It is
* either deduced from the `geom_traits` \ref bgl_namedparameters "Named Parameters" if provided, * either deduced from the `geom_traits` \ref bgl_namedparameters "Named Parameters" if provided,
* or from the geometric traits class deduced from the point property map * or from the geometric traits class deduced from the point property map of `pmesh`.
* of `pmesh`.
* *
* \warning This function involves a square root computation. * \warning This function involves a square root computation.
* If the field type (`FT`) of the traits does not support the `sqrt()` operation, * If the field type (`FT`) of the traits does not support the `sqrt()` operation,
* the square root computation will be performed approximately. * the square root computation will be performed approximately.
*
* @see `compute_face_normals()`
*/ */
template <typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters> template <typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters>
#ifdef DOXYGEN_RUNNING #ifdef DOXYGEN_RUNNING
@ -190,7 +193,9 @@ compute_face_normal(typename boost::graph_traits<PolygonMesh>::face_descriptor f
/** /**
* \ingroup PMP_normal_grp * \ingroup PMP_normal_grp
*
* computes the outward unit vector normal for all faces of the polygon mesh. * computes the outward unit vector normal for all faces of the polygon mesh.
*
* @tparam PolygonMesh a model of `FaceGraph` * @tparam PolygonMesh a model of `FaceGraph`
* @tparam Face_normal_map a model of `WritablePropertyMap` with * @tparam Face_normal_map a model of `WritablePropertyMap` with
`boost::graph_traits<PolygonMesh>::%face_descriptor` as key type and `boost::graph_traits<PolygonMesh>::%face_descriptor` as key type and
@ -221,6 +226,8 @@ compute_face_normal(typename boost::graph_traits<PolygonMesh>::face_descriptor f
* \warning This function involves a square root computation. * \warning This function involves a square root computation.
* If the field type (`FT`) of the traits does not support the `sqrt()` operation, * If the field type (`FT`) of the traits does not support the `sqrt()` operation,
* the square root computation will be performed approximately. * the square root computation will be performed approximately.
*
* @see `compute_face_normal()`
*/ */
template <typename PolygonMesh, typename Face_normal_map, typename NamedParameters = parameters::Default_named_parameters> template <typename PolygonMesh, typename Face_normal_map, typename NamedParameters = parameters::Default_named_parameters>
void compute_face_normals(const PolygonMesh& pmesh, void compute_face_normals(const PolygonMesh& pmesh,
@ -604,7 +611,12 @@ compute_vertex_normal_as_sum_of_weighted_normals(typename boost::graph_traits<Po
/** /**
* \ingroup PMP_normal_grp * \ingroup PMP_normal_grp
*
* computes the unit normal at vertex `v` as the average of the normals of incident faces. * computes the unit normal at vertex `v` as the average of the normals of incident faces.
*
* @note The function `compute_vertex_normals()` should be prefered if normals are intended to be
* computed at all vertices of the graph.
*
* @tparam PolygonMesh a model of `FaceGraph` * @tparam PolygonMesh a model of `FaceGraph`
* *
* @param v the vertex whose normal is computed * @param v the vertex whose normal is computed
@ -631,12 +643,13 @@ compute_vertex_normal_as_sum_of_weighted_normals(typename boost::graph_traits<Po
* *
* @return the computed normal. The return type is a 3D vector type. It is * @return the computed normal. The return type is a 3D vector type. It is
* either deduced from the `geom_traits` \ref bgl_namedparameters "Named Parameters" if provided, * either deduced from the `geom_traits` \ref bgl_namedparameters "Named Parameters" if provided,
* or the geometric traits class deduced from the point property map * or the geometric traits class deduced from the point property map of `pmesh`.
* of `pmesh`.
* *
* \warning This function involves a square root computation. * \warning This function involves a square root computation.
* If the field type (`FT`) of the traits does not support the `sqrt()` operation, * If the field type (`FT`) of the traits does not support the `sqrt()` operation,
* the square root computation will be performed approximately. * the square root computation will be performed approximately.
*
* @see `compute_vertex_normals()`
*/ */
template<typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters> template<typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters>
#ifdef DOXYGEN_RUNNING #ifdef DOXYGEN_RUNNING
@ -723,6 +736,7 @@ compute_vertex_normal(typename boost::graph_traits<PolygonMesh>::vertex_descript
/** /**
* \ingroup PMP_normal_grp * \ingroup PMP_normal_grp
*
* computes the outward unit vector normal for all vertices of the polygon mesh. * computes the outward unit vector normal for all vertices of the polygon mesh.
* *
* @tparam PolygonMesh a model of `FaceListGraph` * @tparam PolygonMesh a model of `FaceListGraph`
@ -755,6 +769,8 @@ compute_vertex_normal(typename boost::graph_traits<PolygonMesh>::vertex_descript
* \warning This function involves a square root computation. * \warning This function involves a square root computation.
* If the field type (`FT`) of the traits does not support the `sqrt()` operation, * If the field type (`FT`) of the traits does not support the `sqrt()` operation,
* the square root computation will be performed approximately. * the square root computation will be performed approximately.
*
* @see `compute_vertex_normal()`
*/ */
template <typename PolygonMesh, typename VertexNormalMap, typename NamedParameters = parameters::Default_named_parameters> template <typename PolygonMesh, typename VertexNormalMap, typename NamedParameters = parameters::Default_named_parameters>
void compute_vertex_normals(const PolygonMesh& pmesh, void compute_vertex_normals(const PolygonMesh& pmesh,
@ -813,6 +829,7 @@ void compute_vertex_normals(const PolygonMesh& pmesh,
/** /**
* \ingroup PMP_normal_grp * \ingroup PMP_normal_grp
*
* computes the outward unit vector normal for all vertices and faces of the polygon mesh. * computes the outward unit vector normal for all vertices and faces of the polygon mesh.
* *
* @tparam PolygonMesh a model of `FaceListGraph` * @tparam PolygonMesh a model of `FaceListGraph`
@ -849,6 +866,9 @@ void compute_vertex_normals(const PolygonMesh& pmesh,
* \warning This function involves a square root computation. * \warning This function involves a square root computation.
* If the field type (`FT`) of the traits does not support the `sqrt()` operation, * If the field type (`FT`) of the traits does not support the `sqrt()` operation,
* the square root computation will be performed approximately. * the square root computation will be performed approximately.
*
* @see `compute_vertex_normals()`
* @see `compute_face_normals()`
*/ */
template <typename PolygonMesh, template <typename PolygonMesh,
typename VertexNormalMap, typename FaceNormalMap, typename VertexNormalMap, typename FaceNormalMap,

74
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/connected_components.h
View File

@ -89,7 +89,8 @@ namespace internal {
} // namespace internal } // namespace internal
/*! /*!
* \ingroup keep_connected_components_grp * \ingroup PMP_keep_connected_components_grp
*
* discovers all the faces in the same connected component as `seed_face` and records them in `out`. * discovers all the faces in the same connected component as `seed_face` and records them in `out`.
* `seed_face` will also be added in `out`. * `seed_face` will also be added in `out`.
* *
@ -97,8 +98,7 @@ namespace internal {
* \tparam FaceOutputIterator a model of `OutputIterator` with value type `boost::graph_traits<PolygonMesh>::%face_descriptor`. * \tparam FaceOutputIterator a model of `OutputIterator` with value type `boost::graph_traits<PolygonMesh>::%face_descriptor`.
* \tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters" * \tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
* *
* \param seed_face a face of `pmesh` from which exploration starts to detect the connected component * \param seed_face a face of `pmesh` from which exploration starts to detect the connected component that contains it
that contains it
* \param pmesh the polygon mesh * \param pmesh the polygon mesh
* \param out the output iterator that collects faces from the same connected component as `seed_face` * \param out the output iterator that collects faces from the same connected component as `seed_face`
* \param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below * \param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
@ -114,6 +114,7 @@ namespace internal {
* *
* \returns the output iterator. * \returns the output iterator.
* *
* \see `connected_components()`
*/ */
template <typename PolygonMesh template <typename PolygonMesh
, typename FaceOutputIterator , typename FaceOutputIterator
@ -161,15 +162,16 @@ connected_component(typename boost::graph_traits<PolygonMesh>::face_descriptor s
} }
/*! /*!
* \ingroup keep_connected_components_grp * \ingroup PMP_keep_connected_components_grp
*
* computes for each face the index of the corresponding connected component. * computes for each face the index of the corresponding connected component.
* *
* \tparam PolygonMesh a model of `FaceListGraph` * \tparam PolygonMesh a model of `FaceListGraph`
* \tparam FaceComponentMap a model of `WritablePropertyMap` with * \tparam FaceComponentMap a model of `WritablePropertyMap` with
`boost::graph_traits<PolygonMesh>::%face_descriptor` as key type and * `boost::graph_traits<PolygonMesh>::%face_descriptor` as key type and
`boost::graph_traits<PolygonMesh>::%faces_size_type` as value type. * `boost::graph_traits<PolygonMesh>::%faces_size_type` as value type.
* \tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters" * \tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
*
* \param pmesh the polygon mesh * \param pmesh the polygon mesh
* \param fcm the property map with indices of components associated to faces in `pmesh` * \param fcm the property map with indices of components associated to faces in `pmesh`
* \param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below * \param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
@ -181,7 +183,7 @@ connected_component(typename boost::graph_traits<PolygonMesh>::face_descriptor s
* as key type and `bool` as value type} * as key type and `bool` as value type}
* \cgalParamDefault{a constant property map returning `false` for any edge} * \cgalParamDefault{a constant property map returning `false` for any edge}
* \cgalParamNEnd * \cgalParamNEnd
*
* \cgalParamNBegin{face_index_map} * \cgalParamNBegin{face_index_map}
* \cgalParamDescription{a property map associating to each face of `pmesh` a unique index between `0` and `num_faces(pmesh) - 1`} * \cgalParamDescription{a property map associating to each face of `pmesh` a unique index between `0` and `num_faces(pmesh) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%face_descriptor` * \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%face_descriptor`
@ -191,8 +193,9 @@ connected_component(typename boost::graph_traits<PolygonMesh>::face_descriptor s
* \cgalNamedParamsEnd * \cgalNamedParamsEnd
* *
* \returns the number of connected components. * \returns the number of connected components.
*
* \see `connected_component()`
*/ */
template <typename PolygonMesh template <typename PolygonMesh
, typename FaceComponentMap , typename FaceComponentMap
, typename NamedParameters = parameters::Default_named_parameters , typename NamedParameters = parameters::Default_named_parameters
@ -266,7 +269,8 @@ void keep_connected_components(PolygonMesh& pmesh
namespace internal { namespace internal {
// /*! // /*!
// * \ingroup keep_connected_components_grp // * \ingroup PMP_keep_connected_components_grp
// *
// * returns the number of connected components in the mesh. // * returns the number of connected components in the mesh.
// * // *
// * A property map for `CGAL::face_index_t` must be either available as an internal property map // * A property map for `CGAL::face_index_t` must be either available as an internal property map
@ -296,6 +300,7 @@ namespace internal {
// * // *
// * \returns the output iterator. // * \returns the output iterator.
// * // *
// * \see `connected_components()`
// */ // */
template <typename PolygonMesh, template <typename PolygonMesh,
typename CGAL_NP_TEMPLATE_PARAMETERS> typename CGAL_NP_TEMPLATE_PARAMETERS>
@ -314,9 +319,10 @@ std::size_t number_of_connected_components(const PolygonMesh& pmesh,
} // end namespace internal } // end namespace internal
/*! /*!
* \ingroup keep_connected_components_grp * \ingroup PMP_keep_connected_components_grp
*
* \brief removes the small connected components and all isolated vertices.
* *
* removes the small connected components and all isolated vertices.
* Keep the `nb_components_to_keep` largest connected components, where the size of a connected * Keep the `nb_components_to_keep` largest connected components, where the size of a connected
* component is computed as the sum of the individual sizes of all the faces of the connected component. * component is computed as the sum of the individual sizes of all the faces of the connected component.
* By default, the size of a face is `1` (and thus the size of a connected component is the number * By default, the size of a face is `1` (and thus the size of a connected component is the number
@ -375,6 +381,8 @@ std::size_t number_of_connected_components(const PolygonMesh& pmesh,
* \cgalNamedParamsEnd * \cgalNamedParamsEnd
* *
* \return the number of connected components removed (ignoring isolated vertices). * \return the number of connected components removed (ignoring isolated vertices).
*
* \see `keep_large_connected_components()`
*/ */
template <typename PolygonMesh, template <typename PolygonMesh,
typename NamedParameters = parameters::Default_named_parameters> typename NamedParameters = parameters::Default_named_parameters>
@ -458,12 +466,14 @@ std::size_t keep_largest_connected_components(PolygonMesh& pmesh,
} }
/*! /*!
* \ingroup keep_connected_components_grp * \ingroup PMP_keep_connected_components_grp
* removes connected components whose size is (strictly) smaller than a given threshold value, *
* \brief removes connected components whose size is (strictly) smaller than a given threshold value,
* where the size of a connected component is computed as the sum of the individual sizes * where the size of a connected component is computed as the sum of the individual sizes
* of all the faces of the connected component. By default, the size of a face is `1` (and thus * of all the faces of the connected component.
* the size of a connected component is the number of faces it contains), but it is also possible *
* to pass custom sizes, such as the area of the face. * By default, the size of a face is `1` (and thus the size of a connected component is the number
* of faces it contains), but it is also possible to pass custom sizes, such as the area of the face.
* *
* \tparam PolygonMesh a model of `FaceListGraph` and `MutableFaceGraph` * \tparam PolygonMesh a model of `FaceListGraph` and `MutableFaceGraph`
* \tparam ThresholdValueType the type of the threshold value * \tparam ThresholdValueType the type of the threshold value
@ -521,6 +531,8 @@ std::size_t keep_largest_connected_components(PolygonMesh& pmesh,
* type as the value type of the property map. Otherwise, `ThresholdValueType` must be `std::size_t`. * type as the value type of the property map. Otherwise, `ThresholdValueType` must be `std::size_t`.
* *
* \return the number of connected components removed (ignoring isolated vertices). * \return the number of connected components removed (ignoring isolated vertices).
*
* \see `keep_largest_connected_components()`
*/ */
template <typename PolygonMesh, template <typename PolygonMesh,
typename ThresholdValueType, typename ThresholdValueType,
@ -740,7 +752,8 @@ void keep_or_remove_connected_components(PolygonMesh& pmesh
} }
/*! /*!
* \ingroup keep_connected_components_grp * \ingroup PMP_keep_connected_components_grp
*
* keeps the connected components designated by theirs ids in `components_to_keep`, * keeps the connected components designated by theirs ids in `components_to_keep`,
* and removes the other connected components as well as all isolated vertices. * and removes the other connected components as well as all isolated vertices.
* The connected component id of a face is given by `fcm`. * The connected component id of a face is given by `fcm`.
@ -770,6 +783,7 @@ void keep_or_remove_connected_components(PolygonMesh& pmesh
* \cgalParamNEnd * \cgalParamNEnd
* \cgalNamedParamsEnd * \cgalNamedParamsEnd
* *
* \see `remove_connected_components()`
*/ */
template <typename PolygonMesh template <typename PolygonMesh
, typename ComponentRange , typename ComponentRange
@ -784,7 +798,8 @@ void keep_connected_components(PolygonMesh& pmesh
} }
/*! /*!
* \ingroup keep_connected_components_grp * \ingroup PMP_keep_connected_components_grp
*
* removes in `pmesh` the connected components designated by theirs ids * removes in `pmesh` the connected components designated by theirs ids
* in `components_to_remove` as well as all isolated vertices. * in `components_to_remove` as well as all isolated vertices.
* The connected component id of a face is given by `fcm`. * The connected component id of a face is given by `fcm`.
@ -814,6 +829,7 @@ void keep_connected_components(PolygonMesh& pmesh
* \cgalParamNEnd * \cgalParamNEnd
* \cgalNamedParamsEnd * \cgalNamedParamsEnd
* *
* \see `keep_connected_components()`
*/ */
template <typename PolygonMesh template <typename PolygonMesh
, typename ComponentRange , typename ComponentRange
@ -829,7 +845,8 @@ void remove_connected_components(PolygonMesh& pmesh
} }
/*! /*!
* \ingroup keep_connected_components_grp * \ingroup PMP_keep_connected_components_grp
*
* keeps the connected components not designated by the faces in `components_to_remove`, * keeps the connected components not designated by the faces in `components_to_remove`,
* and removes the other connected components and all isolated vertices. * and removes the other connected components and all isolated vertices.
* *
@ -868,6 +885,7 @@ void remove_connected_components(PolygonMesh& pmesh
* \cgalParamNEnd * \cgalParamNEnd
* \cgalNamedParamsEnd * \cgalNamedParamsEnd
* *
* \see `keep_connected_components()`
*/ */
template <typename PolygonMesh template <typename PolygonMesh
, typename FaceRange , typename FaceRange
@ -899,7 +917,8 @@ void remove_connected_components(PolygonMesh& pmesh
} }
/*! /*!
* \ingroup keep_connected_components_grp * \ingroup PMP_keep_connected_components_grp
*
* keeps the connected components designated by the faces in `components_to_keep`, * keeps the connected components designated by the faces in `components_to_keep`,
* and removes the other connected components and all isolated vertices. * and removes the other connected components and all isolated vertices.
* *
@ -938,6 +957,7 @@ void remove_connected_components(PolygonMesh& pmesh
* \cgalParamNEnd * \cgalParamNEnd
* \cgalNamedParamsEnd * \cgalNamedParamsEnd
* *
* \see `remove_connected_components()`
*/ */
template <typename PolygonMesh template <typename PolygonMesh
, typename FaceRange , typename FaceRange
@ -1027,16 +1047,18 @@ void split_connected_components_impl(FIMap fim,
}//internal }//internal
/*! /*!
* \ingroup keep_connected_components_grp * \ingroup PMP_keep_connected_components_grp
* identifies the connected components of `pmesh` and pushes back a new `PolygonMesh` for each connected component in `cc_meshes`.
* *
* \tparam PolygonMesh a model of `FaceListGraph` * identifies the connected components of `pmesh` and pushes back a new `PolygonMesh`
* \tparam PolygonMeshRange a model of `SequenceContainer` with `PolygonMesh` as value type. * for each connected component in `cc_meshes`.
*
* \tparam PolygonMesh a model of `FaceListGraph` and `MutableFaceGraph`
* \tparam PolygonMeshRange a model of `SequenceContainer` with `PolygonMesh` as value type
* *
* \tparam NamedParameters a sequence of Named Parameters * \tparam NamedParameters a sequence of Named Parameters
* *
* \param pmesh the polygon mesh * \param pmesh the polygon mesh
* \param cc_meshes container that is filled with the extracted connected components. * \param cc_meshes container that is filled with the extracted connected components
* \param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below * \param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
* *
* \cgalNamedParamsBegin * \cgalNamedParamsBegin

11
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/corefinement.h
View File

@ -67,6 +67,7 @@ enum Boolean_operation_type {UNION = 0, INTERSECTION=1,
/** /**
* \ingroup PMP_corefinement_grp * \ingroup PMP_corefinement_grp
*
* \link coref_def_subsec corefines \endlink `tm1` and `tm2` and for each triangle mesh `tm_out` passed * \link coref_def_subsec corefines \endlink `tm1` and `tm2` and for each triangle mesh `tm_out` passed
* as an optional in `output` different from `boost::none`, the triangulated surface mesh * as an optional in `output` different from `boost::none`, the triangulated surface mesh
* \link coref_def_subsec bounding \endlink the result of a particular Boolean operation * \link coref_def_subsec bounding \endlink the result of a particular Boolean operation
@ -88,7 +89,7 @@ enum Boolean_operation_type {UNION = 0, INTERSECTION=1,
* \pre \link CGAL::Polygon_mesh_processing::does_bound_a_volume() `CGAL::Polygon_mesh_processing::does_bound_a_volume(tm1)` \endlink * \pre \link CGAL::Polygon_mesh_processing::does_bound_a_volume() `CGAL::Polygon_mesh_processing::does_bound_a_volume(tm1)` \endlink
* \pre \link CGAL::Polygon_mesh_processing::does_bound_a_volume() `CGAL::Polygon_mesh_processing::does_bound_a_volume(tm2)` \endlink * \pre \link CGAL::Polygon_mesh_processing::does_bound_a_volume() `CGAL::Polygon_mesh_processing::does_bound_a_volume(tm2)` \endlink
* *
* @tparam TriangleMesh a model of `MutableFaceGraph`, `HalfedgeListGraph` and `FaceListGraph` * @tparam TriangleMesh a model of `HalfedgeListGraph`, `FaceListGraph`, and `MutableFaceGraph`
* @tparam NamedParameters1 a sequence of \ref bgl_namedparameters "Named Parameters" * @tparam NamedParameters1 a sequence of \ref bgl_namedparameters "Named Parameters"
* @tparam NamedParameters2 a sequence of \ref bgl_namedparameters "Named Parameters" * @tparam NamedParameters2 a sequence of \ref bgl_namedparameters "Named Parameters"
* @tparam NamedParametersOut0 a sequence of \ref bgl_namedparameters "Named Parameters" for computing the union of the volumes bounded by `tm1` and `tm2` * @tparam NamedParametersOut0 a sequence of \ref bgl_namedparameters "Named Parameters" for computing the union of the volumes bounded by `tm1` and `tm2`
@ -430,7 +431,7 @@ corefine_and_compute_boolean_operations(
* \pre \link CGAL::Polygon_mesh_processing::does_bound_a_volume() `CGAL::Polygon_mesh_processing::does_bound_a_volume(tm1)` \endlink * \pre \link CGAL::Polygon_mesh_processing::does_bound_a_volume() `CGAL::Polygon_mesh_processing::does_bound_a_volume(tm1)` \endlink
* \pre \link CGAL::Polygon_mesh_processing::does_bound_a_volume() `CGAL::Polygon_mesh_processing::does_bound_a_volume(tm2)` \endlink * \pre \link CGAL::Polygon_mesh_processing::does_bound_a_volume() `CGAL::Polygon_mesh_processing::does_bound_a_volume(tm2)` \endlink
* *
* @tparam TriangleMesh a model of `MutableFaceGraph`, `HalfedgeListGraph` and `FaceListGraph` * @tparam TriangleMesh a model of `HalfedgeListGraph`, `FaceListGraph`, and `MutableFaceGraph`
* @tparam NamedParameters1 a sequence of \ref bgl_namedparameters "Named Parameters" * @tparam NamedParameters1 a sequence of \ref bgl_namedparameters "Named Parameters"
* @tparam NamedParameters2 a sequence of \ref bgl_namedparameters "Named Parameters" * @tparam NamedParameters2 a sequence of \ref bgl_namedparameters "Named Parameters"
* @tparam NamedParametersOut a sequence of \ref bgl_namedparameters "Named Parameters" * @tparam NamedParametersOut a sequence of \ref bgl_namedparameters "Named Parameters"
@ -609,7 +610,7 @@ corefine_and_compute_difference( TriangleMesh& tm1,
* \pre \link CGAL::Polygon_mesh_processing::does_self_intersect() `!CGAL::Polygon_mesh_processing::does_self_intersect(tm1)` \endlink * \pre \link CGAL::Polygon_mesh_processing::does_self_intersect() `!CGAL::Polygon_mesh_processing::does_self_intersect(tm1)` \endlink
* \pre \link CGAL::Polygon_mesh_processing::does_self_intersect() `!CGAL::Polygon_mesh_processing::does_self_intersect(tm2)` \endlink * \pre \link CGAL::Polygon_mesh_processing::does_self_intersect() `!CGAL::Polygon_mesh_processing::does_self_intersect(tm2)` \endlink
* *
* @tparam TriangleMesh a model of `MutableFaceGraph`, `HalfedgeListGraph` and `FaceListGraph` * @tparam TriangleMesh a model of `HalfedgeListGraph`, `FaceListGraph`, and `MutableFaceGraph`
* @tparam NamedParameters1 a sequence of \ref bgl_namedparameters "Named Parameters" * @tparam NamedParameters1 a sequence of \ref bgl_namedparameters "Named Parameters"
* @tparam NamedParameters2 a sequence of \ref bgl_namedparameters "Named Parameters" * @tparam NamedParameters2 a sequence of \ref bgl_namedparameters "Named Parameters"
* *
@ -764,7 +765,7 @@ namespace experimental {
* Self-intersection edges will be marked as constrained. If an edge that was marked as * Self-intersection edges will be marked as constrained. If an edge that was marked as
* constrained is split, its sub-edges will be marked as constrained as well. * constrained is split, its sub-edges will be marked as constrained as well.
* *
* @tparam TriangleMesh a model of `MutableFaceGraph`, `HalfedgeListGraph` and `FaceListGraph` * @tparam TriangleMesh a model of `HalfedgeListGraph`, `FaceListGraph`, and `MutableFaceGraph`
* @tparam NamedParameters a sequence of \ref namedparameters * @tparam NamedParameters a sequence of \ref namedparameters
* *
* @param tm input triangulated surface mesh * @param tm input triangulated surface mesh
@ -856,7 +857,7 @@ autorefine( TriangleMesh& tm,
* constrained is split, its sub-edges will be marked as constrained as well. * constrained is split, its sub-edges will be marked as constrained as well.
* \return `true` if all self-intersections were fixed and `false` otherwise. * \return `true` if all self-intersections were fixed and `false` otherwise.
* *
* @tparam TriangleMesh a model of `MutableFaceGraph`, `HalfedgeListGraph` and `FaceListGraph` * @tparam TriangleMesh a model of `HalfedgeListGraph`, `FaceListGraph`, and `MutableFaceGraph`
* @tparam NamedParameters a sequence of \ref namedparameters * @tparam NamedParameters a sequence of \ref namedparameters
* *
* @param tm input triangulated surface mesh * @param tm input triangulated surface mesh

27
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/detect_features.h
View File

@ -225,7 +225,8 @@ void sharp_call(const FT angle_in_deg,
/*! /*!
* \ingroup PMP_detect_features_grp * \ingroup PMP_detect_features_grp
* *
* detects and marks the edges that are considered to be sharp with respect to the given angle bound. * \brief detects and marks the edges that are considered to be sharp with respect to the given angle bound.
*
* `angle_in_deg` gives the maximum angle (in degrees) between the two normal vectors of adjacent triangles. * `angle_in_deg` gives the maximum angle (in degrees) between the two normal vectors of adjacent triangles.
* For an edge of the input polygon mesh, if the angle between the two normal vectors of its incident facets is bigger * For an edge of the input polygon mesh, if the angle between the two normal vectors of its incident facets is bigger
* than the given bound, then the edge is marked as being a feature edge. * than the given bound, then the edge is marked as being a feature edge.
@ -261,6 +262,7 @@ void sharp_call(const FT angle_in_deg,
* \cgalParamNEnd * \cgalParamNEnd
* \cgalNamedParamsEnd * \cgalNamedParamsEnd
* *
* \see `sharp_edges_segmentation()`
*/ */
#ifdef DOXYGEN_RUNNING #ifdef DOXYGEN_RUNNING
template <typename PolygonMesh, typename FT, template <typename PolygonMesh, typename FT,
@ -299,13 +301,13 @@ void detect_sharp_edges(const PolygonMesh& pmesh,
* *
* \tparam PolygonMesh a model of `HalfedgeListGraph` * \tparam PolygonMesh a model of `HalfedgeListGraph`
* \tparam PatchIdMap a model of `ReadablePropertyMap` with * \tparam PatchIdMap a model of `ReadablePropertyMap` with
`boost::graph_traits<PolygonMesh>::%face_descriptor` as key type * `boost::graph_traits<PolygonMesh>::%face_descriptor` as key type
and the desired patch id, model of `CopyConstructible` as value type. * and the desired patch id, model of `CopyConstructible` as value type.
* \tparam VertexIncidentPatchesMap a model of mutable `LvaluePropertyMap` with * \tparam VertexIncidentPatchesMap a model of mutable `LvaluePropertyMap` with
`boost::graph_traits<PolygonMesh>::%vertex_descriptor` as key type. Its value type * `boost::graph_traits<PolygonMesh>::%vertex_descriptor` as key type. Its value type
must be a container of `boost::property_traits<PatchIdMap>::%value_type` and have a function `insert()`. * must be a container of `boost::property_traits<PatchIdMap>::%value_type` and have a function `insert()`.
A `std::set` or a `boost::unordered_set` are recommended, as a patch index may be * A `std::set` or a `boost::unordered_set` are recommended, as a patch index may be
inserted several times. * inserted several times.
* \tparam EdgeIsFeatureMap a model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%edge_descriptor` * \tparam EdgeIsFeatureMap a model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%edge_descriptor`
* as key type and `bool` as value type. * as key type and `bool` as value type.
* *
@ -314,7 +316,7 @@ void detect_sharp_edges(const PolygonMesh& pmesh,
* \param vertex_incident_patches_map a property map that will contain the patch ids of all the faces incident to each vertex of `pmesh`. * \param vertex_incident_patches_map a property map that will contain the patch ids of all the faces incident to each vertex of `pmesh`.
* \param edge_is_feature_map a filled property map that will contain the sharp-or-not status of each edge of `pmesh` * \param edge_is_feature_map a filled property map that will contain the sharp-or-not status of each edge of `pmesh`
* *
* @see `CGAL::Polygon_mesh_processing::sharp_edges_segmentation()` * \see `sharp_edges_segmentation()`
*/ */
template <typename PolygonMesh, typename PatchIdMap, template <typename PolygonMesh, typename PatchIdMap,
@ -369,12 +371,11 @@ void vip_call(const PolygonMesh&, PIDMap, const internal_np::Param_not_found&, E
* \ingroup PMP_detect_features_grp * \ingroup PMP_detect_features_grp
* *
* This function calls successively `CGAL::Polygon_mesh_processing::detect_sharp_edges()`, * This function calls successively `CGAL::Polygon_mesh_processing::detect_sharp_edges()`,
* `CGAL::Polygon_mesh_processing::connected_components()` and * `CGAL::Polygon_mesh_processing::connected_components()`, and
* `CGAL::Polygon_mesh_processing::detect_vertex_incident_patches()` * `CGAL::Polygon_mesh_processing::detect_vertex_incident_patches()`
* *
* It detects and marks the sharp edges of `pmesh` according to `angle_in_deg`. * It detects and marks the sharp edges of `pmesh` according to `angle_in_deg`.
* The sharp edges define a segmentation of `pmesh`, that is done by * The sharp edges define a segmentation of `pmesh`, that is done by computing a
* computing a
* surface patch id for each face. * surface patch id for each face.
* *
* \tparam PolygonMesh a model of `FaceGraph` * \tparam PolygonMesh a model of `FaceGraph`
@ -384,8 +385,8 @@ void vip_call(const PolygonMesh&, PIDMap, const internal_np::Param_not_found&, E
* of `PolygonMesh`. * of `PolygonMesh`.
* \tparam EdgeIsFeatureMap a model of `ReadWritePropertyMap` with `boost::graph_traits<PolygonMesh>::%edge_descriptor` * \tparam EdgeIsFeatureMap a model of `ReadWritePropertyMap` with `boost::graph_traits<PolygonMesh>::%edge_descriptor`
* \tparam PatchIdMap a model of `ReadWritePropertyMap` with * \tparam PatchIdMap a model of `ReadWritePropertyMap` with
`boost::graph_traits<PolygonMesh>::%face_descriptor` as key type * `boost::graph_traits<PolygonMesh>::%face_descriptor` as key type
and the desired patch id, model of `CopyConstructible` as value type. * and the desired patch id, model of `CopyConstructible` as value type.
* \tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters" * \tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
* *
* \param pmesh the polygon mesh * \param pmesh the polygon mesh

13
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/extrude.h
View File

@ -245,8 +245,8 @@ void extrude_mesh(const InputMesh& input,
* @tparam NamedParameters1 a sequence of \ref bgl_namedparameters "Named Parameters" for `InputMesh` * @tparam NamedParameters1 a sequence of \ref bgl_namedparameters "Named Parameters" for `InputMesh`
* @tparam NamedParameters2 a sequence of \ref bgl_namedparameters "Named Parameters" for `OutputMesh` * @tparam NamedParameters2 a sequence of \ref bgl_namedparameters "Named Parameters" for `OutputMesh`
* *
* @param input an open surface mesh to extrude. * @param input an open surface mesh to extrude
* @param output a surface mesh that will contain the result of the extrusion. * @param output a surface mesh that will contain the result of the extrusion
* @param v the vector defining the direction of the extrusion * @param v the vector defining the direction of the extrusion
* @param np_in an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below * @param np_in an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
* *
@ -280,11 +280,11 @@ template <class InputMesh,
class CGAL_NP_TEMPLATE_PARAMETERS_2> class CGAL_NP_TEMPLATE_PARAMETERS_2>
void extrude_mesh(const InputMesh& input, void extrude_mesh(const InputMesh& input,
OutputMesh& output, OutputMesh& output,
#ifdef DOXYGEN_RUNNING #ifdef DOXYGEN_RUNNING
Vector_3 v, Vector_3 v,
#else #else
typename GetGeomTraits<OutputMesh, CGAL_NP_CLASS_2>::type::Vector_3 v, typename GetGeomTraits<OutputMesh, CGAL_NP_CLASS_2>::type::Vector_3 v,
#endif #endif
const CGAL_NP_CLASS_1& np_in = parameters::default_values(), const CGAL_NP_CLASS_1& np_in = parameters::default_values(),
const CGAL_NP_CLASS_2& np_out = parameters::default_values()) const CGAL_NP_CLASS_2& np_out = parameters::default_values())
{ {
@ -294,8 +294,7 @@ void extrude_mesh(const InputMesh& input,
extrude_impl::Const_dist_translation< extrude_impl::Const_dist_translation<
typename GetVertexPointMap<OutputMesh, CGAL_NP_CLASS_2>::type, typename GetVertexPointMap<OutputMesh, CGAL_NP_CLASS_2>::type,
typename GetGeomTraits<OutputMesh, CGAL_NP_CLASS_2>::type::Vector_3> bot(output_vpm, typename GetGeomTraits<OutputMesh, CGAL_NP_CLASS_2>::type::Vector_3> bot(output_vpm, v);
v);
extrude_impl::Identity_functor top; extrude_impl::Identity_functor top;
extrude_mesh(input, output, bot,top, np_in, np_out); extrude_mesh(input, output, bot,top, np_in, np_out);
} }

6
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/fair.h
View File

@ -58,7 +58,9 @@ namespace internal {
/*! /*!
\ingroup PMP_meshing_grp \ingroup PMP_meshing_grp
@brief fairs a region on a triangle mesh. @brief fairs a region on a triangle mesh.
The points of the selected vertices are The points of the selected vertices are
relocated to yield an as-smooth-as-possible surface patch, relocated to yield an as-smooth-as-possible surface patch,
based on solving a linear bi-Laplacian system with boundary constraints, based on solving a linear bi-Laplacian system with boundary constraints,
@ -114,11 +116,11 @@ namespace internal {
\cgalParamNEnd \cgalParamNEnd
\cgalNamedParamsEnd \cgalNamedParamsEnd
@return `true` if fairing is successful, otherwise no vertices are relocated @return `true` if fairing is successful, otherwise no vertices are relocated.
@pre `is_triangle_mesh(tmesh)` @pre `is_triangle_mesh(tmesh)`
@warning This function involves linear algebra, that is computed using a non-exact floating-point arithmetic. @warning This function involves linear algebra, that is computed using non-exact, floating-point arithmetic.
@todo accuracy of solvers are not good, for example when there is no boundary condition pre_factor should fail, but it does not. @todo accuracy of solvers are not good, for example when there is no boundary condition pre_factor should fail, but it does not.
*/ */

75
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/intersection.h
View File

@ -333,7 +333,8 @@ struct Throw_at_first_output {
}; };
// Note this is not officially documented // Note this is not officially documented
/* /* \ingroup PMP_intersection_grp
*
* reports all the pairs of faces intersecting between two triangulated surface meshes. * reports all the pairs of faces intersecting between two triangulated surface meshes.
* This function depends on the package \ref PkgBoxIntersectionD. * This function depends on the package \ref PkgBoxIntersectionD.
* *
@ -466,13 +467,15 @@ compute_face_face_intersection(const FaceRange& face_range1,
} }
// Note this is not officially documented // Note this is not officially documented
/* /* \ingroup PMP_intersection_grp
*
* reports all the pairs of segments and faces intersecting between * reports all the pairs of segments and faces intersecting between
* a triangulated surface mesh and a polyline. * a triangulated surface mesh and a polyline.
* \attention If a polyline vertex intersects a face, the intersection will
* be reported twice (even more if it is on a vertex, edge, or point).
* This function depends on the package \ref PkgBoxIntersectionD. * This function depends on the package \ref PkgBoxIntersectionD.
* *
* \attention If a polyline vertex intersects a face, the intersection will
* be reported twice (or more if it is on a vertex, edge, or point).
*
* \pre `CGAL::is_triangle_mesh(tm)` * \pre `CGAL::is_triangle_mesh(tm)`
* *
* \tparam TriangleMesh a model of `FaceListGraph` * \tparam TriangleMesh a model of `FaceListGraph`
@ -518,7 +521,7 @@ template <class TriangleMesh,
class OutputIterator, class OutputIterator,
class NamedParameters> class NamedParameters>
OutputIterator OutputIterator
compute_face_polyline_intersection( const FaceRange& face_range, compute_face_polyline_intersection(const FaceRange& face_range,
const Polyline& polyline, const Polyline& polyline,
const TriangleMesh& tm, const TriangleMesh& tm,
OutputIterator out, OutputIterator out,
@ -596,12 +599,14 @@ compute_face_polyline_intersection( const FaceRange& face_range,
} }
// Note this is not officially documented // Note this is not officially documented
/* /* \ingroup PMP_intersection_grp
*
* reports all the pairs of segments and faces intersecting between * reports all the pairs of segments and faces intersecting between
* a triangulated surface mesh and a range of polylines. * a triangulated surface mesh and a range of polylines.
* This function depends on the package \ref PkgBoxIntersectionD.
*
* \attention If a polyline vertex intersects a face, the intersection will * \attention If a polyline vertex intersects a face, the intersection will
* be reported twice (even more if it is on a vertex, edge, or point). * be reported twice (even more if it is on a vertex, edge, or point).
* This function depends on the package \ref PkgBoxIntersectionD.
* *
* \pre `CGAL::is_triangle_mesh(tm)` * \pre `CGAL::is_triangle_mesh(tm)`
* *
@ -743,11 +748,14 @@ compute_face_polylines_intersection(const FaceRange& face_range,
} }
// Note this is not officially documented // Note this is not officially documented
/* /* \ingroup PMP_intersection_grp
*
* detects and records intersections between two polylines. * detects and records intersections between two polylines.
* This function depends on the package \ref PkgBoxIntersectionD. * This function depends on the package \ref PkgBoxIntersectionD.
*
* \attention If a polyline vertex intersects another polyline, the intersection will * \attention If a polyline vertex intersects another polyline, the intersection will
* be reported twice (even more if it is on a vertex). * be reported twice (even more if it is on a vertex).
*
* \tparam Polyline a `RandomAccessRange` of points. * \tparam Polyline a `RandomAccessRange` of points.
* \tparam OutputIterator a model of `OutputIterator` holding objects of type * \tparam OutputIterator a model of `OutputIterator` holding objects of type
* `std::pair<std::size_t, std::size_t>`. This OutputIterator will hold the position of the * `std::pair<std::size_t, std::size_t>`. This OutputIterator will hold the position of the
@ -818,11 +826,13 @@ compute_polyline_polyline_intersection(const Polyline& polyline1,
} }
// Note this is not officially documented // Note this is not officially documented
/* /* \ingroup PMP_intersection_grp
*
* detects and records intersections between two ranges of polylines. * detects and records intersections between two ranges of polylines.
* This function depends on the package \ref PkgBoxIntersectionD.
*
* \attention If a polyline vertex intersects another polyline, the intersection will * \attention If a polyline vertex intersects another polyline, the intersection will
* be reported twice (even more if it is on a vertex). * be reported twice (even more if it is on a vertex).
* This function depends on the package \ref PkgBoxIntersectionD.
* *
* \tparam PolylineRange a `RandomAccessRange` of `RandomAccessRange` of points. * \tparam PolylineRange a `RandomAccessRange` of `RandomAccessRange` of points.
* \tparam OutputIterator a model of `OutputIterator` holding objects of type * \tparam OutputIterator a model of `OutputIterator` holding objects of type
@ -925,7 +935,8 @@ compute_polylines_polylines_intersection(const PolylineRange& polylines1,
} }
// Note this is not officially documented // Note this is not officially documented
/* /* \ingroup PMP_intersection_grp
*
* reports all the pairs of faces intersecting between two triangulated surface meshes. * reports all the pairs of faces intersecting between two triangulated surface meshes.
* This function depends on the package \ref PkgBoxIntersectionD. * This function depends on the package \ref PkgBoxIntersectionD.
* *
@ -980,12 +991,13 @@ compute_face_face_intersection(const TriangleMesh& tm1,
} }
// Note this is not officially documented // Note this is not officially documented
/* /* \ingroup PMP_intersection_grp
* detects and records intersections between a triangulated surface mesh *
* and a polyline. * detects and records intersections between a triangulated surface mesh and a polyline.
* This function depends on the package \ref PkgBoxIntersectionD.
*
* \attention If a polyline vertex intersects a face or another polyline, the intersection will * \attention If a polyline vertex intersects a face or another polyline, the intersection will
* be reported twice (even more if it is on a vertex, edge, or point). * be reported twice (even more if it is on a vertex, edge, or point).
* This function depends on the package \ref PkgBoxIntersectionD.
* *
* \pre `CGAL::is_triangle_mesh(tm)` * \pre `CGAL::is_triangle_mesh(tm)`
* *
@ -1037,7 +1049,6 @@ compute_face_polyline_intersection(const TriangleMesh& tm,
return compute_face_polyline_intersection(faces(tm), polyline, tm, out, np); return compute_face_polyline_intersection(faces(tm), polyline, tm, out, np);
} }
// functions to check for overlap of meshes // functions to check for overlap of meshes
template <class GT, class TriangleMesh, class VPM> template <class GT, class TriangleMesh, class VPM>
void get_one_point_per_cc(TriangleMesh& tm, void get_one_point_per_cc(TriangleMesh& tm,
@ -1114,7 +1125,8 @@ bool is_mesh2_in_mesh1(const TriangleMesh& tm1,
}// namespace internal }// namespace internal
/** /**
* \ingroup PMP_predicates_grp * \ingroup PMP_intersection_grp
*
* returns `true` if there exists a segment of a polyline of `polylines1` * returns `true` if there exists a segment of a polyline of `polylines1`
* and a segment of a polyline of `polylines2` which intersect, and `false` otherwise. * and a segment of a polyline of `polylines2` which intersect, and `false` otherwise.
* This function depends on the package \ref PkgBoxIntersectionD. * This function depends on the package \ref PkgBoxIntersectionD.
@ -1157,7 +1169,8 @@ bool do_intersect(const PolylineRange& polylines1,
} }
/** /**
* \ingroup PMP_predicates_grp * \ingroup PMP_intersection_grp
*
* returns `true` if there exists a segment of `polyline1` and a segment of `polyline2` which intersect, * returns `true` if there exists a segment of `polyline1` and a segment of `polyline2` which intersect,
* and `false` otherwise. * and `false` otherwise.
* This function depends on the package \ref PkgBoxIntersectionD. * This function depends on the package \ref PkgBoxIntersectionD.
@ -1203,9 +1216,12 @@ bool do_intersect(const Polyline& polyline1,
} }
/** /**
* \ingroup PMP_predicates_grp * \ingroup PMP_intersection_grp
* returns `true` if there exists a face of `tm1` and a face of `tm2` which intersect, and `false` otherwise. *
* If `do_overlap_test_of_bounded_sides` is set to `true`, the overlap of bounded sides are tested as well. In that case, the meshes must be closed. * \brief returns `true` if there exists a face of `tm1` and a face of `tm2` which intersect, and `false` otherwise.
*
* If `do_overlap_test_of_bounded_sides` is set to `true`, the overlap of bounded sides are tested as well.
* In that case, the meshes must be closed.
* This function depends on the package \ref PkgBoxIntersectionD. * This function depends on the package \ref PkgBoxIntersectionD.
* *
* @pre `CGAL::is_triangle_mesh(tm1)` * @pre `CGAL::is_triangle_mesh(tm1)`
@ -1249,6 +1265,7 @@ bool do_intersect(const Polyline& polyline1,
* \cgalParamNEnd * \cgalParamNEnd
* \cgalNamedParamsEnd * \cgalNamedParamsEnd
* *
* \see `intersecting_meshes()`
*/ */
template <class TriangleMesh, template <class TriangleMesh,
class CGAL_NP_TEMPLATE_PARAMETERS_1, class CGAL_NP_TEMPLATE_PARAMETERS_1,
@ -1301,10 +1318,12 @@ bool do_intersect(const TriangleMesh& tm1,
} }
/** /**
* \ingroup PMP_predicates_grp * \ingroup PMP_intersection_grp
*
* returns `true` if there exists a face of `tm` and a segment of a polyline of `polylines` which intersect, * returns `true` if there exists a face of `tm` and a segment of a polyline of `polylines` which intersect,
* and `false` otherwise. * and `false` otherwise.
* This function depends on the package \ref PkgBoxIntersectionD. * This function depends on the package \ref PkgBoxIntersectionD.
*
* @pre `CGAL::is_triangle_mesh(tm)` * @pre `CGAL::is_triangle_mesh(tm)`
* *
* \tparam TriangleMesh a model of `FaceListGraph` * \tparam TriangleMesh a model of `FaceListGraph`
@ -1367,9 +1386,11 @@ bool do_intersect(const TriangleMesh& tm,
} }
/** /**
* \ingroup PMP_predicates_grp * \ingroup PMP_intersection_grp
*
* returns `true` if there exists a face of `tm` and a segment of `polyline` which intersect, and `false` otherwise. * returns `true` if there exists a face of `tm` and a segment of `polyline` which intersect, and `false` otherwise.
* This function depends on the package \ref PkgBoxIntersectionD. * This function depends on the package \ref PkgBoxIntersectionD.
*
* @pre `CGAL::is_triangle_mesh(tm)` * @pre `CGAL::is_triangle_mesh(tm)`
* *
* \tparam TriangleMesh a model of `FaceListGraph` * \tparam TriangleMesh a model of `FaceListGraph`
@ -1551,7 +1572,8 @@ struct Mesh_callback
}//end internal }//end internal
/*! /*!
* \ingroup PMP_predicates_grp * \ingroup PMP_intersection_grp
*
* detects and reports all the pairs of meshes intersecting in a range of triangulated surface meshes. * detects and reports all the pairs of meshes intersecting in a range of triangulated surface meshes.
* A pair of meshes intersecting is put in the output iterator `out` as a `std::pair<std::size_t, std::size_t>`, * A pair of meshes intersecting is put in the output iterator `out` as a `std::pair<std::size_t, std::size_t>`,
* each index refering to the index of the triangle mesh in the input range. * each index refering to the index of the triangle mesh in the input range.
@ -1596,8 +1618,9 @@ struct Mesh_callback
* \cgalParamExtra{All vertex point maps must have the same value type} * \cgalParamExtra{All vertex point maps must have the same value type}
* \cgalParamNEnd * \cgalParamNEnd
* \cgalNamedParamsEnd * \cgalNamedParamsEnd
*
* \see `do_intersect()`
*/ */
template <class TriangleMeshRange, template <class TriangleMeshRange,
class OutputIterator, class OutputIterator,
class NamedParameters, class NamedParameters,
@ -1659,6 +1682,7 @@ OutputIterator intersecting_meshes(const TriangleMeshRange& range,
/** /**
* \ingroup PMP_corefinement_grp * \ingroup PMP_corefinement_grp
*
* computes the intersection of triangles of `tm1` and `tm2`. The output is a * computes the intersection of triangles of `tm1` and `tm2`. The output is a
* set of polylines with all vertices but endpoints being of degree 2. * set of polylines with all vertices but endpoints being of degree 2.
* *
@ -1700,6 +1724,7 @@ OutputIterator intersecting_meshes(const TriangleMeshRange& range,
* \cgalParamNEnd * \cgalParamNEnd
* \cgalNamedParamsEnd * \cgalNamedParamsEnd
* *
* \see `do_intersect()`
*/ */
template <class OutputIterator, template <class OutputIterator,
class TriangleMesh, class TriangleMesh,

30
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/manifoldness.h
View File

@ -34,18 +34,20 @@ namespace CGAL {
namespace Polygon_mesh_processing { namespace Polygon_mesh_processing {
/// \ingroup PMP_repairing_grp /// \ingroup PMP_repairing_grp
/// returns whether a vertex of a polygon mesh is non-manifold. ///
/// \brief returns whether a vertex of a polygon mesh is non-manifold.
///
/// \warning This function has linear runtime with respect to the size of the mesh. The function
/// `non_manifold_vertices()` should be used when gathering all non manifold vertices.
/// ///
/// @tparam PolygonMesh a model of `HalfedgeListGraph` /// @tparam PolygonMesh a model of `HalfedgeListGraph`
/// ///
/// @param v a vertex of `pm` /// @param v a vertex of `pm`
/// @param pm a triangle mesh containing `v` /// @param pm a triangle mesh containing `v`
/// ///
/// \warning This function has linear runtime with respect to the size of the mesh. /// \return `true` if the vertex is non-manifold, `false` otherwise
/// ///
/// \sa `duplicate_non_manifold_vertices()` /// \sa `duplicate_non_manifold_vertices()`
///
/// \return `true` if the vertex is non-manifold, `false` otherwise.
template <typename PolygonMesh> template <typename PolygonMesh>
bool is_non_manifold_vertex(typename boost::graph_traits<PolygonMesh>::vertex_descriptor v, bool is_non_manifold_vertex(typename boost::graph_traits<PolygonMesh>::vertex_descriptor v,
const PolygonMesh& pm) const PolygonMesh& pm)
@ -283,10 +285,13 @@ std::size_t make_umbrella_manifold(typename boost::graph_traits<PolygonMesh>::ha
} // end namespace internal } // end namespace internal
/// \ingroup PMP_repairing_grp /// \ingroup PMP_repairing_grp
/// collects the non-manifold vertices (if any) present in the mesh. A non-manifold vertex `v` is returned ///
/// via one incident halfedge `h` such that `target(h, pm) = v` for all the umbrellas that `v` appears in /// \brief collects the non-manifold vertices (if any) present in the mesh.
/// (an <i>umbrella</i> being the set of faces incident to all the halfedges reachable by walking around `v` ///
/// using `hnext = prev(opposite(h, pm), pm)`, starting from `h`). /// A non-manifold vertex `v` is returned via one incident halfedge `h` such that `target(h, pm) = v`
/// for all the umbrellas that `v` appears in (an <i>umbrella</i> being the set of faces incident
/// to all the halfedges reachable by walking around `v` using `hnext = prev(opposite(h, pm), pm)`,
/// starting from `h`).
/// ///
/// @tparam PolygonMesh a model of `HalfedgeListGraph` /// @tparam PolygonMesh a model of `HalfedgeListGraph`
/// @tparam OutputIterator a model of `OutputIterator` holding objects of type /// @tparam OutputIterator a model of `OutputIterator` holding objects of type
@ -295,10 +300,10 @@ std::size_t make_umbrella_manifold(typename boost::graph_traits<PolygonMesh>::ha
/// @param pm a triangle mesh /// @param pm a triangle mesh
/// @param out the output iterator that collects halfedges incident to `v` /// @param out the output iterator that collects halfedges incident to `v`
/// ///
/// \return the output iterator
///
/// \sa `is_non_manifold_vertex()` /// \sa `is_non_manifold_vertex()`
/// \sa `duplicate_non_manifold_vertices()` /// \sa `duplicate_non_manifold_vertices()`
///
/// \return the output iterator.
template <typename PolygonMesh, typename OutputIterator> template <typename PolygonMesh, typename OutputIterator>
OutputIterator non_manifold_vertices(const PolygonMesh& pm, OutputIterator non_manifold_vertices(const PolygonMesh& pm,
OutputIterator out) OutputIterator out)
@ -390,6 +395,7 @@ OutputIterator non_manifold_vertices(const PolygonMesh& pm,
} }
/// \ingroup PMP_repairing_grp /// \ingroup PMP_repairing_grp
///
/// duplicates all the non-manifold vertices of the input mesh. /// duplicates all the non-manifold vertices of the input mesh.
/// ///
/// @tparam PolygonMesh a model of `HalfedgeListGraph` and `MutableHalfedgeGraph` /// @tparam PolygonMesh a model of `HalfedgeListGraph` and `MutableHalfedgeGraph`
@ -426,7 +432,9 @@ OutputIterator non_manifold_vertices(const PolygonMesh& pm,
/// \cgalParamNEnd /// \cgalParamNEnd
/// \cgalNamedParamsEnd /// \cgalNamedParamsEnd
/// ///
/// \return the number of vertices created. /// \return the number of vertices created
///
/// \see `non_manifold_vertices()`
template <typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters> template <typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters>
std::size_t duplicate_non_manifold_vertices(PolygonMesh& pm, std::size_t duplicate_non_manifold_vertices(PolygonMesh& pm,
const NamedParameters& np = parameters::default_values()) const NamedParameters& np = parameters::default_values())

153
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/measure.h
View File

@ -57,7 +57,8 @@ inline void rearrange_face_ids(boost::container::small_vector<std::size_t, 4>& i
}//namespace internal }//namespace internal
/** /**
* \ingroup measure_grp * \ingroup PMP_measure_grp
*
* computes the length of an edge of a given polygon mesh. * computes the length of an edge of a given polygon mesh.
* The edge is given by one of its halfedges, or the edge itself. * The edge is given by one of its halfedges, or the edge itself.
* *
@ -84,10 +85,9 @@ inline void rearrange_face_ids(boost::container::small_vector<std::size_t, 4>& i
* \cgalParamNEnd * \cgalParamNEnd
* \cgalNamedParamsEnd * \cgalNamedParamsEnd
* *
* @return the length of `h`. The return type `FT` is a number type. It is * @return the length of `h`. The return type `FT` is a number type either deduced
* either deduced from the `geom_traits` \ref bgl_namedparameters "Named Parameters" if provided, * from the `geom_traits` \ref bgl_namedparameters "Named Parameters" if provided,
* or the geometric traits class deduced from the point property map * or the geometric traits class deduced from the point property map of `pmesh`.
* of `pmesh`.
* *
* \warning This function involves a square root computation. * \warning This function involves a square root computation.
* If `FT` does not have a `sqrt()` operation, the square root computation * If `FT` does not have a `sqrt()` operation, the square root computation
@ -136,7 +136,8 @@ edge_length(typename boost::graph_traits<PolygonMesh>::edge_descriptor e,
} }
/** /**
* \ingroup measure_grp * \ingroup PMP_measure_grp
*
* computes the squared length of an edge of a given polygon mesh. * computes the squared length of an edge of a given polygon mesh.
* The edge is given by one of its halfedges, or the edge itself. * The edge is given by one of its halfedges, or the edge itself.
* *
@ -163,10 +164,9 @@ edge_length(typename boost::graph_traits<PolygonMesh>::edge_descriptor e,
* \cgalParamNEnd * \cgalParamNEnd
* \cgalNamedParamsEnd * \cgalNamedParamsEnd
* *
* @return the squared length of `h`. The return type `FT` is a number type. It is * @return the squared length of `h`. The return type `FT` is a number type either deduced
* either deduced from the `geom_traits` \ref bgl_namedparameters "Named Parameters" if provided, * from the `geom_traits` \ref bgl_namedparameters "Named Parameters" if provided,
* or the geometric traits class deduced from the point property map * or the geometric traits class deduced from the point property map of `pmesh`.
* of `pmesh`.
* *
* @sa `edge_length()` * @sa `edge_length()`
* @sa `face_border_length()` * @sa `face_border_length()`
@ -212,9 +212,9 @@ squared_edge_length(typename boost::graph_traits<PolygonMesh>::edge_descriptor e
} }
/** /**
* \ingroup measure_grp * \ingroup PMP_measure_grp
* computes the length of the border polyline *
* that contains a given halfedge. * computes the length of the border polyline that contains a given halfedge.
* *
* @tparam PolygonMesh a model of `HalfedgeGraph` * @tparam PolygonMesh a model of `HalfedgeGraph`
* @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters" * @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
@ -240,10 +240,9 @@ squared_edge_length(typename boost::graph_traits<PolygonMesh>::edge_descriptor e
* \cgalNamedParamsEnd * \cgalNamedParamsEnd
* *
* @return the length of the sequence of border edges of `face(h, pmesh)`. * @return the length of the sequence of border edges of `face(h, pmesh)`.
* The return type `FT` is a number type. It is * The return type `FT` is a number type either deduced from the `geom_traits`
* either deduced from the `geom_traits` \ref bgl_namedparameters "Named Parameters" if provided, * \ref bgl_namedparameters "Named Parameters" if provided, or the geometric traits class deduced
* or the geometric traits class deduced from the point property map * from the point property map of `pmesh`.
* of `pmesh`.
* *
* \warning This function involves a square root computation. * \warning This function involves a square root computation.
* If `Kernel::FT` does not have a `sqrt()` operation, the square root computation * If `Kernel::FT` does not have a `sqrt()` operation, the square root computation
@ -274,9 +273,10 @@ face_border_length(typename boost::graph_traits<PolygonMesh>::halfedge_descripto
} }
/** /**
* \ingroup measure_grp * \ingroup PMP_measure_grp
*
* finds the longest border of a given triangulated surface and returns * finds the longest border of a given triangulated surface and returns
* a halfedge that is part of this border and the length of this border. * a halfedge that is part of this border as well as the length of this border.
* *
* @tparam PolygonMesh a model of `HalfedgeGraph` * @tparam PolygonMesh a model of `HalfedgeGraph`
* @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters" * @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
@ -305,11 +305,11 @@ face_border_length(typename boost::graph_traits<PolygonMesh>::halfedge_descripto
* The return type `halfedge_descriptor` is a halfedge descriptor. It is * The return type `halfedge_descriptor` is a halfedge descriptor. It is
* deduced from the graph traits corresponding to the type `PolygonMesh`. * deduced from the graph traits corresponding to the type `PolygonMesh`.
* - `second`: the length of the longest border * - `second`: the length of the longest border
* The return type `FT` is a number type. It is * The return type `FT` is a number type either deduced from the `geom_traits`
* either deduced from the `geom_traits` \ref bgl_namedparameters "Named Parameters" if provided, * \ref bgl_namedparameters "Named Parameters" if provided,
* or the geometric traits class deduced from the point property map * or the geometric traits class deduced from the point property map of `pmesh`
* of `pmesh`
* *
* @see `face_border_length()`
*/ */
template<typename PolygonMesh, template<typename PolygonMesh,
typename NamedParameters = parameters::Default_named_parameters> typename NamedParameters = parameters::Default_named_parameters>
@ -317,7 +317,7 @@ template<typename PolygonMesh,
std::pair<halfedge_descriptor, FT> std::pair<halfedge_descriptor, FT>
#else #else
std::pair<typename boost::graph_traits<PolygonMesh>::halfedge_descriptor, std::pair<typename boost::graph_traits<PolygonMesh>::halfedge_descriptor,
typename GetGeomTraits<PolygonMesh, NamedParameters>::type::FT> typename GetGeomTraits<PolygonMesh, NamedParameters>::type::FT>
#endif #endif
longest_border(const PolygonMesh& pmesh, longest_border(const PolygonMesh& pmesh,
const NamedParameters& np = parameters::default_values()) const NamedParameters& np = parameters::default_values())
@ -354,9 +354,9 @@ longest_border(const PolygonMesh& pmesh,
} }
/** /**
* \ingroup measure_grp * \ingroup PMP_measure_grp
* computes the area of a face of a given *
* triangulated surface mesh. * computes the area of a face of a given triangulated surface mesh.
* *
* @tparam TriangleMesh a model of `FaceGraph` * @tparam TriangleMesh a model of `FaceGraph`
* @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters" * @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
@ -384,10 +384,9 @@ longest_border(const PolygonMesh& pmesh,
* @pre `f != boost::graph_traits<TriangleMesh>::%null_face()` * @pre `f != boost::graph_traits<TriangleMesh>::%null_face()`
* *
* @return the area of `f`. * @return the area of `f`.
* The return type `FT` is a number type. It is * The return type `FT` is a number type either deduced from the `geom_traits`
* either deduced from the `geom_traits` \ref bgl_namedparameters "Named Parameters" if provided, * \ref bgl_namedparameters "Named Parameters" if provided, or the geometric traits class deduced
* or the geometric traits class deduced from the point property map * from the point property map of `tmesh`.
* of `tmesh`.
* *
* \warning This function involves a square root computation. * \warning This function involves a square root computation.
* If `Kernel::FT` does not have a `sqrt()` operation, the square root computation * If `Kernel::FT` does not have a `sqrt()` operation, the square root computation
@ -431,9 +430,9 @@ face_area(typename boost::graph_traits<TriangleMesh>::face_descriptor f,
/** /**
* \ingroup measure_grp * \ingroup PMP_measure_grp
* computes the squared area of a face of a given *
* triangulated surface mesh. * computes the squared area of a face of a given triangulated surface mesh.
* *
* @tparam TriangleMesh a model of `FaceGraph` * @tparam TriangleMesh a model of `FaceGraph`
* @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters" * @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
@ -461,10 +460,9 @@ face_area(typename boost::graph_traits<TriangleMesh>::face_descriptor f,
* @pre `f != boost::graph_traits<TriangleMesh>::%null_face()` * @pre `f != boost::graph_traits<TriangleMesh>::%null_face()`
* *
* @return the squared area of `f`. * @return the squared area of `f`.
* The return type `FT` is a number type. It is * The return type `FT` is a number type either deduced from the `geom_traits`
* either deduced from the `geom_traits` \ref bgl_namedparameters "Named Parameters" if provided, * \ref bgl_namedparameters "Named Parameters" if provided,
* or the geometric traits class deduced from the point property map * or the geometric traits class deduced from the point property map of `tmesh`.
* of `tmesh`.
* *
* @sa `face_area()` * @sa `face_area()`
*/ */
@ -502,9 +500,9 @@ squared_face_area(typename boost::graph_traits<TriangleMesh>::face_descriptor f,
} }
/** /**
* \ingroup measure_grp * \ingroup PMP_measure_grp
* computes the area of a range of faces of a given *
* triangulated surface mesh. * computes the area of a range of faces of a given triangulated surface mesh.
* *
* @tparam FaceRange range of `boost::graph_traits<PolygonMesh>::%face_descriptor`, * @tparam FaceRange range of `boost::graph_traits<PolygonMesh>::%face_descriptor`,
model of `Range`. model of `Range`.
@ -533,10 +531,9 @@ squared_face_area(typename boost::graph_traits<TriangleMesh>::face_descriptor f,
* \cgalNamedParamsEnd * \cgalNamedParamsEnd
* *
* @return sum of face areas of `faces`. * @return sum of face areas of `faces`.
* The return type `FT` is a number type. It is * The return type `FT` is a number type either deduced from the `geom_traits`
* either deduced from the `geom_traits` \ref bgl_namedparameters "Named Parameters" if provided, * \ref bgl_namedparameters "Named Parameters" if provided,
* or the geometric traits class deduced from the point property map * or the geometric traits class deduced from the point property map of `tmesh`.
* of `tmesh`.
* *
* \warning This function involves a square root computation. * \warning This function involves a square root computation.
* If `Kernel::FT` does not have a `sqrt()` operation, the square root computation * If `Kernel::FT` does not have a `sqrt()` operation, the square root computation
@ -569,7 +566,7 @@ area(FaceRange face_range,
} }
/** /**
* \ingroup measure_grp * \ingroup PMP_measure_grp
* computes the surface area of a triangulated surface mesh. * computes the surface area of a triangulated surface mesh.
* *
* @tparam TriangleMesh a model of `FaceGraph` * @tparam TriangleMesh a model of `FaceGraph`
@ -595,10 +592,9 @@ area(FaceRange face_range,
* \cgalNamedParamsEnd * \cgalNamedParamsEnd
* *
* @return the surface area of `tmesh`. * @return the surface area of `tmesh`.
* The return type `FT` is a number type. It is * The return type `FT` is a number type either deduced from the `geom_traits`
* either deduced from the `geom_traits` \ref bgl_namedparameters "Named Parameters" if provided, * \ref bgl_namedparameters "Named Parameters" if provided,
* or the geometric traits class deduced from the point property map * or the geometric traits class deduced from the point property map of `tmesh`.
* of `tmesh`.
* *
* \warning This function involves a square root computation. * \warning This function involves a square root computation.
* If `Kernel::FT` does not have a `sqrt()` operation, the square root computation * If `Kernel::FT` does not have a `sqrt()` operation, the square root computation
@ -613,15 +609,16 @@ FT
#else #else
typename GetGeomTraits<TriangleMesh, CGAL_NP_CLASS>::type::FT typename GetGeomTraits<TriangleMesh, CGAL_NP_CLASS>::type::FT
#endif #endif
area(const TriangleMesh& tmesh, const CGAL_NP_CLASS& np = parameters::default_values()) area(const TriangleMesh& tmesh,
const CGAL_NP_CLASS& np = parameters::default_values())
{ {
return area(faces(tmesh), tmesh, np); return area(faces(tmesh), tmesh, np);
} }
/** /**
* \ingroup measure_grp * \ingroup PMP_measure_grp
* computes the volume of the domain bounded by *
* a closed triangulated surface mesh. * computes the volume of the domain bounded by a closed triangulated surface mesh.
* *
* @tparam TriangleMesh a model of `HalfedgeGraph` * @tparam TriangleMesh a model of `HalfedgeGraph`
* @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters" * @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
@ -648,10 +645,9 @@ area(const TriangleMesh& tmesh, const CGAL_NP_CLASS& np = parameters::default_va
* \cgalNamedParamsEnd * \cgalNamedParamsEnd
* *
* @return the volume bounded by `tmesh`. * @return the volume bounded by `tmesh`.
* The return type `FT` is a number type. It is * The return type `FT` is a number type either deduced from the `geom_traits`
* either deduced from the `geom_traits` \ref bgl_namedparameters "Named Parameters" if provided, * \ref bgl_namedparameters "Named Parameters" if provided,
* or the geometric traits class deduced from the point property map * or the geometric traits class deduced from the point property map of `tmesh`.
* of `tmesh`.
*/ */
template<typename TriangleMesh, template<typename TriangleMesh,
typename CGAL_NP_TEMPLATE_PARAMETERS> typename CGAL_NP_TEMPLATE_PARAMETERS>
@ -693,7 +689,8 @@ volume(const TriangleMesh& tmesh,
} }
/** /**
* \ingroup measure_grp * \ingroup PMP_measure_grp
*
* computes the aspect ratio of a face of a given triangulated surface mesh. * computes the aspect ratio of a face of a given triangulated surface mesh.
* *
* @tparam TriangleMesh a model of `HalfedgeGraph` * @tparam TriangleMesh a model of `HalfedgeGraph`
@ -721,10 +718,13 @@ volume(const TriangleMesh& tmesh,
* *
* @pre `f != boost::graph_traits<TriangleMesh>::%null_face()` * @pre `f != boost::graph_traits<TriangleMesh>::%null_face()`
* *
* @return the aspect ratio of `f`. The return type `FT` is a number type. It is * @return the aspect ratio of `f`. The return type `FT` is a number type
* either deduced from the `geom_traits` \ref bgl_namedparameters "Named Parameters" if provided, * either deduced from the `geom_traits` \ref bgl_namedparameters "Named Parameters" if provided,
* or the geometric traits class deduced from the point property map of `tmesh`. * or the geometric traits class deduced from the point property map of `tmesh`.
* *
* \warning This function involves a square root computation.
* If `Kernel::FT` does not have a `sqrt()` operation, the square root computation
* will be done approximately.
*/ */
template<typename TriangleMesh, template<typename TriangleMesh,
typename CGAL_NP_TEMPLATE_PARAMETERS> typename CGAL_NP_TEMPLATE_PARAMETERS>
@ -803,9 +803,9 @@ face_aspect_ratio(typename boost::graph_traits<TriangleMesh>::face_descriptor f,
} }
/** /**
* \ingroup measure_grp * \ingroup PMP_measure_grp
* computes the centroid of a volume bounded by *
* a closed triangulated surface mesh. * computes the centroid of a volume bounded by a closed triangulated surface mesh.
* *
* @tparam TriangleMesh a model of `FaceListGraph` * @tparam TriangleMesh a model of `FaceListGraph`
* @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters" * @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
@ -839,7 +839,8 @@ Point_3
#else #else
typename GetGeomTraits<TriangleMesh, CGAL_NP_CLASS>::type::Point_3 typename GetGeomTraits<TriangleMesh, CGAL_NP_CLASS>::type::Point_3
#endif #endif
centroid(const TriangleMesh& tmesh, const CGAL_NP_CLASS& np = parameters::default_values()) centroid(const TriangleMesh& tmesh,
const CGAL_NP_CLASS& np = parameters::default_values())
{ {
// See: http://www2.imperial.ac.uk/~rn/centroid.pdf // See: http://www2.imperial.ac.uk/~rn/centroid.pdf
@ -903,7 +904,8 @@ centroid(const TriangleMesh& tmesh, const CGAL_NP_CLASS& np = parameters::defaul
} }
/** /**
* \ingroup measure_grp * \ingroup PMP_measure_grp
*
* identifies faces only present in `m1` and `m2` as well as the faces present * identifies faces only present in `m1` and `m2` as well as the faces present
* in both polygon meshes. Two faces are matching if they have the same * in both polygon meshes. Two faces are matching if they have the same
* orientation and the same points. * orientation and the same points.
@ -911,19 +913,19 @@ centroid(const TriangleMesh& tmesh, const CGAL_NP_CLASS& np = parameters::defaul
* @tparam PolygonMesh1 a model of `HalfedgeListGraph` and `FaceListGraph` * @tparam PolygonMesh1 a model of `HalfedgeListGraph` and `FaceListGraph`
* @tparam PolygonMesh2 a model of `HalfedgeListGraph` and `FaceListGraph` * @tparam PolygonMesh2 a model of `HalfedgeListGraph` and `FaceListGraph`
* @tparam FaceOutputIterator1 model of `OutputIterator` * @tparam FaceOutputIterator1 model of `OutputIterator`
holding `boost::graph_traits<PolygonMesh1>::%face_descriptor`. * holding `boost::graph_traits<PolygonMesh1>::%face_descriptor`.
* @tparam FaceOutputIterator2 model of `OutputIterator` * @tparam FaceOutputIterator2 model of `OutputIterator`
holding `boost::graph_traits<PolygonMesh2>::%face_descriptor`. * holding `boost::graph_traits<PolygonMesh2>::%face_descriptor`.
* @tparam FacePairOutputIterator model of `OutputIterator` * @tparam FacePairOutputIterator model of `OutputIterator`
holding `std::pair<boost::graph_traits<PolygonMesh1>::%face_descriptor, * holding `std::pair<boost::graph_traits<PolygonMesh1>::%face_descriptor,
boost::graph_traits<PolygonMesh2>::%face_descriptor`. * boost::graph_traits<PolygonMesh2>::%face_descriptor`.
* *
* @tparam NamedParameters1 a sequence of \ref bgl_namedparameters "Named Parameters" * @tparam NamedParameters1 a sequence of \ref bgl_namedparameters "Named Parameters"
* @tparam NamedParameters2 a sequence of \ref bgl_namedparameters "Named Parameters" * @tparam NamedParameters2 a sequence of \ref bgl_namedparameters "Named Parameters"
* *
* @param m1 the first `PolygonMesh` * @param m1 the first polygon mesh
* @param m2 the second `PolygonMesh` * @param m2 the second polygon mesh
* @param common output iterator collecting the faces that are common to both meshes. * @param common output iterator collecting the faces that are common to both meshes
* @param m1_only output iterator collecting the faces that are only in `m1` * @param m1_only output iterator collecting the faces that are only in `m1`
* @param m2_only output iterator collecting the faces that are only in `m2` * @param m2_only output iterator collecting the faces that are only in `m2`
* @param np1 an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below * @param np1 an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
@ -958,8 +960,11 @@ template< typename PolygonMesh1,
typename FaceOutputIterator2, typename FaceOutputIterator2,
typename NamedParameters1 = parameters::Default_named_parameters, typename NamedParameters1 = parameters::Default_named_parameters,
typename NamedParameters2 = parameters::Default_named_parameters > typename NamedParameters2 = parameters::Default_named_parameters >
void match_faces(const PolygonMesh1& m1, const PolygonMesh2& m2, void match_faces(const PolygonMesh1& m1,
FacePairOutputIterator common, FaceOutputIterator1 m1_only, FaceOutputIterator2 m2_only, const PolygonMesh2& m2,
FacePairOutputIterator common,
FaceOutputIterator1 m1_only,
FaceOutputIterator2 m2_only,
const NamedParameters1& np1 = parameters::default_values(), const NamedParameters1& np1 = parameters::default_values(),
const NamedParameters2& np2 = parameters::default_values()) const NamedParameters2& np2 = parameters::default_values())
{ {

15
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/merge_border_vertices.h
View File

@ -62,7 +62,7 @@ struct Less_on_point_of_target
const VertexPointMap& vpm; const VertexPointMap& vpm;
}; };
// Given a container of vectors of halfedges whose target are geometrically indentical, // Given a container of vectors of halfedges whose target are geometrically identical,
// check that the intervals described by these pairs are either disjoint or nested. // check that the intervals described by these pairs are either disjoint or nested.
// This is done to ensure valid combinatorics when we merge the vertices. // This is done to ensure valid combinatorics when we merge the vertices.
// If incompatible (overlapping) intervals are found, the pair representating the longest // If incompatible (overlapping) intervals are found, the pair representating the longest
@ -205,6 +205,7 @@ void detect_identical_mergeable_vertices(
} }
// \ingroup PMP_repairing_grp // \ingroup PMP_repairing_grp
//
// merges target vertices of a list of halfedges. // merges target vertices of a list of halfedges.
// Halfedges must be sorted in the list. // Halfedges must be sorted in the list.
// //
@ -259,6 +260,7 @@ void merge_vertices_in_range(const HalfedgeRange& sorted_hedges,
} // end of internal } // end of internal
/// \ingroup PMP_repairing_grp /// \ingroup PMP_repairing_grp
///
/// merges identical vertices around a cycle of boundary edges. /// merges identical vertices around a cycle of boundary edges.
/// ///
/// @tparam PolygonMesh a model of `FaceListGraph` and `MutableFaceGraph`. /// @tparam PolygonMesh a model of `FaceListGraph` and `MutableFaceGraph`.
@ -277,9 +279,10 @@ void merge_vertices_in_range(const HalfedgeRange& sorted_hedges,
/// \cgalParamNEnd /// \cgalParamNEnd
/// \cgalNamedParamsEnd /// \cgalNamedParamsEnd
/// ///
template <class PolygonMesh, class NamedParameters = parameters::Default_named_parameters> /// \see `merge_duplicated_vertices_in_boundary_cycles()`
void merge_duplicated_vertices_in_boundary_cycle( template <class PolygonMesh,
typename boost::graph_traits<PolygonMesh>::halfedge_descriptor h, class NamedParameters = parameters::Default_named_parameters>
void merge_duplicated_vertices_in_boundary_cycle(typename boost::graph_traits<PolygonMesh>::halfedge_descriptor h,
PolygonMesh& pm, PolygonMesh& pm,
const NamedParameters& np = parameters::default_values()) const NamedParameters& np = parameters::default_values())
{ {
@ -315,6 +318,7 @@ void merge_duplicated_vertices_in_boundary_cycle(
} }
/// \ingroup PMP_repairing_grp /// \ingroup PMP_repairing_grp
///
/// extracts boundary cycles and merges the duplicated vertices of each cycle. /// extracts boundary cycles and merges the duplicated vertices of each cycle.
/// ///
/// @tparam PolygonMesh a model of `FaceListGraph` and `MutableFaceGraph`. /// @tparam PolygonMesh a model of `FaceListGraph` and `MutableFaceGraph`.
@ -333,7 +337,8 @@ void merge_duplicated_vertices_in_boundary_cycle(
/// \cgalNamedParamsEnd /// \cgalNamedParamsEnd
/// ///
/// \sa `merge_duplicated_vertices_in_boundary_cycle()` /// \sa `merge_duplicated_vertices_in_boundary_cycle()`
template <class PolygonMesh, class NamedParameters = parameters::Default_named_parameters> template <class PolygonMesh,
class NamedParameters = parameters::Default_named_parameters>
void merge_duplicated_vertices_in_boundary_cycles( PolygonMesh& pm, void merge_duplicated_vertices_in_boundary_cycles( PolygonMesh& pm,
const NamedParameters& np = parameters::default_values()) const NamedParameters& np = parameters::default_values())
{ {

8
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orient_polygon_soup.h
View File

@ -480,7 +480,9 @@ struct Polygon_soup_orienter
/** /**
* \ingroup PMP_orientation_grp * \ingroup PMP_orientation_grp
* tries to consistently orient a soup of polygons in 3D space. *
* \brief tries to consistently orient a soup of polygons in 3D space.
*
* When it is not possible to produce a combinatorial manifold surface, * When it is not possible to produce a combinatorial manifold surface,
* some points are duplicated. * some points are duplicated.
* Because a polygon soup does not have any connectivity (each point * Because a polygon soup does not have any connectivity (each point
@ -521,8 +523,10 @@ struct Polygon_soup_orienter
* @return `true` if the orientation operation succeded. * @return `true` if the orientation operation succeded.
* @return `false` if some points were duplicated, thus producing a self-intersecting polyhedron. * @return `false` if some points were duplicated, thus producing a self-intersecting polyhedron.
* *
* @sa `orient_triangle_soup_with_reference_triangle_mesh()`
*/ */
template <class PointRange, class PolygonRange, class NamedParameters = parameters::Default_named_parameters> template <class PointRange, class PolygonRange,
class NamedParameters = parameters::Default_named_parameters>
bool orient_polygon_soup(PointRange& points, bool orient_polygon_soup(PointRange& points,
PolygonRange& polygons, PolygonRange& polygons,
const NamedParameters& np = parameters::default_values()) const NamedParameters& np = parameters::default_values())

13
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orient_polygon_soup_extension.h
View File

@ -37,6 +37,7 @@ namespace Polygon_mesh_processing {
/*! /*!
* \ingroup PMP_orientation_grp * \ingroup PMP_orientation_grp
*
* duplicates each point \a p at which the intersection * duplicates each point \a p at which the intersection
* of an infinitesimally small ball centered at \a p * of an infinitesimally small ball centered at \a p
* with the polygons incident to it is not a topological disk. * with the polygons incident to it is not a topological disk.
@ -51,9 +52,12 @@ namespace Polygon_mesh_processing {
* non-manifoldness or non-orientability issues. * non-manifoldness or non-orientability issues.
* @param polygons each element in the vector describes a polygon using the indices of the points in `points`. * @param polygons each element in the vector describes a polygon using the indices of the points in `points`.
* If needed the order of the indices of a polygon might be reversed. * If needed the order of the indices of a polygon might be reversed.
*
* @return `false` if some points were duplicated, thus producing a self-intersecting surface mesh. * @return `false` if some points were duplicated, thus producing a self-intersecting surface mesh.
* @return `true` otherwise. * @return `true` otherwise.
*
* @sa `orient_polygon_soup()` * @sa `orient_polygon_soup()`
* @sa `duplicate_non_manifold_vertices()`
*/ */
template <class PointRange, class PolygonRange> template <class PointRange, class PolygonRange>
bool bool
@ -115,10 +119,13 @@ duplicate_non_manifold_edges_in_polygon_soup(PointRange& points,
* \cgalNamedParamsEnd * \cgalNamedParamsEnd
* *
* \attention The types of points in `PointRange`, `geom_traits` and `vertex_point_map` must be the same. * \attention The types of points in `PointRange`, `geom_traits` and `vertex_point_map` must be the same.
*
* \sa `orient_polygon_soup()`
*/ */
template <class Concurrency_tag = Sequential_tag,
template <class Concurrency_tag = Sequential_tag, class PointRange, class TriangleRange, class PointRange, class TriangleRange,
class TriangleMesh, class NamedParameters = parameters::Default_named_parameters> class TriangleMesh,
class NamedParameters = parameters::Default_named_parameters>
void void
orient_triangle_soup_with_reference_triangle_mesh( orient_triangle_soup_with_reference_triangle_mesh(
const TriangleMesh& tm_ref, const TriangleMesh& tm_ref,

39
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h
View File

@ -141,11 +141,14 @@ namespace internal{
/** /**
* \ingroup PMP_orientation_grp * \ingroup PMP_orientation_grp
* tests whether a closed triangle mesh has a positive orientation. *
* \brief tests whether a closed triangle mesh has a positive orientation.
*
* A closed triangle mesh is considered to have a positive orientation if the normal vectors * A closed triangle mesh is considered to have a positive orientation if the normal vectors
* to all its faces point outside the domain bounded by the triangle mesh. * to all its faces point outside the domain bounded by the triangle mesh.
* The normal vector to each face is chosen pointing on the side of the face * The normal vector to each face is chosen pointing on the side of the face
* where its sequence of vertices is seen counterclockwise. * where its sequence of vertices is seen counterclockwise.
*
* @pre `CGAL::is_closed(tm)` * @pre `CGAL::is_closed(tm)`
* @pre `CGAL::is_triangle_mesh(tm)` * @pre `CGAL::is_triangle_mesh(tm)`
* @pre If `tm` contains several connected components, they are oriented consistently. * @pre If `tm` contains several connected components, they are oriented consistently.
@ -181,7 +184,8 @@ namespace internal{
* *
* \sa `CGAL::Polygon_mesh_processing::reverse_face_orientations()` * \sa `CGAL::Polygon_mesh_processing::reverse_face_orientations()`
*/ */
template<typename TriangleMesh, typename NamedParameters = parameters::Default_named_parameters> template<typename TriangleMesh,
typename NamedParameters = parameters::Default_named_parameters>
bool is_outward_oriented(const TriangleMesh& tm, bool is_outward_oriented(const TriangleMesh& tm,
const NamedParameters& np = parameters::default_values()) const NamedParameters& np = parameters::default_values())
{ {
@ -259,9 +263,12 @@ void reverse_orientation(typename boost::graph_traits<PolygonMesh>::halfedge_des
/** /**
* \ingroup PMP_orientation_grp * \ingroup PMP_orientation_grp
*
* reverses for each face the order of the vertices along the face boundary. * reverses for each face the order of the vertices along the face boundary.
* *
* @tparam PolygonMesh a model of `FaceListGraph` and `MutableFaceGraph` * @tparam PolygonMesh a model of `FaceListGraph` and `MutableFaceGraph`
*
* @sa `is_outward_oriented()`
*/ */
template<typename PolygonMesh> template<typename PolygonMesh>
void reverse_face_orientations(PolygonMesh& pmesh) void reverse_face_orientations(PolygonMesh& pmesh)
@ -317,13 +324,16 @@ void reverse_face_orientations_of_mesh_with_polylines(PolygonMesh& pmesh)
/** /**
* \ingroup PMP_orientation_grp * \ingroup PMP_orientation_grp
*
* reverses for each face in `face_range` the order of the vertices along the face boundary. * reverses for each face in `face_range` the order of the vertices along the face boundary.
* The function does not perform any control and if the orientation change of the faces * The function does not perform any control and if the change of orientation of the faces
* makes the polygon mesh invalid, the behavior is undefined. * makes the polygon mesh invalid, the behavior is undefined.
* *
* @tparam PolygonMesh a model of `FaceListGraph` and `MutableFaceGraph` * @tparam PolygonMesh a model of `FaceListGraph` and `MutableFaceGraph`
* @tparam FaceRange range of face descriptors, model of `Range`. * @tparam FaceRange range of face descriptors, model of `Range`.
* Its iterator type is `InputIterator`. * Its iterator type is `InputIterator`.
*
* @sa `is_outward_oriented()`
*/ */
template<typename PolygonMesh, typename FaceRange> template<typename PolygonMesh, typename FaceRange>
void reverse_face_orientations(const FaceRange& face_range, PolygonMesh& pmesh) void reverse_face_orientations(const FaceRange& face_range, PolygonMesh& pmesh)
@ -354,10 +364,10 @@ void reverse_face_orientations(const FaceRange& face_range, PolygonMesh& pmesh)
/** /**
* \ingroup PMP_orientation_grp * \ingroup PMP_orientation_grp
* makes each connected component of a closed triangulated surface mesh
* inward or outward oriented.
* *
* @tparam TriangleMesh a model of `FaceListGraph` and `MutableFaceGraph` . * makes each connected component of a closed triangulated surface mesh inward or outward oriented.
*
* @tparam TriangleMesh a model of `FaceListGraph` and `MutableFaceGraph`
* @tparam NamedParameters a sequence of \ref bgl_namedparameters * @tparam NamedParameters a sequence of \ref bgl_namedparameters
* *
* @param tm a closed triangulated surface mesh * @param tm a closed triangulated surface mesh
@ -394,7 +404,8 @@ void reverse_face_orientations(const FaceRange& face_range, PolygonMesh& pmesh)
* \cgalParamNEnd * \cgalParamNEnd
* \cgalNamedParamsEnd * \cgalNamedParamsEnd
*/ */
template<class TriangleMesh, class NamedParameters = parameters::Default_named_parameters> template<class TriangleMesh,
class NamedParameters = parameters::Default_named_parameters>
void orient(TriangleMesh& tm, void orient(TriangleMesh& tm,
const NamedParameters& np = parameters::default_values()) const NamedParameters& np = parameters::default_values())
{ {
@ -635,6 +646,7 @@ void set_cc_intersecting_pairs(
/*! /*!
* \ingroup PMP_orientation_grp * \ingroup PMP_orientation_grp
*
* assigns to each face of `tm` an id corresponding to the volume connected component * assigns to each face of `tm` an id corresponding to the volume connected component
* it contributes to. * it contributes to.
* *
@ -1215,7 +1227,7 @@ volume_connected_components(const TriangleMesh& tm,
* indicates if `tm` bounds a volume. * indicates if `tm` bounds a volume.
* See \ref coref_def_subsec for details. * See \ref coref_def_subsec for details.
* *
* @tparam TriangleMesh a model of `MutableFaceGraph`, `HalfedgeListGraph` and `FaceListGraph`. * @tparam TriangleMesh a model of `HalfedgeListGraph`, `FaceListGraph`, and `MutableFaceGraph`.
* @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters" * @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
* *
* @param tm a closed triangulated surface mesh * @param tm a closed triangulated surface mesh
@ -1270,12 +1282,13 @@ bool does_bound_a_volume(const TriangleMesh& tm, const NamedParameters& np = par
return res!=0; return res!=0;
} }
/** \ingroup PMP_orientation_grp /*!
* \ingroup PMP_orientation_grp
* *
* orients the connected components of `tm` to make it bound a volume. * orients the connected components of `tm` to make it bound a volume.
* See \ref coref_def_subsec for a precise definition. * See \ref coref_def_subsec for a precise definition.
* *
* @tparam TriangleMesh a model of `MutableFaceGraph`, `HalfedgeListGraph` and `FaceListGraph`. * @tparam TriangleMesh a model of `HalfedgeListGraph`, `FaceListGraph`, and `MutableFaceGraph`.
* @tparam NamedParameters a sequence of \ref bgl_namedparameters * @tparam NamedParameters a sequence of \ref bgl_namedparameters
* *
* @param tm a closed triangulated surface mesh * @param tm a closed triangulated surface mesh
@ -1385,11 +1398,12 @@ void orient_to_bound_a_volume(TriangleMesh& tm,
/*! /*!
* \ingroup PMP_orientation_grp * \ingroup PMP_orientation_grp
*
* reverses the connected components of `tm` having compatible boundary cycles * reverses the connected components of `tm` having compatible boundary cycles
* that could be merged if their orientation were made compatible, and stitches them. * that could be merged if their orientation were made compatible, and stitches them.
* Connected components are examined by increasing number of faces. * Connected components are examined by increasing number of faces.
* *
* @tparam PolygonMesh a model of `MutableFaceGraph`, `HalfedgeListGraph` and `FaceListGraph`. * @tparam PolygonMesh a model of `HalfedgeListGraph`, `FaceListGraph`, and `MutableFaceGraph`.
* @tparam NamedParameters a sequence of \ref bgl_namedparameters * @tparam NamedParameters a sequence of \ref bgl_namedparameters
* *
* @param pm a surface mesh * @param pm a surface mesh
@ -1422,7 +1436,8 @@ void orient_to_bound_a_volume(TriangleMesh& tm,
* \cgalParamNEnd * \cgalParamNEnd
* \cgalNamedParamsEnd * \cgalNamedParamsEnd
*/ */
template <class PolygonMesh, class NamedParameters = parameters::Default_named_parameters> template <class PolygonMesh,
class NamedParameters = parameters::Default_named_parameters>
void merge_reversible_connected_components(PolygonMesh& pm, void merge_reversible_connected_components(PolygonMesh& pm,
const NamedParameters& np = parameters::default_values()) const NamedParameters& np = parameters::default_values())
{ {

6
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/polygon_soup_to_polygon_mesh.h
View File

@ -145,9 +145,10 @@ private:
/** /**
* \ingroup PMP_repairing_grp * \ingroup PMP_repairing_grp
* *
* returns `true` if the soup of polygons defines a valid polygon * \brief returns `true` if the soup of polygons defines a valid polygon
* mesh that can be handled by * mesh that can be handled by
* `CGAL::Polygon_mesh_processing::polygon_soup_to_polygon_mesh()`. * `CGAL::Polygon_mesh_processing::polygon_soup_to_polygon_mesh()`.
*
* It checks that each edge has at most two incident faces and such an edge * It checks that each edge has at most two incident faces and such an edge
* is visited in opposite direction along the two face boundaries, * is visited in opposite direction along the two face boundaries,
* no polygon has twice the same vertex, * no polygon has twice the same vertex,
@ -164,7 +165,7 @@ private:
* @param polygons each element in the range describes a polygon * @param polygons each element in the range describes a polygon
* using the indices of the vertices. * using the indices of the vertices.
* *
* @sa `orient_polygon_soup()` * @sa `CGAL::Polygon_mesh_processing::orient_polygon_soup()`
*/ */
template<typename PolygonRange> template<typename PolygonRange>
bool is_polygon_soup_a_polygon_mesh(const PolygonRange& polygons) bool is_polygon_soup_a_polygon_mesh(const PolygonRange& polygons)
@ -221,6 +222,7 @@ bool is_polygon_soup_a_polygon_mesh(const PolygonRange& polygons)
/** /**
* \ingroup PMP_repairing_grp * \ingroup PMP_repairing_grp
*
* builds a polygon mesh from a soup of polygons. * builds a polygon mesh from a soup of polygons.
* *
* @pre the input polygon soup describes a consistently oriented * @pre the input polygon soup describes a consistently oriented

63
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/random_perturbation.h
View File

@ -97,21 +97,21 @@ namespace internal {
/*! /*!
* \ingroup PMP_meshing_grp * \ingroup PMP_meshing_grp
* @brief randomly perturbs the locations of vertices of a triangulated surface mesh. *
* @brief randomly perturbs the locations of non-border vertices of a triangulated surface mesh.
*
* By default, the vertices are re-projected onto the input surface after perturbation. * By default, the vertices are re-projected onto the input surface after perturbation.
* Note that no geometric checks are done after the perturbation * Note that no geometric checks are performed after the perturbation (self-intersections might be introduced).
* (face orientation might become incorrect and self-intersections might be introduced).
* *
* @tparam VertexRange model of `Range`, holding * @tparam VertexRange model of `Range`, holding
* vertices of type `boost::graph_traits<TriangleMesh>::%vertex_descriptor`. * vertices of type `boost::graph_traits<TriangleMesh>::%vertex_descriptor`.
* Its iterator type is `ForwardIterator`. * Its iterator type is `ForwardIterator`.
* @tparam TriangleMesh model of `MutableFaceGraph`. * @tparam TriangleMesh model of `VertexListGraph`.
* @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters" * @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
* *
* @param vertices the range of vertices to be perturbed * @param vertices the range of vertices to be perturbed
* @param tmesh the triangulated surface mesh * @param tmesh the triangulated surface mesh
* @param perturbation_max_size the maximal length of moves that can be applied to * @param perturbation_max_size the maximal length of moves that can be applied to vertices of `tmesh`.
* vertices of `tmesh`.
* @param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below * @param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
* *
* \cgalNamedParamsBegin * \cgalNamedParamsBegin
@ -210,7 +210,55 @@ void random_perturbation(VertexRange vertices
/*! /*!
* \ingroup PMP_meshing_grp * \ingroup PMP_meshing_grp
* @brief same as above, but all non-border vertices of `tmesh` are perturbed. *
* @brief randomly perturbs the locations of all non-border 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 performed after the perturbation (self-intersections might be introduced).
*
* @tparam TriangleMesh model of `VertexListGraph`.
* @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
*
* @param tmesh the triangulated surface mesh
* @param perturbation_max_size the maximal length of moves that can be applied to vertices of `tmesh`.
* @param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tmesh`}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tmesh)`}
* \cgalParamNEnd
*
* \cgalParamNBegin{geom_traits}
* \cgalParamDescription{an instance of a geometric traits class}
* \cgalParamType{a class model of `Kernel`}
* \cgalParamDefault{a \cgal Kernel deduced from the point type, using `CGAL::Kernel_traits`}
* \cgalParamExtra{The geometric traits class must be compatible with the vertex point type.}
* \cgalParamNEnd
*
* \cgalParamNBegin{vertex_is_constrained_map}
* \cgalParamDescription{a property map containing the constrained-or-not status of each vertex of `tmesh`}
* \cgalParamType{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.}
* \cgalParamDefault{a default property map where no vertex is constrained}
* \cgalParamExtra{A constrained vertex cannot be modified at all during perturbation}
* \cgalParamNEnd
*
* \cgalParamNBegin{do_project}
* \cgalParamDescription{indicates whether vertices are reprojected on the input surface
* after their coordinates random perturbation}
* \cgalParamType{Boolean}
* \cgalParamDefault{`true`}
* \cgalParamNEnd
*
* \cgalParamNBegin{random_seed}
* \cgalParamDescription{a value to seed the random number generator, and make the perturbation deterministic}
* \cgalParamType{unsigned int}
* \cgalParamDefault{`unsigned int(-1)`}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*/ */
template<typename TriangleMesh, typename NamedParameters = parameters::Default_named_parameters> template<typename TriangleMesh, typename NamedParameters = parameters::Default_named_parameters>
void random_perturbation(TriangleMesh& tmesh void random_perturbation(TriangleMesh& tmesh
@ -219,6 +267,7 @@ void random_perturbation(TriangleMesh& tmesh
{ {
random_perturbation(vertices(tmesh), tmesh, perturbation_max_size, np); random_perturbation(vertices(tmesh), tmesh, perturbation_max_size, np);
} }
} //end namespace Polygon_mesh_processing } //end namespace Polygon_mesh_processing
} //end namespace CGAL } //end namespace CGAL

3
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/refine.h
View File

@ -27,6 +27,7 @@ namespace Polygon_mesh_processing {
/*! /*!
\ingroup PMP_meshing_grp \ingroup PMP_meshing_grp
@brief refines a region of a triangle mesh. @brief refines a region of a triangle mesh.
@tparam TriangleMesh model of `MutableFaceGraph` @tparam TriangleMesh model of `MutableFaceGraph`
@ -83,7 +84,7 @@ namespace Polygon_mesh_processing {
using parameters::choose_parameter; using parameters::choose_parameter;
using parameters::get_parameter; using parameters::get_parameter;
CGAL_precondition(is_triangle_mesh(tmesh) ); CGAL_precondition(is_triangle_mesh(tmesh));
typedef typename GetVertexPointMap<TriangleMesh,NamedParameters>::type VPmap; typedef typename GetVertexPointMap<TriangleMesh,NamedParameters>::type VPmap;
VPmap vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), VPmap vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),

3
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/remesh.h
View File

@ -32,6 +32,7 @@ namespace Polygon_mesh_processing {
/*! /*!
* \ingroup PMP_meshing_grp * \ingroup PMP_meshing_grp
*
* @brief remeshes a triangulated region of a polygon mesh. * @brief remeshes a triangulated region of a polygon mesh.
* This operation sequentially performs edge splits, edge collapses, * This operation sequentially performs edge splits, edge collapses,
* edge flips, tangential relaxation and projection to the initial surface * edge flips, tangential relaxation and projection to the initial surface
@ -52,7 +53,7 @@ namespace Polygon_mesh_processing {
* @param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below * @param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
* *
* @pre if constraints protection is activated, the constrained edges must * @pre if constraints protection is activated, the constrained edges must
* not be longer than 4/3*`target_edge_length` * not be longer than 4/3*`target_edge_length`.
* *
* \cgalNamedParamsBegin * \cgalNamedParamsBegin
* \cgalParamNBegin{vertex_point_map} * \cgalParamNBegin{vertex_point_map}

14
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair.h
View File

@ -30,16 +30,16 @@ namespace CGAL {
namespace Polygon_mesh_processing { namespace Polygon_mesh_processing {
/// \ingroup PMP_repairing_grp /// \ingroup PMP_repairing_grp
/// removes the isolated vertices from any polygon mesh. ///
/// A vertex is considered isolated if it is not incident to any simplex /// \brief removes the isolated vertices from any polygon mesh.
/// of higher dimension. ///
/// A vertex is considered isolated if it is not incident to any simplex of higher dimension.
/// ///
/// @tparam PolygonMesh a model of `FaceListGraph` and `MutableFaceGraph` /// @tparam PolygonMesh a model of `FaceListGraph` and `MutableFaceGraph`
/// ///
/// @param pmesh the polygon mesh to be repaired /// @param pmesh the polygon mesh to be repaired
/// ///
/// @return number of removed isolated vertices /// @return the number of removed isolated vertices
///
template <class PolygonMesh> template <class PolygonMesh>
std::size_t remove_isolated_vertices(PolygonMesh& pmesh) std::size_t remove_isolated_vertices(PolygonMesh& pmesh)
{ {
@ -62,7 +62,7 @@ std::size_t remove_isolated_vertices(PolygonMesh& pmesh)
/// \ingroup PMP_repairing_grp /// \ingroup PMP_repairing_grp
/// ///
/// removes connected components whose area or volume is under a certain threshold value. /// \brief removes connected components whose area or volume is under a certain threshold value.
/// ///
/// Thresholds are provided via \ref bgl_namedparameters "Named Parameters". (see below). /// Thresholds are provided via \ref bgl_namedparameters "Named Parameters". (see below).
/// If thresholds are not provided by the user, default values are computed as follows: /// If thresholds are not provided by the user, default values are computed as follows:
@ -147,6 +147,8 @@ std::size_t remove_isolated_vertices(PolygonMesh& pmesh)
/// ///
/// \return the number of connected components removed (ignoring isolated vertices). /// \return the number of connected components removed (ignoring isolated vertices).
/// ///
/// \sa `keep_connected_components()`
/// \sa `remove_connected_components()`
template <typename TriangleMesh, template <typename TriangleMesh,
typename NamedParameters = parameters::Default_named_parameters> typename NamedParameters = parameters::Default_named_parameters>
std::size_t remove_connected_components_of_negligible_size(TriangleMesh& tmesh, std::size_t remove_connected_components_of_negligible_size(TriangleMesh& tmesh,

44
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair_degeneracies.h
View File

@ -1202,6 +1202,45 @@ remove_a_border_edge(typename boost::graph_traits<TriangleMesh>::edge_descriptor
return remove_a_border_edge(ed, tm, input_range, edge_set, face_set); return remove_a_border_edge(ed, tm, input_range, edge_set, face_set);
} }
// \ingroup PMP_repairing_grp
//
// removes the degenerate edges from a triangulated surface mesh.
// An edge is considered degenerate if its two extremities share the same location.
//
// @pre `CGAL::is_triangle_mesh(tmesh)`
//
// @tparam TriangleMesh a model of `FaceListGraph` and `MutableFaceGraph`
// @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
//
// @param tmesh the triangulated surface mesh to be repaired
// @param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
//
// \cgalNamedParamsBegin
// \cgalParamNBegin{vertex_point_map}
// \cgalParamDescription{a property map associating points to the vertices of `tmesh`}
// \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
// as key type and `%Point_3` as value type}
// \cgalParamDefault{`boost::get(CGAL::vertex_point, tmesh)`}
// \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
// must be available in `TriangleMesh`.}
// \cgalParamNEnd
//
// \cgalParamNBegin{geom_traits}
// \cgalParamDescription{an instance of a geometric traits class}
// \cgalParamType{The traits class must provide the nested type `Point_3`,
// and the nested functors:
// - `Compare_distance_3` to compute the distance between 2 points
// - `Less_xyz_3` to compare lexicographically two points
// - `Equal_3` to check whether 2 points are identical.
// For each functor `Foo`, a function `Foo foo_object()` must be provided.}
// \cgalParamDefault{a \cgal Kernel deduced from the point type, using `CGAL::Kernel_traits`}
// \cgalParamExtra{The geometric traits class must be compatible with the vertex point type.}
// \cgalParamNEnd
// \cgalNamedParamsEnd
//
// \return `true` if all degenerate faces were successfully removed, and `false` otherwise.
//
// \sa `degenerate_edges()`
template <typename EdgeRange, typename TriangleMesh, typename FaceSet, typename NamedParameters = parameters::Default_named_parameters> template <typename EdgeRange, typename TriangleMesh, typename FaceSet, typename NamedParameters = parameters::Default_named_parameters>
bool remove_degenerate_edges(const EdgeRange& edge_range, bool remove_degenerate_edges(const EdgeRange& edge_range,
TriangleMesh& tmesh, TriangleMesh& tmesh,
@ -1723,6 +1762,7 @@ bool remove_degenerate_edges(TriangleMesh& tmesh,
} }
// \ingroup PMP_repairing_grp // \ingroup PMP_repairing_grp
//
// removes the degenerate faces from a triangulated surface mesh. // removes the degenerate faces from a triangulated surface mesh.
// A face is considered degenerate if two of its vertices share the same location, // A face is considered degenerate if two of its vertices share the same location,
// or more generally if all its vertices are collinear. // or more generally if all its vertices are collinear.
@ -1753,7 +1793,7 @@ bool remove_degenerate_edges(TriangleMesh& tmesh,
// - `Collinear_3` to check whether 3 points are collinear // - `Collinear_3` to check whether 3 points are collinear
// - `Less_xyz_3` to compare lexicographically two points // - `Less_xyz_3` to compare lexicographically two points
// - `Equal_3` to check whether 2 points are identical. // - `Equal_3` to check whether 2 points are identical.
// For each functor Foo, a function `Foo foo_object()` must be provided.} // For each functor `Foo`, a function `Foo foo_object()` must be provided.}
// \cgalParamDefault{a \cgal Kernel deduced from the point type, using `CGAL::Kernel_traits`} // \cgalParamDefault{a \cgal Kernel deduced from the point type, using `CGAL::Kernel_traits`}
// \cgalParamExtra{The geometric traits class must be compatible with the vertex point type.} // \cgalParamExtra{The geometric traits class must be compatible with the vertex point type.}
// \cgalParamNEnd // \cgalParamNEnd
@ -1763,6 +1803,8 @@ bool remove_degenerate_edges(TriangleMesh& tmesh,
// We should probably do something with the return type. // We should probably do something with the return type.
// //
// \return `true` if all degenerate faces were successfully removed, and `false` otherwise. // \return `true` if all degenerate faces were successfully removed, and `false` otherwise.
//
// \sa `degenerate_faces()`
template <typename FaceRange, typename TriangleMesh, typename NamedParameters = parameters::Default_named_parameters> template <typename FaceRange, typename TriangleMesh, typename NamedParameters = parameters::Default_named_parameters>
bool remove_degenerate_faces(const FaceRange& face_range, bool remove_degenerate_faces(const FaceRange& face_range,
TriangleMesh& tmesh, TriangleMesh& tmesh,

17
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair_polygon_soup.h
View File

@ -157,12 +157,13 @@ bool simplify_polygon(PointRange& points,
// \cgalParamNBegin{geom_traits} // \cgalParamNBegin{geom_traits}
// \cgalParamDescription{an instance of a geometric traits class} // \cgalParamDescription{an instance of a geometric traits class}
// \cgalParamType{The traits class must provide the nested functor `Equal_3` // \cgalParamType{The traits class must provide the nested functor `Equal_3`
// to compare lexicographically two points a function `Equal_3 equal_3_object()`.} // to compare lexicographically two points, and a function `Equal_3 equal_3_object()`.}
// \cgalParamDefault{a \cgal Kernel deduced from the point type, using `CGAL::Kernel_traits`} // \cgalParamDefault{a \cgal Kernel deduced from the point type, using `CGAL::Kernel_traits`}
// \cgalParamExtra{The geometric traits class must be compatible with the vertex point type.} // \cgalParamExtra{The geometric traits class must be compatible with the vertex point type.}
// \cgalParamNEnd // \cgalParamNEnd
// \cgalNamedParamsEnd // \cgalNamedParamsEnd
// //
// \sa `repair_polygon_soup()`
template <typename Traits, typename PointRange, typename PolygonRange> template <typename Traits, typename PointRange, typename PolygonRange>
std::size_t simplify_polygons_in_polygon_soup(PointRange& points, std::size_t simplify_polygons_in_polygon_soup(PointRange& points,
PolygonRange& polygons, PolygonRange& polygons,
@ -217,6 +218,7 @@ std::size_t simplify_polygons_in_polygon_soup(PointRange& points,
// \cgalParamNEnd // \cgalParamNEnd
// \cgalNamedParamsEnd // \cgalNamedParamsEnd
// //
// \sa `repair_polygon_soup()`
template <typename Traits, typename PointRange, typename PolygonRange> template <typename Traits, typename PointRange, typename PolygonRange>
std::size_t split_pinched_polygons_in_polygon_soup(PointRange& points, std::size_t split_pinched_polygons_in_polygon_soup(PointRange& points,
PolygonRange& polygons, PolygonRange& polygons,
@ -311,6 +313,7 @@ std::size_t split_pinched_polygons_in_polygon_soup(PointRange& points,
// \param polygons a vector of polygons. Each element in the vector describes a polygon // \param polygons a vector of polygons. Each element in the vector describes a polygon
// using the indices of the points in `points`. // using the indices of the points in `points`.
// //
// \sa `repair_polygon_soup()`
template <typename PointRange, typename PolygonRange> template <typename PointRange, typename PolygonRange>
std::size_t remove_invalid_polygons_in_polygon_soup(PointRange& /*points*/, std::size_t remove_invalid_polygons_in_polygon_soup(PointRange& /*points*/,
PolygonRange& polygons) PolygonRange& polygons)
@ -358,6 +361,7 @@ std::size_t remove_invalid_polygons_in_polygon_soup(PointRange& /*points*/,
/// ///
/// \returns the number of removed isolated points /// \returns the number of removed isolated points
/// ///
/// \sa `repair_polygon_soup()`
template <typename PointRange, typename PolygonRange> template <typename PointRange, typename PolygonRange>
std::size_t remove_isolated_points_in_polygon_soup(PointRange& points, std::size_t remove_isolated_points_in_polygon_soup(PointRange& points,
PolygonRange& polygons) PolygonRange& polygons)
@ -446,7 +450,8 @@ std::size_t remove_isolated_points_in_polygon_soup(PointRange& points,
/// \ingroup PMP_repairing_grp /// \ingroup PMP_repairing_grp
/// ///
/// merges the duplicate points in a polygon soup. /// \brief merges the duplicate points in a polygon soup.
///
/// Note that the index of a point that is merged with another point will thus change /// Note that the index of a point that is merged with another point will thus change
/// in all the polygons that the point appears in. /// in all the polygons that the point appears in.
/// ///
@ -474,6 +479,7 @@ std::size_t remove_isolated_points_in_polygon_soup(PointRange& points,
/// ///
/// \returns the number of removed points /// \returns the number of removed points
/// ///
/// \sa `repair_polygon_soup()`
template <typename PointRange, typename PolygonRange, typename NamedParameters = parameters::Default_named_parameters> template <typename PointRange, typename PolygonRange, typename NamedParameters = parameters::Default_named_parameters>
std::size_t merge_duplicate_points_in_polygon_soup(PointRange& points, std::size_t merge_duplicate_points_in_polygon_soup(PointRange& points,
PolygonRange& polygons, PolygonRange& polygons,
@ -770,6 +776,7 @@ struct Duplicate_collector<ValueType, CGAL::Emptyset_iterator>
// polygon ids `i0`, `i1`, etc. such that `polygons[i0] = polygons[i1] = ...` // polygon ids `i0`, `i1`, etc. such that `polygons[i0] = polygons[i1] = ...`
// \param same_orientation whether two polygons should have the same orientation to be duplicates. // \param same_orientation whether two polygons should have the same orientation to be duplicates.
// //
// \sa `repair_polygon_soup()`
template <typename PointRange, typename PolygonRange, typename DuplicateOutputIterator, typename Traits> template <typename PointRange, typename PolygonRange, typename DuplicateOutputIterator, typename Traits>
DuplicateOutputIterator collect_duplicate_polygons(const PointRange& points, DuplicateOutputIterator collect_duplicate_polygons(const PointRange& points,
const PolygonRange& polygons, const PolygonRange& polygons,
@ -873,6 +880,7 @@ DuplicateOutputIterator collect_duplicate_polygons(const PointRange& points,
/// ///
/// \returns the number of removed polygons /// \returns the number of removed polygons
/// ///
/// \sa `repair_polygon_soup()`
template <typename PointRange, typename PolygonRange, typename NamedParameters = parameters::Default_named_parameters> template <typename PointRange, typename PolygonRange, typename NamedParameters = parameters::Default_named_parameters>
std::size_t merge_duplicate_polygons_in_polygon_soup(const PointRange& points, std::size_t merge_duplicate_polygons_in_polygon_soup(const PointRange& points,
PolygonRange& polygons, PolygonRange& polygons,
@ -974,8 +982,9 @@ std::size_t merge_duplicate_polygons_in_polygon_soup(const PointRange& points,
/// \ingroup PMP_repairing_grp /// \ingroup PMP_repairing_grp
/// ///
/// cleans a given polygon soup through various repairing operations. More precisely, this function /// \brief cleans a given polygon soup through various repairing operations.
/// carries out the following tasks, in the same order as they are listed: ///
/// More precisely, this function carries out the following tasks, in the same order as they are listed:
/// - merging of duplicate points, using the function /// - merging of duplicate points, using the function
/// `CGAL::Polygon_mesh_processing::merge_duplicate_points_in_polygon_soup()`; /// `CGAL::Polygon_mesh_processing::merge_duplicate_points_in_polygon_soup()`;
/// - simplification of polygons to remove geometrically identical consecutive vertices; /// - simplification of polygons to remove geometrically identical consecutive vertices;

23
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/self_intersections.h
View File

@ -386,7 +386,8 @@ self_intersections_impl(const FaceRange& face_range,
typedef internal::Strict_intersect_faces<Box, TM, VPM, GT, boost::function_output_iterator<Count_and_throw_filter > > Intersecting_faces_limited_filter; typedef internal::Strict_intersect_faces<Box, TM, VPM, GT, boost::function_output_iterator<Count_and_throw_filter > > Intersecting_faces_limited_filter;
Intersecting_faces_limited_filter limited_intersect_faces(tmesh, vpmap, gt, Intersecting_faces_limited_filter limited_intersect_faces(tmesh, vpmap, gt,
boost::make_function_output_iterator(max_inter_counter)); boost::make_function_output_iterator(max_inter_counter));
try{ try
{
CGAL::box_self_intersection_d<CGAL::Sequential_tag>(box_ptr.begin(), box_ptr.end(), limited_intersect_faces, cutoff); CGAL::box_self_intersection_d<CGAL::Sequential_tag>(box_ptr.begin(), box_ptr.end(), limited_intersect_faces, cutoff);
} }
catch (const CGAL::internal::Throw_at_output_exception&) catch (const CGAL::internal::Throw_at_output_exception&)
@ -404,6 +405,7 @@ self_intersections_impl(const FaceRange& face_range,
/*! /*!
* \ingroup PMP_intersection_grp * \ingroup PMP_intersection_grp
*
* collects intersections between a subset of faces of a triangulated surface mesh. * collects intersections between a subset of faces of a triangulated surface mesh.
* Two faces are said to intersect if the corresponding triangles intersect * Two faces are said to intersect if the corresponding triangles intersect
* and the intersection is not an edge nor a vertex incident to both faces. * and the intersection is not an edge nor a vertex incident to both faces.
@ -451,6 +453,8 @@ self_intersections_impl(const FaceRange& face_range,
* \cgalNamedParamsEnd * \cgalNamedParamsEnd
* *
* @return `out` * @return `out`
*
* @sa `does_self_intersect()`
*/ */
template < class ConcurrencyTag = Sequential_tag, template < class ConcurrencyTag = Sequential_tag,
class TriangleMesh, class TriangleMesh,
@ -468,6 +472,7 @@ self_intersections(const FaceRange& face_range,
/** /**
* \ingroup PMP_intersection_grp * \ingroup PMP_intersection_grp
*
* collects intersections between all the faces of a triangulated surface mesh. * collects intersections between all the faces of a triangulated surface mesh.
* Two faces are said to intersect if the corresponding triangles intersect * Two faces are said to intersect if the corresponding triangles intersect
* and the intersection is not an edge nor a vertex incident to both faces. * and the intersection is not an edge nor a vertex incident to both faces.
@ -516,6 +521,8 @@ self_intersections(const FaceRange& face_range,
* \cgalNamedParamsEnd * \cgalNamedParamsEnd
* *
* @return `out` * @return `out`
*
* @sa `does_self_intersect()`
*/ */
template <class ConcurrencyTag = Sequential_tag, template <class ConcurrencyTag = Sequential_tag,
class TriangleMesh, class TriangleMesh,
@ -531,8 +538,11 @@ self_intersections(const TriangleMesh& tmesh,
/** /**
* \ingroup PMP_intersection_grp * \ingroup PMP_intersection_grp
* tests if a set of faces of a triangulated surface mesh self-intersects. *
* \brief tests if a set of faces of a triangulated surface mesh self-intersects.
*
* This function depends on the package \ref PkgBoxIntersectionD * This function depends on the package \ref PkgBoxIntersectionD
*
* @pre `CGAL::is_triangle_mesh(tmesh)` * @pre `CGAL::is_triangle_mesh(tmesh)`
* *
* @tparam ConcurrencyTag enables sequential versus parallel algorithm. * @tparam ConcurrencyTag enables sequential versus parallel algorithm.
@ -563,6 +573,8 @@ self_intersections(const TriangleMesh& tmesh,
* \cgalNamedParamsEnd * \cgalNamedParamsEnd
* *
* @return `true` if the faces in `face_range` self-intersect * @return `true` if the faces in `face_range` self-intersect
*
* @sa `self_intersections()`
*/ */
template <class ConcurrencyTag = Sequential_tag, template <class ConcurrencyTag = Sequential_tag,
class FaceRange, class FaceRange,
@ -599,8 +611,11 @@ bool does_self_intersect(const FaceRange& face_range,
/** /**
* \ingroup PMP_intersection_grp * \ingroup PMP_intersection_grp
* tests if a triangulated surface mesh self-intersects. *
* \brief tests if a triangulated surface mesh self-intersects.
*
* This function depends on the package \ref PkgBoxIntersectionD * This function depends on the package \ref PkgBoxIntersectionD
*
* @pre `CGAL::is_triangle_mesh(tmesh)` * @pre `CGAL::is_triangle_mesh(tmesh)`
* *
* @tparam ConcurrencyTag enables sequential versus parallel algorithm. * @tparam ConcurrencyTag enables sequential versus parallel algorithm.
@ -629,6 +644,8 @@ bool does_self_intersect(const FaceRange& face_range,
* \cgalNamedParamsEnd * \cgalNamedParamsEnd
* *
* @return `true` if `tmesh` self-intersects * @return `true` if `tmesh` self-intersects
*
* @sa `self_intersections()`
*/ */
template <class ConcurrencyTag = Sequential_tag, template <class ConcurrencyTag = Sequential_tag,
class TriangleMesh, class TriangleMesh,

28
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/shape_predicates.h
View File

@ -36,6 +36,7 @@ namespace CGAL {
namespace Polygon_mesh_processing { namespace Polygon_mesh_processing {
/// \ingroup PMP_repairing_grp /// \ingroup PMP_repairing_grp
///
/// checks whether an edge is degenerate. /// checks whether an edge is degenerate.
/// An edge is considered degenerate if the geometric positions of its two extremities are identical. /// An edge is considered degenerate if the geometric positions of its two extremities are identical.
/// ///
@ -63,9 +64,9 @@ namespace Polygon_mesh_processing {
/// \cgalParamNEnd /// \cgalParamNEnd
/// \cgalNamedParamsEnd /// \cgalNamedParamsEnd
/// ///
/// \sa `degenerate_edges()`
///
/// \return `true` if the edge `e` is degenerate, `false` otherwise. /// \return `true` if the edge `e` is degenerate, `false` otherwise.
///
/// \sa `degenerate_edges()`
template <typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters> template <typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters>
bool is_degenerate_edge(typename boost::graph_traits<PolygonMesh>::edge_descriptor e, bool is_degenerate_edge(typename boost::graph_traits<PolygonMesh>::edge_descriptor e,
const PolygonMesh& pm, const PolygonMesh& pm,
@ -85,6 +86,7 @@ bool is_degenerate_edge(typename boost::graph_traits<PolygonMesh>::edge_descript
} }
/// \ingroup PMP_repairing_grp /// \ingroup PMP_repairing_grp
///
/// collects the degenerate edges within a given range of edges. /// collects the degenerate edges within a given range of edges.
/// ///
/// @tparam EdgeRange a model of `Range` with value type `boost::graph_traits<TriangleMesh>::%edge_descriptor` /// @tparam EdgeRange a model of `Range` with value type `boost::graph_traits<TriangleMesh>::%edge_descriptor`
@ -114,6 +116,9 @@ bool is_degenerate_edge(typename boost::graph_traits<PolygonMesh>::edge_descript
/// \cgalParamExtra{The geometric traits class must be compatible with the vertex point type.} /// \cgalParamExtra{The geometric traits class must be compatible with the vertex point type.}
/// \cgalParamNEnd /// \cgalParamNEnd
/// \cgalNamedParamsEnd /// \cgalNamedParamsEnd
///
/// \sa `is_degenerate_edge()`
// \sa `remove_degenerate_edges()`
template <typename EdgeRange, typename TriangleMesh, typename OutputIterator, typename CGAL_NP_TEMPLATE_PARAMETERS> template <typename EdgeRange, typename TriangleMesh, typename OutputIterator, typename CGAL_NP_TEMPLATE_PARAMETERS>
OutputIterator degenerate_edges(const EdgeRange& edges, OutputIterator degenerate_edges(const EdgeRange& edges,
const TriangleMesh& tm, const TriangleMesh& tm,
@ -130,10 +135,10 @@ OutputIterator degenerate_edges(const EdgeRange& edges,
} }
/// \ingroup PMP_repairing_grp /// \ingroup PMP_repairing_grp
///
/// calls the function `degenerate_edges()` with the range: `edges(tm)`. /// calls the function `degenerate_edges()` with the range: `edges(tm)`.
/// ///
/// See above for the comprehensive description of the parameters. /// See the other overload for the comprehensive description of the parameters.
///
template <typename TriangleMesh, typename OutputIterator, typename CGAL_NP_TEMPLATE_PARAMETERS> template <typename TriangleMesh, typename OutputIterator, typename CGAL_NP_TEMPLATE_PARAMETERS>
OutputIterator degenerate_edges(const TriangleMesh& tm, OutputIterator degenerate_edges(const TriangleMesh& tm,
OutputIterator out, OutputIterator out,
@ -144,6 +149,7 @@ OutputIterator degenerate_edges(const TriangleMesh& tm,
} }
/// \ingroup PMP_repairing_grp /// \ingroup PMP_repairing_grp
///
/// checks whether a triangle face is degenerate. /// checks whether a triangle face is degenerate.
/// A triangle face is considered degenerate if the geometric positions of its vertices are collinear. /// A triangle face is considered degenerate if the geometric positions of its vertices are collinear.
/// ///
@ -171,9 +177,9 @@ OutputIterator degenerate_edges(const TriangleMesh& tm,
/// \cgalParamNEnd /// \cgalParamNEnd
/// \cgalNamedParamsEnd /// \cgalNamedParamsEnd
/// ///
/// \sa `degenerate_faces()`
///
/// \return `true` if the face `f` is degenerate, `false` otherwise. /// \return `true` if the face `f` is degenerate, `false` otherwise.
///
/// \sa `degenerate_faces()`
template <typename TriangleMesh, typename NamedParameters = parameters::Default_named_parameters> template <typename TriangleMesh, typename NamedParameters = parameters::Default_named_parameters>
bool is_degenerate_triangle_face(typename boost::graph_traits<TriangleMesh>::face_descriptor f, bool is_degenerate_triangle_face(typename boost::graph_traits<TriangleMesh>::face_descriptor f,
const TriangleMesh& tm, const TriangleMesh& tm,
@ -229,6 +235,8 @@ bool is_degenerate_triangle_face(typename boost::graph_traits<TriangleMesh>::fac
/// \cgalParamNEnd /// \cgalParamNEnd
/// \cgalNamedParamsEnd /// \cgalNamedParamsEnd
/// ///
/// \sa `is_degenerate_triangle_face()`
// `\sa remove_degenerate_faces()`
template <typename FaceRange, typename TriangleMesh, typename OutputIterator, typename CGAL_NP_TEMPLATE_PARAMETERS> template <typename FaceRange, typename TriangleMesh, typename OutputIterator, typename CGAL_NP_TEMPLATE_PARAMETERS>
OutputIterator degenerate_faces(const FaceRange& faces, OutputIterator degenerate_faces(const FaceRange& faces,
const TriangleMesh& tm, const TriangleMesh& tm,
@ -246,10 +254,10 @@ OutputIterator degenerate_faces(const FaceRange& faces,
} }
/// \ingroup PMP_repairing_grp /// \ingroup PMP_repairing_grp
///
/// calls the function `degenerate_faces()` with the range: `faces(tm)`. /// calls the function `degenerate_faces()` with the range: `faces(tm)`.
/// ///
/// See above for the comprehensive description of the parameters. /// See the other overload for the comprehensive description of the parameters.
///
template <typename TriangleMesh, typename OutputIterator, typename CGAL_NP_TEMPLATE_PARAMETERS> template <typename TriangleMesh, typename OutputIterator, typename CGAL_NP_TEMPLATE_PARAMETERS>
OutputIterator degenerate_faces(const TriangleMesh& tm, OutputIterator degenerate_faces(const TriangleMesh& tm,
OutputIterator out, OutputIterator out,
@ -290,6 +298,8 @@ OutputIterator degenerate_faces(const TriangleMesh& tm,
/// ///
/// \return the shortest halfedge if the triangle face is a needle, and a null halfedge otherwise. /// \return the shortest halfedge if the triangle face is a needle, and a null halfedge otherwise.
/// If the face contains degenerate edges, a halfedge corresponding to one of these edges is returned. /// If the face contains degenerate edges, a halfedge corresponding to one of these edges is returned.
///
/// \sa `is_cap_triangle_face()`
template <typename TriangleMesh, typename NamedParameters = parameters::Default_named_parameters> template <typename TriangleMesh, typename NamedParameters = parameters::Default_named_parameters>
typename boost::graph_traits<TriangleMesh>::halfedge_descriptor typename boost::graph_traits<TriangleMesh>::halfedge_descriptor
is_needle_triangle_face(typename boost::graph_traits<TriangleMesh>::face_descriptor f, is_needle_triangle_face(typename boost::graph_traits<TriangleMesh>::face_descriptor f,
@ -388,6 +398,8 @@ is_needle_triangle_face(typename boost::graph_traits<TriangleMesh>::face_descrip
/// \cgalNamedParamsEnd /// \cgalNamedParamsEnd
/// ///
/// \return the halfedge opposite of the largest angle if the face is a cap, and a null halfedge otherwise. /// \return the halfedge opposite of the largest angle if the face is a cap, and a null halfedge otherwise.
///
/// \sa `is_needle_triangle_face()`
template <typename TriangleMesh, typename NamedParameters = parameters::Default_named_parameters> template <typename TriangleMesh, typename NamedParameters = parameters::Default_named_parameters>
typename boost::graph_traits<TriangleMesh>::halfedge_descriptor typename boost::graph_traits<TriangleMesh>::halfedge_descriptor
is_cap_triangle_face(typename boost::graph_traits<TriangleMesh>::face_descriptor f, is_cap_triangle_face(typename boost::graph_traits<TriangleMesh>::face_descriptor f,

4
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/smooth_mesh.h
View File

@ -31,7 +31,7 @@ namespace Polygon_mesh_processing {
/*! /*!
* \ingroup PMP_meshing_grp * \ingroup PMP_meshing_grp
* *
* \short smooths a triangulated region of a polygon mesh. * \brief smooths a triangulated region of a polygon mesh.
* *
* This function attempts to make the triangle angle and area distributions as uniform as possible * This function attempts to make the triangle angle and area distributions as uniform as possible
* by moving (non-constrained) vertices. * by moving (non-constrained) vertices.
@ -128,6 +128,8 @@ namespace Polygon_mesh_processing {
* to use area-based smoothing. * to use area-based smoothing.
* *
* @pre `tmesh` does not contain any degenerate faces * @pre `tmesh` does not contain any degenerate faces
*
* @see `smooth_shape()`
*/ */
template<typename TriangleMesh, typename FaceRange, typename NamedParameters = parameters::Default_named_parameters> template<typename TriangleMesh, typename FaceRange, typename NamedParameters = parameters::Default_named_parameters>
void smooth_mesh(const FaceRange& faces, void smooth_mesh(const FaceRange& faces,

8
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/smooth_shape.h
View File

@ -35,7 +35,9 @@ namespace Polygon_mesh_processing {
/*! /*!
* \ingroup PMP_meshing_grp * \ingroup PMP_meshing_grp
* smooths the overall shape of the mesh by using the mean curvature flow. *
* @brief 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 * 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. * represents the amount by which vertices are allowed to move.
* The result conformally maps the initial surface to a sphere. * The result conformally maps the initial surface to a sphere.
@ -93,7 +95,9 @@ namespace Polygon_mesh_processing {
* \cgalParamNEnd * \cgalParamNEnd
* \cgalNamedParamsEnd * \cgalNamedParamsEnd
* *
* @warning This function involves linear algebra, that is computed using a non-exact floating-point arithmetic. * @warning This function involves linear algebra, that is computed using non-exact, floating-point arithmetic.
*
* @see `smooth_mesh()`
*/ */
template<typename TriangleMesh, typename FaceRange, typename NamedParameters = parameters::Default_named_parameters> template<typename TriangleMesh, typename FaceRange, typename NamedParameters = parameters::Default_named_parameters>
void smooth_shape(const FaceRange& faces, void smooth_shape(const FaceRange& faces,

6
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/stitch_borders.h
View File

@ -1088,7 +1088,8 @@ std::size_t stitch_boundary_cycle(const typename boost::graph_traits<PolygonMesh
/// \ingroup PMP_repairing_grp /// \ingroup PMP_repairing_grp
/// ///
/// \brief stitches together, whenever possible, two halfedges belonging to the boundary cycle described by the halfedge `h`. /// \brief stitches together, whenever possible, two halfedges belonging to the boundary cycle
/// described by the halfedge `h`.
/// ///
/// Two border halfedges `h1` and `h2` can be stitched /// Two border halfedges `h1` and `h2` can be stitched
/// if the points associated to the source and target vertices of `h1` are /// if the points associated to the source and target vertices of `h1` are
@ -1206,7 +1207,6 @@ std::size_t stitch_boundary_cycles(PolygonMesh& pmesh,
/// \endcond /// \endcond
// The VPM is only used here for debugging info purposes as in this overload, the halfedges // The VPM is only used here for debugging info purposes as in this overload, the halfedges
// to stitch are already provided and all further checks are combinatorial and not geometrical. // to stitch are already provided and all further checks are combinatorial and not geometrical.
/*! /*!
@ -1242,6 +1242,8 @@ std::size_t stitch_boundary_cycles(PolygonMesh& pmesh,
* *
* \return the number of pairs of halfedges that were stitched. * \return the number of pairs of halfedges that were stitched.
* *
* \sa `stitch_boundary_cycle()`
* \sa `stitch_boundary_cycles()`
*/ */
template <typename PolygonMesh, template <typename PolygonMesh,
typename HalfedgePairsRange, typename HalfedgePairsRange,

22
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/triangulate_faces.h
View File

@ -426,7 +426,9 @@ public:
/** /**
* \ingroup PMP_meshing_grp * \ingroup PMP_meshing_grp
* triangulates a single face of a polygon mesh. This function depends on the package \ref PkgTriangulation2 *
* triangulates a single face of a polygon mesh. This function depends on the package \ref PkgTriangulation2.
*
* @tparam PolygonMesh a model of `FaceListGraph` and `MutableFaceGraph` * @tparam PolygonMesh a model of `FaceListGraph` and `MutableFaceGraph`
* @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters" * @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
* *
@ -461,6 +463,8 @@ public:
* \cgalNamedParamsEnd * \cgalNamedParamsEnd
* *
* @return `true` if the face has been triangulated. * @return `true` if the face has been triangulated.
*
* @see `triangulate_faces()`
*/ */
template<typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters> template<typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters>
bool triangulate_face(typename boost::graph_traits<PolygonMesh>::face_descriptor f, bool triangulate_face(typename boost::graph_traits<PolygonMesh>::face_descriptor f,
@ -497,11 +501,11 @@ bool triangulate_face(typename boost::graph_traits<PolygonMesh>::face_descriptor
/** /**
* \ingroup PMP_meshing_grp * \ingroup PMP_meshing_grp
* triangulates given faces of a polygon mesh. This function depends on the package \ref PkgTriangulation2
* *
* @tparam FaceRange range of `boost::graph_traits<PolygonMesh>::%face_descriptor`, * triangulates given faces of a polygon mesh. This function depends on the package \ref PkgTriangulation2.
model of `Range`. *
Its iterator type is `InputIterator`. * @tparam FaceRange range of `boost::graph_traits<PolygonMesh>::%face_descriptor`, model of `Range`.
* Its iterator type is `InputIterator`.
* @tparam PolygonMesh a model of `FaceListGraph` and `MutableFaceGraph` * @tparam PolygonMesh a model of `FaceListGraph` and `MutableFaceGraph`
* @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters" * @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
* *
@ -537,7 +541,7 @@ bool triangulate_face(typename boost::graph_traits<PolygonMesh>::face_descriptor
* *
* @return `true` if all the faces have been triangulated. * @return `true` if all the faces have been triangulated.
* *
* @see triangulate_face() * @see `triangulate_face()`
*/ */
template <typename FaceRange, typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters> template <typename FaceRange, typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters>
bool triangulate_faces(FaceRange face_range, bool triangulate_faces(FaceRange face_range,
@ -574,7 +578,9 @@ bool triangulate_faces(FaceRange face_range,
/** /**
* \ingroup PMP_meshing_grp * \ingroup PMP_meshing_grp
* triangulates all faces of a polygon mesh. This function depends on the package \ref PkgTriangulation2 *
* triangulates all faces of a polygon mesh. This function depends on the package \ref PkgTriangulation2.
*
* @tparam PolygonMesh a model of `FaceListGraph` and `MutableFaceGraph` * @tparam PolygonMesh a model of `FaceListGraph` and `MutableFaceGraph`
* @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters" * @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
* *
@ -609,7 +615,7 @@ bool triangulate_faces(FaceRange face_range,
* *
* @return `true` if all the faces have been triangulated. * @return `true` if all the faces have been triangulated.
* *
* @see triangulate_face() * @see `triangulate_face()`
*/ */
template <typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters> template <typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters>
bool triangulate_faces(PolygonMesh& pmesh, bool triangulate_faces(PolygonMesh& pmesh,

3
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/triangulate_hole.h
View File

@ -36,7 +36,8 @@ namespace CGAL {
namespace Polygon_mesh_processing { namespace Polygon_mesh_processing {
/*! /*!
\ingroup hole_filling_grp \ingroup PMP_hole_filling_grp
triangulates a hole in a polygon mesh. triangulates a hole in a polygon mesh.
Depending on the choice of the underlying algorithm different preconditions apply. Depending on the choice of the underlying algorithm different preconditions apply.

2
Polygon_mesh_processing/include/CGAL/Side_of_triangle_mesh.h
View File

@ -29,7 +29,7 @@
namespace CGAL { namespace CGAL {
/** /**
* \ingroup PkgPolygonMeshProcessingRef * \ingroup PMP_predicates_grp
* This class provides an efficient point location functionality with respect to a domain bounded * This class provides an efficient point location functionality with respect to a domain bounded
* by one or several disjoint closed triangle meshes. * by one or several disjoint closed triangle meshes.
* *