diff --git a/Surface_mesh_parameterization/include/CGAL/Barycentric_mapping_parameterizer_3.h b/Surface_mesh_parameterization/include/CGAL/Barycentric_mapping_parameterizer_3.h index 67824f1563a..d632259f048 100644 --- a/Surface_mesh_parameterization/include/CGAL/Barycentric_mapping_parameterizer_3.h +++ b/Surface_mesh_parameterization/include/CGAL/Barycentric_mapping_parameterizer_3.h @@ -27,7 +27,8 @@ namespace CGAL { - +/// \ingroup PkgSurfaceParameterizationMethods +/// /// The class Barycentric_mapping_parameterizer_3 implements Tutte Barycentric Mapping algorithm [Tut63]. /// This algorithm is also called "Tutte Uniform Weights" by other authors. /// @@ -44,16 +45,25 @@ namespace CGAL { /// \models ParameterizerTraits_3 /// /// ## Design Pattern ## -/// Barycentric_mapping_parameterizer_3 class is a -/// Strategy [GHJV95]: it implements a strategy of surface parameterization -/// for models of ParameterizationMesh_3. +/// `Barycentric_mapping_parameterizer_3` class is a +/// Strategy \cite cgal:ghjv-dpero-95 : it implements a strategy of surface parameterization +/// for models of `ParameterizationMesh_3`. /// -/// @param ParameterizationMesh_3 3D surface mesh. -/// @param BorderParameterizer_3 Strategy to parameterize the surface border. -/// @param SparseLinearAlgebraTraits_d Traits class to solve a sparse linear system. +/// \tparam ParameterizationMesh_3 3D surface mesh. +/// \tparam BorderParameterizer_3 Strategy to parameterize the surface border. +/// \tparam SparseLinearAlgebraTraits_d Traits class to solve a sparse linear system. /// Note: the system is *not* symmetric because Fixed_border_parameterizer_3 /// does not remove (yet) border vertices from the system. +/*! +\sa `CGAL::Parameterizer_traits_3` +\sa `CGAL::Fixed_border_parameterizer_3` +\sa `CGAL::Discrete_authalic_parameterizer_3` +\sa `CGAL::Discrete_conformal_map_parameterizer_3` +\sa `CGAL::LSCM_parameterizer_3` +\sa `CGAL::Mean_value_coordinates_parameterizer_3` + */ + template < class ParameterizationMesh_3, diff --git a/Surface_mesh_parameterization/include/CGAL/Circular_border_parameterizer_3.h b/Surface_mesh_parameterization/include/CGAL/Circular_border_parameterizer_3.h index 7e4c5b00906..0d39db3e768 100644 --- a/Surface_mesh_parameterization/include/CGAL/Circular_border_parameterizer_3.h +++ b/Surface_mesh_parameterization/include/CGAL/Circular_border_parameterizer_3.h @@ -32,6 +32,8 @@ namespace CGAL { // Class Circular_border_parameterizer_3 // +/// \ingroup PkgSurfaceParameterizationBorder +/// /// This is the base class of strategies that parameterize the border /// of a 3D surface onto a circle. /// Circular_border_parameterizer_3 is a pure virtual class, thus @@ -49,6 +51,9 @@ namespace CGAL { /// ## Design Pattern ## /// BorderParameterizer_3 models are Strategies [GHJV95]: they implement /// a strategy of border parameterization for models of ParameterizationMesh_3. +/// +/// \sa CGAL::Circular_border_arc_length_parameterizer_3` +/// \sa CGAL::Circular_border_uniform_parameterizer_3}` template //< 3D surface class Circular_border_parameterizer_3 @@ -204,6 +209,8 @@ Circular_border_parameterizer_3::parameterize_border(Adaptor& mesh) // Class Circular_border_uniform_parameterizer_3 // +/// \ingroup PkgSurfaceParameterizationBorder +/// /// This class parameterizes the border of a 3D surface onto a circle /// in a uniform manner: points are equally spaced. /// Circular_border_parameterizer_3 implements most of the border parameterization @@ -215,6 +222,9 @@ Circular_border_parameterizer_3::parameterize_border(Adaptor& mesh) /// ## Design Pattern ## /// BorderParameterizer_3 models are Strategies [GHJV95]: they implement /// a strategy of border parameterization for models of ParameterizationMesh_3 +/// +/// \sa CGAL::Circular_border_arc_length_parameterizer_3` +/// \sa CGAL::Circular_border_parameterizer_3}` template //< 3D surface class Circular_border_uniform_parameterizer_3 @@ -283,6 +293,8 @@ protected: // Class Circular_border_arc_length_parameterizer_3 // +/// \ingroup PkgSurfaceParameterizationBorder +/// /// This class parameterizes the border of a 3D surface onto a circle, /// with an arc-length parameterization: (u,v) values are /// proportional to the length of border edges. @@ -295,6 +307,9 @@ protected: /// ## Design Pattern ## /// BorderParameterizer_3 models are Strategies [GHJV95]: they implement /// a strategy of border parameterization for models of ParameterizationMesh_3 +/// +/// \sa CGAL::Circular_border_parameterizer_3` +/// \sa CGAL::Circular_border_uniform_parameterizer_3}` template //< 3D surface class Circular_border_arc_length_parameterizer_3 diff --git a/Surface_mesh_parameterization/include/CGAL/Discrete_authalic_parameterizer_3.h b/Surface_mesh_parameterization/include/CGAL/Discrete_authalic_parameterizer_3.h index 089ac160c4a..b1f12db78a0 100644 --- a/Surface_mesh_parameterization/include/CGAL/Discrete_authalic_parameterizer_3.h +++ b/Surface_mesh_parameterization/include/CGAL/Discrete_authalic_parameterizer_3.h @@ -28,6 +28,8 @@ namespace CGAL { +/// \ingroup PkgSurfaceParameterizationMethods +/// /// The class Discrete_authalic_parameterizer_3 /// implements the Discrete Authalic Parameterization algorithm [DMA02]. /// This method is sometimes called "DAP" or just "Authalic parameterization". @@ -51,6 +53,13 @@ namespace CGAL { /// Discrete_authalic_parameterizer_3 class is a /// Strategy [GHJV95]: it implements a strategy of surface parameterization /// for models of ParameterizationMesh_3. +/// +/// \sa `CGAL::Parameterizer_traits_3` +/// \sa `CGAL::Fixed_border_parameterizer_3` +/// \sa `CGAL::Barycentric_mapping_parameterizer_3` +/// \sa `CGAL::Discrete_conformal_map_parameterizer_3` +/// \sa `CGAL::LSCM_parameterizer_3` +/// \sa `CGAL::Mean_value_coordinates_parameterizer_3` template < diff --git a/Surface_mesh_parameterization/include/CGAL/Discrete_conformal_map_parameterizer_3.h b/Surface_mesh_parameterization/include/CGAL/Discrete_conformal_map_parameterizer_3.h index eddebc08fbf..3d31b3d3f9f 100644 --- a/Surface_mesh_parameterization/include/CGAL/Discrete_conformal_map_parameterizer_3.h +++ b/Surface_mesh_parameterization/include/CGAL/Discrete_conformal_map_parameterizer_3.h @@ -28,6 +28,8 @@ namespace CGAL { +/// \ingroup PkgSurfaceParameterizationMethods +/// /// The class Discrete_conformal_map_parameterizer_3 /// implements the Discrete Conformal Map (DCM) parameterization [EDD+95]. /// This algorithm is also called "Discrete Conformal Parameterization (DCP)", @@ -51,11 +53,18 @@ namespace CGAL { /// Strategy [GHJV95]: it implements a strategy of surface parameterization /// for models of ParameterizationMesh_3. /// -/// @param ParameterizationMesh_3 3D surface mesh. -/// @param BorderParameterizer_3 Strategy to parameterize the surface border. -/// @param SparseLinearAlgebraTraits_d Traits class to solve a sparse linear system. +/// \param ParameterizationMesh_3 3D surface mesh. +/// \param BorderParameterizer_3 Strategy to parameterize the surface border. +/// \param SparseLinearAlgebraTraits_d Traits class to solve a sparse linear system. /// Note: the system is *not* symmetric because Fixed_border_parameterizer_3 /// does not remove (yet) border vertices from the system. +/// +/// \sa `CGAL::Parameterizer_traits_3` +/// \sa `CGAL::Fixed_border_parameterizer_3` +/// \sa `CGAL::Barycentric_mapping_parameterizer_3` +/// \sa `CGAL::Discrete_authalic_parameterizer_3` +/// \sa `CGAL::LSCM_parameterizer_3` +/// \sa `CGAL::Mean_value_coordinates_parameterizer_3` template < diff --git a/Surface_mesh_parameterization/include/CGAL/Fixed_border_parameterizer_3.h b/Surface_mesh_parameterization/include/CGAL/Fixed_border_parameterizer_3.h index 10e9c37fd8a..73394d9c6c6 100644 --- a/Surface_mesh_parameterization/include/CGAL/Fixed_border_parameterizer_3.h +++ b/Surface_mesh_parameterization/include/CGAL/Fixed_border_parameterizer_3.h @@ -40,6 +40,9 @@ namespace CGAL { // Declaration // ------------------------------------------------------------------------------------ + +/// \ingroup PkgSurfaceParameterizationMethods +/// /// The class Fixed_border_parameterizer_3 /// is the base class of fixed border parameterization methods (Tutte, Floater, ...). /// @@ -64,6 +67,13 @@ namespace CGAL { /// Fixed_border_parameterizer_3 class is a /// Strategy [GHJV95]: it implements (part of) a strategy of surface parameterization /// for models of ParameterizationMesh_3. +/// +/// \sa `CGAL::Parameterizer_traits_3` +/// \sa `CGAL::Barycentric_mapping_parameterizer_3` +/// \sa `CGAL::Discrete_authalic_parameterizer_3` +/// \sa `CGAL::Discrete_conformal_map_parameterizer_3` +/// \sa `CGAL::LSCM_parameterizer_3` +/// \sa `CGAL::Mean_value_coordinates_parameterizer_3` template < @@ -151,21 +161,21 @@ public: // Default copy constructor and operator =() are fine - /// Compute a one-to-one mapping from a triangular 3D surface 'mesh' + /// Compute a one-to-one mapping from a triangular 3D surface mesh /// to a piece of the 2D space. /// The mapping is linear by pieces (linear in each triangle). /// The result is the (u,v) pair image of each vertex of the 3D surface. /// - /// \pre 'mesh' must be a surface with one connected component. - /// \pre 'mesh' must be a triangular mesh. + /// \pre `mesh` must be a surface with one connected component. + /// \pre `mesh` must be a triangular mesh. /// \pre The mesh border must be mapped onto a convex polygon. virtual Error_code parameterize(Adaptor& mesh); // Protected operations protected: /// Check parameterize() preconditions: - /// - 'mesh' must be a surface with one connected component. - /// - 'mesh' must be a triangular mesh. + /// - `mesh` must be a surface with one connected component. + /// - `mesh` must be a triangular mesh. /// - The mesh border must be mapped onto a convex polygon. virtual Error_code check_parameterize_preconditions(Adaptor& mesh); @@ -239,14 +249,14 @@ private: // Implementation // ------------------------------------------------------------------------------------ -// Compute a one-to-one mapping from a triangular 3D surface 'mesh' +// Compute a one-to-one mapping from a triangular 3D surface mesh // to a piece of the 2D space. // The mapping is linear by pieces (linear in each triangle). // The result is the (u,v) pair image of each vertex of the 3D surface. // // Preconditions: -// - 'mesh' must be a surface with one connected component. -// - 'mesh' must be a triangular mesh. +// - `mesh` must be a surface with one connected component. +// - `mesh` must be a triangular mesh. // - The mesh border must be mapped onto a convex polygon. template inline @@ -374,8 +384,8 @@ parameterize(Adaptor& mesh) // Check parameterize() preconditions: -// - 'mesh' must be a surface with one connected component. -// - 'mesh' must be a triangular mesh. +// - `mesh` must be a surface with one connected component. +// - `mesh` must be a triangular mesh. // - The mesh border must be mapped onto a convex polygon. template inline diff --git a/Surface_mesh_parameterization/include/CGAL/LSCM_parameterizer_3.h b/Surface_mesh_parameterization/include/CGAL/LSCM_parameterizer_3.h index c55fa407d75..d2325635a65 100644 --- a/Surface_mesh_parameterization/include/CGAL/LSCM_parameterizer_3.h +++ b/Surface_mesh_parameterization/include/CGAL/LSCM_parameterizer_3.h @@ -39,6 +39,8 @@ namespace CGAL { // Declaration // ------------------------------------------------------------------------------------ +/// \ingroup PkgSurfaceParameterizationMethods +/// /// The class LSCM_parameterizer_3 implements the /// Least Squares Conformal Maps (LSCM) parameterization [LPRM02]. /// @@ -54,6 +56,13 @@ namespace CGAL { /// LSCM_parameterizer_3 class is a /// Strategy [GHJV95]: it implements a strategy of surface parameterization /// for models of ParameterizationMesh_3. +/// +/// \sa `CGAL::Parameterizer_traits_3` +/// \sa `CGAL::Fixed_border_parameterizer_3` +/// \sa `CGAL::Barycentric_mapping_parameterizer_3` +/// \sa `CGAL::Discrete_authalic_parameterizer_3` +/// \sa `CGAL::Discrete_conformal_map_parameterizer_3` +/// \sa `CGAL::Mean_value_coordinates_parameterizer_3` template < @@ -144,20 +153,20 @@ public: // Default copy constructor and operator =() are fine - /// Compute a one-to-one mapping from a triangular 3D surface 'mesh' + /// Compute a one-to-one mapping from a triangular 3D surface mesh /// to a piece of the 2D space. /// The mapping is linear by pieces (linear in each triangle). /// The result is the (u,v) pair image of each vertex of the 3D surface. /// - /// \pre 'mesh' must be a surface with one connected component. - /// \pre 'mesh' must be a triangular mesh. + /// \pre `mesh` must be a surface with one connected component. + /// \pre `mesh` must be a triangular mesh. virtual Error_code parameterize(Adaptor& mesh); // Private operations private: /// Check parameterize() preconditions: - /// - 'mesh' must be a surface with one connected component. - /// - 'mesh' must be a triangular mesh. + /// - `mesh` must be a surface with one connected component. + /// - `mesh` must be a triangular mesh. virtual Error_code check_parameterize_preconditions(Adaptor& mesh); /// Initialize "A*X = B" linear system after @@ -217,14 +226,14 @@ private: // Implementation // ------------------------------------------------------------------------------------ -// Compute a one-to-one mapping from a triangular 3D surface 'mesh' +// Compute a one-to-one mapping from a triangular 3D surface mesh // to a piece of the 2D space. // The mapping is linear by pieces (linear in each triangle). // The result is the (u,v) pair image of each vertex of the 3D surface. // // Preconditions: -// - 'mesh' must be a surface with one connected component. -// - 'mesh' must be a triangular mesh. +// - `mesh` must be a surface with one connected component. +// - `mesh` must be a triangular mesh. // // Implementation note: Outline of the algorithm: // 1) Find an initial solution by projecting on a plane. @@ -338,8 +347,8 @@ parameterize(Adaptor& mesh) // Check parameterize() preconditions: -// - 'mesh' must be a surface with one connected component -// - 'mesh' must be a triangular mesh +// - `mesh` must be a surface with one connected component +// - `mesh` must be a triangular mesh template inline typename LSCM_parameterizer_3::Error_code diff --git a/Surface_mesh_parameterization/include/CGAL/Mean_value_coordinates_parameterizer_3.h b/Surface_mesh_parameterization/include/CGAL/Mean_value_coordinates_parameterizer_3.h index f2c2e38c971..0bc3d81bf1d 100644 --- a/Surface_mesh_parameterization/include/CGAL/Mean_value_coordinates_parameterizer_3.h +++ b/Surface_mesh_parameterization/include/CGAL/Mean_value_coordinates_parameterizer_3.h @@ -28,6 +28,8 @@ namespace CGAL { +/// \ingroup PkgSurfaceParameterizationMethods +/// /// The class Mean_value_coordinates_parameterizer_3 /// implements Floater Mean Value Coordinates parameterization [Flo03]. /// This method is sometimes called simply "Floater parameterization". @@ -50,6 +52,13 @@ namespace CGAL { /// Mean_value_coordinates_parameterizer_3 class is a /// Strategy [GHJV95]: it implements a strategy of surface parameterization /// for models of ParameterizationMesh_3. +/// +/// \sa `CGAL::Parameterizer_traits_3` +/// \sa `CGAL::Fixed_border_parameterizer_3` +/// \sa `CGAL::Barycentric_mapping_parameterizer_3` +/// \sa `CGAL::Discrete_authalic_parameterizer_3` +/// \sa `CGAL::Discrete_conformal_map_parameterizer_3` +/// \sa `CGAL::LSCM_parameterizer_3} template < diff --git a/Surface_mesh_parameterization/include/CGAL/Parameterization_mesh_feature_extractor.h b/Surface_mesh_parameterization/include/CGAL/Parameterization_mesh_feature_extractor.h index b0c240174c0..6418174dd41 100644 --- a/Surface_mesh_parameterization/include/CGAL/Parameterization_mesh_feature_extractor.h +++ b/Surface_mesh_parameterization/include/CGAL/Parameterization_mesh_feature_extractor.h @@ -27,6 +27,8 @@ namespace CGAL { +/// \ingroup PkgSurfaceParameterizationHelper +/// /// The class Parameterization_mesh_feature_extractor /// computes features (genus, borders, ...) of a 3D surface, /// model of the ParameterizationMesh_3 concept. @@ -86,8 +88,8 @@ public: /// Constructor. /// - /// CAUTION: This class caches the result of feature extractions - /// => The caller must *not* modify 'mesh' during the + /// \attention This class caches the result of feature extractions + /// => The caller must *not* modify `mesh` during the /// Parameterization_mesh_feature_extractor life cycle. Parameterization_mesh_feature_extractor(Adaptor& mesh) // Store reference to adapted mesh diff --git a/Surface_mesh_parameterization/include/CGAL/Parameterization_mesh_patch_3.h b/Surface_mesh_parameterization/include/CGAL/Parameterization_mesh_patch_3.h index e2c017e5f57..9e6260b6510 100644 --- a/Surface_mesh_parameterization/include/CGAL/Parameterization_mesh_patch_3.h +++ b/Surface_mesh_parameterization/include/CGAL/Parameterization_mesh_patch_3.h @@ -37,6 +37,8 @@ namespace CGAL { +/// \ingroup PkgSurfaceParameterizationMesh +/// /// Parameterization_mesh_patch_3 is a Decorator class to "virtually" cut a patch /// in a ParameterizationPatchableMesh_3 3D surface. Only the patch is exported, /// making the 3D surface look like a topological disk. diff --git a/Surface_mesh_parameterization/include/CGAL/Parameterization_polyhedron_adaptor_3.h b/Surface_mesh_parameterization/include/CGAL/Parameterization_polyhedron_adaptor_3.h index cf9360046d7..57334fa6ccb 100644 --- a/Surface_mesh_parameterization/include/CGAL/Parameterization_polyhedron_adaptor_3.h +++ b/Surface_mesh_parameterization/include/CGAL/Parameterization_polyhedron_adaptor_3.h @@ -35,6 +35,8 @@ namespace CGAL { +/// \ingroup PkgSurfaceParameterizationMesh +/// /// Parameterization_polyhedron_adaptor_3 is an adaptor class to access to a Polyhedron /// 3D mesh using the ParameterizationPatchableMesh_3 interface. /// Among other things, this concept defines the accessor to the (u,v) values diff --git a/Surface_mesh_parameterization/include/CGAL/Parameterizer_traits_3.h b/Surface_mesh_parameterization/include/CGAL/Parameterizer_traits_3.h index 03786a69b17..ae7a0494e04 100644 --- a/Surface_mesh_parameterization/include/CGAL/Parameterizer_traits_3.h +++ b/Surface_mesh_parameterization/include/CGAL/Parameterizer_traits_3.h @@ -28,6 +28,8 @@ namespace CGAL { +/// \ingroup PkgSurfaceParameterizationMethods +/// /// The class Parameterizer_traits_3 /// is the base class of all parameterization methods. /// This class is a pure virtual class, thus cannot be instantiated. @@ -42,6 +44,14 @@ namespace CGAL { /// ## Design Pattern ## /// ParameterizerTraits_3 models are Strategies [GHJV95]: they implement /// a strategy of surface parameterization for models of ParameterizationMesh_3. +/// + +/// \sa `CGAL::Fixed_border_parameterizer_3` +/// \sa `CGAL::Barycentric_mapping_parameterizer_3` +/// \sa `CGAL::Discrete_authalic_parameterizer_3` +/// \sa `CGAL::Discrete_conformal_map_parameterizer_3` +/// \sa `CGAL::LSCM_parameterizer_3` +/// \sa `CGAL::Mean_value_coordinates_parameterizer_3` template //< 3D surface class Parameterizer_traits_3 @@ -107,13 +117,13 @@ public: // Default constructor, copy constructor and operator =() are fine - /// Compute a one-to-one mapping from a 3D surface 'mesh' + /// Compute a one-to-one mapping from a 3D surface mesh /// to a piece of the 2D space. /// The mapping is linear by pieces (linear in each triangle). /// The result is the (u,v) pair image of each vertex of the 3D surface. /// - /// \pre 'mesh' must be a surface with one connected component. - /// \pre 'mesh' must be a triangular mesh. + /// \pre `mesh` must be a surface with one connected component. + /// \pre `mesh` must be a triangular mesh. virtual Error_code parameterize (Adaptor& mesh) = 0; /// Get message (in English) corresponding to an error code diff --git a/Surface_mesh_parameterization/include/CGAL/Square_border_parameterizer_3.h b/Surface_mesh_parameterization/include/CGAL/Square_border_parameterizer_3.h index 789ed0d400d..aab47c93232 100644 --- a/Surface_mesh_parameterization/include/CGAL/Square_border_parameterizer_3.h +++ b/Surface_mesh_parameterization/include/CGAL/Square_border_parameterizer_3.h @@ -36,6 +36,8 @@ namespace CGAL { // Class Square_border_parameterizer_3 // +/// \ingroup PkgSurfaceParameterizationBorder +/// /// This is the base class of strategies that parameterize the border /// of a 3D surface onto a square. /// Square_border_parameterizer_3 is a pure virtual class, thus @@ -281,6 +283,9 @@ Square_border_parameterizer_3::closest_iterator(Adaptor& mesh, // Class Square_border_uniform_parameterizer_3 // + +/// \ingroup PkgSurfaceParameterizationBorder +/// /// This class parameterizes the border of a 3D surface onto a square /// in a uniform manner: points are equally spaced. /// @@ -361,6 +366,8 @@ protected: // Class Square_border_arc_length_parameterizer_3 // +/// \ingroup PkgSurfaceParameterizationBorder +/// /// This class parameterizes the border of a 3D surface onto a square, /// with an arc-length parameterization: (u,v) values are /// proportional to the length of border edges. diff --git a/Surface_mesh_parameterization/include/CGAL/Taucs_solver_traits.h b/Surface_mesh_parameterization/include/CGAL/Taucs_solver_traits.h index 6499aa9a9d8..11dd54f8e7d 100644 --- a/Surface_mesh_parameterization/include/CGAL/Taucs_solver_traits.h +++ b/Surface_mesh_parameterization/include/CGAL/Taucs_solver_traits.h @@ -50,6 +50,8 @@ namespace CGAL { +/// \ingroup PkgSurfaceParameterizationAlgebra +/// /// The class Taucs_symmetric_solver_traits /// is a traits class for solving symmetric positive definite sparse linear systems /// using TAUCS solvers family. @@ -186,6 +188,8 @@ private: }; +/// \ingroup PkgSurfaceParameterizationAlgebra +/// /// The class Taucs_solver_traits /// is a traits class for solving GENERAL (aka unsymmetric) sparse linear systems /// using TAUCS out-of-core LU factorization. diff --git a/Surface_mesh_parameterization/include/CGAL/Two_vertices_parameterizer_3.h b/Surface_mesh_parameterization/include/CGAL/Two_vertices_parameterizer_3.h index 763e8a9f80b..20ac7c6b1a4 100644 --- a/Surface_mesh_parameterization/include/CGAL/Two_vertices_parameterizer_3.h +++ b/Surface_mesh_parameterization/include/CGAL/Two_vertices_parameterizer_3.h @@ -35,6 +35,9 @@ namespace CGAL { // Declaration // + +/// \ingroup PkgSurfaceParameterizationBorder +/// /// The class Two_vertices_parameterizer_3 /// parameterizes two extreme vertices of a 3D surface. /// This kind of border parameterization is used by free border parameterizations. diff --git a/Surface_mesh_parameterization/include/CGAL/parameterize.h b/Surface_mesh_parameterization/include/CGAL/parameterize.h index ce4cf1798b6..a6499dbfb81 100644 --- a/Surface_mesh_parameterization/include/CGAL/parameterize.h +++ b/Surface_mesh_parameterization/include/CGAL/parameterize.h @@ -26,15 +26,17 @@ namespace CGAL { -/// Compute a one-to-one mapping from a 3D triangle surface 'mesh' to a +/// \ingroup PkgSurfaceParameterizationMethods +/// +/// Compute a one-to-one mapping from a 3D triangle surface `mesh` to a /// 2D circle, using Floater Mean Value Coordinates algorithm. /// A one-to-one mapping is guaranteed. /// /// The mapping is piecewise linear on the input mesh triangles. /// The result is a (u,v) pair of parameter coordinates for each vertex of the input mesh. /// -/// \pre 'mesh' must be a surface with one connected component. -/// \pre 'mesh' must be a triangular mesh. +/// \pre `mesh` must be a surface with one connected component. +/// \pre `mesh` must be a triangular mesh. /// template typename Parameterizer_traits_3::Error_code @@ -45,7 +47,9 @@ parameterize(ParameterizationMesh_3& mesh) ///< 3D mesh, model of Parameterizat } -/// Compute a one-to-one mapping from a 3D triangle surface 'mesh' to a +/// \ingroup PkgSurfaceParameterizationMethods +/// +/// Compute a one-to-one mapping from a 3D triangle surface `mesh` to a /// simple 2D domain. /// The mapping is piecewise linear on the triangle mesh. /// The result is a pair (u,v) of parameter coordinates for each vertex of the input mesh. @@ -53,15 +57,15 @@ parameterize(ParameterizationMesh_3& mesh) ///< 3D mesh, model of Parameterizat /// One-to-one mapping may be guaranteed or /// not, depending on the chosen ParametizerTraits_3 algorithm. /// -/// \pre 'mesh' must be a surface with one connected component. -/// \pre 'mesh' must be a triangular mesh. +/// \pre `mesh` must be a surface with one connected component. +/// \pre `mesh` must be a triangular mesh. /// \pre The mesh border must be mapped onto a convex polygon /// (for fixed border parameterizations). /// template typename Parameterizer_traits_3::Error_code parameterize(ParameterizationMesh_3& mesh, ///< 3D mesh, model of ParameterizationMesh_3 - ParameterizerTraits_3 parameterizer) ///< Parameterization method for 'mesh' + ParameterizerTraits_3 parameterizer) ///< Parameterization method for `mesh` { return parameterizer.parameterize(mesh); }