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

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

@ -1,350 +1,365 @@
/**************************************************************************** /****************************************************************************
* VCGLib o o * * VCGLib o o *
* Visual and Computer Graphics Library o o * * Visual and Computer Graphics Library o o *
* _ O _ * * _ O _ *
* Copyright(C) 2004 \/)\/ * * Copyright(C) 2004 \/)\/ *
* Visual Computing Lab /\/| * * Visual Computing Lab /\/| *
* ISTI - Italian National Research Council | * * ISTI - Italian National Research Council | *
* \ * * \ *
* All rights reserved. * * All rights reserved. *
* * * *
* This program is free software; you can redistribute it and/or modify * * This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by * * it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or * * the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. * * (at your option) any later version. *
* * * *
* This program is distributed in the hope that it will be useful, * * This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of * * but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License (http://www.gnu.org/licenses/gpl.txt) * * GNU General Public License (http://www.gnu.org/licenses/gpl.txt) *
* for more details. * * for more details. *
* * * *
****************************************************************************/ ****************************************************************************/
/**************************************************************************** /****************************************************************************
History History
$Log: not supported by cvs2svn $ $Log: not supported by cvs2svn $
Revision 1.20 2008/04/18 17:52:08 cignoni Revision 1.20 2008/04/18 17:52:08 cignoni
added PerVertexFromCurrentFaceNormal added PerVertexFromCurrentFaceNormal
AreaNormalizeFace NormalizeFace AreaNormalizeFace NormalizeFace
and shortened PerVertexNormalizedPerFaceNormalized and shortened PerVertexNormalizedPerFaceNormalized
Revision 1.19 2008/02/15 08:08:59 cignoni Revision 1.19 2008/02/15 08:08:59 cignoni
added missing include matrix33 added missing include matrix33
Revision 1.18 2007/12/13 17:57:27 cignoni Revision 1.18 2007/12/13 17:57:27 cignoni
removed harmless gcc warnings removed harmless gcc warnings
Revision 1.17 2007/11/23 17:02:47 cignoni Revision 1.17 2007/11/23 17:02:47 cignoni
disambiguated pow call (again) disambiguated pow call (again)
Revision 1.16 2007/11/23 15:42:11 cignoni Revision 1.16 2007/11/23 15:42:11 cignoni
disambiguated pow call disambiguated pow call
Revision 1.15 2007/11/14 11:56:23 ganovelli Revision 1.15 2007/11/14 11:56:23 ganovelli
added updating of vertex and face normals added updating of vertex and face normals
Revision 1.14 2007/07/12 23:11:35 cignoni Revision 1.14 2007/07/12 23:11:35 cignoni
added the missing PerVertexNormalizedPerFaceNormalized added the missing PerVertexNormalizedPerFaceNormalized
Revision 1.13 2007/01/10 17:25:14 matteodelle Revision 1.13 2007/01/10 17:25:14 matteodelle
*** empty log message *** *** empty log message ***
Revision 1.12 2006/11/07 15:13:56 zifnab1974 Revision 1.12 2006/11/07 15:13:56 zifnab1974
Necessary changes for compilation with gcc 3.4.6. Especially the hash function is a problem Necessary changes for compilation with gcc 3.4.6. Especially the hash function is a problem
Revision 1.11 2005/12/06 18:22:31 pietroni Revision 1.11 2005/12/06 18:22:31 pietroni
changed FaceType::ComputeNormal and FaceType::ComputeNormalizedNormal changed FaceType::ComputeNormal and FaceType::ComputeNormalizedNormal
with face::ComputeNormal and face::ComputeNormalizedNormal with face::ComputeNormal and face::ComputeNormalizedNormal
Revision 1.10 2005/12/06 15:30:45 ponchio Revision 1.10 2005/12/06 15:30:45 ponchio
added #include triangle3.h for Normal(...) added #include triangle3.h for Normal(...)
added a few FaceType:: instead of face:: added a few FaceType:: instead of face::
Revision 1.9 2005/11/22 15:47:34 cignoni Revision 1.9 2005/11/22 15:47:34 cignoni
Moved ComputeNormal and ComputeNormalizedNormal out of the face class (no more a member function!) Moved ComputeNormal and ComputeNormalizedNormal out of the face class (no more a member function!)
Revision 1.8 2005/11/21 21:44:43 cignoni Revision 1.8 2005/11/21 21:44:43 cignoni
Moved ComputeNormal and ComputeNormalizedNormal out of the face class (no more a member function!) Moved ComputeNormal and ComputeNormalizedNormal out of the face class (no more a member function!)
Revision 1.7 2005/10/13 08:38:00 cignoni Revision 1.7 2005/10/13 08:38:00 cignoni
removed the access to the face member function normal and substituted with vcg::normal(*f); removed the access to the face member function normal and substituted with vcg::normal(*f);
Revision 1.6 2005/06/17 00:46:09 cignoni Revision 1.6 2005/06/17 00:46:09 cignoni
Added a PerVertexNormalizedPerFace (vertex are face/area weighted AND normalized) Added a PerVertexNormalizedPerFace (vertex are face/area weighted AND normalized)
Revision 1.5 2005/04/01 13:04:55 fiorin Revision 1.5 2005/04/01 13:04:55 fiorin
Minor changes Minor changes
Revision 1.4 2004/09/09 14:35:14 ponchio Revision 1.4 2004/09/09 14:35:14 ponchio
Typename changes for linux Typename changes for linux
Revision 1.3 2004/08/31 15:18:54 pietroni Revision 1.3 2004/08/31 15:18:54 pietroni
minor changes to comply gcc compiler (typename's ) minor changes to comply gcc compiler (typename's )
Revision 1.2 2004/03/12 15:22:19 cignoni Revision 1.2 2004/03/12 15:22:19 cignoni
Written some documentation and added to the trimes doxygen module Written some documentation and added to the trimes doxygen module
Revision 1.1 2004/03/05 10:59:24 cignoni Revision 1.1 2004/03/05 10:59:24 cignoni
Changed name from plural to singular (normals->normal) Changed name from plural to singular (normals->normal)
Revision 1.1 2004/03/04 00:05:50 cignoni Revision 1.1 2004/03/04 00:05:50 cignoni
First working version! First working version!
Revision 1.1 2004/02/19 13:11:06 cignoni Revision 1.1 2004/02/19 13:11:06 cignoni
Initial commit Initial commit
****************************************************************************/ ****************************************************************************/
#ifndef __VCG_TRI_UPDATE_NORMALS #ifndef __VCG_TRI_UPDATE_NORMALS
#define __VCG_TRI_UPDATE_NORMALS #define __VCG_TRI_UPDATE_NORMALS
#include <vcg/space/triangle3.h> #include <vcg/space/triangle3.h>
#include <vcg/math/matrix33.h> #include <vcg/math/matrix33.h>
namespace vcg { namespace vcg {
namespace tri { namespace tri {
/** \addtogroup trimesh */ /// \ingroup trimesh
/*@{*/
/// \headerfile normal.h vcg/complex/trimesh/update/normal.h
/// 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. /// \brief Management, updating and computation of per-vertex and per-face normals.
template <class ComputeMeshType> /**
class UpdateNormals This class is used to compute or update the normals that can be stored in the vertex or face component of a mesh.
{ */
public: template <class ComputeMeshType>
typedef ComputeMeshType MeshType; class UpdateNormals
typedef typename MeshType::VertexType VertexType; {
typedef typename VertexType::NormalType NormalType; public:
typedef typename VertexType::ScalarType ScalarType; typedef ComputeMeshType MeshType;
typedef typename MeshType::VertexPointer VertexPointer; typedef typename MeshType::VertexType VertexType;
typedef typename MeshType::VertexIterator VertexIterator; typedef typename VertexType::NormalType NormalType;
typedef typename MeshType::FaceType FaceType; typedef typename VertexType::ScalarType ScalarType;
typedef typename MeshType::FacePointer FacePointer; typedef typename MeshType::VertexPointer VertexPointer;
typedef typename MeshType::FaceIterator FaceIterator; typedef typename MeshType::VertexIterator VertexIterator;
typedef typename MeshType::FaceType FaceType;
/// Calculates the face normal (if stored in the current face type) typedef typename MeshType::FacePointer FacePointer;
static void PerFace(ComputeMeshType &m) typedef typename MeshType::FaceIterator FaceIterator;
{
if( !m.HasPerFaceNormal()) return; /// \brief Calculates the face normal (if stored in the current face type)
FaceIterator f;
for(f=m.face.begin();f!=m.face.end();++f) static void PerFace(ComputeMeshType &m)
if( !(*f).IsD() ) face::ComputeNormal(*f); {
} if( !m.HasPerFaceNormal()) return;
FaceIterator f;
/// Calculates the vertex normal. Exploiting or current face normals for(f=m.face.begin();f!=m.face.end();++f)
/// The normal of a vertex v is the weigthed average of the normals of the faces incident on v. if( !(*f).IsD() ) face::ComputeNormal(*f);
static void PerVertexFromCurrentFaceNormal(ComputeMeshType &m) }
{
if( !m.HasPerVertexNormal()) return; /// \brief Calculates the vertex normal. Exploiting or current face normals.
/**
VertexIterator vi; The normal of a vertex v is the weigthed average of the normals of the faces incident on v.
for(vi=m.vert.begin();vi!=m.vert.end();++vi) */
if( !(*vi).IsD() && (*vi).IsRW() ) static void PerVertexFromCurrentFaceNormal(ComputeMeshType &m)
(*vi).N().Construct(0,0,0); {
if( !m.HasPerVertexNormal()) return;
FaceIterator fi;
for(fi=m.face.begin();fi!=m.face.end();++fi) VertexIterator vi;
if( !(*fi).IsD()) for(vi=m.vert.begin();vi!=m.vert.end();++vi)
{ if( !(*vi).IsD() && (*vi).IsRW() )
for(int j=0; j<3; ++j) (*vi).N().Construct(0,0,0);
if( !(*fi).V(j)->IsD())
(*fi).V(j)->N() += (*fi).cN(); FaceIterator fi;
} for(fi=m.face.begin();fi!=m.face.end();++fi)
} if( !(*fi).IsD())
{
for(int j=0; j<3; ++j)
/// Calculates the vertex normal. Without exploiting or touching face normals if( !(*fi).V(j)->IsD())
/// The normal of a vertex v is the weigthed average of the normals of the faces incident on v. (*fi).V(j)->N() += (*fi).cN();
static void PerVertex(ComputeMeshType &m) }
{ }
if( !m.HasPerVertexNormal()) return;
VertexIterator vi; /// \brief Calculates the vertex normal. Without exploiting or touching face normals.
for(vi=m.vert.begin();vi!=m.vert.end();++vi) /**
if( !(*vi).IsD() && (*vi).IsRW() ) The normal of a vertex v is the weigthed average of the normals of the faces incident on v.
(*vi).N() = NormalType((ScalarType)0,(ScalarType)0,(ScalarType)0); */
FaceIterator f; static void PerVertex(ComputeMeshType &m)
{
for(f=m.face.begin();f!=m.face.end();++f) if( !m.HasPerVertexNormal()) return;
if( !(*f).IsD() && (*f).IsR() )
{ VertexIterator vi;
//typename FaceType::NormalType t = (*f).Normal(); for(vi=m.vert.begin();vi!=m.vert.end();++vi)
typename FaceType::NormalType t = vcg::Normal(*f); if( !(*vi).IsD() && (*vi).IsRW() )
(*vi).N() = NormalType((ScalarType)0,(ScalarType)0,(ScalarType)0);
for(int j=0; j<3; ++j)
if( !(*f).V(j)->IsD() && (*f).V(j)->IsRW() ) FaceIterator f;
(*f).V(j)->N() += t;
} for(f=m.face.begin();f!=m.face.end();++f)
} if( !(*f).IsD() && (*f).IsR() )
{
//typename FaceType::NormalType t = (*f).Normal();
/// Calculates both vertex and face normals. typename FaceType::NormalType t = vcg::Normal(*f);
/// The normal of a vertex v is the weigthed average of the normals of the faces incident on v.
static void PerVertexPerFace(ComputeMeshType &m) for(int j=0; j<3; ++j)
{ if( !(*f).V(j)->IsD() && (*f).V(j)->IsRW() )
if( !m.HasPerVertexNormal() || !m.HasPerFaceNormal()) return; (*f).V(j)->N() += t;
}
PerFace(m); }
VertexIterator vi;
for(vi=m.vert.begin();vi!=m.vert.end();++vi)
if( !(*vi).IsD() && (*vi).IsRW() ) /// \brief Calculates both vertex and face normals.
(*vi).N() = NormalType((ScalarType)0,(ScalarType)0,(ScalarType)0); /**
The normal of a vertex v is the weigthed average of the normals of the faces incident on v.
FaceIterator f; */
for(f=m.face.begin();f!=m.face.end();++f) static void PerVertexPerFace(ComputeMeshType &m)
if( !(*f).IsD() && (*f).IsR() ) {
{ if( !m.HasPerVertexNormal() || !m.HasPerFaceNormal()) return;
for(int j=0; j<3; ++j)
if( !(*f).V(j)->IsD() && (*f).V(j)->IsRW() ) PerFace(m);
(*f).V(j)->N() += (*f).cN(); VertexIterator vi;
} for(vi=m.vert.begin();vi!=m.vert.end();++vi)
} if( !(*vi).IsD() && (*vi).IsRW() )
(*vi).N() = NormalType((ScalarType)0,(ScalarType)0,(ScalarType)0);
/// 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. FaceIterator f;
static void PerVertexNormalizedPerFace(ComputeMeshType &m)
{ for(f=m.face.begin();f!=m.face.end();++f)
PerVertexPerFace(m); if( !(*f).IsD() && (*f).IsR() )
NormalizeVertex(m); {
} for(int j=0; j<3; ++j)
if( !(*f).V(j)->IsD() && (*f).V(j)->IsRW() )
/// Normalize the lenght of the face normals (*f).V(j)->N() += (*f).cN();
static void NormalizeVertex(ComputeMeshType &m) }
{ }
VertexIterator vi;
for(vi=m.vert.begin();vi!=m.vert.end();++vi) /// \brief Calculates both vertex and face normals.
if( !(*vi).IsD() && (*vi).IsRW() ) /**
(*vi).N().Normalize(); The normal of a vertex v is the weigthed average of the normals of the faces incident on v.
} */
/// Normalize the lenght of the face normals static void PerVertexNormalizedPerFace(ComputeMeshType &m)
static void NormalizeFace(ComputeMeshType &m) {
{ PerVertexPerFace(m);
FaceIterator fi; NormalizeVertex(m);
for(fi=m.face.begin();fi!=m.face.end();++fi) }
if( !(*fi).IsD() ) (*fi).N().Normalize();
} /// \brief Normalize the lenght of the face normals.
static void NormalizeVertex(ComputeMeshType &m)
static void AreaNormalizeFace(ComputeMeshType &m) {
{ VertexIterator vi;
FaceIterator fi; for(vi=m.vert.begin();vi!=m.vert.end();++vi)
for(fi=m.face.begin();fi!=m.face.end();++fi) if( !(*vi).IsD() && (*vi).IsRW() )
if( !(*fi).IsD() ) (*vi).N().Normalize();
{ }
(*fi).N().Normalize();
(*fi).N() = (*fi).N() * DoubleArea(*fi); /// \brief Normalize the lenght of the face normals.
} static void NormalizeFace(ComputeMeshType &m)
} {
FaceIterator fi;
static void PerVertexNormalizedPerFaceNormalized(ComputeMeshType &m) for(fi=m.face.begin();fi!=m.face.end();++fi)
{ if( !(*fi).IsD() ) (*fi).N().Normalize();
PerVertexNormalizedPerFace(m); }
NormalizeFace(m);
} static void AreaNormalizeFace(ComputeMeshType &m)
{
static void PerFaceRW(ComputeMeshType &m, bool normalize=false) FaceIterator fi;
{ for(fi=m.face.begin();fi!=m.face.end();++fi)
if( !m.HasPerFaceNormal()) return; if( !(*fi).IsD() )
{
FaceIterator f; (*fi).N().Normalize();
bool cn = true; (*fi).N() = (*fi).N() * DoubleArea(*fi);
}
if(normalize) }
{
for(f=m.m.face.begin();f!=m.m.face.end();++f) static void PerVertexNormalizedPerFaceNormalized(ComputeMeshType &m)
if( !(*f).IsD() && (*f).IsRW() ) {
{ PerVertexNormalizedPerFace(m);
for(int j=0; j<3; ++j) NormalizeFace(m);
if( !(*f).V(j)->IsR()) cn = false; }
if( cn ) face::ComputeNormalizedNormal(*f);
cn = true; static void PerFaceRW(ComputeMeshType &m, bool normalize=false)
} {
} if( !m.HasPerFaceNormal()) return;
else
{ FaceIterator f;
for(f=m.m.face.begin();f!=m.m.face.end();++f) bool cn = true;
if( !(*f).IsD() && (*f).IsRW() )
{ if(normalize)
for(int j=0; j<3; ++j) {
if( !(*f).V(j)->IsR()) cn = false; for(f=m.m.face.begin();f!=m.m.face.end();++f)
if( !(*f).IsD() && (*f).IsRW() )
if( cn ) {
(*f).ComputeNormal(); for(int j=0; j<3; ++j)
cn = true; if( !(*f).V(j)->IsR()) cn = false;
} if( cn ) face::ComputeNormalizedNormal(*f);
} cn = true;
} }
}
else
static void PerFaceNormalized(ComputeMeshType &m) {
{ for(f=m.m.face.begin();f!=m.m.face.end();++f)
if( !m.HasPerFaceNormal()) return; if( !(*f).IsD() && (*f).IsRW() )
FaceIterator f; {
for(f=m.face.begin();f!=m.face.end();++f) for(int j=0; j<3; ++j)
if( !(*f).IsD() ) face::ComputeNormalizedNormal(*f); if( !(*f).V(j)->IsR()) cn = false;
}
if( cn )
(*f).ComputeNormal();
/// Calculates the vertex normal cn = true;
static void PerVertexNormalized(ComputeMeshType &m) }
{ }
if( !m.HasPerVertexNormal()) return; }
PerVertex(m);
for(VertexIterator vi=m.vert.begin();vi!=m.vert.end();++vi)
if( !(*vi).IsD() && (*vi).IsRW() ) static void PerFaceNormalized(ComputeMeshType &m)
(*vi).N().Normalize(); {
} if( !m.HasPerFaceNormal()) return;
FaceIterator f;
/// multiply the vertex normals by the matrix passed. By default, the scale component is removed for(f=m.face.begin();f!=m.face.end();++f)
static void PerVertexMatrix(ComputeMeshType &m, const Matrix44<ScalarType> &mat, bool remove_scaling= true){ if( !(*f).IsD() ) face::ComputeNormalizedNormal(*f);
float scale; }
Matrix33<ScalarType> mat33(mat,3);
/// \brief Calculates the vertex normal.
if( !m.HasPerVertexNormal()) return; static void PerVertexNormalized(ComputeMeshType &m)
{
if(remove_scaling){ if( !m.HasPerVertexNormal()) return;
scale = pow(mat33.Determinant(),(ScalarType)(1.0/3.0)); PerVertex(m);
mat33[0][0]/=scale; for(VertexIterator vi=m.vert.begin();vi!=m.vert.end();++vi)
mat33[1][1]/=scale; if( !(*vi).IsD() && (*vi).IsRW() )
mat33[2][2]/=scale; (*vi).N().Normalize();
} }
for(VertexIterator vi=m.vert.begin();vi!=m.vert.end();++vi) /// \brief Multiply the vertex normals by the matrix passed. By default, the scale component is removed.
if( !(*vi).IsD() && (*vi).IsRW() ) static void PerVertexMatrix(ComputeMeshType &m, const Matrix44<ScalarType> &mat, bool remove_scaling= true){
(*vi).N() = mat33*(*vi).N(); float scale;
}
Matrix33<ScalarType> mat33(mat,3);
/// 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){ if( !m.HasPerVertexNormal()) return;
float scale;
if(remove_scaling){
Matrix33<ScalarType> mat33(mat,3); scale = pow(mat33.Determinant(),(ScalarType)(1.0/3.0));
mat33[0][0]/=scale;
if( !m.HasPerFaceNormal()) return; mat33[1][1]/=scale;
mat33[2][2]/=scale;
if(remove_scaling){ }
scale = pow(mat33.Determinant(),ScalarType(1.0/3.0));
mat33[0][0]/=scale; for(VertexIterator vi=m.vert.begin();vi!=m.vert.end();++vi)
mat33[1][1]/=scale; if( !(*vi).IsD() && (*vi).IsRW() )
mat33[2][2]/=scale; (*vi).N() = mat33*(*vi).N();
} }
for(FaceIterator fi=m.face.begin();fi!=m.face.end();++fi) /// \brief Multiply the face normals by the matrix passed. By default, the scale component is removed.
if( !(*fi).IsD() && (*fi).IsRW() ) static void PerFaceMatrix(ComputeMeshType &m, const Matrix44<ScalarType> &mat, bool remove_scaling= true){
(*fi).N() = mat33* (*fi).N(); float scale;
}
Matrix33<ScalarType> mat33(mat,3);
}; // end class
if( !m.HasPerFaceNormal()) return;
} // End namespace
} // End namespace if(remove_scaling){
scale = pow(mat33.Determinant(),ScalarType(1.0/3.0));
mat33[0][0]/=scale;
#endif mat33[1][1]/=scale;
mat33[2][2]/=scale;
}
for(FaceIterator fi=m.face.begin();fi!=m.face.end();++fi)
if( !(*fi).IsD() && (*fi).IsRW() )
(*fi).N() = mat33* (*fi).N();
}
}; // end class
} // End namespace
} // End namespace
#endif

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;

24
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
This class is templated over the mesh and (like all other Update* classes) has only static members; Typical usage:
/// \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:
\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
{ {