/**************************************************************************** * 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 #include #include #include #include #include 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 TrivialEar { public: typedef typename MESH::FaceType FaceType; typedef typename MESH::FacePointer FacePointer; typedef typename face::Pos 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* vf; TrivialEar(){} TrivialEar(const PosType & ep) { e0=ep; assert(e0.IsBorder()); e1=e0; e1.NextB(); n=vcg::Normal(*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 MinimumWeightEar : public TrivialEar { public: static float &DiedralWeight() { static float _dw=1.0; return _dw;} typedef TrivialEar 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(ep) MinimumWeightEar(const typename face::Pos& ep) : TrivialEar(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 SelfIntersectionEar : public MinimumWeightEar { public: typedef typename MESH::FaceType FaceType; typedef typename MESH::FacePointer FacePointer; typedef typename face::Pos PosType; typedef typename MESH::ScalarType ScalarType; typedef typename MESH::CoordType CoordType; static std::vector &AdjacencyRing() { static std::vector ar; return ar; } SelfIntersectionEar(){} SelfIntersectionEar(const PosType & ep):MinimumWeightEar(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::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 *)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::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 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 Box3Type; typedef typename face::Pos PosType; public: class Info { public: Info(){} Info(PosType const &pHole, int const pHoleSize, Box3 &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 static void FillHoleEar(MESH &m, Info &h ,int UBIT, std::vector &app,std::vector *vf =0) { //Aggiungo le facce e aggiorno il puntatore alla faccia! FaceIterator f = tri::Allocator::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 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::iterator ith; //Info app; int indCb=0; int holeCnt=0; std::vector 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 static int EarCuttingIntersectionFill(MESH &m, int sizeHole, bool Selected = false, CallBackPos *cb=0) { std::vector vinfo; int UBIT = GetInfo(m, Selected,vinfo); std::vector vf; PosType sp; PosType ap; typename std::vector::iterator ith; // collect the face pointer that has to be updated by the various addfaces std::vector 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 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::iterator fpi; for(fpi=EAR::AdjacencyRing().begin();fpi!=EAR::AdjacencyRing().end();++fpi) vfp.push_back( &*fpi ); FillHoleEar(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& 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 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(angle , ComputeDihedralAngle(pi.v->P(), pj.v->P(), pk.v->P(), px.v->P()) ); } else { angle = std::max( 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(angle , ComputeDihedralAngle(pj.v->P(), pk.v->P(), pi.v->P(), px.v->P()) ); } else { angle = std::max( 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(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 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( nv, Weight() ) ); vi.resize( nv, std::vector( 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 > vi, std::vector 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 vvi; std::vector vfp; std::vector vinfo; typename std::vector::iterator VIT; GetInfo(m, Selected,vinfo); for(VIT = vinfo.begin(); VIT != vinfo.end();++VIT) { vvi.push_back(VIT->p); } typename std::vector::iterator ith; typename std::vector::iterator ithn; typename std::vector::iterator itf; std::vector app; PosType ps; std::vector tr; std::vector 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::iterator itP; std::vector 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::AddFaces(m, (app.size()-2) , vfp); calculateMinimumWeightTriangulation(m,f, app); } } } static void getBoundHole (PosType sp,std::vector&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