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
/// \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
/// of adjacent faces such that all edges between two consecutive faces of the
/// path are not marked as constrained.
///
/// \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.
/// \ingroup PkgPolygonMeshProcessingRef
@ -22,7 +20,7 @@
/// Functions to compute unit normals for individual/all vertices or faces.
/// \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.
/// \ingroup PkgPolygonMeshProcessingRef
@ -56,10 +54,8 @@
/// Functions to locate points on a mesh, and manipulate such locations.
/// \ingroup PkgPolygonMeshProcessingRef
/// \defgroup PMP_predicates_grp Intersection Detection Functions
/// Functions to detect intersections.
/// 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.
/// \defgroup PMP_predicates_grp Predicates
/// Classes and functions that answer queries about a polygon mesh or its elements.
/// \ingroup PkgPolygonMeshProcessingRef
/// \defgroup PMP_IO_grp I/O Functions
@ -94,21 +90,20 @@ ranging from basic operations on simplices, to complex geometry processing algor
\cgalCRPSection{Parameters}
Optional parameters of the functions of this package
are implemented as \ref BGLNamedParameters.
Optional parameters of the functions of this package are implemented as \ref BGLNamedParameters.
The page \ref bgl_namedparameters "Named Parameters" describes their usage.
\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::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::smooth_mesh()`
- `CGAL::Polygon_mesh_processing::smooth_shape()`
- `CGAL::Polygon_mesh_processing::random_perturbation()`
\cgalCRPSection{Hole Filling Functions}
- `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_hole_polyline()`
\cgalCRPSection{Predicate Functions}
\cgalCRPSection{Intersection Functions}
- `CGAL::Polygon_mesh_processing::does_self_intersect()`
- `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()`
\cgalCRPSection{Predicate Functions}
- `CGAL::Polygon_mesh_processing::is_degenerate_edge()`
- `CGAL::Polygon_mesh_processing::degenerate_edges()`
- `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_cap_triangle_face()`
- `CGAL::Polyhedral_envelope`
- `CGAL::Side_of_triangle_mesh`
\cgalCRPSection{Location Functions}
- \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::remove_isolated_vertices()`
- `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::merge_duplicated_vertices_in_boundary_cycle()`
- `CGAL::Polygon_mesh_processing::merge_duplicated_vertices_in_boundary_cycles()`
- `CGAL::Polygon_mesh_processing::remove_connected_components_of_negligible_size()`
\cgalCRPSection{Normal Computation Functions}
- `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_largest_connected_components()`
- `CGAL::Polygon_mesh_processing::split_connected_components()`
- \link 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::keep_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}
- `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()`
\cgalCRPSection{Geometric Measure Functions}
- \link measure_grp `CGAL::Polygon_mesh_processing::face_area()` \endlink
- \link measure_grp `CGAL::Polygon_mesh_processing::squared_face_area()` \endlink
- \link measure_grp `CGAL::Polygon_mesh_processing::area()` \endlink
- \link measure_grp `CGAL::Polygon_mesh_processing::volume()` \endlink
- \link measure_grp `CGAL::Polygon_mesh_processing::edge_length()` \endlink
- \link measure_grp `CGAL::Polygon_mesh_processing::squared_edge_length()` \endlink
- \link measure_grp `CGAL::Polygon_mesh_processing::face_border_length()` \endlink
- \link measure_grp `CGAL::Polygon_mesh_processing::centroid()` \endlink
- \link measure_grp `CGAL::Polygon_mesh_processing::match_faces()` \endlink
- \link PMP_measure_grp `CGAL::Polygon_mesh_processing::edge_length()` \endlink
- \link PMP_measure_grp `CGAL::Polygon_mesh_processing::squared_edge_length()` \endlink
- \link PMP_measure_grp `CGAL::Polygon_mesh_processing::face_area()` \endlink
- \link PMP_measure_grp `CGAL::Polygon_mesh_processing::squared_face_area()` \endlink
- \link PMP_measure_grp `CGAL::Polygon_mesh_processing::area()` \endlink
- \link PMP_measure_grp `CGAL::Polygon_mesh_processing::volume()` \endlink
- \link PMP_measure_grp `CGAL::Polygon_mesh_processing::face_border_length()` \endlink
- \link PMP_measure_grp `CGAL::Polygon_mesh_processing::longest_border()` \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}
- `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_max_distance_to_point_set()`
- `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_mesh()`
\cgalCRPSection{Feature Detection Functions}
- `CGAL::Polygon_mesh_processing::sharp_edges_segmentation()`
@ -223,7 +223,6 @@ The page \ref bgl_namedparameters "Named Parameters" describes their usage.
\cgalCRPSection{Miscellaneous}
- `CGAL::Polygon_mesh_slicer`
- `CGAL::Side_of_triangle_mesh`
- `CGAL::Polygon_mesh_processing::bbox()`
- `CGAL::Polygon_mesh_processing::vertex_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
* \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:
* - \ref IOStreamOFF (`.off`)

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

@ -29,9 +29,10 @@ namespace CGAL {
/*!
* \ingroup PkgPolygonMeshProcessingRef
* computes a bounding box of a polygon mesh.
*
* @tparam PolygonMesh a model of `HalfedgeListGraph`
* computes a bounding box of a polygon mesh.
*
* @tparam PolygonMesh a model of `VertexListGraph`
* @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
*
* @param pmesh a polygon mesh
@ -50,12 +51,14 @@ namespace CGAL {
* \cgalParamNBegin{geom_traits}
* \cgalParamDescription{an instance of a geometric traits class providing the functor `Construct_bbox_3`
* 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.}
* \cgalParamNEnd
* \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>
CGAL::Bbox_3 bbox(const PolygonMesh& pmesh,
@ -84,9 +87,10 @@ namespace CGAL {
/*!
* \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"
*
* @param vd a descriptor of a vertex in `pmesh`
@ -111,7 +115,9 @@ namespace CGAL {
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* @return a bounding box of `pmesh`
* @see `edge_bbox()`
* @see `face_bbox()`
* @see `bbox()`
*/
template<typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters>
CGAL::Bbox_3 vertex_bbox(typename boost::graph_traits<PolygonMesh>::vertex_descriptor vd,
@ -133,9 +139,10 @@ namespace CGAL {
/*!
* \ingroup PkgPolygonMeshProcessingRef
* computes a bounding box of an edge of a polygon mesh.
*
* @tparam PolygonMesh a model of `HalfedgeGraph`
* computes a bounding box of an edge of a polygon mesh.
*
* @tparam PolygonMesh a model of `Graph`
* @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
*
* @param ed a descriptor of an edge in `pmesh`
@ -160,7 +167,9 @@ namespace CGAL {
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* @return a bounding box of `pmesh`
* @see `vertex_bbox()`
* @see `face_bbox()`
* @see `bbox()`
*/
template<typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters>
CGAL::Bbox_3 edge_bbox(typename boost::graph_traits<PolygonMesh>::edge_descriptor ed,
@ -184,9 +193,10 @@ namespace CGAL {
/*!
* \ingroup PkgPolygonMeshProcessingRef
* computes a bounding box of a face of a polygon mesh.
*
* @tparam PolygonMesh a model of `HalfedgeGraph`
* computes a bounding box of a face of a polygon mesh.
*
* @tparam PolygonMesh a model of `Graph`
* @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
*
* @param fd a descriptor of a face in `pmesh`
@ -212,7 +222,9 @@ namespace CGAL {
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* @return a bounding box of `pmesh`
* @see `vertex_bbox()`
* @see `edge_bbox()`
* @see `bbox()`
*/
template<typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters>
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;
CGAL::Bbox_3 bb;
for(halfedge_descriptor h :
halfedges_around_face(halfedge(fd, pmesh), pmesh))
for(halfedge_descriptor h : halfedges_around_face(halfedge(fd, pmesh), 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
/*!
\ingroup PkgPolygonMeshProcessingRef
* collects the border halfedges of a surface patch defined as a face range.
* \ingroup PkgPolygonMeshProcessingRef
*
* \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,
* 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
*
* @returns `out`
*
* @see `extract_boundary_cycles()`
*/
template<typename PolygonMesh
, typename FaceRange
@ -233,6 +237,7 @@ std::size_t border_size(typename boost::graph_traits<PolygonMesh>::halfedge_desc
}
/// @ingroup PkgPolygonMeshProcessingRef
///
/// extracts boundary cycles as a list of halfedges, with one halfedge per border.
///
/// @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 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 should probably go into BGL package (like the rest of this file).
template <typename PolygonMesh, typename OutputIterator>

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

@ -513,10 +513,11 @@ generic_clip_impl(
/**
* \ingroup PMP_corefinement_grp
*
* clips `tm` by keeping the part that is inside the volume \link coref_def_subsec bounded \endlink
* by `clipper`.
* \brief clips `tm` by keeping the part that is inside the volume \link coref_def_subsec bounded \endlink by `clipper`.
*
* 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.
*
* \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
@ -593,6 +594,8 @@ generic_clip_impl(
*
* @return `true` if the output surface mesh is manifold.
* If `false` is returned `tm` and `clipper` are only corefined.
*
* @see `split()`
*/
template <class TriangleMesh,
class NamedParameters1 = parameters::Default_named_parameters,
@ -623,12 +626,14 @@ clip(TriangleMesh& tm,
/**
* \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`.
* 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
* 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 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
*
@ -691,6 +696,8 @@ clip(TriangleMesh& tm,
*
* @return `true` if the output surface mesh is manifold.
* If `false` is returned `tm` is only refined by the intersection with `plane`.
*
* @see `split()`
*/
template <class TriangleMesh,
class NamedParameters = parameters::Default_named_parameters>
@ -737,12 +744,15 @@ bool clip(TriangleMesh& tm,
/**
* \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`.
* 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
* 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 internal vertex point map of `TriangleMesh`.
* \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
*
* @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.
* If `false` is returned `tm` is only refined by the intersection with `iso_cuboid`.
*
* @see `split()`
*/
template <class TriangleMesh,
class NamedParameters = parameters::Default_named_parameters>
@ -827,12 +839,13 @@ bool clip(TriangleMesh& tm,
/*!
* \ingroup PMP_corefinement_grp
*
* 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(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 NamedParameters2 a sequence of \ref bgl_namedparameters "Named Parameters"
@ -877,6 +890,8 @@ bool clip(TriangleMesh& tm,
* \cgalParamNEnd
*
* \cgalNamedParamsEnd
*
* @see `clip()`
*/
template <class TriangleMesh,
class NamedParameters1 = parameters::Default_named_parameters,
@ -918,15 +933,16 @@ void split(TriangleMesh& tm,
/**
* \ingroup PMP_corefinement_grp
*
* 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
*
* @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.
*
* @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
*
* @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`.}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* @see `clip()`
*/
template <class TriangleMesh,
class NamedParameters = parameters::Default_named_parameters>
@ -1005,16 +1023,16 @@ void split(TriangleMesh& tm,
/**
* \ingroup PMP_corefinement_grp
*
* 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 vertex point map.
* \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 of `tm`.
*
* \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.
*
* @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
*
* @param tm input triangulated surface mesh
@ -1053,7 +1071,7 @@ void split(TriangleMesh& tm,
* \cgalParamNEnd
*
* \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}
* \cgalParamDefault{`true`}
* \cgalParamNEnd
@ -1066,17 +1084,18 @@ void split(TriangleMesh& tm,
* Setting this option to `true` will automatically set `throw_on_self_intersection` to `false`
* and `clip_volume` to `false`.}
* \cgalParamNEnd
*
* \cgalNamedParamsEnd
*
* @see `clip()`
*/
template <class TriangleMesh,
class NamedParameters = parameters::Default_named_parameters>
void split(TriangleMesh& tm,
#ifdef DOXYGEN_RUNNING
#ifdef DOXYGEN_RUNNING
const Iso_cuboid_3& iso_cuboid,
#else
#else
const typename GetGeomTraits<TriangleMesh, NamedParameters>::type::Iso_cuboid_3& iso_cuboid,
#endif
#endif
const NamedParameters& np = parameters::default_values())
{
namespace PMP = CGAL::Polygon_mesh_processing;
@ -1088,8 +1107,8 @@ void split(TriangleMesh& tm,
TriangleMesh splitter;
make_hexahedron(iso_cuboid[0], iso_cuboid[1], iso_cuboid[2], iso_cuboid[3],
iso_cuboid[4], iso_cuboid[5], iso_cuboid[6], iso_cuboid[7],
splitter);
iso_cuboid[4], iso_cuboid[5], iso_cuboid[6], iso_cuboid[7],
splitter);
triangulate_faces(splitter);
const bool do_not_modify = choose_parameter(get_parameter(np, internal_np::allow_self_intersections), false);
return split(tm, splitter, np, params::do_not_modify(do_not_modify));

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
*
* computes the outward unit vector normal to face `f`.
*
* @tparam PolygonMesh a model of `FaceGraph`
* @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
* 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
* of `pmesh`.
* or from the geometric traits class deduced from the point property map of `pmesh`.
*
* \warning This function involves a square root computation.
* If the field type (`FT`) of the traits does not support the `sqrt()` operation,
* the square root computation will be performed approximately.
*
* @see `compute_face_normals()`
*/
template <typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters>
#ifdef DOXYGEN_RUNNING
@ -190,7 +193,9 @@ compute_face_normal(typename boost::graph_traits<PolygonMesh>::face_descriptor f
/**
* \ingroup PMP_normal_grp
*
* computes the outward unit vector normal for all faces of the polygon mesh.
*
* @tparam PolygonMesh a model of `FaceGraph`
* @tparam Face_normal_map a model of `WritablePropertyMap` with
`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.
* If the field type (`FT`) of the traits does not support the `sqrt()` operation,
* 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>
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
*
* 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`
*
* @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
* 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 `pmesh`.
* or the geometric traits class deduced from the point property map of `pmesh`.
*
* \warning This function involves a square root computation.
* If the field type (`FT`) of the traits does not support the `sqrt()` operation,
* the square root computation will be performed approximately.
*
* @see `compute_vertex_normals()`
*/
template<typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters>
#ifdef DOXYGEN_RUNNING
@ -723,6 +736,7 @@ compute_vertex_normal(typename boost::graph_traits<PolygonMesh>::vertex_descript
/**
* \ingroup PMP_normal_grp
*
* computes the outward unit vector normal for all vertices of the polygon mesh.
*
* @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.
* If the field type (`FT`) of the traits does not support the `sqrt()` operation,
* the square root computation will be performed approximately.
*
* @see `compute_vertex_normal()`
*/
template <typename PolygonMesh, typename VertexNormalMap, typename NamedParameters = parameters::Default_named_parameters>
void compute_vertex_normals(const PolygonMesh& pmesh,
@ -813,6 +829,7 @@ void compute_vertex_normals(const PolygonMesh& pmesh,
/**
* \ingroup PMP_normal_grp
*
* computes the outward unit vector normal for all vertices and faces of the polygon mesh.
*
* @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.
* If the field type (`FT`) of the traits does not support the `sqrt()` operation,
* the square root computation will be performed approximately.
*
* @see `compute_vertex_normals()`
* @see `compute_face_normals()`
*/
template <typename PolygonMesh,
typename VertexNormalMap, typename FaceNormalMap,

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

@ -89,19 +89,19 @@ namespace internal {
} // namespace internal
/*!
* \ingroup keep_connected_components_grp
* discovers all the faces in the same connected component as `seed_face` and records them in `out`.
* \ingroup PMP_keep_connected_components_grp
*
* 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`.
*
* \tparam PolygonMesh a model of `FaceGraph`
* \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 PolygonMesh a model of `FaceGraph`
* \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"
*
* \param seed_face a face of `pmesh` from which exploration starts to detect the connected component
that contains it
* \param pmesh the polygon mesh
* \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 seed_face a face of `pmesh` from which exploration starts to detect the connected component that contains it
* \param pmesh the polygon mesh
* \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
*
* \cgalNamedParamsBegin
* \cgalParamNBegin{edge_is_constrained_map}
@ -114,6 +114,7 @@ namespace internal {
*
* \returns the output iterator.
*
* \see `connected_components()`
*/
template <typename PolygonMesh
, typename FaceOutputIterator
@ -161,15 +162,16 @@ connected_component(typename boost::graph_traits<PolygonMesh>::face_descriptor s
}
/*!
* \ingroup keep_connected_components_grp
* computes for each face the index of the corresponding connected component.
* \ingroup PMP_keep_connected_components_grp
*
* computes for each face the index of the corresponding connected component.
*
* \tparam PolygonMesh a model of `FaceListGraph`
* \tparam FaceComponentMap a model of `WritablePropertyMap` with
* `boost::graph_traits<PolygonMesh>::%face_descriptor` as key type and
* `boost::graph_traits<PolygonMesh>::%faces_size_type` as value type.
* \tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
*
* \tparam PolygonMesh a model of `FaceListGraph`
* \tparam FaceComponentMap a model of `WritablePropertyMap` with
`boost::graph_traits<PolygonMesh>::%face_descriptor` as key type and
`boost::graph_traits<PolygonMesh>::%faces_size_type` as value type.
* \tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
* \param pmesh the polygon mesh
* \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
@ -181,7 +183,7 @@ connected_component(typename boost::graph_traits<PolygonMesh>::face_descriptor s
* as key type and `bool` as value type}
* \cgalParamDefault{a constant property map returning `false` for any edge}
* \cgalParamNEnd
*
* \cgalParamNBegin{face_index_map}
* \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`
@ -191,8 +193,9 @@ connected_component(typename boost::graph_traits<PolygonMesh>::face_descriptor s
* \cgalNamedParamsEnd
*
* \returns the number of connected components.
*
* \see `connected_component()`
*/
template <typename PolygonMesh
, typename FaceComponentMap
, typename NamedParameters = parameters::Default_named_parameters
@ -266,17 +269,18 @@ void keep_connected_components(PolygonMesh& pmesh
namespace internal {
// /*!
// * \ingroup keep_connected_components_grp
// * returns the number of connected components in the mesh.
// * \ingroup PMP_keep_connected_components_grp
// *
// * A property map for `CGAL::face_index_t` must be either available as an internal property map
// * to `pmesh` or provided as one of the \ref bgl_namedparameters "Named Parameters".
// * returns the number of connected components in the mesh.
// *
// * \tparam PolygonMesh a model of `FaceGraph`
// * \tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
// * A property map for `CGAL::face_index_t` must be either available as an internal property map
// * to `pmesh` or provided as one of the \ref bgl_namedparameters "Named Parameters".
// *
// * \param pmesh the polygon mesh
// * \param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
// * \tparam PolygonMesh a model of `FaceGraph`
// * \tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
// *
// * \param pmesh the polygon mesh
// * \param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
// *
// * \cgalNamedParamsBegin
// * \cgalParamNBegin{edge_is_constrained_map}
@ -296,6 +300,7 @@ namespace internal {
// *
// * \returns the output iterator.
// *
// * \see `connected_components()`
// */
template <typename PolygonMesh,
typename CGAL_NP_TEMPLATE_PARAMETERS>
@ -314,9 +319,10 @@ std::size_t number_of_connected_components(const PolygonMesh& pmesh,
} // 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
* 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
@ -375,6 +381,8 @@ std::size_t number_of_connected_components(const PolygonMesh& pmesh,
* \cgalNamedParamsEnd
*
* \return the number of connected components removed (ignoring isolated vertices).
*
* \see `keep_large_connected_components()`
*/
template <typename PolygonMesh,
typename NamedParameters = parameters::Default_named_parameters>
@ -458,12 +466,14 @@ std::size_t keep_largest_connected_components(PolygonMesh& pmesh,
}
/*!
* \ingroup keep_connected_components_grp
* removes connected components whose size is (strictly) smaller than a given threshold value,
* \ingroup PMP_keep_connected_components_grp
*
* \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
* 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 of faces it contains), but it is also possible
* to pass custom sizes, such as the area of the face.
* 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
* 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 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`.
*
* \return the number of connected components removed (ignoring isolated vertices).
*
* \see `keep_largest_connected_components()`
*/
template <typename PolygonMesh,
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`,
* and removes the other connected components as well as all isolated vertices.
* The connected component id of a face is given by `fcm`.
@ -770,6 +783,7 @@ void keep_or_remove_connected_components(PolygonMesh& pmesh
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* \see `remove_connected_components()`
*/
template <typename PolygonMesh
, 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
* in `components_to_remove` as well as all isolated vertices.
* The connected component id of a face is given by `fcm`.
@ -814,6 +829,7 @@ void keep_connected_components(PolygonMesh& pmesh
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* \see `keep_connected_components()`
*/
template <typename PolygonMesh
, typename ComponentRange
@ -829,9 +845,10 @@ void remove_connected_components(PolygonMesh& pmesh
}
/*!
* \ingroup keep_connected_components_grp
* keeps the connected components not designated by the faces in `components_to_remove`,
* and removes the other connected components and all isolated vertices.
* \ingroup PMP_keep_connected_components_grp
*
* keeps the connected components not designated by the faces in `components_to_remove`,
* and removes the other connected components and all isolated vertices.
*
* \note If the removal of the connected components makes `pmesh` a non-manifold surface,
* then the behavior of this function is undefined.
@ -868,6 +885,7 @@ void remove_connected_components(PolygonMesh& pmesh
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* \see `keep_connected_components()`
*/
template <typename PolygonMesh
, typename FaceRange
@ -899,9 +917,10 @@ void remove_connected_components(PolygonMesh& pmesh
}
/*!
* \ingroup keep_connected_components_grp
* keeps the connected components designated by the faces in `components_to_keep`,
* and removes the other connected components and all isolated vertices.
* \ingroup PMP_keep_connected_components_grp
*
* keeps the connected components designated by the faces in `components_to_keep`,
* and removes the other connected components and all isolated vertices.
*
* \note If the removal of the connected components makes `pmesh` a non-manifold surface,
* then the behavior of this function is undefined.
@ -938,6 +957,7 @@ void remove_connected_components(PolygonMesh& pmesh
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* \see `remove_connected_components()`
*/
template <typename PolygonMesh
, typename FaceRange
@ -1027,16 +1047,18 @@ void split_connected_components_impl(FIMap fim,
}//internal
/*!
* \ingroup keep_connected_components_grp
* identifies the connected components of `pmesh` and pushes back a new `PolygonMesh` for each connected component in `cc_meshes`.
* \ingroup PMP_keep_connected_components_grp
*
* \tparam PolygonMesh a model of `FaceListGraph`
* \tparam PolygonMeshRange a model of `SequenceContainer` with `PolygonMesh` as value type.
* identifies the connected components of `pmesh` and pushes back a new `PolygonMesh`
* for each connected component in `cc_meshes`.
*
* \tparam NamedParameters a sequence of Named Parameters
* \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
*
* \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
*
* \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
*
* \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
* \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(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 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`
@ -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(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 NamedParameters2 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(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 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
* 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
*
* @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.
* \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
*
* @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
*
* 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.
* 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.
@ -261,6 +262,7 @@ void sharp_call(const FT angle_in_deg,
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* \see `sharp_edges_segmentation()`
*/
#ifdef DOXYGEN_RUNNING
template <typename PolygonMesh, typename FT,
@ -299,13 +301,13 @@ void detect_sharp_edges(const PolygonMesh& pmesh,
*
* \tparam PolygonMesh a model of `HalfedgeListGraph`
* \tparam PatchIdMap a model of `ReadablePropertyMap` with
`boost::graph_traits<PolygonMesh>::%face_descriptor` as key type
and the desired patch id, model of `CopyConstructible` as value type.
* `boost::graph_traits<PolygonMesh>::%face_descriptor` as key type
* and the desired patch id, model of `CopyConstructible` as value type.
* \tparam VertexIncidentPatchesMap a model of mutable `LvaluePropertyMap` with
`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()`.
A `std::set` or a `boost::unordered_set` are recommended, as a patch index may be
inserted several times.
* `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()`.
* A `std::set` or a `boost::unordered_set` are recommended, as a patch index may be
* inserted several times.
* \tparam EdgeIsFeatureMap a model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%edge_descriptor`
* 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 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,
@ -369,12 +371,11 @@ void vip_call(const PolygonMesh&, PIDMap, const internal_np::Param_not_found&, E
* \ingroup PMP_detect_features_grp
*
* 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()`
*
* 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
* computing a
* The sharp edges define a segmentation of `pmesh`, that is done by computing a
* surface patch id for each face.
*
* \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`.
* \tparam EdgeIsFeatureMap a model of `ReadWritePropertyMap` with `boost::graph_traits<PolygonMesh>::%edge_descriptor`
* \tparam PatchIdMap a model of `ReadWritePropertyMap` with
`boost::graph_traits<PolygonMesh>::%face_descriptor` as key type
and the desired patch id, model of `CopyConstructible` as value type.
* `boost::graph_traits<PolygonMesh>::%face_descriptor` as key type
* and the desired patch id, model of `CopyConstructible` as value type.
* \tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
*
* \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 NamedParameters2 a sequence of \ref bgl_namedparameters "Named Parameters" for `OutputMesh`
*
* @param input an open surface mesh to extrude.
* @param output a surface mesh that will contain the result of the extrusion.
* @param input an open surface mesh to extrude
* @param output a surface mesh that will contain the result 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
*
@ -280,11 +280,11 @@ template <class InputMesh,
class CGAL_NP_TEMPLATE_PARAMETERS_2>
void extrude_mesh(const InputMesh& input,
OutputMesh& output,
#ifdef DOXYGEN_RUNNING
#ifdef DOXYGEN_RUNNING
Vector_3 v,
#else
#else
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_2& np_out = parameters::default_values())
{
@ -294,8 +294,7 @@ void extrude_mesh(const InputMesh& input,
extrude_impl::Const_dist_translation<
typename GetVertexPointMap<OutputMesh, CGAL_NP_CLASS_2>::type,
typename GetGeomTraits<OutputMesh, CGAL_NP_CLASS_2>::type::Vector_3> bot(output_vpm,
v);
typename GetGeomTraits<OutputMesh, CGAL_NP_CLASS_2>::type::Vector_3> bot(output_vpm, v);
extrude_impl::Identity_functor top;
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
@brief fairs a region on a triangle mesh.
The points of the selected vertices are
relocated to yield an as-smooth-as-possible surface patch,
based on solving a linear bi-Laplacian system with boundary constraints,
@ -114,11 +116,11 @@ namespace internal {
\cgalParamNEnd
\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)`
@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.
*/

95
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
/*
/* \ingroup PMP_intersection_grp
*
* reports all the pairs of faces intersecting between two triangulated surface meshes.
* 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
/*
/* \ingroup PMP_intersection_grp
*
* reports all the pairs of segments and faces intersecting between
* 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.
*
* \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)`
*
* \tparam TriangleMesh a model of `FaceListGraph`
@ -518,11 +521,11 @@ template <class TriangleMesh,
class OutputIterator,
class NamedParameters>
OutputIterator
compute_face_polyline_intersection( const FaceRange& face_range,
const Polyline& polyline,
const TriangleMesh& tm,
OutputIterator out,
const NamedParameters& np)
compute_face_polyline_intersection(const FaceRange& face_range,
const Polyline& polyline,
const TriangleMesh& tm,
OutputIterator out,
const NamedParameters& np)
{
using parameters::choose_parameter;
using parameters::get_parameter;
@ -596,12 +599,14 @@ compute_face_polyline_intersection( const FaceRange& face_range,
}
// Note this is not officially documented
/*
/* \ingroup PMP_intersection_grp
*
* reports all the pairs of segments and faces intersecting between
* 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
* 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)`
*
@ -743,11 +748,14 @@ compute_face_polylines_intersection(const FaceRange& face_range,
}
// Note this is not officially documented
/*
/* \ingroup PMP_intersection_grp
*
* detects and records intersections between two polylines.
* This function depends on the package \ref PkgBoxIntersectionD.
*
* \attention If a polyline vertex intersects another polyline, the intersection will
* be reported twice (even more if it is on a vertex).
*
* \tparam Polyline a `RandomAccessRange` of points.
* \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
@ -818,12 +826,14 @@ compute_polyline_polyline_intersection(const Polyline& polyline1,
}
// Note this is not officially documented
/*
/* \ingroup PMP_intersection_grp
*
* detects and records intersections between two ranges of polylines.
* \attention If a polyline vertex intersects another polyline, the intersection will
* be reported twice (even more if it is on a vertex).
* This function depends on the package \ref PkgBoxIntersectionD.
*
* \attention If a polyline vertex intersects another polyline, the intersection will
* be reported twice (even more if it is on a vertex).
*
* \tparam PolylineRange a `RandomAccessRange` of `RandomAccessRange` of points.
* \tparam OutputIterator a model of `OutputIterator` holding objects of type
* `std::pair<std::pair<std::size_t, std::size_t>, std::pair<std::size_t, std::size_t> >`.
@ -925,7 +935,8 @@ compute_polylines_polylines_intersection(const PolylineRange& polylines1,
}
// Note this is not officially documented
/*
/* \ingroup PMP_intersection_grp
*
* reports all the pairs of faces intersecting between two triangulated surface meshes.
* This function depends on the package \ref PkgBoxIntersectionD.
*
@ -980,13 +991,14 @@ compute_face_face_intersection(const TriangleMesh& tm1,
}
// Note this is not officially documented
/*
* detects and records intersections between a triangulated surface mesh
* and a polyline.
* \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).
/* \ingroup PMP_intersection_grp
*
* 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
* be reported twice (even more if it is on a vertex, edge, or point).
*
* \pre `CGAL::is_triangle_mesh(tm)`
*
* \tparam TriangleMesh a model of `FaceListGraph`
@ -995,7 +1007,7 @@ compute_face_face_intersection(const TriangleMesh& tm1,
* \cgalDescribePolylineType
* \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
* elements in their respective range. In the case of the polyline, this position is the index
* elements in their respective range. In the case of the polyline, this position is the index
* of the segment that holds the intersection, so it is the index of the first point of the
* segment following the range order.
* \tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
@ -1030,14 +1042,13 @@ template <class TriangleMesh,
class NamedParameters>
OutputIterator
compute_face_polyline_intersection(const TriangleMesh& tm,
const Polyline& polyline,
OutputIterator out,
const NamedParameters& np)
const Polyline& polyline,
OutputIterator out,
const NamedParameters& np)
{
return compute_face_polyline_intersection(faces(tm), polyline, tm, out, np);
}
// functions to check for overlap of meshes
template <class GT, class TriangleMesh, class VPM>
void get_one_point_per_cc(TriangleMesh& tm,
@ -1114,7 +1125,8 @@ bool is_mesh2_in_mesh1(const TriangleMesh& tm1,
}// namespace internal
/**
* \ingroup PMP_predicates_grp
* \ingroup PMP_intersection_grp
*
* 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.
* 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,
* and `false` otherwise.
* This function depends on the package \ref PkgBoxIntersectionD.
@ -1203,9 +1216,12 @@ bool do_intersect(const Polyline& polyline1,
}
/**
* \ingroup PMP_predicates_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.
* \ingroup PMP_intersection_grp
*
* \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.
*
* @pre `CGAL::is_triangle_mesh(tm1)`
@ -1249,6 +1265,7 @@ bool do_intersect(const Polyline& polyline1,
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* \see `intersecting_meshes()`
*/
template <class TriangleMesh,
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,
* and `false` otherwise.
* This function depends on the package \ref PkgBoxIntersectionD.
*
* @pre `CGAL::is_triangle_mesh(tm)`
*
* \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.
* This function depends on the package \ref PkgBoxIntersectionD.
*
* @pre `CGAL::is_triangle_mesh(tm)`
*
* \tparam TriangleMesh a model of `FaceListGraph`
@ -1551,7 +1572,8 @@ struct Mesh_callback
}//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.
* 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.
@ -1596,8 +1618,9 @@ struct Mesh_callback
* \cgalParamExtra{All vertex point maps must have the same value type}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* \see `do_intersect()`
*/
template <class TriangleMeshRange,
class OutputIterator,
class NamedParameters,
@ -1659,6 +1682,7 @@ OutputIterator intersecting_meshes(const TriangleMeshRange& range,
/**
* \ingroup PMP_corefinement_grp
*
* 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.
*
@ -1700,6 +1724,7 @@ OutputIterator intersecting_meshes(const TriangleMeshRange& range,
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* \see `do_intersect()`
*/
template <class OutputIterator,
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 {
/// \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`
///
/// @param v a vertex of `pm`
/// @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()`
///
/// \return `true` if the vertex is non-manifold, `false` otherwise.
template <typename PolygonMesh>
bool is_non_manifold_vertex(typename boost::graph_traits<PolygonMesh>::vertex_descriptor v,
const PolygonMesh& pm)
@ -283,10 +285,13 @@ std::size_t make_umbrella_manifold(typename boost::graph_traits<PolygonMesh>::ha
} // end namespace internal
/// \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
/// (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`).
///
/// \brief 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 (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 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 out the output iterator that collects halfedges incident to `v`
///
/// \return the output iterator
///
/// \sa `is_non_manifold_vertex()`
/// \sa `duplicate_non_manifold_vertices()`
///
/// \return the output iterator.
template <typename PolygonMesh, typename OutputIterator>
OutputIterator non_manifold_vertices(const PolygonMesh& pm,
OutputIterator out)
@ -390,6 +395,7 @@ OutputIterator non_manifold_vertices(const PolygonMesh& pm,
}
/// \ingroup PMP_repairing_grp
///
/// duplicates all the non-manifold vertices of the input mesh.
///
/// @tparam PolygonMesh a model of `HalfedgeListGraph` and `MutableHalfedgeGraph`
@ -426,7 +432,9 @@ OutputIterator non_manifold_vertices(const PolygonMesh& pm,
/// \cgalParamNEnd
/// \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>
std::size_t duplicate_non_manifold_vertices(PolygonMesh& pm,
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
/**
* \ingroup measure_grp
* \ingroup PMP_measure_grp
*
* computes the length of an edge of a given polygon mesh.
* 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
* \cgalNamedParamsEnd
*
* @return the length of `h`. The return type `FT` is a number type. It is
* 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 `pmesh`.
* @return the length of `h`. The return type `FT` is a number type 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 `pmesh`.
*
* \warning This function involves a 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.
* 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
* \cgalNamedParamsEnd
*
* @return the squared length of `h`. The return type `FT` is a number type. It is
* 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 `pmesh`.
* @return the squared length of `h`. The return type `FT` is a number type 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 `pmesh`.
*
* @sa `edge_length()`
* @sa `face_border_length()`
@ -212,9 +212,9 @@ squared_edge_length(typename boost::graph_traits<PolygonMesh>::edge_descriptor e
}
/**
* \ingroup measure_grp
* computes the length of the border polyline
* that contains a given halfedge.
* \ingroup PMP_measure_grp
*
* computes the length of the border polyline that contains a given halfedge.
*
* @tparam PolygonMesh a model of `HalfedgeGraph`
* @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
*
* @return the length of the sequence of border edges of `face(h, pmesh)`.
* The return type `FT` is a number type. It is
* 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 `pmesh`.
* The return type `FT` is a number type 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 `pmesh`.
*
* \warning This function involves a 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
* 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 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
* deduced from the graph traits corresponding to the type `PolygonMesh`.
* - `second`: the length of the longest border
* The return type `FT` is a number type. It is
* 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 `pmesh`
* The return type `FT` is a number type 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 `pmesh`
*
* @see `face_border_length()`
*/
template<typename PolygonMesh,
typename NamedParameters = parameters::Default_named_parameters>
@ -317,7 +317,7 @@ template<typename PolygonMesh,
std::pair<halfedge_descriptor, FT>
#else
std::pair<typename boost::graph_traits<PolygonMesh>::halfedge_descriptor,
typename GetGeomTraits<PolygonMesh, NamedParameters>::type::FT>
typename GetGeomTraits<PolygonMesh, NamedParameters>::type::FT>
#endif
longest_border(const PolygonMesh& pmesh,
const NamedParameters& np = parameters::default_values())
@ -354,9 +354,9 @@ longest_border(const PolygonMesh& pmesh,
}
/**
* \ingroup measure_grp
* computes the area of a face of a given
* triangulated surface mesh.
* \ingroup PMP_measure_grp
*
* computes the area of a face of a given triangulated surface mesh.
*
* @tparam TriangleMesh a model of `FaceGraph`
* @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()`
*
* @return the area of `f`.
* The return type `FT` is a number type. It is
* 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`.
* The return type `FT` is a number type 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`.
*
* \warning This function involves a 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
* computes the squared area of a face of a given
* triangulated surface mesh.
* \ingroup PMP_measure_grp
*
* computes the squared area of a face of a given triangulated surface mesh.
*
* @tparam TriangleMesh a model of `FaceGraph`
* @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()`
*
* @return the squared area of `f`.
* The return type `FT` is a number type. It is
* 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`.
* The return type `FT` is a number type 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`.
*
* @sa `face_area()`
*/
@ -502,9 +500,9 @@ squared_face_area(typename boost::graph_traits<TriangleMesh>::face_descriptor f,
}
/**
* \ingroup measure_grp
* computes the area of a range of faces of a given
* triangulated surface mesh.
* \ingroup PMP_measure_grp
*
* computes the area of a range of faces of a given triangulated surface mesh.
*
* @tparam FaceRange range of `boost::graph_traits<PolygonMesh>::%face_descriptor`,
model of `Range`.
@ -533,10 +531,9 @@ squared_face_area(typename boost::graph_traits<TriangleMesh>::face_descriptor f,
* \cgalNamedParamsEnd
*
* @return sum of face areas of `faces`.
* The return type `FT` is a number type. It is
* 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`.
* The return type `FT` is a number type 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`.
*
* \warning This function involves a 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.
*
* @tparam TriangleMesh a model of `FaceGraph`
@ -595,10 +592,9 @@ area(FaceRange face_range,
* \cgalNamedParamsEnd
*
* @return the surface area of `tmesh`.
* The return type `FT` is a number type. It is
* 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`.
* The return type `FT` is a number type 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`.
*
* \warning This function involves a square root computation.
* If `Kernel::FT` does not have a `sqrt()` operation, the square root computation
@ -613,15 +609,16 @@ FT
#else
typename GetGeomTraits<TriangleMesh, CGAL_NP_CLASS>::type::FT
#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);
}
/**
* \ingroup measure_grp
* computes the volume of the domain bounded by
* a closed triangulated surface mesh.
* \ingroup PMP_measure_grp
*
* computes the volume of the domain bounded by a closed triangulated surface mesh.
*
* @tparam TriangleMesh a model of `HalfedgeGraph`
* @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
*
* @return the volume bounded by `tmesh`.
* The return type `FT` is a number type. It is
* 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`.
* The return type `FT` is a number type 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`.
*/
template<typename TriangleMesh,
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.
*
* @tparam TriangleMesh a model of `HalfedgeGraph`
@ -721,10 +718,13 @@ volume(const TriangleMesh& tmesh,
*
* @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,
* 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,
typename CGAL_NP_TEMPLATE_PARAMETERS>
@ -803,9 +803,9 @@ face_aspect_ratio(typename boost::graph_traits<TriangleMesh>::face_descriptor f,
}
/**
* \ingroup measure_grp
* computes the centroid of a volume bounded by
* a closed triangulated surface mesh.
* \ingroup PMP_measure_grp
*
* computes the centroid of a volume bounded by a closed triangulated surface mesh.
*
* @tparam TriangleMesh a model of `FaceListGraph`
* @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
@ -839,7 +839,8 @@ Point_3
#else
typename GetGeomTraits<TriangleMesh, CGAL_NP_CLASS>::type::Point_3
#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
@ -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
* in both polygon meshes. Two faces are matching if they have the same
* 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 PolygonMesh2 a model of `HalfedgeListGraph` and `FaceListGraph`
* @tparam FaceOutputIterator1 model of `OutputIterator`
holding `boost::graph_traits<PolygonMesh1>::%face_descriptor`.
* holding `boost::graph_traits<PolygonMesh1>::%face_descriptor`.
* @tparam FaceOutputIterator2 model of `OutputIterator`
holding `boost::graph_traits<PolygonMesh2>::%face_descriptor`.
* holding `boost::graph_traits<PolygonMesh2>::%face_descriptor`.
* @tparam FacePairOutputIterator model of `OutputIterator`
holding `std::pair<boost::graph_traits<PolygonMesh1>::%face_descriptor,
boost::graph_traits<PolygonMesh2>::%face_descriptor`.
* holding `std::pair<boost::graph_traits<PolygonMesh1>::%face_descriptor,
* boost::graph_traits<PolygonMesh2>::%face_descriptor`.
*
* @tparam NamedParameters1 a sequence of \ref bgl_namedparameters "Named Parameters"
* @tparam NamedParameters2 a sequence of \ref bgl_namedparameters "Named Parameters"
*
* @param m1 the first `PolygonMesh`
* @param m2 the second `PolygonMesh`
* @param common output iterator collecting the faces that are common to both meshes.
* @param m1 the first polygon mesh
* @param m2 the second polygon mesh
* @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 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
@ -958,8 +960,11 @@ template< typename PolygonMesh1,
typename FaceOutputIterator2,
typename NamedParameters1 = parameters::Default_named_parameters,
typename NamedParameters2 = parameters::Default_named_parameters >
void match_faces(const PolygonMesh1& m1, const PolygonMesh2& m2,
FacePairOutputIterator common, FaceOutputIterator1 m1_only, FaceOutputIterator2 m2_only,
void match_faces(const PolygonMesh1& m1,
const PolygonMesh2& m2,
FacePairOutputIterator common,
FaceOutputIterator1 m1_only,
FaceOutputIterator2 m2_only,
const NamedParameters1& np1 = parameters::default_values(),
const NamedParameters2& np2 = parameters::default_values())
{

19
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;
};
// 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.
// This is done to ensure valid combinatorics when we merge the vertices.
// If incompatible (overlapping) intervals are found, the pair representating the longest
@ -205,6 +205,7 @@ void detect_identical_mergeable_vertices(
}
// \ingroup PMP_repairing_grp
//
// merges target vertices of a list of halfedges.
// Halfedges must be sorted in the list.
//
@ -259,6 +260,7 @@ void merge_vertices_in_range(const HalfedgeRange& sorted_hedges,
} // end of internal
/// \ingroup PMP_repairing_grp
///
/// merges identical vertices around a cycle of boundary edges.
///
/// @tparam PolygonMesh a model of `FaceListGraph` and `MutableFaceGraph`.
@ -277,11 +279,12 @@ void merge_vertices_in_range(const HalfedgeRange& sorted_hedges,
/// \cgalParamNEnd
/// \cgalNamedParamsEnd
///
template <class PolygonMesh, class NamedParameters = parameters::Default_named_parameters>
void merge_duplicated_vertices_in_boundary_cycle(
typename boost::graph_traits<PolygonMesh>::halfedge_descriptor h,
PolygonMesh& pm,
const NamedParameters& np = parameters::default_values())
/// \see `merge_duplicated_vertices_in_boundary_cycles()`
template <class PolygonMesh,
class NamedParameters = parameters::Default_named_parameters>
void merge_duplicated_vertices_in_boundary_cycle(typename boost::graph_traits<PolygonMesh>::halfedge_descriptor h,
PolygonMesh& pm,
const NamedParameters& np = parameters::default_values())
{
typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor halfedge_descriptor;
typedef typename GetVertexPointMap<PolygonMesh, NamedParameters>::const_type Vpm;
@ -315,6 +318,7 @@ void merge_duplicated_vertices_in_boundary_cycle(
}
/// \ingroup PMP_repairing_grp
///
/// extracts boundary cycles and merges the duplicated vertices of each cycle.
///
/// @tparam PolygonMesh a model of `FaceListGraph` and `MutableFaceGraph`.
@ -333,7 +337,8 @@ void merge_duplicated_vertices_in_boundary_cycle(
/// \cgalNamedParamsEnd
///
/// \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,
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
* 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,
* some points are duplicated.
* 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 `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,
PolygonRange& polygons,
const NamedParameters& np = parameters::default_values())

15
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
*
* duplicates each point \a p at which the intersection
* of an infinitesimally small ball centered at \a p
* with the polygons incident to it is not a topological disk.
@ -51,14 +52,17 @@ namespace Polygon_mesh_processing {
* non-manifoldness or non-orientability issues.
* @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.
*
* @return `false` if some points were duplicated, thus producing a self-intersecting surface mesh.
* @return `true` otherwise.
*
* @sa `orient_polygon_soup()`
* @sa `duplicate_non_manifold_vertices()`
*/
template <class PointRange, class PolygonRange>
bool
duplicate_non_manifold_edges_in_polygon_soup(PointRange& points,
PolygonRange& polygons)
PolygonRange& polygons)
{
std::size_t inital_nb_pts = points.size();
typedef CGAL::Polygon_mesh_processing::internal::
@ -115,10 +119,13 @@ duplicate_non_manifold_edges_in_polygon_soup(PointRange& points,
* \cgalNamedParamsEnd
*
* \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, class PointRange, class TriangleRange,
class TriangleMesh, class NamedParameters = parameters::Default_named_parameters>
template <class Concurrency_tag = Sequential_tag,
class PointRange, class TriangleRange,
class TriangleMesh,
class NamedParameters = parameters::Default_named_parameters>
void
orient_triangle_soup_with_reference_triangle_mesh(
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
* 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
* 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
* where its sequence of vertices is seen counterclockwise.
*
* @pre `CGAL::is_closed(tm)`
* @pre `CGAL::is_triangle_mesh(tm)`
* @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()`
*/
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,
const NamedParameters& np = parameters::default_values())
{
@ -259,9 +263,12 @@ void reverse_orientation(typename boost::graph_traits<PolygonMesh>::halfedge_des
/**
* \ingroup PMP_orientation_grp
*
* reverses for each face the order of the vertices along the face boundary.
*
* @tparam PolygonMesh a model of `FaceListGraph` and `MutableFaceGraph`
*
* @sa `is_outward_oriented()`
*/
template<typename PolygonMesh>
void reverse_face_orientations(PolygonMesh& pmesh)
@ -317,13 +324,16 @@ void reverse_face_orientations_of_mesh_with_polylines(PolygonMesh& pmesh)
/**
* \ingroup PMP_orientation_grp
*
* 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.
*
* @tparam PolygonMesh a model of `FaceListGraph` and `MutableFaceGraph`
* @tparam FaceRange range of face descriptors, model of `Range`.
* Its iterator type is `InputIterator`.
*
* @sa `is_outward_oriented()`
*/
template<typename PolygonMesh, typename FaceRange>
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
* 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
*
* @param tm a closed triangulated surface mesh
@ -394,7 +404,8 @@ void reverse_face_orientations(const FaceRange& face_range, PolygonMesh& pmesh)
* \cgalParamNEnd
* \cgalNamedParamsEnd
*/
template<class TriangleMesh, class NamedParameters = parameters::Default_named_parameters>
template<class TriangleMesh,
class NamedParameters = parameters::Default_named_parameters>
void orient(TriangleMesh& tm,
const NamedParameters& np = parameters::default_values())
{
@ -635,6 +646,7 @@ void set_cc_intersecting_pairs(
/*!
* \ingroup PMP_orientation_grp
*
* assigns to each face of `tm` an id corresponding to the volume connected component
* it contributes to.
*
@ -1215,7 +1227,7 @@ volume_connected_components(const TriangleMesh& tm,
* indicates if `tm` bounds a volume.
* 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"
*
* @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;
}
/** \ingroup PMP_orientation_grp
/*!
* \ingroup PMP_orientation_grp
*
* orients the connected components of `tm` to make it bound a volume.
* 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
*
* @param tm a closed triangulated surface mesh
@ -1385,11 +1398,12 @@ void orient_to_bound_a_volume(TriangleMesh& tm,
/*!
* \ingroup PMP_orientation_grp
*
* reverses the connected components of `tm` having compatible boundary cycles
* that could be merged if their orientation were made compatible, and stitches them.
* 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
*
* @param pm a surface mesh
@ -1422,7 +1436,8 @@ void orient_to_bound_a_volume(TriangleMesh& tm,
* \cgalParamNEnd
* \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,
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
*
* 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
* `CGAL::Polygon_mesh_processing::polygon_soup_to_polygon_mesh()`.
*
* 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,
* no polygon has twice the same vertex,
@ -164,7 +165,7 @@ private:
* @param polygons each element in the range describes a polygon
* using the indices of the vertices.
*
* @sa `orient_polygon_soup()`
* @sa `CGAL::Polygon_mesh_processing::orient_polygon_soup()`
*/
template<typename PolygonRange>
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
*
* builds a polygon mesh from a soup of polygons.
*
* @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
* @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.
* Note that no geometric checks are done after the perturbation
* (face orientation might become incorrect and self-intersections might be introduced).
* Note that no geometric checks are performed after the perturbation (self-intersections might be introduced).
*
* @tparam VertexRange model of `Range`, holding
* vertices of type `boost::graph_traits<TriangleMesh>::%vertex_descriptor`.
* 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"
*
* @param vertices the range of vertices to be perturbed
* @param tmesh the triangulated surface mesh
* @param perturbation_max_size the maximal length of moves that can be applied to
* vertices of `tmesh`.
* @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
@ -210,7 +210,55 @@ void random_perturbation(VertexRange vertices
/*!
* \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>
void random_perturbation(TriangleMesh& tmesh
@ -219,6 +267,7 @@ void random_perturbation(TriangleMesh& tmesh
{
random_perturbation(vertices(tmesh), tmesh, perturbation_max_size, np);
}
} //end namespace Polygon_mesh_processing
} //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
@brief refines a region of a triangle mesh.
@tparam TriangleMesh model of `MutableFaceGraph`
@ -83,7 +84,7 @@ namespace Polygon_mesh_processing {
using parameters::choose_parameter;
using parameters::get_parameter;
CGAL_precondition(is_triangle_mesh(tmesh) );
CGAL_precondition(is_triangle_mesh(tmesh));
typedef typename GetVertexPointMap<TriangleMesh,NamedParameters>::type VPmap;
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
*
* @brief remeshes a triangulated region of a polygon mesh.
* This operation sequentially performs edge splits, edge collapses,
* 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
*
* @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
* \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 {
/// \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
/// of higher dimension.
///
/// \brief removes the isolated vertices from any polygon mesh.
///
/// A vertex is considered isolated if it is not incident to any simplex of higher dimension.
///
/// @tparam PolygonMesh a model of `FaceListGraph` and `MutableFaceGraph`
///
/// @param pmesh the polygon mesh to be repaired
///
/// @return number of removed isolated vertices
///
/// @return the number of removed isolated vertices
template <class PolygonMesh>
std::size_t remove_isolated_vertices(PolygonMesh& pmesh)
{
@ -62,7 +62,7 @@ std::size_t remove_isolated_vertices(PolygonMesh& pmesh)
/// \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).
/// 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).
///
/// \sa `keep_connected_components()`
/// \sa `remove_connected_components()`
template <typename TriangleMesh,
typename NamedParameters = parameters::Default_named_parameters>
std::size_t remove_connected_components_of_negligible_size(TriangleMesh& tmesh,

46
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);
}
// \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>
bool remove_degenerate_edges(const EdgeRange& edge_range,
TriangleMesh& tmesh,
@ -1723,6 +1762,7 @@ bool remove_degenerate_edges(TriangleMesh& tmesh,
}
// \ingroup PMP_repairing_grp
//
// removes the degenerate faces from a triangulated surface mesh.
// A face is considered degenerate if two of its vertices share the same location,
// or more generally if all its vertices are collinear.
@ -1732,7 +1772,7 @@ bool remove_degenerate_edges(TriangleMesh& 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 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
@ -1753,7 +1793,7 @@ bool remove_degenerate_edges(TriangleMesh& tmesh,
// - `Collinear_3` to check whether 3 points are collinear
// - `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.}
// 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
@ -1763,6 +1803,8 @@ bool remove_degenerate_edges(TriangleMesh& tmesh,
// We should probably do something with the return type.
//
// \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>
bool remove_degenerate_faces(const FaceRange& face_range,
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}
// \cgalParamDescription{an instance of a geometric traits class}
// \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`}
// \cgalParamExtra{The geometric traits class must be compatible with the vertex point type.}
// \cgalParamNEnd
// \cgalNamedParamsEnd
//
// \sa `repair_polygon_soup()`
template <typename Traits, typename PointRange, typename PolygonRange>
std::size_t simplify_polygons_in_polygon_soup(PointRange& points,
PolygonRange& polygons,
@ -217,6 +218,7 @@ std::size_t simplify_polygons_in_polygon_soup(PointRange& points,
// \cgalParamNEnd
// \cgalNamedParamsEnd
//
// \sa `repair_polygon_soup()`
template <typename Traits, typename PointRange, typename PolygonRange>
std::size_t split_pinched_polygons_in_polygon_soup(PointRange& points,
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
// using the indices of the points in `points`.
//
// \sa `repair_polygon_soup()`
template <typename PointRange, typename PolygonRange>
std::size_t remove_invalid_polygons_in_polygon_soup(PointRange& /*points*/,
PolygonRange& polygons)
@ -358,6 +361,7 @@ std::size_t remove_invalid_polygons_in_polygon_soup(PointRange& /*points*/,
///
/// \returns the number of removed isolated points
///
/// \sa `repair_polygon_soup()`
template <typename PointRange, typename PolygonRange>
std::size_t remove_isolated_points_in_polygon_soup(PointRange& points,
PolygonRange& polygons)
@ -446,7 +450,8 @@ std::size_t remove_isolated_points_in_polygon_soup(PointRange& points,
/// \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
/// 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
///
/// \sa `repair_polygon_soup()`
template <typename PointRange, typename PolygonRange, typename NamedParameters = parameters::Default_named_parameters>
std::size_t merge_duplicate_points_in_polygon_soup(PointRange& points,
PolygonRange& polygons,
@ -770,6 +776,7 @@ struct Duplicate_collector<ValueType, CGAL::Emptyset_iterator>
// 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.
//
// \sa `repair_polygon_soup()`
template <typename PointRange, typename PolygonRange, typename DuplicateOutputIterator, typename Traits>
DuplicateOutputIterator collect_duplicate_polygons(const PointRange& points,
const PolygonRange& polygons,
@ -873,6 +880,7 @@ DuplicateOutputIterator collect_duplicate_polygons(const PointRange& points,
///
/// \returns the number of removed polygons
///
/// \sa `repair_polygon_soup()`
template <typename PointRange, typename PolygonRange, typename NamedParameters = parameters::Default_named_parameters>
std::size_t merge_duplicate_polygons_in_polygon_soup(const PointRange& points,
PolygonRange& polygons,
@ -974,8 +982,9 @@ std::size_t merge_duplicate_polygons_in_polygon_soup(const PointRange& points,
/// \ingroup PMP_repairing_grp
///
/// cleans a given polygon soup through various repairing operations. More precisely, this function
/// carries out the following tasks, in the same order as they are listed:
/// \brief cleans a given polygon soup through various repairing operations.
///
/// More precisely, this function carries out the following tasks, in the same order as they are listed:
/// - merging of duplicate points, using the function
/// `CGAL::Polygon_mesh_processing::merge_duplicate_points_in_polygon_soup()`;
/// - 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;
Intersecting_faces_limited_filter limited_intersect_faces(tmesh, vpmap, gt,
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);
}
catch (const CGAL::internal::Throw_at_output_exception&)
@ -404,6 +405,7 @@ self_intersections_impl(const FaceRange& face_range,
/*!
* \ingroup PMP_intersection_grp
*
* collects intersections between a subset of faces of a triangulated surface mesh.
* 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.
@ -451,6 +453,8 @@ self_intersections_impl(const FaceRange& face_range,
* \cgalNamedParamsEnd
*
* @return `out`
*
* @sa `does_self_intersect()`
*/
template < class ConcurrencyTag = Sequential_tag,
class TriangleMesh,
@ -468,6 +472,7 @@ self_intersections(const FaceRange& face_range,
/**
* \ingroup PMP_intersection_grp
*
* collects intersections between all the faces of a triangulated surface mesh.
* 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.
@ -516,6 +521,8 @@ self_intersections(const FaceRange& face_range,
* \cgalNamedParamsEnd
*
* @return `out`
*
* @sa `does_self_intersect()`
*/
template <class ConcurrencyTag = Sequential_tag,
class TriangleMesh,
@ -531,8 +538,11 @@ self_intersections(const TriangleMesh& tmesh,
/**
* \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
*
* @pre `CGAL::is_triangle_mesh(tmesh)`
*
* @tparam ConcurrencyTag enables sequential versus parallel algorithm.
@ -563,6 +573,8 @@ self_intersections(const TriangleMesh& tmesh,
* \cgalNamedParamsEnd
*
* @return `true` if the faces in `face_range` self-intersect
*
* @sa `self_intersections()`
*/
template <class ConcurrencyTag = Sequential_tag,
class FaceRange,
@ -599,8 +611,11 @@ bool does_self_intersect(const FaceRange& face_range,
/**
* \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
*
* @pre `CGAL::is_triangle_mesh(tmesh)`
*
* @tparam ConcurrencyTag enables sequential versus parallel algorithm.
@ -629,6 +644,8 @@ bool does_self_intersect(const FaceRange& face_range,
* \cgalNamedParamsEnd
*
* @return `true` if `tmesh` self-intersects
*
* @sa `self_intersections()`
*/
template <class ConcurrencyTag = Sequential_tag,
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 {
/// \ingroup PMP_repairing_grp
///
/// checks whether an edge is degenerate.
/// An edge is considered degenerate if the geometric positions of its two extremities are identical.
///
@ -63,9 +64,9 @@ namespace Polygon_mesh_processing {
/// \cgalParamNEnd
/// \cgalNamedParamsEnd
///
/// \sa `degenerate_edges()`
///
/// \return `true` if the edge `e` is degenerate, `false` otherwise.
///
/// \sa `degenerate_edges()`
template <typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters>
bool is_degenerate_edge(typename boost::graph_traits<PolygonMesh>::edge_descriptor e,
const PolygonMesh& pm,
@ -85,6 +86,7 @@ bool is_degenerate_edge(typename boost::graph_traits<PolygonMesh>::edge_descript
}
/// \ingroup PMP_repairing_grp
///
/// 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`
@ -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.}
/// \cgalParamNEnd
/// \cgalNamedParamsEnd
///
/// \sa `is_degenerate_edge()`
// \sa `remove_degenerate_edges()`
template <typename EdgeRange, typename TriangleMesh, typename OutputIterator, typename CGAL_NP_TEMPLATE_PARAMETERS>
OutputIterator degenerate_edges(const EdgeRange& edges,
const TriangleMesh& tm,
@ -130,10 +135,10 @@ OutputIterator degenerate_edges(const EdgeRange& edges,
}
/// \ingroup PMP_repairing_grp
///
/// 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>
OutputIterator degenerate_edges(const TriangleMesh& tm,
OutputIterator out,
@ -144,6 +149,7 @@ OutputIterator degenerate_edges(const TriangleMesh& tm,
}
/// \ingroup PMP_repairing_grp
///
/// checks whether a triangle face is degenerate.
/// 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
/// \cgalNamedParamsEnd
///
/// \sa `degenerate_faces()`
///
/// \return `true` if the face `f` is degenerate, `false` otherwise.
///
/// \sa `degenerate_faces()`
template <typename TriangleMesh, typename NamedParameters = parameters::Default_named_parameters>
bool is_degenerate_triangle_face(typename boost::graph_traits<TriangleMesh>::face_descriptor f,
const TriangleMesh& tm,
@ -229,6 +235,8 @@ bool is_degenerate_triangle_face(typename boost::graph_traits<TriangleMesh>::fac
/// \cgalParamNEnd
/// \cgalNamedParamsEnd
///
/// \sa `is_degenerate_triangle_face()`
// `\sa remove_degenerate_faces()`
template <typename FaceRange, typename TriangleMesh, typename OutputIterator, typename CGAL_NP_TEMPLATE_PARAMETERS>
OutputIterator degenerate_faces(const FaceRange& faces,
const TriangleMesh& tm,
@ -246,10 +254,10 @@ OutputIterator degenerate_faces(const FaceRange& faces,
}
/// \ingroup PMP_repairing_grp
///
/// 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>
OutputIterator degenerate_faces(const TriangleMesh& tm,
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.
/// 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>
typename boost::graph_traits<TriangleMesh>::halfedge_descriptor
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
///
/// \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>
typename boost::graph_traits<TriangleMesh>::halfedge_descriptor
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
*
* \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
* by moving (non-constrained) vertices.
@ -128,6 +128,8 @@ namespace Polygon_mesh_processing {
* to use area-based smoothing.
*
* @pre `tmesh` does not contain any degenerate faces
*
* @see `smooth_shape()`
*/
template<typename TriangleMesh, typename FaceRange, typename NamedParameters = parameters::Default_named_parameters>
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
* 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
* represents the amount by which vertices are allowed to move.
* The result conformally maps the initial surface to a sphere.
@ -93,7 +95,9 @@ namespace Polygon_mesh_processing {
* \cgalParamNEnd
* \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>
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
///
/// \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
/// 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
// 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.
/*!
@ -1242,6 +1242,8 @@ std::size_t stitch_boundary_cycles(PolygonMesh& pmesh,
*
* \return the number of pairs of halfedges that were stitched.
*
* \sa `stitch_boundary_cycle()`
* \sa `stitch_boundary_cycles()`
*/
template <typename PolygonMesh,
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
* 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 NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
*
@ -461,6 +463,8 @@ public:
* \cgalNamedParamsEnd
*
* @return `true` if the face has been triangulated.
*
* @see `triangulate_faces()`
*/
template<typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters>
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
* 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`,
model of `Range`.
Its iterator type is `InputIterator`.
* 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`, model of `Range`.
* Its iterator type is `InputIterator`.
* @tparam PolygonMesh a model of `FaceListGraph` and `MutableFaceGraph`
* @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.
*
* @see triangulate_face()
* @see `triangulate_face()`
*/
template <typename FaceRange, typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters>
bool triangulate_faces(FaceRange face_range,
@ -574,7 +578,9 @@ bool triangulate_faces(FaceRange face_range,
/**
* \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 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.
*
* @see triangulate_face()
* @see `triangulate_face()`
*/
template <typename PolygonMesh, typename NamedParameters = parameters::Default_named_parameters>
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 {
/*!
\ingroup hole_filling_grp
\ingroup PMP_hole_filling_grp
triangulates a hole in a polygon mesh.
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 {
/**
* \ingroup PkgPolygonMeshProcessingRef
* \ingroup PMP_predicates_grp
* This class provides an efficient point location functionality with respect to a domain bounded
* by one or several disjoint closed triangle meshes.
*