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

first realease only link conditions control are implemented

This commit is contained in:
Nico Pietroni 2004-06-08 15:24:58 +00:00
parent ae77c7c439
commit 68a6f52588
1 changed files with 232 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

232
vcg/complex/trimesh/edge_collapse.h Normal file
View File

@ -0,0 +1,232 @@
/****************************************************************************
* 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
****************************************************************************/
#ifndef __VCG_TETRA_TRI_COLLAPSE
#define __VCG_TETRA_TRI_COLLAPSE
#include<vcg\simplex\face\pos.h>
#include<map>
/** \addtogroup trimesh */
/*@{*/
/// This Class is used for the edge collapse
namespace vcg{
namespace tri{
template <class TRI_MESH_TYPE>
class EdgeCollapse
{
public:
/// The tetrahedral mesh type
typedef typename TRI_MESH_TYPE TriMeshType;
/// The tetrahedron type
typedef typename TriMeshType::FaceType FaceType;
/// The vertex type
typedef typename FaceType::VertexType VertexType;
/// The vertex iterator type
typedef typename TriMeshType::VertexIterator VertexIterator;
/// The tetra iterator type
typedef typename TriMeshType::FaceIterator TetraIterator;
/// The coordinate type
typedef typename FaceType::VertexType::CoordType CoordType;
/// The scalar type
typedef typename TriMeshType::VertexType::ScalarType ScalarType;
///the container of tetrahedron type
typedef typename TriMeshType::FaceContainer FaceContainer;
///the container of vertex type
typedef typename TriMeshType::VertexContainer VertexContainer;
/// Default Constructor
EdgeCollapse()
{
};
~EdgeCollapse()
{
};
struct Edge{
VertexType* v0,v1;
EdgeMark( const VertexType*& a,const VertexType*& b){
assert(a!=b);
if(a<b)
{v0=a;v1=b;}
else
{v1=a;v0=b;}
}
const bool operator <(const EdgeMark & e) const {
return (v0==e.v0)?(v1<e.v1):(v0<e.v0);
}
const bool operator ==(const EdgeMark & e) const {
return (v0==e.v0)&&(v1==e.v1);
}
};
map<Edge,char> EdgeMark;
void orMark(Edge E,char M)
{
map<Edge,char>::Iterator EI;
EdgeMark.find(E);
if (EI==EdgeMArk.end())
EdgeMark.insert (Pair<Edge,char>(E,M));
else
(*EI).second()|=M;
}
bool isMarked(Edge E,char M)
{
map<Edge,char>::Iterator EI;
EdgeMark.find(E);
if (EI==EdgeMArk.end())
return false;
else return ((*EI).second()&M);
}
///control link conditions for the collapse
bool LinkCondition(Pos<FaceType> pos)
{
const int LINK_V0 = VertexType::NewBitFlag();
const int LINK_V1 = VertexType::NewBitFlag();
const int LINK_EE = VertexType::NewBitFlag();
const int NOT_LINKED = ~(LINK_V0 | LINK_V1 | LINK_EE);
VertexType *ve0=pos.f->V(pos.z);
VertexType *ve1=pos.f->V((pos.z+1)%3);
int edge =pos.z;
VFIterator<FaceType> vf0(ve0->VFb(),ve0->VFi());
// Clear visited and adj flag for all vertices adj to v0;
while (!vf0.End())
{
vf0.f->V(0)->Flags() &= NOT_LINKED;
vf0.f->V(1)->Flags() &= NOT_LINKED;
vf0.f->V(2)->Flags() &= NOT_LINKED;
vf0++;
}
VFIterator<FaceType> vf1(ve1->VFb(),ve1->VFi());
// Clear visited and adj flag for all vertices adj to v0;
while (!vf1.End())
{
vf1.f->V(0)->Flags() &= NOT_LINKED;
vf1.f->V(1)->Flags() &= NOT_LINKED;
vf1.f->V(2)->Flags() &= NOT_LINKED;
vf1++;
}
vf0.f=ve0->VFb();
vf0.f=ve0->VFi();
// Mark vertices of v0
while (!vf0.End())
{
vf0.f->V(0)->Flags() |= (LINK_V0);
vf0.f->V(1)->Flags() |= (LINK_V0);
vf0.f->V(2)->Flags() |= (LINK_V0);
orMark(Edge(vf0.f->V(0),vf0.f->V(1)),LINK_V0);
orMark(Edge(vf0.f->V(1),vf0.f->V(2)),LINK_V0);
orMark(Edge(vf0.f->V(2),vf0.f->V(0)),LINK_V0);
vf0++;
}
//mark the entities on the edge
VertexType* vt0=pos.f->V(edge);
VertexType* vt1=pos.f->V((edge+1)%3);
VertexType* vt2=pos.f->V((edge+2)%3);
vt0->Flags() |= (LINK_EE);
vt1->Flags() |= (LINK_EE);
vt2->Flags() |= (LINK_EE);
FaceType *opp=pos.f()->FFp(edge);
int eopp=pos.f()->FFi(edge);
VertexType* vt3=opp.f->V((eopp+2)%3);
vt3->Flags() |= LINK_EE;
//mark the edges
orMark(Edge(vt0,vt1),LINK_EE);
orMark(Edge(vt0,vt2),LINK_EE);
orMark(Edge(vt1,vt2),LINK_EE);
orMark(Edge(vt0,vt3),LINK_EE);
orMark(Edge(vt1,vt3),LINK_EE);
//and at the end I verify if the intersection is equal to the star of the edge
vf1.f=ve1->VFb();
vf1.f=ve1->VFi();
bool correct=true;
while (!vf1.End())
{
vt0=vf1.f->V(0);
vt1=vf1.f->V(1);
vt2=vf1.f->V(2);
if ((vt0->Flags()& LINK_V0)&&(!(vt0->Flags()& LINK_EE)))
correct=false;
else
if ((vt1->Flags()& LINK_V0)&&(!(vt1->Flags()& LINK_EE)))
correct=false;
else
if ((vt2->Flags()& LINK_V0)&&(!(vt2->Flags()& LINK_EE)))
correct=false;
else
if ((isMarked(Edge(v0,v1),LINK_V0))&&(!isMarked(Edge(v0,v1),LINK_EE)))
correct=false;
else
if ((isMarked(Edge(v1,v2),LINK_V0))&&(!isMarked(Edge(v1,v2),LINK_EE)))
correct=false;
else
if ((isMarked(Edge(v2,v0),LINK_V0))&&(!isMarked(Edge(v2,v0),LINK_EE)))
correct=false;
if (!correct)
{
VertexType::DeleteBitFlag(LINK_V0);
VertexType::DeleteBitFlag(LINK_V1);
VertexType::DeleteBitFlag(LINK_EE);
return (false)
}
vf1++;
}
return true;
VertexType::DeleteBitFlag(LINK_V0);
VertexType::DeleteBitFlag(LINK_V1);
VertexType::DeleteBitFlag(LINK_EE);
}
};
}
}