diff --git a/Polygon_mesh_processing/doc/Polygon_mesh_processing/PackageDescription.txt b/Polygon_mesh_processing/doc/Polygon_mesh_processing/PackageDescription.txt index 5d2addbde92..282472edb64 100644 --- a/Polygon_mesh_processing/doc/Polygon_mesh_processing/PackageDescription.txt +++ b/Polygon_mesh_processing/doc/Polygon_mesh_processing/PackageDescription.txt @@ -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 connected component 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()` diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/IO/polygon_mesh_io.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/IO/polygon_mesh_io.h index 7435f6fcc64..ca75594d6e9 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/IO/polygon_mesh_io.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/IO/polygon_mesh_io.h @@ -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`) diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/bbox.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/bbox.h index 21a1cab9a62..580dccecb52 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/bbox.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/bbox.h @@ -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 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 CGAL::Bbox_3 vertex_bbox(typename boost::graph_traits::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 CGAL::Bbox_3 edge_bbox(typename boost::graph_traits::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 CGAL::Bbox_3 face_bbox(typename boost::graph_traits::face_descriptor fd, @@ -233,8 +245,7 @@ namespace CGAL { typedef typename boost::graph_traits::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)) ); } diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/border.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/border.h index 4d23f1c86b2..78cb33ce2f9 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/border.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/border.h @@ -144,8 +144,10 @@ std::size_t border_size(typename boost::graph_traits::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::halfedge_desc * \cgalNamedParamsEnd * * @returns `out` + * + * @see `extract_boundary_cycles()` */ template::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::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 diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/clip.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/clip.h index 2a793ba1e4c..25bf9c91d15 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/clip.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/clip.h @@ -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 @@ -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 @@ -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 @@ -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 void split(TriangleMesh& tm, - #ifdef DOXYGEN_RUNNING +#ifdef DOXYGEN_RUNNING const Iso_cuboid_3& iso_cuboid, - #else +#else const typename GetGeomTraits::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)); diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/compute_normal.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/compute_normal.h index 4fabb08700f..0cee61cbada 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/compute_normal.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/compute_normal.h @@ -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 #ifdef DOXYGEN_RUNNING @@ -190,7 +193,9 @@ compute_face_normal(typename boost::graph_traits::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::%face_descriptor` as key type and @@ -221,6 +226,8 @@ compute_face_normal(typename boost::graph_traits::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 void compute_face_normals(const PolygonMesh& pmesh, @@ -604,7 +611,12 @@ compute_vertex_normal_as_sum_of_weighted_normals(typename boost::graph_traits #ifdef DOXYGEN_RUNNING @@ -723,6 +736,7 @@ compute_vertex_normal(typename boost::graph_traits::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::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 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 ::%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::%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 ::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::%face_descriptor` as key type and + * `boost::graph_traits::%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::%face_descriptor` as key type and - `boost::graph_traits::%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::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::%face_descriptor` @@ -191,8 +193,9 @@ connected_component(typename boost::graph_traits::face_descriptor s * \cgalNamedParamsEnd * * \returns the number of connected components. + * + * \see `connected_component()` */ - template @@ -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 @@ -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 ::%face_descriptor` as key type - and the desired patch id, model of `CopyConstructible` as value type. + * `boost::graph_traits::%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::%vertex_descriptor` as key type. Its value type - must be a container of `boost::property_traits::%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::%vertex_descriptor` as key type. Its value type + * must be a container of `boost::property_traits::%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::%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 ::%edge_descriptor` * \tparam PatchIdMap a model of `ReadWritePropertyMap` with - `boost::graph_traits::%face_descriptor` as key type - and the desired patch id, model of `CopyConstructible` as value type. + * `boost::graph_traits::%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 diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/extrude.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/extrude.h index 58152b0fad2..d0eb45cb2e7 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/extrude.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/extrude.h @@ -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 void extrude_mesh(const InputMesh& input, OutputMesh& output, - #ifdef DOXYGEN_RUNNING +#ifdef DOXYGEN_RUNNING Vector_3 v, - #else +#else typename GetGeomTraits::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::type, - typename GetGeomTraits::type::Vector_3> bot(output_vpm, - v); + typename GetGeomTraits::type::Vector_3> bot(output_vpm, v); extrude_impl::Identity_functor top; extrude_mesh(input, output, bot,top, np_in, np_out); } diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/fair.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/fair.h index b7255e6c388..a7c4f67aad9 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/fair.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/fair.h @@ -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. */ diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/intersection.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/intersection.h index fb65a38fedb..2fc0d96751c 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/intersection.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/intersection.h @@ -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 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`. 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 >`. @@ -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`. 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 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 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 `, * 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 bool is_non_manifold_vertex(typename boost::graph_traits::vertex_descriptor v, const PolygonMesh& pm) @@ -283,10 +285,13 @@ std::size_t make_umbrella_manifold(typename boost::graph_traits::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 umbrella 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 umbrella 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::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 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 std::size_t duplicate_non_manifold_vertices(PolygonMesh& pm, const NamedParameters& np = parameters::default_values()) diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/measure.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/measure.h index f84f6ec2c48..3be7564ac36 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/measure.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/measure.h @@ -57,7 +57,8 @@ inline void rearrange_face_ids(boost::container::small_vector& 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& 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::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::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::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::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::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::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 @@ -317,7 +317,7 @@ template #else std::pair::halfedge_descriptor, -typename GetGeomTraits::type::FT> + typename GetGeomTraits::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::%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::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::face_descriptor f, * @pre `f != boost::graph_traits::%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::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::%face_descriptor`, model of `Range`. @@ -533,10 +531,9 @@ squared_face_area(typename boost::graph_traits::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::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 @@ -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::%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 @@ -803,9 +803,9 @@ face_aspect_ratio(typename boost::graph_traits::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::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::%face_descriptor`. + * holding `boost::graph_traits::%face_descriptor`. * @tparam FaceOutputIterator2 model of `OutputIterator` - holding `boost::graph_traits::%face_descriptor`. + * holding `boost::graph_traits::%face_descriptor`. * @tparam FacePairOutputIterator model of `OutputIterator` - holding `std::pair::%face_descriptor, - boost::graph_traits::%face_descriptor`. + * holding `std::pair::%face_descriptor, + * boost::graph_traits::%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()) { diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/merge_border_vertices.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/merge_border_vertices.h index d188195b104..b0a97548d83 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/merge_border_vertices.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/merge_border_vertices.h @@ -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 -void merge_duplicated_vertices_in_boundary_cycle( - typename boost::graph_traits::halfedge_descriptor h, - PolygonMesh& pm, - const NamedParameters& np = parameters::default_values()) +/// \see `merge_duplicated_vertices_in_boundary_cycles()` +template +void merge_duplicated_vertices_in_boundary_cycle(typename boost::graph_traits::halfedge_descriptor h, + PolygonMesh& pm, + const NamedParameters& np = parameters::default_values()) { typedef typename boost::graph_traits::halfedge_descriptor halfedge_descriptor; typedef typename GetVertexPointMap::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 +template void merge_duplicated_vertices_in_boundary_cycles( PolygonMesh& pm, const NamedParameters& np = parameters::default_values()) { diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orient_polygon_soup.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orient_polygon_soup.h index 4621879ee1d..20187552973 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orient_polygon_soup.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orient_polygon_soup.h @@ -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 +template bool orient_polygon_soup(PointRange& points, PolygonRange& polygons, const NamedParameters& np = parameters::default_values()) diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orient_polygon_soup_extension.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orient_polygon_soup_extension.h index 98e3e45af81..cbba84b3f65 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orient_polygon_soup_extension.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orient_polygon_soup_extension.h @@ -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 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 +template void orient_triangle_soup_with_reference_triangle_mesh( const TriangleMesh& tm_ref, diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h index f209ddefb13..290c65ccebe 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h @@ -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 +template bool is_outward_oriented(const TriangleMesh& tm, const NamedParameters& np = parameters::default_values()) { @@ -259,9 +263,12 @@ void reverse_orientation(typename boost::graph_traits::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 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 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 +template 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 +template void merge_reversible_connected_components(PolygonMesh& pm, const NamedParameters& np = parameters::default_values()) { diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/polygon_soup_to_polygon_mesh.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/polygon_soup_to_polygon_mesh.h index 8aea03c4e96..45f76b3aa71 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/polygon_soup_to_polygon_mesh.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/polygon_soup_to_polygon_mesh.h @@ -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 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 diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/random_perturbation.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/random_perturbation.h index 4e78ce22c26..ffde3e90d83 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/random_perturbation.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/random_perturbation.h @@ -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::%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::%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::%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 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 diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/refine.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/refine.h index effb3fb7d3f..99dfd990136 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/refine.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/refine.h @@ -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::type VPmap; VPmap vpm = choose_parameter(get_parameter(np, internal_np::vertex_point), diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/remesh.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/remesh.h index 030864e6bbe..9e4a5912c82 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/remesh.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/remesh.h @@ -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} diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair.h index 2c60db87688..354f3df181e 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair.h @@ -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 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 std::size_t remove_connected_components_of_negligible_size(TriangleMesh& tmesh, diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair_degeneracies.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair_degeneracies.h index fb5f52785fd..3dbe662c104 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair_degeneracies.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair_degeneracies.h @@ -1202,6 +1202,45 @@ remove_a_border_edge(typename boost::graph_traits::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::%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 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 bool remove_degenerate_faces(const FaceRange& face_range, TriangleMesh& tmesh, diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair_polygon_soup.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair_polygon_soup.h index 54a7a171aa5..1c1f145774e 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair_polygon_soup.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair_polygon_soup.h @@ -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 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 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 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 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 std::size_t merge_duplicate_points_in_polygon_soup(PointRange& points, PolygonRange& polygons, @@ -770,6 +776,7 @@ struct Duplicate_collector // 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 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 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; diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/self_intersections.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/self_intersections.h index 1f7ccc69ffa..4f7de944b48 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/self_intersections.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/self_intersections.h @@ -386,7 +386,8 @@ self_intersections_impl(const FaceRange& face_range, typedef internal::Strict_intersect_faces > 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(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 bool is_degenerate_edge(typename boost::graph_traits::edge_descriptor e, const PolygonMesh& pm, @@ -85,6 +86,7 @@ bool is_degenerate_edge(typename boost::graph_traits::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::%edge_descriptor` @@ -114,6 +116,9 @@ bool is_degenerate_edge(typename boost::graph_traits::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 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 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 bool is_degenerate_triangle_face(typename boost::graph_traits::face_descriptor f, const TriangleMesh& tm, @@ -229,6 +235,8 @@ bool is_degenerate_triangle_face(typename boost::graph_traits::fac /// \cgalParamNEnd /// \cgalNamedParamsEnd /// +/// \sa `is_degenerate_triangle_face()` +// `\sa remove_degenerate_faces()` template 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 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 boost::graph_traits::halfedge_descriptor is_needle_triangle_face(typename boost::graph_traits::face_descriptor f, @@ -388,6 +398,8 @@ is_needle_triangle_face(typename boost::graph_traits::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 boost::graph_traits::halfedge_descriptor is_cap_triangle_face(typename boost::graph_traits::face_descriptor f, diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/smooth_mesh.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/smooth_mesh.h index 630bb83b09a..5049a671e6b 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/smooth_mesh.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/smooth_mesh.h @@ -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 void smooth_mesh(const FaceRange& faces, diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/smooth_shape.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/smooth_shape.h index a8ff2ce530c..9fc55050273 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/smooth_shape.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/smooth_shape.h @@ -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 void smooth_shape(const FaceRange& faces, diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/stitch_borders.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/stitch_borders.h index f2b20bf7c5b..49c3fa8b49a 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/stitch_borders.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/stitch_borders.h @@ -1088,7 +1088,8 @@ std::size_t stitch_boundary_cycle(const typename boost::graph_traits bool triangulate_face(typename boost::graph_traits::face_descriptor f, @@ -497,11 +501,11 @@ bool triangulate_face(typename boost::graph_traits::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::%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::%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::face_descriptor * * @return `true` if all the faces have been triangulated. * -* @see triangulate_face() +* @see `triangulate_face()` */ template 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 bool triangulate_faces(PolygonMesh& pmesh, diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/triangulate_hole.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/triangulate_hole.h index 9ad9ce6ab7c..509ce1a8b3e 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/triangulate_hole.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/triangulate_hole.h @@ -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. diff --git a/Polygon_mesh_processing/include/CGAL/Side_of_triangle_mesh.h b/Polygon_mesh_processing/include/CGAL/Side_of_triangle_mesh.h index c634e2a1fe7..89e28153408 100644 --- a/Polygon_mesh_processing/include/CGAL/Side_of_triangle_mesh.h +++ b/Polygon_mesh_processing/include/CGAL/Side_of_triangle_mesh.h @@ -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. *