993 lines
28 KiB
C++
993 lines
28 KiB
C++
/****************************************************************************
|
|
* 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.34 2007/01/31 15:25:49 giec
|
|
Remove some usless code in Minimum Weight Triangulation.
|
|
|
|
Revision 1.33 2007/01/31 11:46:12 giec
|
|
Bug fix
|
|
|
|
Revision 1.32 2007/01/18 18:15:14 cignoni
|
|
added missing typenames
|
|
|
|
Revision 1.31 2007/01/18 11:17:43 giec
|
|
The minimum weight algorithm keep the topology consistent.
|
|
|
|
Revision 1.30 2007/01/10 12:07:54 giec
|
|
Bugfixed ComputeDihedralAngle function
|
|
|
|
Revision 1.29 2006/12/27 15:09:52 giec
|
|
Bug fix on ComputeDihedralAngle function
|
|
|
|
Revision 1.28 2006/12/12 11:14:51 cignoni
|
|
Commented some variant of the quality measure of weighted ears
|
|
|
|
Revision 1.27 2006/12/07 00:40:18 cignoni
|
|
Added many this-> for gcc compiling
|
|
|
|
Revision 1.26 2006/12/06 13:03:59 cignoni
|
|
Corrected bugs on selfintersection
|
|
|
|
Revision 1.25 2006/12/06 00:12:53 cignoni
|
|
Heavily restructured and corrected. Now a single Close ear function
|
|
Corrected Hole search function, and management of double non manifold vertex in a hole
|
|
Changed priority strategy in the heap, now a mix of quality and dihedral angle.
|
|
Changed but still untested IntersectionEar
|
|
|
|
Revision 1.24 2006/12/01 21:24:16 cignoni
|
|
Corrected bug in the search of holes. Removed output prints
|
|
|
|
Revision 1.23 2006/12/01 08:53:55 cignoni
|
|
Corrected pop_heap vs pop_back issue in heap usage
|
|
|
|
Revision 1.22 2006/12/01 00:11:17 cignoni
|
|
Added Callback, Corrected some spelling errors (adiacense -> adjacency).
|
|
Added Validity Check function for hole loops
|
|
|
|
Revision 1.21 2006/11/30 11:49:20 cignoni
|
|
small gcc compiling issues
|
|
|
|
Revision 1.20 2006/11/29 16:21:45 cignoni
|
|
Made static exposed funtions of the class
|
|
|
|
Revision 1.19 2006/11/29 15:25:22 giec
|
|
Removed limit.
|
|
|
|
Revision 1.18 2006/11/29 15:18:49 giec
|
|
Code refactory and bugfix.
|
|
|
|
Revision 1.17 2006/11/24 10:42:39 mariolatronico
|
|
Now compiles on gcc under linux.
|
|
|
|
Revision 1.16 2006/11/22 13:43:28 giec
|
|
Code refactory and added minimum weight triangolation.
|
|
|
|
Revision 1.15 2006/11/13 10:11:38 giec
|
|
Clear some useless code
|
|
|
|
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
|
|
|
|
Revision 1.13 2006/11/07 11:47:11 cignoni
|
|
gcc compiling issues
|
|
|
|
Revision 1.12 2006/11/07 07:56:43 cignoni
|
|
Added missing std::
|
|
|
|
Revision 1.11 2006/11/06 16:12:29 giec
|
|
Leipa ear now compute max dihedral angle.
|
|
|
|
Revision 1.10 2006/10/31 11:30:41 ganovelli
|
|
changed access throught iterator with static call to comply 2005 compiler
|
|
|
|
Revision 1.9 2006/10/20 07:44:45 cignoni
|
|
Added missing std::
|
|
|
|
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.
|
|
|
|
Revision 1.7 2006/10/10 09:12:02 giec
|
|
Bugfix and added a new type of ear (Liepa like)
|
|
|
|
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.
|
|
|
|
Revision 1.5 2006/10/06 15:28:14 giec
|
|
first working implementationof "EAR HOLE FILLING".
|
|
|
|
Revision 1.4 2006/10/02 12:06:40 giec
|
|
BugFix
|
|
|
|
Revision 1.3 2006/09/27 15:33:32 giec
|
|
It close one simple hole . . .
|
|
|
|
Revision 1.2 2006/09/27 09:29:53 giec
|
|
Frist working release whit a few bugs.
|
|
It almost fills the hole ...
|
|
|
|
Revision 1.1 2006/09/25 09:17:44 cignoni
|
|
First Non working Version
|
|
|
|
****************************************************************************/
|
|
#ifndef __VCG_TRI_UPDATE_HOLE
|
|
#define __VCG_TRI_UPDATE_HOLE
|
|
|
|
#include <wrap/callback.h>
|
|
#include <vcg/math/base.h>
|
|
#include <vcg/complex/algorithms/clean.h>
|
|
#include <vcg/space/point3.h>
|
|
#include <vector>
|
|
#include <float.h>
|
|
|
|
namespace vcg {
|
|
namespace tri {
|
|
|
|
/*
|
|
Un ear e' identificato da due hedge pos.
|
|
i vertici dell'ear sono
|
|
e0.VFlip().v
|
|
e0.v
|
|
e1.v
|
|
Vale che e1== e0.NextB();
|
|
e che e1.FlipV() == e0;
|
|
Situazioni ear non manifold, e degeneri (buco triangolare)
|
|
|
|
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
|
|
*/
|
|
template<class MESH> class TrivialEar
|
|
{
|
|
public:
|
|
typedef typename MESH::FaceType FaceType;
|
|
typedef typename MESH::FacePointer FacePointer;
|
|
typedef typename face::Pos<FaceType> PosType;
|
|
typedef typename MESH::ScalarType ScalarType;
|
|
typedef typename MESH::CoordType CoordType;
|
|
|
|
PosType e0;
|
|
PosType e1;
|
|
CoordType n; // the normal of the face defined by the ear
|
|
const char * Dump() {return 0;}
|
|
const CoordType &cP(int i) const {return P(i);}
|
|
const CoordType &P(int i) const {
|
|
switch(i) {
|
|
case 0 : return e0.v->cP();
|
|
case 1 : return e1.v->cP();
|
|
case 2 : return e0.VFlip()->cP();
|
|
default: assert(0);
|
|
}
|
|
return e0.v->cP();
|
|
}
|
|
|
|
ScalarType quality;
|
|
ScalarType angle;
|
|
//std::vector<typename MESH::FaceType>* vf;
|
|
TrivialEar(){}
|
|
TrivialEar(const PosType & ep)
|
|
{
|
|
e0=ep;
|
|
assert(e0.IsBorder());
|
|
e1=e0;
|
|
e1.NextB();
|
|
n=vcg::Normal<TrivialEar>(*this);
|
|
ComputeQuality();
|
|
ComputeAngle();
|
|
}
|
|
|
|
/// Compute the angle of the two edges of the ear.
|
|
// it tries to make the computation in a precision safe way.
|
|
// the angle computation takes into account the case of reversed ears
|
|
void ComputeAngle()
|
|
{
|
|
angle=Angle(cP(2)-cP(0), cP(1)-cP(0));
|
|
ScalarType flipAngle = n.dot(e0.v->N());
|
|
if(flipAngle<0) angle = (2.0 *(float)M_PI) - angle;
|
|
}
|
|
|
|
virtual inline bool operator < ( const TrivialEar & c ) const { return quality < c.quality; }
|
|
|
|
bool IsNull(){return e0.IsNull() || e1.IsNull();}
|
|
void SetNull(){e0.SetNull();e1.SetNull();}
|
|
virtual void ComputeQuality() { quality = QualityFace(*this) ; };
|
|
bool IsUpToDate() {return ( e0.IsBorder() && e1.IsBorder());};
|
|
// An ear is degenerated if both of its two endpoints are non manifold.
|
|
bool IsDegen(const int nonManifoldBit)
|
|
{
|
|
if(e0.VFlip()->IsUserBit(nonManifoldBit) && e1.V()->IsUserBit(nonManifoldBit))
|
|
return true;
|
|
else return false;
|
|
}
|
|
bool IsConcave() const {return(angle > (float)M_PI);}
|
|
|
|
virtual bool Close(PosType &np0, PosType &np1, FaceType * f)
|
|
{
|
|
// simple topological check
|
|
if(e0.f==e1.f) {
|
|
//printf("Avoided bad ear");
|
|
return false;
|
|
}
|
|
|
|
//usato per generare una delle due nuove orecchie.
|
|
PosType ep=e0; ep.FlipV(); ep.NextB(); ep.FlipV(); // he precedente a e0
|
|
PosType en=e1; en.NextB(); // he successivo a e1
|
|
|
|
(*f).V(0) = e0.VFlip();
|
|
(*f).V(1) = e0.v;
|
|
(*f).V(2) = e1.v;
|
|
ComputeNormal(*f);
|
|
|
|
(*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;
|
|
np0.SetNull();
|
|
np1.SetNull();
|
|
}
|
|
// Caso ear non manifold a
|
|
else if(ep.v==en.v)
|
|
{
|
|
//printf("Ear Non manif A\n");
|
|
PosType 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;
|
|
np0=ep;
|
|
np1=en;
|
|
}
|
|
// Caso ear non manifold b
|
|
else if(ep.VFlip()==e1.v)
|
|
{
|
|
//printf("Ear Non manif B\n");
|
|
PosType 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;
|
|
np0=ep; // assign the two new
|
|
np1=en; // pos that denote the ears
|
|
}
|
|
else // caso standard // Now compute the new ears;
|
|
{
|
|
np0=ep;
|
|
np1=PosType(f,2,e1.v);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
};
|
|
|
|
//Ear with FillHoleMinimumWeight's quality policy
|
|
template<class MESH> class MinimumWeightEar : public TrivialEar<MESH>
|
|
{
|
|
public:
|
|
static float &DiedralWeight() { static float _dw=1.0; return _dw;}
|
|
typedef TrivialEar<MESH> TE;
|
|
typename MESH::ScalarType dihedralRad;
|
|
typename MESH::ScalarType aspectRatio;
|
|
const char * Dump() {
|
|
static char buf[200];
|
|
if(this->IsConcave()) sprintf(buf,"Dihedral -(deg) %6.2f Quality %6.2f\n",math::ToDeg(dihedralRad),aspectRatio);
|
|
else sprintf(buf,"Dihedral (deg) %6.2f Quality %6.2f\n",math::ToDeg(dihedralRad),aspectRatio);
|
|
return buf;
|
|
}
|
|
|
|
MinimumWeightEar(){}
|
|
//MinimumWeightEar(const PosType & ep) : TrivialEar<MESH>(ep)
|
|
MinimumWeightEar(const typename face::Pos<typename MESH::FaceType>& ep) : TrivialEar<MESH>(ep)
|
|
{
|
|
ComputeQuality();
|
|
}
|
|
|
|
// In the heap, by default, we retrieve the LARGEST value,
|
|
// so if we need the ear with minimal dihedral angle, we must reverse the sign of the comparison.
|
|
// The concave elements must be all in the end of the heap, sorted accordingly,
|
|
// So if only one of the two ear is Concave that one is always the minimum one.
|
|
// the pow function is here just to give a way to play with different weighting schemas, balancing in a different way
|
|
|
|
virtual inline bool operator < ( const MinimumWeightEar & c ) const
|
|
{
|
|
if(TE::IsConcave() == c.IsConcave())
|
|
{
|
|
return (pow((float)dihedralRad,(float)DiedralWeight())/aspectRatio) > (pow((float)c.dihedralRad,(float)DiedralWeight())/c.aspectRatio);
|
|
}
|
|
if(TE::IsConcave()) return true;
|
|
// assert(c.IsConcave());
|
|
return false;
|
|
}
|
|
|
|
// the real core of the whole hole filling strategy.
|
|
virtual void ComputeQuality()
|
|
{
|
|
//compute quality by (dihedral ancgle, area/sum(edge^2) )
|
|
typename MESH::CoordType n1=TE::e0.FFlip()->cN();
|
|
typename MESH::CoordType n2=TE::e1.FFlip()->cN();
|
|
|
|
dihedralRad = std::max(Angle(TE::n,n1),Angle(TE::n,n2));
|
|
aspectRatio = QualityFace(*this);
|
|
}
|
|
|
|
};
|
|
//Ear for selfintersection algorithm
|
|
template<class MESH> class SelfIntersectionEar : public MinimumWeightEar<MESH>
|
|
{
|
|
public:
|
|
typedef typename MESH::FaceType FaceType;
|
|
typedef typename MESH::FacePointer FacePointer;
|
|
typedef typename face::Pos<FaceType> PosType;
|
|
typedef typename MESH::ScalarType ScalarType;
|
|
typedef typename MESH::CoordType CoordType;
|
|
|
|
static std::vector<FacePointer> &AdjacencyRing()
|
|
{
|
|
static std::vector<FacePointer> ar;
|
|
return ar;
|
|
}
|
|
|
|
SelfIntersectionEar(){}
|
|
SelfIntersectionEar(const PosType & ep):MinimumWeightEar<MESH>(ep){}
|
|
|
|
virtual bool Close(PosType &np0, PosType &np1, FacePointer f)
|
|
{
|
|
PosType ep=this->e0; ep.FlipV(); ep.NextB(); ep.FlipV(); // he precedente a e0
|
|
PosType en=this->e1; en.NextB(); // he successivo a e1
|
|
//costruisco la faccia e poi testo, o copio o butto via.
|
|
(*f).V(0) = this->e0.VFlip();
|
|
(*f).V(1) = this->e0.v;
|
|
(*f).V(2) = this->e1.v;
|
|
|
|
(*f).FFp(0) = this->e0.f;
|
|
(*f).FFi(0) = this->e0.z;
|
|
(*f).FFp(1) = this->e1.f;
|
|
(*f).FFi(1) = this->e1.z;
|
|
(*f).FFp(2) = f;
|
|
(*f).FFi(2) = 2;
|
|
|
|
int a1, a2;
|
|
a1= this->e0.z;
|
|
a2= this->e1.z;
|
|
|
|
this->e0.f->FFp(this->e0.z)=f;
|
|
this->e0.f->FFi(this->e0.z)=0;
|
|
|
|
this->e1.f->FFp(this->e1.z)=f;
|
|
this->e1.f->FFi(this->e1.z)=1;
|
|
typename std::vector< FacePointer >::iterator it;
|
|
for(it = this->AdjacencyRing().begin();it!= this->AdjacencyRing().end();++it)
|
|
{
|
|
if(!(*it)->IsD())
|
|
if( tri::Clean<MESH>::TestIntersection(&(*f),*it))
|
|
{
|
|
this->e0.f->FFp(this->e0.z)= this->e0.f;
|
|
this->e0.f->FFi(this->e0.z)=a1;
|
|
|
|
this->e1.f->FFp(this->e1.z)= this->e1.f;
|
|
this->e1.f->FFi(this->e1.z)=a2;
|
|
return false;
|
|
}
|
|
}
|
|
//return ((TrivialEar<MESH> *)this)->Close(np0,np1,f);
|
|
this->e0.f->FFp(this->e0.z)= this->e0.f;
|
|
this->e0.f->FFi(this->e0.z)=a1;
|
|
|
|
this->e1.f->FFp(this->e1.z)=this->e1.f;
|
|
this->e1.f->FFi(this->e1.z)=a2;
|
|
|
|
bool ret=TrivialEar<MESH>::Close(np0,np1,f);
|
|
if(ret) AdjacencyRing().push_back(f);
|
|
return ret;
|
|
}
|
|
};
|
|
|
|
// 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>
|
|
class Hole
|
|
{
|
|
public:
|
|
typedef typename MESH::VertexType VertexType;
|
|
typedef typename MESH::VertexPointer VertexPointer;
|
|
typedef typename MESH::ScalarType ScalarType;
|
|
typedef typename MESH::FaceType FaceType;
|
|
typedef typename MESH::FacePointer FacePointer;
|
|
typedef typename MESH::FaceIterator FaceIterator;
|
|
typedef typename MESH::CoordType CoordType;
|
|
typedef typename vcg::Box3<ScalarType> Box3Type;
|
|
typedef typename face::Pos<FaceType> PosType;
|
|
|
|
public:
|
|
|
|
class Info
|
|
{
|
|
public:
|
|
Info(){}
|
|
Info(PosType const &pHole, int const pHoleSize, Box3<ScalarType> &pHoleBB)
|
|
{
|
|
p=pHole;
|
|
size=pHoleSize;
|
|
bb=pHoleBB;
|
|
}
|
|
|
|
PosType p;
|
|
int size;
|
|
Box3Type bb;
|
|
|
|
bool operator < (const Info & hh) const {return size < hh.size;}
|
|
|
|
ScalarType Perimeter()
|
|
{
|
|
ScalarType sum=0;
|
|
PosType ip = p;
|
|
do
|
|
{
|
|
sum+=Distance(ip.v->cP(),ip.VFlip()->cP());
|
|
ip.NextB();
|
|
}
|
|
while (ip != p);
|
|
return sum;
|
|
}
|
|
|
|
// Support function to test the validity of a single hole loop
|
|
// for now it test only that all the edges are border;
|
|
// The real test should check if all non manifold vertices
|
|
// are touched only by edges belonging to this hole loop.
|
|
bool CheckValidity()
|
|
{
|
|
if(!p.IsBorder())
|
|
return false;
|
|
PosType ip=p;ip.NextB();
|
|
for(;ip!=p;ip.NextB())
|
|
{
|
|
if(!ip.IsBorder())
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
|
|
template<class EAR>
|
|
static void FillHoleEar(MESH &m, Info &h ,int UBIT, std::vector<FacePointer *> &app,std::vector<FaceType > *vf =0)
|
|
{
|
|
//Aggiungo le facce e aggiorno il puntatore alla faccia!
|
|
FaceIterator f = tri::Allocator<MESH>::AddFaces(m, h.size-2, app);
|
|
assert(h.p.f >= &*m.face.begin());
|
|
assert(h.p.f <= &m.face.back());
|
|
assert(h.p.IsBorder());//test fondamentale altrimenti qualcosa s'e' rotto!
|
|
std::vector< EAR > H;
|
|
H.reserve(h.size);
|
|
int nmBit= VertexType::NewBitFlag(); // non manifoldness bit
|
|
|
|
//First loops around the hole to mark non manifold vertices.
|
|
PosType ip = h.p; // Pos iterator
|
|
do{
|
|
ip.V()->ClearUserBit(nmBit);
|
|
ip.V()->ClearV();
|
|
ip.NextB();
|
|
} while(ip!=h.p);
|
|
|
|
ip = h.p; // Re init the pos iterator for another loop (useless if everithing is ok!!)
|
|
do{
|
|
if(!ip.V()->IsV())
|
|
ip.V()->SetV(); // All the vertexes that are visited more than once are non manifold
|
|
else ip.V()->SetUserBit(nmBit);
|
|
ip.NextB();
|
|
} while(ip!=h.p);
|
|
|
|
PosType fp = h.p;
|
|
do{
|
|
EAR app = EAR(fp);
|
|
H.push_back( app );
|
|
//printf("Adding ear %s ",app.Dump());
|
|
fp.NextB();
|
|
assert(fp.IsBorder());
|
|
}while(fp!=h.p);
|
|
|
|
int cnt=h.size;
|
|
|
|
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() )
|
|
{
|
|
//printf("Front of the heap is %s", H.front().Dump());
|
|
pop_heap(H.begin(), H.end()); // retrieve the MAXIMUM value and put in the back;
|
|
PosType ep0,ep1;
|
|
EAR BestEar=H.back();
|
|
H.pop_back();
|
|
if(BestEar.IsUpToDate() && !BestEar.IsDegen(nmBit))
|
|
{
|
|
if((*f).HasPolyInfo()) (*f).Alloc(3);
|
|
if(BestEar.Close(ep0,ep1,&*f))
|
|
{
|
|
if(!ep0.IsNull()){
|
|
H.push_back(EAR(ep0));
|
|
push_heap( H.begin(), H.end());
|
|
}
|
|
if(!ep1.IsNull()){
|
|
H.push_back(EAR(ep1));
|
|
push_heap( H.begin(), H.end());
|
|
}
|
|
--cnt;
|
|
f->SetUserBit(UBIT);
|
|
if(vf != 0) (*vf).push_back(*f);
|
|
++f;
|
|
}
|
|
}//is update()
|
|
}//fine del while principale.
|
|
//tolgo le facce non utilizzate.
|
|
while(f!=m.face.end())
|
|
{
|
|
(*f).SetD();
|
|
++f;
|
|
m.fn--;
|
|
}
|
|
|
|
VertexType::DeleteBitFlag(nmBit); // non manifoldness bit
|
|
}
|
|
|
|
template<class EAR>
|
|
static int EarCuttingFill(MESH &m, int sizeHole,bool Selected = false, CallBackPos *cb=0)
|
|
{
|
|
std::vector< Info > vinfo;
|
|
int UBIT = GetInfo(m, Selected,vinfo);
|
|
|
|
typename std::vector<Info >::iterator ith;
|
|
//Info app;
|
|
int indCb=0;
|
|
int holeCnt=0;
|
|
std::vector<FacePointer *> vfp;
|
|
for(ith = vinfo.begin(); ith!= vinfo.end(); ++ith)
|
|
vfp.push_back( &(*ith).p.f );
|
|
|
|
for(ith = vinfo.begin(); ith!= vinfo.end(); ++ith)
|
|
{
|
|
indCb++;
|
|
if(cb) (*cb)(indCb*10/vinfo.size(),"Closing Holes");
|
|
if((*ith).size < sizeHole){
|
|
holeCnt++;
|
|
FillHoleEar< EAR >(m, *ith,UBIT,vfp);
|
|
}
|
|
}
|
|
|
|
FaceIterator fi;
|
|
for(fi = m.face.begin(); fi!=m.face.end(); ++fi)
|
|
{
|
|
if(!(*fi).IsD())
|
|
(*fi).ClearUserBit(UBIT);
|
|
}
|
|
return holeCnt;
|
|
}
|
|
|
|
// it returns the number of created holes.
|
|
|
|
template<class EAR>
|
|
static int EarCuttingIntersectionFill(MESH &m, int sizeHole, bool Selected = false, CallBackPos *cb=0)
|
|
{
|
|
std::vector<Info > vinfo;
|
|
int UBIT = GetInfo(m, Selected,vinfo);
|
|
std::vector<FaceType > vf;
|
|
PosType sp;
|
|
PosType ap;
|
|
typename std::vector<Info >::iterator ith;
|
|
|
|
// collect the face pointer that has to be updated by the various addfaces
|
|
std::vector<FacePointer *> vfpOrig;
|
|
for(ith = vinfo.begin(); ith!= vinfo.end(); ++ith)
|
|
vfpOrig.push_back( &(*ith).p.f );
|
|
|
|
int indCb=0;
|
|
int holeCnt=0;
|
|
for(ith = vinfo.begin(); ith!= vinfo.end(); ++ith)
|
|
{
|
|
indCb++;
|
|
if(cb) (*cb)(indCb*10/vinfo.size(),"Closing Holes");
|
|
if((*ith).size < sizeHole){
|
|
std::vector<FacePointer *> vfp;
|
|
holeCnt++;
|
|
vfp=vfpOrig;
|
|
EAR::AdjacencyRing().clear();
|
|
//Loops around the hole to collect the races .
|
|
PosType ip = (*ith).p;
|
|
do
|
|
{
|
|
PosType inp = ip;
|
|
do
|
|
{
|
|
inp.FlipE();
|
|
inp.FlipF();
|
|
EAR::AdjacencyRing().push_back(inp.f);
|
|
} while(!inp.IsBorder());
|
|
ip.NextB();
|
|
}while(ip != (*ith).p);
|
|
|
|
typename std::vector<FacePointer>::iterator fpi;
|
|
for(fpi=EAR::AdjacencyRing().begin();fpi!=EAR::AdjacencyRing().end();++fpi)
|
|
vfp.push_back( &*fpi );
|
|
|
|
FillHoleEar<EAR >(m, *ith,UBIT,vfp,&vf);
|
|
EAR::AdjacencyRing().clear();
|
|
}
|
|
}
|
|
FaceIterator fi;
|
|
for(fi = m.face.begin(); fi!=m.face.end(); ++fi)
|
|
{
|
|
if(!(*fi).IsD())
|
|
(*fi).ClearUserBit(UBIT);
|
|
}
|
|
return holeCnt;
|
|
}
|
|
|
|
|
|
|
|
static int GetInfo(MESH &m,bool Selected ,std::vector<Info >& VHI)
|
|
{
|
|
FaceIterator fi;
|
|
int UBIT = FaceType::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
|
|
{
|
|
for(int j =0; j<3 ; ++j)
|
|
{
|
|
if( face::IsBorder(*fi,j) && !(*fi).IsUserBit(UBIT) )
|
|
{//Trovato una faccia di bordo non ancora visitata.
|
|
(*fi).SetUserBit(UBIT);
|
|
PosType sp(&*fi, j, (*fi).V(j));
|
|
PosType fp=sp;
|
|
int holesize=0;
|
|
|
|
Box3Type hbox;
|
|
hbox.Add(sp.v->cP());
|
|
//printf("Looping %i : (face %i edge %i) \n", VHI.size(),sp.f-&*m.face.begin(),sp.z);
|
|
sp.f->SetUserBit(UBIT);
|
|
do
|
|
{
|
|
sp.f->SetUserBit(UBIT);
|
|
hbox.Add(sp.v->cP());
|
|
++holesize;
|
|
sp.NextB();
|
|
sp.f->SetUserBit(UBIT);
|
|
assert(sp.IsBorder());
|
|
}while(sp != fp);
|
|
|
|
//ho recuperato l'inofrmazione su tutto il buco
|
|
VHI.push_back( Info(sp,holesize,hbox) );
|
|
}
|
|
}//for sugli edge del triangolo
|
|
}//S & !S
|
|
}//!IsD()
|
|
}//for principale!!!
|
|
return UBIT;
|
|
}
|
|
|
|
//Minimum Weight Algorithm
|
|
class Weight
|
|
{
|
|
public:
|
|
|
|
Weight() { ang = 180; ar = FLT_MAX ;}
|
|
Weight( float An, float Ar ) { ang=An ; ar= Ar;}
|
|
~Weight() {}
|
|
|
|
float angle() const { return ang; }
|
|
float area() const { return ar; }
|
|
|
|
Weight operator+( const Weight & other ) const {return Weight( std::max( angle(), other.angle() ), area() + other.area());}
|
|
bool operator<( const Weight & rhs ) const {return ( angle() < rhs.angle() ||(angle() == rhs.angle() && area() < rhs.area())); }
|
|
|
|
private:
|
|
float ang;
|
|
float ar;
|
|
};
|
|
|
|
/*
|
|
\ / \/
|
|
v1*---------*v4
|
|
/ \ /
|
|
/ \ /
|
|
/ \ /
|
|
/ear \ /
|
|
*---------*-
|
|
| v3 v2\
|
|
*/
|
|
|
|
static float ComputeDihedralAngle(CoordType p1,CoordType p2,CoordType p3,CoordType p4)
|
|
{
|
|
CoordType n1 = NormalizedNormal(p1,p3,p2);
|
|
CoordType n2 = NormalizedNormal(p1,p2,p4);
|
|
return math::ToDeg(AngleN(n1,n2));
|
|
}
|
|
|
|
static bool existEdge(PosType pi,PosType pf)
|
|
{
|
|
PosType app = pi;
|
|
PosType appF = pi;
|
|
PosType tmp;
|
|
assert(pi.IsBorder());
|
|
appF.NextB();
|
|
appF.FlipV();
|
|
do
|
|
{
|
|
tmp = app;
|
|
tmp.FlipV();
|
|
if(tmp.v == pf.v)
|
|
return true;
|
|
app.FlipE();
|
|
app.FlipF();
|
|
|
|
if(app == pi)return false;
|
|
}while(app != appF);
|
|
return false;
|
|
}
|
|
|
|
static Weight computeWeight( int i, int j, int k,
|
|
std::vector<PosType > pv,
|
|
std::vector< std::vector< int > > v)
|
|
{
|
|
PosType pi = pv[i];
|
|
PosType pj = pv[j];
|
|
PosType pk = pv[k];
|
|
|
|
//test complex edge
|
|
if(existEdge(pi,pj) || existEdge(pj,pk)|| existEdge(pk,pi) )
|
|
{
|
|
return Weight();
|
|
}
|
|
// Return an infinite weight, if one of the neighboring patches
|
|
// could not be created.
|
|
if(v[i][j] == -1){return Weight();}
|
|
if(v[j][k] == -1){return Weight();}
|
|
|
|
//calcolo il massimo angolo diedrale, se esiste.
|
|
float angle = 0.0f;
|
|
PosType px;
|
|
if(i + 1 == j)
|
|
{
|
|
px = pj;
|
|
px.FlipE(); px.FlipV();
|
|
angle = std::max<float>(angle , ComputeDihedralAngle(pi.v->P(), pj.v->P(), pk.v->P(), px.v->P()) );
|
|
}
|
|
else
|
|
{
|
|
angle = std::max<float>( angle, ComputeDihedralAngle(pi.v->P(),pj.v->P(), pk.v->P(), pv[ v[i][j] ].v->P()));
|
|
}
|
|
|
|
if(j + 1 == k)
|
|
{
|
|
px = pk;
|
|
px.FlipE(); px.FlipV();
|
|
angle = std::max<float>(angle , ComputeDihedralAngle(pj.v->P(), pk.v->P(), pi.v->P(), px.v->P()) );
|
|
}
|
|
else
|
|
{
|
|
angle = std::max<float>( angle, ComputeDihedralAngle(pj.v->P(),pk.v->P(), pi.v->P(), pv[ v[j][k] ].v->P()));
|
|
}
|
|
|
|
if( i == 0 && k == (int)v.size() - 1)
|
|
{
|
|
px = pi;
|
|
px.FlipE(); px.FlipV();
|
|
angle = std::max<float>(angle , ComputeDihedralAngle(pk.v->P(), pi.v->P(), pj.v->P(),px.v->P() ) );
|
|
}
|
|
|
|
ScalarType area = ( (pj.v->P() - pi.v->P()) ^ (pk.v->P() - pi.v->P()) ).Norm() * 0.5;
|
|
|
|
return Weight(angle, area);
|
|
}
|
|
|
|
static void calculateMinimumWeightTriangulation(MESH &m, FaceIterator f,std::vector<PosType > vv )
|
|
{
|
|
std::vector< std::vector< Weight > > w; //matrice dei pesi minimali di ogni orecchio preso in conzideraione
|
|
std::vector< std::vector< int > > vi;//memorizza l'indice del terzo vertice del triangolo
|
|
|
|
//hole size
|
|
int nv = vv.size();
|
|
|
|
w.clear();
|
|
w.resize( nv, std::vector<Weight>( nv, Weight() ) );
|
|
|
|
vi.resize( nv, std::vector<int>( nv, 0 ) );
|
|
|
|
//inizializzo tutti i pesi possibili del buco
|
|
for ( int i = 0; i < nv-1; ++i )
|
|
w[i][i+1] = Weight( 0, 0 );
|
|
|
|
//doppio ciclo for per calcolare di tutti i possibili triangoli i loro pesi.
|
|
for ( int j = 2; j < nv; ++j )
|
|
{
|
|
for ( int i = 0; i + j < nv; ++i )
|
|
{
|
|
//per ogni triangolazione mi mantengo il minimo valore del peso tra i triangoli possibili
|
|
Weight minval;
|
|
|
|
//indice del vertice che da il peso minimo nella triangolazione corrente
|
|
int minIndex = -1;
|
|
|
|
//ciclo tra i vertici in mezzo a i due prefissati
|
|
for ( int m = i + 1; m < i + j; ++m )
|
|
{
|
|
Weight a = w[i][m];
|
|
Weight b = w[m][i+j];
|
|
Weight newval = a + b + computeWeight( i, m, i+j, vv, vi);
|
|
if ( newval < minval )
|
|
{
|
|
minval = newval;
|
|
minIndex = m;
|
|
}
|
|
}
|
|
w[i][i+j] = minval;
|
|
vi[i][i+j] = minIndex;
|
|
}
|
|
}
|
|
|
|
//Triangulate
|
|
int i, j;
|
|
i=0; j=nv-1;
|
|
|
|
triangulate(m,f, i, j, vi, vv);
|
|
|
|
while(f!=m.face.end())
|
|
{
|
|
(*f).SetD();
|
|
++f;
|
|
m.fn--;
|
|
}
|
|
}
|
|
|
|
|
|
static void triangulate(MESH &m, FaceIterator &f,int i, int j,
|
|
std::vector< std::vector<int> > vi, std::vector<PosType > vv)
|
|
{
|
|
if(i + 1 == j){return;}
|
|
if(i==j)return;
|
|
|
|
int k = vi[i][j];
|
|
|
|
if(k == -1) return;
|
|
|
|
//Setto i vertici
|
|
f->V(0) = vv[i].v;
|
|
f->V(1) = vv[k].v;
|
|
f->V(2) = vv[j].v;
|
|
|
|
f++;
|
|
triangulate(m,f,i,k,vi,vv);
|
|
triangulate(m,f,k,j,vi,vv);
|
|
}
|
|
|
|
static void MinimumWeightFill(MESH &m, int holeSize, bool Selected)
|
|
{
|
|
FaceIterator fi;
|
|
std::vector<PosType > vvi;
|
|
std::vector<FacePointer * > vfp;
|
|
|
|
std::vector<Info > vinfo;
|
|
typename std::vector<Info >::iterator VIT;
|
|
GetInfo(m, Selected,vinfo);
|
|
|
|
for(VIT = vinfo.begin(); VIT != vinfo.end();++VIT)
|
|
{
|
|
vvi.push_back(VIT->p);
|
|
}
|
|
|
|
typename std::vector<PosType >::iterator ith;
|
|
typename std::vector<PosType >::iterator ithn;
|
|
typename std::vector<VertexPointer >::iterator itf;
|
|
|
|
std::vector<PosType > app;
|
|
PosType ps;
|
|
std::vector<FaceType > tr;
|
|
std::vector<VertexPointer > vf;
|
|
|
|
for(ith = vvi.begin(); ith!= vvi.end(); ++ith)
|
|
{
|
|
tr.clear();
|
|
vf.clear();
|
|
app.clear();
|
|
vfp.clear();
|
|
|
|
ps = *ith;
|
|
getBoundHole(ps,app);
|
|
|
|
if(app.size() <= size_t(holeSize) )
|
|
{
|
|
typename std::vector<PosType >::iterator itP;
|
|
std::vector<FacePointer *> vfp;
|
|
|
|
for(ithn = vvi.begin(); ithn!= vvi.end(); ++ithn)
|
|
vfp.push_back(&(ithn->f));
|
|
|
|
for(itP = app.begin (); itP != app.end ();++itP)
|
|
vfp.push_back( &(*itP).f );
|
|
|
|
//aggiungo le facce
|
|
FaceIterator f = tri::Allocator<MESH>::AddFaces(m, (app.size()-2) , vfp);
|
|
|
|
calculateMinimumWeightTriangulation(m,f, app);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
static void getBoundHole (PosType sp,std::vector<PosType >&ret)
|
|
{
|
|
PosType fp = sp;
|
|
//take vertex around the hole
|
|
do
|
|
{
|
|
assert(fp.IsBorder());
|
|
ret.push_back(fp);
|
|
fp.NextB();
|
|
}while(sp != fp);
|
|
}
|
|
|
|
};//close class Hole
|
|
|
|
} // end namespace
|
|
}
|
|
#endif
|