manolas
/
vcglib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
vcglib/vcg/complex/tetramesh/update/topology.h

441 lines
10 KiB
C++
Raw Blame History

/****************************************************************************
* 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 <algorithm>
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)<f)||((*this)==f));
}
inline bool operator >= ( 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 UpdateTetraTopology
{
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;
public:
/***********************************************/
/** @Vertex-Tetrahedron Topology Funtions
**/
//@{
///create the VT topology for tetrahedrons that are into containers
void VTTopology(VertexContainer &vert,TetraContainer &tetra)
{
VertexIterator v;
TetraIterator t;
ClearVTTopology(vert,tetra);
for(t=tetra.begin();t!=tetra.end();++t)
if( ! (*t).IsD())
for(int j=0;j<4;++j)
{
(*t).TVp(j) = (*t).V(j)->VTb();
(*t).TVi(j) = (*t).V(j)->VTi();
(*t).V(j)->VTb() = &(*t);
(*t).V(j)->VTi() = j;
}
}
/// clear the Vertex-Tetra topology
void ClearVTTopology(VertexContainer &vert,TetraContainer &tetra)
{
VertexIterator v;
for(v=vert.begin();v!=vert.end();++v)
{
v->VTb() = 0;
v->VTi() = 0;
}
TetraIterator t;
for(t=tetra.begin();t!=tetra.end();++t)
for(int j=0;j<4;++j)
{
(*t).TVp(j) = 0;
(*t).TVi(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<TetraType> 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(VertexContainer &vert,TetraContainer &tetra)
{
vector <Facet<VertexType,TetraType> > VF;
VertexType* v0;
VertexType* v1;
VertexType* v2;
for (TetraIterator ti=tetra.begin();ti!=tetra.end();ti++)
{
if (!(*ti).IsD())
{
(*ti).TTi(0)=0;
(*ti).TTi(1)=1;
(*ti).TTi(2)=2;
(*ti).TTi(3)=3;
(*ti).TTp(0)=(&(*ti));
(*ti).TTp(1)=(&(*ti));
(*ti).TTp(2)=(&(*ti));
(*ti).TTp(3)=(&(*ti));
v0=(*ti).V(Tetra3<double>::VofF(0,0));
v1=(*ti).V(Tetra3<double>::VofF(0,1));
v2=(*ti).V(Tetra3<double>::VofF(0,2));
VF.push_back(Facet<VertexType,TetraType>(v0,v1,v2,&(*ti),0));
v0=(*ti).V(Tetra3<double>::VofF(1,0));
v1=(*ti).V(Tetra3<double>::VofF(1,1));
v2=(*ti).V(Tetra3<double>::VofF(1,2));
VF.push_back(Facet<VertexType,TetraType>(v0,v1,v2,&(*ti),1));
v0=(*ti).V(Tetra3<double>::VofF(2,0));
v1=(*ti).V(Tetra3<double>::VofF(2,1));
v2=(*ti).V(Tetra3<double>::VofF(2,2));
VF.push_back(Facet<VertexType,TetraType>(v0,v1,v2,&(*ti),2));
v0=(*ti).V(Tetra3<double>::VofF(3,0));
v1=(*ti).V(Tetra3<double>::VofF(3,1));
v2=(*ti).V(Tetra3<double>::VofF(3,2));
VF.push_back(Facet<VertexType,TetraType>(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;i<VF.size()-1;i++)
{
j=i+1;
if (VF[i]==VF[j])
{
t0=VF[i].getTetrahedron();
t1=VF[j].getTetrahedron();
faceindex0=VF[i].getFaceIndex();
faceindex1=VF[j].getFaceIndex();
t0->TTp(faceindex0)=(t1);
t1->TTp(faceindex1)=(t0);
t0->TTi(faceindex0)=(faceindex1);
t1->TTi(faceindex1)=(faceindex0);
i++;
}
}
}
///Test the Tetrahedron-Tetrahedron Topology (by Face)
void TestTTTopology(VertexContainer &vert,TetraContainer &tetra)
{
int i;
for (TetraIterator ti=tetra.begin();ti!=tetra.end();ti++)
{
for (i=0;i<4;i++)
{
if ((!(*ti).IsD())&&((*ti).TTp(i)!=&(*ti)))
{
assert( ((((*ti).TTp(i))->TTp((*ti).TTi(i)))==&(*ti)));
VertexType *v0=(*ti).V(Tetra3<double>::VofF(i,0));
VertexType *v1=(*ti).V(Tetra3<double>::VofF(i,1));
VertexType *v2=(*ti).V(Tetra3<double>::VofF(i,2));
TetraType *t1=(TetraType*)(*ti).TTp(i);
int z1=(*ti).TTi(i);
VertexType *vo0=(*t1).V(Tetra3<double>::VofF(z1,0));
VertexType *vo1=(*t1).V(Tetra3<double>::VofF(z1,1));
VertexType *vo2=(*t1).V(Tetra3<double>::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
Reference in New Issue View Git Blame Copy Permalink