diff --git a/vcg/complex/tetramesh/base.h b/vcg/complex/tetramesh/base.h new file mode 100644 index 00000000..11548984 --- /dev/null +++ b/vcg/complex/tetramesh/base.h @@ -0,0 +1,248 @@ +/**************************************************************************** +* 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.1 2004/04/15 08:54:20 pietroni +*** empty log message *** + + +***************************************************************************/ + + +#pragma warning( disable : 4804 ) +#pragma once + +#ifndef __VCG_TETRAMESH +#define __VCG_TETRAMESH +#include + + +namespace vcg { +namespace tetra { + /** \addtogroup trimesh */ +/*@{*/ + + /** Class TetraMesh. + This is class for definition of a mesh. + @param STL_VERT_CONT (Template Parameter) Specifies the type of the vertices container any the vertex type. + @param STL_FACE_CONT (Template Parameter) Specifies the type of the faces container any the face type. + */ + + +template < class STL_VERT_CONT ,class STL_TETRA_CONT > +class Tetramesh{ + public: + +/***********************************************/ +/** @name Tetramesh Type Definitions **/ +//@{ + + /// The mesh type + typedef Tetramesh TetraMeshType; + + /// The vertex container + typedef STL_VERT_CONT VertexContainer; + + /// The tethaedhron container + typedef STL_TETRA_CONT TetraContainer; + + /// The vertex type + typedef typename STL_VERT_CONT::value_type VertexType; + + /// The tetrahedron type + typedef typename STL_TETRA_CONT::value_type TetraType; + + /// The type of vertex iterator + typedef typename STL_VERT_CONT::iterator VertexIterator; + + /// The type of tetra iterator + typedef typename STL_TETRA_CONT::iterator TetraIterator; + + /// The type of constant vertex iterator + typedef typename STL_VERT_CONT::const_iterator const_VertexIterator; + + /// The type of constant face iterator + typedef typename STL_TETRA_CONT::const_iterator const_TetraIterator; + + /// The vertex pointer type + typedef VertexType * VertexPointer; + + /// The tetra pointer type + typedef VertexType * TetraPointer; + + /// The type of the constant vertex pointer + typedef const VertexType * const_VertexPointer; + + /// The type of the constant tetrahedron pointer + typedef const VertexType * const_TetraPointer; + + typedef typename VertexType::ScalarType ScalarType; +//@} + +/***********************************************/ +/** @Common Attributes of a tetrahedral mesh **/ +//@{ + + ///temporary mark for decimation + int IMark; + + /// Set of vertices + STL_VERT_CONT vert; + + /// Real number of vertices + int vn; + + /// Set of tetrahedron + STL_TETRA_CONT tetra; + + /// Real number of tetrahedron + int tn; + + /// Real number of edges + int en; + + ///Boundingbox della mesh + Box3 bbox; +//@} + +/***********************************************/ +/** @Default Functions **/ +//@{ + + /// Default constructor + Tetramesh() + { + tn = vn = en = 0; + } + + Tetramesh(VertexContainer v,TetraContainer t) + { + this->vert=v; + this->tetra=t; + vn=v.size(); + tn=t.size(); + } + + inline int MemUsed() const + { + return sizeof(TMTYPE)+sizeof(VertexType)*vert.size()+sizeof(tetrahedron)*tetra.size()+sizeof(edge)*edges.size(); + } +//@} + +/***********************************************/ +/** @Functions used to retrieve vertex informations**/ +//@{ + static bool HasPerVertexNormal() { return bool(VertexType::OBJ_TYPE & (VertexType::OBJ_TYPE_N)); } + static bool HasPerVertexColor() { return bool(VertexType::OBJ_TYPE & (VertexType::OBJ_TYPE_C)); } + static bool HasPerVertexMark() { return bool(VertexType::OBJ_TYPE & (VertexType::OBJ_TYPE_M)); } + static bool HasPerVertexQuality() { return bool(VertexType::OBJ_TYPE & (VertexType::OBJ_TYPE_Q)); } + static bool HasPerVertexTexture() { return bool(VertexType::OBJ_TYPE & (VertexType::OBJ_TYPE_T)); } +//@} + +/***********************************************/ +/** @Functions used for handle the temporany mark of a tetrahedron used in decimation**/ +//@{ + +///Increase the current mark. + void UnMarkAll() + { + ++IMark; + } + +///Mark the vertex with current value + void Mark(VertexType *v) + { + v->IMark()=IMark; + } + +///Initialize the mark of all vertices + void InitIMark() + { + VertexIterator vi; + IMark=0; + for(vi=vert.begin();vi!=vert.end();vi++) + { + (*vi).InitIMark(); + } + } + +//@} + + +void LoadTs(char * filename, double meshscale ) +{ + int nvertex; + int ntetra; + float x; + float y; + float z; + int tp0; + int tp1; + int tp2; + int tp3; + float mass; + FILE *f; + Tetramesh::VertexType p1; + f = fopen(filename,"r"); + if(f == NULL ) + printf( "The file was not opened\n" ); + else + { + fscanf(f, "%i", &nvertex ); + fscanf(f, "%i", &ntetra ); + int j; + for (j=0;j +using namespace std; +namespace vcg { +namespace tetra { +/** \addtogroup tetramesh */ +/*@{*/ + + /** Class Allocate. + This is class for Allocate new vertices or tetrahedron on the mesh. + @param STL_VERT_CONT (Template Parameter) Specifies the type of the vertices container any the vertex type. + @param STL_TETRA_CONT (Template Parameter) Specifies the type of the tetrahedrons container any the tetrahedrons type. + */ +template < class STL_VERT_CONT ,class STL_TETRA_CONT > +class Allocate +{ + +public: + + /// The vertex container + typedef STL_VERT_CONT VertexContainer; + + /// The tethaedhron container + typedef STL_TETRA_CONT TetraContainer; + + /// The vertex type + typedef typename STL_VERT_CONT::value_type VertexType; + + /// The tetrahedron type + typedef typename STL_TETRA_CONT::value_type TetraType; + + /// The type of vertex iterator + typedef typename STL_VERT_CONT::iterator VertexIterator; + + /// The type of tetra iterator + typedef typename STL_TETRA_CONT::iterator TetraIterator; + + /// The type of constant vertex iterator + typedef typename STL_VERT_CONT::const_iterator const_VertexIterator; + + /// The type of constant face iterator + typedef typename STL_TETRA_CONT::const_iterator const_TetraIterator; + +private: + VertexContainer* _vert; + TetraContainer* _tetra; + +public: + ///defaul constructor + Allocate(VertexContainer *v,TetraContainer *t) + { + _vert=v; + _tetra=t; + } + + /** Function to add n vertices to the mesh. The second parameter hold a vector of +pointers to pointer to elements of the mesh that should be updated after a +possible vector realloc. +@param n Il numero di vertici che si vuole aggiungere alla mesh. +@param local_var Vettore di variabili locali che rappresentano puntatori a vertici. +restituisce l'iteratore al primo elemento aggiunto. +*/ + +VertexIterator AddVertices(int n, vector &local_var) +{ + VertexIterator oldbegin, newbegin; + oldbegin = _vert->begin(); + VertexIterator last=_vert->end(); + if(_vert->empty()) last=0; // if the vector is empty we cannot find the last valid element + else --last; + unsigned int siz=0; +#ifdef __STL_CONFIG_H +if(last!=0) distance(_vert->begin(),last,siz); +#else +if(last!=0) siz=distance(_vert->begin(),last); +#endif + for(unsigned int i=0; ipush_back(VertexType()); + _vert->back().Supervisor_Flags() = 0; + } + vn+=n; + newbegin = _vert->begin(); + if(newbegin != oldbegin) + { + TetraIterator f; + for (f=_tetra->begin(); f!=_tetra->end(); ++f) + if(!(*f).IsD()) + for(unsigned int k=0; k<4; ++k) + (*f).V(k)= (*f).V(k)-&*oldbegin+&*newbegin; + for(unsigned int j=0; jbegin(); + advance(last,siz+1); + } + else last=_vert->begin(); + } + else + { + // se non e'cambiato lo spazio (vector abbastanza grande o lista) + if(last==0) last = _vert->begin(); // se il vettore era vuoto si restituisce begin + else advance(last,1); // altrimenti il primo dopo quello che era in precedenza l'ultimo valido. + } + return last; +} + +}; // end class + + +/*@}*/ +} // End namespace +} // End namespace + + +#endif diff --git a/vcg/complex/tetramesh/update/topology.h b/vcg/complex/tetramesh/update/topology.h new file mode 100644 index 00000000..c6d3772b --- /dev/null +++ b/vcg/complex/tetramesh/update/topology.h @@ -0,0 +1,449 @@ +/**************************************************************************** +* 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 + +Revision 1.1 2004/16/04 14:32 pietroni +Initial commit + + +****************************************************************************/ +#ifndef __VCG_TETRA_UPDATE_TOPOLOGY +#define __VCG_TETRA_UPDATE_TOPOLOGY +#include + +namespace vcg { +namespace tetra { +/** Class Facet. + This is class for definition of a face of tethahedron + @param STL_VERT_CONT (Template Parameter) Specifies the type of the vertices container any the vertex type. + */ + + +template < class VERT_TYPE , class TETRA_TYPE> +class Facet{ + +public: + + /// The vertex type + typedef VERT_TYPE MVTYPE; + typedef TETRA_TYPE MTTYPE; + + +private: + MTTYPE *Tr; + int numface; + MVTYPE * vertex[3]; + +public: + + Facet(MVTYPE *v0,MVTYPE *v1,MVTYPE *v2,TETRA_TYPE * t,int index) + { + vertex[0]=v0; + vertex[1]=v1; + vertex[2]=v2; + sort(vertex,vertex+3); + Tr = t; + numface = index; + } + + inline const MVTYPE * V(int index) const + { + return vertex[index]; + } + + TETRA_TYPE *getTetrahedron() + { + return Tr; + } + + void setTetrahedron(TETRA_TYPE * t) + { + Tr=t; + } + + inline bool operator == ( Facet const & f) const + { + return ((vertex[0]==f.V(0))&&(vertex[1]==f.V(1))&&(vertex[2]==f.V(2))); + } + + inline bool operator != ( Facet const & f) const + { + return !((*this) == f); + } + + inline bool operator > ( Facet const & f) const + { + + if (vertex[0]!=f.V(0)) + { + if (vertex[0]>f.V(0)) + return true; + else + return false; + } + else + if (vertex[1]!=f.V(1)) + { + if (vertex[1]>f.V(1)) + return true; + else + return false; + } + else + if (vertex[2]!=f.V(2)) + { + if (vertex[2]>f.V(2)) + return true; + else + return false; + }else + return false; + + } + + inline bool operator < ( Facet const & f) const + { + return !(((*this)>f)&&((*this)!=f)); + } + + inline bool operator <= ( Facet const & f) const + { + return (((*this)= ( Facet const & f) const + { + return (((*this)>f)||((*this)==f)); + } + + int getFaceIndex()const + { + return numface; + } + +};//end class +/** \addtogroup tetramesh */ +/*@{*/ + + /** Class UpdateTopology. + This is class for Topology of a tetrahedralmesh. + @param STL_VERT_CONT (Template Parameter) Specifies the type of the vertices container any the vertex type. + @param STL_TETRA_CONT (Template Parameter) Specifies the type of the tetrahedrons container any the tetrahedrons type. + */ +template < class STL_VERT_CONT ,class STL_TETRA_CONT > +class UpdateTopology +{ + +public: + + /// The vertex container + typedef STL_VERT_CONT VertexContainer; + + /// The tethaedhron container + typedef STL_TETRA_CONT TetraContainer; + + /// The vertex type + typedef typename STL_VERT_CONT::value_type VertexType; + + /// The tetrahedron type + typedef typename STL_TETRA_CONT::value_type TetraType; + + /// The type of vertex iterator + typedef typename STL_VERT_CONT::iterator VertexIterator; + + /// The type of tetra iterator + typedef typename STL_TETRA_CONT::iterator TetraIterator; + + /// The type of constant vertex iterator + typedef typename STL_VERT_CONT::const_iterator const_VertexIterator; + + /// The type of constant face iterator + typedef typename STL_TETRA_CONT::const_iterator const_TetraIterator; + +private: + VertexContainer* _vert; + TetraContainer* _tetra; + +public: + ///defaul constructor + UpdateTopology(VertexContainer *v,TetraContainer *t) + { + _vert=v; + _tetra=t; + } +/***********************************************/ +/** @Vertex-Tetrahedron Topology Funtions +**/ +//@{ + + ///create the VT topology for tetrahedrons that are into containers +void VTTopology() + { + vertex_iterator v; + tetra_iterator t; + + ClearVTTopology(); + + for(t=_tetra.begin();t!=_tetra.end();++t) + if( ! (*t).IsD()) + for(int j=0;j<4;++j) + { + (*t).tv[j] = (*t).V(j)->Fp(); + (*t).zv[j] = (*t).V(j)->Zp(); + (*t).V(j)->Fp() = &(*t); + (*t).V(j)->Zp() = j; + } + + } + + /// clear the Vertex-Tetra topology + void ClearVTTopology() + { + vertex_iterator v; + for(v=_vert->begin();v!=_vert->end();++v) + { + v->Fp() = 0; + v->Zp() = 0; + } + + tetra_iterator t; + for(t=_tetra->begin();t!=_tetra->end();++t) + for(int j=0;j<4;++j) + { + (*t).TV(j) = 0; + (*t).ZV(j) = 0; + } +} + +///erase one tetrahedron from VTTopology of all his vertices + +void DetachVTTopology(TetraType *t) + { + int i; + for(i=0;i<4;i++) + DetachVTTopology(t->V(i),t); + } + +///erase one tetrahedron from VTTopology of one specified vertex +void DetachVTTopology(VertexType *v,TetraType *t) + { + TetraType *lastt; + int lastz; + EdgePosT Et(v->Fp(),v->Zp()); + if (Et.t==t) + { + v->Fp()=(TetraType *)t->tv[v->Zp()]; + v->Zp()=t->zv[v->Zp()]; + } + else + { + lastz=Et.z; + while((Et.t!=t)&&(Et.t!=NULL)) + { + lastz=Et.z; + lastt=Et.t; + Et.NextT(); + } + //in the list of the vertex v must be present the + //tetrahedron that you want to detach + assert(Et.t!=NULL); + lastt->tv[lastz]=Et.t->tv[Et.z]; + lastt->zv[lastz]=Et.t->zv[Et.z]; + } + } + +///insert the tetrahedron t in VT topology for vertex v of index z +void InsertVTTopology(VertexType *v,int z,TetraType *t) + { + if( ! (*t).IsD()) + { + (*t).tv[z] = v->Fp(); + (*t).zv[z] = v->Zp(); + v->Fp() = &(*t); + v->Zp() = z; + } +} + + +///insert the tetrahedron t in VT topology for all his vertices +void InsertVTTopology(TetraType *t) + { + assert(!t->IsD()); + int k=0; + for (k=0;k<4;k++) + { + assert(!t->V(k)->IsD()); + InsertVTTopology(t->V(k),k,t); + } +} +/*@}*/ +/***********************************************/ +/** @Tetrahedron-Tetrahedron Topology Funtions +**/ +//@{ +///Build the Tetrahedron-Tetrahedron Topology (by Face) +void TTTopology() + { + vector > VF; + VertexType* v0; + VertexType* v1; + VertexType* v2; + + for (TetraIterator ti=_tetra->begin();ti!=_tetra->end();ti++) + { + if (!(*ti).IsD()) + { + (*ti).Z(0)=0; + (*ti).Z(1)=1; + (*ti).Z(2)=2; + (*ti).Z(3)=3; + (*ti).T(0)=(&(*ti)); + (*ti).T(1)=(&(*ti)); + (*ti).T(2)=(&(*ti)); + (*ti).T(3)=(&(*ti)); + + v0=(*ti).V(Tetra4::VofF(0,0)); + v1=(*ti).V(Tetra4::VofF(0,1)); + v2=(*ti).V(Tetra4::VofF(0,2)); + + VF.push_back(Facet(v0,v1,v2,&(*ti),0)); + + v0=(*ti).V(Tetra4::VofF(1,0)); + v1=(*ti).V(Tetra4::VofF(1,1)); + v2=(*ti).V(Tetra4::VofF(1,2)); + + VF.push_back(Facet(v0,v1,v2,&(*ti),1)); + + v0=(*ti).V(Tetra4::VofF(2,0)); + v1=(*ti).V(Tetra4::VofF(2,1)); + v2=(*ti).V(Tetra4::VofF(2,2)); + + VF.push_back(Facet(v0,v1,v2,&(*ti),2)); + + v0=(*ti).V(Tetra4::VofF(3,0)); + v1=(*ti).V(Tetra4::VofF(3,1)); + v2=(*ti).V(Tetra4::VofF(3,2)); + + VF.push_back(Facet(v0,v1,v2,&(*ti),3)); + } + } + sort(VF.begin(),VF.end()); + + TetraType *t0; + TetraType *t1; + int faceindex0; + int faceindex1; + int j; + unsigned int i; + for (i=0;iT(faceindex0)=(t1); + t1->T(faceindex1)=(t0); + t0->Z(faceindex0)=(faceindex1); + t1->Z(faceindex1)=(faceindex0); + i++; + } + + } + } + +///Test the Tetrahedron-Tetrahedron Topology (by Face) +void TestTTTopology() + { + int i; + for (TetraIterator ti=_tetra->begin();ti!=_tetra->end();ti++) + { + for (i=0;i<4;i++) + { + if ((!(*ti).IsD())&& ((*ti).T(i)!=&(*ti))) + { + assert( ((((*ti).T(i))->T((*ti).Z(i)))==&(*ti))); + + VertexType *v0=(*ti).V(Tetra4::VofF(i,0)); + VertexType *v1=(*ti).V(Tetra4::VofF(i,1)); + VertexType *v2=(*ti).V(Tetra4::VofF(i,2)); + + TetraType *t1=(TetraType*)(*ti).T(i); + int z1=(*ti).Z(i); + + VertexType *vo0=(*ti).V(Tetra4::VofF(z1,0)); + VertexType *vo1=(*ti).V(Tetra4::VofF(z1,1)); + VertexType *vo2=(*ti).V(Tetra4::VofF(z1,2)); + + assert((v0!=v1)&&(v0!=v2)&&(v1!=v2)); + assert((vo0!=vo1)&&(vo0!=vo2)&&(vo1!=vo2)); + + assert ((v0==vo0)||(v0==vo1)||(v0==vo2)); + assert ((v1==vo0)||(v1==vo1)||(v1==vo2)); + assert ((v2==vo0)||(v2==vo1)||(v2==vo2)); + } + } + } + + } + +void setExternalVertices() + { + + TetraIterator tt; + int i; + for (tt=_tetra.begin();tt<_tetra.end();++tt) + { + + for(i=0;i<4;i++) + { + if ((*tt).IsBorderF(i)) + { + (*tt).FV(i,0)->SetB(); + (*tt).FV(i,1)->SetB(); + (*tt).FV(i,2)->SetB(); + } + else + { + (*tt).FV(i,0)->SetB(); + (*tt).FV(i,1)->SetB(); + (*tt).FV(i,2)->SetB(); + } + } + + } + } + +/*@}*/ +}; // end class + + +/*@}*/ +} // End namespace +} // End namespace + + +#endif diff --git a/vcg/simplex/tetrahedron/base.h b/vcg/simplex/tetrahedron/base.h index caad1e29..3e82f7d2 100644 --- a/vcg/simplex/tetrahedron/base.h +++ b/vcg/simplex/tetrahedron/base.h @@ -24,13 +24,16 @@ History $Log: not supported by cvs2svn $ +Revision 1.1 2004/04/15 08:54:20 pietroni +*** empty log message *** + ****************************************************************************/ #ifndef TETRA_TYPE #pragma message("\nYou should never directly include this file\_n") #else -#define TETRA_TYPE +#define NULL 0 #include #include @@ -72,7 +75,7 @@ vcg::TetrahedronFull::SetUserBit() vcg::TetrahedronFull::ClearUserBit() and vcg: /// This are the flags of tetrahedron, the default value is 0 int _flags; -enum { + enum { DELETED = 0x00000001, // deleted tetrahedron flag SELECTED = 0x00000002, // Selection flag BORDERF0 = 0x00000004, // Border flag, Face 0 @@ -133,10 +136,7 @@ void SetS() {_flags |=SELECTED;} /// This function mark the tetrahedron as not selected. void ClearS() {_flags &=~SELECTED;} /// This function return true if one face is extern. -bool HaveBorderF() -{ - {return ((_flags & (BORDERF0 | BORDERF1 | BORDERF2 | BORDERF3)) != 0);} -{ +bool HaveBorderF() {return ((_flags & (BORDERF0 | BORDERF1 | BORDERF2 | BORDERF3)) != 0);} /// This function return true if the face is extern. bool IsBorderF(int face) { assert ((face<4)&&(face>-1)); @@ -167,12 +167,12 @@ protected: VertexType *_v[4]; public: /// The Functions to access a vertex - inline MVTYPE * &V(int index) + inline VertexType * &V(int index) { return _v[index]; } /// The Functions to access a vertex - inline const MVTYPE * &V(int index) const + inline const VertexType * &V(int index) const { return _v[index]; } @@ -197,12 +197,12 @@ public: ///Function to access the Tetrahedron that share the index-face (extern face returns a pointer to himself) TETRA_TYPE *&T(const int &index) { - return t[index]; + return _t[index]; } ///Function to see the index of the face as seen from the other tetrahedron (extern face returns -1) int &Z(const int &index) { - return z[index]; + return _z[index]; } #endif @@ -237,7 +237,7 @@ public: _flags=0; } ///initialize default parameters of tetrahedron - virtual void Init(MVTYPE * p0,MVTYPE * p1,MVTYPE * p2,MVTYPE * p3) + virtual void Init(VertexType * p0,VertexType * p1,VertexType * p2,VertexType * p3) { _flags = 0; _v[0]=p0; @@ -249,12 +249,12 @@ public: swap(_v[1],_v[2]); #ifdef __VCGLIB_TETRA_A - z[0]=z[1]=z[2]=z[3]=-1; - t[0]=t[1]=t[2]=t[3]=NULL; + _z[0]=_z[1]=_z[2]=_z[3]=-1; + _t[0]=_t[1]=_t[2]=_t[3]=NULL; #endif #ifdef __VCGLIB_TETRA_V - zv[0]=zv[1]=zv[2]=zv[3]=-1; - tv[0]=tv[1]=tv[2]=tv[3]=NULL; + _zv[0]=_zv[1]=_zv[2]=_zv[3]=-1; + _tv[0]=_tv[1]=_tv[2]=_tv[3]=NULL; #endif } ///set border vertices using TT-topology @@ -278,16 +278,21 @@ public: //@{ #ifdef __VCGLIB_TETRA_Q - scalar_type _volume; - scalar_type _aspect_ratio; + ScalarType _volume; + ScalarType _aspect_ratio; #endif -#ifdef __VCGLIB_TETRA_Q - scalar_type ComputeVolume(){ - Tetra4 T(V(0)->cP(),V(1)->cP(),V(2)->cP(),V(3)->cP()); + + ScalarType ComputeVolume(){ + Tetra4 T(V(0)->cP(),V(1)->cP(),V(2)->cP(),V(3)->cP()); + #ifdef __VCGLIB_TETRA_Q _volume = T.ComputeVolume(); + return _volume; + #else + return (T.ComputeVolume()); + #endif } -#endif + ///return the volume of the tetrahedron const double & Volume(){ @@ -307,123 +312,6 @@ public: } //@} -/***********************************************/ -/** @Tatrahedron Functions to retrieve information about relation between faces of tetrahedron -(faces,adges,vertices).**/ -//@{ - - MVTYPE *FV(const int &indexF,const int &indexV) - { int facevert[4][3]={{0,1,2}, - {0,3,1}, - {0,2,3}, - {1,3,2}}; - assert ((indexF<4)&&(indexV<3)); - return _v[facevert[indexF][indexV]]; - } - - int iFV(const int &indexF,const int &indexV) - { int facevert[4][3]={{0,1,2}, - {0,3,1}, - {0,2,3}, - {1,3,2}}; - - assert ((indexF<4)&&(indexV<3)); - return facevert[indexF][indexV]; - } - - int VF(const int &indexV,const int &indexF) - { int vertface[4][3]={{0,1,2}, - {0,3,1}, - {0,2,3}, - {1,3,2}}; - - assert ((indexV<4)&&(indexF<3)); - return vertface[indexV][indexF]; - } - - int FVE(const int &indexF,const int &indexV) - { - - int facevertedge[4][4]={{1,0,3,-1}, - {2,0,-1,4}, - {-1,3,5,4}, - {1,-1,5,2} - }; - assert ((indexF<4)&&(indexV<4)); - return facevertedge[indexF][indexV]; - } - - inline MVTYPE * VE(const int &indexE,const int &indexV) - { int edgevert[6][2]={{0,1}, - {0,2}, - {0,3}, - {1,2}, - {1,3}, - {2,3}}; - assert ((indexE<6)&&(indexV<2)); - return _v[edgevert[indexE][indexV]]; - } -// Tetrahedron Vertex (Couple) To Edge Conversion Function - inline int VEC(const int &indexV1,const int &indexV2) - { int ve[4][4]={{-1, 0, 1, 2}, - { 0, -1, 3, 4}, - { 1, 3, -1, 5}, - { 2, 4, 5, -1}}; - - assert ((indexV1<4)&&(indexV2<4)); - return ve[indexV1][indexV2]; - } - - inline int EV(const int &indexV,const int &indexE) - { - int vertedge[4][3]={{0,1,2}, - {0,3,4}, - {5,1,3}, - {4,5,2}}; - assert ((indexE<3)&&(indexV<4)); - return vertedge[indexV][indexE]; - } - - inline int iVE(const int &indexE,const int &indexV) - { int edgevert[6][2]={{0,1}, - {0,2}, - {0,3}, - {1,2}, - {1,3}, - {2,3}}; - assert ((indexE<6)&&(indexV<2)); - return edgevert[indexE][indexV]; - } - - inline int FE(const int &indexE,const int &indexSide) - { int edgeface[6][2]={{0,1}, - {0,2}, - {1,2}, - {0,3}, - {1,3}, - {2,3}}; - - assert ((indexE<6)&&(indexSide<2)); - return edgeface [indexE][indexSide]; - } - - inline int EF(const int &indexF,const int &faceindexEdge) - { int faceedge[4][3]={{0,3,1}, - {2,4,0}, - {1,5,2}, - {4,5,3} - }; - - assert ((indexF<4)&&(faceindexEdge<3)); - return faceedge [indexF][faceindexEdge]; - } - -//@} - - - - - };//end class diff --git a/vcg/simplex/tetrahedron/with/a.h b/vcg/simplex/tetrahedron/with/a.h new file mode 100644 index 00000000..c69ce645 --- /dev/null +++ b/vcg/simplex/tetrahedron/with/a.h @@ -0,0 +1,14 @@ +#ifndef __VCGLIB_TETRA_A_TYPE +#define __VCGLIB_TETRA_A_TYPE + +#define TETRA_TYPE TetraA + +#define __VCGLIB_TETRA_A + +#include + +#undef TETRA_TYPE + +#undef __VCGLIB_TETRA_A + +#endif diff --git a/vcg/simplex/tetrahedron/with/av.h b/vcg/simplex/tetrahedron/with/av.h new file mode 100644 index 00000000..ad6d4bbb --- /dev/null +++ b/vcg/simplex/tetrahedron/with/av.h @@ -0,0 +1,15 @@ +#ifndef __VCGLIB_TETRA_AV_TYPE +#define __VCGLIB_TETRA_AV_TYPE + +#define TETRA_TYPE TetraAV + +#define __VCGLIB_TETRA_A +#define __VCGLIB_TETRA_V +#include + +#undef TETRA_TYPE + +#undef __VCGLIB_TETRA_A +#undef __VCGLIB_TETRA_V + +#endif diff --git a/vcg/simplex/tetrahedron/with/avq.h b/vcg/simplex/tetrahedron/with/avq.h new file mode 100644 index 00000000..df060b35 --- /dev/null +++ b/vcg/simplex/tetrahedron/with/avq.h @@ -0,0 +1,17 @@ +#ifndef __VCGLIB_TETRA_AVQ_TYPE +#define __VCGLIB_TETRA_AVQ_TYPE + +#define TETRA_TYPE TetraAVQ + +#define __VCGLIB_TETRA_A +#define __VCGLIB_TETRA_V +#define __VCGLIB_TETRA_Q +#include + +#undef TETRA_TYPE + +#undef __VCGLIB_TETRA_A +#undef __VCGLIB_TETRA_V +#undef __VCGLIB_TETRA_Q + +#endif diff --git a/vcg/simplex/tetrahedron/with/q.h b/vcg/simplex/tetrahedron/with/q.h new file mode 100644 index 00000000..e92eb14b --- /dev/null +++ b/vcg/simplex/tetrahedron/with/q.h @@ -0,0 +1,14 @@ +#ifndef __VCGLIB_TETRA_Q_TYPE +#define __VCGLIB_TETRA_Q_TYPE + +#define TETRA_TYPE TetraQ + +#define __VCGLIB_TETRA_Q + +#include + +#undef TETRA_TYPE + +#undef __VCGLIB_TETRA_Q + +#endif