vcglib: pos.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.32  2007/10/17 19:46:50  cignoni
00028 Added I() access function for the z member to the pos
00029 
00030 Revision 1.31  2007/05/28 14:09:41  fiorin
00031 Added Set method which takes a face pointer and a vertex pointer.
00032 
00033 Revision 1.30  2007/05/16 15:11:32  fiorin
00034 Replaced ambigous StarSize method with NumberOfIncidentVertices and NumberOfIncidentFaces
00035 
00036 Revision 1.29  2007/04/20 12:40:31  cignoni
00037 Corrected  V() operator. It was plainly wrong. Luckly enough it was not very used
00038 
00039 Revision 1.28  2007/01/11 10:37:08  cignoni
00040 Added include assert.h
00041 
00042 Revision 1.27  2007/01/02 10:06:53  giec
00043 Added access functions F()
00044 
00045 Revision 1.26  2006/12/29 13:13:00  giec
00046 Corrected wrong assert in V(i) access function
00047 
00048 Revision 1.25  2006/12/04 16:06:12  cignoni
00049 Added FFlip() and const VFlip() operators
00050 
00051 Revision 1.24  2006/11/13 01:57:23  cignoni
00052 Added a missing prototype to ismanifold
00053 
00054 Revision 1.23  2006/11/09 17:22:56  cignoni
00055 Added ismanifold
00056 
00057 Revision 1.22  2006/10/07 14:24:26  cignoni
00058 Explained the use of V() operator of a pos
00059 
00060 Revision 1.21  2006/09/25 09:57:49  cignoni
00061 Better comment on usage of VF iterators
00062 
00063 Revision 1.20  2005/12/15 11:57:48  corsini
00064 Replace Pos<FaceType> with PosType
00065 
00066 Revision 1.19  2005/12/15 11:19:00  corsini
00067 Fix operators
00068 
00069 Revision 1.18  2005/12/15 10:53:16  corsini
00070 Add constructor which takes as input a face and a vertex
00071 
00072 Revision 1.17  2005/10/16 23:30:39  ponchio
00073 IsBorder(...) declaration needed.
00074 
00075 Revision 1.16  2005/10/13 09:29:10  cignoni
00076 Removed the reference to Deprecated f->IsBorder(i) now everyone should use IsBorder(*f,i);
00077 
00078 Revision 1.15  2005/01/03 11:22:31  cignoni
00079 Added better documentation (with an example and the V0 V1 V2 access members
00080 
00081 Revision 1.14  2004/10/28 00:50:48  cignoni
00082 Better Doxygen documentation
00083 
00084 Revision 1.13  2004/10/18 17:14:42  ganovelli
00085 error FFP -> FFp
00086 
00087 Revision 1.12  2004/09/14 19:46:10  ganovelli
00088 constructor added
00089 
00090 Revision 1.11  2004/08/25 15:15:27  ganovelli
00091 minor changes to comply gcc compiler (typename's and stuff)
00092 
00093 Revision 1.10  2004/07/27 09:47:49  cignoni
00094 Added V() access function instead of V(0)
00095 
00096 Revision 1.9  2004/07/18 07:45:30  cignoni
00097 Removed two const modifiers from the VFIterator
00098 
00099 Revision 1.8  2004/07/15 12:03:07  ganovelli
00100 minor changes
00101 
00102 Revision 1.7  2004/07/15 11:28:44  ganovelli
00103 basefacetype to facetype
00104 
00105 Revision 1.6  2004/07/06 06:25:44  cignoni
00106 changed the VFIterator ++ to return a facepointer instead of a bool
00107 
00108 Revision 1.5  2004/06/02 16:25:45  ganovelli
00109 changed F(.. to FFp
00110 changed Z(   to FFi(
00111 
00112 Revision 1.4  2004/05/10 15:21:47  cignoni
00113 Added a constructor without vertex pointer
00114 
00115 Revision 1.3  2004/05/10 13:41:57  cignoni
00116 Added VFIterator
00117 
00118 Revision 1.2  2004/03/12 15:22:28  cignoni
00119 Written some documentation and added to the trimes doxygen module
00120 
00121 Revision 1.1  2004/03/10 08:32:30  cignoni
00122 Initial commit
00123 
00124 
00125 ****************************************************************************/
00126 
00132 #ifndef __VCG_FACE_POS
00133 #define __VCG_FACE_POS
00134 
00135 #include <assert.h>
00136 
00137 namespace vcg {
00138 namespace face {
00139 
00142 
00143 // Needed Prototypes (pos is include before topology)
00144 template <class FaceType>
00145 bool IsBorder(FaceType const & f,  const int j );
00146 template <class FaceType>
00147 bool IsManifold(FaceType const & f,  const int j );
00148 
00157 template <class FaceType> 
00158 class Pos
00159 {
00160 public:
00161 
00163         typedef typename FaceType::VertexType VertexType;
00165         typedef Pos<FaceType> PosType;
00167         typedef typename VertexType::ScalarType ScalarType;
00168         
00170         typename FaceType::FaceType *f;
00172         int z;
00174         VertexType *v;
00175 
00177         Pos(){}
00179         Pos(FaceType * const fp, int const zp, VertexType * const vp){f=fp; z=zp; v=vp;}
00180         Pos(FaceType * const fp, int const zp){f=fp; z=zp; v=f->V(zp);}
00181         Pos(FaceType * const fp, VertexType * const vp)
00182         {
00183                 f = fp;
00184                 v = vp;
00185                 for(int i = 0; i < f->VN(); ++i)
00186                         if (f->V(i) == v) { z = f->Prev(i); break;}
00187         }
00188 
00189         // Official Access functions functions 
00190    VertexType *& V(){ return v; }
00191          int         & E(){ return z; }
00192          FaceType   *& F(){ return f; }
00193 
00194 
00195 // Returns the face index of the vertex inside the face.
00196 // Note that this is DIFFERENT from using the z member that denotes the edge index inside the face. 
00197 // It should holds that Vind != (z+1)%3   &&   Vind == z || Vind = z+2%3
00198    int VInd()
00199          {
00200                  for(int i = 0; i < f->VN(); ++i) if(v==f->V(i)) return i;
00201                  assert(0);
00202                  return -1;
00203          }
00204 
00205   
00207         inline bool operator == ( PosType const & p ) const {
00208                         return (f==p.f && z==p.z && v==p.v);
00209         } 
00210 
00212         inline bool operator != ( PosType const & p ) const {
00213                         return (f!=p.f || z!=p.z || v!=p.v);
00214         } 
00216         inline bool operator <= ( PosType const & p) const {
00217                 return  (f!=p.f)?(f<f.p):
00218                                                 (z!=p.z)?(z<p.z):
00219                                                 (v<=p.v);
00220         }       
00221 
00223         inline FaceType & operator = ( const FaceType & h ){
00224                 f=h.f;
00225                 z=h.z;
00226                 v=h.v;
00227                 return *this;
00228                 }
00230         void SetNull(){
00231                 f=0;
00232                 v=0;
00233                 z=-1;
00234         }
00236         bool IsNull() const {
00237                 return f==0 || v==0 || z<0;
00238         }
00239 
00240         //Cambia Faccia lungo z
00241         // e' uguale a FlipF solo che funziona anche per non manifold.
00243         void NextF()
00244         {
00245                 FaceType * t = f;
00246                 f = t->FFp(z);
00247                 z = t->FFi(z);
00248         }
00249   
00250                 // Paolo Cignoni 19/6/99
00251                 // Si muove sulla faccia adiacente a f, lungo uno spigolo che
00252                 // NON e' j, e che e' adiacente a v 
00253                 // in questo modo si scandiscono tutte le facce incidenti in un 
00254                 // vertice f facendo Next() finche' non si ritorna all'inizio
00255                 // Nota che sul bordo rimbalza, cioe' se lo spigolo !=j e' di bordo
00256                 // restituisce sempre la faccia f ma con nj che e' il nuovo spigolo di bordo 
00257                 // vecchi parametri:            FaceType * & f, VertexType * v, int & j
00258 
00260         void NextE()
00261         {
00262                 assert( f->V(z)==v || f->V(f->Next(z))==v ); // L'edge j deve contenere v
00263                 FlipE();
00264                 FlipF();
00265                 assert( f->V(z)==v || f->V(f->Next(z))==v ); 
00266         }
00267         // Cambia edge mantenendo la stessa faccia e lo stesso vertice
00269         void FlipE()
00270         {
00271                 assert(f->V(f->Prev(z))!=v && (f->V(f->Next(z))==v || f->V((z+0)%f->VN())==v));
00272                 if(f->V(f->Next(z))==v) z=f->Next(z);
00273                 else z= f->Prev(z);
00274                 assert(f->V(f->Prev(z))!=v && (f->V(f->Next(z))==v || f->V((z))==v));
00275         }
00276 
00277         // Cambia Faccia mantenendo lo stesso vertice e lo stesso edge
00278         // Vale che he.flipf.flipf= he
00279         // Se l'he e' di bordo he.flipf()==he
00280         // Si puo' usare SOLO se l'edge e' 2manifold altrimenti 
00281         // si deve usare nextf
00282 
00284         void FlipF()
00285         {
00286                 assert( f->FFp(z)->FFp(f->FFi(z))==f );  // two manifoldness check
00287                 assert(f->V(f->Prev(z))!=v && (f->V(f->Next(z))==v || f->V((z))==v));
00288                 FaceType *nf=f->FFp(z);
00289                 int nz=f->FFi(z);
00290                 assert(nf->V(f->Prev(nz))!=v && (nf->V(f->Next(nz))==v || nf->V((nz))==v));
00291                 f=nf;
00292                 z=nz;
00293                 assert(f->V(f->Prev(z))!=v && (f->V(f->Next(z))==v || f->V(z)==v));
00294         }
00295 
00297         void FlipV()
00298         {
00299                 assert(f->V(f->Prev(z))!=v && (f->V(f->Next(z))==v || f->V(z)==v));
00300                 
00301                 if(f->V(f->Next(z))==v)
00302                         v=f->V(z);
00303                 else
00304                         v=f->V(f->Next(z));
00305 
00306                 assert(f->V(f->Prev(z))!=v && (f->V(f->Next(z))==v || f->V(z)==v));
00307         }
00308         
00309         // return the vertex that it should have if we make FlipV;
00310         VertexType *VFlip()
00311         {
00312                 assert(f->V(f->Prev(z))!=v && (f->V(f->Next(z))==v || f->V(z)==v));
00313                 if(f->V(f->Next(z))==v) return f->V(z);
00314                                                                 else                    return f->V(f->Next(z));
00315         }
00316 
00317   // return the vertex that it should have if we make FlipV;
00318         const VertexType *VFlip() const 
00319         {
00320                 assert(f->cV(f->Prev(z))!=v && (f->cV(f->Next(z))==v || f->cV(z)==v));
00321                 if(f->cV(f->Next(z))==v)        return f->cV(z);
00322                                                                 else                    return f->cV(f->Next(z));
00323         }
00324 
00325   // return the face that it should have if we make FlipF;
00326         const FaceType *FFlip() const 
00327         {
00328                 assert( f->FFp(z)->FFp(f->FFi(z))==f );
00329                 assert(f->V(f->Prev(z))!=v && (f->V(f->Next(z))==v || f->V((z+0)%f->VN())==v));
00330                 FaceType *nf=f->FFp(z);
00331                 return nf;
00332   }
00333 
00334 
00335         // Trova il prossimo half-edge di bordo (nhe)
00336         // tale che 
00337         // --nhe.f adiacente per vertice a he.f
00338         // --nhe.v adiacente per edge di bordo a he.v 
00339         // l'idea e' che se he e' un half edge di bordo 
00340         // si puo scorrere tutto un bordo facendo 
00341         //
00342         //              hei=he;
00343         //              do
00344         //                      hei.Nextb()
00345         //              while(hei!=he);
00346         
00348         void NextB( )
00349         {
00350                 assert(f->V(f->Prev(z))!=v && (f->V(f->Next(z))==v || f->V(z)==v));
00351                 assert(f->FFp(z)==f); // f is border along j
00352         // Si deve cambiare faccia intorno allo stesso vertice v
00353         //finche' non si trova una faccia di bordo.
00354                 do
00355                         NextE();
00356       while(!IsBorder());
00357                 
00358                 // L'edge j e' di bordo e deve contenere v
00359                 assert(IsBorder() &&( f->V(z)==v || f->V(f->Next(z))==v )); 
00360                 
00361                 FlipV();
00362                 assert(f->V(f->Prev(z))!=v && (f->V(f->Next(z))==v || f->V(z)==v));
00363                 assert(f->FFp(z)==f); // f is border along j
00364         }
00365 
00367         bool IsBorder()
00368         {
00369     return face::IsBorder(*f,z);
00370         }
00371 
00372   bool IsManifold()
00373         {
00374     return face::IsManifold(*f,z);
00375         }
00376 
00380         int NumberOfIncidentVertices()
00381         {
00382                 int  count               = 0;
00383                 bool on_border = false;
00384                 CheckIncidentFaces(count, on_border);
00385                 if(on_border) return (count/2)+1;
00386                 else                                    return count;
00387         }
00388 
00392         int NumberOfIncidentFaces()
00393         {
00394                 int  count               = 0;
00395                 bool on_border = false;
00396                 CheckIncidentFaces(count, on_border);
00397                 if(on_border) return count/2;
00398                 else                                    return count;
00399         }
00400 
00406         void Set(FaceType  * const fp, int const zp,  VertexType  * const vp)
00407         {
00408                 f=fp;z=zp;v=vp;
00409                 assert(f->V(f->Prev(z))!=v && (f->V(f->Next(z))==v || f->V(z)==v));
00410         }
00411         
00412         void Set(FaceType  * const pFace, VertexType  * const pVertex)
00413         {
00414                 f = pFace;
00415                 v = pVertex;
00416                 for(int i  = 0; i < f->VN(); ++i) if(f->V(i) == v ) {z = f->Prev(i);break;}
00417         }
00418 
00419         void Assert()
00420         #ifdef _DEBUG
00421         {
00422                 FaceType ht=*this;
00423                 ht.FlipF();
00424                 ht.FlipF();
00425                 assert(ht==*this);
00426 
00427                 ht.FlipE();
00428                 ht.FlipE();
00429                 assert(ht==*this);
00430 
00431                 ht.FlipV();
00432                 ht.FlipV();
00433                 assert(ht==*this);
00434         }
00435         #else
00436         {}
00437         #endif
00438 
00439 
00440         protected:
00441                 void CheckIncidentFaces(int & count, bool & on_border)
00442                 {
00443                         PosType ht = *this;
00444                         do
00445                         {
00446                                 ++count;
00447                                 ht.NextE();
00448                                 if(ht.IsBorder()) on_border=true;
00449                         } while (ht != *this);
00450                 }
00451 };
00452 
00453 template <class FaceType>
00458 class PosN : public Pos<FaceType>
00459 {
00460 public:
00461         typedef typename FaceType::CoordType CoordType;
00462         //normale per visualizzazione creaseangle
00463         CoordType normal;
00464 };
00465 
00466 
00493 template <typename FaceType> 
00494 class VFIterator
00495 {
00496 public:
00497 
00499         typedef typename FaceType::VertexType VertexType;
00501         typedef  FaceType  VFIFaceType;
00503         typedef typename VertexType::CoordType CoordType;
00505         typedef typename VertexType::ScalarType ScalarType;
00506 
00508         FaceType *f;
00510         int z;
00511         
00513         VFIterator(){}
00515         VFIterator(FaceType * _f,  const int &  _z){f = _f; z = _z;}
00516 
00518         VFIterator(VertexType * _v){f = _v->VFp(); z = _v->VFi();}
00519 
00520         VFIFaceType *&  F() { return f;}
00521         int     &                                         I() { return z;}
00522   
00523   // Access to the vertex. Having a VFIterator vfi, it corresponds to 
00524   // vfi.V() = vfi.F()->V(vfi.I())
00525   inline VertexType *V() const { return f->V(z);}
00526 
00527   inline VertexType * const & V0() const { return f->V0(z);} 
00528   inline VertexType * const & V1() const { return f->V1(z);}
00529   inline VertexType * const & V2() const { return f->V2(z);}
00530         
00531   bool End() const {return f==0;}
00532   VFIFaceType *operator++() {
00533     FaceType* t = f;
00534                 f = f->VFp(z);
00535                 z = t->VFi(z);
00536     return f;
00537   }
00538                 
00539 };
00540 
00542 }        // end namespace
00543 }        // end namespace
00544 #endif