manolas
/
vcglib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

fixed doxygen comments according to the new vcg's doxygen comments style (please look at doxygen-comments-style.txt in the vcgrootfolder/docs)

This commit is contained in:
granzuglia 2008-05-28 13:28:52 +00:00
parent f0373b8ebb
commit 2d281abc5d
10 changed files with 479 additions and 434 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
vcg/complex/trimesh/update/bounding.h
View File

@ -54,11 +54,15 @@ Initial commit
namespace vcg { namespace vcg {
namespace tri { namespace tri {
/** \addtogroup trimesh */ /// \ingroup trimesh
/*@{*/
/// \headerfile bounding.h vcg/complex/trimesh/update/bounding.h
/// \brief Management, updating and computation of per-vertex and per-face normals.
/**
This class is used to compute or update the normals that can be stored in the vertex or face component of a mesh.
*/
/// Management, updating and computation of per-vertex and per-face normals.
/// This class is used to compute or update the normals that can be stored in the vertex or face component of a mesh.
template <class ComputeMeshType> template <class ComputeMeshType>
class UpdateBounding class UpdateBounding
{ {
@ -69,8 +73,8 @@ typedef typename MeshType::VertexType VertexType;
typedef typename MeshType::VertexPointer VertexPointer; typedef typename MeshType::VertexPointer VertexPointer;
typedef typename MeshType::VertexIterator VertexIterator; typedef typename MeshType::VertexIterator VertexIterator;
/// Calculates the bounding box of the <ComputeMeshType> m /// \brief Calculates the bounding box of the \code <ComputeMeshType> \endcode m
///
static void Box(ComputeMeshType &m) static void Box(ComputeMeshType &m)
{ {
m.bbox.SetNull(); m.bbox.SetNull();

29
vcg/complex/trimesh/update/color.h
View File

@ -68,10 +68,15 @@ Changed name from plural to singular (normals->normal)
namespace vcg { namespace vcg {
namespace tri { namespace tri {
/** \addtogroup trimesh */
/*@{*/ /// \ingroup trimesh
/// Generation of per-vertex and per-face colors according to various strategy.
/// This class is used to compute per face or per vertex color with respect to for example Border (UpdateColor::VertexBorderFlag), Selection (UpdateColor::FaceSelected), Quality . /// \headerfile color.h vcg/complex/trimesh/update/color.h
/// \brief Generation of per-vertex and per-face colors according to various strategy.
/**
This class is used to compute per face or per vertex color with respect to for example Border (UpdateColor::VertexBorderFlag), Selection (UpdateColor::FaceSelected), Quality .
*/
template <class UpdateMeshType> template <class UpdateMeshType>
class UpdateColor class UpdateColor
@ -85,16 +90,18 @@ typedef typename UpdateMeshType::FaceType FaceType;
typedef typename UpdateMeshType::FacePointer FacePointer; typedef typename UpdateMeshType::FacePointer FacePointer;
typedef typename UpdateMeshType::FaceIterator FaceIterator; typedef typename UpdateMeshType::FaceIterator FaceIterator;
/** Color the vertexes of the mesh that are on the border /// \brief Color the vertexes of the mesh that are on the border
/**
It uses the information in the Vertex flags, and not any topology. It uses the information in the Vertex flags, and not any topology.
So it just require that you have correctly computed the flags; So it just require that you have correctly computed the flags;
vcg::tri::UpdateTopology<Mesh>::FaceFace(m.cm); - vcg::tri::UpdateTopology<Mesh>::FaceFace(m.cm);
vcg::tri::UpdateFlags<Mesh>::FaceBorderFromFF(m.cm); - vcg::tri::UpdateFlags<Mesh>::FaceBorderFromFF(m.cm);
vcg::tri::UpdateFlags<Mesh>::VertexBorderFromFace (m.cm); - vcg::tri::UpdateFlags<Mesh>::VertexBorderFromFace (m.cm);
vcg::tri::UpdateColor<Mesh>::VertexBorderFlag(m.cm); - vcg::tri::UpdateColor<Mesh>::VertexBorderFlag(m.cm);
**/ */
static void VertexBorderFlag( UpdateMeshType &m, Color4b BorderColor=Color4b::Blue, Color4b InternalColor=Color4b::White) static void VertexBorderFlag( UpdateMeshType &m, Color4b BorderColor=Color4b::Blue, Color4b InternalColor=Color4b::White)
{ {
typename UpdateMeshType::VertexIterator vi; typename UpdateMeshType::VertexIterator vi;
@ -278,7 +285,7 @@ static void VertexQuality(UpdateMeshType &m)
} }
}; };
/*@}*/
}// end namespace }// end namespace
}// end namespace }// end namespace
#endif #endif

52
vcg/complex/trimesh/update/curvature.h
View File

@ -66,11 +66,15 @@ the vertex
namespace vcg { namespace vcg {
namespace tri { namespace tri {
/** \addtogroup trimesh */ /// \ingroup trimesh
/*@{*/
/// \headerfile curvature.h vcg/complex/trimesh/update/curvature.h
/// \brief Management, updating and computation of per-vertex and per-face normals.
/**
This class is used to compute or update the normals that can be stored in the vertex or face component of a mesh.
*/
/// Management, updating and computation of per-vertex and per-face normals.
/// This class is used to compute or update the normals that can be stored in the vertex or face component of a mesh.
template <class MeshType> template <class MeshType>
class UpdateCurvature class UpdateCurvature
{ {
@ -95,17 +99,10 @@ private:
bool isBorder; bool isBorder;
}; };
public: public:
/* /// \brief Compute principal direction and magniuto of curvature.
Compute principal direction and magniuto of curvature as describe in the paper:
@InProceedings{bb33922, /**
author = "G. Taubin", Based on the paper <a href="http://mesh.caltech.edu/taubin/publications/taubin-iccv95b.pdf"> <em> "Estimating the Tensor of Curvature of a Surface from a Polyhedral Approximation" </em> </a>
title = "Estimating the Tensor of Curvature of a Surface from a
Polyhedral Approximation",
booktitle = "International Conference on Computer Vision",
year = "1995",
pages = "902--907",
URL = "http://dx.doi.org/10.1109/ICCV.1995.466840",
bibsource = "http://www.visionbib.com/bibliography/describe440.html#TT32253",
*/ */
static void PrincipalDirections(MeshType &m) { static void PrincipalDirections(MeshType &m) {
@ -284,9 +281,12 @@ public:
}; };
/** computes the discrete gaussian curvature as proposed in /// \brief Computes the discrete gaussian curvature.
Discrete Differential-Geometry Operators for Triangulated 2-Manifolds Mark Meyer,
Mathieu Desbrun, Peter Schroder, Alan H. Barr VisMath '02, Berlin /** For further details, please, refer to: \n
- <em> Discrete Differential-Geometry Operators for Triangulated 2-Manifolds Mark Meyer,
Mathieu Desbrun, Peter Schroder, Alan H. Barr VisMath '02, Berlin </em>
*/ */
static void MeanAndGaussian(MeshType & m) static void MeanAndGaussian(MeshType & m)
{ {
@ -395,14 +395,14 @@ Discrete Differential-Geometry Operators for Triangulated 2-Manifolds Mark Meyer
} }
/* Update the mean and the gaussian curvature of a vertex, using the /// \brief Update the mean and the gaussian curvature of a vertex.
* VF adiacency to walk around the vertex. Return the voronoi area
* around the vertex. /**
* if norm == true, the mean and the gaussian curvature are normalized The function uses the VF adiacency to walk around the vertex.
* based on the paper \return It will return the voronoi area around the vertex. If (norm == true) the mean and the gaussian curvature are normalized.
* "optimizing 3d triangulations using discrete curvature analysis" Based on the paper <a href="http://www2.in.tu-clausthal.de/~hormann/papers/Dyn.2001.OTU.pdf"> <em> "Optimizing 3d triangulations using discrete curvature analysis" </em> </a>
* http://www2.in.tu-clausthal.de/~hormann/papers/Dyn.2001.OTU.pdf */
* */
static float VertexCurvature(VertexPointer v, bool norm = true) static float VertexCurvature(VertexPointer v, bool norm = true)
{ {
// VFAdjacency required! // VFAdjacency required!

7
vcg/complex/trimesh/update/edges.h
View File

@ -45,10 +45,11 @@ created
namespace vcg { namespace vcg {
namespace tri { namespace tri {
/** \addtogroup trimesh */ /// \ingroup trimesh
/*@{*/
/// This class is used to compute or update the precomputed data used to efficiently compute point-face distances.. /// \headerfile edges.h vcg/complex/trimesh/update/edges.h
/// \brief This class is used to compute or update the precomputed data used to efficiently compute point-face distances.
template <class ComputeMeshType> template <class ComputeMeshType>
class UpdateEdges class UpdateEdges
{ {

26
vcg/complex/trimesh/update/flag.h
View File

@ -93,10 +93,15 @@ First working version!
namespace vcg { namespace vcg {
namespace tri { namespace tri {
/** \addtogroup trimesh */ /// \ingroup trimesh
/*@{*/
/// Management, updating and computation of per-vertex and per-face flags (like border flags). /// \headerfile flag.h vcg/complex/trimesh/update/flag.h
/// This class is used to compute or update some of the flags that can be stored in the mesh components. For now just Border flags (e.g. the flag that tells if a given edge of a face belong to a border of the mesh or not).
/// \brief Management, updating and computation of per-vertex and per-face flags (like border flags).
/**
This class is used to compute or update some of the flags that can be stored in the mesh components. For now just Border flags (e.g. the flag that tells if a given edge of a face belong to a border of the mesh or not).
*/
template <class UpdateMeshType> template <class UpdateMeshType>
class UpdateFlags class UpdateFlags
@ -112,8 +117,8 @@ typedef typename MeshType::FaceType FaceType;
typedef typename MeshType::FacePointer FacePointer; typedef typename MeshType::FacePointer FacePointer;
typedef typename MeshType::FaceIterator FaceIterator; typedef typename MeshType::FaceIterator FaceIterator;
/** Reset all the mesh flags (both vertexes and faces) setting everithing to zero (the default value for flags) /// \brief Reset all the mesh flags (both vertexes and faces) setting everithing to zero (the default value for flags)
**/
static void Clear(MeshType &m) static void Clear(MeshType &m)
{ {
assert(HasPerFaceFlags(m)); assert(HasPerFaceFlags(m));
@ -137,9 +142,11 @@ static void VertexClearV(MeshType &m) { VertexClear(m,VertexType::VISITED);}
static void VertexClearB(MeshType &m) { VertexClear(m,VertexType::BORDER);} static void VertexClearB(MeshType &m) { VertexClear(m,VertexType::BORDER);}
/** Compute the border flags for the faces using the Face-Face Topology. /// \brief Compute the border flags for the faces using the Face-Face Topology.
Obviously it assumes that the topology has been correctly computed (see: UpdateTopology::FaceFace )
**/ /**
\warning Obviously it assumes that the topology has been correctly computed (see: UpdateTopology::FaceFace )
*/
static void FaceBorderFromFF(MeshType &m) static void FaceBorderFromFF(MeshType &m)
{ {
assert(HasPerFaceFlags(m)); assert(HasPerFaceFlags(m));
@ -358,7 +365,6 @@ static void VertexBorderFromFace(MeshType &m)
}; // end class }; // end class
/*@}*/
} // End namespace tri } // End namespace tri
} // End namespace vcg } // End namespace vcg

53
vcg/complex/trimesh/update/normal.h
View File

@ -106,15 +106,18 @@ Initial commit
namespace vcg { namespace vcg {
namespace tri { namespace tri {
/** \addtogroup trimesh */ /// \ingroup trimesh
/*@{*/
/// \headerfile normal.h vcg/complex/trimesh/update/normal.h
/// \brief Management, updating and computation of per-vertex and per-face normals.
/**
This class is used to compute or update the normals that can be stored in the vertex or face component of a mesh.
*/
/// Management, updating and computation of per-vertex and per-face normals.
/// This class is used to compute or update the normals that can be stored in the vertex or face component of a mesh.
template <class ComputeMeshType> template <class ComputeMeshType>
class UpdateNormals class UpdateNormals
{ {
public: public:
typedef ComputeMeshType MeshType; typedef ComputeMeshType MeshType;
typedef typename MeshType::VertexType VertexType; typedef typename MeshType::VertexType VertexType;
@ -126,7 +129,8 @@ typedef typename MeshType::FaceType FaceType;
typedef typename MeshType::FacePointer FacePointer; typedef typename MeshType::FacePointer FacePointer;
typedef typename MeshType::FaceIterator FaceIterator; typedef typename MeshType::FaceIterator FaceIterator;
/// Calculates the face normal (if stored in the current face type) /// \brief Calculates the face normal (if stored in the current face type)
static void PerFace(ComputeMeshType &m) static void PerFace(ComputeMeshType &m)
{ {
if( !m.HasPerFaceNormal()) return; if( !m.HasPerFaceNormal()) return;
@ -135,8 +139,10 @@ static void PerFace(ComputeMeshType &m)
if( !(*f).IsD() ) face::ComputeNormal(*f); if( !(*f).IsD() ) face::ComputeNormal(*f);
} }
/// Calculates the vertex normal. Exploiting or current face normals /// \brief Calculates the vertex normal. Exploiting or current face normals.
/// The normal of a vertex v is the weigthed average of the normals of the faces incident on v. /**
The normal of a vertex v is the weigthed average of the normals of the faces incident on v.
*/
static void PerVertexFromCurrentFaceNormal(ComputeMeshType &m) static void PerVertexFromCurrentFaceNormal(ComputeMeshType &m)
{ {
if( !m.HasPerVertexNormal()) return; if( !m.HasPerVertexNormal()) return;
@ -157,8 +163,11 @@ static void PerVertexFromCurrentFaceNormal(ComputeMeshType &m)
} }
/// Calculates the vertex normal. Without exploiting or touching face normals /// \brief Calculates the vertex normal. Without exploiting or touching face normals.
/// The normal of a vertex v is the weigthed average of the normals of the faces incident on v. /**
The normal of a vertex v is the weigthed average of the normals of the faces incident on v.
*/
static void PerVertex(ComputeMeshType &m) static void PerVertex(ComputeMeshType &m)
{ {
if( !m.HasPerVertexNormal()) return; if( !m.HasPerVertexNormal()) return;
@ -183,8 +192,11 @@ static void PerVertex(ComputeMeshType &m)
} }
/// Calculates both vertex and face normals. /// \brief Calculates both vertex and face normals.
/// The normal of a vertex v is the weigthed average of the normals of the faces incident on v. /**
The normal of a vertex v is the weigthed average of the normals of the faces incident on v.
*/
static void PerVertexPerFace(ComputeMeshType &m) static void PerVertexPerFace(ComputeMeshType &m)
{ {
if( !m.HasPerVertexNormal() || !m.HasPerFaceNormal()) return; if( !m.HasPerVertexNormal() || !m.HasPerFaceNormal()) return;
@ -206,15 +218,18 @@ static void PerVertexPerFace(ComputeMeshType &m)
} }
} }
/// Calculates both vertex and face normals. /// \brief Calculates both vertex and face normals.
/// The normal of a vertex v is the weigthed average of the normals of the faces incident on v. /**
The normal of a vertex v is the weigthed average of the normals of the faces incident on v.
*/
static void PerVertexNormalizedPerFace(ComputeMeshType &m) static void PerVertexNormalizedPerFace(ComputeMeshType &m)
{ {
PerVertexPerFace(m); PerVertexPerFace(m);
NormalizeVertex(m); NormalizeVertex(m);
} }
/// Normalize the lenght of the face normals /// \brief Normalize the lenght of the face normals.
static void NormalizeVertex(ComputeMeshType &m) static void NormalizeVertex(ComputeMeshType &m)
{ {
VertexIterator vi; VertexIterator vi;
@ -223,7 +238,7 @@ static void NormalizeVertex(ComputeMeshType &m)
(*vi).N().Normalize(); (*vi).N().Normalize();
} }
/// Normalize the lenght of the face normals /// \brief Normalize the lenght of the face normals.
static void NormalizeFace(ComputeMeshType &m) static void NormalizeFace(ComputeMeshType &m)
{ {
FaceIterator fi; FaceIterator fi;
@ -291,7 +306,7 @@ static void PerFaceNormalized(ComputeMeshType &m)
} }
/// Calculates the vertex normal /// \brief Calculates the vertex normal.
static void PerVertexNormalized(ComputeMeshType &m) static void PerVertexNormalized(ComputeMeshType &m)
{ {
if( !m.HasPerVertexNormal()) return; if( !m.HasPerVertexNormal()) return;
@ -301,7 +316,7 @@ static void PerVertexNormalized(ComputeMeshType &m)
(*vi).N().Normalize(); (*vi).N().Normalize();
} }
/// multiply the vertex normals by the matrix passed. By default, the scale component is removed /// \brief Multiply the vertex normals by the matrix passed. By default, the scale component is removed.
static void PerVertexMatrix(ComputeMeshType &m, const Matrix44<ScalarType> &mat, bool remove_scaling= true){ static void PerVertexMatrix(ComputeMeshType &m, const Matrix44<ScalarType> &mat, bool remove_scaling= true){
float scale; float scale;
@ -321,7 +336,7 @@ static void PerVertexMatrix(ComputeMeshType &m, const Matrix44<ScalarType> &mat,
(*vi).N() = mat33*(*vi).N(); (*vi).N() = mat33*(*vi).N();
} }
/// multiply the face normals by the matrix passed. By default, the scale component is removed /// \brief Multiply the face normals by the matrix passed. By default, the scale component is removed.
static void PerFaceMatrix(ComputeMeshType &m, const Matrix44<ScalarType> &mat, bool remove_scaling= true){ static void PerFaceMatrix(ComputeMeshType &m, const Matrix44<ScalarType> &mat, bool remove_scaling= true){
float scale; float scale;

9
vcg/complex/trimesh/update/position.h
View File

@ -37,10 +37,11 @@ Initial commit
namespace vcg { namespace vcg {
namespace tri { namespace tri {
/** \addtogroup trimesh */ /// \ingroup trimesh
/*@{*/
/// This class is used to update vertex position according to a transformation matrix. /// \headerfile position.h vcg/complex/trimesh/update/position.h
/// \brief This class is used to update vertex position according to a transformation matrix.
template <class ComputeMeshType> template <class ComputeMeshType>
class UpdatePosition class UpdatePosition
{ {
@ -55,7 +56,7 @@ typedef typename MeshType::FaceType FaceType;
typedef typename MeshType::FacePointer FacePointer; typedef typename MeshType::FacePointer FacePointer;
typedef typename MeshType::FaceIterator FaceIterator; typedef typename MeshType::FaceIterator FaceIterator;
/// Multiply /// \brief Multiply
static void Matrix(ComputeMeshType &m, const Matrix44<ScalarType> &M, bool update_also_normals = true) static void Matrix(ComputeMeshType &m, const Matrix44<ScalarType> &M, bool update_also_normals = true)
{ {
VertexIterator vi; VertexIterator vi;

22
vcg/complex/trimesh/update/quality.h
View File

@ -59,15 +59,19 @@ First working version!
namespace vcg { namespace vcg {
namespace tri { namespace tri {
/** \addtogroup trimesh */ /// \ingroup trimesh
/*@{*/
/** Generation of per-vertex and per-face Qualities according to various strategy, like geodesic distance from the border (UpdateQuality::VertexGeodesicFromBorder) or curvature ecc. /// \headerfile quality.h vcg/complex/trimesh/update/quality.h
/// \brief Generation of per-vertex and per-face qualities.
/**
It works according to various strategy, like geodesic distance from the border (UpdateQuality::VertexGeodesicFromBorder) or curvature ecc.
This class is templated over the mesh and (like all other Update* classes) has only static members; Typical usage: This class is templated over the mesh and (like all other Update* classes) has only static members; Typical usage:
\code \code
MyMeshType m; MyMeshType m;
UpdateQuality<MyMeshType>::VertexGeodesicFromBorder(m); UpdateQuality<MyMeshType>::VertexGeodesicFromBorder(m);
\endcode \endcode
**/ */
template <class UpdateMeshType> template <class UpdateMeshType>
class UpdateQuality class UpdateQuality
@ -118,10 +122,14 @@ public:
// della nuova distanza essa rimanesse uguale a prima. Patchato rimettendo i vertici nello // della nuova distanza essa rimanesse uguale a prima. Patchato rimettendo i vertici nello
// heap solo se migliorano la distanza di un epsilon == 1/100000 della mesh diag. // heap solo se migliorano la distanza di un epsilon == 1/100000 della mesh diag.
/** Compute, for each vertex of the mesh the geodesic distance from the border of the mesh itself; /// \brief Compute, for each vertex of the mesh the geodesic distance from the border of the mesh itself.
Requirements: VF topology, Per Vertex Quality and border flags already computed (see UpdateFlags::FaceBorderFromVF and UpdateTopology::VertexFace);
it uses the classical dijkstra Shortest Path Tree algorithm. /**
It uses the classical Dijkstra Shortest Path Tree algorithm.
The geodesic distance is approximated by allowing to walk only along edges of the mesh. The geodesic distance is approximated by allowing to walk only along edges of the mesh.
\warning VF topology, Per Vertex Quality and border flags already computed (see UpdateFlags::FaceBorderFromVF and UpdateTopology::VertexFace);
*/ */
static void VertexGeodesicFromBorder(MeshType &m) // R1 static void VertexGeodesicFromBorder(MeshType &m) // R1
{ {

28
vcg/complex/trimesh/update/selection.h
View File

@ -40,11 +40,15 @@ First Working Version
namespace vcg { namespace vcg {
namespace tri { namespace tri {
/** \addtogroup trimesh */ /// \ingroup trimesh
/*@{*/
/// \headerfile selection.h vcg/complex/trimesh/update/selection.h
/// \brief Management, updating and computation of per-vertex and per-face normals.
/**
This class is used to compute or update the normals that can be stored in the vertex or face component of a mesh.
*/
/// Management, updating and computation of per-vertex and per-face normals.
/// This class is used to compute or update the normals that can be stored in the vertex or face component of a mesh.
template <class ComputeMeshType> template <class ComputeMeshType>
class UpdateSelection class UpdateSelection
{ {
@ -58,7 +62,6 @@ typedef typename MeshType::FaceType FaceType;
typedef typename MeshType::FacePointer FacePointer; typedef typename MeshType::FacePointer FacePointer;
typedef typename MeshType::FaceIterator FaceIterator; typedef typename MeshType::FaceIterator FaceIterator;
///
static size_t AllVertex(MeshType &m) static size_t AllVertex(MeshType &m)
{ {
VertexIterator vi; VertexIterator vi;
@ -147,7 +150,7 @@ static size_t InvertVertex(MeshType &m)
return selCnt; return selCnt;
} }
// Select all the vertices that are touched by at least a single selected faces /// \brief Select all the vertices that are touched by at least a single selected faces
static size_t VertexFromFaceLoose(MeshType &m) static size_t VertexFromFaceLoose(MeshType &m)
{ {
size_t selCnt=0; size_t selCnt=0;
@ -163,10 +166,10 @@ static size_t VertexFromFaceLoose(MeshType &m)
return selCnt; return selCnt;
} }
// Select ONLY the vertices that are touched ONLY by selected faces /// \brief Select ONLY the vertices that are touched ONLY by selected faces
// or in other words all the vertices having all the faces incident on them selected. /** In other words all the vertices having all the faces incident on them selected.
// Ambiguity in the def: isolated vertices should be selected? NO. \warning Isolated vertices will not selected.
// */
static size_t VertexFromFaceStrict(MeshType &m) static size_t VertexFromFaceStrict(MeshType &m)
{ {
size_t selCnt=0; size_t selCnt=0;
@ -182,7 +185,7 @@ static size_t VertexFromFaceStrict(MeshType &m)
return CountVertex(m); return CountVertex(m);
} }
// Select ONLY the faces with ALL the vertices selected /// \brief Select ONLY the faces with ALL the vertices selected
static size_t FaceFromVertexStrict(MeshType &m) static size_t FaceFromVertexStrict(MeshType &m)
{ {
size_t selCnt=0; size_t selCnt=0;
@ -233,8 +236,7 @@ static size_t FaceFromBorder(MeshType &m)
} }
return selCnt; return selCnt;
} }
// Select ONLY the vertices whose quality is in the specified closed interval. /// \brief Select ONLY the vertices whose quality is in the specified closed interval.
//
static size_t VertexFromQualityRange(MeshType &m,float minq, float maxq) static size_t VertexFromQualityRange(MeshType &m,float minq, float maxq)
{ {
size_t selCnt=0; size_t selCnt=0;

7
vcg/complex/trimesh/update/texture.h
View File

@ -34,10 +34,11 @@ $Log: position.h,v $
namespace vcg { namespace vcg {
namespace tri { namespace tri {
/** \addtogroup trimesh */ /// \ingroup trimesh
/*@{*/
/// This class is used to update vertex position according to a transformation matrix. /// \headerfile texture.h vcg/complex/trimesh/update/texture.h
/// \brief This class is used to update vertex position according to a transformation matrix.
template <class ComputeMeshType> template <class ComputeMeshType>
class UpdateTexture class UpdateTexture
{ {