2006-09-25 11:17:44 +02:00
|
|
|
/****************************************************************************
|
|
|
|
* 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. *
|
|
|
|
* *
|
|
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
2006-10-06 17:28:14 +02:00
|
|
|
History
|
2006-09-25 11:17:44 +02:00
|
|
|
|
|
|
|
$Log: not supported by cvs2svn $
|
2006-11-13 11:11:38 +01:00
|
|
|
Revision 1.14 2006/11/07 15:13:56 zifnab1974
|
|
|
|
Necessary changes for compilation with gcc 3.4.6. Especially the hash function is a problem
|
|
|
|
|
2006-11-07 16:13:57 +01:00
|
|
|
Revision 1.13 2006/11/07 11:47:11 cignoni
|
|
|
|
gcc compiling issues
|
|
|
|
|
2006-11-07 12:47:14 +01:00
|
|
|
Revision 1.12 2006/11/07 07:56:43 cignoni
|
|
|
|
Added missing std::
|
|
|
|
|
2006-11-07 08:56:43 +01:00
|
|
|
Revision 1.11 2006/11/06 16:12:29 giec
|
|
|
|
Leipa ear now compute max dihedral angle.
|
|
|
|
|
2006-11-06 17:12:29 +01:00
|
|
|
Revision 1.10 2006/10/31 11:30:41 ganovelli
|
|
|
|
changed access throught iterator with static call to comply 2005 compiler
|
|
|
|
|
2006-10-31 12:30:41 +01:00
|
|
|
Revision 1.9 2006/10/20 07:44:45 cignoni
|
|
|
|
Added missing std::
|
|
|
|
|
2006-10-20 09:44:45 +02:00
|
|
|
Revision 1.8 2006/10/18 15:06:47 giec
|
|
|
|
New policy for compute quality in TrivialEar.
|
|
|
|
Bugfixed LeipaEar.
|
|
|
|
Added new algorithm "selfintersection" with test for self intersection.
|
|
|
|
|
2006-10-18 17:06:47 +02:00
|
|
|
Revision 1.7 2006/10/10 09:12:02 giec
|
|
|
|
Bugfix and added a new type of ear (Liepa like)
|
|
|
|
|
2006-10-10 11:12:02 +02:00
|
|
|
Revision 1.6 2006/10/09 10:07:07 giec
|
|
|
|
Optimized version of "EAR HOLE FILLING", the Ear is selected according to its dihedral angle.
|
|
|
|
|
2006-10-09 12:07:07 +02:00
|
|
|
Revision 1.5 2006/10/06 15:28:14 giec
|
|
|
|
first working implementationof "EAR HOLE FILLING".
|
|
|
|
|
2006-10-06 17:28:14 +02:00
|
|
|
Revision 1.4 2006/10/02 12:06:40 giec
|
|
|
|
BugFix
|
|
|
|
|
2006-10-02 14:06:40 +02:00
|
|
|
Revision 1.3 2006/09/27 15:33:32 giec
|
|
|
|
It close one simple hole . . .
|
|
|
|
|
2006-09-27 17:33:32 +02:00
|
|
|
Revision 1.2 2006/09/27 09:29:53 giec
|
|
|
|
Frist working release whit a few bugs.
|
|
|
|
It almost fills the hole ...
|
|
|
|
|
2006-09-27 11:29:53 +02:00
|
|
|
Revision 1.1 2006/09/25 09:17:44 cignoni
|
|
|
|
First Non working Version
|
|
|
|
|
2006-09-25 11:17:44 +02:00
|
|
|
****************************************************************************/
|
|
|
|
#ifndef __VCG_TRI_UPDATE_HOLE
|
|
|
|
#define __VCG_TRI_UPDATE_HOLE
|
|
|
|
|
2006-10-18 17:06:47 +02:00
|
|
|
#include <vcg/math/base.h>
|
|
|
|
|
2006-09-25 11:17:44 +02:00
|
|
|
/*
|
|
|
|
Questa Classe serve per gestire la non duplicazione degli edge durante la chiusura
|
|
|
|
di un buco.
|
|
|
|
*/
|
|
|
|
namespace vcg {
|
2006-10-06 17:28:14 +02:00
|
|
|
namespace tri {
|
2006-09-27 11:29:53 +02:00
|
|
|
|
2006-10-06 17:28:14 +02:00
|
|
|
template<class MESH>
|
|
|
|
class SimpleEdge
|
2006-09-25 11:17:44 +02:00
|
|
|
{
|
2006-10-06 17:28:14 +02:00
|
|
|
public:
|
|
|
|
typename MESH::VertexType v[2];
|
|
|
|
SimpleEdge()
|
|
|
|
{}
|
2006-09-25 11:17:44 +02:00
|
|
|
|
2006-10-06 17:28:14 +02:00
|
|
|
SimpleEdge(typename MESH::VertexType v0, typename MESH::VertexType v1)
|
|
|
|
{
|
|
|
|
if(v0.P().X() != v1.P().X() &&
|
|
|
|
v0.P().Y() != v1.P().Y() &&
|
|
|
|
v0.P().Z() != v1.P().Z())
|
|
|
|
{v[0]=v1; v[1]=v0;}
|
|
|
|
else {v[0]=v0; v[1]=v1;}
|
|
|
|
}
|
|
|
|
|
2006-11-07 12:47:14 +01:00
|
|
|
SimpleEdge(typename face::Pos<typename MESH::FaceType> &ep) {
|
2006-10-06 17:28:14 +02:00
|
|
|
//*this=SimpleEdge(*ep.VFlip(), *ep.v);
|
2006-11-07 12:47:14 +01:00
|
|
|
typename MESH::VertexType v0 ,v1;
|
2006-09-27 11:29:53 +02:00
|
|
|
v0 = *ep.VFlip();
|
|
|
|
v1 = *ep.v;
|
2006-10-06 17:28:14 +02:00
|
|
|
if(v0.P().X() != v1.P().X() &&
|
|
|
|
v0.P().Y() != v1.P().Y() &&
|
|
|
|
v0.P().Z() != v1.P().Z())
|
|
|
|
{v[0]=v1; v[1]=v0;}
|
|
|
|
else {v[0]=v0; v[1]=v1;}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool operator < (const SimpleEdge & e) const
|
2006-11-07 12:47:14 +01:00
|
|
|
{
|
|
|
|
v[0] = e.v[0]; v[1]=e.v[1];
|
2006-10-06 17:28:14 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
bool operator != (const SimpleEdge & e)
|
|
|
|
{
|
|
|
|
if(v[0].P().X() != e.v[0].P().X() &&
|
|
|
|
v[0].P().Y() != e.v[0].P().Y() &&
|
|
|
|
v[0].P().Z() != e.v[0].P().Z())
|
|
|
|
return true;
|
|
|
|
else return false;
|
|
|
|
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template<class MESH>
|
|
|
|
class HoleInfo
|
2006-09-25 11:17:44 +02:00
|
|
|
{
|
2006-10-06 17:28:14 +02:00
|
|
|
public:
|
|
|
|
HoleInfo(){}
|
|
|
|
HoleInfo(face::Pos<typename MESH::FaceType> const &pHole, int const pHoleSize, vcg::Box3<typename MESH::ScalarType> &pHoleBB)
|
|
|
|
{
|
|
|
|
p=pHole;
|
|
|
|
size=pHoleSize;
|
|
|
|
bb=pHoleBB;
|
|
|
|
}
|
|
|
|
|
|
|
|
HoleInfo(face::Pos<typename MESH::FaceType> const &pHole, int const pHoleSize, vcg::Box3<typename MESH::ScalarType> &pHoleBB, int FI)
|
|
|
|
{
|
|
|
|
p=pHole;
|
|
|
|
size=pHoleSize;
|
|
|
|
bb=pHoleBB;
|
|
|
|
faceindex = FI;
|
|
|
|
}
|
2006-09-25 11:17:44 +02:00
|
|
|
|
|
|
|
|
2006-10-06 17:28:14 +02:00
|
|
|
typename face::Pos<typename MESH::FaceType> p;
|
|
|
|
int size;
|
|
|
|
vcg::Box3<typename MESH::ScalarType> bb;
|
|
|
|
int faceindex;
|
2006-09-25 11:17:44 +02:00
|
|
|
|
2006-10-06 17:28:14 +02:00
|
|
|
void Refresh(MESH &m)
|
|
|
|
{
|
2006-11-07 16:13:57 +01:00
|
|
|
p.f = (typename MESH::FacePointer)(faceindex + &(*(m.face.begin())));
|
2006-10-06 17:28:14 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
bool operator < (const HoleInfo & hh) const {return size < hh.size;}
|
|
|
|
bool operator > (const HoleInfo & hh) const {return size > hh.size;}
|
|
|
|
bool operator == (const HoleInfo & hh) const {return size == hh.size;}
|
|
|
|
bool operator != (const HoleInfo & hh) const {return size != hh.size;}
|
|
|
|
bool operator >= (const HoleInfo & hh) const {return size >= hh.size;}
|
|
|
|
bool operator <= (const HoleInfo & hh) const {return size <= hh.size;}
|
|
|
|
|
|
|
|
typename MESH::ScalarType Perimeter()
|
|
|
|
{
|
2006-11-07 12:47:14 +01:00
|
|
|
typename MESH::ScalarType sum=0;
|
2006-10-06 17:28:14 +02:00
|
|
|
face::Pos<typename MESH::FaceType> ip = p;
|
|
|
|
do
|
|
|
|
{
|
|
|
|
sum+=Distance(ip.v->cP(),ip.VFlip()->cP());
|
|
|
|
ip.NextB();
|
|
|
|
}
|
|
|
|
while (ip != p);
|
|
|
|
return sum;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int CollectEdges(std::vector< SimpleEdge<MESH> > &EV)
|
|
|
|
{
|
|
|
|
assert(p.IsBorder());
|
|
|
|
EV.clear();
|
|
|
|
int tsz=0;
|
|
|
|
face::Pos<typename MESH::FaceType> ip=p;
|
|
|
|
face::Pos<typename MESH::FaceType> tp;
|
|
|
|
|
|
|
|
do
|
|
|
|
{
|
|
|
|
// Stesso codice della nextb
|
|
|
|
do
|
|
|
|
{
|
|
|
|
ip.NextE();
|
|
|
|
EV.push_back(SimpleEdge<MESH>(ip)); // l'edge che sto scorrendo
|
|
|
|
tp=ip;
|
|
|
|
tp.FlipV();tp.FlipE();
|
|
|
|
EV.push_back(SimpleEdge<MESH>(tp)); // l'edge della faccia su cui sono e opposto al vertice su cui ruoto
|
|
|
|
tp.FlipF(); tp.FlipE();
|
|
|
|
EV.push_back(SimpleEdge<MESH>(tp)); // gli altri due edge della faccia opposta a questa
|
|
|
|
tp.FlipE();
|
|
|
|
EV.push_back(SimpleEdge<MESH>(tp));
|
|
|
|
}
|
|
|
|
while(!ip.f->IsB(ip.z));
|
|
|
|
ip.FlipV();
|
|
|
|
++tsz;
|
|
|
|
}
|
|
|
|
while (ip != p);
|
|
|
|
assert(tsz==size);
|
|
|
|
|
|
|
|
return EV.size();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template<class MESH>
|
|
|
|
void FindHole(MESH &m, face::Pos<typename MESH::FaceType> ep, HoleInfo<MESH> &h)
|
2006-09-25 11:17:44 +02:00
|
|
|
{
|
2006-10-06 17:28:14 +02:00
|
|
|
if(!ep.IsBorder()) return;
|
|
|
|
|
|
|
|
int holesize = 0;
|
|
|
|
|
2006-11-07 12:47:14 +01:00
|
|
|
Box3<typename MESH::ScalarType> hbox;
|
2006-10-06 17:28:14 +02:00
|
|
|
if(ep.v->IsR()) hbox.Add(ep.v->cP());
|
|
|
|
face::Pos<typename MESH::FaceType> init;
|
|
|
|
init = ep;
|
2006-09-25 11:17:44 +02:00
|
|
|
do
|
|
|
|
{
|
2006-10-06 17:28:14 +02:00
|
|
|
ep.NextB();
|
|
|
|
ep.f->SetV();
|
|
|
|
if(ep.v->IsR()) hbox.Add(ep.v->cP());
|
|
|
|
++holesize;
|
2006-09-25 11:17:44 +02:00
|
|
|
}
|
2006-10-06 17:28:14 +02:00
|
|
|
while (ep != init);
|
|
|
|
h=HoleInfo<MESH>(ep,holesize,hbox);
|
2006-09-25 11:17:44 +02:00
|
|
|
}
|
|
|
|
|
2006-10-06 17:28:14 +02:00
|
|
|
template<class MESH,class STL_CONTAINER_HOLES>
|
|
|
|
void FindHole(MESH &m, STL_CONTAINER_HOLES & H)
|
2006-09-25 11:17:44 +02:00
|
|
|
{
|
2006-11-07 12:47:14 +01:00
|
|
|
typename MESH::FaceIterator pf;
|
2006-10-06 17:28:14 +02:00
|
|
|
int holesize;
|
|
|
|
for (pf=m.face.begin(); pf!=m.face.end(); ++pf)
|
|
|
|
if( !(*pf).IsD() && (*pf).IsW() )
|
|
|
|
(*pf).ClearS();
|
|
|
|
|
|
|
|
face::Pos<typename MESH::FaceType> ep;
|
|
|
|
for (pf=m.face.begin(); pf!=m.face.end(); ++pf)
|
2006-09-25 11:17:44 +02:00
|
|
|
{
|
2006-10-06 17:28:14 +02:00
|
|
|
if( !(*pf).IsD() && !(*pf).IsS() && (*pf).IsR() )
|
|
|
|
{
|
|
|
|
for(int j=0; j<3; ++j)
|
|
|
|
if( (*pf).IsB(j) && !(*pf).IsS() && (*pf).IsR() )
|
2006-09-25 11:17:44 +02:00
|
|
|
{
|
2006-10-06 17:28:14 +02:00
|
|
|
(*pf).SetS();
|
|
|
|
ep.Set(&*pf, j, (*pf).V(j));
|
|
|
|
holesize = 0;
|
|
|
|
|
2006-11-07 12:47:14 +01:00
|
|
|
Box3<typename MESH::ScalarType> hbox;
|
2006-09-25 11:17:44 +02:00
|
|
|
if(ep.v->IsR()) hbox.Add(ep.v->cP());
|
2006-10-06 17:28:14 +02:00
|
|
|
face::Pos<typename MESH::FaceType> init;
|
|
|
|
init = ep;
|
|
|
|
do
|
|
|
|
{
|
|
|
|
ep.NextB();
|
|
|
|
ep.f->SetS();
|
|
|
|
if(ep.v->IsR()) hbox.Add(ep.v->cP());
|
|
|
|
++holesize;
|
|
|
|
}
|
|
|
|
while (ep != init);
|
|
|
|
H.push_back(HoleInfo<MESH>(ep,holesize,hbox));
|
|
|
|
break;
|
2006-09-25 11:17:44 +02:00
|
|
|
}
|
2006-10-06 17:28:14 +02:00
|
|
|
}
|
2006-09-25 11:17:44 +02:00
|
|
|
}
|
2006-10-06 17:28:14 +02:00
|
|
|
};
|
2006-09-25 11:17:44 +02:00
|
|
|
|
|
|
|
|
2006-10-06 17:28:14 +02:00
|
|
|
/*
|
|
|
|
Un ear e' identificato da due hedge pos.
|
2006-09-25 11:17:44 +02:00
|
|
|
|
2006-10-06 17:28:14 +02:00
|
|
|
i vertici dell'ear sono
|
|
|
|
e0.FlipV().v
|
|
|
|
e0.v
|
|
|
|
e1.v
|
2006-09-25 11:17:44 +02:00
|
|
|
|
2006-10-06 17:28:14 +02:00
|
|
|
Vale che e1== e0.NextB();
|
|
|
|
e che e1.FlipV() == e0;
|
2006-09-25 11:17:44 +02:00
|
|
|
|
2006-10-06 17:28:14 +02:00
|
|
|
Situazioni ear non manifold, e degeneri (buco triangolare)
|
2006-09-25 11:17:44 +02:00
|
|
|
|
|
|
|
|
2006-10-06 17:28:14 +02:00
|
|
|
T XXXXXXXXXXXXX A /XXXXX B en/XXXXX
|
|
|
|
/XXXXXXXXXXXXXXX /XXXXXX /XXXXXX
|
|
|
|
XXXXXXep==en XXX ep\ /en XXXX /e1 XXXX
|
|
|
|
XXXXXX ----/| XX ------ ----/| XX ------ ----/|XXX
|
|
|
|
XXXXXX| /e1 XX XXXXXX| /e1 XX XXXXXX| o/e0 XX
|
|
|
|
XXXXXX| /XXXXXX XXXXXX| /XXXXXX XXXXXX| /XXXXXX
|
|
|
|
XXX e0|o/XXXXXXX XXX e0|o/XXXXXXX XXX ep| /XXXXXXX
|
|
|
|
XXX \|/XXXXXXXX XXX \|/XXXXXXXX XXX \|/XXXXXXXX
|
|
|
|
XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXX
|
2006-09-25 11:17:44 +02:00
|
|
|
|
2006-10-06 17:28:14 +02:00
|
|
|
*/
|
|
|
|
template<class MSH_TYPE> class TrivialEar
|
|
|
|
{
|
|
|
|
public:
|
2006-10-10 11:12:02 +02:00
|
|
|
face::Pos<typename MSH_TYPE::FaceType> e0;
|
|
|
|
face::Pos<typename MSH_TYPE::FaceType> e1;
|
2006-10-18 17:06:47 +02:00
|
|
|
typedef typename MSH_TYPE::ScalarType ScalarType;
|
|
|
|
ScalarType quality;
|
|
|
|
ScalarType angle;
|
2006-10-06 17:28:14 +02:00
|
|
|
TrivialEar(){}
|
|
|
|
TrivialEar(const face::Pos<typename MSH_TYPE::FaceType> & ep)
|
|
|
|
{
|
|
|
|
e0=ep;
|
|
|
|
assert(e0.IsBorder());
|
|
|
|
e1=e0;
|
|
|
|
e1.NextB();
|
|
|
|
ComputeQuality();
|
2006-10-18 17:06:47 +02:00
|
|
|
computeAngle();
|
2006-10-06 17:28:14 +02:00
|
|
|
}
|
|
|
|
|
2006-10-18 17:06:47 +02:00
|
|
|
void computeAngle()
|
|
|
|
{
|
|
|
|
Point3f p1 = e0.VFlip()->P() - e0.v->P();
|
|
|
|
Point3f p2 = e1.v->P() - e0.v->P();
|
|
|
|
|
|
|
|
ScalarType w = p2.Norm()*p1.Norm();
|
|
|
|
if(w==0) angle =90;
|
2006-11-07 12:47:14 +01:00
|
|
|
ScalarType p = (p2*p1);
|
2006-10-18 17:06:47 +02:00
|
|
|
p= p/w;
|
|
|
|
p = acos(p);
|
|
|
|
if(p < -1) p = -1;
|
|
|
|
if(p > 1) p = 1;
|
|
|
|
|
|
|
|
Point3f t = p2^p1;
|
|
|
|
ScalarType n = t* e0.v->N();
|
|
|
|
if(n<0)
|
|
|
|
{
|
|
|
|
p = 2.0 *(float)M_PI - p;
|
|
|
|
}
|
|
|
|
angle = p;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline bool operator < ( const TrivialEar & c ) const { return quality < c.quality; }
|
2006-10-06 17:28:14 +02:00
|
|
|
|
|
|
|
bool IsNull(){return e0.IsNull() || e1.IsNull();}
|
|
|
|
void SetNull(){e0.SetNull();e1.SetNull();}
|
|
|
|
void ComputeQuality()
|
|
|
|
{
|
2006-10-18 17:06:47 +02:00
|
|
|
ScalarType ar;
|
|
|
|
ar = ( (e0.VFlip()->P() - e0.v->P()) ^ ( e1.v->P() - e0.v->P()) ).Norm() ;
|
|
|
|
ScalarType area = (ar);
|
|
|
|
|
|
|
|
ScalarType l1 = Distance( e0.v->P(),e1.v->P());
|
|
|
|
ScalarType l2 = Distance( e0.v->P(),e0.VFlip()->P());
|
|
|
|
ScalarType l3 = Distance( e0.VFlip()->P(),e1.v->P());
|
|
|
|
|
|
|
|
quality = area / ( (l1 *l1) + (l2 * l2) + (l3 * l3) );
|
|
|
|
};
|
2006-10-06 17:28:14 +02:00
|
|
|
bool IsUpToDate() {return (e0.IsBorder() && e1.IsBorder());};
|
2006-09-25 11:17:44 +02:00
|
|
|
|
2006-10-18 17:06:47 +02:00
|
|
|
bool IsConvex(){return (angle > (float)M_PI);}
|
|
|
|
|
|
|
|
|
2006-10-06 17:28:14 +02:00
|
|
|
bool Degen()
|
|
|
|
{
|
|
|
|
face::Pos<typename MSH_TYPE::FaceType> ep=e0; ep.FlipV(); ep.NextB(); ep.FlipV(); // he precedente a e0
|
|
|
|
face::Pos<typename MSH_TYPE::FaceType> en=e1; en.NextB(); // he successivo a e1
|
2006-09-25 11:17:44 +02:00
|
|
|
|
2006-10-06 17:28:14 +02:00
|
|
|
// caso ear degenere per buco triangolare
|
|
|
|
if(ep==en) return true;//provo a togliere sto controllo
|
|
|
|
// Caso ear non manifold a
|
|
|
|
if(ep.v==en.v) return true;
|
|
|
|
// Caso ear non manifold b
|
|
|
|
if(ep.VFlip()==e1.v) return true;
|
2006-09-25 11:17:44 +02:00
|
|
|
|
2006-10-06 17:28:14 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Close(TrivialEar &ne0, TrivialEar &ne1, typename MSH_TYPE::FaceType * f)
|
|
|
|
{
|
|
|
|
// simple topological check
|
|
|
|
if(e0.f==e1.f) {
|
|
|
|
printf("Avoided bad ear");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
//usato per generare una delle due nuove orecchie.
|
|
|
|
face::Pos<typename MSH_TYPE::FaceType> ep=e0; ep.FlipV(); ep.NextB(); ep.FlipV(); // he precedente a e0
|
|
|
|
face::Pos<typename MSH_TYPE::FaceType> en=e1; en.NextB(); // he successivo a e1
|
|
|
|
|
|
|
|
(*f).V(0) = e0.VFlip();
|
|
|
|
(*f).V(1) = e0.v;
|
|
|
|
(*f).V(2) = e1.v;
|
|
|
|
|
|
|
|
(*f).FFp(0) = e0.f;
|
|
|
|
(*f).FFi(0) = e0.z;
|
|
|
|
(*f).FFp(1) = e1.f;
|
|
|
|
(*f).FFi(1) = e1.z;
|
|
|
|
(*f).FFp(2) = f;
|
|
|
|
(*f).FFi(2) = 2;
|
|
|
|
|
|
|
|
e0.f->FFp(e0.z)=f;
|
|
|
|
e0.f->FFi(e0.z)=0;
|
|
|
|
|
|
|
|
e1.f->FFp(e1.z)=f;
|
|
|
|
e1.f->FFi(e1.z)=1;
|
|
|
|
|
|
|
|
// caso ear degenere per buco triangolare
|
|
|
|
if(ep==en)
|
|
|
|
{
|
|
|
|
printf("Closing the last triangle");
|
|
|
|
f->FFp(2)=en.f;
|
|
|
|
f->FFi(2)=en.z;
|
|
|
|
en.f->FFp(en.z)=f;
|
|
|
|
en.f->FFi(en.z)=2;
|
|
|
|
ne0.SetNull();
|
|
|
|
ne1.SetNull();
|
|
|
|
}
|
|
|
|
// Caso ear non manifold a
|
|
|
|
else if(ep.v==en.v)
|
|
|
|
{
|
|
|
|
printf("Ear Non manif A\n");
|
|
|
|
face::Pos<typename MSH_TYPE::FaceType> enold=en;
|
|
|
|
en.NextB();
|
|
|
|
f->FFp(2)=enold.f;
|
|
|
|
f->FFi(2)=enold.z;
|
|
|
|
enold.f->FFp(enold.z)=f;
|
|
|
|
enold.f->FFi(enold.z)=2;
|
|
|
|
ne0=TrivialEar(ep);
|
|
|
|
ne1=TrivialEar(en);
|
|
|
|
}
|
|
|
|
// Caso ear non manifold b
|
|
|
|
else if(ep.VFlip()==e1.v)
|
|
|
|
{
|
|
|
|
printf("Ear Non manif B\n");
|
|
|
|
face::Pos<typename MSH_TYPE::FaceType> epold=ep;
|
|
|
|
ep.FlipV(); ep.NextB(); ep.FlipV();
|
|
|
|
f->FFp(2)=epold.f;
|
|
|
|
f->FFi(2)=epold.z;
|
|
|
|
epold.f->FFp(epold.z)=f;
|
|
|
|
epold.f->FFi(epold.z)=2;
|
|
|
|
ne0=TrivialEar(ep);
|
|
|
|
ne1=TrivialEar(en);
|
|
|
|
}
|
|
|
|
else // caso standard
|
|
|
|
// Now compute the new ears;
|
|
|
|
{
|
|
|
|
ne0=TrivialEar(ep);
|
|
|
|
ne1=TrivialEar(face::Pos<typename MSH_TYPE::FaceType>(f,2,e1.v));
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2006-10-18 17:06:47 +02:00
|
|
|
//Ear with Leipa's quality policy
|
|
|
|
template<class MSH_TYPE> class LeipaEar
|
2006-10-10 11:12:02 +02:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
face::Pos<typename MSH_TYPE::FaceType> e0;
|
|
|
|
face::Pos<typename MSH_TYPE::FaceType> e1;
|
2006-10-18 17:06:47 +02:00
|
|
|
typedef typename MSH_TYPE::ScalarType ScalarType;
|
|
|
|
ScalarType angle;
|
|
|
|
ScalarType dihedral;
|
|
|
|
ScalarType area;
|
2006-10-10 11:12:02 +02:00
|
|
|
LeipaEar(){}
|
|
|
|
LeipaEar(const face::Pos<typename MSH_TYPE::FaceType> & ep)
|
|
|
|
{
|
|
|
|
e0=ep;
|
|
|
|
assert(e0.IsBorder());
|
|
|
|
e1=e0;
|
|
|
|
e1.NextB();
|
|
|
|
ComputeQuality();
|
2006-10-18 17:06:47 +02:00
|
|
|
computeAngle();
|
2006-10-10 11:12:02 +02:00
|
|
|
}
|
|
|
|
|
2006-10-18 17:06:47 +02:00
|
|
|
void computeAngle()
|
|
|
|
{
|
|
|
|
Point3f p1 = e0.VFlip()->P() - e0.v->P();
|
|
|
|
Point3f p2 = e1.v->P() - e0.v->P();
|
|
|
|
|
|
|
|
ScalarType w = p2.Norm()*p1.Norm();
|
|
|
|
if(w==0) angle =90;
|
|
|
|
ScalarType p = (p2*p1);
|
|
|
|
p= p/w;
|
|
|
|
p = acos(p);
|
|
|
|
if(p < -1) p = -1;
|
|
|
|
if(p > 1) p = 1;
|
|
|
|
|
|
|
|
Point3f t = p2^p1;
|
|
|
|
ScalarType n = t* e0.v->N();
|
|
|
|
if(n<0)
|
|
|
|
{
|
|
|
|
p = 2.0 *(float)M_PI - p;
|
|
|
|
}
|
|
|
|
angle = p;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Nota: minori invertiti
|
2006-10-10 11:12:02 +02:00
|
|
|
inline bool operator < ( const LeipaEar & c ) const
|
|
|
|
{
|
|
|
|
if(dihedral < c.dihedral)return true;
|
|
|
|
else return ((dihedral == c.dihedral) && (area < c.area));
|
|
|
|
}
|
|
|
|
|
|
|
|
bool IsNull(){return e0.IsNull() || e1.IsNull();}
|
|
|
|
void SetNull(){e0.SetNull();e1.SetNull();}
|
|
|
|
void ComputeQuality()
|
|
|
|
{
|
2006-10-18 17:06:47 +02:00
|
|
|
//comute quality by (dihedral ancgle, area/sum(edge^2) )
|
2006-10-10 11:12:02 +02:00
|
|
|
Point3f n1 = (e0.v->N() + e1.v->N() + e0.VFlip()->N() ) / 3;
|
|
|
|
face::Pos<typename MSH_TYPE::FaceType> tmp = e1;
|
|
|
|
tmp.FlipE();tmp.FlipV();
|
2006-11-06 17:12:29 +01:00
|
|
|
Point3f n2=(e1.VFlip()->N() + e1.v->N() + tmp.v->N() ) / 3;
|
|
|
|
tmp = e0;
|
|
|
|
tmp.FlipE(); tmp.FlipV();
|
|
|
|
Point3f n3=(e0.VFlip()->N() + e0.v->N() + tmp.v->N() ) / 3;
|
2006-11-07 12:47:14 +01:00
|
|
|
dihedral = std::max(Angle(n1,n2),Angle(n1,n3));
|
2006-10-10 11:12:02 +02:00
|
|
|
|
2006-11-07 12:47:14 +01:00
|
|
|
ScalarType ar;
|
2006-10-10 11:12:02 +02:00
|
|
|
ar = ( (e0.VFlip()->P() - e0.v->P()) ^ ( e1.v->P() - e0.v->P()) ).Norm() ;
|
2006-10-18 17:06:47 +02:00
|
|
|
|
|
|
|
/*ScalarType l1 = Distance( e0.v->P(),e1.v->P());
|
|
|
|
ScalarType l2 = Distance( e0.v->P(),e0.VFlip()->P());
|
|
|
|
ScalarType l3 = Distance( e0.VFlip()->P(),e1.v->P());*/
|
|
|
|
|
|
|
|
|
|
|
|
area = ar ;// ( (l1 *l1) + (l2 * l2) + (l3 * l3) );
|
|
|
|
|
2006-10-10 11:12:02 +02:00
|
|
|
|
|
|
|
};//dovrebbe
|
|
|
|
bool IsUpToDate() {return (e0.IsBorder() && e1.IsBorder());};
|
2006-10-18 17:06:47 +02:00
|
|
|
bool IsConvex(){return angle > (float)M_PI;}
|
2006-10-10 11:12:02 +02:00
|
|
|
bool Degen()
|
|
|
|
{
|
|
|
|
face::Pos<typename MSH_TYPE::FaceType> ep=e0; ep.FlipV(); ep.NextB(); ep.FlipV(); // he precedente a e0
|
|
|
|
face::Pos<typename MSH_TYPE::FaceType> en=e1; en.NextB(); // he successivo a e1
|
|
|
|
|
|
|
|
// caso ear degenere per buco triangolare
|
|
|
|
if(ep==en) return true;//provo a togliere sto controllo
|
|
|
|
// Caso ear non manifold a
|
|
|
|
if(ep.v==en.v) return true;
|
|
|
|
// Caso ear non manifold b
|
|
|
|
if(ep.VFlip()==e1.v) return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Close(LeipaEar &ne0, LeipaEar &ne1, typename MSH_TYPE::FaceType * f)
|
|
|
|
{
|
|
|
|
// simple topological check
|
|
|
|
if(e0.f==e1.f) {
|
|
|
|
printf("Avoided bad ear");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
//usato per generare una delle due nuove orecchie.
|
|
|
|
face::Pos<typename MSH_TYPE::FaceType> ep=e0; ep.FlipV(); ep.NextB(); ep.FlipV(); // he precedente a e0
|
|
|
|
face::Pos<typename MSH_TYPE::FaceType> en=e1; en.NextB(); // he successivo a e1
|
|
|
|
|
|
|
|
(*f).V(0) = e0.VFlip();
|
|
|
|
(*f).V(1) = e0.v;
|
|
|
|
(*f).V(2) = e1.v;
|
|
|
|
|
|
|
|
(*f).FFp(0) = e0.f;
|
|
|
|
(*f).FFi(0) = e0.z;
|
|
|
|
(*f).FFp(1) = e1.f;
|
|
|
|
(*f).FFi(1) = e1.z;
|
|
|
|
(*f).FFp(2) = f;
|
|
|
|
(*f).FFi(2) = 2;
|
|
|
|
|
|
|
|
e0.f->FFp(e0.z)=f;
|
|
|
|
e0.f->FFi(e0.z)=0;
|
|
|
|
|
|
|
|
e1.f->FFp(e1.z)=f;
|
|
|
|
e1.f->FFi(e1.z)=1;
|
|
|
|
|
|
|
|
// caso ear degenere per buco triangolare
|
|
|
|
if(ep==en)
|
|
|
|
{
|
|
|
|
printf("Closing the last triangle");
|
|
|
|
f->FFp(2)=en.f;
|
|
|
|
f->FFi(2)=en.z;
|
|
|
|
en.f->FFp(en.z)=f;
|
|
|
|
en.f->FFi(en.z)=2;
|
|
|
|
ne0.SetNull();
|
|
|
|
ne1.SetNull();
|
|
|
|
}
|
|
|
|
// Caso ear non manifold a
|
|
|
|
else if(ep.v==en.v)
|
|
|
|
{
|
|
|
|
printf("Ear Non manif A\n");
|
|
|
|
face::Pos<typename MSH_TYPE::FaceType> enold=en;
|
|
|
|
en.NextB();
|
|
|
|
f->FFp(2)=enold.f;
|
|
|
|
f->FFi(2)=enold.z;
|
|
|
|
enold.f->FFp(enold.z)=f;
|
|
|
|
enold.f->FFi(enold.z)=2;
|
|
|
|
ne0=LeipaEar(ep);
|
|
|
|
ne1=LeipaEar(en);
|
|
|
|
}
|
|
|
|
// Caso ear non manifold b
|
|
|
|
else if(ep.VFlip()==e1.v)
|
|
|
|
{
|
|
|
|
printf("Ear Non manif B\n");
|
|
|
|
face::Pos<typename MSH_TYPE::FaceType> epold=ep;
|
|
|
|
ep.FlipV(); ep.NextB(); ep.FlipV();
|
|
|
|
f->FFp(2)=epold.f;
|
|
|
|
f->FFi(2)=epold.z;
|
|
|
|
epold.f->FFp(epold.z)=f;
|
|
|
|
epold.f->FFi(epold.z)=2;
|
|
|
|
ne0=LeipaEar(ep);
|
|
|
|
ne1=LeipaEar(en);
|
|
|
|
}
|
|
|
|
else // caso standard
|
|
|
|
// Now compute the new ears;
|
|
|
|
{
|
|
|
|
ne0=LeipaEar(ep);
|
|
|
|
ne1=LeipaEar(face::Pos<typename MSH_TYPE::FaceType>(f,2,e1.v));
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
};
|
2006-10-18 17:06:47 +02:00
|
|
|
//Ear for selfintersection algorithm
|
|
|
|
template<class MSH_TYPE> class SelfIntersection
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
face::Pos<typename MSH_TYPE::FaceType> e0;
|
|
|
|
face::Pos<typename MSH_TYPE::FaceType> e1;
|
|
|
|
typedef typename MSH_TYPE::ScalarType ScalarType;
|
|
|
|
ScalarType quality;
|
|
|
|
ScalarType angle;
|
|
|
|
SelfIntersection(){}
|
|
|
|
SelfIntersection(const face::Pos<typename MSH_TYPE::FaceType> & ep)
|
|
|
|
{
|
|
|
|
e0=ep;
|
|
|
|
assert(e0.IsBorder());
|
|
|
|
e1=e0;
|
|
|
|
e1.NextB();
|
|
|
|
ComputeQuality();
|
|
|
|
computeAngle();
|
|
|
|
}
|
|
|
|
|
|
|
|
inline bool operator < ( const SelfIntersection & c ) const
|
|
|
|
{
|
|
|
|
return (quality < c.quality);
|
|
|
|
}
|
|
|
|
void computeAngle()
|
|
|
|
{
|
|
|
|
Point3f p1 = e0.VFlip()->P() - e0.v->P();
|
|
|
|
Point3f p2 = e1.v->P() - e0.v->P();
|
|
|
|
|
|
|
|
ScalarType w = p2.Norm()*p1.Norm();
|
|
|
|
if(w==0) angle =90;
|
2006-11-07 12:47:14 +01:00
|
|
|
ScalarType p = (p2*p1);
|
2006-10-18 17:06:47 +02:00
|
|
|
p= p/w;
|
|
|
|
p = acos(p);
|
|
|
|
if(p < -1) p = -1;
|
|
|
|
if(p > 1) p = 1;
|
|
|
|
|
|
|
|
Point3f t = p2^p1;
|
|
|
|
ScalarType n = t* e0.v->N();
|
|
|
|
if(n<0)
|
|
|
|
{
|
|
|
|
p = 2.0 *(float)M_PI - p;
|
|
|
|
}
|
|
|
|
angle = p;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool IsNull(){return e0.IsNull() || e1.IsNull();}
|
|
|
|
void SetNull(){e0.SetNull();e1.SetNull();}
|
|
|
|
void ComputeQuality()
|
|
|
|
{
|
|
|
|
ScalarType ar;
|
|
|
|
ar = ( (e0.VFlip()->P() - e0.v->P()) ^ ( e1.v->P() - e0.v->P()) ).Norm() ;
|
|
|
|
ScalarType area = (ar);
|
|
|
|
|
|
|
|
ScalarType l1 = Distance( e0.v->P(),e1.v->P());
|
|
|
|
ScalarType l2 = Distance( e0.v->P(),e0.VFlip()->P());
|
|
|
|
ScalarType l3 = Distance( e0.VFlip()->P(),e1.v->P());
|
|
|
|
|
|
|
|
quality = area / ( (l1 *l1) + (l2 * l2) + (l3 * l3) );
|
|
|
|
};
|
|
|
|
bool IsUpToDate() {return (e0.IsBorder() && e1.IsBorder());};
|
|
|
|
bool IsConvex(){ return (angle > (float)M_PI);}
|
|
|
|
bool Degen()
|
|
|
|
{
|
|
|
|
face::Pos<typename MSH_TYPE::FaceType> ep=e0; ep.FlipV(); ep.NextB(); ep.FlipV(); // he precedente a e0
|
|
|
|
face::Pos<typename MSH_TYPE::FaceType> en=e1; en.NextB(); // he successivo a e1
|
|
|
|
|
|
|
|
// caso ear degenere per buco triangolare
|
|
|
|
if(ep==en) return true;//provo a togliere sto controllo
|
|
|
|
// Caso ear non manifold a
|
|
|
|
if(ep.v==en.v) return true;
|
|
|
|
// Caso ear non manifold b
|
|
|
|
if(ep.VFlip()==e1.v) return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Close(SelfIntersection &ne0, SelfIntersection &ne1, typename MSH_TYPE::FaceType * f, std::vector<typename MSH_TYPE::FaceType> vf)
|
|
|
|
{
|
|
|
|
// simple topological check
|
|
|
|
if(e0.f==e1.f) {
|
|
|
|
printf("Avoided bad ear");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
face::Pos<typename MSH_TYPE::FaceType> ep=e0; ep.FlipV(); ep.NextB(); ep.FlipV(); // he precedente a e0
|
|
|
|
face::Pos<typename MSH_TYPE::FaceType> en=e1; en.NextB(); // he successivo a e1
|
|
|
|
//costruisco la faccia e poi testo, o copio o butto via.
|
|
|
|
(*f).V(0) = e0.VFlip();
|
|
|
|
(*f).V(1) = e0.v;
|
|
|
|
(*f).V(2) = e1.v;
|
|
|
|
|
|
|
|
(*f).FFp(0) = e0.f;
|
|
|
|
(*f).FFi(0) = e0.z;
|
|
|
|
(*f).FFp(1) = e1.f;
|
|
|
|
(*f).FFi(1) = e1.z;
|
|
|
|
(*f).FFp(2) = f;
|
|
|
|
(*f).FFi(2) = 2;
|
|
|
|
|
|
|
|
int a1, a2;
|
|
|
|
a1=e0.z;
|
|
|
|
a2=e1.z;
|
|
|
|
|
|
|
|
e0.f->FFp(e0.z)=f;
|
|
|
|
e0.f->FFi(e0.z)=0;
|
|
|
|
|
|
|
|
e1.f->FFp(e1.z)=f;
|
|
|
|
e1.f->FFi(e1.z)=1;
|
2006-11-07 12:47:14 +01:00
|
|
|
typename std::vector<typename MSH_TYPE::FaceType>::iterator it;
|
2006-10-18 17:06:47 +02:00
|
|
|
for(it = vf.begin();it!= vf.end();++it)
|
|
|
|
{
|
|
|
|
if(!it->IsD())
|
|
|
|
if( tri::Clean<MSH_TYPE>::TestIntersection(&(*f),&(*it)))
|
|
|
|
{
|
|
|
|
//rimetto a posto
|
|
|
|
|
|
|
|
e0.f->FFp(e0.z)=e0.f;
|
|
|
|
e0.f->FFi(e0.z)=a1;
|
|
|
|
|
|
|
|
e1.f->FFp(e1.z)=e1.f;
|
|
|
|
e1.f->FFi(e1.z)=a2;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// caso ear degenere per buco triangolare
|
|
|
|
if(ep==en)
|
|
|
|
{
|
|
|
|
printf("Closing the last triangle");
|
|
|
|
f->FFp(2)=en.f;
|
|
|
|
f->FFi(2)=en.z;
|
|
|
|
en.f->FFp(en.z)=f;
|
|
|
|
en.f->FFi(en.z)=2;
|
|
|
|
ne0.SetNull();
|
|
|
|
ne1.SetNull();
|
|
|
|
}
|
|
|
|
// Caso ear non manifold a
|
|
|
|
else if(ep.v==en.v)
|
|
|
|
{
|
|
|
|
printf("Ear Non manif A\n");
|
|
|
|
face::Pos<typename MSH_TYPE::FaceType> enold=en;
|
|
|
|
en.NextB();
|
|
|
|
f->FFp(2)=enold.f;
|
|
|
|
f->FFi(2)=enold.z;
|
|
|
|
enold.f->FFp(enold.z)=f;
|
|
|
|
enold.f->FFi(enold.z)=2;
|
|
|
|
ne0=SelfIntersection(ep);
|
|
|
|
ne1=SelfIntersection(en);
|
|
|
|
}
|
|
|
|
// Caso ear non manifold b
|
|
|
|
else if(ep.VFlip()==e1.v)
|
|
|
|
{
|
|
|
|
printf("Ear Non manif B\n");
|
|
|
|
face::Pos<typename MSH_TYPE::FaceType> epold=ep;
|
|
|
|
ep.FlipV(); ep.NextB(); ep.FlipV();
|
|
|
|
f->FFp(2)=epold.f;
|
|
|
|
f->FFi(2)=epold.z;
|
|
|
|
epold.f->FFp(epold.z)=f;
|
|
|
|
epold.f->FFi(epold.z)=2;
|
|
|
|
ne0=SelfIntersection(ep);
|
|
|
|
ne1=SelfIntersection(en);
|
|
|
|
}
|
|
|
|
else // caso standard
|
|
|
|
// Now compute the new ears;
|
|
|
|
{
|
|
|
|
ne0=SelfIntersection(ep);
|
|
|
|
ne1=SelfIntersection(face::Pos<typename MSH_TYPE::FaceType>(f,2,e1.v));
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2006-10-06 17:28:14 +02:00
|
|
|
|
|
|
|
|
|
|
|
// Funzione principale per chiudier un buco in maniera topologicamente corretta.
|
|
|
|
// Gestisce situazioni non manifold ragionevoli
|
|
|
|
// (tutte eccetto quelle piu' di 2 facce per 1 edge).
|
|
|
|
// Controlla che non si generino nuove situazioni non manifold chiudendo orecchie
|
|
|
|
// che sottendono un edge che gia'esiste.
|
|
|
|
template<class MESH>
|
|
|
|
tri::HoleInfo<MESH> getHoleInfo(MESH &m, face::Pos<typename MESH::FaceType> sp,
|
|
|
|
face::Pos<typename MESH::FaceType> fp,
|
|
|
|
int UBIT)
|
2006-09-25 11:17:44 +02:00
|
|
|
{
|
2006-10-06 17:28:14 +02:00
|
|
|
int holesize=0;
|
|
|
|
|
2006-11-07 12:47:14 +01:00
|
|
|
Box3<typename MESH::ScalarType> hbox;
|
2006-10-06 17:28:14 +02:00
|
|
|
hbox.Add(sp.v->cP());
|
|
|
|
|
|
|
|
do
|
|
|
|
{
|
|
|
|
sp.f->SetUserBit(UBIT);
|
|
|
|
hbox.Add(sp.v->cP());
|
|
|
|
++holesize;
|
|
|
|
sp.NextB();
|
|
|
|
assert(sp.IsBorder());
|
|
|
|
}while(sp != fp);
|
|
|
|
|
|
|
|
int tmp = ((int)(sp.f - &(*(m.face.begin()))));
|
|
|
|
return tri::HoleInfo<MESH>(sp,holesize,hbox, tmp );
|
2006-09-25 11:17:44 +02:00
|
|
|
}
|
2006-10-06 17:28:14 +02:00
|
|
|
|
|
|
|
template<class MESH,class EAR , class VECTOR_EAR>
|
2006-10-18 17:06:47 +02:00
|
|
|
void refreshHole(MESH &m, VECTOR_EAR &ve, face::Pos<typename MESH::FaceType> &fp)
|
2006-09-25 11:17:44 +02:00
|
|
|
{
|
2006-10-06 17:28:14 +02:00
|
|
|
face::Pos<typename MESH::FaceType> ff = fp;
|
|
|
|
|
|
|
|
do{
|
|
|
|
ve.push_back(EAR(fp));
|
|
|
|
fp.NextB();//semmai da provare a sostituire il codice della NextB();
|
|
|
|
assert(fp.IsBorder());
|
|
|
|
}while(fp!=ff);
|
|
|
|
|
2006-09-25 11:17:44 +02:00
|
|
|
}
|
|
|
|
|
2006-10-06 17:28:14 +02:00
|
|
|
template <class MESH, class EAR>
|
|
|
|
void fillHoleEar(MESH &m, tri::HoleInfo<MESH> &h ,int UBIT)
|
2006-09-25 11:17:44 +02:00
|
|
|
{
|
2006-10-06 17:28:14 +02:00
|
|
|
//Aggiungo le facce e aggiorno il puntatore alla faccia!
|
2006-11-07 12:47:14 +01:00
|
|
|
std::vector<typename MESH::FacePointer *> app;
|
2006-10-06 17:28:14 +02:00
|
|
|
app.push_back( &h.p.f );
|
2006-11-07 12:47:14 +01:00
|
|
|
typename MESH::FaceIterator f = tri::Allocator<MESH>::AddFaces(m, h.size-2, app);
|
2006-10-10 11:12:02 +02:00
|
|
|
h.Refresh(m);
|
2006-10-06 17:28:14 +02:00
|
|
|
assert(h.p.IsBorder());//test fondamentale altrimenti qualcosa s'e' rotto!
|
|
|
|
|
|
|
|
std::vector<EAR > H; //vettore di orecchie
|
|
|
|
|
|
|
|
H.reserve(h.size);
|
|
|
|
|
|
|
|
//prendo le informazioni sul buco
|
2006-10-18 17:06:47 +02:00
|
|
|
refreshHole<MESH,EAR, std::vector<EAR> >(m,H,h.p);
|
2006-10-06 17:28:14 +02:00
|
|
|
|
|
|
|
bool fitted = false;
|
|
|
|
int cnt=h.size;
|
2006-11-07 12:47:14 +01:00
|
|
|
typename MESH::FaceIterator tmp;
|
2006-10-06 17:28:14 +02:00
|
|
|
|
2006-10-09 12:07:07 +02:00
|
|
|
make_heap(H.begin(), H.end());
|
|
|
|
|
2006-10-18 17:06:47 +02:00
|
|
|
while( cnt > 2 && !H.empty() && !fitted) //finche' il buco non e' chiuso o non ci sono piu' orecchie da analizzare
|
2006-10-06 17:28:14 +02:00
|
|
|
{
|
2006-09-27 17:33:32 +02:00
|
|
|
|
2006-10-09 12:07:07 +02:00
|
|
|
pop_heap(H.begin(), H.end());
|
2006-10-06 17:28:14 +02:00
|
|
|
|
2006-10-09 12:07:07 +02:00
|
|
|
EAR en0,en1;
|
2006-10-06 17:28:14 +02:00
|
|
|
|
2006-11-07 12:47:14 +01:00
|
|
|
typename MESH::FaceIterator Fadd = f;
|
2006-10-06 17:28:14 +02:00
|
|
|
|
2006-10-18 17:06:47 +02:00
|
|
|
if(H.back().IsUpToDate() && !H.back().IsConvex())
|
2006-10-06 17:28:14 +02:00
|
|
|
{
|
2006-10-09 12:07:07 +02:00
|
|
|
if(H.back().Degen()){
|
2006-09-27 17:33:32 +02:00
|
|
|
// Nota che nel caso di ear degeneri si DEVE permettere la creazione di un edge che gia'esiste
|
|
|
|
printf("\n -> Evitata orecchia brutta!");
|
2006-10-06 17:28:14 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2006-10-18 17:06:47 +02:00
|
|
|
|
2006-10-06 17:28:14 +02:00
|
|
|
if(H.back().Close(en0,en1,&*f))
|
2006-09-27 17:33:32 +02:00
|
|
|
{
|
2006-10-06 17:28:14 +02:00
|
|
|
if(!en0.IsNull()){
|
2006-10-09 12:07:07 +02:00
|
|
|
H.push_back(en0);
|
|
|
|
push_heap( H.begin(), H.end());
|
2006-10-06 17:28:14 +02:00
|
|
|
}
|
|
|
|
if(!en1.IsNull()){
|
2006-10-09 12:07:07 +02:00
|
|
|
H.push_back(en1);
|
|
|
|
push_heap( H.begin(), H.end());
|
|
|
|
}
|
2006-10-06 17:28:14 +02:00
|
|
|
--cnt;
|
2006-10-09 12:07:07 +02:00
|
|
|
f->SetUserBit(UBIT);
|
2006-10-06 17:28:14 +02:00
|
|
|
++f;
|
|
|
|
fitted = true;
|
2006-09-27 17:33:32 +02:00
|
|
|
}
|
2006-10-06 17:28:14 +02:00
|
|
|
}
|
2006-10-09 12:07:07 +02:00
|
|
|
|
|
|
|
if(cnt == 3 && !fitted)
|
|
|
|
{//ultimo buco o unico buco
|
|
|
|
if(H.back().Close(en0,en1,&*f))
|
|
|
|
{
|
|
|
|
--cnt;
|
|
|
|
tmp = f;
|
|
|
|
++f;
|
|
|
|
}
|
2006-10-06 17:28:14 +02:00
|
|
|
}
|
2006-10-09 12:07:07 +02:00
|
|
|
}//is update()
|
|
|
|
fitted = false;
|
|
|
|
//non ho messo il triangolo quindi tolgo l'orecchio e continuo
|
|
|
|
H.pop_back();
|
2006-10-06 17:28:14 +02:00
|
|
|
}//fine del while principale
|
|
|
|
|
|
|
|
while(f!=m.face.end())
|
|
|
|
{
|
|
|
|
(*f).SetD();
|
|
|
|
++f;
|
|
|
|
m.fn--;
|
|
|
|
}
|
|
|
|
|
2006-09-27 17:33:32 +02:00
|
|
|
}
|
2006-10-06 17:28:14 +02:00
|
|
|
|
|
|
|
|
2006-10-10 11:12:02 +02:00
|
|
|
template<class MESH, class EAR>
|
2006-10-06 17:28:14 +02:00
|
|
|
void holeFillingEar(MESH &m, int sizeHole,bool Selected = false)
|
2006-09-27 17:33:32 +02:00
|
|
|
{
|
2006-11-07 12:47:14 +01:00
|
|
|
typename MESH::FaceIterator fi;
|
2006-10-06 17:28:14 +02:00
|
|
|
std::vector<tri::HoleInfo<MESH> > vinfo;
|
2006-10-31 12:30:41 +01:00
|
|
|
int UBIT = MESH::FaceType::LastBitFlag();
|
2006-10-06 17:28:14 +02:00
|
|
|
|
|
|
|
for(fi = m.face.begin(); fi!=m.face.end(); ++fi)
|
|
|
|
{
|
|
|
|
if(!(*fi).IsD())
|
2006-09-27 17:33:32 +02:00
|
|
|
{
|
2006-10-06 17:28:14 +02:00
|
|
|
if(Selected && !(*fi).IsS())
|
|
|
|
{
|
|
|
|
//se devo considerare solo i triangoli selezionati e
|
|
|
|
//quello che sto considerando non lo e' lo marchio e vado avanti
|
|
|
|
(*fi).SetUserBit(UBIT);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if( !(*fi).IsUserBit(UBIT) )
|
|
|
|
{
|
|
|
|
(*fi).SetUserBit(UBIT);
|
|
|
|
for(int j =0; j<3 ; ++j)
|
|
|
|
{
|
|
|
|
if( (*fi).IsB(j) )
|
|
|
|
{//Trovato una faccia di bordo non ancora visitata.
|
|
|
|
face::Pos<typename MESH::FaceType> sp(&*fi, j, (*fi).V(j));
|
|
|
|
|
|
|
|
// if(!(*fi).IsR())return;
|
|
|
|
tri::HoleInfo<MESH> HI = getHoleInfo<MESH>(m,sp,sp, UBIT);
|
|
|
|
//ho recuperato l'inofrmazione su tutto il buco
|
|
|
|
vinfo.push_back(HI);
|
|
|
|
}
|
|
|
|
}//for sugli edge del triangolo
|
|
|
|
}//se e' gia stato visitato
|
|
|
|
}//S & !S
|
|
|
|
}//!IsD()
|
|
|
|
}//for principale!!!
|
|
|
|
|
2006-11-07 12:47:14 +01:00
|
|
|
typename std::vector<typename tri::HoleInfo<MESH> >::iterator ith;
|
|
|
|
typename tri::HoleInfo<MESH> app;
|
2006-10-06 17:28:14 +02:00
|
|
|
for(ith = vinfo.begin(); ith!= vinfo.end(); ++ith)
|
|
|
|
{
|
|
|
|
app=(tri::HoleInfo<MESH>)*ith;
|
|
|
|
if(app.size < sizeHole){
|
2006-10-10 11:12:02 +02:00
|
|
|
fillHoleEar<MESH, EAR >(m, app,UBIT);
|
2006-09-25 11:17:44 +02:00
|
|
|
}
|
2006-10-06 17:28:14 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
for(fi = m.face.begin(); fi!=m.face.end(); ++fi)
|
|
|
|
{
|
|
|
|
if(!(*fi).IsD())
|
|
|
|
(*fi).ClearUserBit(UBIT);
|
|
|
|
}
|
2006-09-25 11:17:44 +02:00
|
|
|
}
|
2006-09-27 17:33:32 +02:00
|
|
|
|
2006-10-18 17:06:47 +02:00
|
|
|
/*
|
|
|
|
FillHoleSelfIntersection
|
|
|
|
*/
|
|
|
|
template <class MESH, class EAR>
|
|
|
|
void fillHoleInt(MESH &m, tri::HoleInfo<MESH> &h ,int UBIT, std::vector<typename MESH::FaceType > vf)
|
|
|
|
{
|
|
|
|
//Aggiungo le facce e aggiorno il puntatore alla faccia!
|
2006-11-07 12:47:14 +01:00
|
|
|
std::vector<typename MESH::FacePointer *> app;
|
2006-10-18 17:06:47 +02:00
|
|
|
app.push_back( &h.p.f );
|
2006-11-07 12:47:14 +01:00
|
|
|
typename MESH::FaceIterator f = tri::Allocator<MESH>::AddFaces(m, h.size-2, app);
|
2006-10-18 17:06:47 +02:00
|
|
|
h.Refresh(m);
|
|
|
|
assert(h.p.IsBorder());//test fondamentale altrimenti qualcosa s'e' rotto!
|
|
|
|
std::vector<EAR > H; //vettore di orecchie
|
|
|
|
H.reserve(h.size);
|
|
|
|
|
|
|
|
//prendo le informazioni sul buco
|
|
|
|
tri::refreshHole<MESH,EAR, std::vector<EAR> >(m,H,h.p);
|
|
|
|
|
|
|
|
bool fitted = false;
|
|
|
|
int cnt=h.size;
|
2006-11-07 12:47:14 +01:00
|
|
|
typename MESH::FaceIterator tmp;
|
2006-10-18 17:06:47 +02:00
|
|
|
|
|
|
|
make_heap(H.begin(), H.end());
|
|
|
|
//finche' il buco non e' chiuso o non ci sono piu' orecchie da analizzare.
|
|
|
|
while( cnt > 2 && !H.empty() )
|
|
|
|
{
|
|
|
|
pop_heap(H.begin(), H.end());
|
|
|
|
EAR en0,en1;
|
2006-11-07 12:47:14 +01:00
|
|
|
typename MESH::FaceIterator Fadd = f;
|
2006-10-18 17:06:47 +02:00
|
|
|
if(H.back().IsUpToDate() && !H.back().IsConvex())
|
|
|
|
{
|
|
|
|
if(H.back().Degen()){
|
|
|
|
// Nota che nel caso di ear degeneri si DEVE permettere la creazione di un edge che gia'esiste.
|
|
|
|
printf("\n -> Evitata orecchia brutta!");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if(H.back().Close(en0,en1,&*f,vf))
|
|
|
|
{
|
|
|
|
if(!en0.IsNull()){
|
|
|
|
H.push_back(en0);
|
|
|
|
push_heap( H.begin(), H.end());
|
|
|
|
}
|
|
|
|
if(!en1.IsNull()){
|
|
|
|
H.push_back(en1);
|
|
|
|
push_heap( H.begin(), H.end());
|
|
|
|
}
|
|
|
|
--cnt;
|
|
|
|
f->SetUserBit(UBIT);
|
|
|
|
vf.push_back(*f);
|
|
|
|
++f;
|
|
|
|
fitted = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//ultimo buco o unico buco.
|
|
|
|
if(cnt == 3 && !fitted)
|
|
|
|
{
|
|
|
|
if(H.back().Close(en0,en1,&*f,vf))
|
|
|
|
{
|
|
|
|
--cnt;
|
|
|
|
tmp = f;
|
|
|
|
vf.push_back(*f);
|
|
|
|
++f;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}//is update()
|
|
|
|
fitted = false;
|
|
|
|
//non ho messo il triangolo quindi tolgo l'orecchio e continuo.
|
|
|
|
H.pop_back();
|
|
|
|
}//fine del while principale.
|
|
|
|
//tolgo le facce non utilizzate.
|
|
|
|
while(f!=m.face.end())
|
|
|
|
{
|
|
|
|
(*f).SetD();
|
|
|
|
++f;
|
|
|
|
m.fn--;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
//hole filling selfintersection main algorithm
|
|
|
|
template<class MESH, class EAR>
|
|
|
|
void holeFillingIntersection(MESH &m, int sizeHole,bool Selected = false)
|
|
|
|
{
|
2006-11-07 12:47:14 +01:00
|
|
|
typename MESH::FaceIterator fi;
|
|
|
|
std::vector<typename tri::HoleInfo<MESH> > vinfo;
|
2006-10-18 17:06:47 +02:00
|
|
|
int UBIT = fi->LastBitFlag();
|
|
|
|
|
|
|
|
for(fi = m.face.begin(); fi!=m.face.end(); ++fi)
|
|
|
|
{
|
|
|
|
if(!(*fi).IsD())
|
|
|
|
{
|
|
|
|
if(Selected && !(*fi).IsS())
|
|
|
|
{
|
|
|
|
//se devo considerare solo i triangoli selezionati e
|
|
|
|
//quello che sto considerando non lo e' lo marchio e vado avanti
|
|
|
|
(*fi).SetUserBit(UBIT);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if( !(*fi).IsUserBit(UBIT) )
|
|
|
|
{
|
|
|
|
(*fi).SetUserBit(UBIT);
|
|
|
|
for(int j =0; j<3 ; ++j)
|
|
|
|
{
|
|
|
|
if( (*fi).IsB(j) )
|
|
|
|
{//Trovato una faccia di bordo non ancora visitata.
|
|
|
|
face::Pos<typename MESH::FaceType> sp(&*fi, j, (*fi).V(j));
|
|
|
|
|
|
|
|
// if(!(*fi).IsR())return;
|
|
|
|
tri::HoleInfo<MESH> HI = tri::getHoleInfo<MESH>(m,sp,sp, UBIT);
|
|
|
|
//ho recuperato l'inofrmazione su tutto il buco
|
|
|
|
vinfo.push_back(HI);
|
|
|
|
}
|
|
|
|
}//for sugli edge del triangolo
|
|
|
|
}//se e' gia stato visitato
|
|
|
|
}//S & !S
|
|
|
|
}//!IsD()
|
|
|
|
}//for principale!!!
|
|
|
|
|
2006-11-07 12:47:14 +01:00
|
|
|
std::vector<typename MESH::FaceType > vf;
|
2006-10-18 17:06:47 +02:00
|
|
|
face::Pos<typename MESH::FaceType>sp;
|
|
|
|
face::Pos<typename MESH::FaceType>ap;
|
2006-11-07 12:47:14 +01:00
|
|
|
typename std::vector<tri::HoleInfo<MESH> >::iterator ith;
|
2006-10-18 17:06:47 +02:00
|
|
|
tri::HoleInfo<MESH> app;
|
|
|
|
for(ith = vinfo.begin(); ith!= vinfo.end(); ++ith)
|
|
|
|
{
|
|
|
|
app=(tri::HoleInfo<MESH>)*ith;
|
|
|
|
if(app.size < sizeHole){
|
|
|
|
app.Refresh(m);
|
|
|
|
//colleziono il ring intorno al buco per poi fare il test sul'intersezione
|
|
|
|
sp = app.p;
|
|
|
|
do
|
|
|
|
{
|
|
|
|
ap = sp;
|
|
|
|
do
|
|
|
|
{
|
|
|
|
ap.FlipE();
|
|
|
|
ap.FlipF();
|
|
|
|
vf.push_back(*ap.f);
|
|
|
|
}while(!ap.IsBorder());
|
|
|
|
sp.NextB();
|
|
|
|
|
|
|
|
}while(sp != app.p);
|
|
|
|
|
|
|
|
fillHoleInt<MESH, EAR >(m, app,UBIT,vf);
|
|
|
|
vf.clear();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for(fi = m.face.begin(); fi!=m.face.end(); ++fi)
|
|
|
|
{
|
|
|
|
if(!(*fi).IsD())
|
|
|
|
(*fi).ClearUserBit(UBIT);
|
|
|
|
}
|
|
|
|
}
|
2006-10-06 17:28:14 +02:00
|
|
|
} // end namespace
|
2006-09-27 11:29:53 +02:00
|
|
|
}
|
2006-11-07 12:47:14 +01:00
|
|
|
#endif
|