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 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>
class UpdateBounding
{
@ -69,8 +73,8 @@ typedef typename MeshType::VertexType VertexType;
typedef typename MeshType::VertexPointer VertexPointer;
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)
{
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 tri {
/** \addtogroup 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 .
/// \ingroup trimesh
/// \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>
class UpdateColor
@ -85,16 +90,18 @@ typedef typename UpdateMeshType::FaceType FaceType;
typedef typename UpdateMeshType::FacePointer FacePointer;
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.
So it just require that you have correctly computed the flags;
vcg::tri::UpdateTopology<Mesh>::FaceFace(m.cm);
vcg::tri::UpdateFlags<Mesh>::FaceBorderFromFF(m.cm);
vcg::tri::UpdateFlags<Mesh>::VertexBorderFromFace (m.cm);
vcg::tri::UpdateColor<Mesh>::VertexBorderFlag(m.cm);
- vcg::tri::UpdateTopology<Mesh>::FaceFace(m.cm);
- vcg::tri::UpdateFlags<Mesh>::FaceBorderFromFF(m.cm);
- vcg::tri::UpdateFlags<Mesh>::VertexBorderFromFace (m.cm);
- vcg::tri::UpdateColor<Mesh>::VertexBorderFlag(m.cm);
**/
*/
static void VertexBorderFlag( UpdateMeshType &m, Color4b BorderColor=Color4b::Blue, Color4b InternalColor=Color4b::White)
{
typename UpdateMeshType::VertexIterator vi;
@ -278,7 +285,7 @@ static void VertexQuality(UpdateMeshType &m)
}
};
/*@}*/
}// end namespace
}// end namespace
#endif

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

@ -66,11 +66,15 @@ the vertex
namespace vcg {
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>
class UpdateCurvature
{
@ -95,17 +99,10 @@ private:
bool isBorder;
};
public:
/*
Compute principal direction and magniuto of curvature as describe in the paper:
@InProceedings{bb33922,
author = "G. Taubin",
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",
/// \brief Compute principal direction and magniuto of curvature.
/**
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>
*/
static void PrincipalDirections(MeshType &m) {
@ -284,9 +281,12 @@ public:
};
/** computes the discrete gaussian curvature as proposed in
Discrete Differential-Geometry Operators for Triangulated 2-Manifolds Mark Meyer,
Mathieu Desbrun, Peter Schroder, Alan H. Barr VisMath '02, Berlin
/// \brief Computes the discrete gaussian curvature.
/** 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)
{
@ -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
* 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
* based on the paper
* "optimizing 3d triangulations using discrete curvature analysis"
* http://www2.in.tu-clausthal.de/~hormann/papers/Dyn.2001.OTU.pdf
* */
/// \brief Update the mean and the gaussian curvature of a vertex.
/**
The function uses the VF adiacency to walk around the vertex.
\return It will return the voronoi area around the vertex. If (norm == true) the mean and the gaussian curvature are normalized.
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>
*/
static float VertexCurvature(VertexPointer v, bool norm = true)
{
// VFAdjacency required!

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

@ -45,10 +45,11 @@ created
namespace vcg {
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>
class UpdateEdges
{

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

@ -93,10 +93,15 @@ First working version!
namespace vcg {
namespace tri {
/** \addtogroup trimesh */
/*@{*/
/// 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).
/// \ingroup trimesh
/// \headerfile flag.h vcg/complex/trimesh/update/flag.h
/// \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>
class UpdateFlags
@ -112,8 +117,8 @@ typedef typename MeshType::FaceType FaceType;
typedef typename MeshType::FacePointer FacePointer;
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)
{
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);}
/** 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 )
**/
/// \brief Compute the border flags for the faces using the Face-Face Topology.
/**
\warning Obviously it assumes that the topology has been correctly computed (see: UpdateTopology::FaceFace )
*/
static void FaceBorderFromFF(MeshType &m)
{
assert(HasPerFaceFlags(m));
@ -358,7 +365,6 @@ static void VertexBorderFromFace(MeshType &m)
}; // end class
/*@}*/
} // End namespace tri
} // End namespace vcg

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

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

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

@ -59,15 +59,19 @@ First working version!
namespace vcg {
namespace tri {
/** \addtogroup trimesh */
/*@{*/
/** Generation of per-vertex and per-face Qualities 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:
/// \ingroup trimesh
/// \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:
\code
MyMeshType m;
UpdateQuality<MyMeshType>::VertexGeodesicFromBorder(m);
\endcode
**/
*/
template <class UpdateMeshType>
class UpdateQuality
@ -118,10 +122,14 @@ public:
// 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.
/** 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.
/// \brief Compute, for each vertex of the mesh the geodesic distance from the border of the mesh itself.
/**
It uses the classical Dijkstra Shortest Path Tree algorithm.
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
{

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

@ -40,11 +40,15 @@ First Working Version
namespace vcg {
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>
class UpdateSelection
{
@ -58,7 +62,6 @@ typedef typename MeshType::FaceType FaceType;
typedef typename MeshType::FacePointer FacePointer;
typedef typename MeshType::FaceIterator FaceIterator;
///
static size_t AllVertex(MeshType &m)
{
VertexIterator vi;
@ -147,7 +150,7 @@ static size_t InvertVertex(MeshType &m)
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)
{
size_t selCnt=0;
@ -163,10 +166,10 @@ static size_t VertexFromFaceLoose(MeshType &m)
return selCnt;
}
// 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.
// Ambiguity in the def: isolated vertices should be selected? NO.
//
/// \brief Select ONLY the vertices that are touched ONLY by selected faces
/** In other words all the vertices having all the faces incident on them selected.
\warning Isolated vertices will not selected.
*/
static size_t VertexFromFaceStrict(MeshType &m)
{
size_t selCnt=0;
@ -182,7 +185,7 @@ static size_t VertexFromFaceStrict(MeshType &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)
{
size_t selCnt=0;
@ -233,8 +236,7 @@ static size_t FaceFromBorder(MeshType &m)
}
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)
{
size_t selCnt=0;

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

@ -34,10 +34,11 @@ $Log: position.h,v $
namespace vcg {
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>
class UpdateTexture
{