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

Edge pointers substituted with hedge pointers; 

Made EH and HE adjs optional;
Re-written method to check if a diagonal is collapsible;
This commit is contained in:
Paolo Cignoni 2011-01-27 12:03:44 +00:00
parent 7e611ef038
commit 3777d7925d
1 changed files with 153 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

263
vcg/complex/trimesh/update/halfedge_topology.h
View File

@ -46,11 +46,11 @@ namespace vcg
/// Default Constructor /// Default Constructor
Garbage() Garbage()
{ {
}; }
~Garbage() ~Garbage()
{ {
}; }
void undelete_hedges(MeshType &m) void undelete_hedges(MeshType &m)
{ {
@ -133,20 +133,18 @@ namespace vcg
* *
* \return Pointer to the new vertex * \return Pointer to the new vertex
*/ */
static VertexPointer edge_collapse_quad(MeshType &m, EdgePointer ep, VertexPointer vp) static VertexPointer edge_collapse_quad(MeshType &m, HEdgePointer hp, VertexPointer vp)
{ {
assert(vp); assert(vp);
assert(ep); assert(hp);
assert(MeshType::EdgeType::HasEHAdjacency());
assert(MeshType::HEdgeType::HasHEAdjacency());
assert(MeshType::HEdgeType::HasHVAdjacency()); assert(MeshType::HEdgeType::HasHVAdjacency());
assert(ep->EHp()->HVp() == vp || ep->EHp()->HOp()->HVp() == vp); assert(hp->HVp() == vp || hp->HOp()->HVp() == vp);
assert(ep->EHp()->HFp()->VN() == 4); assert(hp->HFp()->VN() == 4);
assert(ep->EHp()->HOp()->HFp()->VN() == 4); assert(hp->HOp()->HFp()->VN() == 4);
VertexPointer vp_opp; VertexPointer vp_opp;
FacePointer fp; FacePointer fp;
HEdgePointer hp = ep->EHp();
if( hp->HVp() == vp ) if( hp->HVp() == vp )
hp = hp->HOp(); hp = hp->HOp();
@ -176,10 +174,8 @@ namespace vcg
{ {
assert(MeshType::VertexType::HasVHAdjacency()); assert(MeshType::VertexType::HasVHAdjacency());
assert(MeshType::EdgeType::HasEHAdjacency());
assert(MeshType::FaceType::HasFHAdjacency()); assert(MeshType::FaceType::HasFHAdjacency());
assert(MeshType::HEdgeType::HasHVAdjacency()); assert(MeshType::HEdgeType::HasHVAdjacency());
assert(MeshType::HEdgeType::HasHEAdjacency());
assert(MeshType::HEdgeType::HasHFAdjacency()); assert(MeshType::HEdgeType::HasHFAdjacency());
assert(MeshType::HEdgeType::HasHOppAdjacency()); assert(MeshType::HEdgeType::HasHOppAdjacency());
assert(MeshType::HEdgeType::HasHPrevAdjacency()); assert(MeshType::HEdgeType::HasHPrevAdjacency());
@ -192,6 +188,8 @@ namespace vcg
assert( !has_doublet(fp) ); assert( !has_doublet(fp) );
assert(!is_singlet(fp)); assert(!is_singlet(fp));
bool HasHE = MeshType::HEdgeType::HasHEAdjacency();
bool HasEH = MeshType::EdgeType::HasEHAdjacency();
HEdgePointer hp; HEdgePointer hp;
@ -225,22 +223,27 @@ namespace vcg
hps[2]->HOp()->HOp()=hps[3]->HOp(); hps[2]->HOp()->HOp()=hps[3]->HOp();
hps[3]->HOp()->HOp()=hps[2]->HOp(); hps[3]->HOp()->HOp()=hps[2]->HOp();
hps[1]->HOp()->HEp()=hps[0]->HEp();
hps[3]->HOp()->HEp()=hps[2]->HEp();
for(int i=0; i<3; i+=2)
{
if(hps[i]->HEp()->EHp() == hps[i])
hps[i]->HEp()->EHp() = hps[i]->HOp();
}
for(int i=0; i<4; i++) for(int i=0; i<4; i++)
{ {
if(hps[i]->HVp()->VHp() == hps[i]) if(hps[i]->HVp()->VHp() == hps[i])
hps[i]->HVp()->VHp() = hps[(i+4-1)%4]->HOp(); hps[i]->HVp()->VHp() = hps[(i+4-1)%4]->HOp();
} }
if(HasHE)
{
hps[1]->HOp()->HEp()=hps[0]->HEp();
hps[3]->HOp()->HEp()=hps[2]->HEp();
}
if(HasEH && HasHE)
{
for(int i=0; i<3; i+=2)
{
if(hps[i]->HEp()->EHp() == hps[i])
hps[i]->HEp()->EHp() = hps[i]->HOp();
}
}
// there are no faces, remove hedges and edge // there are no faces, remove hedges and edge
/* /*
/\ /\
@ -261,7 +264,9 @@ namespace vcg
{ {
if(b[j]) if(b[j])
{ {
Allocator<MeshType>::DeleteEdge(m, *(hps[i]->HEp()) ); if(HasHE)
Allocator<MeshType>::DeleteEdge(m, *(hps[i]->HEp()) );
Allocator<MeshType>::DeleteHEdge(m, *(hps[i]->HOp()) ); Allocator<MeshType>::DeleteHEdge(m, *(hps[i]->HOp()) );
Allocator<MeshType>::DeleteHEdge(m, *(hps[i+1]->HOp()) ); Allocator<MeshType>::DeleteHEdge(m, *(hps[i+1]->HOp()) );
@ -285,15 +290,16 @@ namespace vcg
Allocator<MeshType>::DeleteFace(m, *(fp) ); Allocator<MeshType>::DeleteFace(m, *(fp) );
Allocator<MeshType>::DeleteVertex(m, *(opposite_vertex) ); Allocator<MeshType>::DeleteVertex(m, *(opposite_vertex) );
Allocator<MeshType>::DeleteEdge(m, *(hps[1]->HEp()) ); if(HasHE)
Allocator<MeshType>::DeleteEdge(m, *(hps[3]->HEp()) ); {
Allocator<MeshType>::DeleteEdge(m, *(hps[1]->HEp()) );
Allocator<MeshType>::DeleteEdge(m, *(hps[3]->HEp()) );
}
Allocator<MeshType>::DeleteHEdge(m, *(hps[0]) ); Allocator<MeshType>::DeleteHEdge(m, *(hps[0]) );
Allocator<MeshType>::DeleteHEdge(m, *(hps[1]) ); Allocator<MeshType>::DeleteHEdge(m, *(hps[1]) );
Allocator<MeshType>::DeleteHEdge(m, *(hps[2]) ); Allocator<MeshType>::DeleteHEdge(m, *(hps[2]) );
Allocator<MeshType>::DeleteHEdge(m, *(hps[3]) ); Allocator<MeshType>::DeleteHEdge(m, *(hps[3]) );
// assert( !is_nonManifold_vertex(m, vp) );
return vp; return vp;
} }
@ -353,8 +359,11 @@ namespace vcg
Allocator<MeshType>::DeleteVertex(m, *vp); Allocator<MeshType>::DeleteVertex(m, *vp);
Allocator<MeshType>::DeleteEdge(m, *(hp->HEp()) ); if(MeshType::HEdgeType::HasHEAdjacency())
Allocator<MeshType>::DeleteEdge(m, *(hp->HPp()->HEp()) ); {
Allocator<MeshType>::DeleteEdge(m, *(hp->HEp()) );
Allocator<MeshType>::DeleteEdge(m, *(hp->HPp()->HEp()) );
}
Allocator<MeshType>::DeleteHEdge(m, *hp ); Allocator<MeshType>::DeleteHEdge(m, *hp );
Allocator<MeshType>::DeleteHEdge(m, *(hp->HOp()) ); Allocator<MeshType>::DeleteHEdge(m, *(hp->HOp()) );
Allocator<MeshType>::DeleteHEdge(m, *(hp->HPp()) ); Allocator<MeshType>::DeleteHEdge(m, *(hp->HPp()) );
@ -374,9 +383,9 @@ namespace vcg
* \param m Mesh * \param m Mesh
* \param vp Vertex shared by the two consecutive edges inside the singlet * \param vp Vertex shared by the two consecutive edges inside the singlet
* *
* \return Pointer to the new edge * \return Pointer to an halfdedge representing the new edge
*/ */
static EdgePointer singlet_remove(MeshType &m, FacePointer fp) static HEdgePointer singlet_remove(MeshType &m, FacePointer fp)
{ {
/* /*
2 2
@ -393,6 +402,8 @@ namespace vcg
assert( is_singlet(fp) ); assert( is_singlet(fp) );
bool HasHE = MeshType::HEdgeType::HasHEAdjacency();
bool HasEH = MeshType::EdgeType::HasEHAdjacency();
vector<HEdgePointer> ext_hedges; vector<HEdgePointer> ext_hedges;
@ -409,7 +420,8 @@ namespace vcg
else if(vertex_valence((*hi)->HVp()) == 1) else if(vertex_valence((*hi)->HVp()) == 1)
{ {
Allocator<MeshType>::DeleteVertex( m, *((*hi)->HVp()) ); Allocator<MeshType>::DeleteVertex( m, *((*hi)->HVp()) );
Allocator<MeshType>::DeleteEdge( m, *((*hi)->HEp()) ); if(HasHE)
Allocator<MeshType>::DeleteEdge( m, *((*hi)->HEp()) );
} }
} }
@ -425,16 +437,20 @@ namespace vcg
ext_hedges[0]->HOp() = ext_hedges[1]; ext_hedges[0]->HOp() = ext_hedges[1];
ext_hedges[1]->HOp() = ext_hedges[0]; ext_hedges[1]->HOp() = ext_hedges[0];
Allocator<MeshType>::DeleteEdge( m, *(ext_hedges[1]->HEp()) ); if(HasHE)
{
Allocator<MeshType>::DeleteEdge( m, *(ext_hedges[1]->HEp()) );
ext_hedges[1]->HEp() = ext_hedges[0]->HEp(); ext_hedges[1]->HEp() = ext_hedges[0]->HEp();
ext_hedges[0]->HEp()->EHp() = ext_hedges[0]; if(HasEH)
ext_hedges[0]->HEp()->EHp() = ext_hedges[0];
}
ext_hedges[0]->HVp()->VHp() = ext_hedges[0]; ext_hedges[0]->HVp()->VHp() = ext_hedges[0];
ext_hedges[1]->HVp()->VHp() = ext_hedges[1]; ext_hedges[1]->HVp()->VHp() = ext_hedges[1];
return ext_hedges[0]->HEp(); return ext_hedges[0];
} }
else else
@ -442,8 +458,11 @@ namespace vcg
ext_hedges[0]->HVp()->VHp() = NULL; ext_hedges[0]->HVp()->VHp() = NULL;
ext_hedges[1]->HVp()->VHp() = NULL; ext_hedges[1]->HVp()->VHp() = NULL;
Allocator<MeshType>::DeleteEdge( m, *( ext_hedges[0]->HEp()) ); if(HasHE)
Allocator<MeshType>::DeleteEdge( m, *( ext_hedges[1]->HEp()) ); {
Allocator<MeshType>::DeleteEdge( m, *( ext_hedges[0]->HEp()) );
Allocator<MeshType>::DeleteEdge( m, *( ext_hedges[1]->HEp()) );
}
Allocator<MeshType>::DeleteHEdge( m, *( ext_hedges[0]) ); Allocator<MeshType>::DeleteHEdge( m, *( ext_hedges[0]) );
Allocator<MeshType>::DeleteHEdge( m, *( ext_hedges[1]) ); Allocator<MeshType>::DeleteHEdge( m, *( ext_hedges[1]) );
@ -462,16 +481,17 @@ namespace vcg
* *
* \return Pointer to the rotated edge * \return Pointer to the rotated edge
*/ */
static EdgePointer edge_rotate(MeshType &m, EdgePointer ep, bool cw) static HEdgePointer edge_rotate(HEdgePointer hp, bool cw)
{ {
assert( MeshType::EdgeType::HasEHAdjacency() );
assert( MeshType::HEdgeType::HasHFAdjacency() ); assert( MeshType::HEdgeType::HasHFAdjacency() );
assert( MeshType::HEdgeType::HasHOppAdjacency() ); assert( MeshType::HEdgeType::HasHOppAdjacency() );
assert( MeshType::FaceType::HasFHAdjacency() ); assert( MeshType::FaceType::HasFHAdjacency() );
FacePointer fp1 = ep->EHp()->HFp();
FacePointer fp2 = ep->EHp()->HOp()->HFp(); FacePointer fp1 = hp->HFp();
FacePointer fp2 = hp->HOp()->HFp();
assert( fp1 ); assert( fp1 );
assert( fp1->VN() == 4 ); assert( fp1->VN() == 4 );
@ -492,8 +512,9 @@ namespace vcg
fps.push_back(fp1); fps.push_back(fp1);
fps.push_back(fp2); fps.push_back(fp2);
hps.push_back( getHEdges( fp1, ep->EHp() ) );
hps.push_back( getHEdges( fp2, ep->EHp()->HOp() ) ); hps.push_back( getHEdges( fp1, hp ) );
hps.push_back( getHEdges( fp2, hp->HOp() ) );
for(int i=0; i< 2; i++) for(int i=0; i< 2; i++)
@ -541,7 +562,7 @@ namespace vcg
} }
return ep; return hp;
} }
@ -621,49 +642,47 @@ namespace vcg
* *
* \return Pointer to the other vertex belonging to the collapsed edge * \return Pointer to the other vertex belonging to the collapsed edge
*/ */
static VertexPointer edge_collapse(MeshType &m, EdgePointer ep, VertexPointer vp) static VertexPointer edge_collapse(MeshType &m, HEdgePointer hp, VertexPointer vp)
{ {
assert(MeshType::EdgeType::HasEHAdjacency());
assert(MeshType::VertexType::HasVHAdjacency()); assert(MeshType::VertexType::HasVHAdjacency());
assert(MeshType::HEdgeType::HasHOppAdjacency()); assert(MeshType::HEdgeType::HasHOppAdjacency());
assert(MeshType::HEdgeType::HasHVAdjacency()); assert(MeshType::HEdgeType::HasHVAdjacency());
assert(MeshType::HEdgeType::HasHPrevAdjacency()); assert(MeshType::HEdgeType::HasHPrevAdjacency());
if( ep->EHp()->HFp() ) if( hp->HFp() )
assert(ep->EHp()->HFp()->VN() > 3); assert(hp->HFp()->VN() > 3);
if( ep->EHp()->HOp()->HFp()) if( hp->HOp()->HFp())
assert(ep->EHp()->HOp()->HFp()->VN() > 3); assert(hp->HOp()->HFp()->VN() > 3);
assert(ep->EHp()->HFp() || ep->EHp()->HOp()->HFp()); assert(hp->HFp() || hp->HOp()->HFp());
assert(ep->EHp()->HVp() == vp || ep->EHp()->HOp()->HVp() == vp); assert(hp->HVp() == vp || hp->HOp()->HVp() == vp);
HEdgePointer he = ep->EHp(); HEdgePointer hopp = hp->HOp();
HEdgePointer hopp = he->HOp();
VertexPointer vp1; VertexPointer vp1;
if( he->HVp() == vp ) if( hp->HVp() == vp )
vp1 = hopp->HVp(); vp1 = hopp->HVp();
else else
vp1 = he->HVp(); vp1 = hp->HVp();
change_vertex( vp, vp1); change_vertex( vp, vp1);
//HP //HP
he->HNp()->HPp() = he->HPp(); hp->HNp()->HPp() = hp->HPp();
hopp->HNp()->HPp() = hopp->HPp(); hopp->HNp()->HPp() = hopp->HPp();
//HN //HN
he->HPp()->HNp() = he->HNp(); hp->HPp()->HNp() = hp->HNp();
hopp->HPp()->HNp() = hopp->HNp(); hopp->HPp()->HNp() = hopp->HNp();
//FH //FH
if( he->HFp() ) if( hp->HFp() )
if( he->HFp()->FHp() == he ) if( hp->HFp()->FHp() == hp )
he->HFp()->FHp() = he->HNp(); hp->HFp()->FHp() = hp->HNp();
if( hopp->HFp() ) if( hopp->HFp() )
if( hopp->HFp()->FHp() == hopp ) if( hopp->HFp()->FHp() == hopp )
@ -673,8 +692,9 @@ namespace vcg
if( vp1->VHp() == hopp ) if( vp1->VHp() == hopp )
vp1->VHp() = hopp->HNp(); vp1->VHp() = hopp->HNp();
Allocator<MeshType>::DeleteEdge(m,*ep); if(HasHEAdjacency(m))
Allocator<MeshType>::DeleteHEdge(m,*he); Allocator<MeshType>::DeleteEdge(m,*(hp->HEp()));
Allocator<MeshType>::DeleteHEdge(m,*hp);
Allocator<MeshType>::DeleteHEdge(m,*hopp); Allocator<MeshType>::DeleteHEdge(m,*hopp);
Allocator<MeshType>::DeleteVertex(m,*vp); Allocator<MeshType>::DeleteVertex(m,*vp);
@ -694,9 +714,7 @@ namespace vcg
{ {
assert(MeshType::VertexType::HasVHAdjacency()); assert(MeshType::VertexType::HasVHAdjacency());
assert(MeshType::EdgeType::HasEHAdjacency());
assert(MeshType::HEdgeType::HasHVAdjacency()); assert(MeshType::HEdgeType::HasHVAdjacency());
assert(MeshType::HEdgeType::HasHEAdjacency());
assert(MeshType::HEdgeType::HasHFAdjacency()); assert(MeshType::HEdgeType::HasHFAdjacency());
assert(MeshType::HEdgeType::HasHOppAdjacency()); assert(MeshType::HEdgeType::HasHOppAdjacency());
assert(MeshType::HEdgeType::HasHPrevAdjacency()); assert(MeshType::HEdgeType::HasHPrevAdjacency());
@ -736,10 +754,8 @@ namespace vcg
{ {
assert(MeshType::VertexType::HasVHAdjacency()); assert(MeshType::VertexType::HasVHAdjacency());
assert(MeshType::EdgeType::HasEHAdjacency());
assert(MeshType::FaceType::HasFHAdjacency()); assert(MeshType::FaceType::HasFHAdjacency());
assert(MeshType::HEdgeType::HasHVAdjacency()); assert(MeshType::HEdgeType::HasHVAdjacency());
assert(MeshType::HEdgeType::HasHEAdjacency());
assert(MeshType::HEdgeType::HasHFAdjacency()); assert(MeshType::HEdgeType::HasHFAdjacency());
assert(MeshType::HEdgeType::HasHOppAdjacency()); assert(MeshType::HEdgeType::HasHOppAdjacency());
assert(MeshType::HEdgeType::HasHPrevAdjacency()); assert(MeshType::HEdgeType::HasHPrevAdjacency());
@ -795,9 +811,7 @@ namespace vcg
{ {
assert(MeshType::VertexType::HasVHAdjacency()); assert(MeshType::VertexType::HasVHAdjacency());
assert(MeshType::EdgeType::HasEHAdjacency());
assert(MeshType::HEdgeType::HasHVAdjacency()); assert(MeshType::HEdgeType::HasHVAdjacency());
assert(MeshType::HEdgeType::HasHEAdjacency());
assert(MeshType::HEdgeType::HasHFAdjacency()); assert(MeshType::HEdgeType::HasHFAdjacency());
assert(MeshType::HEdgeType::HasHOppAdjacency()); assert(MeshType::HEdgeType::HasHOppAdjacency());
assert(MeshType::HEdgeType::HasHPrevAdjacency()); assert(MeshType::HEdgeType::HasHPrevAdjacency());
@ -812,6 +826,9 @@ namespace vcg
// assert( count(vps.begin(), vps.end(), vps[i]) == 1 ); // assert( count(vps.begin(), vps.end(), vps[i]) == 1 );
// } // }
bool HasHE = MeshType::HEdgeType::HasHEAdjacency();
bool HasEH = MeshType::EdgeType::HasEHAdjacency();
HEdgeIterator hi; HEdgeIterator hi;
std::vector<HEdgePointer> gphps; std::vector<HEdgePointer> gphps;
@ -849,9 +866,12 @@ namespace vcg
{ {
fp->SetD(); fp->SetD();
ei = Allocator<MeshType>::AddEdges(m,edge_n); if(HasEH || HasHE)
for(EdgeIterator ei1 = ei; ei1 != m.edge.end(); ++ei1) {
(*ei1).SetD(); ei = Allocator<MeshType>::AddEdges(m,edge_n);
for(EdgeIterator ei1 = ei; ei1 != m.edge.end(); ++ei1)
(*ei1).SetD();
}
typename Allocator<MeshType>::template PointerUpdater<HEdgePointer> pu; typename Allocator<MeshType>::template PointerUpdater<HEdgePointer> pu;
@ -889,14 +909,20 @@ namespace vcg
++hi2; ++hi2;
for(EdgeIterator ei1 = ei; ei1 != m.edge.end(); ++ei1, ++hi1, ++hi2) EdgeIterator ei1 = ei;
for(; hi2 != m.hedge.end(); ++hi1, ++hi2)
{ {
// EH // EH
(*ei1).EHp() = &(*hi1); if(HasEH)
(*ei1).EHp() = &(*hi1);
// HE // HE
(*hi1).HEp() = &(*ei1); if(HasHE)
(*hi2).HEp() = &(*ei1); {
(*hi1).HEp() = &(*ei1);
(*hi2).HEp() = &(*ei1);
}
//HO //HO
(*hi1).HOp() = &(*hi2); (*hi1).HOp() = &(*hi2);
@ -1117,7 +1143,9 @@ namespace vcg
Allocator<MeshType>::DeleteHEdge( m, *hps[i] ); Allocator<MeshType>::DeleteHEdge( m, *hps[i] );
Allocator<MeshType>::DeleteHEdge( m, *(hps[i]->HOp()) ); Allocator<MeshType>::DeleteHEdge( m, *(hps[i]->HOp()) );
Allocator<MeshType>::DeleteEdge( m, *(hps[i]->HEp()) );
if(MeshType::HEdgeType::HasHEAdjacency())
Allocator<MeshType>::DeleteEdge( m, *(hps[i]->HEp()) );
if( !hps[(i+size-1)%size]->HOp()->HFp() ) if( !hps[(i+size-1)%size]->HOp()->HFp() )
{ {
@ -1314,7 +1342,7 @@ namespace vcg
* \retval true if diagonal can be collapsed * \retval true if diagonal can be collapsed
* \retval false if diagonal cannot be collapsed * \retval false if diagonal cannot be collapsed
*/ */
static bool can_collapse_diagonal(HEdgePointer hp) static bool check_diagonal_collapse(HEdgePointer hp)
{ {
assert(hp); assert(hp);
@ -1324,38 +1352,21 @@ namespace vcg
vector<FacePointer> faces; vector<FacePointer> faces;
Pos<MeshType> p(hp); HEdgePointer hopp = hp->HNp()->HNp();
vector<FacePointer> faces1 = get_incident_faces(hp->HVp(), hp);
vector<FacePointer> faces2 = get_incident_faces(hp->HNp()->HNp()->HVp(), hopp);
p.FlipE(); faces.assign(faces1.begin()+1, faces1.end());
p.FlipF(); faces.assign(faces2.begin()+1, faces2.end());
while( p.HE() != hp )
{
faces.push_back(p.F());
p.FlipE();
p.FlipF();
}
HEdgePointer opp = hp->HNp()->HNp();
p.he = opp;
p.FlipE();
p.FlipF();
while( p.HE() != opp )
{
faces.push_back(p.F());
p.FlipE();
p.FlipF();
}
// First check:
unsigned int size = faces.size(); unsigned int size = faces.size();
int null_count = 0; bool null_face = false;
// if size <=2 check is ok
if(size > 2) if(size > 2)
{ {
for(unsigned int i = 0; i < size; i++) for(unsigned int i = 0; i < size; i++)
@ -1364,15 +1375,45 @@ namespace vcg
{ {
if(faces[(i+1)%size] != NULL && faces[((i+size)-1)%size] != NULL ) if(faces[(i+1)%size] != NULL && faces[((i+size)-1)%size] != NULL )
{ {
if(null_count > 0) if(null_face)
return false; return false;
else
null_count++; null_face=true;
} }
} }
} }
} }
// End of first check
// Second check
sort (faces1.begin(), faces1.end());
sort (faces2.begin(), faces2.end());
if( faces1[0] == NULL )
faces1.erase(faces1.begin());
if( faces2[0] == NULL )
faces2.erase(faces2.begin());
vector<FacePointer> intersection(faces1.size()+faces2.size());
typename vector<FacePointer>::iterator it;
it = set_intersection(faces1.begin(),faces1.end(), faces2.begin(), faces2.end(), intersection.begin());
intersection.erase(it,intersection.end());
size = intersection.size();
assert( size != 0);
if(size != 1)
return false;
// End of second check
return true; return true;
} }
@ -1457,7 +1498,7 @@ namespace vcg
/*! /*!
* Gets vertices on the 1-ring of a vertex * Gets vertices on the 1-ring of a vertex
* *
* \param vp Vertex * \param vp Vertex. It must be a non-border vertex.
* *
* \return Vector containing vertices * \return Vector containing vertices
*/ */
@ -1495,8 +1536,9 @@ namespace vcg
return ret; return ret;
} }
/*! /*!
* Gets facees on the 1-ring of a vertex * Gets faces on the 1-ring of a vertex
* *
* \param vp Vertex * \param vp Vertex
* *
@ -1521,6 +1563,7 @@ namespace vcg
} }
/*! /*!
* Checks if a face is a singlet * Checks if a face is a singlet
* *