vcglib: flag.h Source File

00001 /****************************************************************************
00002 * VCGLib                                                            o o     *
00003 * Visual and Computer Graphics Library                            o     o   *
00004 *                                                                _   O  _   *
00005 * Copyright(C) 2004                                                \/)\/    *
00006 * Visual Computing Lab                                            /\/|      *
00007 * ISTI - Italian National Research Council                           |      *
00008 *                                                                    \      *
00009 * All rights reserved.                                                      *
00010 *                                                                           *
00011 * This program is free software; you can redistribute it and/or modify      *   
00012 * it under the terms of the GNU General Public License as published by      *
00013 * the Free Software Foundation; either version 2 of the License, or         *
00014 * (at your option) any later version.                                       *
00015 *                                                                           *
00016 * This program is distributed in the hope that it will be useful,           *
00017 * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
00018 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
00019 * GNU General Public License (http://www.gnu.org/licenses/gpl.txt)          *
00020 * for more details.                                                         *
00021 *                                                                           *
00022 ****************************************************************************/
00023 /****************************************************************************
00024   History
00025 
00026 $Log: not supported by cvs2svn $
00027 Revision 1.20  2007/05/31 15:24:50  ponchio
00028 FIxed off-by-one error on FaceBorderFromNone.
00029 
00030 Revision 1.19  2007/05/22 15:19:42  cignoni
00031 Added VertexClear
00032 
00033 Revision 1.18  2007/01/30 18:49:23  tarini
00034 aggiunta la VertexBorderFromNone (flag bordo per vertici senza richiedere nulla)
00035 
00036 Revision 1.17  2006/08/31 13:11:12  marfr960
00037 corrected bounds of a vector scan
00038 
00039 Revision 1.16  2006/08/30 12:59:49  marfr960
00040 Added missing std:: to swap
00041 
00042 Revision 1.15  2006/08/30 06:50:07  cignoni
00043 Reverted to version 1.13. Version 1.14 was done on outdated version.
00044 
00045 Revision 1.13  2006/06/18 20:49:30  cignoni
00046 Added missing IsD tests
00047 
00048 Revision 1.12  2006/05/03 21:23:25  cignoni
00049 Corrected IsDeleted -> isD
00050 
00051 Revision 1.11  2005/12/02 00:09:12  cignoni
00052 Added assert(HasFlags) everywhere..
00053 
00054 Revision 1.10  2005/07/06 08:16:34  ganovelli
00055 set VertexBorderFromFace as static
00056 
00057 Revision 1.9  2005/06/10 15:07:23  cignoni
00058 Completed FaceBorderFromNone (and added a missing helper class)
00059 
00060 Revision 1.8  2005/04/01 13:04:55  fiorin
00061 Minor changes
00062 
00063 Revision 1.7  2004/09/14 19:49:43  ganovelli
00064 first compilation version
00065 
00066 Revision 1.6  2004/07/15 00:13:39  cignoni
00067 Better doxigen documentation
00068 
00069 Revision 1.5  2004/07/06 06:27:02  cignoni
00070 Added  FaceBorderFromVF
00071 
00072 Revision 1.4  2004/05/13 15:58:55  ganovelli
00073 function Clear added
00074 
00075 Revision 1.3  2004/03/12 15:22:19  cignoni
00076 Written some documentation and added to the trimes doxygen module
00077 
00078 Revision 1.2  2004/03/10 00:46:10  cignoni
00079 changed to the face::IsBorder() style
00080 
00081 Revision 1.1  2004/03/05 10:59:24  cignoni
00082 Changed name from plural to singular (normals->normal)
00083 
00084 Revision 1.1  2004/03/04 00:37:56  cignoni
00085 First working version!
00086 
00087 
00088 ****************************************************************************/
00089 #ifndef __VCG_TRI_UPDATE_FLAGS
00090 #define __VCG_TRI_UPDATE_FLAGS
00091 
00092 #include <vcg/simplex/face/pos.h>
00093 
00094 namespace vcg {
00095 namespace tri {
00097 
00099 
00101 
00106 template <class UpdateMeshType>
00107 class UpdateFlags
00108 {
00109 
00110 public:
00111 typedef UpdateMeshType MeshType; 
00112 typedef vcg::face::Pos<typename UpdateMeshType::FaceType> PosType;
00113 typedef typename MeshType::ScalarType     ScalarType;
00114 typedef typename MeshType::VertexType     VertexType;
00115 typedef typename MeshType::VertexPointer  VertexPointer;
00116 typedef typename MeshType::VertexIterator VertexIterator;
00117 typedef typename MeshType::FaceType       FaceType;
00118 typedef typename MeshType::FacePointer    FacePointer;
00119 typedef typename MeshType::FaceIterator   FaceIterator;
00120 
00122 
00123 static void Clear(MeshType &m)
00124 {
00125   assert(HasPerFaceFlags(m));
00126         FaceIterator fi;
00127         VertexIterator vi;
00128         for(fi=m.face.begin(); fi!=m.face.end(); ++fi)
00129                 (*fi).Flags() = 0;
00130         for(vi=m.vert.begin(); vi!=m.vert.end(); ++vi)
00131                 (*vi).Flags() = 0;
00132 }
00133 
00134 static void VertexClear(MeshType &m, unsigned int FlagMask = 0xffffffff)
00135 {
00136         VertexIterator vi;
00137         int andMask = ~FlagMask;
00138         for(vi=m.vert.begin(); vi!=m.vert.end(); ++vi)
00139                 if(!(*vi).IsD()) (*vi).Flags() &= andMask ;
00140 }
00141 
00142 static void FaceClear(MeshType &m, unsigned int FlagMask = 0xffffffff)
00143 {
00144         FaceIterator fi;
00145         int andMask = ~FlagMask;
00146         for(fi=m.face.begin(); fi!=m.face.end(); ++fi)
00147                 if(!(*fi).IsD()) (*fi).Flags() &= andMask ;
00148 }
00149 
00150 static void VertexSet(MeshType &m, unsigned int FlagMask)
00151 {
00152         VertexIterator vi;
00153         for(vi=m.vert.begin(); vi!=m.vert.end(); ++vi)
00154                 if(!(*vi).IsD()) (*vi).Flags() |= FlagMask ;
00155 }
00156 
00157 static void FaceSet(MeshType &m, unsigned int FlagMask)
00158 {
00159         FaceIterator fi;
00160   for(fi=m.face.begin(); fi!=m.face.end(); ++fi)
00161                 if(!(*fi).IsD()) (*fi).Flags() |= FlagMask ;
00162 }
00163 
00164 
00165 
00166 static void VertexClearV(MeshType &m) { VertexClear(m,VertexType::VISITED);}
00167 static void VertexClearB(MeshType &m) { VertexClear(m,VertexType::BORDER);}
00168 static void FaceClearV(MeshType &m) { FaceClear(m,FaceType::VISITED);}
00169 static void FaceClearB(MeshType &m) { FaceClear(m,FaceType::BORDER012);}
00170 static void FaceClearF(MeshType &m) { FaceClear(m,FaceType::FAUX012);}
00171 
00172 static void VertexSetV(MeshType &m) { VertexSet(m,VertexType::VISITED);}
00173 static void VertexSetB(MeshType &m) { VertexSet(m,VertexType::BORDER);}
00174 static void FaceSetV(MeshType &m) { FaceSet(m,FaceType::VISITED);}
00175 static void FaceSetB(MeshType &m) { FaceSet(m,FaceType::BORDER);}
00176 static void FaceSetF(MeshType &m) { FaceSet(m,FaceType::FAUX012);}
00177 
00179 
00183 static void FaceBorderFromFF(MeshType &m)
00184 {
00185   assert(HasPerFaceFlags(m));
00186 //      const int BORDERFLAG[3]={FaceType::BORDER0,FaceType::BORDER1,FaceType::BORDER2};
00187         FaceIterator fi;
00188         for(fi=m.face.begin();fi!=m.face.end();++fi)if(!(*fi).IsD())
00189                 for(int j=0;j<3;++j)
00190                 {
00191                         //if(!(*fi).IsManifold(j)) (*fi).SetCF(j);
00192                         //else 
00193       if(face::IsBorder(*fi,j)) (*fi).SetB(j);
00194                                          else (*fi).ClearB(j);
00195                 }
00196 }
00197 
00198 
00199 static void FaceBorderFromVF(MeshType &m)
00200 {
00201   assert(HasPerFaceFlags(m));
00202         VertexIterator vi;
00203   assert(m.HasVFTopology());
00204 
00205   int visitedBit=VertexType::NewBitFlag();
00206 
00207         // Calcolo dei bordi
00208   // per ogni vertice vi si cercano i vertici adiacenti che sono toccati da una faccia sola
00209         // (o meglio da un numero dispari di facce)
00210 
00211                 const int BORDERFLAG[3]={FaceType::BORDER0, FaceType::BORDER1, FaceType::BORDER2};
00212                 
00213                 for(vi=m.vert.begin();vi!=m.vert.end();++vi)
00214                         if(!(*vi).IsD())
00215                                 {
00216                                         for(face::VFIterator<FaceType> vfi(&*vi) ; !vfi.End(); ++vfi )
00217           {
00218                                   vfi.f->V1(vfi.z)->ClearUserBit(visitedBit);
00219                                                                 vfi.f->V2(vfi.z)->ClearUserBit(visitedBit);
00220           }
00221                                         for(face::VFIterator<FaceType> vfi(&*vi) ; !vfi.End(); ++vfi )
00222           {
00223             if(vfi.f->V1(vfi.z)->IsUserBit(visitedBit))  vfi.f->V1(vfi.z)->ClearUserBit(visitedBit);
00224                                                                                                                                                     else vfi.f->V1(vfi.z)->SetUserBit(visitedBit);
00225                                                 if(vfi.f->V2(vfi.z)->IsUserBit(visitedBit))  vfi.f->V2(vfi.z)->ClearUserBit(visitedBit);
00226                                                                                                                                                     else vfi.f->V2(vfi.z)->SetUserBit(visitedBit);
00227                                         }
00228           for(face::VFIterator<FaceType> vfi(&*vi) ; !vfi.End(); ++vfi )
00229           {
00230                                 if(vfi.f->V(vfi.z)< vfi.f->V1(vfi.z)  &&  vfi.f->V1(vfi.z)->IsUserBit(visitedBit)) 
00231                                                 vfi.f->Flags() |= BORDERFLAG[vfi.z];
00232                                 if(vfi.f->V(vfi.z)< vfi.f->V2(vfi.z)  &&  vfi.f->V2(vfi.z)->IsUserBit(visitedBit)) 
00233                                                 vfi.f->Flags() |= BORDERFLAG[(vfi.z+2)%3];
00234           }
00235                         }       
00236                 VertexType::DeleteBitFlag(VertexType::LastBitFlag());
00237 }
00238 
00239  
00240 class EdgeSorter
00241 {
00242 public:
00243         
00244         VertexPointer v[2];             // Puntatore ai due vertici (Ordinati)
00245         FacePointer    f;                               // Puntatore alla faccia generatrice
00246         int      z;                             // Indice dell'edge nella faccia
00247 
00248   EdgeSorter() {} // Nothing to do
00249 
00250 
00251 void Set( const FacePointer pf, const int nz )
00252 {
00253         assert(pf!=0);
00254         assert(nz>=0);
00255         assert(nz<3);
00256         
00257         v[0] = pf->V(nz);
00258         v[1] = pf->V((nz+1)%3);
00259         assert(v[0] != v[1]);
00260 
00261         if( v[0] > v[1] ) std::swap(v[0],v[1]);
00262         f    = pf;
00263         z    = nz;
00264 }
00265 
00266 inline bool operator <  ( const EdgeSorter & pe ) const {
00267         if( v[0]<pe.v[0] ) return true;
00268         else if( v[0]>pe.v[0] ) return false;
00269         else return v[1] < pe.v[1];
00270 }
00271 
00272 inline bool operator == ( const EdgeSorter & pe ) const
00273 {
00274         return v[0]==pe.v[0] && v[1]==pe.v[1];
00275 }
00276 inline bool operator != ( const EdgeSorter & pe ) const
00277 {
00278         return v[0]!=pe.v[0] || v[1]!=pe.v[1];
00279 }
00280 
00281 };
00282 
00283 
00284 // versione minimale che non calcola i complex flag.
00285 static void VertexBorderFromNone(MeshType &m)
00286 {
00287   assert(HasPerVertexFlags(m));
00288         std::vector<EdgeSorter> e;
00289         typename UpdateMeshType::FaceIterator pf;
00290         typename std::vector<EdgeSorter>::iterator p;
00291 
00292         if( m.fn == 0 ) 
00293                 return;
00294 
00295         e.resize(m.fn*3);                                                               // Alloco il vettore ausiliario
00296         p = e.begin();
00297         for(pf=m.face.begin();pf!=m.face.end();++pf)                    // Lo riempio con i dati delle facce
00298                 if( ! (*pf).IsD() )
00299                         for(int j=0;j<3;++j)
00300                         {
00301                                 (*p).Set(&(*pf),j);
00302                                 (*pf).ClearB(j);
00303                                 ++p;
00304                         }
00305         assert(p==e.end());
00306         sort(e.begin(), e.end());                                                       // Lo ordino per vertici
00307         
00308         typename std::vector<EdgeSorter>::iterator pe,ps;
00309         for(ps = e.begin(), pe = e.begin(); pe < e.end(); ++pe) // Scansione vettore ausiliario
00310         {
00311                 if( pe==e.end() ||  *pe != *ps )                                        // Trovo blocco di edge uguali
00312                 {
00313                         if(pe-ps==1)    {       
00314                                         ps->v[0]->SetB();
00315                                         ps->v[1]->SetB();
00316                         } else
00317                         if(pe-ps!=2)  {  // not twomanyfold!
00318                                 for(;ps!=pe;++ps) {
00319                                                 ps->v[0]->SetB(); // Si settano border anche i complex.
00320                                                 ps->v[1]->SetB();
00321         }
00322                         } 
00323                         ps = pe;
00324                 }
00325         }
00326 }
00327 
00331 static void FaceProjection(MeshType &m)
00332 {
00333         FaceIterator fi;
00334         for(fi=m.face.begin();fi!=m.face.end();++fi)                    // Lo riempio con i dati delle facce
00335                 if( ! (*fi).IsD() )
00336                 {
00337                         ScalarType nx = math::Abs((*fi).cN()[0]);
00338                         ScalarType ny = math::Abs((*fi).cN()[1]);
00339                         ScalarType nz = math::Abs((*fi).cN()[2]);
00340                         if(nx>ny && nx>nz) { (*fi).Flags() |= FaceType::NORMX; }
00341                         else if(ny>nz)     { (*fi).Flags() |= FaceType::NORMY; }
00342                         else               { (*fi).Flags() |= FaceType::NORMZ; }
00343                 }
00344 }
00345 
00348 static void FaceBorderFromNone(MeshType &m)
00349 {
00350   assert(HasPerFaceFlags(m));
00351         std::vector<EdgeSorter> e;
00352         typename UpdateMeshType::FaceIterator pf;
00353         typename std::vector<EdgeSorter>::iterator p;
00354 
00355         for(VertexIterator v=m.vert.begin();v!=m.vert.end();++v)
00356                 (*v).ClearB();
00357                 
00358         if( m.fn == 0 ) 
00359                 return;
00360 
00361         FaceIterator fi;
00362         int n_edges = 0;
00363         for(fi = m.face.begin(); fi != m.face.end(); ++fi) if(! (*fi).IsD()) n_edges+=(*fi).VN();
00364         e.resize(n_edges);
00365 
00366         p = e.begin();
00367         for(pf=m.face.begin();pf!=m.face.end();++pf)                    // Lo riempio con i dati delle facce
00368                 if( ! (*pf).IsD() )
00369                         for(int j=0;j<(*pf).VN();++j)
00370                         {
00371                                 (*p).Set(&(*pf),j);
00372                                 (*pf).ClearB(j);
00373                                 ++p;
00374                         }
00375         assert(p==e.end());
00376         sort(e.begin(), e.end());                                                       // Lo ordino per vertici
00377          
00378         typename std::vector<EdgeSorter>::iterator pe,ps;
00379         ps = e.begin();pe=e.begin();
00380         do
00381         {        
00382                 if( pe==e.end() ||  *pe != *ps )                                        // Trovo blocco di edge uguali
00383                 {
00384                         if(pe-ps==1)    {       
00385                                         ps->f->SetB(ps->z);
00386                         } else
00387                         if(pe-ps!=2)  {  // Caso complex!!
00388                                 for(;ps!=pe;++ps)
00389                                                 ps->f->SetB(ps->z); // Si settano border anche i complex.
00390                         } 
00391                         ps = pe;
00392                 }
00393                 if(pe==e.end()) break;
00394                 ++pe;
00395         } while(true);
00396 //      TRACE("found %i border (%i complex) on %i edges\n",nborder,ncomplex,ne);
00397 }
00398 
00400 static void VertexBorderFromFace(MeshType &m)
00401 {
00402   assert(HasPerFaceFlags(m));
00403         typename MeshType::VertexIterator v;
00404         typename MeshType::FaceIterator f;
00405 
00406         for(v=m.vert.begin();v!=m.vert.end();++v)
00407                 (*v).ClearB();
00408 
00409         for(f=m.face.begin();f!=m.face.end();++f)
00410     if(!(*f).IsD())
00411             {
00412                     for(int z=0;z<(*f).VN();++z)
00413                             if( (*f).IsB(z) )
00414                             {
00415                                     (*f).V(z)->SetB();
00416                                     (*f).V((*f).Next(z))->SetB();
00417                             }
00418             }
00419 }
00420 //
00421 static void FaceFauxCrease(MeshType &m,float AngleRad)
00422 {
00423   assert(HasPerFaceFlags(m));
00424   assert(HasFFAdjacency(m));
00425 
00426   typename MeshType::FaceIterator f;
00427 
00428   //initially everything is faux (e.g all internal)
00429   FaceSetF(m);
00430   for(f=m.face.begin();f!=m.face.end();++f)
00431   {
00432     if(!(*f).IsD())
00433     {
00434       for(int z=0;z<(*f).VN();++z)
00435       {
00436         if( face::IsBorder(*f,z) )  (*f).ClearF(z);
00437         else
00438         {
00439           if(Angle((*f).N(), (*f).FFp(z)->N()) > AngleRad)
00440             (*f).ClearF(z);
00441         }
00442       }
00443     }
00444   }
00445 }
00446 
00447 }; // end class
00448 
00449 }       // End namespace tri
00450 }       // End namespace vcg
00451 
00452 
00453 #endif