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

many changes

This commit is contained in:
Andreas Fabri 2012-09-14 14:50:52 +00:00
parent 3effa6eae8
commit 2bcbae97ba
15 changed files with 147 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
Surface_mesh_parameterization/include/CGAL/Barycentric_mapping_parameterizer_3.h
View File

@ -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<ParameterizationMesh_3>`
\sa `CGAL::Fixed_border_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
\sa `CGAL::Discrete_authalic_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
\sa `CGAL::Discrete_conformal_map_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
\sa `CGAL::LSCM_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
\sa `CGAL::Mean_value_coordinates_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
*/
template
<
class ParameterizationMesh_3,

15
Surface_mesh_parameterization/include/CGAL/Circular_border_parameterizer_3.h
View File

@ -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<ParameterizationMesh_3>`
/// \sa CGAL::Circular_border_uniform_parameterizer_3<ParameterizationMesh_3>}`
template<class ParameterizationMesh_3> //< 3D surface
class Circular_border_parameterizer_3
@ -204,6 +209,8 @@ Circular_border_parameterizer_3<Adaptor>::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<Adaptor>::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<ParameterizationMesh_3>`
/// \sa CGAL::Circular_border_parameterizer_3<ParameterizationMesh_3>}`
template<class ParameterizationMesh_3> //< 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<ParameterizationMesh_3>`
/// \sa CGAL::Circular_border_uniform_parameterizer_3<ParameterizationMesh_3>}`
template<class ParameterizationMesh_3> //< 3D surface
class Circular_border_arc_length_parameterizer_3

9
Surface_mesh_parameterization/include/CGAL/Discrete_authalic_parameterizer_3.h
View File

@ -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<ParameterizationMesh_3>`
/// \sa `CGAL::Fixed_border_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
/// \sa `CGAL::Barycentric_mapping_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
/// \sa `CGAL::Discrete_conformal_map_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
/// \sa `CGAL::LSCM_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
/// \sa `CGAL::Mean_value_coordinates_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
template
<

15
Surface_mesh_parameterization/include/CGAL/Discrete_conformal_map_parameterizer_3.h
View File

@ -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<ParameterizationMesh_3>`
/// \sa `CGAL::Fixed_border_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
/// \sa `CGAL::Barycentric_mapping_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
/// \sa `CGAL::Discrete_authalic_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
/// \sa `CGAL::LSCM_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
/// \sa `CGAL::Mean_value_coordinates_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
template
<

30
Surface_mesh_parameterization/include/CGAL/Fixed_border_parameterizer_3.h
View File

@ -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<ParameterizationMesh_3>`
/// \sa `CGAL::Barycentric_mapping_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
/// \sa `CGAL::Discrete_authalic_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
/// \sa `CGAL::Discrete_conformal_map_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
/// \sa `CGAL::LSCM_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
/// \sa `CGAL::Mean_value_coordinates_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
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<class Adaptor, class Border_param, class Sparse_LA>
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<class Adaptor, class Border_param, class Sparse_LA>
inline

29
Surface_mesh_parameterization/include/CGAL/LSCM_parameterizer_3.h
View File

@ -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<ParameterizationMesh_3>`
/// \sa `CGAL::Fixed_border_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
/// \sa `CGAL::Barycentric_mapping_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
/// \sa `CGAL::Discrete_authalic_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
/// \sa `CGAL::Discrete_conformal_map_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
/// \sa `CGAL::Mean_value_coordinates_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
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<class Adaptor, class Border_param, class Sparse_LA>
inline
typename LSCM_parameterizer_3<Adaptor, Border_param, Sparse_LA>::Error_code

9
Surface_mesh_parameterization/include/CGAL/Mean_value_coordinates_parameterizer_3.h
View File

@ -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<ParameterizationMesh_3>`
/// \sa `CGAL::Fixed_border_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
/// \sa `CGAL::Barycentric_mapping_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
/// \sa `CGAL::Discrete_authalic_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
/// \sa `CGAL::Discrete_conformal_map_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
/// \sa `CGAL::LSCM_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>}
template
<

6
Surface_mesh_parameterization/include/CGAL/Parameterization_mesh_feature_extractor.h
View File

@ -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

2
Surface_mesh_parameterization/include/CGAL/Parameterization_mesh_patch_3.h
View File

@ -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.

2
Surface_mesh_parameterization/include/CGAL/Parameterization_polyhedron_adaptor_3.h
View File

@ -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

16
Surface_mesh_parameterization/include/CGAL/Parameterizer_traits_3.h
View File

@ -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<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
/// \sa `CGAL::Barycentric_mapping_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
/// \sa `CGAL::Discrete_authalic_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
/// \sa `CGAL::Discrete_conformal_map_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
/// \sa `CGAL::LSCM_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
/// \sa `CGAL::Mean_value_coordinates_parameterizer_3<ParameterizationMesh_3, BorderParameterizer_3, SparseLinearAlgebraTraits_d>`
template<class ParameterizationMesh_3> //< 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

7
Surface_mesh_parameterization/include/CGAL/Square_border_parameterizer_3.h
View File

@ -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<Adaptor>::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.

4
Surface_mesh_parameterization/include/CGAL/Taucs_solver_traits.h
View File

@ -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.

3
Surface_mesh_parameterization/include/CGAL/Two_vertices_parameterizer_3.h
View File

@ -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.

18
Surface_mesh_parameterization/include/CGAL/parameterize.h
View File

@ -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 <class ParameterizationMesh_3>
typename Parameterizer_traits_3<ParameterizationMesh_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 <class ParameterizationMesh_3, class ParameterizerTraits_3>
typename Parameterizer_traits_3<ParameterizationMesh_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);
}