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

Update PMP NPs to new macros

This commit is contained in:
Mael Rouxel-Labbé 2020-03-29 17:16:50 +02:00
parent 497f703077
commit e7d52999a8
68 changed files with 2580 additions and 1330 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
BGL/include/CGAL/boost/graph/Face_filtered_graph.h
View File

@ -117,7 +117,7 @@ struct Face_filtered_graph
* \param face_patch_index_map the property_map that assigns a patch index to each face, with
`face_descriptor` as key type and `boost::graph_traits<Graph>::%faces_size_type` as value type.
* \param selected_face_patch_indices a range of the face patch indices to select.
* \param np optional sequence of named parameters among the ones listed below
* \param np an optional sequence of named parameters among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{face_index_map}
@ -177,7 +177,7 @@ struct Face_filtered_graph
`face_descriptor` as key type and
`graph_traits<Graph>::%faces_size_type` as value type.
* \param selected_face_patch_index the index of the face patch selected.
* \param np optional sequence of named parameters among the ones listed below
* \param np an optional sequence of named parameters among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{face_index_map}
@ -223,7 +223,7 @@ struct Face_filtered_graph
* \tparam NamedParameters a sequence of named parameters
* \param graph the graph containing the wanted patch.
* \param selected_faces the set of selected faces.
* \param np optional sequence of named parameters among the ones listed below
* \param np an optional sequence of named parameters among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{face_index_map}

2
BGL/include/CGAL/boost/graph/METIS/partition_dual_graph.h
View File

@ -135,7 +135,7 @@ void partition_dual_graph(const TriangleMesh& tm, int nparts,
///
/// \param tm a triangle mesh
/// \param nparts the number of parts in the final partition
/// \param np optional \ref bgl_namedparameters "Named Parameters" described below
/// \param np an optional \ref bgl_namedparameters "Named Parameters" described below
///
/// \tparam TriangleMesh is a model of the `FaceListGraph` concept.
/// \tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"

2
BGL/include/CGAL/boost/graph/METIS/partition_graph.h
View File

@ -167,7 +167,7 @@ void partition_graph(const TriangleMesh& tm, int nparts,
///
/// \param tm a triangle mesh
/// \param nparts the number of parts in the final partition
/// \param np optional \ref bgl_namedparameters "Named Parameters" described below
/// \param np an optional \ref bgl_namedparameters "Named Parameters" described below
///
/// \tparam TriangleMesh is a model of the `FaceListGraph` concept.
/// \tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"

4
BGL/include/CGAL/boost/graph/copy_face_graph.h
View File

@ -260,7 +260,7 @@ inline Emptyset_iterator make_functor(const internal_np::Param_not_found&)
\param sm the source mesh
\param tm the target mesh
\param np1 optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
\param np1 an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
\cgalNamedParamsBegin
\cgalParamBegin{vertex_point_map}
@ -291,7 +291,7 @@ inline Emptyset_iterator make_functor(const internal_np::Param_not_found&)
\cgalParamEnd
\cgalNamedParamsEnd
\param np2 optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
\param np2 an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
\cgalNamedParamsBegin
\cgalParamBegin{vertex_point_map}

2
BGL/include/CGAL/boost/graph/io.h
View File

@ -618,7 +618,7 @@ write_polys_points(std::ostream& os,
*
* \param os the stream used for writing.
* \param mesh the triangle mesh to be written.
* \param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the
* \param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the
* ones listed below
*
* \cgalNamedParamsBegin

2
Convex_hull_3/doc/Convex_hull_3/CGAL/convex_hull_3.h
View File

@ -49,7 +49,7 @@ void convex_hull_3(InputIterator first, InputIterator last, PolygonMesh& pm, con
*
* \param g the graph
* \param pm the `PolygonMesh` that will contain the convex hull
* \param np optional sequence of named parameters among the ones listed below
* \param np an optional sequence of named parameters among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `g`.

2
Point_set_processing_3/include/CGAL/IO/read_las_points.h
View File

@ -428,7 +428,7 @@ bool read_las_points_with_properties (std::istream& stream,
\param stream input stream.
\param output output iterator over points.
\param np optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `WritablePropertyMap` with value type `geom_traits::Point_3`.

2
Point_set_processing_3/include/CGAL/IO/read_off_points.h
View File

@ -45,7 +45,7 @@ namespace CGAL {
\param stream input stream.
\param output output iterator over points.
\param np optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `WritablePropertyMap` with value type `geom_traits::Point_3`.

2
Point_set_processing_3/include/CGAL/IO/read_ply_points.h
View File

@ -201,7 +201,7 @@ bool read_ply_points_with_properties (std::istream& stream,
\param stream input stream.
\param output output iterator over points.
\param np optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `WritablePropertyMap` with value type `geom_traits::Point_3`.

2
Point_set_processing_3/include/CGAL/IO/read_xyz_points.h
View File

@ -44,7 +44,7 @@ namespace CGAL {
\param stream input stream.
\param output output iterator over points.
\param np optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `WritablePropertyMap` with value type `geom_traits::Point_3`.

2
Point_set_processing_3/include/CGAL/IO/write_las_points.h
View File

@ -254,7 +254,7 @@ bool write_las_points_with_properties (std::ostream& stream, ///< output stream
\param stream output stream.
\param points input point range.
\param np optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `ReadablePropertyMap` with value type `geom_traits::Point_3`.

2
Point_set_processing_3/include/CGAL/IO/write_off_points.h
View File

@ -40,7 +40,7 @@ namespace CGAL {
\param stream output stream.
\param points input point range.
\param np optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `ReadablePropertyMap` with value type `geom_traits::Point_3`.

2
Point_set_processing_3/include/CGAL/IO/write_ply_points.h
View File

@ -159,7 +159,7 @@ write_ply_points_with_properties(
\param stream output stream.
\param points input point range.
\param np optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `ReadablePropertyMap` with value type `geom_traits::Point_3`.

2
Point_set_processing_3/include/CGAL/IO/write_xyz_points.h
View File

@ -40,7 +40,7 @@ namespace CGAL {
\param stream output stream.
\param points input point range.
\param np optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `ReadablePropertyMap` with value type `geom_traits::Point_3`.

4
Point_set_processing_3/include/CGAL/OpenGR/compute_registration_transformation.h
View File

@ -169,7 +169,7 @@ compute_registration_transformation(const PointRange1& range1, const PointRan
\param point_set_1 input point range used as reference.
\param point_set_2 input point range whose registration w.r.t. `point_set_1` will be computed.
\param np1 optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np1 an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `ReadablePropertyMap` whose key type
@ -237,7 +237,7 @@ compute_registration_transformation(const PointRange1& range1, const PointRan
model of `Kernel`\cgalParamEnd
\cgalNamedParamsEnd
\param np2 optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np2 an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `ReadablePropertyMap` whose key type

4
Point_set_processing_3/include/CGAL/OpenGR/register_point_sets.h
View File

@ -90,7 +90,7 @@ register_point_sets(const PointRange1& range1, PointRange2& range2,
\param point_set_1 input point range used as reference.
\param point_set_2 input point range whose registration w.r.t. `point_set_1` will be computed.
\param np1 optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np1 an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `ReadablePropertyMap` whose key type
@ -158,7 +158,7 @@ register_point_sets(const PointRange1& range1, PointRange2& range2,
model of `Kernel`\cgalParamEnd
\cgalNamedParamsEnd
\param np2 optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np2 an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `ReadablePropertyMap` whose key type

2
Point_set_processing_3/include/CGAL/bilateral_smooth_point_set.h
View File

@ -359,7 +359,7 @@ public:
\param points input point range.
\param k size of the neighborhood for the implicit surface patch fitting.
The larger the value is, the smoother the result will be.
\param np optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `ReadWritePropertyMap` with value type `geom_traits::Point_3`.

2
Point_set_processing_3/include/CGAL/compute_average_spacing.h
View File

@ -157,7 +157,7 @@ compute_average_spacing(const typename Kernel::Point_3& query, ///< 3D point who
\param points input point range.
\param k number of neighbors.
\param np optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `ReadablePropertyMap` with value type `geom_traits::Point_3`.

2
Point_set_processing_3/include/CGAL/edge_aware_upsample_point_set.h
View File

@ -293,7 +293,7 @@ update_new_point(
\param points input point range.
\param output iterator where output points and normals are put.
\param np optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `ReadablePropertyMap` with value type `geom_traits::Point_3`.

8
Point_set_processing_3/include/CGAL/estimate_scale.h
View File

@ -452,7 +452,7 @@ public:
\param points input point range.
\param queries range of locations where scale must be estimated
\param output iterator to store the computed scales
\param np optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `ReadablePropertyMap` with
@ -539,7 +539,7 @@ estimate_local_k_neighbor_scales(
its iterator is the key type of the named parameter `point_map`.
\param points input point range.
\param np optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `ReadablePropertyMap` with
@ -605,7 +605,7 @@ estimate_global_k_neighbor_scale(const PointRange& points)
\param points input point range.
\param queries range of locations where scale must be estimated
\param output iterator to store the computed scales
\param np optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `ReadablePropertyMap` with
@ -692,7 +692,7 @@ estimate_local_range_scales(
its iterator is the key type of the named parameter `point_map`.
\param points input point range.
\param np optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `ReadablePropertyMap` with

2
Point_set_processing_3/include/CGAL/grid_simplify_point_set.h
View File

@ -175,7 +175,7 @@ public:
\param points input point range.
\param epsilon tolerance value when merging 3D points.
\param np optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `ReadWritePropertyMap` with value type `geom_traits::Point_3`.

2
Point_set_processing_3/include/CGAL/hierarchy_simplify_point_set.h
View File

@ -123,7 +123,7 @@ namespace CGAL {
its iterator is the key type of the named parameter `point_map`.
\param points input point range.
\param np optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `ReadWritePropertyMap` with value type `geom_traits::Point_3`.

2
Point_set_processing_3/include/CGAL/jet_estimate_normals.h
View File

@ -159,7 +159,7 @@ jet_estimate_normal(const typename Kernel::Point_3& query, ///< point to compute
\param points input point range.
\param k number of neighbors
\param np optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `ReadablePropertyMap` with value type `geom_traits::Point_3`.

2
Point_set_processing_3/include/CGAL/jet_smooth_point_set.h
View File

@ -163,7 +163,7 @@ jet_smooth_point(
\param points input point range.
\param k number of neighbors
\param np optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `ReadablePropertyMap` with value type `geom_traits::Point_3`.

2
Point_set_processing_3/include/CGAL/mst_orient_normals.h
View File

@ -573,7 +573,7 @@ create_mst_graph(
\param points input point range.
\param k number of neighbors.
\param np optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `ReadablePropertyMap` with value type `geom_traits::Point_3`.

2
Point_set_processing_3/include/CGAL/pca_estimate_normals.h
View File

@ -149,7 +149,7 @@ pca_estimate_normal(const typename Kernel::Point_3& query, ///< point to compute
\param points input point range.
\param k number of neighbors
\param np optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin \cgalParamBegin{point_map} a model of
`ReadablePropertyMap` with value type `geom_traits::Point_3`. If

4
Point_set_processing_3/include/CGAL/pointmatcher/compute_registration_transformation.h
View File

@ -366,7 +366,7 @@ compute_registration_transformation(const PointRange1& range1, const PointRange2
the key type of the named parameter `point_map` in `NamedParameters2`.
\param point_set_1 input point range used as reference.
\param point_set_2 input point range whose registration w.r.t. `point_set_1` will be computed.
\param np1 optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np1 an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `ReadablePropertyMap` whose key type
is the value type of the iterator of `PointRange1` and whose value type is
@ -497,7 +497,7 @@ compute_registration_transformation(const PointRange1& range1, const PointRange2
\cgalNamedParamsEnd
\param np2 optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np2 an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `ReadablePropertyMap` whose key type
is the value type of the iterator of `PointRange2` and whose value type is

4
Point_set_processing_3/include/CGAL/pointmatcher/register_point_sets.h
View File

@ -49,7 +49,7 @@ namespace pointmatcher {
\param point_set_1 input point range used as reference.
\param point_set_2 input point range whose registration w.r.t. `point_set_1` will be computed.
\param np1 optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np1 an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `ReadablePropertyMap` whose key type
@ -179,7 +179,7 @@ namespace pointmatcher {
model of `Kernel`\cgalParamEnd
\cgalNamedParamsEnd
\param np2 optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np2 an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `ReadablePropertyMap` whose key type
is the value type of the iterator of `PointRange2` and whose value type is

2
Point_set_processing_3/include/CGAL/remove_outliers.h
View File

@ -100,7 +100,7 @@ compute_avg_knn_sq_distance_3(
\param points input point range.
\param k number of neighbors
\param np optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `ReadablePropertyMap` with value type `geom_traits::Point_3`.

4
Point_set_processing_3/include/CGAL/structure_point_set.h
View File

@ -164,7 +164,7 @@ public:
\param points input point range.
\param planes input plane range.
\param epsilon size parameter.
\param np optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `ReadablePropertyMap` with value type `Kernel::Point_3`.
@ -1491,7 +1491,7 @@ private:
\param planes input plane range.
\param output output iterator where output points are written
\param epsilon size parameter.
\param np optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `ReadablePropertyMap` with value type `geom_traits::Point_3`.

6
Point_set_processing_3/include/CGAL/vcm_estimate_normals.h
View File

@ -235,7 +235,7 @@ vcm_convolve (ForwardIterator first,
\param ccov output range of covariance matrices.
\param offset_radius offset_radius.
\param convolution_radius convolution_radius.
\param np optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `ReadablePropertyMap` with value type `geom_traits::Point_3`.
@ -398,7 +398,7 @@ vcm_estimate_normals_internal (PointRange& points,
\param points input point range.
\param offset_radius offset_radius.
\param convolution_radius convolution_radius.
\param np optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `ReadablePropertyMap` with value type `geom_traits::Point_3`.
@ -457,7 +457,7 @@ vcm_estimate_normals (PointRange& points,
\param points input point range.
\param offset_radius offset_radius.
\param k number of neighbor points used for convolution.
\param np optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `ReadablePropertyMap` with value type `geom_traits::Point_3`.

2
Point_set_processing_3/include/CGAL/wlop_simplify_and_regularize_point_set.h
View File

@ -420,7 +420,7 @@ public:
\param points input point range.
\param output iterator where output points are put.
\param np optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np an optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `ReadWritePropertyMap` with value type `geom_traits::Point_3`.

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

@ -46,18 +46,24 @@ namespace CGAL {
* @tparam NamedParameters a sequence of \ref pmp_namedparameters "Named Parameters"
*
* @param pmesh a polygon mesh
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `PolygonMesh`\cgalParamEnd
* \cgalParamBegin{geom_traits} 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)` where `Point_3` is the value type
* of the vertex point map.
* \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `pmesh`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, pmesh)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* must be available in `PolygonMesh`.}
* \cgalParamNEnd
*
* \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)`
* where `%Point_3` is the value type of the vertex point map.}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* @return a bounding box of `pmesh`
@ -96,18 +102,24 @@ namespace CGAL {
*
* @param vd a descriptor of a vertex in `pmesh`
* @param pmesh a polygon mesh
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `PolygonMesh`\cgalParamEnd
* \cgalParamBegin{geom_traits} 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)` where `Point_3` is the value type
* of the vertex point map.
* \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `pmesh`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, pmesh)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* must be available in `PolygonMesh`.}
* \cgalParamNEnd
*
* \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)`
* where `%Point_3` is the value type of the vertex point map.}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* @return a bounding box of `pmesh`
@ -139,18 +151,24 @@ namespace CGAL {
*
* @param ed a descriptor of an edge in `pmesh`
* @param pmesh a polygon mesh
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `PolygonMesh`\cgalParamEnd
* \cgalParamBegin{geom_traits} 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)` where `Point_3` is the value type
* of the vertex point map.
* \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `pmesh`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, pmesh)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* must be available in `PolygonMesh`.}
* \cgalParamNEnd
*
* \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)`
* where `%Point_3` is the value type of the vertex point map.}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* @return a bounding box of `pmesh`
@ -184,18 +202,25 @@ namespace CGAL {
*
* @param fd a descriptor of a face in `pmesh`
* @param pmesh a polygon mesh
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `PolygonMesh`\cgalParamEnd
* \cgalParamBegin{geom_traits} 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)` where `Point_3` is the value type
* of the vertex point map.
* \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `pmesh`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, pmesh)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* must be available in `PolygonMesh`.}
* \cgalParamNEnd
*
* \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)`
* where `%Point_3` is the value type of the vertex point map.}
* \cgalParamDefault{a \cgal Kernel deduced from the point type, using `CGAL::Kernel_traits`}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* @return a bounding box of `pmesh`

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

@ -161,11 +161,16 @@ std::size_t border_size(typename boost::graph_traits<PolygonMesh>::halfedge_desc
* are collected
* @param out the output iterator that collects the border halfedges of the patch,
* seen from outside.
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* \cgalNamedParamsBegin
\cgalParamBegin{face_index_map} a property map containing the index of each face of `pmesh` \cgalParamEnd
\cgalNamedParamsEnd
* \cgalParamNBegin{face_index_map}
* \cgalParamDescription{a property map associating to each face of `pmesh` a unique index between `0` and `num_faces(pmesh) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%face_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* @returns `out`
*/

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

@ -428,16 +428,20 @@ void split_along_edges(TriangleMesh& tm,
* \cgalNamedParamsBegin
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tm` (resp. `clipper`)}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor` as key type and `%Point_3` as value type}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm (resp. clipper))`}
* \cgalParamExtra{if this parameter is omitted an internal property map for `CGAL::vertex_point_t` must be available in `TriangleMesh`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* must be available in `TriangleMesh`.}
* \cgalParamNEnd
*
* \cgalParamNBegin{face_index_map}
* \cgalParamDescription{a property map associating to each face of `tm` (`clipper`) a unique index between `0` and `num_faces(tm (resp. clipper)) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%face_descriptor` as key type and `std::size_t` as value type}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%face_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamExtra{if the property map is writable, the indices of the faces of `tm` and `clipper` will be set after refining `tm` with the intersection with `clipper`}
* \cgalParamExtra{if the property map is writable, the indices of the faces of `tm` and `clipper`
* will be set after refining `tm` with the intersection with `clipper`}
* \cgalParamNEnd
*
* \cgalParamNBegin{visitor}
@ -447,17 +451,17 @@ void split_along_edges(TriangleMesh& tm,
* \cgalParamNEnd
*
* \cgalParamNBegin{throw_on_self_intersection}
* \cgalParamDescription{if `true` the set of triangles closed to the intersection of `tm` and `clipper` will be
* \cgalParamDescription{If `true`, the set of triangles closed to the intersection of `tm` and `clipper` will be
* checked for self-intersections and `Corefinement::Self_intersection_exception`
* will be thrown if at least one self-intersection is found}
* will be thrown if at least one self-intersection is found.}
* \cgalParamType{Boolean}
* \cgalParamDefault{`false`}
* \cgalParamNEnd
*
* \cgalParamNBegin{clip_volume}
* \cgalParamDescription{if `true` and `tm` is closed, the clipping will be done on the volume
* \cgalParamDescription{If `true`, and `tm` is closed, the clipping will be done on the volume
* \link coref_def_subsec bounded \endlink by `tm` rather than on its surface
* (i.e., `tm` will be kept closed)}
* (i.e., `tm` will be kept closed).}
* \cgalParamType{Boolean}
* \cgalParamDefault{`false`}
* \cgalParamNEnd
@ -512,12 +516,13 @@ clip(TriangleMesh& tm,
* @param tm input triangulated surface mesh
* @param plane plane whose negative side defines the half-space to intersect `tm` with.
* `Plane_3` is the plane type for the same CGAL kernel as the point of the vertex point map of `tm`.
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tm`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor` as key type and `%Point_3` as value type}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
* \cgalParamNEnd
*
@ -528,18 +533,18 @@ clip(TriangleMesh& tm,
* \cgalParamNEnd
*
* \cgalParamNBegin{throw_on_self_intersection}
* \cgalParamDescription{if `true`, the set of triangles closed to the intersection of `tm`
* \cgalParamDescription{If `true`, the set of triangles closed to the intersection of `tm`
* and `plane` will be checked for self-intersections
* and `CGAL::Polygon_mesh_processing::Corefinement::Self_intersection_exception`
* will be thrown if at least one self-intersection is found}
* will be thrown if at least one self-intersection is found.}
* \cgalParamType{Boolean}
* \cgalParamDefault{`false`}
* \cgalParamNEnd
*
* \cgalParamNBegin{clip_volume}
* \cgalParamDescription{if `true` and `tm` is closed, the clipping will be done on
* \cgalParamDescription{If `true`, and `tm` is closed, the clipping will be done on
* the volume \link coref_def_subsec bounded \endlink by `tm`
* rather than on its surface (i.e., `tm` will be kept closed)}
* rather than on its surface (i.e., `tm` will be kept closed).}
* \cgalParamType{Boolean}
* \cgalParamDefault{`false`}
* \cgalParamNEnd
@ -612,10 +617,11 @@ bool clip(TriangleMesh& tm,
* \cgalNamedParamsBegin
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tm` (`splitter`)}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor` as key type and `%Point_3` as value type}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
* \cgalParamDefault{If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`}
* `CGAL::vertex_point_t` must be available in `TriangleMesh`.}
* \cgalParamNEnd
*
* \cgalParamNBegin{visitor}
@ -625,10 +631,10 @@ bool clip(TriangleMesh& tm,
* \cgalParamNEnd
*
* \cgalParamNBegin{throw_on_self_intersection}
* \cgalParamDescription{if `true`, the set of triangles closed to the intersection of `tm`
* \cgalParamDescription{If `true`, the set of triangles closed to the intersection of `tm`
* and `splitter` will be checked for self-intersections
* and `CGAL::Polygon_mesh_processing::Corefinement::Self_intersection_exception`
* will be thrown if at least one self-intersection is found}
* will be thrown if at least one self-intersection is found.}
* \cgalParamType{Boolean}
* \cgalParamDefault{`false`}
* \cgalParamNEnd
@ -687,12 +693,13 @@ void split(TriangleMesh& tm,
* @param tm input triangulated surface mesh
* @param plane the plane that will be used to split `tm`.
* `Plane_3` is the plane type for the same CGAL kernel as the point of the vertex point map of `tm`.
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tm`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor` as key type and `%Point_3` as value type}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
* \cgalParamNEnd
*
@ -703,10 +710,10 @@ void split(TriangleMesh& tm,
* \cgalParamNEnd
*
* \cgalParamNBegin{throw_on_self_intersection}
* \cgalParamDescription{if `true`, the set of triangles closed to the intersection of `tm`
* \cgalParamDescription{If `true`, the set of triangles closed to the intersection of `tm`
* and `plane` will be checked for self-intersections
* and `CGAL::Polygon_mesh_processing::Corefinement::Self_intersection_exception`
* will be thrown if at least one self-intersection is found}
* will be thrown if at least one self-intersection is found.}
* \cgalParamType{Boolean}
* \cgalParamDefault{`false`}
* \cgalParamNEnd
@ -763,12 +770,13 @@ void split(TriangleMesh& tm,
*
* @param tm input triangulated surface mesh
* @param iso_cuboid iso-cuboid used to clip `tm`.
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tm`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor` as key type and `%Point_3` as value type}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
* \cgalParamNEnd
*
@ -779,18 +787,18 @@ void split(TriangleMesh& tm,
* \cgalParamNEnd
*
* \cgalParamNBegin{throw_on_self_intersection}
* \cgalParamDescription{if `true`, the set of triangles closed to the intersection of `tm`
* \cgalParamDescription{If `true`, the set of triangles closed to the intersection of `tm`
* and `iso_cuboid` will be checked for self-intersections
* and `CGAL::Polygon_mesh_processing::Corefinement::Self_intersection_exception`
* will be thrown if at least one self-intersection is found}
* will be thrown if at least one self-intersection is found.}
* \cgalParamType{Boolean}
* \cgalParamDefault{`false`}
* \cgalParamNEnd
*
* \cgalParamNBegin{clip_volume}
* \cgalParamDescription{if `true` and `tm` is closed, the clipping will be done on
* \cgalParamDescription{If `true`, and `tm` is closed, the clipping will be done on
* the volume \link coref_def_subsec bounded \endlink by `tm`
* rather than on its surface (i.e., `tm` will be kept closed)}
* rather than on its surface (i.e., `tm` will be kept closed).}
* \cgalParamType{Boolean}
* \cgalParamDefault{`false`}
* \cgalParamNEnd

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

@ -112,15 +112,26 @@ void sum_normals(const PM& pmesh,
* @tparam PolygonMesh a model of `FaceGraph`
* @tparam NamedParameters a sequence of \ref pmp_namedparameters "Named Parameters"
*
* @param f the face on which the normal is computed
* @param f the face whose normal is computed
* @param pmesh the polygon mesh containing `f`
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `PolygonMesh`\cgalParamEnd
* \cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `Kernel`\cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `pmesh`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, pmesh)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* must be available in `PolygonMesh`.}
* \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
* \cgalNamedParamsEnd
*
* @return the computed normal. The return type is a 3D vector type. It is
@ -129,8 +140,8 @@ void sum_normals(const PM& pmesh,
* of `pmesh`.
*
* \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.
* If the field type (`FT`) of the traits does not support the `sqrt()` operation,
* the square root computation will be performed approximately.
*/
template <typename PolygonMesh, typename NamedParameters>
#ifdef DOXYGEN_RUNNING
@ -182,18 +193,29 @@ compute_face_normal(typename boost::graph_traits<PolygonMesh>::face_descriptor f
*
* @param pmesh the polygon mesh
* @param face_normals the property map in which the normals are written
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `PolygonMesh`\cgalParamEnd
* \cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `Kernel`\cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `pmesh`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, pmesh)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* must be available in `PolygonMesh`.}
* \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
* \cgalNamedParamsEnd
*
* \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.
* If the field type (`FT`) of the traits does not support the `sqrt()` operation,
* the square root computation will be performed approximately.
*/
template <typename PolygonMesh, typename Face_normal_map, typename NamedParameters>
void compute_face_normals(const PolygonMesh& pmesh,
@ -575,15 +597,26 @@ compute_vertex_normal_as_sum_of_weighted_normals(typename boost::graph_traits<Po
* computes the unit normal at vertex `v` as the average of the normals of incident faces.
* @tparam PolygonMesh a model of `FaceGraph`
*
* @param v the vertex at which the normal is computed
* @param v the vertex whose normal is computed
* @param pmesh the polygon mesh containing `v`
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `PolygonMesh`\cgalParamEnd
* \cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `Kernel`\cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `pmesh`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, pmesh)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* must be available in `PolygonMesh`.}
* \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
* \cgalNamedParamsEnd
*
* @return the computed normal. The return type is a 3D vector type. It is
@ -592,8 +625,8 @@ compute_vertex_normal_as_sum_of_weighted_normals(typename boost::graph_traits<Po
* of `pmesh`.
*
* \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.
* If the field type (`FT`) of the traits does not support the `sqrt()` operation,
* the square root computation will be performed approximately.
*/
template<typename PolygonMesh, typename NamedParameters>
#ifdef DOXYGEN_RUNNING
@ -698,18 +731,29 @@ compute_vertex_normal(typename boost::graph_traits<PolygonMesh>::vertex_descript
*
* @param pmesh the polygon mesh
* @param vertex_normals the property map in which the normals are written
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `PolygonMesh`\cgalParamEnd
* \cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `Kernel`\cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `pmesh`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, pmesh)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* must be available in `PolygonMesh`.}
* \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
* \cgalNamedParamsEnd
*
* \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.
* If the field type (`FT`) of the traits does not support the `sqrt()` operation,
* the square root computation will be performed approximately.
*/
template <typename PolygonMesh, typename VertexNormalMap, typename NamedParameters>
void compute_vertex_normals(const PolygonMesh& pmesh,
@ -787,18 +831,29 @@ void compute_vertex_normals(const PolygonMesh& pmesh, VertexNormalMap vertex_nor
* @param pmesh the polygon mesh
* @param vertex_normals the property map in which the vertex normals are written
* @param face_normals the property map in which the face normals are written
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `PolygonMesh`\cgalParamEnd
* \cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `Kernel`\cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `pmesh`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, pmesh)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* must be available in `PolygonMesh`.}
* \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
* \cgalNamedParamsEnd
*
* \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.
* If the field type (`FT`) of the traits does not support the `sqrt()` operation,
* the square root computation will be performed approximately.
*/
template <typename PolygonMesh,
typename VertexNormalMap, typename FaceNormalMap,

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

@ -99,22 +99,25 @@ namespace internal {
* `seed_face` will also be added in `out`.
*
* \tparam PolygonMesh a model of `FaceGraph`
* \tparam FaceOutputIterator a model of `OutputIterator` that accepts
faces of type
`boost::graph_traits<PolygonMesh>::%face_descriptor`.
* \tparam FaceOutputIterator a model of `OutputIterator` with value type `boost::graph_traits<PolygonMesh>::%face_descriptor`.
* \tparam NamedParameters a sequence of \ref pmp_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 optional \ref pmp_namedparameters "Named Parameters" described below
* \param np an optional \ref pmp_namedparameters "Named Parameters" described below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{edge_is_constrained_map} a property map containing the constrained-or-not status of each edge of `pmesh` \cgalParamEnd
* \cgalParamNBegin{edge_is_constrained_map}
* \cgalParamDescription{a property map containing the constrained-or-not status of each edge of `pmesh`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%edge_descriptor`
* as key type and `bool` as value type}
* \cgalParamDefault{a constant property map returning `false` for any edge key}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* \returns the output iterator.
* \returns the output iterator.
*
*/
template <typename PolygonMesh
@ -184,14 +187,25 @@ connected_component(typename boost::graph_traits<PolygonMesh>::face_descriptor s
* \param pmesh the polygon mesh
* \param fcm the property map with indices of components associated to faces in `pmesh`
* \param np optional \ref pmp_namedparameters "Named Parameters" described below
* \param np an optional \ref pmp_namedparameters "Named Parameters" described below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{edge_is_constrained_map} a property map containing the constrained-or-not status of each edge of `pmesh` \cgalParamEnd
* \cgalParamBegin{face_index_map} a property map containing the index of each face of `pmesh` \cgalParamEnd
* \cgalParamNBegin{edge_is_constrained_map}
* \cgalParamDescription{a property map containing the constrained-or-not status of each edge of `pmesh`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%edge_descriptor`
* as key type and `bool` as value type}
* \cgalParamDefault{a constant property map returning `false` for any edge}
* \cgalParamNEnd
* \cgalParamNBegin{face_index_map}
* \cgalParamDescription{a property map associating to each face of `pmesh` a unique index between `0` and `num_faces(pmesh) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%face_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* \returns the number of connected components.
* \returns the number of connected components.
*/
template <typename PolygonMesh
@ -284,11 +298,22 @@ namespace internal {
// * \tparam NamedParameters a sequence of \ref pmp_namedparameters "Named Parameters"
// *
// * \param pmesh the polygon mesh
// * \param np optional \ref pmp_namedparameters "Named Parameters" described below
// * \param np an optional \ref pmp_namedparameters "Named Parameters" described below
// *
// * \cgalNamedParamsBegin
// * \cgalParamBegin{edge_is_constrained_map} a property map containing the constrained-or-not status of each edge of `pmesh` \cgalParamEnd
// * \cgalParamBegin{face_index_map} a property map containing the index of each face of `pmesh` \cgalParamEnd
// * \cgalParamNBegin{edge_is_constrained_map}
// * \cgalParamDescription{a property map containing the constrained-or-not status of each edge of `pmesh`}
// * \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%edge_descriptor`
// * as key type and `bool` as value type}
// * \cgalParamDefault{a constant property map returning `false` for any edge}
// * \cgalParamNEnd
// *
// * \cgalParamNBegin{face_index_map}
// * \cgalParamDescription{a property map associating to each face of `pmesh` a unique index between `0` and `num_faces(pmesh) - 1`}
// * \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%face_descriptor`
// * as key type and `std::size_t` as value type}
// * \cgalParamDefault{an automatically indexed internal map}
// * \cgalParamNEnd
// * \cgalNamedParamsEnd
// *
// * \returns the output iterator.
@ -330,28 +355,53 @@ std::size_t number_of_connected_components(const PolygonMesh& pmesh)
* \param pmesh the polygon mesh
* \param nb_components_to_keep the number of components to be kept. If this number is larger than
* the number of components in the mesh, all components are kept.
* \param np optional \ref pmp_namedparameters "Named Parameters", amongst those described below
* \param np an optional \ref pmp_namedparameters "Named Parameters", amongst those described below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{edge_is_constrained_map} a property map containing the constrained-or-not status of each edge of `pmesh` \cgalParamEnd
* \cgalParamBegin{face_index_map} a property map containing the index of each face of `pmesh` \cgalParamEnd
* \cgalParamBegin{vertex_index_map} a property map containing the index of each vertex of `pmesh` \cgalParamEnd
* \cgalParamBegin{face_size_map}
* a property map containing a size for each face of `pmesh`. The value type of this property map
* is chosen by the user, but must be constructible from `0` and support `operator+=()` and
* comparisons.
* \cgalParamEnd
* \cgalParamBegin{dry_run}
* a Boolean parameter. If set to `true`, the mesh will not be altered, but the number
* of components that would be removed is returned. The default value is `false`.
* \cgalParamEnd
* \cgalParamBegin{output_iterator} a model of `OutputIterator` with value type `face_descriptor`.
* When using the "dry run" mode (see parameter `dry_run`), faces that would be removed by the
* algorithm can be collected with this output iterator.
* \cgalParamEnd
* \cgalParamNBegin{edge_is_constrained_map}
* \cgalParamDescription{a property map containing the constrained-or-not status of each edge of `pmesh`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%edge_descriptor`
* as key type and `bool` as value type}
* \cgalParamDefault{a constant property map returning `false` for any edge}
* \cgalParamNEnd
*
* \cgalParamNBegin{vertex_index_map}
* \cgalParamDescription{a property map associating to each vertex of `pmesh` a unique index between `0` and `num_vertices(pmesh) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamNEnd
*
* \cgalParamNBegin{face_index_map}
* \cgalParamDescription{a property map associating to each face of `pmesh` a unique index between `0` and `num_faces(pmesh) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%face_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamNEnd
*
* \cgalParamNBegin{face_size_map}
* \cgalParamDescription{a property map associating to each face of `pmesh` a size}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%face_descriptor` as key type.
* The value type is chosen by the user, but must be constructible from `0` and support summation and comparisons.}
* \cgalParamDefault{A constant property map returning `1` for any face}
* \cgalParamNEnd
*
* \cgalParamNBegin{dry_run}
* \cgalParamDescription{If set to `true`, the mesh will not be altered, but the number of components
* that would be removed is returned.}
* \cgalParamType{Boolean}
* \cgalParamDefault{`false`}
* \cgalParamNEnd
*
* \cgalParamNBegin{output_iterator}
* \cgalParamDescription{An output iterator to collect the faces that would be removed by the algorithm,
* when using the "dry run" mode (see parameter `dry_run`)}
* \cgalParamType{a model of `OutputIterator` with value type `face_descriptor`}
* \cgalParamDefault{`false`}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* \return the number of connected components removed (ignoring isolated vertices).
* \return the number of connected components removed (ignoring isolated vertices).
*/
template <typename PolygonMesh,
typename NamedParameters>
@ -457,31 +507,56 @@ std::size_t keep_largest_connected_components(PolygonMesh& pmesh,
*
* \param pmesh the polygon mesh
* \param threshold_value any connected component with a size (strictly) smaller than this value will be discarded
* \param np optional \ref pmp_namedparameters "Named Parameters", amongst those described below
* \param np an optional \ref pmp_namedparameters "Named Parameters", amongst those described below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{edge_is_constrained_map} a property map containing the constrained-or-not status of each edge of `pmesh` \cgalParamEnd
* \cgalParamBegin{face_index_map} a property map containing the index of each face of `pmesh` \cgalParamEnd
* \cgalParamBegin{vertex_index_map} a property map containing the index of each vertex of `pmesh` \cgalParamEnd
* \cgalParamBegin{face_size_map}
* a property map containing a size for each face of `pmesh`. The value type of this property map
* is chosen by the user, but must be constructible from `0` and support `operator+=()` and
* comparisons.
* \cgalParamEnd
* \cgalParamBegin{dry_run}
* a Boolean parameter. If set to `true`, the mesh will not be altered, but the number
* of components that would be removed is returned. The default value is `false`.
* \cgalParamEnd
* \cgalParamBegin{output_iterator} a model of `OutputIterator` with value type `face_descriptor`.
* When using the "dry run" mode (see parameter `dry_run`), faces that would be removed by the
* algorithm can be collected with this output iterator.
* \cgalParamEnd
* \cgalParamNBegin{edge_is_constrained_map}
* \cgalParamDescription{a property map containing the constrained-or-not status of each edge of `pmesh`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%edge_descriptor`
* as key type and `bool` as value type}
* \cgalParamDefault{a constant property map returning `false` for any edge}
* \cgalParamNEnd
*
* \cgalParamNBegin{vertex_index_map}
* \cgalParamDescription{a property map associating to each vertex of `pmesh` a unique index between `0` and `num_vertices(pmesh) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamNEnd
*
* \cgalParamNBegin{face_index_map}
* \cgalParamDescription{a property map associating to each face of `pmesh` a unique index between `0` and `num_faces(pmesh) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%face_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamNEnd
*
* \cgalParamNBegin{face_size_map}
* \cgalParamDescription{a property map associating to each face of `pmesh` a size}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%face_descriptor` as key type.
* The value type is chosen by the user, but must be constructible from `0` and support summation and comparisons.}
* \cgalParamDefault{A constant property map returning `1` for any face}
* \cgalParamNEnd
*
* \cgalParamNBegin{dry_run}
* \cgalParamDescription{If set to `true`, the mesh will not be altered, but the number of components
* that would be removed is returned.}
* \cgalParamType{Boolean}
* \cgalParamDefault{`false`}
* \cgalParamNEnd
*
* \cgalParamNBegin{output_iterator}
* \cgalParamDescription{An output iterator to collect the faces that would be removed by the algorithm,
* when using the "dry run" mode (see parameter `dry_run`)}
* \cgalParamType{a model of `OutputIterator` with value type `face_descriptor`}
* \cgalParamDefault{`false`}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* \pre If a face size property map is passed by the user, `ThresholdValueType` must be the same
* type as the value type of the property map. Otherwise, `ThresholdValueType` must be `std::size_t`.
*
* \return the number of connected components removed (ignoring isolated vertices).
* \return the number of connected components removed (ignoring isolated vertices).
*/
template <typename PolygonMesh,
typename ThresholdValueType,
@ -708,20 +783,25 @@ void keep_or_remove_connected_components(PolygonMesh& pmesh
* then the behavior of this function is undefined.
*
* \tparam PolygonMesh a model of `FaceListGraph` and `MutableFaceGraph`
* \tparam NamedParameters a sequence of \ref pmp_namedparameters "Named Parameters"
* \tparam ComponentRange a range of ids convertible to `std::size`
* \tparam FaceComponentMap a model of `ReadWritePropertyMap` with
* `boost::graph_traits<PolygonMesh>::%face_descriptor` as key type and
* `boost::graph_traits<PolygonMesh>::%faces_size_type` as value type.
* \tparam NamedParameters a sequence of \ref pmp_namedparameters "Named Parameters"
*
* \param components_to_keep the range of ids of connected components to keep
* \param pmesh the polygon mesh
* \param fcm the property map with indices of components associated to faces in `pmesh`.
* After calling this function, the values of `fcm` are undefined.
* \param np optional \ref pmp_namedparameters "Named Parameters" described below
* \param np an optional \ref pmp_namedparameters "Named Parameters" described below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_index_map} a property map containing the index of each vertex of `pmesh` \cgalParamEnd
* \cgalParamNBegin{vertex_index_map}
* \cgalParamDescription{a property map associating to each vertex of `pmesh` a unique index between `0` and `num_vertices(pmesh) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
*/
@ -747,20 +827,25 @@ void keep_connected_components(PolygonMesh& pmesh
* then the behavior of this function is undefined.
*
* \tparam PolygonMesh a model of `FaceListGraph` and `MutableFaceGraph`
* \tparam NamedParameters a sequence of \ref pmp_namedparameters "Named Parameters"
* \tparam ComponentRange a range of ids convertible to `std::size`
* \tparam FaceComponentMap a model of `ReadWritePropertyMap` with
* `boost::graph_traits<PolygonMesh>::%face_descriptor` as key type and
* `boost::graph_traits<PolygonMesh>::%faces_size_type` as value type.
* \tparam NamedParameters a sequence of \ref pmp_namedparameters "Named Parameters"
*
* \param components_to_remove the range of ids of connected components to remove
* \param pmesh the polygon mesh
* \param fcm the property map with indices of components associated to faces in `pmesh`.
* After calling this function, the values of `fcm` are undefined.
* \param np optional \ref pmp_namedparameters "Named Parameters" described below
* \param np an optional \ref pmp_namedparameters "Named Parameters" described below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_index_map} a property map containing the index of each vertex of `pmesh` \cgalParamEnd
* \cgalParamNBegin{vertex_index_map}
* \cgalParamDescription{a property map associating to each vertex of `pmesh` a unique index between `0` and `num_vertices(pmesh) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
*/
@ -792,12 +877,29 @@ void remove_connected_components(PolygonMesh& pmesh
*
* \param components_to_remove a face range, including one face or more on each component to be removed
* \param pmesh the polygon mesh
* \param np optional \ref pmp_namedparameters "Named Parameters", amongst those described below
* \param np an optional \ref pmp_namedparameters "Named Parameters", amongst those described below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{edge_is_constrained_map} a property map containing the constrained-or-not status of each edge of `pmesh` \cgalParamEnd
* \cgalParamBegin{face_index_map} a property map containing the index of each face of `pmesh` \cgalParamEnd
* \cgalParamBegin{vertex_index_map} a property map containing the index of each vertex of `pmesh` \cgalParamEnd
* \cgalParamNBegin{edge_is_constrained_map}
* \cgalParamDescription{a property map containing the constrained-or-not status of each edge of `pmesh`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%edge_descriptor`
* as key type and `bool` as value type}
* \cgalParamDefault{a constant property map returning `false` for any edge}
* \cgalParamNEnd
*
* \cgalParamNBegin{vertex_index_map}
* \cgalParamDescription{a property map associating to each vertex of `pmesh` a unique index between `0` and `num_vertices(pmesh) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamNEnd
*
* \cgalParamNBegin{face_index_map}
* \cgalParamDescription{a property map associating to each face of `pmesh` a unique index between `0` and `num_faces(pmesh) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%face_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
*/
@ -845,12 +947,29 @@ void remove_connected_components(PolygonMesh& pmesh
*
* \param pmesh the polygon mesh
* \param components_to_keep a face range, including one face or more on each component to be kept
* \param np optional \ref pmp_namedparameters "Named Parameters", amongst those described below
* \param np an optional \ref pmp_namedparameters "Named Parameters", amongst those described below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{edge_is_constrained_map} a property map containing the constrained-or-not status of each edge of `pmesh` \cgalParamEnd
* \cgalParamBegin{face_index_map} a property map containing the index of each face of `pmesh` \cgalParamEnd
* \cgalParamBegin{vertex_index_map} a property map containing the index of each vertex of `pmesh` \cgalParamEnd
* \cgalParamNBegin{edge_is_constrained_map}
* \cgalParamDescription{a property map containing the constrained-or-not status of each edge of `pmesh`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%edge_descriptor`
* as key type and `bool` as value type}
* \cgalParamDefault{a constant property map returning `false` for any edge}
* \cgalParamNEnd
*
* \cgalParamNBegin{vertex_index_map}
* \cgalParamDescription{a property map associating to each vertex of `pmesh` a unique index between `0` and `num_vertices(pmesh) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamNEnd
*
* \cgalParamNBegin{face_index_map}
* \cgalParamDescription{a property map associating to each face of `pmesh` a unique index between `0` and `num_faces(pmesh) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%face_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
*/
@ -963,34 +1082,50 @@ void split_connected_components_impl(FIMap fim,
/*!
* \ingroup keep_connected_components_grp
* identifies the connected components of `pm` and pushes back a new `PolygonMesh` for each connected component in `cc_meshes`.
*
* identifies the connected components of `pmesh` and pushes back a new `PolygonMesh` for each connected component in `cc_meshes`.
*
* \tparam PolygonMesh a model of `FaceListGraph`
* \tparam PolygonMeshRange a model of `SequenceContainer` with `PolygonMesh` as value type.
*
* \tparam NamedParameters a sequence of Named Parameters
*
* \param pm the polygon mesh
* \param pmesh the polygon mesh
* \param cc_meshes container that is filled with the extracted connected components.
* \param np an optional sequence of Named Parameters among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{edge_is_constrained_map} a property map containing the constrained-or-not status of each edge of `pm` \cgalParamEnd
* \cgalParamBegin{face_index_map}
* a property map containing a unique index for each face initialized from 0 to `num_faces(pm)`
* \cgalParamEnd
* \cgalParamBegin{vertex_index_map}
* a property map containing a unique index for each vertex initialized 0 to `num_vertices(pm)`
* \cgalParamEnd
* \cgalNPBegin{halfedge_index_map}
* a property map containing a unique index for each halfedge initialized 0 to `num_halfedges(pm)`
* \cgalNPEnd
* \cgalParamNBegin{edge_is_constrained_map}
* \cgalParamDescription{a property map containing the constrained-or-not status of each edge of `pmesh`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%edge_descriptor`
* as key type and `bool` as value type}
* \cgalParamDefault{a constant property map returning `false` for any edge}
* \cgalParamNEnd
*
* \cgalParamNBegin{vertex_index_map}
* \cgalParamDescription{a property map associating to each vertex of `pmesh` a unique index between `0` and `num_vertices(pmesh) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamNEnd
*
* \cgalParamNBegin{halfedge_index_map}
* \cgalParamDescription{a property map associating to each halfedge of `pmesh` a unique index between `0` and `num_halfedges(pmesh) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%halfedge_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamNEnd
*
* \cgalParamNBegin{face_index_map}
* \cgalParamDescription{a property map associating to each face of `pmesh` a unique index between `0` and `num_faces(pmesh) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%face_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
*/
template <class PolygonMesh, class PolygonMeshRange, class NamedParameters>
void split_connected_components(const PolygonMesh& pm,
void split_connected_components(const PolygonMesh& pmesh,
PolygonMeshRange& cc_meshes,
const NamedParameters& np)
{
@ -1006,17 +1141,17 @@ void split_connected_components(const PolygonMesh& pm,
Ecm ecm = choose_parameter(get_parameter(np, internal_np::edge_is_constrained),
internal::No_mark<PolygonMesh>());
internal::split_connected_components_impl(CGAL::get_initialized_face_index_map(pm, np),
CGAL::get_initialized_halfedge_index_map(pm, np),
CGAL::get_initialized_vertex_index_map(pm, np),
internal::split_connected_components_impl(CGAL::get_initialized_face_index_map(pmesh, np),
CGAL::get_initialized_halfedge_index_map(pmesh, np),
CGAL::get_initialized_vertex_index_map(pmesh, np),
ecm, cc_meshes, pm);
}
template <class PolygonMesh, class PolygonMeshRange>
void split_connected_components(const PolygonMesh& pm,
void split_connected_components(const PolygonMesh& pmesh,
PolygonMeshRange& cc_meshes)
{
split_connected_components(pm, cc_meshes, parameters::all_default());
split_connected_components(pmesh, cc_meshes, parameters::all_default());
}
} // namespace Polygon_mesh_processing

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

@ -99,46 +99,73 @@ enum Boolean_operation_type {UNION = 0, INTERSECTION=1,
* @param tm1 first input triangulated surface mesh
* @param tm2 second input triangulated surface mesh
* @param output an array of output surface meshes
* @param np1 optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np2 optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np1 an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np2 an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map}
* the property map with the points associated to the vertices of `tm1` (`tm2`).
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` should be available in `TriangleMesh`
* \cgalParamEnd
* \cgalParamBegin{edge_is_constrained_map} a property map containing the
* constrained-or-not status of each edge of `tm1` (`tm2`).
* \cgalParamEnd
* \cgalParamBegin{face_index_map} a property map containing the index of each face of `tm1` (`tm2`).
* Note that if the property map is writable, the indices of the faces
* of `tm1` and `tm2` will be set after the corefinement is done.
* \cgalParamEnd
* \cgalParamBegin{visitor} a class model of `PMPCorefinementVisitor`
* that is used to track the creation of new faces (`np1` only)
* \cgalParamEnd
* \cgalParamBegin{throw_on_self_intersection} if `true`, for each input triangle mesh,
* the set of triangles close to the intersection of `tm1` and `tm2` will be
* checked for self-intersection and `CGAL::Polygon_mesh_processing::Corefinement::Self_intersection_exception`
* will be thrown if at least one is found (`np1` only).
* \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tm1` (`tm2`)}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm1 (tm2))`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* must be available in `TriangleMesh`.}
* \cgalParamNEnd
*
* \cgalParamNBegin{edge_is_constrained_map}
* \cgalParamDescription{a property map containing the constrained-or-not status of each edge of `tm1` (`tm2`)}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%edge_descriptor`
* 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 `tm1` (`tm2`) a unique index
* between `0` and `num_faces(tm1) - 1` (`num_faces(tm2) - 1`)}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%face_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamExtra{If the property map is writable, the indices of the faces of `tm1` and `tm2`
* will be set after the corefinement is done.}
* \cgalParamNEnd
*
* \cgalParamNBegin{visitor}
* \cgalParamDescription{a visitor used to track the creation of new faces}
* \cgalParamType{a class model of `PMPCorefinementVisitor`}
* \cgalParamDefault{`Corefinement::Default_visitor<TriangleMesh>`}
* \cgalParamExtra{`np1` only}
* \cgalParamNEnd
*
* \cgalParamNBegin{throw_on_self_intersection}
* \cgalParamDescription{if `true` the set of triangles closed to the intersection of `tm1` and `tm2` will be
* checked for self-intersections and `Corefinement::Self_intersection_exception`
* will be thrown if at least one self-intersection is found}
* \cgalParamType{Boolean}
* \cgalParamDefault{`false`}
* \cgalParamExtra{`np1` only}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* @param nps_out tuple of optional sequences of \ref pmp_namedparameters "Named Parameters" each among the ones listed below
* @param nps_out a tuple of optional sequences of \ref pmp_namedparameters "Named Parameters" each among the ones listed below
* (`tm_out` being used to refer to the output surface mesh in `output` corresponding to a given named parameter sequence)
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map}
* the property map with the points associated to the vertices of `tm_out`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`
* \cgalParamEnd
* \cgalParamBegin{edge_is_constrained_map} a property map containing the
* constrained-or-not status of each edge of `tm_out`. An edge of `tm_out` is constrained
* if it is on the intersection of `tm1` and `tm2`, or if the edge corresponds to a
* constrained edge in `tm1` or `tm2`.
* \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tm_out`}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm_out)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* must be available in `TriangleMesh`.}
* \cgalParamNEnd
*
* \cgalParamNBegin{edge_is_constrained_map}
* \cgalParamDescription{a property map containing the constrained-or-not status of each edge of `tm_out`.
* An edge of `tm_out` is constrained if it is on the intersection of `tm1` and `tm2`,
* or if the edge corresponds to a constrained edge in `tm1` or `tm2`.}
* \cgalParamType{a class model of `WritablePropertyMap` with `boost::graph_traits<TriangleMesh>::%edge_descriptor`
* as key type and `bool` as value type}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* @return an array filled as follows: for each operation computed, the position in the array
@ -456,45 +483,72 @@ corefine_and_compute_boolean_operations(
* @param tm1 first input triangulated surface mesh
* @param tm2 second input triangulated surface mesh
* @param tm_out output surface mesh
* @param np1 optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np2 optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np1 an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np2 an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map}
* the property map with the points associated to the vertices of `tm1` (`tm2`).
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`
* \cgalParamEnd
* \cgalParamBegin{edge_is_constrained_map} a property map containing the
* constrained-or-not status of each edge of `tm1` (`tm2`).
* \cgalParamEnd
* \cgalParamBegin{face_index_map} a property map containing the index of each face of `tm1` (`tm2`).
* Note that if the property map is writable, the indices of the faces
* of `tm1` and `tm2` will be set after the corefinement is done.
* \cgalParamEnd
* \cgalParamBegin{visitor} a class model of `PMPCorefinementVisitor`
* that is used to track the creation of new faces (`np1` only)
* \cgalParamEnd
* \cgalParamBegin{throw_on_self_intersection} if `true`, for each input triangle mesh,
* the set of triangles close to the intersection of `tm1` and `tm2` will be
* checked for self-intersection and `CGAL::Polygon_mesh_processing::Corefinement::Self_intersection_exception`
* will be thrown if at least one is found (`np1` only).
* \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tm1` (`tm2`)}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm1 (tm2))`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* must be available in `TriangleMesh`.}
* \cgalParamNEnd
*
* \cgalParamNBegin{edge_is_constrained_map}
* \cgalParamDescription{a property map containing the constrained-or-not status of each edge of `tm1` (`tm2`)}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%edge_descriptor`
* 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 `tm1` (`tm2`) a unique index
* between `0` and `num_faces(tm1) - 1` (`num_faces(tm2) - 1`)}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%face_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamExtra{If the property map is writable, the indices of the faces of `tm1` and `tm2`
* will be set after the corefinement is done.}
* \cgalParamNEnd
*
* \cgalParamNBegin{visitor}
* \cgalParamDescription{a visitor used to track the creation of new faces}
* \cgalParamType{a class model of `PMPCorefinementVisitor`}
* \cgalParamDefault{`Corefinement::Default_visitor<TriangleMesh>`}
* \cgalParamExtra{`np1` only}
* \cgalParamNEnd
*
* \cgalParamNBegin{throw_on_self_intersection}
* \cgalParamDescription{if `true` the set of triangles closed to the intersection of `tm1` and `tm2` will be
* checked for self-intersections and `Corefinement::Self_intersection_exception`
* will be thrown if at least one self-intersection is found}
* \cgalParamType{Boolean}
* \cgalParamDefault{`false`}
* \cgalParamExtra{`np1` only}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* @param np_out optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map}
* the property map with the points associated to the vertices of `tm_out`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`
* \cgalParamEnd
* \cgalParamBegin{edge_is_constrained_map} a property map containing the
* constrained-or-not status of each edge of `tm_out`. An edge of `tm_out` is constrained
* if it is on the intersection of `tm1` and `tm2`, or if the edge corresponds to a
* constrained edge in `tm1` or `tm2`.
* \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tm_out`}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm_out)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* must be available in `TriangleMesh`.}
* \cgalParamNEnd
*
* \cgalParamNBegin{edge_is_constrained_map}
* \cgalParamDescription{a property map containing the constrained-or-not status of each edge of `tm_out`.
* An edge of `tm_out` is constrained if it is on the intersection of `tm1` and `tm2`,
* or if the edge corresponds to a constrained edge in `tm1` or `tm2`.}
* \cgalParamType{a class model of `WritablePropertyMap` with `boost::graph_traits<TriangleMesh>::%edge_descriptor`
* as key type and `bool` as value type}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* @return `true` if the output surface mesh is manifold and is put into `tm_out`.
@ -606,26 +660,41 @@ corefine_and_compute_difference( TriangleMesh& tm1,
*
* @param tm1 first input triangulated surface mesh
* @param tm2 second input triangulated surface mesh
* @param np1 optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np2 optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np1 an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np2 an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map}
* the property map with the points associated to the vertices of `tm1` (`tm2`).
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`
* \cgalParamEnd
* \cgalParamBegin{edge_is_constrained_map} a property map containing the
* constrained-or-not status of each edge of `tm1` (`tm2`)
* \cgalParamEnd
* \cgalParamBegin{visitor} a class model of `PMPCorefinementVisitor`
* that is used to track the creation of new faces (`np1` only)
* \cgalParamEnd
* \cgalParamBegin{throw_on_self_intersection} if `true`, for each input triangle mesh,
* the set of triangles close to the intersection of `tm1` and `tm2` will be
* checked for self-intersection and `CGAL::Polygon_mesh_processing::Corefinement::Self_intersection_exception`
* will be thrown if at least one is found (`np1` only).
* \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tm1` (`tm2`)}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm1 (tm2))`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* must be available in `TriangleMesh`.}
* \cgalParamNEnd
*
* \cgalParamNBegin{edge_is_constrained_map}
* \cgalParamDescription{a property map containing the constrained-or-not status of each edge of `tm1` (`tm2`)}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%edge_descriptor`
* as key type and `bool` as value type}
* \cgalParamDefault{a constant property map returning `false` for any edge}
* \cgalParamNEnd
*
* \cgalParamNBegin{visitor}
* \cgalParamDescription{a visitor used to track the creation of new faces}
* \cgalParamType{a class model of `PMPCorefinementVisitor`}
* \cgalParamDefault{`Corefinement::Default_visitor<TriangleMesh>`}
* \cgalParamExtra{`np1` only}
* \cgalParamNEnd
*
* \cgalParamNBegin{throw_on_self_intersection}
* \cgalParamDescription{if `true` the set of triangles closed to the intersection of `tm1` and `tm2` will be
* checked for self-intersections and `Corefinement::Self_intersection_exception`
* will be thrown if at least one self-intersection is found}
* \cgalParamType{Boolean}
* \cgalParamDefault{`false`}
* \cgalParamExtra{`np1` only}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
*/
@ -716,20 +785,39 @@ namespace experimental {
* @tparam NamedParameters a sequence of \ref namedparameters
*
* @param tm input triangulated surface mesh
* @param np optional sequence of \ref namedparameters among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map}
* the property map with the points associated to the vertices of `tm`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`
* \cgalParamEnd
* \cgalParamBegin{edge_is_constrained_map} a property map containing the
* constrained-or-not status of each edge of `tm`
* \cgalParamEnd
* \cgalParamBegin{visitor} a class model of `PMPCorefinementVisitor`
* that is used to track the creation of new faces
* \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tm`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* must be available in `TriangleMesh`.}
* \cgalParamNEnd
*
* \cgalParamNBegin{edge_is_constrained_map}
* \cgalParamDescription{a property map containing the constrained-or-not status of each edge of `tm`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%edge_descriptor`
* 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 `tm` a unique index between `0` and `num_faces(tm) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%face_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamExtra{If the property map is writable, the indices of the faces of `tm1` and `tm2`
* will be set after the corefinement is done.}
* \cgalParamNEnd
*
* \cgalParamNBegin{visitor}
* \cgalParamDescription{a visitor used to track the creation of new faces}
* \cgalParamType{a class model of `PMPCorefinementVisitor`}
* \cgalParamDefault{`Corefinement::Default_visitor<TriangleMesh>`}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
*/
@ -789,21 +877,40 @@ autorefine( TriangleMesh& tm,
* @tparam NamedParameters a sequence of \ref namedparameters
*
* @param tm input triangulated surface mesh
* @param np optional sequence of \ref namedparameters among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map}
* the property map with the points associated to the vertices of `tm`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`
* \cgalParamEnd
* \cgalParamBegin{edge_is_constrained_map} a property map containing the
* constrained-or-not status of each edge of `tm`
* \cgalParamEnd
* \cgalParamBegin{face_index_map} a property map containing the index of each face of `tm` \cgalParamEnd
* \cgalParamBegin{visitor} a class model of `PMPCorefinementVisitor`
* that is used to track the creation of new faces
* \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tm`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* must be available in `TriangleMesh`.}
* \cgalParamNEnd
*
* \cgalParamNBegin{edge_is_constrained_map}
* \cgalParamDescription{a property map containing the constrained-or-not status of each edge of `tm`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%edge_descriptor`
* 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 `tm` a unique index between `0` and `num_faces(tm) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%face_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamExtra{If the property map is writable, the indices of the faces of `tm` will be set
* after the autorefinement is done.}
* \cgalParamNEnd
*
* \cgalParamNBegin{visitor}
* \cgalParamDescription{a visitor used to track the creation of new faces}
* \cgalParamType{a class model of `PMPCorefinementVisitor`}
* \cgalParamDefault{`Corefinement::Default_visitor<TriangleMesh>`}
* \cgalParamNEnd
*
* \cgalNamedParamsEnd
*
*/

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

@ -246,12 +246,21 @@ template<typename GT,
* \param pmesh the polygon mesh
* \param angle_in_deg the dihedral angle bound
* \param edge_is_feature_map the property map that will contain the sharp-or-not status of each edge of `pmesh`
* \param np optional \ref pmp_namedparameters "Named Parameters", amongst those described below
* \param np an optional \ref pmp_namedparameters "Named Parameters", amongst those described below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `Kernel`\cgalParamEnd
* \cgalParamBegin{vertex_feature_degree_map} a property map that will contain the number of adjacent feature edges for
* each vertex of `pmesh` \cgalParamEnd
* \cgalParamNBegin{vertex_feature_degree_map}
* \cgalParamDescription{a property map that will associate to each vertex of `pmesh` the number of incident feature edges}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor` as key type and `int` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_feature_degree_t(), pmesh)`}
* \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
* \cgalNamedParamsEnd
*
*/
@ -295,6 +304,7 @@ void detect_sharp_edges(PolygonMesh& pmesh,
inserted several times.
* \tparam EdgeIsFeatureMap a model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%edge_descriptor`
* as key type and `bool` as value type.
*
* \param pmesh the polygon mesh
* \param patch_id_map the property map containing the surface patch ids for the faces of `pmesh`. It must be already filled.
* \param vertex_incident_patches_map a property map that will contain the patch ids of all the faces incident to each vertex of `pmesh`.
@ -368,7 +378,6 @@ namespace internal
* computing a
* surface patch id for each face.
*
*
* \tparam PolygonMesh a model of `FaceGraph`
* \tparam FT a number type. It is
* either deduced from the `geom_traits` \ref pmp_namedparameters "Named Parameters" if provided,
@ -384,15 +393,44 @@ namespace internal
* \param angle_in_deg the dihedral angle bound
* \param edge_is_feature_map the property map that will contain the sharp-or-not status of each edge of `pmesh`
* \param patch_id_map the property map that will contain the surface patch ids for the faces of `pmesh`.
* \param np optional \ref pmp_namedparameters "Named Parameters", amongst those described below
* \param np an optional \ref pmp_namedparameters "Named Parameters", amongst those described below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `Kernel`\cgalParamEnd
* \cgalParamBegin{vertex_feature_degree_map} a property map that will contain the number of adjacent feature edges for each vertex of `pmesh` \cgalParamEnd
* \cgalParamBegin{first_index} a `std::size_t` containing the index of the first surface patch of `pmesh`.
* The patches will be numbered on [first_index; first_index + num_patches], where num_patches is the number of surface patches \cgalParamEnd
* \cgalParamBegin{face_index_map} a property map containing the index of each face of `pmesh` \cgalParamEnd
* \cgalParamBegin{vertex_incident_patches_map} a property map that will contain the patch ids of all the faces incident to each vertex of `pmesh`. \cgalParamEnd
* \cgalParamNBegin{vertex_feature_degree_map}
* \cgalParamDescription{a property map that will associate to each vertex of `pmesh` the number of incident feature edges}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
* as key type and `int` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_feature_degree_t(), pmesh)`}
* \cgalParamNEnd
*
* \cgalParamNBegin{first_index}
* \cgalParamDescription{the index of the first surface patch of `pmesh`}
* \cgalParamType{`std::size_t`}
* \cgalParamExtra{the patches will be numbered on `[first_index; first_index + num_patches]`,
* where `num_patches` is the number of surface patches}
* \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<TriangleMesh>::%face_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamNEnd
*
* \cgalParamNBegin{vertex_incident_patches_map}
* \cgalParamDescription{a property map that will contain the patch ids of all the faces incident to each vertex of `pmesh`}
* \cgalParamType{a model of mutable `LvaluePropertyMap` with
* `boost::graph_traits<PolygonMesh>::%vertex_descriptor` as key type. Its value type
* must be a container of `boost::property_traits<PatchIdMap>::%value_type` and have a function `insert()`.}
* \cgalParamExtra{A `std::set` or a `boost::unordered_set` are recommended, as a patch index may be inserted several times.}
* \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
* \cgalNamedParamsEnd
* \returns the number of surface patches.
*
@ -451,9 +489,6 @@ sharp_edges_segmentation(PolygonMesh& p,
parameters::all_default());
}
} // end namespace PMP
} // end namespace CGAL

268
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/distance.h
View File

@ -234,87 +234,131 @@ sample_triangles(const FaceRange& triangles,
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points
* associated to the vertices of `tm`. If this parameter is omitted,
* an internal property map for `CGAL::vertex_point_t`
* must be available for `TriangleMesh`.
* \cgalParamEnd
* \cgalParamBegin{geom_traits} a model of `PMPDistanceTraits`. \cgalParamEnd
* \cgalParamBegin{use_random_uniform_sampling}
* if `true` is passed (the default), points are generated in a random
* and uniform way on the surface of `tm`, and/or on edges of `tm`.
* For faces, the number of sample points is the value passed to the named
* parameter `number_of_points_on_faces()`. If not set,
* the value passed to the named parameter `number_of_points_per_area_unit()`
* is multiplied by the area of `tm` to get the number of sample points.
* If none of these parameters is set, the number of points sampled is `num_vertices(tm)`.
* For edges, the number of the number of sample points is the value passed to the named
* parameter `number_of_points_on_edges()`. If not set,
* the value passed to the named parameter `number_of_points_per_distance_unit()`
* is multiplied by the sum of the length of edges of `tm` to get the number of sample points.
* If none of these parameters is set, the number of points sampled is `num_vertices(tm)`.
* \cgalParamEnd
* \cgalParamBegin{use_grid_sampling}
* if `true` is passed, points are generated on a grid in each triangle,
* with a minimum of one point per triangle. The distance between
* two consecutive points in the grid is that of the length of the
* smallest non-null edge of `tm` or the value passed to
* the named parameter `grid_spacing()`. Edges are also split using the
* same distance, if requested.
* \cgalParamEnd
* \cgalParamBegin{use_monte_carlo_sampling}
* if `true` is passed, points are generated randomly in each triangle and/or
* on each edge.
* For faces, the number of points per triangle is the value passed to the named
* parameter `number_of_points_per_face()`. If not set, the value passed
* to the named parameter `number_of_points_per_area_unit()` is
* used to pick a number of points per face proportional to the triangle
* area with a minimum of one point per face. If none of these parameters
* is set, 2 divided by the square of the length of the smallest non-null
* edge of `tm` is used as if it was passed to
* `number_of_points_per_area_unit()`.
* For edges, the number of points per edge is the value passed to the named
* parameter `number_of_points_per_edge()`. If not set, the value passed
* to the named parameter `number_of_points_per_distance_unit()` is
* used to pick a number of points per edge proportional to the length of
* the edge with a minimum of one point per face. If none of these parameters
* is set, 1 divided by the length of the smallest non-null edge of `tm`
* is used as if it was passed to `number_of_points_per_distance_unit()`.
* \cgalParamEnd
* \cgalParamBegin{sample_vertices} if `true` is passed (default value),
* vertices of `tm` are put into `out`.\cgalParamEnd
* \cgalParamBegin{sample_edges} if `true` is passed (default value),
* edges of `tm` are sampled.\cgalParamEnd
* \cgalParamBegin{sample_faces} if `true` is passed (default value),
* faces of `tm` are sampled.\cgalParamEnd
* \cgalParamBegin{grid_spacing} a double value used as the grid spacing
* for the grid sampling method.
* \cgalParamEnd
* \cgalParamBegin{number_of_points_on_edges} an unsigned integral value used
* for the random sampling method as the number of points to pick exclusively
* on edges.
* \cgalParamEnd
* \cgalParamBegin{number_of_points_on_faces} an unsigned integral value used
* for the random sampling method as the number of points to pick on the surface.
* \cgalParamEnd
* \cgalParamBegin{number_of_points_per_distance_unit} a double value
* used for the random sampling and the Monte Carlo sampling methods to
* repectively determine the total number of points on edges and the
* number of points per edge.
* \cgalParamEnd
* \cgalParamBegin{number_of_points_per_edge} an unsigned integral value
* used by the Monte-Carlo sampling method as the number of points per edge
* to pick.
* \cgalParamEnd
* \cgalParamBegin{number_of_points_per_face} an unsigned integral value
* used by the Monte-Carlo sampling method as the number of points per face
* to pick.
* \cgalParamEnd
* \cgalParamBegin{number_of_points_per_area_unit} a double value
* used for the random sampling and the Monte Carlo sampling methods to
* repectively determine the total number of points inside faces
* and the number of points per face.
* \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tm`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
* \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{a class model of `PMPDistanceTraits`}
* \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{use_random_uniform_sampling}
* \cgalParamDescription{If `true` is passed, points are generated in a random and uniform way
* on the surface of `tm`, and/or on edges of `tm`.}
* \cgalParamType{Boolean}
* \cgalParamType{`true`}
* \cgalParamExtra{For faces, the number of sample points is the value passed to the named
* parameter `number_of_points_on_faces`. If not set,
* the value passed to the named parameter `number_of_points_per_area_unit`
* is multiplied by the area of `tm` to get the number of sample points.
* If none of these parameters is set, the number of points sampled is `num_vertices(tm)`.
* For edges, the number of the number of sample points is the value passed to the named
* parameter `number_of_points_on_edges`. If not set,
* the value passed to the named parameter `number_of_points_per_distance_unit`
* is multiplied by the sum of the length of edges of `tm` to get the number of sample points.
* If none of these parameters is set, the number of points sampled is `num_vertices(tm)`.}
* \cgalParamNEnd
*
* \cgalParamNBegin{use_grid_sampling}
* \cgalParamDescription{If `true` is passed, points are generated on a grid in each triangle,
* with a minimum of one point per triangle.}
* \cgalParamType{Boolean}
* \cgalParamDefault{`false`}
* \cgalParamExtra{The distance between two consecutive points in the grid is that of the length
* of the smallest non-null edge of `tm` or the value passed to the named parameter
* `grid_spacing`. Edges are also split using the same distance, if requested.}
* \cgalParamNEnd
*
* \cgalParamNBegin{use_monte_carlo_sampling}
* \cgalParamDescription{if `true` is passed, points are generated randomly in each triangle and/or on each edge.}
* \cgalParamType{Boolean}
* \cgalParamDefault{`false`}
* \cgalParamExtra{For faces, the number of points per triangle is the value passed to the named
* parameter `number_of_points_per_face`. If not set, the value passed
* to the named parameter `number_of_points_per_area_unit` is
* used to pick a number of points per face proportional to the triangle
* area with a minimum of one point per face. If none of these parameters
* is set, 2 divided by the square of the length of the smallest non-null
* edge of `tm` is used as if it was passed to
* `number_of_points_per_area_unit`.
* For edges, the number of points per edge is the value passed to the named
* parameter `number_of_points_per_edge`. If not set, the value passed
* to the named parameter `number_of_points_per_distance_unit` is
* used to pick a number of points per edge proportional to the length of
* the edge with a minimum of one point per face. If none of these parameters
* is set, 1 divided by the length of the smallest non-null edge of `tm`
* is used as if it was passed to `number_of_points_per_distance_unit`.}
* \cgalParamNEnd
*
* \cgalParamNBegin{sample_vertices}
* \cgalParamDescription{If `true` is passed, vertices of `tm` are put into `out`.}
* \cgalParamType{Boolean}
* \cgalParamDefault{`true`}
* \cgalParamNEnd
*
* \cgalParamNBegin{sample_edges}
* \cgalParamDescription{If `true` is passed, edges of `tm` are sampled.}
* \cgalParamType{Boolean}
* \cgalParamDefault{`true`}
* \cgalParamNEnd
*
* \cgalParamNBegin{sample_faces}
* \cgalParamDescription{If `true` is passed, faces of `tm` are sampled.}
* \cgalParamType{Boolean}
* \cgalParamDefault{`true`}
* \cgalParamNEnd
*
* \cgalParamNBegin{grid_spacing}
* \cgalParamDescription{a value used as the grid spacing for the grid sampling method}
* \cgalParamType{double}
* \cgalParamDefault{the length of the shortest, non-degenerate edge of `tm`}
* \cgalParamNEnd
*
* \cgalParamNBegin{number_of_points_on_edges}
* \cgalParamDescription{a value used for the random sampling method as the number of points to pick exclusively on edges}
* \cgalParamType{unsigned int}
* \cgalParamDefault{`num_vertices(tm)` or a value based on `nb_points_per_distance_unit`, if it is defined}
* \cgalParamNEnd
*
* \cgalParamNBegin{number_of_points_on_faces}
* \cgalParamDescription{a value used for the random sampling method as the number of points to pick on the surface}
* \cgalParamType{unsigned int}
* \cgalParamDefault{`num_vertices(tm)` or a value based on `nb_points_per_area_unit`, if it is defined}
* \cgalParamNEnd
*
* \cgalParamNBegin{number_of_points_per_distance_unit}
* \cgalParamDescription{a value used for the random sampling and the Monte Carlo sampling methods to
* respectively determine the total number of points on edges and the number of points per edge}
* \cgalParamType{double}
* \cgalParamDefault{`1` divided by the length of the shortest, non-degenerate edge of `tm`}
* \cgalParamNEnd
*
* \cgalParamNBegin{number_of_points_per_edge}
* \cgalParamDescription{a value used by the Monte-Carlo sampling method as the number of points per edge to pick}
* \cgalParamType{unsigned int}
* \cgalParamDefault{`0`}
* \cgalParamNEnd
*
* \cgalParamNBegin{number_of_points_per_area_unit}
* \cgalParamDescription{a value used for the random sampling and the Monte Carlo sampling methods to
* respectively determine the total number of points inside faces and the number of points per face}
* \cgalParamType{double}
* \cgalParamDefault{`2` divided by the squared length of the shortest, non-degenerate edge of `tm`}
* \cgalParamNEnd
*
* \cgalParamNBegin{number_of_points_per_face}
* \cgalParamDescription{a value used by the Monte-Carlo sampling method as the number of points per face to pick}
* \cgalParamType{unsigned int}
* \cgalParamDefault{`0`}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*/
template<class OutputIterator, class TriangleMesh, class NamedParameters>
@ -595,18 +639,24 @@ double approximate_Hausdorff_distance(
*
* @param tm1 the triangle mesh that will be sampled
* @param tm2 the triangle mesh to compute the distance to
* @param np1 optional sequence of \ref pmp_namedparameters "Named Parameters" for `tm1` passed to `sample_triangle_mesh()`.
* @param np1 an optional sequence of \ref pmp_namedparameters "Named Parameters" for `tm1`,
* forwarded to `sample_triangle_mesh()`.
*
* @param np2 optional sequence of \ref pmp_namedparameters "Named Parameters" for `tm2` among the ones listed below
* @param np2 an optional sequence of \ref pmp_namedparameters "Named Parameters" for `tm2` among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `tm2`
* If this parameter is omitted, an internal property map for `CGAL::vertex_point_t` must be available in `TriangleMesh`
* and in all places where `vertex_point_map` is used.
* \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tm2`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm2)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* must be available in `TriangleMesh`.}
* \cgalParamNEnd
* \cgalNamedParamsEnd
* The function `CGAL::parameters::all_default()` can be used to indicate to use the default values for
* `np1` and specify custom values for `np2`
*
* The function `CGAL::parameters::all_default()` can be used to indicate to use the default values
* for `np1` and specify custom values for `np2`.
*/
template< class Concurrency_tag,
class TriangleMesh,
@ -659,11 +709,21 @@ double approximate_symmetric_Hausdorff_distance(
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map}
* the property map with the points associated to the vertices of `tm`. If this parameter is omitted,
* an internal property map for `CGAL::vertex_point_t` must be available for the
vertices of `tm` \cgalParamEnd
* \cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `PMPDistanceTraits`\cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tm`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
* \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{a class model of `PMPDistanceTraits`}
* \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
*/
template< class Concurrency_tag,
@ -696,11 +756,21 @@ double max_distance_to_triangle_mesh(const PointRange& points,
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map}
* the property map with the points associated to the vertices of `tm`. If this parameter is omitted,
* an internal property map for `CGAL::vertex_point_t` must be available for the
vertices of `tm` \cgalParamEnd
* \cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `PMPDistanceTraits`. \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tm`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
* \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{a class model of `PMPDistanceTraits`}
* \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
*/
template< class TriangleMesh,

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

@ -103,6 +103,7 @@ struct Identity_functor
/**
* \ingroup PMP_meshing_grp
*
* \brief performs a generalized extrusion of `input` and puts it in `output`.
*
* This function extrudes the open surface mesh `input` and puts the result in `output`. The mesh generated is a closed
@ -112,7 +113,9 @@ struct Identity_functor
* vertices of the bottom and top part are first initialized to the same value as the corresponding
* vertices of `input`. Then for each vertex, a call to `bot` and `top` is done for the vertices of the
* bottom part and the top part, respectively.
*
* \attention `output` may be self intersecting.
*
* @tparam InputMesh a model of `FaceListGraph`
* @tparam OutputMesh a model of `FaceListGraph` and `MutableFaceGraph`
* @tparam NamedParameters1 a sequence of \ref pmp_namedparameters "Named Parameters" for `InputMesh`
@ -124,6 +127,7 @@ struct Identity_functor
* where `output_v` is the copy of `input_v` from `input` into the bottom part of `output`.
*
* @tparam TopFunctor a functor providing a similar `operator()` as `BottomFunctor`.
*
* @param input an open surface mesh to extrude.
* @param output a surface mesh that will contain the result of the extrusion.
* @param bot functor that will transform all points copied from
@ -133,21 +137,26 @@ struct Identity_functor
* @param np_in an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map}
* the property map that contains the points associated to the vertices of `input`.
* If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* should be available for the vertices of `input`
* \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `input`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<InputMesh>::%vertex_descriptor` as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, input)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* should be available for the vertices of `input`.}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* @param np_out an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map}
* the property map that will contain the points associated to the vertices of `output`.
* If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* should be available for the vertices of `output`
* \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `ouput`}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<OutputMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, ouput)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* should be available for the vertices of `ouput`.}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*/
template <class InputMesh,
@ -225,36 +234,46 @@ void extrude_mesh(const InputMesh& input,
/**
* \ingroup PMP_meshing_grp
*
* fills `output` with a closed mesh bounding the volume swept by `input` when translating its
* vertices by `v`. The mesh is oriented so that the faces corresponding to `input`
* in `output` have the same orientation.
*
* \attention `output` may be self intersecting.
*
* @tparam InputMesh a model of the concept `FaceListGraph`
* @tparam OutputMesh a model of the concept `FaceListGraph` and `MutableFaceGraph`
* @tparam Vector_3 vector type from the same CGAL kernel as the point of the vertex point map used for `OutputMesh`.
* @tparam NamedParameters1 a sequence of \ref pmp_namedparameters "Named Parameters" for `InputMesh`
* @tparam NamedParameters2 a sequence of \ref pmp_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 v the vector defining the direction of the extrusion
* @param np_in an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map}
* the property map that contains the points associated to the vertices of `input`.
* If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* should be available for the vertices of `input`
* \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `input`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<InputMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, input)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* should be available for the vertices of `input`}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* @param np_out an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map}
* the property map that will contain the points associated to the vertices of `output`.
* If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* should be available for the vertices of `output`
* \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `ouput`}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<OutputMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, ouput)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* should be available for the vertices of `ouput`}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*/
template <class InputMesh,

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

@ -82,14 +82,35 @@ namespace internal {
@param tmesh the triangle mesh with patches to be faired
@param vertices the vertices of the patches to be faired (the positions of only those vertices will be changed)
@param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
@param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
\cgalNamedParamsBegin
\cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `tmesh`.
If this parameter is omitted, an internal property map for
`CGAL::vertex_point_t` must be available in `TriangleMesh`\cgalParamEnd
\cgalParamBegin{fairing_continuity} tangential continuity of the output surface patch. The larger `fairing_continuity` gets, the more fixed vertices are required \cgalParamEnd
\cgalParamBegin{sparse_linear_solver} an instance of the sparse linear solver used for fairing \cgalParamEnd
\cgalParamNBegin{vertex_point_map}
\cgalParamDescription{a property map associating points to the vertices of `tmesh`}
\cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
as key type and `%Point_3` as value type}
\cgalParamDefault{`boost::get(CGAL::vertex_point, tmesh)`}
\cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
should be available for the vertices of `input`.}
\cgalParamNEnd
\cgalParamNBegin{fairing_continuity}
\cgalParamDescription{A value controling the tangential continuity of the output surface patch.
The possible values are 0, 1 and 2, refering to the C<sup>0</sup>, C<sup>1</sup>
and C<sup>2</sup> continuity.}
\cgalParamType{unsigned int}
\cgalParamDefault{`1`}
\cgalParamExtra{The larger `fairing_continuity` gets, the more fixed vertices are required}
\cgalParamNEnd
\cgalParamNBegin{sparse_linear_solver}
\cgalParamDescription{an instance of the sparse linear solver used for fairing}
\cgalParamType{a class model of `SparseLinearAlgebraWithFactorTraits_d`}
\cgalParamDefault{If \ref thirdpartyEigen "Eigen" 3.2 (or greater) is available and
`CGAL_EIGEN3_ENABLED` is defined, then the following overload of `Eigen_solver_traits`
is provided as default value:\n
`CGAL::Eigen_solver_traits<Eigen::SparseLU<CGAL::Eigen_sparse_matrix<double>::%EigenType, Eigen::COLAMDOrdering<int> > >`}
\cgalParamNEnd
\cgalNamedParamsEnd
@return `true` if fairing is successful, otherwise no vertices are relocated

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

@ -50,7 +50,6 @@ template<class TM,
class VertexPointMap2>
struct Intersect_faces
{
// typedefs
typedef typename Kernel::Segment_3 Segment;
typedef typename Kernel::Triangle_3 Triangle;
@ -68,10 +67,6 @@ struct Intersect_faces
typename Kernel::Construct_triangle_3 triangle_functor;
typename Kernel::Do_intersect_3 do_intersect_3_functor;
Intersect_faces(const TM& tm1, const TM& tm2,
OutputIterator it,
VertexPointMap1 vpmap1, VertexPointMap2 vpmap2,
@ -137,9 +132,6 @@ struct Intersect_face_polyline
typename Kernel::Construct_triangle_3 triangle_functor;
typename Kernel::Do_intersect_3 do_intersect_3_functor;
Intersect_face_polyline(const TM& tm,
const std::vector<face_descriptor>& faces,
const Polyline& polyline,
@ -193,7 +185,6 @@ struct Intersect_face_polylines
typedef typename boost::property_map<TM, boost::vertex_point_t>::const_type Ppmap;
typedef typename boost::property_traits<Ppmap>::value_type Point;
// members
const TM& m_tm;
const std::vector<face_descriptor>& faces;
@ -205,9 +196,6 @@ struct Intersect_face_polylines
typename Kernel::Construct_triangle_3 triangle_functor;
typename Kernel::Do_intersect_3 do_intersect_3_functor;
Intersect_face_polylines(const TM& tm,
const std::vector<face_descriptor>& faces,
const PolylineRange& polylines,
@ -249,8 +237,6 @@ template<class Polyline,
class OutputIterator>
struct Intersect_polylines
{
// typedefs
typedef typename Kernel::Segment_3 Segment;
typedef typename Kernel::Point_3 Point;
@ -264,9 +250,6 @@ struct Intersect_polylines
typename Kernel::Construct_segment_3 segment_functor;
typename Kernel::Do_intersect_3 do_intersect_3_functor;
Intersect_polylines(const Polyline& polyline1,
const Polyline& polyline2,
OutputIterator it,
@ -299,8 +282,6 @@ template<class PolylineRange,
class OutputIterator>
struct Intersect_polyline_ranges
{
// typedefs
typedef typename Kernel::Segment_3 Segment;
typedef typename Kernel::Point_3 Point;
@ -314,9 +295,6 @@ struct Intersect_polyline_ranges
typename Kernel::Construct_segment_3 segment_functor;
typename Kernel::Do_intersect_3 do_intersect_3_functor;
Intersect_polyline_ranges(const PolylineRange& polyline1,
const PolylineRange& polyline2,
OutputIterator it,
@ -367,7 +345,7 @@ struct Throw_at_first_output {
* model of `RandomAccessRange`.
* \tparam OutputIterator a model of `OutputIterator` holding objects of type
* `std::pair<boost::graph_traits<TriangleMesh>::%face_descriptor, boost::graph_traits<TriangleMesh>::%face_descriptor>`
* \tparam NamedParameters a sequence of \ref pmp_namedparameters
* \tparam NamedParameters a sequence of \ref pmp_namedparameters "Named Parameters"
*
* \param face_range1 the range of faces of `tm1` to check for intersections.
* \param face_range2 the range of faces of `tm2` to check for intersections.
@ -375,15 +353,29 @@ struct Throw_at_first_output {
* \param tm2 the second triangulated surface mesh.
* \param out output iterator to be filled with all pairs of faces that intersect.
* First and second element in the pairs correspond to faces of `tm1` and `tm2` respectively
* \param np1 optional sequence of \ref pmp_namedparameters for `tm1`, among the ones listed below
* \param np2 optional sequence of \ref pmp_namedparameters for `tm2`, among the ones listed below
* \param np1 an optional sequence of \ref pmp_namedparameters for `tm1`, among the ones listed below
* \param np2 an optional sequence of \ref pmp_namedparameters for `tm2`, among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`\cgalParamEnd
* \cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `PMPSelfIntersectionTraits` \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tm1` (`tm2`)}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm1 (tm2))`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* should be available for the vertices of `tm1` (`tm2`)}
* \cgalParamExtra{Both vertex point map must have the same value type}
* \cgalParamNEnd
*
* \cgalParamNBegin{geom_traits}
* \cgalParamDescription{an instance of a geometric traits class}
* \cgalParamType{a class model of `PMPSelfIntersectionTraits`}
* \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 types}
* \cgalParamExtra{np1 only}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* \return `out`
*/
template <class TriangleMesh,
@ -493,20 +485,31 @@ compute_face_face_intersection(const FaceRange& face_range1,
* elements in their respective range. In the case of the polyline, this position is the index of
* the segment intersecting the face (which is the index of the first point of the
* segment following the range order.)
* \tparam NamedParameters a sequence of \ref pmp_namedparameters
* \tparam NamedParameters a sequence of \ref pmp_namedparameters "Named Parameters"
*
* \param face_range the range of faces of `tm` to check for intersections.
* \param polyline the polyline to check for intersections.
* \param tm the triangulated surface mesh to check for intersections.
* \param out output iterator to be filled with all pairs of face-segment that intersect
* \param np optional sequence of \ref pmp_namedparameters for `tm`, among the ones listed below
* \param np an optional sequence of \ref pmp_namedparameters for `tm`, among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `tm`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`\cgalParamEnd
* \cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `PMPSelfIntersectionTraits` \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tm`}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor` as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* should be available for the vertices of `tm`}
* \cgalParamNEnd
*
* \cgalParamNBegin{geom_traits}
* \cgalParamDescription{an instance of a geometric traits class}
* \cgalParamType{a class model of `PMPSelfIntersectionTraits`}
* \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 types}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* \return `out`
*/
template <class TriangleMesh,
@ -611,19 +614,30 @@ compute_face_polyline_intersection( const FaceRange& face_range,
* `std::pair<std::size_t, std::pair<std::size_t, std::size_t> >`.
* Each pair holds the index of the face and a pair containing the index of the polyline in the range and the index of
* the first point of the segment in the polyline.
* \tparam NamedParameters a sequence of \ref pmp_namedparameters
* \tparam NamedParameters a sequence of \ref pmp_namedparameters "Named Parameters"
*
* \param face_range the range of `tm` faces to check for intersections.
* \param polyline_range the range of polylines to check for intersections.
* \param tm the triangulated surface mesh to check for intersections.
* \param out output iterator to be filled with all pairs of face-segment that intersect
* \param np optional sequence of \ref pmp_namedparameters for `tm`, among the ones listed below
* \param np an optional sequence of \ref pmp_namedparameters for `tm`, among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `tm`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`\cgalParamEnd
* \cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `PMPSelfIntersectionTraits` \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tm`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* should be available for the vertices of `tm`}
* \cgalParamNEnd
*
* \cgalParamNBegin{geom_traits}
* \cgalParamDescription{an instance of a geometric traits class}
* \cgalParamType{a class model of `PMPSelfIntersectionTraits`}
* \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 types}
* \cgalParamNEnd
* \cgalNamedParamsEnd
* \return `out`
*/
@ -921,20 +935,33 @@ compute_polylines_polylines_intersection(const PolylineRange& polylines1,
* \tparam TriangleMesh a model of `FaceListGraph`
* \tparam OutputIterator a model of `OutputIterator` holding objects of type
* `std::pair<boost::graph_traits<TriangleMesh>::%face_descriptor, boost::graph_traits<TriangleMesh>::%face_descriptor>`
* \tparam NamedParameters a sequence of \ref pmp_namedparameters
* \tparam NamedParameters a sequence of \ref pmp_namedparameters "Named Parameters"
*
* \param tm1 the first triangulated surface mesh to check for intersections
* \param tm2 the second triangulated surface mesh to check for intersections
* \param out output iterator to be filled with all pairs of faces that intersect
* \param np1 optional sequence of \ref pmp_namedparameters for `tm1`, among the ones listed below
* \param np2 optional sequence of \ref pmp_namedparameters for `tm2`, among the ones listed below
* \param np1 an optional sequence of \ref pmp_namedparameters for `tm1`, among the ones listed below
* \param np2 an optional sequence of \ref pmp_namedparameters for `tm2`, among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`\cgalParamEnd
* \cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `PMPSelfIntersectionTraits` \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tm1` (`tm2`)}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm1 (tm2))`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* should be available for the vertices of `tm1` (`tm2`)}
* \cgalParamNEnd
*
* \cgalParamNBegin{geom_traits}
* \cgalParamDescription{an instance of a geometric traits class}
* \cgalParamType{a class model of `PMPSelfIntersectionTraits`}
* \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 types}
* \cgalParamExtra{np1 only}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* \return `out`
*/
template <class TriangleMesh,
@ -971,19 +998,30 @@ compute_face_face_intersection(const TriangleMesh& tm1,
* 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 pmp_namedparameters
* \tparam NamedParameters a sequence of \ref pmp_namedparameters "Named Parameters"
*
* \param tm the triangulated surface mesh to check for intersections.
* \param polyline the polyline to check for intersections.
* \param out output iterator to be filled with all pairs of face-segment that intersect
* \param np optional sequence of \ref pmp_namedparameters for `tm`, among the ones listed below
* \param np an optional sequence of \ref pmp_namedparameters for `tm`, among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`\cgalParamEnd
* \cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `PMPSelfIntersectionTraits` \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tm`}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor` as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* should be available for the vertices of `tm`}
* \cgalParamNEnd
*
* \cgalParamNBegin{geom_traits}
* \cgalParamDescription{an instance of a geometric traits class}
* \cgalParamType{a class model of `PMPSelfIntersectionTraits`}
* \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 types}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* \return `out`
*/
template <class TriangleMesh,
@ -1176,24 +1214,39 @@ bool do_intersect(const Polyline& polyline1,
* @pre `!do_overlap_test_of_bounded_sides || CGAL::is_closed(tm2)`
*
* @tparam TriangleMesh a model of `FaceListGraph`
* @tparam NamedParameters1 a sequence of \ref pmp_namedparameters for `tm1`
* @tparam NamedParameters2 a sequence of \ref pmp_namedparameters for `tm2`
* @tparam NamedParameters1 a sequence of \ref pmp_namedparameters "Named Parameters" for `tm1`
* @tparam NamedParameters2 a sequence of \ref pmp_namedparameters "Named Parameters" for `tm2`
*
* @param tm1 the first triangulated surface mesh to check for intersections
* @param tm2 the second triangulated surface mesh to check for intersections
* @param np1 optional sequence of \ref pmp_namedparameters for `tm1`, among the ones listed below
* @param np2 optional sequence of \ref pmp_namedparameters for `tm2`, among the ones listed below
* @param np1 an optional sequence of \ref pmp_namedparameters for `tm1`, among the ones listed below
* @param np2 an optional sequence of \ref pmp_namedparameters for `tm2`, among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `tm1` (`tm2`).
* \attention The two property maps must have the same `value_type`.
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tm1` (`tm2`)}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm1 (tm2))`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* should be available for the vertices of `tm1` (`tm2`)}
* \cgalParamExtra{Both vertex point map must have the same value type}
* \cgalParamNEnd
*
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`\cgalParamEnd
* \cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `PMPSelfIntersectionTraits` \cgalParamEnd
* \cgalParamBegin{do_overlap_test_of_bounded_sides} if set to `true` tests also the overlap of the bounded sides of `tm1` and `tm2`.
* If `false` (default), only the intersection of surface triangles are tested.
* \cgalParamEnd
* \cgalParamNBegin{geom_traits}
* \cgalParamDescription{an instance of a geometric traits class}
* \cgalParamType{a class model of `PMPSelfIntersectionTraits`}
* \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 types}
* \cgalParamExtra{np1 only}
* \cgalParamNEnd
*
* \cgalParamNBegin{do_overlap_test_of_bounded_sides}
* \cgalParamDescription{If `true`, also tests the overlap of the bounded sides of `tm1` and `tm2`.
* If `false`, only the intersection of surface triangles is tested.}
* \cgalParamType{Boolean}
* \cgalParamDefault{`false`}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
*/
@ -1269,13 +1322,23 @@ bool do_intersect(const TriangleMesh& tm1,
*
* @param tm the triangulated surface mesh to check for intersections
* @param polylines the range of polylines to check for intersections.
* @param np optional sequence of \ref pmp_namedparameters among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `tm`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`\cgalParamEnd
* \cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `PMPSelfIntersectionTraits` \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tm`}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor` as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* should be available for the vertices of `tm`}
* \cgalParamNEnd
*
* \cgalParamNBegin{geom_traits}
* \cgalParamDescription{an instance of a geometric traits class}
* \cgalParamType{a class model of `PMPSelfIntersectionTraits`}
* \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 types}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
*/
@ -1320,17 +1383,27 @@ bool do_intersect(const TriangleMesh& tm,
* \tparam Polyline a `RandomAccessRange` of points. The point type of the range must be the
* same as the value type of the vertex point map.
* \cgalDescribePolylineType
* @tparam NamedParameters a sequence of \ref pmp_namedparameters
* @tparam NamedParameters a sequence of \ref pmp_namedparameters "Named Parameters"
*
* @param tm the triangulated surface mesh to check for intersections
* @param polyline the polyline to check for intersections.
* @param np optional sequence of \ref pmp_namedparameters among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `tn`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`\cgalParamEnd
* \cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `PMPSelfIntersectionTraits` \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tm`}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor` as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* should be available for the vertices of `tm`}
* \cgalParamNEnd
*
* \cgalParamNBegin{geom_traits}
* \cgalParamDescription{an instance of a geometric traits class}
* \cgalParamType{a class model of `PMPSelfIntersectionTraits`}
* \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 types}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
*/
@ -1530,31 +1603,41 @@ struct Mesh_callback
*
* \tparam TriangleMeshRange a model of `RandomAccessRange` of triangulated surface meshes model of `FaceListGraph`.
* \tparam OutputIterator an output iterator in which `std::pair<std::size_t, std::size_t>` can be put.
* \tparam NamedParameters a sequence of \ref pmp_namedparameters for the algorithm
* \tparam NamedParametersRange a range of named parameters for the meshes.
* \tparam NamedParameters a sequence of \ref pmp_namedparameters "Named Parameters" for the algorithm
* \tparam NamedParametersRange a range of \ref pmp_namedparameters "Named Parameters" for the meshes.
*
* \param range the range of triangulated surface meshes to be checked for intersections.
* \param out output iterator used to collect pairs of intersecting meshes.
* \param np an optional sequence named parameters among the one listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `PMPSelfIntersectionTraits`.
* The default value for `geom_traits` is `CGAL::Kernel_traits<Point>::Kernel`, where `Point` is the
* value type of the vertex point map of the meshes.
* \cgalParamEnd
* \cgalParamBegin{do_overlap_test_of_bounded_sides} if set to `true` reports also overlap of bounded sides of meshes.
* If `false` (default), only the intersection of surface triangles are tested.
* \cgalParamEnd
* \cgalParamNBegin{geom_traits}
* \cgalParamDescription{an instance of a geometric traits class}
* \cgalParamType{a class model of `PMPSelfIntersectionTraits`}
* \cgalParamDefault{a \cgal Kernel deduced from the point type, using `CGAL::Kernel_traits`,
* where `Point` is the value type of the vertex point map of the meshes}
* \cgalParamNEnd
*
* \cgalParamNBegin{do_overlap_test_of_bounded_sides}
* \cgalParamDescription{If set to `true` reports also overlap of bounded sides of meshes.
* If `false`, only the intersection of surface triangles are tested.}
* \cgalParamType{Boolean}
* \cgalParamDefault{`false`}
* \cgalParamNEnd
* \cgalNamedParamsEnd
* \param nps an optional range of `vertex_point_map` named parameters containing the `VertexPointMap` of each mesh in `range`, in the same order.
* If this parameter is omitted, then an internal property map for `CGAL::vertex_point_t` must be available for every mesh in the range.
* All the vertex point maps must be of the same type.
*
* \param nps an optional range of named parameters among the one listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of a mesh.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in the triangle mesh type used in the range
* \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of a mesh `tm`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* should be available for the vertices of `tm`}
* \cgalParamExtra{All vertex point maps must have the same value type}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*/
@ -1636,19 +1719,28 @@ OutputIterator intersecting_meshes(const TriangleMeshRange& range,
* @param tm2 second input triangulated surface mesh
* @param polyline_output output iterator of polylines. Each polyline will be
* given as a vector of points
* @param np1 optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np2 optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np1 an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np2 an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map}
* a property map with the points associated to the vertices of `tm1`
* (`tm2`). The two property map types must be the same.
* \cgalParamEnd
* \cgalParamBegin{throw_on_self_intersection} if `true`, for each input triangle mesh,
* the set of triangles close to the intersection of `tm1` and `tm2` will be
* checked for self-intersection and `CGAL::Polygon_mesh_processing::Corefinement::Self_intersection_exception`
* will be thrown if at least one is found (`np1` only).
* \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tm1` (`tm2`)}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm1 (tm2))`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* should be available for the vertices of `tm1` (`tm2`)}
* \cgalParamExtra{Both vertex point map must have the same value type}
* \cgalParamNEnd
*
* \cgalParamNBegin{throw_on_self_intersection}
* \cgalParamDescription{If `true`, the set of triangles closed to the intersection of `tm1` and `tm2` will be
* checked for self-intersections and `Corefinement::Self_intersection_exception`
* will be thrown if at least one self-intersection is found.}
* \cgalParamType{Boolean}
* \cgalParamDefault{`false`}
* \cgalParamExtra{`np1` only}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
*/
@ -1688,10 +1780,10 @@ surface_intersection(const TriangleMesh& tm1,
namespace experimental {
/**
* \ingroup PMP_corefinement_grp
*
* computes the autointersection of triangles of `tm`. The output is a
* set of polylines with all vertices but endpoints being of degree 2.
*
*
* @tparam TriangleMesh a model of `HalfedgeListGraph` and `FaceListGraph`
* @tparam NamedParameters a sequence of \ref namedparameters
* @tparam OutputIterator an output iterator in which `std::vector` of points
@ -1701,12 +1793,15 @@ namespace experimental {
* @param tm input triangulated surface mesh
* @param polyline_output output iterator of polylines. Each polyline will be
* given as a vector of points
* @param np optional sequence of \ref namedparameters among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map}
* a property map with the points associated to the vertices of `tm`
* \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tm`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
*/

255
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/locate.h
View File

@ -569,15 +569,21 @@ get_descriptor_from_location(const std::pair<typename boost::graph_traits<Triang
/// \param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below:
///
/// \cgalNamedParamsBegin
/// \cgalParamBegin{vertex_point_map}
/// the property map with the points associated to the vertices of `tm`.
/// If this parameter is omitted, an internal property map for
/// `boost::vertex_point_t` must be available in `TriangleMesh`.
/// \cgalParamEnd
/// \cgalParamBegin{geom_traits}
/// a geometric traits class instance, model of `Kernel`. If such traits class is provided,
/// its type `FT` must be identical to the template parameter `FT` of this function.
/// \cgalParamEnd
/// \cgalParamNBegin{vertex_point_map}
/// \cgalParamDescription{a property map associating points to the vertices of `tm`}
/// \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
/// as key type and `%Point_3` as value type}
/// \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
/// \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.}
/// \cgalParamExtra{If such traits class is provided, its type `FT` must be identical
/// to the template parameter `FT` of this function.}
/// \cgalParamNEnd
/// \cgalNamedParamsEnd
///
/// \pre `loc.first` is a face descriptor corresponding to a face of `tm`.
@ -1075,23 +1081,32 @@ locate_on_halfedge(const typename boost::graph_traits<TriangleMesh>::halfedge_de
/// \param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below:
///
/// \cgalNamedParamsBegin
/// \cgalParamBegin{vertex_point_map}
/// the property map with the points associated to the vertices of `tm`.
/// If this parameter is omitted, an internal property map for
/// `boost::vertex_point_t` must be available in `TriangleMesh`.
/// \cgalParamEnd
/// \cgalParamBegin{geom_traits}
/// a geometric traits class instance, model of `Kernel`. If provided, the types `FT` and `Kernel::FT`
/// must be identical and the traits class must be compatible with the value type of the vertex point
/// property map.
/// \cgalParamEnd
/// \cgalParamBegin{snapping_tolerance}
/// a tolerance value used to snap barycentric coordinates. Depending on the geometric traits used,
/// the computation of the barycentric coordinates might be an inexact construction, thus leading
/// to sometimes surprising values (e.g. a triplet `[0.5, 0.5, -1-e17]` for a point at the middle
/// of an edge). The coordinates will be snapped towards `0` and `1` if the difference is smaller than the tolerance value, while
/// still ensuring that the total sum of the coordinates is `1`. By default, the tolerance is `0`.
/// \cgalParamEnd
/// \cgalParamNBegin{vertex_point_map}
/// \cgalParamDescription{a property map associating points to the vertices of `tm`}
/// \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
/// as key type and `%Point_3` as value type}
/// \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
/// \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.}
/// \cgalParamExtra{If such traits class is provided, its type `FT` must be identical
/// to the template parameter `FT` of this function.}
/// \cgalParamNEnd
///
/// \cgalParamNBegin{snapping_tolerance}
/// \cgalParamDescription{a tolerance value used to snap barycentric coordinates}
/// \cgalParamType{double}
/// \cgalParamDefault{`0`}
/// \cgalParamExtra{Depending on the geometric traits used, the computation of the barycentric coordinates
/// might be an inexact construction, thus leading to sometimes surprising values
/// (e.g. a triplet `[0.5, 0.5, -1-e17]` for a point at the middle of an edge).
/// The coordinates will be snapped towards `0` and `1` if the difference is smaller
/// than the tolerance value, while still ensuring that the total sum of the coordinates is `1`.}
/// \cgalParamNEnd
/// \cgalNamedParamsEnd
///
/// \pre `fd` is not the null face
@ -1563,16 +1578,20 @@ void build_AABB_tree(const TriangleMesh& tm,
/// \param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below:
///
/// \cgalNamedParamsBegin
/// \cgalParamBegin{vertex_point_map}
/// the property map with the points associated to the vertices of `tm`.
/// If this parameter is omitted, an internal property map for
/// `boost::vertex_point_t` must be available in `TriangleMesh`.
/// \cgalParamEnd
/// \cgalParamBegin{geom_traits}
/// a geometric traits class instance, model of `Kernel` compatible with the point type held
/// in the vertex point property map (either user-provided or internal to the mesh).
/// Must be identical to the traits used in the template parameter of the `AABB_traits`.
/// \cgalParamEnd
/// \cgalParamNBegin{vertex_point_map}
/// \cgalParamDescription{a property map associating points to the vertices of `tm`}
/// \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
/// as key type and `%Point_3` as value type}
/// \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
/// \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.}
/// \cgalParamExtra{Must be identical to the traits used in the template parameter of the `AABB_traits`.}
/// \cgalParamNEnd
/// \cgalNamedParamsEnd
///
template <typename TriangleMesh, typename Point3VPM, typename NamedParameters>
@ -1626,23 +1645,31 @@ void build_AABB_tree(const TriangleMesh& tm, AABB_tree<AABBTraits>& outTree)
/// \param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below:
///
/// \cgalNamedParamsBegin
/// \cgalParamBegin{vertex_point_map}
/// the property map with the points associated to the vertices of `tm`.
/// If this parameter is omitted, an internal property map for
/// `boost::vertex_point_t` must be available in `TriangleMesh`.
/// \cgalParamEnd
/// \cgalParamBegin{geom_traits}
/// a geometric traits class instance, model of `Kernel` compatible with the point type held
/// in the vertex point property map (either user-provided or internal to the mesh).
/// Must be identical to the traits used in the template parameter of the `AABB_traits`.
/// \cgalParamEnd
/// \cgalParamBegin{snapping_tolerance}
/// a tolerance value used to snap barycentric coordinates. Depending on the geometric traits used,
/// the computation of the barycentric coordinates might be an inexact construction, thus leading
/// to sometimes surprising values (e.g. a triplet `[0.5, 0.5, -1-e17]` for a point at the middle
/// of an edge). The coordinates will be snapped towards `0` and `1` if the difference is smaller than the tolerance value, while
/// still ensuring that the total sum of the coordinates is `1`. By default, the tolerance is `0`.
/// \cgalParamEnd
/// \cgalParamNBegin{vertex_point_map}
/// \cgalParamDescription{a property map associating points to the vertices of `tm`}
/// \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
/// as key type and `%Point_3` as value type}
/// \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
/// \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.}
/// \cgalParamExtra{Must be identical to the traits used in the template parameter of the `AABB_traits`.}
/// \cgalParamNEnd
///
/// \cgalParamNBegin{snapping_tolerance}
/// \cgalParamDescription{a tolerance value used to snap barycentric coordinates}
/// \cgalParamType{double}
/// \cgalParamDefault{`0`}
/// \cgalParamExtra{Depending on the geometric traits used, the computation of the barycentric coordinates
/// might be an inexact construction, thus leading to sometimes surprising values
/// (e.g. a triplet `[0.5, 0.5, -1-e17]` for a point at the middle of an edge).
/// The coordinates will be snapped towards `0` and `1` if the difference is smaller
/// than the tolerance value, while still ensuring that the total sum of the coordinates is `1`.}
/// \cgalParamNEnd
/// \cgalNamedParamsEnd
///
/// \returns a face location. The type `FT` is deduced from the geometric traits, either provided by
@ -1722,22 +1749,30 @@ locate_with_AABB_tree(const typename internal::Location_traits<TriangleMesh>::Po
/// \param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below:
///
/// \cgalNamedParamsBegin
/// \cgalParamBegin{vertex_point_map}
/// the property map with the points associated to the vertices of `tm`.
/// If this parameter is omitted, an internal property map for
/// `boost::vertex_point_t` must be available in `TriangleMesh`.
/// \cgalParamEnd
/// \cgalParamBegin{geom_traits}
/// a geometric traits class instance, model of `Kernel` compatible with the point type held
/// in the vertex point property map (either user-provided or internal to the mesh).
/// \cgalParamEnd
/// \cgalParamBegin{snapping_tolerance}
/// a tolerance value used to snap barycentric coordinates. Depending on the geometric traits used,
/// the computation of the barycentric coordinates might be an inexact construction, thus leading
/// to sometimes surprising values (e.g. a triplet `[0.5, 0.5, -1-e17]` for a point at the middle
/// of an edge). The coordinates will be snapped towards `0` and `1` if the difference is smaller than the tolerance value, while
/// still ensuring that the total sum of the coordinates is `1`. By default, the tolerance is `0`.
/// \cgalParamEnd
/// \cgalParamNBegin{vertex_point_map}
/// \cgalParamDescription{a property map associating points to the vertices of `tm`}
/// \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
/// as key type and `%Point_3` as value type}
/// \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
/// \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{snapping_tolerance}
/// \cgalParamDescription{a tolerance value used to snap barycentric coordinates}
/// \cgalParamType{double}
/// \cgalParamDefault{`0`}
/// \cgalParamExtra{Depending on the geometric traits used, the computation of the barycentric coordinates
/// might be an inexact construction, thus leading to sometimes surprising values
/// (e.g. a triplet `[0.5, 0.5, -1-e17]` for a point at the middle of an edge).
/// The coordinates will be snapped towards `0` and `1` if the difference is smaller
/// than the tolerance value, while still ensuring that the total sum of the coordinates is `1`.}
/// \cgalParamNEnd
/// \cgalNamedParamsEnd
///
template <typename TriangleMesh, typename NamedParameters>
@ -1808,23 +1843,31 @@ locate(const typename property_map_value<TriangleMesh, boost::vertex_point_t>::t
/// \param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below:
///
/// \cgalNamedParamsBegin
/// \cgalParamBegin{vertex_point_map}
/// the property map with the points associated to the vertices of `tm`.
/// If this parameter is omitted, an internal property map for
/// `boost::vertex_point_t` must be available in `TriangleMesh`.
/// \cgalParamEnd
/// \cgalParamBegin{geom_traits}
/// a geometric traits class instance, model of `Kernel` compatible with the point type held
/// in the vertex point property map (either user-provided or internal to the mesh).
/// Must be identical to the traits used in the template parameter of the `AABB_traits`.
/// \cgalParamEnd
/// \cgalParamBegin{snapping_tolerance}
/// a tolerance value used to snap barycentric coordinates. Depending on the geometric traits used,
/// the computation of the barycentric coordinates might be an inexact construction, thus leading
/// to sometimes surprising values (e.g. a triplet `[0.5, 0.5, -1-e17]` for a point at the middle
/// of an edge). The coordinates will be snapped towards `0` and `1` if the difference is smaller than the tolerance value, while
/// still ensuring that the total sum of the coordinates is `1`. By default, the tolerance is `0`.
/// \cgalParamEnd
/// \cgalParamNBegin{vertex_point_map}
/// \cgalParamDescription{a property map associating points to the vertices of `tm`}
/// \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
/// as key type and `%Point_3` as value type}
/// \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
/// \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.}
/// \cgalParamExtra{Must be identical to the traits used in the template parameter of the `AABB_traits`.}
/// \cgalParamNEnd
///
/// \cgalParamNBegin{snapping_tolerance}
/// \cgalParamDescription{a tolerance value used to snap barycentric coordinates}
/// \cgalParamType{double}
/// \cgalParamDefault{`0`}
/// \cgalParamExtra{Depending on the geometric traits used, the computation of the barycentric coordinates
/// might be an inexact construction, thus leading to sometimes surprising values
/// (e.g. a triplet `[0.5, 0.5, -1-e17]` for a point at the middle of an edge).
/// The coordinates will be snapped towards `0` and `1` if the difference is smaller
/// than the tolerance value, while still ensuring that the total sum of the coordinates is `1`.}
/// \cgalParamNEnd
/// \cgalNamedParamsEnd
///
/// \pre `ray` is an object with the same ambient dimension as the point type (the value type of the vertex point map).
@ -1943,22 +1986,30 @@ locate_with_AABB_tree(const typename internal::Location_traits<TriangleMesh>::Ra
/// \param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below:
///
/// \cgalNamedParamsBegin
/// \cgalParamBegin{vertex_point_map}
/// the property map with the points associated to the vertices of `tm`.
/// If this parameter is omitted, an internal property map for
/// `boost::vertex_point_t` must be available in `TriangleMesh`.
/// \cgalParamEnd
/// \cgalParamBegin{geom_traits}
/// a geometric traits class instance, model of `Kernel` compatible with the point type held
/// in the vertex point property map (either user-provided or internal to the mesh).
/// \cgalParamEnd
/// \cgalParamBegin{snapping_tolerance}
/// a tolerance value used to snap barycentric coordinates. Depending on the geometric traits used,
/// the computation of the barycentric coordinates might be an inexact construction, thus leading
/// to sometimes surprising values (e.g. a triplet `[0.5, 0.5, -1-e17]` for a point at the middle
/// of an edge). The coordinates will be snapped towards `0` and `1` if the difference is smaller than the tolerance value, while
/// still ensuring that the total sum of the coordinates is `1`. By default, the tolerance is `0`.
/// \cgalParamEnd
/// \cgalParamNBegin{vertex_point_map}
/// \cgalParamDescription{a property map associating points to the vertices of `tm`}
/// \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
/// as key type and `%Point_3` as value type}
/// \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
/// \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{snapping_tolerance}
/// \cgalParamDescription{a tolerance value used to snap barycentric coordinates}
/// \cgalParamType{double}
/// \cgalParamDefault{`0`}
/// \cgalParamExtra{Depending on the geometric traits used, the computation of the barycentric coordinates
/// might be an inexact construction, thus leading to sometimes surprising values
/// (e.g. a triplet `[0.5, 0.5, -1-e17]` for a point at the middle of an edge).
/// The coordinates will be snapped towards `0` and `1` if the difference is smaller
/// than the tolerance value, while still ensuring that the total sum of the coordinates is `1`.}
/// \cgalParamNEnd
/// \cgalNamedParamsEnd
///
/// \pre `ray` is an object with the same ambient dimension as the point type (the value type of the vertex point map).

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

@ -60,13 +60,22 @@ namespace Polygon_mesh_processing {
*
* @param h one halfedge of the edge to compute the length
* @param pmesh the polygon mesh to which `h` belongs
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `PolygonMesh`\cgalParamEnd
* \cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `Kernel`\cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `pmesh`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, pmesh)`}
* \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
* \cgalNamedParamsEnd
*
* @return the length of `h`. The return type `FT` is a number type. It is
@ -140,13 +149,22 @@ edge_length(typename boost::graph_traits<PolygonMesh>::edge_descriptor e,
*
* @param h a halfedge of the border polyline of which the length is computed
* @param pmesh the polygon mesh to which `h` belongs
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `PolygonMesh`\cgalParamEnd
* \cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `Kernel`\cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `pmesh`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, pmesh)`}
* \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
* \cgalNamedParamsEnd
*
* @return the length of the sequence of border edges of `face(h, pmesh)`.
@ -201,13 +219,22 @@ face_border_length(typename boost::graph_traits<PolygonMesh>::halfedge_descripto
* @tparam NamedParameters a sequence of \ref pmp_namedparameters "Named Parameters"
*
* @param pmesh the polygon mesh
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `PolygonMesh`\cgalParamEnd
* \cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `Kernel`\cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `pmesh`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, pmesh)`}
* \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
* \cgalNamedParamsEnd
*
* @return a pair composed of two members:
@ -282,13 +309,22 @@ longest_border(const PolygonMesh& pmesh)
*
* @param f the face of which the area is computed
* @param tmesh the triangulated surface mesh to which `f` belongs
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`\cgalParamEnd
* \cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `Kernel`\cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tmesh`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tmesh)`}
* \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
* \cgalNamedParamsEnd
*
* @pre `f != boost::graph_traits<TriangleMesh>::%null_face()`
@ -356,13 +392,22 @@ face_area(typename boost::graph_traits<TriangleMesh>::face_descriptor f,
*
* @param face_range the range of faces of which the area is computed
* @param tmesh the triangulated surface mesh to which the faces of `face_range` belong
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`\cgalParamEnd
* \cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `Kernel` \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tmesh`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tmesh)`}
* \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
* \cgalNamedParamsEnd
*
* @return sum of face areas of `faces`.
@ -416,13 +461,22 @@ area(FaceRange face_range, const TriangleMesh& tmesh)
* @tparam NamedParameters a sequence of \ref pmp_namedparameters "Named Parameters"
*
* @param tmesh the triangulated surface mesh
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`\cgalParamEnd
* \cgalParamBegin{geom_traits}an instance of a geometric traits class, model of `Kernel`\cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tmesh`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tmesh)`}
* \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
* \cgalNamedParamsEnd
*
* @return the surface area of `tmesh`.
@ -466,15 +520,24 @@ area(const TriangleMesh& tmesh)
* @tparam NamedParameters a sequence of \ref pmp_namedparameters "Named Parameters"
*
* @param tmesh the closed triangulated surface mesh bounding the volume
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* @pre `tmesh` is closed
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`\cgalParamEnd
* \cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `Kernel`\cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tmesh`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tmesh)`}
* \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
* \cgalNamedParamsEnd
*
* @return the volume bounded by `tmesh`.
@ -539,13 +602,22 @@ volume(const TriangleMesh& tmesh)
*
* @param f the face of which the aspect ratio is computed
* @param tmesh the triangulated surface mesh to which `f` belongs
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`\cgalParamEnd
* \cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `Kernel`\cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tmesh`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tmesh)`}
* \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
* \cgalNamedParamsEnd
*
* @pre `f != boost::graph_traits<TriangleMesh>::%null_face()`
@ -649,15 +721,24 @@ face_aspect_ratio(typename boost::graph_traits<TriangleMesh>::face_descriptor f,
* @tparam NamedParameters a sequence of \ref pmp_namedparameters "Named Parameters"
*
* @param tmesh the closed triangulated surface mesh bounding the volume
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* @pre `tmesh` is closed
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`\cgalParamEnd
* \cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `Kernel`\cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tmesh`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tmesh)`}
* \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
* \cgalNamedParamsEnd
*
* @return the centroid of the domain bounded by `tmesh`.

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

@ -9,6 +9,7 @@
//
//
// Author(s) : Sebastien Loriot
// Mael Rouxel-Labbé
#ifndef CGAL_POLYGON_MESH_PROCESSING_MERGE_BORDER_VERTICES_H
#define CGAL_POLYGON_MESH_PROCESSING_MERGE_BORDER_VERTICES_H
@ -265,14 +266,15 @@ void merge_vertices_in_range(const HalfedgeRange& sorted_hedges,
///
/// @param h a halfedge that belongs to a boundary cycle.
/// @param pm the polygon mesh which contains the boundary cycle.
/// @param np optional parameter of \ref pmp_namedparameters "Named Parameters" listed below.
/// @param np an optional parameter of \ref pmp_namedparameters "Named Parameters" listed below.
///
/// \cgalNamedParamsBegin
/// \cgalParamBegin{vertex_point_map}
/// the property map with the points associated to the vertices of `pm`.
/// If this parameter is omitted, an internal property map for
/// `CGAL::vertex_point_t` should be available in `PolygonMesh`
/// \cgalParamEnd
/// \cgalParamNBegin{vertex_point_map}
/// \cgalParamDescription{a property map associating points to the vertices of `pm`}
/// \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
/// as key type and `%Point_3` as value type}
/// \cgalParamDefault{`boost::get(CGAL::vertex_point, pm)`}
/// \cgalParamNEnd
/// \cgalNamedParamsEnd
template <class PolygonMesh, class NamedParameter>
void merge_duplicated_vertices_in_boundary_cycle(
@ -318,14 +320,15 @@ void merge_duplicated_vertices_in_boundary_cycle(
/// @tparam NamedParameter a sequence of \ref pmp_namedparameters "Named Parameters".
///
/// @param pm the polygon mesh which contains the cycles.
/// @param np optional parameter of \ref pmp_namedparameters "Named Parameters" listed below.
/// @param np an optional parameter of \ref pmp_namedparameters "Named Parameters" listed below.
///
/// \cgalNamedParamsBegin
/// \cgalParamBegin{vertex_point_map}
/// the property map with the points associated to the vertices of `pm`.
/// If this parameter is omitted, an internal property map for
/// `CGAL::vertex_point_t` should be available in `PolygonMesh`
/// \cgalParamEnd
/// \cgalParamNBegin{vertex_point_map}
/// \cgalParamDescription{a property map associating points to the vertices of `pm`}
/// \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
/// as key type and `%Point_3` as value type}
/// \cgalParamDefault{`boost::get(CGAL::vertex_point, pm)`}
/// \cgalParamNEnd
/// \cgalNamedParamsEnd
///
/// \sa `merge_duplicated_vertices_in_boundary_cycle()`

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

@ -154,14 +154,22 @@ namespace internal{
* @tparam NamedParameters a sequence of \ref pmp_namedparameters "Named Parameters"
*
* @param pmesh the closed polygon mesh to be tested
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`
* \cgalParamEnd
* \cgalParamBegin{geom_traits} a geometric traits class instance \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `pmesh`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, pmesh)`}
* \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
* \cgalNamedParamsEnd
*
* \note This function is only doing an orientation test for one connected component of `pmesh`.
@ -361,22 +369,36 @@ void reverse_face_orientations(const FaceRange& face_range, PolygonMesh& pmesh)
* @tparam NamedParameters a sequence of \ref pmp_namedparameters
*
* @param tm a closed triangulated surface mesh
* @param np optional sequence of \ref pmp_namedparameters among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters among the ones listed below
*
* \pre `CGAL::is_closed(tm)`
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map}
* the property map with the points associated to the vertices of `tm`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`
* \cgalParamEnd
* \cgalParamBegin{face_index_map}
* a property map containing the index of each face of `tm`.
* \cgalParamEnd
* \cgalParamBegin{outward_orientation}
* if set to `true` (default) indicates that each connected component will be outward oriented,
* (inward oriented if `false`).
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tm`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
* \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{face_index_map}
* \cgalParamDescription{a property map associating to each face of `tm` a unique index between `0` and `num_faces(tm) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%face_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamNEnd
*
* \cgalParamNBegin{outward_orientation}
* \cgalParamDescription{If `true`, each connected component will be outward oriented (and inward oriented if `false`).}
* \cgalParamType{Boolean}
* \cgalParamDefault{`true`}
* \cgalParamEnd
* \cgalNamedParamsEnd
*/
@ -663,90 +685,125 @@ void set_cc_intersecting_pairs(
*
* @tparam TriangleMesh a model of `FaceListGraph`
* @tparam VolumeFaceIndexMap a model of `WritablePropertyMap` with
* `boost::graph_traits<PolygonMesh>::%face_descriptor` as key type and
* `boost::graph_traits<PolygonMesh>::%faces_size_type` as value type.
* `boost::graph_traits<TriangleMesh>::%face_descriptor` as key type and
* `boost::graph_traits<TriangleMesh>::%faces_size_type` as value type.
* @tparam NamedParameters a sequence of \ref pmp_namedparameters "Named Parameters"
*
* @param tm the input triangle mesh
* @param volume_id_map the property map filled by this function with indices of volume components associated to the faces of `tm`
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* @pre `CGAL::is_closed(tm)`
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map}
* the property map with the points associated to the vertices of `tm`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`
* \cgalParamEnd
* \cgalParamBegin{face_index_map}
* a property map containing a unique id per face of `tm`, in the range `[0, num_faces(tm)[`
* \cgalParamEnd
* \cgalParamBegin{face_connected_component_map}
* a property map filled by this function and that will contain for each face the id
* of its surface component in the range `[0, number of surface components - 1[`
* \cgalParamEnd
* \cgalParamBegin{volume_inclusions}
* a `reference_wrapper` (either from `boost` or the standard library) containing
* a reference to an object that must be a model of the `BackInsertionSequence` concept,
* with a value type being a model of `BackInsertionSequence` of `std::size_t`,
* both types having the functions `reserve()` and `push_back()`.
* The size of the container is exactly the number of surface components of `tm`.
* The container at position `k` contains the ids of all the
* surface components that are the first intersected by any ray with source on
* the surface component `k` and directed outside the volume enclosed by the
* surface component `k`. There is only one such id but when some surface components intersect.
* \cgalParamEnd
* \cgalParamBegin{do_orientation_tests}
* if `true` (the default value), the orientation of the faces of
* each surface components will be taken into account for the definition of the volume.
* If `false`, the face orientation is ignored and the volumes are defined only by the
* nesting of surface components.
* \cgalParamEnd
* \cgalParamBegin{error_codes}
* a `reference_wrapper` (either from `boost` or the standard library) containing
* a reference to a container that must be a model of the `BackInsertionSequence` concept,
* with a `value_type` being \link PMP_orientation_grp `Volume_error_code` \endlink
* The size of the container is exactly the number of volume components.
* The container indicates the status of a volume assigned to a set of faces.
* The description of the value type is given in the documentation of the enumeration type.
* \cgalParamEnd
* \cgalParamBegin{do_self_intersection_tests}
* If `false` (the default value), it is assumed that `tm` does not contains any self-intersections.
* if `true`, the input might contain some self-intersections and a test is done
* prior to the volume decomposition.
* \cgalParamEnd
* \cgalParamBegin{connected_component_id_to_volume_id}
* a `reference_wrapper` (either from `boost` or the standard library) containing
* a reference to a container that must be a model of the `BackInsertionSequence` concept,
* with a value_type being `std::size_t`.
* The size of the container is exactly the number of connected components.
* For each connected component identified using its id `ccid`, the id of the volume it contributes
* to describe is the value at the position `ccid` in the container.
* \cgalParamEnd
* \cgalParamBegin{nesting_levels}
* a `reference_wrapper` (either from `boost` or the standard library) containing
* a reference to a container that must be a model of the `BackInsertionSequence` concept,
* with a `value_type` being `std::size_t`.
* The size of the container is exactly the number of connected components.
* For each connected component identified using its id `ccid`, the container contains the number of
* connected components containing on its bounded side this component.
* \cgalParamEnd
* \cgalParamBegin{is_cc_outward_oriented}
* a `reference_wrapper` (either from `boost` or the standard library) containing
* a reference to a container that must be a model of the `BackInsertionSequence` concept,
* with a `value_type` being `bool`.
* The size of the container is exactly the number of connected components.
* For each connected component identified using its id `ccid`, the output of `is_outward_oriented()`
* called on the triangle mesh corresponding to this connected component
* is the value at the position `ccid` in the container.
* \cgalParamEnd
* \cgalParamBegin{intersecting_volume_pairs_output_iterator}
* Output iterator into which pairs of ids (id must be convertible to `std::size_t`) can be put.
* Each pair of connected components intersecting will be reported using their ids.
* If `do_self_intersection_tests` named parameter is set to `false`, nothing will be reported.
* \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tm`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
* \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{face_index_map}
* \cgalParamDescription{a property map associating to each face of `tm` a unique index between `0` and `num_faces(tm) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%face_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamNEnd
*
* \cgalParamNBegin{face_connected_component_map}
* \cgalParamDescription{a property map filled by this function and that will contain for each face the id
* of its surface component in the range `[0, number of surface components - 1[`}
* \cgalParamType{a class model of `WritablePropertyMap` with `boost::graph_traits<TriangleMesh>::%face_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamNEnd
*
* \cgalParamNBegin{volume_inclusions}
* \cgalParamDescription{a container, which contains at position `k` the ids of all the
* surface components that are the first intersected by any ray with source on
* the surface component `k` and directed outside the volume enclosed by the
* surface component `k`. There is only one such id but when some surface components intersect.
* The size of the container is exactly the number of surface components of `tm`.}
* \cgalParamType{a `reference_wrapper` (either from `boost` or the standard library) containing
* a reference to an object that must be a model of the `BackInsertionSequence` concept,
* with a value type being a model of `BackInsertionSequence` of `std::size_t`,
* both types having the functions `reserve()` and `push_back()`}
* \cgalParamDefault{unused}
* \cgalParamNEnd
*
* \cgalParamNBegin{do_orientation_tests}
* \cgalParamDescription{If `true`, the orientation of the faces of each surface components
* will be taken into account for the definition of the volume.
* If `false`, the face orientation is ignored and the volumes are defined
* only by the nesting of surface components.}
* \cgalParamType{Boolean}
* \cgalParamDefault{`true`}
* \cgalParamNEnd
*
* \cgalParamNBegin{error_codes}
* \cgalParamDescription{a container which indicates the status of a volume assigned to a set of faces.
* The description of the value type is given in the documentation of the enumeration type.
* The size of the container is exactly the number of volume components.}
* \cgalParamType{a `reference_wrapper` (either from `boost` or the standard library) containing
* a reference to a container that must be a model of the `BackInsertionSequence` concept,
* with value type \link PMP_orientation_grp `Volume_error_code` \endlink}
* \cgalParamDefault{unused}
* \cgalParamNEnd
*
* \cgalParamNBegin{do_self_intersection_tests}
* \cgalParamDescription{If `false`, it is assumed that `tm` does not contains any self-intersections.
* If `true`, the input might contain some self-intersections and a test is done prior to the volume decomposition.}
* \cgalParamType{Boolean}
* \cgalParamDefault{`false`}
* \cgalParamNEnd
*
* \cgalParamNBegin{connected_component_id_to_volume_id}
* \cgalParamDescription{For each connected component identified using its id `ccid`, the id
* of the volume it contributes to describe is the value at the position
* `ccid` in the container. The size of the container is exactly the number
* of connected components.}
* \cgalParamType{a `reference_wrapper` (either from `boost` or the standard library) containing
* a reference to a container that must be a model of the `BackInsertionSequence` concept,
* with value type `std::size_t`}
* \cgalParamDefault{unused}
* \cgalParamNEnd
*
*
* \cgalParamNBegin{nesting_levels}
* \cgalParamDescription{For each connected component identified using its id `ccid`, the container contains the number of
* connected components containing on its bounded side this component.
* The size of the container is exactly the number of connected components.}
* \cgalParamType{a `reference_wrapper` (either from `boost` or the standard library) containing
* a reference to a container that must be a model of the `BackInsertionSequence` concept,
* with value type `std::size_t`}
* \cgalParamDefault{unused}
* \cgalParamNEnd
*
* \cgalParamNBegin{is_cc_outward_oriented}
* \cgalParamDescription{For each connected component identified using its id `ccid`, the output of `is_outward_oriented()`
* called on the triangle mesh corresponding to this connected component
* is the value at the position `ccid` in the container.
* The size of the container is exactly the number of connected components.}
* \cgalParamType{a `reference_wrapper` (either from `boost` or the standard library) containing
* a reference to a container that must be a model of the `BackInsertionSequence` concept,
* with value type `bool`}
* \cgalParamDefault{unused}
* \cgalParamNEnd
*
* \cgalParamNBegin{intersecting_volume_pairs_output_iterator}
* \cgalParamDescription{Output iterator into which pairs of ids (id must be convertible to `std::size_t`) can be put.
* Each pair of connected components intersecting will be reported using their ids.
* If `do_self_intersection_tests` named parameter is set to `false`, nothing will be reported.}
* \cgalParamType{a model of `OutputIterator`}
* \cgalParamDefault{unused}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* \return the number of volume components defined by `tm`
@ -1179,27 +1236,35 @@ volume_connected_components(const TriangleMesh& tm,
* @tparam NamedParameters a sequence of \ref pmp_namedparameters "Named Parameters"
*
* @param tm a closed triangulated surface mesh
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* @pre `CGAL::is_closed(tm)`
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map}
* the property map with the points associated to the vertices of `tm`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`
* \cgalParamEnd
* \cgalParamBegin{face_index_map}
* a property map containing the index of each face of `tm`.
* \cgalParamEnd
* \cgalParamBegin{is_cc_outward_oriented}
* a `reference_wrapper` (either from `boost` or the standard library) containing
* a reference to an object of type `std::vector<bool>`.
* The size of the vector is exactly the number of connected components.
* For each connected component identified using its id `ccid`, the output of `is_outward_oriented`
* called on the submesh corresponding to this connected component
* is the value at the position `ccid` in the parameter vector.
* \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tm`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
* \cgalParamNEnd
*
* \cgalParamNBegin{face_index_map}
* \cgalParamDescription{a property map associating to each face of `tm` a unique index between `0` and `num_faces(tm) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%face_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamNEnd
*
* \cgalParamNBegin{is_cc_outward_oriented}
* \cgalParamDescription{For each connected component identified using its id `ccid`, the output of `is_outward_oriented()`
* called on the triangle mesh corresponding to this connected component
* is the value at the position `ccid` in the container.
* The size of the container is exactly the number of connected components.}
* \cgalParamType{a `reference_wrapper` (either from `boost` or the standard library) containing
* a reference to a container that must be a model of the `BackInsertionSequence` concept,
* with value type `bool`}
* \cgalParamDefault{unused}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* \see `CGAL::Polygon_mesh_processing::orient_to_bound_a_volume()`
@ -1246,23 +1311,31 @@ std::size_t volume_connected_components(const TriangleMesh& tm, VolumeFaceIndexM
* @tparam NamedParameters a sequence of \ref pmp_namedparameters
*
* @param tm a closed triangulated surface mesh
* @param np optional sequence of \ref pmp_namedparameters among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters among the ones listed below
*
* @pre `CGAL::is_closed(tm)`
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map}
* the property map with the points associated to the vertices of `tm`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`
* \cgalParamEnd
* \cgalParamBegin{face_index_map}
* a property map containing the index of each face of `tm`.
* \cgalParamEnd
* \cgalParamBegin{outward_orientation}
* if set to `true` (default) the outer connected components will be outward oriented (inward oriented if set to `false`).
* If the outer connected components are inward oriented, it means that the infinity will be considered
* as part of the volume bounded by `tm`.
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tm`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
* \cgalParamNEnd
*
* \cgalParamNBegin{face_index_map}
* \cgalParamDescription{a property map associating to each face of `tm` a unique index between `0` and `num_faces(tm) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%face_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamNEnd
*
* \cgalParamNBegin{outward_orientation}
* \cgalParamDescription{If `true`, each connected component will be outward oriented (and inward oriented if `false`).}
* \cgalParamType{Boolean}
* \cgalParamDefault{`true`}
* \cgalParamExtra{If the outer connected components are inward oriented,
* it means that the infinity will be considered as part of the volume bounded by `tm`.}
* \cgalParamEnd
* \cgalNamedParamsEnd
*

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

@ -44,14 +44,15 @@ namespace Polygon_mesh_processing {
/// \param mesh the mesh whose faces are being put in the polygon soup
/// \param points points making the polygons of the soup
/// \param polygons each element in the vector describes a polygon using the indices of the points in `points`
/// \param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
/// \param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
///
/// \cgalNamedParamsBegin
/// \cgalParamBegin{vertex_point_map}
/// a model of `ReadablePropertyMap`, the property map with the points associated to the vertices of `mesh`.
/// If this parameter is omitted, an internal property map for
/// `CGAL::vertex_point_t` must be available in `PolygonMesh`.
/// \cgalParamEnd
/// \cgalParamNBegin{vertex_point_map}
/// \cgalParamDescription{a property map associating points to the vertices of `mesh`}
/// \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
/// as key type and `%Point_3` as value type}
/// \cgalParamDefault{`boost::get(CGAL::vertex_point, mesh)`}
/// \cgalParamNEnd
/// \cgalNamedParamsEnd
///
/// \cgalAdvancedBegin

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

@ -227,20 +227,23 @@ bool is_polygon_soup_a_polygon_mesh(const PolygonRange& polygons)
* @param np_ps optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{point_map}
* a model of `ReadablePropertyMap` whose value type is a point type convertible to the point type
* of the vertex point map associated to the polygon mesh. If this parameter is omitted, `CGAL::Identity_property_map` is used.
* \cgalParamEnd
* \cgalParamNBegin{point_map}
* \cgalParamDescription{a property map associating points to the elements of the range `points`}
* \cgalParamType{a model of `ReadablePropertyMap` whose value type is a point type convertible to the point type
* of the vertex point map associated to the polygon mesh}
* \cgalParamDefault{`CGAL::Identity_property_map`}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* @param np_pm optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map}
* a model of `WritablePropertyMap`, the property map with the points associated to the vertices of `out`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `PolygonMesh`.
* \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `out`}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, out)`}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* \sa `CGAL::Polygon_mesh_processing::orient_polygon_soup()`

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

@ -112,24 +112,43 @@ namespace internal {
* @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 optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{geom_traits} a geometric traits class instance, model of `Kernel`.
* \cgalParamEnd
* \cgalParamBegin{vertex_point_map} the property map with the points associated
* to the vertices of `tmesh`. Instance of a class model of `ReadWritePropertyMap`.
* \cgalParamEnd
* \cgalParamBegin{vertex_is_constrained_map} a property map containing the
* constrained-or-not status of each vertex of `tmesh`. A constrained vertex
* cannot be modified at all during perturbation
* \cgalParamEnd
* \cgalParamBegin{do_project} a boolean that sets whether vertices are reprojected
* on the input surface after their coordinates random perturbation
* \cgalParamEnd
* \cgalParamBegin{random_seed} a non-negative integer value to seed the random
number generator, and make the perturbation deterministic
* \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tmesh`}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tmesh)`}
* \cgalParamNEnd
*
* \cgalParamNBegin{geom_traits}
* \cgalParamDescription{an instance of a geometric traits class}
* \cgalParamType{a class model of `Kernel`}
* \cgalParamDefault{a \cgal Kernel deduced from the point type, using `CGAL::Kernel_traits`}
* \cgalParamExtra{The geometric traits class must be compatible with the vertex point type.}
* \cgalParamNEnd
*
* \cgalParamNBegin{vertex_is_constrained_map}
* \cgalParamDescription{a property map containing the constrained-or-not status of each vertex of `tmesh`}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<PolygonMesh>::%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
*
*/

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

@ -42,19 +42,25 @@ namespace Polygon_mesh_processing {
@param faces the range of faces defining the patches to refine
@param faces_out output iterator into which descriptors of new faces are recorded
@param vertices_out output iterator into which descriptors of new vertices are recorded
@param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
@param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
\cgalNamedParamsBegin
\cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `tmesh`
Instance of a class model of `ReadWritePropertyMap`.
If this parameter is omitted, an internal property map for
`CGAL::vertex_point_t` must be available in `TriangleMesh`
\cgalParamEnd
\cgalParamBegin{density_control_factor} factor to control density of the output mesh,
where larger values lead to denser refinements.
The density of vertices of `faces_out` is this factor times higher than the vertices of `faces.` \cgalParamEnd
\cgalNamedParamsEnd
\cgalParamNBegin{vertex_point_map}
\cgalParamDescription{a property map associating points to the vertices of `tmesh`}
\cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
as key type and `%Point_3` as value type}
\cgalParamDefault{`boost::get(CGAL::vertex_point, tmesh)`}
\cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
must be available in `TriangleMesh`}
\cgalParamNEnd
\cgalParamNBegin{density_control_factor}
\cgalParamDescription{a factor to control density of the output mesh, where larger values lead to denser refinements.}
\cgalParamType{double}
\cgalParamDefault{\f$ \sqrt{2}\f$}
\cgalParamExtra{The density of vertices of `faces_out` is this factor times higher than the vertices of `faces`.}
\cgalParamNEnd
\cgalNamedParamsEnd
@return pair of `faces_out` and `vertices_out`

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

@ -41,7 +41,6 @@ namespace Polygon_mesh_processing {
* The descriptor types `boost::graph_traits<PolygonMesh>::%face_descriptor`
* and `boost::graph_traits<PolygonMesh>::%halfedge_descriptor` must be
* models of `Hashable`.
*
* @tparam FaceRange range of `boost::graph_traits<PolygonMesh>::%face_descriptor`,
model of `Range`. Its iterator type is `ForwardIterator`.
* @tparam NamedParameters a sequence of \ref pmp_namedparameters "Named Parameters"
@ -50,66 +49,114 @@ namespace Polygon_mesh_processing {
* @param faces the range of triangular faces defining one or several surface patches to be remeshed
* @param target_edge_length the edge length that is targeted in the remeshed patch.
* If `0` is passed then only the edge-flip, tangential relaxation, and projection steps will be done.
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_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`
*
* \cgalNamedParamsBegin
* \cgalParamBegin{geom_traits} a geometric traits class instance, model of `Kernel`.
* Exact constructions kernels are not supported by this function.
* \cgalParamEnd
* \cgalParamBegin{vertex_point_map} the property map with the points associated
* to the vertices of `pmesh`. Instance of a class model of `ReadWritePropertyMap`.
* \cgalParamEnd
* \cgalParamBegin{face_index_map} a property map containing the index of each face of `pmesh`
* \cgalParamEnd
* \cgalParamBegin{number_of_iterations} the number of iterations for the
* sequence of atomic operations performed (listed in the above description)
* \cgalParamEnd
* \cgalParamBegin{edge_is_constrained_map} a property map containing the
* constrained-or-not status of each edge of `pmesh`. A constrained edge can be split
* or collapsed, but not flipped, nor its endpoints moved by smoothing.
* Sub-edges generated by splitting are set to be constrained.
* Note that patch boundary edges (i.e. incident to only one face in the range)
* are always considered as constrained edges.
* \cgalParamEnd
* \cgalParamBegin{vertex_is_constrained_map} a property map containing the
* constrained-or-not status of each vertex of `pmesh`. A constrained vertex
* cannot be modified at all during remeshing
* \cgalParamEnd
* \cgalParamBegin{protect_constraints} If `true`, the edges set as constrained
* in `edge_is_constrained_map` (or by default the boundary edges)
* are not split nor collapsed during remeshing.
* Note that around constrained edges that have their length higher than
* twice `target_edge_length`, remeshing will fail to provide
* good quality results. It can even fail to terminate because of cascading vertex
* insertions.
* \cgalParamEnd
* \cgalParamBegin{collapse_constraints} If `true`, the edges set as constrained
* in `edge_is_constrained_map` (or by default the boundary edges)
* are collapsed during remeshing. This value is ignored if `protect_constraints` is true;
* \cgalParamEnd
* \cgalParamBegin{face_patch_map} a property map with the patch id's associated to the
faces of `faces`. Instance of a class model of `ReadWritePropertyMap`. It gets
updated during the remeshing process while new faces are created.
* \cgalParamEnd
* \cgalParamBegin{number_of_relaxation_steps} the number of iterations of tangential
* relaxation that are performed at each iteration of the remeshing process
* \cgalParamEnd
* \cgalParamBegin{relax_constraints} If `true`, the end vertices of the edges set as
* constrained in `edge_is_constrained_map` and boundary edges move along the
* constrained polylines they belong to.
* \cgalParamEnd
* \cgalParamBegin{do_project} a boolean that sets whether vertices should be reprojected
* on the input surface after creation or displacement.
* \cgalParamEnd
* \cgalParamBegin{projection_functor}
* A function object used to project input vertices (moved by the smoothing) and created vertices.
* It must have `%Point_3 operator()(vertex_descriptor)`, `%Point_3` being the value type
* of the vertex point map.
* If not provided, vertices are projected on the input surface mesh.
* \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `pmesh`}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, pmesh)`}
* \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.}
* \cgalParamExtra{Exact constructions kernels are not supported by this function.}
* \cgalParamNEnd
*
* \cgalParamNBegin{face_index_map}
* \cgalParamDescription{a property map associating to each face of `tm` a unique index between `0` and `num_faces(tm) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%face_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamNEnd
*
* \cgalParamNBegin{number_of_iterations}
* \cgalParamDescription{the number of iterations for the sequence of atomic operations performed (listed in the above description)}
* \cgalParamType{unsigned int}
* \cgalParamDefault{`1`}
* \cgalParamNEnd
*
* \cgalParamNBegin{edge_is_constrained_map}
* \cgalParamDescription{a property map containing the constrained-or-not status of each edge of `pmesh`}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<PolygonMesh>::%edge_descriptor`
* as key type and `bool` as value type. It must be default constructible.}
* \cgalParamDefault{a default property map where no edge is constrained}
* \cgalParamExtra{A constrained edge can be split or collapsed, but not flipped, nor its endpoints moved by smoothing.}
* \cgalParamExtra{Sub-edges generated by splitting are set to be constrained.}
* \cgalParamExtra{Patch boundary edges (i.e. incident to only one face in the range) are always considered as constrained edges.}
* \cgalParamNEnd
*
* \cgalParamNBegin{vertex_is_constrained_map}
* \cgalParamDescription{a property map containing the constrained-or-not status of each vertex of `pmesh`.}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
* as key type and `bool` as value type. It must be default constructible.}
* \cgalParamDefault{a default property map where no vertex is constrained}
* \cgalParamExtra{A constrained vertex cannot be modified during remeshing.}
* \cgalParamNEnd
*
* \cgalParamNBegin{protect_constraints}
* \cgalParamDescription{If `true`, the edges set as constrained in `edge_is_constrained_map`
* (or by default the boundary edges) are not split nor collapsed during remeshing.}
* \cgalParamType{Boolean}
* \cgalParamDefault{`false`}
* \cgalParamExtra{Note that around constrained edges that have their length higher than
* twice `target_edge_length`, remeshing will fail to provide good quality results.
* It can even fail to terminate because of cascading vertex insertions.}
* \cgalParamNEnd
*
* \cgalParamNBegin{collapse_constraints}
* \cgalParamDescription{If `true`, the edges set as constrained in `edge_is_constrained_map`
* (or by default the boundary edges) are collapsed during remeshing.}
* \cgalParamType{Boolean}
* \cgalParamDefault{`true`}
* \cgalParamExtra{This value is ignored if `protect_constraints` is `true`.}
* \cgalParamNEnd
*
* \cgalParamNBegin{face_patch_map}
* \cgalParamDescription{a property map with the patch id's associated to the faces of `faces`}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<PolygonMesh>::%face_descriptor`
* as key type and the desired property, model of `CopyConstructible` as value type.}
* \cgalParamDefault{a default property map where each face is associated with the ID of
* the connected component it belongs to. Connected components are
* computed with respect to the constrained edges listed in the property map
* `edge_is_constrained_map`}
* \cgalParamExtra{The map is updated during the remeshing process while new faces are created.}
* \cgalParamNEnd
*
* \cgalParamNBegin{number_of_relaxation_steps}
* \cgalParamDescription{the number of iterations of tangential relaxation that are performed
* at each iteration of the remeshing process}
* \cgalParamType{unsigned int}
* \cgalParamDefault{`1`}
* \cgalParamNEnd
*
* \cgalParamNBegin{relax_constraints}
* \cgalParamDescription{If `true`, the end vertices of the edges set as constrained
* in `edge_is_constrained_map` and boundary edges move along the}
* constrained polylines they belong to.}
* \cgalParamType{Boolean}
* \cgalParamDefault{`false`}
* \cgalParamNEnd
*
* \cgalParamNBegin{do_project}
* \cgalParamDescription{whether vertices should be reprojected on the input surface after creation or displacement}
* \cgalParamType{Boolean}
* \cgalParamDefault{`true`}
* \cgalParamNEnd
*
* \cgalParamNBegin{projection_functor}
* \cgalParamDescription{A function object used to project input vertices (moved by the smoothing) and created vertices}
* \cgalParamType{Unary functor that provides `%Point_3 operator()(vertex_descriptor)`, `%Point_3` being the value type
* of the vertex point map.}
* \cgalParamDefault{If not provided, vertices are projected on the input surface mesh.}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* @sa `split_long_edges()`
@ -298,18 +345,30 @@ void isotropic_remeshing(
* @param edges the range of edges to be split if they are longer than given threshold
* @param max_length the edge length above which an edge from `edges` is split
* into to sub-edges
* @param np optional \ref pmp_namedparameters "Named Parameters", amongst those described below
* @param np an optional \ref pmp_namedparameters "Named Parameters", amongst those described below
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated
* to the vertices of `pmesh`. Instance of a class model of `ReadWritePropertyMap`.
* \cgalParamEnd
* \cgalParamBegin{face_index_map} a property map containing the index of each face of `pmesh`
* \cgalParamEnd
* \cgalParamBegin{edge_is_constrained_map} a property map containing the
* constrained-or-not status of each edge of `pmesh`. A constrained edge can be split,
* and the sub-edges are set to be constrained.
* \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `pmesh`}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, pmesh)`}
* \cgalParamNEnd
*
* \cgalParamNBegin{face_index_map}
* \cgalParamDescription{a property map associating to each face of `pmesh` a unique index between `0` and `num_faces(pmesh) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%face_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamNEnd
*
* \cgalParamNBegin{edge_is_constrained_map}
* \cgalParamDescription{a property map containing the constrained-or-not status of each edge of `pmesh`}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<PolygonMesh>::%edge_descriptor`
* as key type and `bool` as value type. It must be default constructible.}
* \cgalParamDefault{a default property map where no edge is constrained}
* \cgalParamExtra{A constrained edge can be split or collapsed, but not flipped, nor its endpoints moved by smoothing.}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* @sa `isotropic_remeshing()`

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

@ -115,22 +115,74 @@ std::size_t remove_isolated_vertices(PolygonMesh& pmesh)
/// \tparam NamedParameters a sequence of \ref pmp_namedparameters "Named Parameters"
///
/// \param tmesh the triangulated polygon mesh
/// \param np optional \ref pmp_namedparameters "Named Parameters", amongst those described below
/// \param np an optional \ref pmp_namedparameters "Named Parameters", amongst those described below
///
/// \cgalNamedParamsBegin
/// \cgalParamBegin{area_threshold} a fixed value such that only connected components whose area is
/// larger than this value are kept \cgalParamEnd
/// \cgalParamBegin{volume_threshold} a fixed value such that only connected components whose volume is
/// larger than this value are kept (only applies to closed connected components) \cgalParamEnd
/// \cgalParamBegin{edge_is_constrained_map} a property map containing the constrained-or-not status of each edge of `pmesh` \cgalParamEnd
/// \cgalParamBegin{face_index_map} a property map containing the index of each face of `tmesh` \cgalParamEnd
/// \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `tmesh`.
/// \cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `Kernel` \cgalParamEnd
/// \cgalParamBegin{dry_run} a Boolean parameter. If set to `true`, the mesh will not be altered,
/// but the number of components that would be removed is returned. The default value is `false`.\cgalParamEnd
/// \cgalParamBegin{output_iterator} a model of `OutputIterator` with value type `face_descriptor`.
/// When using the "dry run" mode (see parameter `dry_run`), faces
/// that would be removed by the algorithm can be collected with this output iterator. \cgalParamEnd
/// \cgalParamNBegin{vertex_point_map}
/// \cgalParamDescription{a property map associating points to the vertices of `tmesh`}
/// \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
/// as key type and `%Point_3` as value type}
/// \cgalParamDefault{`boost::get(CGAL::vertex_point, tmesh)`}
/// \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.}
/// \cgalParamExtra{Exact constructions kernels are not supported by this function.}
/// \cgalParamNEnd
///
/// \cgalParamNBegin{face_index_map}
/// \cgalParamDescription{a property map associating to each face of `tmesh` a unique index between `0` and `num_faces(tmesh) - 1`}
/// \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%face_descriptor`
/// as key type and `std::size_t` as value type}
/// \cgalParamDefault{an automatically indexed internal map}
/// \cgalParamNEnd
///
/// \cgalParamNBegin{area_threshold}
/// \cgalParamDescription{a fixed value such that only connected components whose area is larger than this value are kept}
/// \cgalParamType{`geom_traits::FT`}
/// \cgalParamDefault{1\% of the length of the diagonal of the axis-aligned bounding box of the mesh, squared}
/// \cgalParamNEnd
///
/// \cgalParamNBegin{volume_threshold}
/// \cgalParamDescription{a fixed value such that only connected components whose volume is
/// larger than this value are kept (only applies to closed connected components)}
/// \cgalParamType{`geom_traits::FT`}
/// \cgalParamDefault{1\% of the length of the diagonal of the axis-aligned bounding box of the mesh, cubed}
/// \cgalParamExtra{The mesh must be closed.}
/// \cgalParamNEnd
///
/// \cgalParamNBegin{volume_threshold}
/// \cgalParamDescription{a fixed value such that only connected components whose volume is
/// larger than this value are kept (only applies to closed connected components)}
/// \cgalParamType{`geom_traits::FT`}
/// \cgalParamDefault{1\% of the length of the diagonal of the axis-aligned bounding box of the mesh, cubed}
/// \cgalParamExtra{The mesh must be closed.}
/// \cgalParamNEnd
///
/// \cgalParamNBegin{edge_is_constrained_map}
/// \cgalParamDescription{a property map containing the constrained-or-not status of each edge of `tmesh`}
/// \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%edge_descriptor`
/// as key type and `bool` as value type. It must be default constructible.}
/// \cgalParamDefault{a default property map where no edge is constrained}
/// \cgalParamExtra{A constrained edge can be split or collapsed, but not flipped, nor its endpoints moved by smoothing.}
/// \cgalParamNEnd
///
/// \cgalParamNBegin{dry_run}
/// \cgalParamDescription{If set to `true`, the mesh will not be altered, but the number of components
/// that would be removed is returned.}
/// \cgalParamType{Boolean}
/// \cgalParamDefault{`false`}
/// \cgalParamNEnd
///
/// \cgalParamNBegin{output_iterator}
/// \cgalParamDescription{An output iterator to collect the faces that would be removed by the algorithm,
/// when using the "dry run" mode (see parameter `dry_run`)}
/// \cgalParamType{a model of `OutputIterator` with value type `face_descriptor`}
/// \cgalParamDefault{`false`}
/// \cgalParamNEnd
/// \cgalNamedParamsEnd
///
/// \return the number of connected components removed (ignoring isolated vertices).
@ -452,19 +504,25 @@ struct Less_vertex_point{
/// @param edges a subset of edges of `tm`
/// @param tm a triangle mesh
/// @param out an output iterator in which the degenerate edges are written
/// @param np optional \ref pmp_namedparameters "Named Parameters" described below
/// @param np an optional \ref pmp_namedparameters "Named Parameters" described below
///
/// \cgalNamedParamsBegin
/// \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `tm`.
/// The type of this map is model of `ReadWritePropertyMap`.
/// If this parameter is omitted, an internal property map for
/// `CGAL::vertex_point_t` should be available in `TriangleMesh`
/// \cgalParamEnd
/// \cgalParamBegin{geom_traits} a geometric traits class instance.
/// The traits class must provide the nested type `Point_3`,
/// and the nested functor `Equal_3` to check whether two points are identical.
/// \cgalParamEnd
/// \cgalParamNBegin{vertex_point_map}
/// \cgalParamDescription{a property map associating points to the vertices of `tm`}
/// \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
/// as key type and `%Point_3` as value type}
/// \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
/// \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 functor `Equal_3` to check whether two points are identical.}
/// \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
///
template <class EdgeRange, class TriangleMesh, class OutputIterator, class NamedParameters>
OutputIterator degenerate_edges(const EdgeRange& edges,
const TriangleMesh& tm,
@ -528,18 +586,23 @@ degenerate_edges(const TriangleMesh& tm, OutputIterator out)
/// @param faces a subset of faces of `tm`
/// @param tm a triangle mesh
/// @param out an output iterator in which the degenerate faces are put
/// @param np optional \ref pmp_namedparameters "Named Parameters" described below
/// @param np an optional \ref pmp_namedparameters "Named Parameters" described below
///
/// \cgalNamedParamsBegin
/// \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `tm`.
/// The type of this map is model of `ReadWritePropertyMap`.
/// If this parameter is omitted, an internal property map for
/// `CGAL::vertex_point_t` should be available in `TriangleMesh`
/// \cgalParamEnd
/// \cgalParamBegin{geom_traits} a geometric traits class instance.
/// The traits class must provide the nested functor `Collinear_3`
/// to check whether three points are collinear.
/// \cgalParamEnd
/// \cgalParamNBegin{vertex_point_map}
/// \cgalParamDescription{a property map associating points to the vertices of `tm`}
/// \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
/// as key type and `%Point_3` as value type}
/// \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
/// \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 functor `Collinear_3` to check whether two points are identical.}
/// \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
///
template <class FaceRange, class TriangleMesh, class OutputIterator, class NamedParameters>
@ -1348,23 +1411,27 @@ bool remove_degenerate_edges(TriangleMesh& tmesh)
// @tparam NamedParameters a sequence of \ref pmp_namedparameters "Named Parameters"
//
// @param tmesh the triangulated surface mesh to be repaired
// @param np optional \ref pmp_namedparameters "Named Parameters" described below
// @param np an optional \ref pmp_namedparameters "Named Parameters" described below
//
// \cgalNamedParamsBegin
// \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
// The type of this map is model of `ReadWritePropertyMap`.
// If this parameter is omitted, an internal property map for
// `CGAL::vertex_point_t` must be available in `TriangleMesh`
// \cgalParamEnd
// \cgalParamBegin{geom_traits} a geometric traits class instance.
// The traits class must provide the nested type `Point_3`,
// and the nested functors:
// \cgalParamNBegin{vertex_point_map}
// \cgalParamDescription{a property map associating points to the vertices of `tmesh`}
// \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
// as key type and `%Point_3` as value type}
// \cgalParamDefault{`boost::get(CGAL::vertex_point, tmesh)`}
// \cgalParamNEnd
//
// \cgalParamNBegin{geom_traits}
// \cgalParamDescription{an instance of a geometric traits class}
// \cgalParamType{a class providing the nested type `Point_3` and the nested functors:
// - `Compare_distance_3` to compute the distance between 2 points
// - `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.
// \cgalParamEnd
// - `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
//
// @todo the function might not be able to remove all degenerate faces.
@ -2581,23 +2648,33 @@ OutputIterator non_manifold_vertices(const PolygonMesh& pm,
/// @tparam NamedParameters a sequence of \ref pmp_namedparameters "Named Parameters"
///
/// @param pm the surface mesh to be repaired
/// @param np optional \ref pmp_namedparameters "Named Parameters" described below
/// @param np an optional \ref pmp_namedparameters "Named Parameters" described below
///
/// \cgalNamedParamsBegin
/// \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
/// The type of this map is model of `ReadWritePropertyMap`.
/// If this parameter is omitted, an internal property map for
/// `CGAL::vertex_point_t` should be available in `PolygonMesh`
/// \cgalParamEnd
/// \cgalParamBegin{vertex_is_constrained_map} a writable property map with `vertex_descriptor`
/// as key and `bool` as `value_type`. `put(pmap, v, true)` will be called for each duplicated
/// vertices, as well as the original non-manifold vertex in the input mesh.
/// \cgalParamEnd
/// \cgalParamBegin{output_iterator} a model of `OutputIterator` with value type
/// `std::vector<vertex_descriptor>`. The first vertex of each vector is a non-manifold vertex
/// of the input mesh, followed by the new vertices that were created to fix this precise
/// non-manifold configuration.
/// \cgalParamEnd
/// \cgalParamNBegin{vertex_point_map}
/// \cgalParamDescription{a property map associating points to the vertices of `pmesh`}
/// \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
/// as key type and `%Point_3` as value type}
/// \cgalParamDefault{`boost::get(CGAL::vertex_point, pmesh)`}
/// \cgalParamNEnd
///
/// \cgalParamNBegin{vertex_is_constrained_map}
/// \cgalParamDescription{a property map containing the constrained-or-not status of each vertex of `pmesh`.}
/// \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
/// as key type and `bool` as value type. It must be default constructible.}
/// \cgalParamDefault{a default property map where no vertex is constrained}
/// \cgalParamExtra{`put(pmap, v, true)` will be called for each duplicated vertices,
/// as well as the original non-manifold vertex in the input mesh..}
/// \cgalParamNEnd
///
/// \cgalParamNBegin{output_iterator}
/// \cgalParamDescription{a way to link newly created vertices to the previously non-manifold vertices.}
/// \cgalParamType{a model of `OutputIterator` with value type `std::vector<vertex_descriptor>`}
/// \cgalParamDefault{unused}
/// \cgalParamExtra{The first vertex of each vector is a non-manifold vertex
/// of the input mesh, followed by the new vertices that were created to fix this precise
/// non-manifold configuration.}
/// \cgalParamNEnd
/// \cgalNamedParamsEnd
///
/// \return the number of vertices created.

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

@ -174,13 +174,16 @@ bool simplify_polygon(PointRange& points,
// \param points points of the soup of polygons.
// \param polygons a vector of polygons. Each element in the vector describes a polygon
// using the indices of the points in `points`.
// \param np optional \ref pmp_namedparameters "Named Parameters" described below
// \param np an optional \ref pmp_namedparameters "Named Parameters" described below
//
// \cgalNamedParamsBegin
// \cgalParamBegin{geom_traits} a geometric traits class instance.
// The traits class must provide the nested functor `Equal_3`
// to compare lexicographically two points a function `Equal_3 equal_3_object()`.
// \cgalParamEnd
// \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()`.}
// \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
//
template <typename Traits, typename PointRange, typename PolygonRange>
@ -225,13 +228,16 @@ std::size_t simplify_polygons_in_polygon_soup(PointRange& points,
// \param points points of the soup of polygons.
// \param polygons a vector of polygons. Each element in the vector describes a polygon
// using the indices of the points in `points`.
// \param np optional \ref pmp_namedparameters "Named Parameters" described below
// \param np an optional \ref pmp_namedparameters "Named Parameters" described below
//
// \cgalNamedParamsBegin
// \cgalParamBegin{geom_traits} a geometric traits class instance.
// The traits class must provide the nested functor `Less_xyz_3`
// to compare lexicographically two points a function `Less_xyz_3 less_xyz_3_object()`.
// \cgalParamEnd
// \cgalParamNBegin{geom_traits}
// \cgalParamDescription{an instance of a geometric traits class}
// \cgalParamType{The traits class must provide the nested functor `Less_xyz_3`
// to compare lexicographically two points a function `Less_xyz_3 less_xyz_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
//
template <typename Traits, typename PointRange, typename PolygonRange>
@ -489,13 +495,16 @@ std::size_t remove_isolated_points_in_polygon_soup(PointRange& points,
/// \param points points of the soup of polygons.
/// \param polygons a vector of polygons. Each element in the vector describes a polygon
/// using the indices of the points in `points`.
/// \param np optional \ref pmp_namedparameters "Named Parameters" described below
/// \param np an optional \ref pmp_namedparameters "Named Parameters" described below
///
/// \cgalNamedParamsBegin
/// \cgalParamBegin{geom_traits} a geometric traits class instance.
/// The traits class must provide the nested functor `Less_xyz_3`
/// to compare lexicographically two points a function `Less_xyz_3 less_xyz_3_object()`.
/// \cgalParamEnd
/// \cgalParamNBegin{geom_traits}
/// \cgalParamDescription{an instance of a geometric traits class}
/// \cgalParamType{The traits class must provide the nested functor `Less_xyz_3`
/// to compare lexicographically two points a function `Less_xyz_3 less_xyz_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
///
/// \returns the number of removed points
@ -876,22 +885,32 @@ DuplicateOutputIterator collect_duplicate_polygons(const PointRange& points,
/// \param points points of the soup of polygons.
/// \param polygons a vector of polygons. Each element in the vector describes a polygon
/// using the indices of the points in `points`.
/// \param np optional \ref pmp_namedparameters "Named Parameters", amongst those described below
/// \param np an optional \ref pmp_namedparameters "Named Parameters", amongst those described below
///
/// \cgalNamedParamsBegin
/// \cgalParamBegin{geom_traits} a geometric traits class instance.
/// The traits class must provide the nested functor `Less_xyz_3`
/// to compare lexicographically two points a function `Less_xyz_3 less_xyz_3_object()`.
/// \cgalParamEnd
/// \cgalParamBegin{erase_all_duplicates}
/// Parameter to indicate, when multiple polygons are duplicates, whether all the duplicate polygons
/// should be removed or if one (arbitrarily chosen) face should be kept. %Default is `false`.
/// \cgalParamEnd
/// \cgalParamBegin{require_same_orientation}
/// Parameter to indicate if polygon orientation should be taken into account when determining
/// whether two polygons are duplicates, that is, whether e.g. the triangles `0,1,2` and `0,2,1`
/// are duplicates. %Default is `false`.
/// \cgalParamEnd
/// \cgalParamNBegin{geom_traits}
/// \cgalParamDescription{an instance of a geometric traits class}
/// \cgalParamType{The traits class must provide the nested functor `Less_xyz_3`
/// to compare lexicographically two points a function `Less_xyz_3 less_xyz_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
///
/// \cgalParamNBegin{erase_all_duplicates}
/// \cgalParamDescription{Parameter to indicate, when multiple polygons are duplicates,
/// whether all the duplicate polygons should be removed
/// or if one (arbitrarily chosen) face should be kept.}
/// \cgalParamType{Boolean}
/// \cgalParamDefault{`false`}
/// \cgalParamNEnd
///
/// \cgalParamNBegin{require_same_orientation}
/// \cgalParamDescription{Parameter to indicate if polygon orientation should be taken
/// into account when determining whether two polygons are duplicates,
/// that is, whether e.g. the triangles `0,1,2` and `0,2,1` are duplicates.}
/// \cgalParamType{Boolean}
/// \cgalParamDefault{`false`}
/// \cgalParamNEnd
/// \cgalNamedParamsEnd
///
/// \returns the number of removed polygons
@ -1030,27 +1049,33 @@ std::size_t merge_duplicate_polygons_in_polygon_soup(PointRange& points,
/// \param points points of the soup of polygons.
/// \param polygons a vector of polygons. Each element in the vector describes a polygon
/// using the indices of the points in `points`.
/// \param np optional \ref pmp_namedparameters "Named Parameters", amongst those described below
/// \param np an optional \ref pmp_namedparameters "Named Parameters", amongst those described below
///
/// \cgalNamedParamsBegin
/// \cgalParamBegin{geom_traits} a geometric traits class instance.
/// The traits class must provide the nested functors :
/// - `Less_xyz_3` to compare lexicographically two points
/// - `Equal_3` to check whether 2 points are identical
/// \cgalParamNBegin{geom_traits}
/// \cgalParamDescription{an instance of a geometric traits class}
/// \cgalParamType{The traits class must provide the nested functors `Less_xyz_3` and `Equal_3`
/// to respectivelycompare lexicographically two points and to check if 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
///
/// and, for each functor `Foo`, a function `Foo foo_object()`.
/// \cgalParamEnd
/// \cgalParamBegin{erase_all_duplicates}
/// Parameter forwarded to the function `merge_duplicate_polygons_in_polygon_soup()` to indicate,
/// when multiple polygons are duplicates, whether all the duplicate polygons
/// should be removed or if one (arbitrarily chosen) face should be kept. %Default is `false`.
/// \cgalParamEnd
/// \cgalParamBegin{require_same_orientation}
/// Parameter forwarded to the function `merge_duplicate_polygons_in_polygon_soup()`
/// to indicate if polygon orientation should be taken into account when determining whether
/// two polygons are duplicates, that is, whether e.g. the triangles `0,1,2` and `0,2,1` are duplicates.
/// %Default is `false`.
/// \cgalParamEnd
/// \cgalParamNBegin{erase_all_duplicates}
/// \cgalParamDescription{Parameter to indicate, when multiple polygons are duplicates,
/// whether all the duplicate polygons should be removed
/// or if one (arbitrarily chosen) face should be kept.}
/// \cgalParamType{Boolean}
/// \cgalParamDefault{`false`}
/// \cgalParamNEnd
///
/// \cgalParamNBegin{require_same_orientation}
/// \cgalParamDescription{Parameter to indicate if polygon orientation should be taken
/// into account when determining whether two polygons are duplicates,
/// that is, whether e.g. the triangles `0,1,2` and `0,2,1` are duplicates.}
/// \cgalParamType{Boolean}
/// \cgalParamDefault{`false`}
/// \cgalParamNEnd
/// \cgalNamedParamsEnd
///
template <typename PointRange, typename PolygonRange, typename NamedParameters>

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

@ -342,13 +342,23 @@ self_intersections_impl(const FaceRange& face_range,
* @param face_range the range of faces to check for self-intersection.
* @param tmesh the triangulated surface mesh to be checked
* @param out output iterator to be filled with all pairs of non-adjacent faces that intersect
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`\cgalParamEnd
* \cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `PMPSelfIntersectionTraits` \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tmesh`}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor` as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* should be available for the vertices of `tmesh`}
* \cgalParamNEnd
*
* \cgalParamNBegin{geom_traits}
* \cgalParamDescription{an instance of a geometric traits class}
* \cgalParamType{a class model of `PMPSelfIntersectionTraits`}
* \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 types}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*/
template < class ConcurrencyTag = Sequential_tag,
@ -401,13 +411,23 @@ self_intersections(const FaceRange& face_range,
In case `tmesh` contains some degenerate faces, for each degenerate face `f` a pair `(f,f)`
will be put in `out` before any other self intersection between non-degenerate faces.
These are the only pairs where degenerate faces will be reported.
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`\cgalParamEnd
* \cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `PMPSelfIntersectionTraits` \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tmesh`}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor` as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* should be available for the vertices of `tmesh`}
* \cgalParamNEnd
*
* \cgalParamNBegin{geom_traits}
* \cgalParamDescription{an instance of a geometric traits class}
* \cgalParamType{a class model of `PMPSelfIntersectionTraits`}
* \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 types}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* @return `out`
@ -447,13 +467,23 @@ self_intersections(const TriangleMesh& tmesh, FacePairOutputIterator out)
*
* @param face_range the set of faces to test for self-intersection
* @param tmesh the triangulated surface mesh to be tested
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `tmesh`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`\cgalParamEnd
* \cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `SelfIntersectionTraits` \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tmesh`}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor` as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* should be available for the vertices of `tmesh`}
* \cgalParamNEnd
*
* \cgalParamNBegin{geom_traits}
* \cgalParamDescription{an instance of a geometric traits class}
* \cgalParamType{a class model of `PMPSelfIntersectionTraits`}
* \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 types}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* @return `true` if the faces in `face_range` self-intersect
@ -493,13 +523,23 @@ bool does_self_intersect(const FaceRange& face_range,
* @tparam NamedParameters a sequence of \ref pmp_namedparameters "Named Parameters"
*
* @param tmesh the triangulated surface mesh to be tested
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `tmesh`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`\cgalParamEnd
* \cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `PMPSelfIntersectionTraits` \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tmesh`}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor` as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* should be available for the vertices of `tmesh`}
* \cgalParamNEnd
*
* \cgalParamNBegin{geom_traits}
* \cgalParamDescription{an instance of a geometric traits class}
* \cgalParamType{a class model of `PMPSelfIntersectionTraits`}
* \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 types}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* @return `true` if `tmesh` self-intersects

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

@ -43,18 +43,23 @@ namespace Polygon_mesh_processing {
///
/// @param e an edge of `pm`
/// @param pm polygon mesh containing `e`
/// @param np optional \ref pmp_namedparameters "Named Parameters" described below
/// @param np an optional \ref pmp_namedparameters "Named Parameters" described below
///
/// \cgalNamedParamsBegin
/// \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pm`.
/// The type of this map is model of `ReadWritePropertyMap`.
/// If this parameter is omitted, an internal property map for
/// `CGAL::vertex_point_t` should be available in `PolygonMesh`
/// \cgalParamEnd
/// \cgalParamBegin{geom_traits} a geometric traits class instance.
/// The traits class must provide the nested type `Point_3`,
/// and the nested functor `Equal_3` to check whether two points are identical.
/// \cgalParamEnd
/// \cgalParamNBegin{vertex_point_map}
/// \cgalParamDescription{a property map associating points to the vertices of `pm`}
/// \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
/// as key type and `%Point_3` as value type}
/// \cgalParamDefault{`boost::get(CGAL::vertex_point, pm)`}
/// \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 functor `Equal_3` to check whether two points are identical.}
/// \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 `degenerate_edges()`
@ -94,18 +99,23 @@ bool is_degenerate_edge(typename boost::graph_traits<PolygonMesh>::edge_descript
///
/// @param f a triangle face of `tm`
/// @param tm a triangle mesh containing `f`
/// @param np optional \ref pmp_namedparameters "Named Parameters" described below
/// @param np an optional \ref pmp_namedparameters "Named Parameters" described below
///
/// \cgalNamedParamsBegin
/// \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `tm`.
/// The type of this map is model of `ReadWritePropertyMap`.
/// If this parameter is omitted, an internal property map for
/// `CGAL::vertex_point_t` should be available in `TriangleMesh`
/// \cgalParamEnd
/// \cgalParamBegin{geom_traits} a geometric traits class instance.
/// The traits class must provide the nested functor `Collinear_3`
/// to check whether three points are collinear.
/// \cgalParamEnd
/// \cgalParamNBegin{vertex_point_map}
/// \cgalParamDescription{a property map associating points to the vertices of `tm`}
/// \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
/// as key type and `%Point_3` as value type}
/// \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
/// \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 functor `Collinear_3` to check whether three points are aligned.}
/// \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 `degenerate_faces()`
@ -152,18 +162,23 @@ bool is_degenerate_triangle_face(typename boost::graph_traits<TriangleMesh>::fac
/// @param f a triangle face of `tm`
/// @param tm triangle mesh containing `f`
/// @param threshold a bound on the ratio of the longest edge length and the shortest edge length
/// @param np optional \ref pmp_namedparameters "Named Parameters" described below
/// @param np an optional \ref pmp_namedparameters "Named Parameters" described below
///
/// \cgalNamedParamsBegin
/// \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `tm`.
/// The type of this map is model of `ReadWritePropertyMap`.
/// If this parameter is omitted, an internal property map for
/// `CGAL::vertex_point_t` should be available in `TriangleMesh`
/// \cgalParamEnd
/// \cgalParamBegin{geom_traits} a geometric traits class instance.
/// The traits class must provide the nested type `FT` and
/// the nested functor `Compute_squared_distance_3`.
/// \cgalParamEnd
/// \cgalParamNBegin{vertex_point_map}
/// \cgalParamDescription{a property map associating points to the vertices of `tm`}
/// \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
/// as key type and `%Point_3` as value type}
/// \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
/// \cgalParamNEnd
///
/// \cgalParamNBegin{geom_traits}
/// \cgalParamDescription{an instance of a geometric traits class}
/// \cgalParamType{The traits class must provide the nested type `FT`,
/// and the nested functor `Compute_squared_distance_3`.}
/// \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 the shortest halfedge if the triangle face is a needle, and a null halfedge otherwise.
@ -252,18 +267,23 @@ is_needle_triangle_face(typename boost::graph_traits<TriangleMesh>::face_descrip
/// @param threshold the cosine of a minimum angle such that if `f` has an angle greater than this bound,
/// it is a cap. The threshold is in range `[-1 0]` and corresponds to an angle
/// between `90` and `180` degrees.
/// @param np optional \ref pmp_namedparameters "Named Parameters" described below
/// @param np an optional \ref pmp_namedparameters "Named Parameters" described below
///
/// \cgalNamedParamsBegin
/// \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `tm`.
/// The type of this map is model of `ReadWritePropertyMap`.
/// If this parameter is omitted, an internal property map for
/// `CGAL::vertex_point_t` should be available in `TriangleMesh`
/// \cgalParamEnd
/// \cgalParamBegin{geom_traits} a geometric traits class instance.
/// The traits class must provide the nested type `Point_3` and
/// the nested functors `Compute_squared_distance_3`, `Construct_vector_3`,
/// and `Compute_scalar_product_3`.
/// \cgalParamNBegin{vertex_point_map}
/// \cgalParamDescription{a property map associating points to the vertices of `tm`}
/// \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
/// as key type and `%Point_3` as value type}
/// \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
/// \cgalParamNEnd
///
/// \cgalParamNBegin{geom_traits}
/// \cgalParamDescription{an instance of a geometric traits class}
/// \cgalParamType{The traits class must provide the nested type `Point_3`,
/// the nested functors `Compute_squared_distance_3`, `Construct_vector_3`,
/// and `Compute_scalar_product_3`.}
/// \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.}
/// \cgalParamEnd
/// \cgalNamedParamsEnd
///

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

@ -56,41 +56,77 @@ namespace Polygon_mesh_processing {
*
* @param tmesh a polygon mesh with triangulated surface patches to be smoothed.
* @param faces the range of triangular faces defining one or several surface patches to be smoothed.
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below.
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below.
*
* \cgalNamedParamsBegin
* \cgalParamBegin{use_angle_smoothing} Boolean value to indicate whether angle-based smoothing should be used.
* %Default is `true`.
* \cgalParamEnd
* \cgalParamBegin{use_area_smoothing} Boolean value to indicate whether area-based smoothing should be used.
* %Default is `true`.
* \cgalParamEnd
* \cgalParamBegin{number_of_iterations} the number of iterations for the
* sequence of the smoothing iterations performed (default is 1).
* \cgalParamEnd
* \cgalParamBegin{use_safety_constraints} if `true`, vertex moves that would worsen the mesh
* are ignored. %Default is `false`.
* \cgalParamEnd
* \cgalParamBegin{use_Delaunay_flips} if `true` (default value), area-based smoothing will be completed
* by a phase of Delaunay-based edge-flips to prevent the creation of elongated triangles.
* \cgalParamEnd
* \cgalParamBegin{do_project} if `true` (default value), points are projected onto the initial surface
* after each iteration.
* \cgalParamEnd
* \cgalParamBegin{vertex_is_constrained_map} a property map containing the
* constrained-or-not status of each vertex of `tmesh`. A constrained vertex
* cannot be modified at all during smoothing.
* \cgalParamEnd
* \cgalParamBegin{edge_is_constrained_map} a property map, model of `ReadWritePropertyMap`, containing the
* constrained-or-not status of each edge of `tmesh`. A constrained edge cannot be flipped and its extremities
* are tagged as constrained vertices.
* \cgalParamEnd
* \cgalParamBegin{vertex_point_map} the property map, model of `ReadWritePropertyMap`, with the points
* associated to the vertices of `tmesh`.
* \cgalParamEnd
* \cgalParamBegin{geom_traits} a geometric traits class instance, model of `Kernel`.
* Exact constructions kernels are not supported by this function.
* \cgalParamEnd
* \cgalParamNBegin{number_of_iterations}
* \cgalParamDescription{the number of iterations for the sequence of the smoothing iterations performed}
* \cgalParamType{unsigned int}
* \cgalParamDefault{`1`}
* \cgalParamNEnd
*
* \cgalParamNBegin{use_angle_smoothing}
* \cgalParamDescription{value to indicate whether angle-based smoothing should be used}
* \cgalParamType{Boolean}
* \cgalParamDefault{`true`}
* \cgalParamNEnd
*
* \cgalParamNBegin{use_area_smoothing}
* \cgalParamDescription{value to indicate whether area-based smoothing should be used}
* \cgalParamType{Boolean}
* \cgalParamDefault{`true`}
* \cgalParamNEnd
*
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tmesh`}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tmesh)`}
* \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{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{use_safety_constraints}
* \cgalParamDescription{If `true`, vertex moves that would worsen the mesh are ignored.}
* \cgalParamType{Boolean}
* \cgalParamDefault{`false`}
* \cgalParamNEnd
*
* \cgalParamNBegin{use_Delaunay_flips}
* \cgalParamDescription{If `true`, area-based smoothing will be completed by a phase of
* Delaunay-based edge-flips to prevent the creation of elongated triangles.}
* \cgalParamType{Boolean}
* \cgalParamDefault{`true`}
* \cgalParamNEnd
*
* \cgalParamNBegin{do_project}
* \cgalParamDescription{If `true`, points are projected onto the initial surface after each iteration.}
* \cgalParamType{Boolean}
* \cgalParamDefault{`true`}
* \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<PolygonMesh>::%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 smoothing.}
* \cgalParamNEnd
*
* \cgalParamNBegin{edge_is_constrained_map}
* \cgalParamDescription{a property map containing the constrained-or-not status of each edge of `tmesh`.}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<PolygonMesh>::%edge_descriptor`
* as key type and `bool` as value type. It must be default constructible.}
* \cgalParamDefault{a default property map where no edge is constrained}
* \cgalParamExtra{A constrained edge cannot be modified at all during smoothing.}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* @warning The third party library \link thirdpartyCeres Ceres \endlink is required

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

@ -55,24 +55,48 @@ namespace Polygon_mesh_processing {
* @param time a time step that corresponds to the speed by which the surface is smoothed.
* A larger time step results in faster convergence but details may be distorted to have a larger extent
* compared to more iterations with a smaller step. Typical values scale in the interval (1e-6, 1].
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below.
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below.
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated
* to the vertices of `tmesh`. Instance of a class model of `ReadWritePropertyMap`.
* \cgalParamEnd
* \cgalParamBegin{geom_traits} a geometric traits class instance, model of `Kernel`.
* \cgalParamEnd
* \cgalParamBegin{vertex_is_constrained_map} a property map containing the
* constrained-or-not status of each vertex of `tmesh`. A constrained vertex
* cannot be modified at all during smoothing.
* \cgalParamEnd
* \cgalParamBegin{number_of_iterations} the number of iterations for the
* sequence of the smoothing iterations performed. Each iteration is performed
* with the given time step.
* \cgalParamEnd
* \cgalParamBegin{sparse_linear_solver} an instance of the sparse linear solver used for smoothing \cgalParamEnd
* \cgalParamEnd
* \cgalParamNBegin{number_of_iterations}
* \cgalParamDescription{the number of iterations for the sequence of the smoothing iterations performed}
* \cgalParamType{unsigned int}
* \cgalParamDefault{`1`}
* \cgalParamNEnd
*
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tmesh`}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tmesh)`}
* \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{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<PolygonMesh>::%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 smoothing.}
* \cgalParamNEnd
*
* \cgalParamNBegin{sparse_linear_solver}
* \cgalParamDescription{an instance of the sparse linear solver used for smoothing}
* \cgalParamType{a class model of `SparseLinearAlgebraWithFactorTraits_d`}
* \cgalParamDefault{if \ref thirdpartyEigen "Eigen" 3.2 (or greater) is available and
* `CGAL_EIGEN3_ENABLED` is defined, then the following overload of `Eigen_solver_traits`
* is provided as default value:
* `CGAL::Eigen_solver_traits<Eigen::BiCGSTAB<CGAL::Eigen_sparse_matrix<double>::%EigenType, Eigen::IncompleteLUT<double> > >`}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* @warning This function involves linear algebra, that is computed using a non-exact floating-point arithmetic.

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

@ -579,12 +579,17 @@ std::size_t stitch_borders_impl(PM& pmesh,
///
/// \param h a border halfedge of the polygon mesh `pm`
/// \param pm the polygon mesh to be stitched
/// \param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
/// \param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
///
/// \cgalNamedParamsBegin
/// \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
/// If this parameter is omitted, an internal property map for `CGAL::vertex_point_t` must be available in `PolygonMesh`.
/// \cgalParamEnd
/// \cgalParamNBegin{vertex_point_map}
/// \cgalParamDescription{a property map associating points to the vertices of `pm`}
/// \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
/// as key type and `%Point_3` as value type}
/// \cgalParamDefault{`boost::get(CGAL::vertex_point, pm)`}
/// \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
/// must be available in `PolygonMesh`.}
/// \cgalParamNEnd
/// \cgalNamedParamsEnd
///
/// \returns the number of pairs of halfedges that were stitched.
@ -761,12 +766,17 @@ std::size_t stitch_boundary_cycle(const typename boost::graph_traits<PolygonMesh
/// \tparam NamedParameters a sequence of \ref pmp_namedparameters "Named Parameters"
///
/// \param pm the polygon mesh to be stitched
/// \param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
/// \param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
///
/// \cgalNamedParamsBegin
/// \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
/// If this parameter is omitted, an internal property map for `CGAL::vertex_point_t` must be available in `PolygonMesh`.
/// \cgalParamEnd
/// \cgalParamNBegin{vertex_point_map}
/// \cgalParamDescription{a property map associating points to the vertices of `pm`}
/// \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
/// as key type and `%Point_3` as value type}
/// \cgalParamDefault{`boost::get(CGAL::vertex_point, pm)`}
/// \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
/// must be available in `PolygonMesh`.}
/// \cgalParamNEnd
/// \cgalNamedParamsEnd
///
/// \returns the number of pairs of halfedges that were stitched.
@ -857,21 +867,30 @@ std::size_t stitch_borders(PolygonMesh& pmesh,
/// @tparam NamedParameters a sequence of \ref pmp_namedparameters "Named Parameters"
///
/// @param pmesh the polygon mesh to be modified by stitching
/// @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
/// @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
///
/// \cgalNamedParamsBegin
/// \cgalParamBegin{vertex_point_map}
/// the property map with the points associated to the vertices of `pmesh`.
/// If this parameter is omitted, an internal property map for
/// `CGAL::vertex_point_t` must be available in `PolygonMesh`.
/// \cgalParamEnd
/// \cgalParamBegin{apply_per_connected_component}
/// specifies if the borders should only be stitched inside their own connected component.
/// Default value is `false`.
/// \cgalParamEnd
/// \cgalParamBegin{face_index_map}
/// a property map containing for each face of `pmesh` a unique index between `0` and `num_faces(pmesh)-1`
/// \cgalParamEnd
/// \cgalParamNBegin{vertex_point_map}
/// \cgalParamDescription{a property map associating points to the vertices of `pmesh`}
/// \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
/// as key type and `%Point_3` as value type}
/// \cgalParamDefault{`boost::get(CGAL::vertex_point, pmesh)`}
/// \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
/// must be available in `PolygonMesh`.}
/// \cgalParamNEnd
///
/// \cgalParamNBegin{apply_per_connected_component}
/// \cgalParamDescription{specifies if the borders should only be stitched only within their own connected component.}
/// \cgalParamType{Boolean}
/// \cgalParamDefault{`false`}
/// \cgalParamNEnd
///
/// \cgalParamNBegin{face_index_map}
/// \cgalParamDescription{a property map associating to each face of `pmesh` a unique index between `0` and `num_faces(pmesh) - 1`}
/// \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%face_descriptor`
/// as key type and `std::size_t` as value type}
/// \cgalParamDefault{an automatically indexed internal map}
/// \cgalParamNEnd
/// \cgalNamedParamsEnd
///
/// @return the number of pairs of halfedges that were stitched.

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

@ -30,12 +30,17 @@ namespace Polygon_mesh_processing{
*
* @param transformation the transformation functor to apply to the points of `mesh`.
* @param mesh the `PolygonMesh` to transform.
* @param np optional sequence of \ref pmp_namedparameters for `mesh`, among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters for `mesh`, among the ones listed below
*
* * \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `mesh`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `PolygonMesh`\cgalParamEnd
* \cgalNamedParamsBegin
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `mesh`}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, mesh)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* must be available in `PolygonMesh`}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
*/

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

@ -404,14 +404,25 @@ public:
*
* @param f face to be triangulated
* @param pmesh the polygon mesh to which the face to be triangulated belongs
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `PolygonMesh`\cgalParamEnd
* \cgalParamBegin{geom_traits} a geometric traits class instance \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `pmesh`}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, pmesh)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* must be available in `PolygonMesh`.}
* \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
* \cgalNamedParamsEnd
*
* @return `true` if the face has been triangulated.
@ -459,16 +470,28 @@ bool triangulate_face(typename boost::graph_traits<PolygonMesh>::face_descriptor
*
* @param face_range the range of faces to be triangulated
* @param pmesh the polygon mesh to be triangulated
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `PolygonMesh`\cgalParamEnd
* \cgalParamBegin{geom_traits} a geometric traits class instance \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `pmesh`}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, pmesh)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* must be available in `PolygonMesh`.}
* \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
* \cgalNamedParamsEnd
*
* @return `true` if all the faces have been triangulated.
*
* @see triangulate_face()
*/
template <typename FaceRange, typename PolygonMesh, typename NamedParameters>
@ -508,16 +531,28 @@ bool triangulate_faces(FaceRange face_range, PolygonMesh& pmesh)
* @tparam NamedParameters a sequence of \ref pmp_namedparameters "Named Parameters"
*
* @param pmesh the polygon mesh to be triangulated
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `PolygonMesh`\cgalParamEnd
* \cgalParamBegin{geom_traits} a geometric traits class instance \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `pmesh`}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, pmesh)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* must be available in `PolygonMesh`.}
* \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
* \cgalNamedParamsEnd
*
* @return `true` if all the faces have been triangulated.
*
* @see triangulate_face()
*/
template <typename PolygonMesh, typename NamedParameters>

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

@ -55,16 +55,32 @@ namespace Polygon_mesh_processing {
@param pmesh polygon mesh containing the hole
@param border_halfedge a border halfedge incident to the hole
@param out iterator over patch faces
@param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
@param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
\cgalNamedParamsBegin
\cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
If this parameter is omitted, an internal property map for
`CGAL::vertex_point_t` must be available in `PolygonMesh`\cgalParamEnd
\cgalParamBegin{use_delaunay_triangulation} if `true`, use the Delaunay triangulation facet search space.
If no valid triangulation can be found in this search space, the algorithm falls back to the
non-Delaunay triangulations search space to find a solution \cgalParamEnd
\cgalParamBegin{geom_traits} a geometric traits class instance \cgalParamEnd
\cgalParamNBegin{vertex_point_map}
\cgalParamDescription{a property map associating points to the vertices of `pmesh`}
\cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
as key type and `%Point_3` as value type}
\cgalParamDefault{`boost::get(CGAL::vertex_point, pmesh)`}
\cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
must be available in `PolygonMesh`.}
\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{use_delaunay_triangulation}
\cgalParamDescription{If `true`, use the Delaunay triangulation facet search space.}
\cgalParamType{Boolean}
\cgalParamDefault{`true`}
\cgalParamExtra{If no valid triangulation can be found in this search space, the algorithm
falls back to the non-Delaunay triangulations search space to find a solution.}
\cgalParamNEnd
\cgalNamedParamsEnd
@return `out`
@ -149,18 +165,39 @@ namespace Polygon_mesh_processing {
@param border_halfedge a border halfedge incident to the hole
@param face_out output iterator over patch faces
@param vertex_out output iterator over patch vertices without including the boundary
@param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
@param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
\cgalNamedParamsBegin
\cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
If this parameter is omitted, an internal property map for
`CGAL::vertex_point_t` should be available in `PolygonMesh`\cgalParamEnd
\cgalParamBegin{density_control_factor} factor to control density of the ouput mesh, where larger values
cause denser refinements, as in `refine()` \cgalParamEnd
\cgalParamBegin{use_delaunay_triangulation} if `true`, use the Delaunay triangulation facet search space.
If no valid triangulation can be found in this search space, the algorithm falls back to the
non-Delaunay triangulations search space to find a solution \cgalParamEnd
\cgalParamBegin{geom_traits} a geometric traits class instance \cgalParamEnd
\cgalParamNBegin{vertex_point_map}
\cgalParamDescription{a property map associating points to the vertices of `pmesh`}
\cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
as key type and `%Point_3` as value type}
\cgalParamDefault{`boost::get(CGAL::vertex_point, pmesh)`}
\cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
must be available in `PolygonMesh`.}
\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{use_delaunay_triangulation}
\cgalParamDescription{If `true`, use the Delaunay triangulation facet search space.}
\cgalParamType{Boolean}
\cgalParamDefault{`true`}
\cgalParamExtra{If no valid triangulation can be found in this search space, the algorithm
falls back to the non-Delaunay triangulations search space to find a solution.}
\cgalParamNEnd
\cgalParamNBegin{density_control_factor}
\cgalParamDescription{factor to control density of the ouput mesh,
where larger values cause denser refinements, as in `refine()`}
\cgalParamType{double}
\cgalParamDefault{\f$ \sqrt{2}\f$}
\cgalParamNEnd
\cgalNamedParamsEnd
@return pair of `face_out` and `vertex_out`
@ -219,21 +256,57 @@ namespace Polygon_mesh_processing {
@param border_halfedge a border halfedge incident to the hole
@param face_out output iterator over patch faces
@param vertex_out output iterator over patch vertices without including the boundary
@param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
@param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
\cgalNamedParamsBegin
\cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
If this parameter is omitted, an internal property map for
`CGAL::vertex_point_t` should be available in `PolygonMesh`
\cgalParamEnd
\cgalParamBegin{use_delaunay_triangulation} if `true`, use the Delaunay triangulation facet search space.
If no valid triangulation can be found in this search space, the algorithm falls back to the
non-Delaunay triangulations search space to find a solution \cgalParamEnd
\cgalParamBegin{density_control_factor} factor to control density of the ouput mesh, where larger values
cause denser refinements, as in `refine()` \cgalParamEnd
\cgalParamBegin{fairing_continuity} tangential continuity of the output surface patch \cgalParamEnd
\cgalParamBegin{sparse_linear_solver} an instance of the sparse linear solver used for fairing \cgalParamEnd
\cgalParamBegin{geom_traits} a geometric traits class instance \cgalParamEnd
\cgalParamNBegin{vertex_point_map}
\cgalParamDescription{a property map associating points to the vertices of `pmesh`}
\cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
as key type and `%Point_3` as value type}
\cgalParamDefault{`boost::get(CGAL::vertex_point, pmesh)`}
\cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
must be available in `PolygonMesh`.}
\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{use_delaunay_triangulation}
\cgalParamDescription{If `true`, use the Delaunay triangulation facet search space.}
\cgalParamType{Boolean}
\cgalParamDefault{`true`}
\cgalParamExtra{If no valid triangulation can be found in this search space, the algorithm
falls back to the non-Delaunay triangulations search space to find a solution.}
\cgalParamNEnd
\cgalParamNBegin{density_control_factor}
\cgalParamDescription{factor to control density of the ouput mesh,
where larger values cause denser refinements, as in `refine()`}
\cgalParamType{double}
\cgalParamDefault{\f$ \sqrt{2}\f$}
\cgalParamNEnd
\cgalParamNBegin{fairing_continuity}
\cgalParamDescription{A value controling the tangential continuity of the output surface patch.
The possible values are 0, 1 and 2, refering to the C<sup>0</sup>, C<sup>1</sup>
and C<sup>2</sup> continuity.}
\cgalParamType{unsigned int}
\cgalParamDefault{`1`}
\cgalParamExtra{The larger `fairing_continuity` gets, the more fixed vertices are required}
\cgalParamNEnd
\cgalParamNBegin{sparse_linear_solver}
\cgalParamDescription{an instance of the sparse linear solver used for fairing}
\cgalParamType{a class model of `SparseLinearAlgebraWithFactorTraits_d`}
\cgalParamDefault{If \ref thirdpartyEigen "Eigen" 3.2 (or greater) is available and
`CGAL_EIGEN3_ENABLED` is defined, then the following overload of `Eigen_solver_traits`
is provided as default value:\n
`CGAL::Eigen_solver_traits<Eigen::SparseLU<CGAL::Eigen_sparse_matrix<double>::%EigenType, Eigen::COLAMDOrdering<int> > >`}
\cgalParamNEnd
\cgalNamedParamsEnd
@return tuple of
@ -319,13 +392,23 @@ namespace Polygon_mesh_processing {
@param third_points the range of third points
@param out iterator over output patch triangles, described by indices of points
in `points`
@param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
@param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
\cgalNamedParamsBegin
\cgalParamBegin{use_delaunay_triangulation} if `true`, use the Delaunay triangulation facet search space.
If no valid triangulation can be found in this search space, the algorithm falls back to the
non-Delaunay triangulations search space to find a solution \cgalParamEnd
\cgalParamBegin{geom_traits} a geometric traits class instance \cgalParamEnd
\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{use_delaunay_triangulation}
\cgalParamDescription{If `true`, use the Delaunay triangulation facet search space.}
\cgalParamType{Boolean}
\cgalParamDefault{`true`}
\cgalParamExtra{If no valid triangulation can be found in this search space, the algorithm
falls back to the non-Delaunay triangulations search space to find a solution.}
\cgalParamNEnd
\cgalNamedParamsEnd
\todo handle islands

99
Polygon_mesh_processing/include/CGAL/Rigid_triangle_mesh_collision_detection.h
View File

@ -193,22 +193,27 @@ public:
* \return the id of `tm` used to refer to that mesh.
*
* @param tm triangulated surface mesh to add
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map}
* the property map with the points associated to the vertices of `tm`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`
* \cgalParamEnd
* \cgalParamBegin{face_index_map}
* a property map containing the index of each face of `tm`. It must be initialized
* and the value must be unique per face and in the range `[0, num_faces(tm)[`.
* \cgalParamEnd
* \cgalParamBegin{apply_per_connected_component}
* if `false`, `tm` is assumed to have only one connected component, avoiding
* the extraction of connected components. Default is `true`.
* \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tm`}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor` as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t` should be available for the vertices of `tm`}
* \cgalParamNEnd
*
* \cgalParamNBegin{face_index_map}
* \cgalParamDescription{a property map associating to each face of `tm` a unique index between `0` and `num_faces(tm) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%face_descriptor` as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamNEnd
*
* \cgalParamNBegin{apply_per_connected_component}
* \cgalParamDescription{If `false`, `tm` is assumed to have only one connected component, avoiding the extraction of connected components}
* \cgalParamType{Boolean}
* \cgalParamDefault{`true`}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*/
template <class NamedParameters>
@ -250,22 +255,27 @@ public:
*
* @param tree an AABB-tree of faces of a mesh
* @param tm triangulated surface mesh
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map}
* the property map with the points associated to the vertices of `tm`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`
* \cgalParamEnd
* \cgalParamBegin{face_index_map}
* a property map containing the index of each face of `tm`. It must be initialized
* and the value must be unique per face and in the range `[0, num_faces(tm)[`.
* \cgalParamEnd
* \cgalParamBegin{apply_per_connected_component}
* if `false`, `tm` is assumed to have only one connected component, avoiding
* the extraction of connected components. Default is `true`.
* \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tm`}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor` as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t` should be available for the vertices of `tm`}
* \cgalParamNEnd
*
* \cgalParamNBegin{face_index_map}
* \cgalParamDescription{a property map associating to each face of `tm` a unique index between `0` and `num_faces(tm) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%face_descriptor` as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamNEnd
*
* \cgalParamNBegin{apply_per_connected_component}
* \cgalParamDescription{If `false`, `tm` is assumed to have only one connected component, avoiding the extraction of connected components}
* \cgalParamType{Boolean}
* \cgalParamDefault{`true`}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*/
template <class NamedParameters>
@ -491,22 +501,27 @@ public:
*
* @param tm input triangulated surface mesh
* @param [out] points will contain one point per connected component of `tm`
* @param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map}
* the property map with the points associated to the vertices of `tm`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`
* \cgalParamEnd
* \cgalParamBegin{face_index_map}
* a property map containing the index of each face of `tm`. It must be initialized
* and the value must be unique per face and in the range `[0, num_faces(tm)[`.
* \cgalParamEnd
* \cgalParamBegin{apply_per_connected_component}
* if `false`, `tm` is assumed to have only one connected component, avoiding
* the extraction of connected components. %Default is `true`.
* \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `tm`}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor` as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t` should be available for the vertices of `tm`}
* \cgalParamNEnd
*
* \cgalParamNBegin{face_index_map}
* \cgalParamDescription{a property map associating to each face of `tm` a unique index between `0` and `num_faces(tm) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<PolygonMesh>::%face_descriptor` as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamNEnd
*
* \cgalParamNBegin{apply_per_connected_component}
* \cgalParamDescription{If `false`, `tm` is assumed to have only one connected component, avoiding the extraction of connected components}
* \cgalParamType{Boolean}
* \cgalParamDefault{`true`}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*/
template <class NamedParameters>

8
Subdivision_method_3/include/CGAL/Subdivision_method_3/subdivision_hosts_3.h
View File

@ -62,7 +62,7 @@ void PQQ(PolygonMesh& pmesh, Mask mask, int step = 1) {
*
* @param pmesh a polygon mesh
* @param mask a geometry policy mask
* @param np optional sequence of \ref sm_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref sm_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
@ -109,7 +109,7 @@ void PTQ(PolygonMesh& pmesh, Mask mask, int step = 1) {
*
* @param pmesh a polygon mesh
* @param mask a geometry policy mask
* @param np optional sequence of \ref sm_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref sm_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
@ -157,7 +157,7 @@ void DQQ(PolygonMesh& pmesh, Mask mask, int step = 1) {
*
* @param pmesh a polygon mesh
* @param mask a geometry policy mask
* @param np optional sequence of \ref sm_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref sm_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
@ -209,7 +209,7 @@ void Sqrt3(PolygonMesh& pmesh, Mask mask, int step = 1) {
*
* @param pmesh a polygon mesh
* @param mask a geometry policy mask
* @param np optional sequence of \ref sm_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref sm_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.

8
Subdivision_method_3/include/CGAL/Subdivision_method_3/subdivision_methods_3.h
View File

@ -105,7 +105,7 @@ void CatmullClark_subdivision(PolygonMesh& pmesh, int step) {
* @tparam NamedParameters a sequence of \ref sm_namedparameters "Named Parameters"
*
* @param pmesh a polygon mesh
* @param np optional sequence of \ref sm_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref sm_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
@ -161,7 +161,7 @@ void Loop_subdivision(PolygonMesh& pmesh, int step) {
* @tparam NamedParameters a sequence of \ref sm_namedparameters "Named Parameters"
*
* @param pmesh a polygon mesh
* @param np optional sequence of \ref sm_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref sm_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
@ -215,7 +215,7 @@ void DooSabin_subdivision(PolygonMesh& pmesh, int step) {
* @tparam NamedParameters a sequence of \ref sm_namedparameters "Named Parameters"
*
* @param pmesh a polygon mesh
* @param np optional sequence of \ref sm_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref sm_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.
@ -272,7 +272,7 @@ void Sqrt3_subdivision(PolygonMesh& pmesh, int step) {
* @tparam NamedParameters a sequence of \ref sm_namedparameters "Named Parameters"
*
* @param pmesh a polygon mesh
* @param np optional sequence of \ref sm_namedparameters "Named Parameters" among the ones listed below
* @param np an optional sequence of \ref sm_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `pmesh`.

2
Surface_mesh_approximation/include/CGAL/Surface_mesh_approximation/approximate_triangle_mesh.h
View File

@ -65,7 +65,7 @@ unspecified_type all_default();
* @tparam NamedParameters a sequence of \ref vsa_namedparameters
*
* @param tm triangle surface mesh to be approximated
* @param np optional sequence of \ref vsa_namedparameters among the ones listed below
* @param np an optional sequence of \ref vsa_namedparameters among the ones listed below
* @return `true` if the indexed triangles represent a 2-manifold, oriented surface mesh, and `false` otherwise.
*
* \cgalNamedParamsBegin{Approximation Named Parameters}

6
Surface_mesh_approximation/include/CGAL/Variational_shape_approximation.h
View File

@ -297,7 +297,7 @@ public:
* Parameters out of range are ignored.
* @tparam NamedParameters a sequence of \ref vsa_namedparameters
* @param np optional sequence of \ref vsa_namedparameters among the ones listed below
* @param np an optional sequence of \ref vsa_namedparameters among the ones listed below
* @return number of proxies initialized
* \cgalNamedParamsBegin{Seeding Named Parameters}
@ -769,7 +769,7 @@ public:
* @brief extracts the output mesh in the form of an indexed triangle set.
* @tparam NamedParameters a sequence of \ref vsa_namedparameters
*
* @param np optional sequence of \ref vsa_namedparameters among the ones listed below
* @param np an optional sequence of \ref vsa_namedparameters among the ones listed below
* @return `true` if the extracted surface mesh is manifold, and `false` otherwise.
*
* \cgalNamedParamsBegin{Meshing Named Parameters}
@ -833,7 +833,7 @@ public:
* @brief outputs approximation results.
* @tparam NamedParameters a sequence of \ref vsa_namedparameters
* @param np optional sequence of \ref vsa_namedparameters among the ones listed below
* @param np an optional sequence of \ref vsa_namedparameters among the ones listed below
* \cgalNamedParamsBegin{Output Named Parameters}
* \cgalParamBegin{face_proxy_map} a `WritePropertyMap` with

2
Surface_mesh_simplification/doc/Surface_mesh_simplification/CGAL/Surface_mesh_simplification/edge_collapse.h
View File

@ -13,7 +13,7 @@ the number of edges effectively removed.
@param surface_mesh a triangle mesh
@param should_stop the stop-condition policy
@param np optional sequence of \ref sms_namedparameters "Named Parameters" among the ones listed below
@param np an optional sequence of \ref sms_namedparameters "Named Parameters" among the ones listed below
\cgalNamedParamsBegin
\cgalParamBegin{vertex_point_map}