pos.h

Go to the documentation of this file.

/****************************************************************************
* 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



****************************************************************************/

#ifndef __VCG_TETRA_POS
#define __VCG_TETRA_POS

namespace vcg {
  namespace tetra {



template < class MTTYPE> 
class VTIterator
{
public:
        typedef  MTTYPE TetraType;
private:
        TetraType *_vt;
        int _vi;
public:
  VTIterator() : _vt(0), _vi(-1){}
        VTIterator(TetraType  * const tp, int const zp)
        {       
                _vt=tp;
                _vi=zp;
  }

        ~VTIterator(){};

inline TetraType* & Vt()
{
        return _vt;
} 

inline int & Vi()
{
        return _vi;
}

inline const int & Vi() const
{
                return _vi;
}

inline bool End(){return (Vt()==NULL);}

void operator++() 
{
                int vi=Vi();
                TetraType * tw = Vt();
                Vt() = tw->TVp(vi);
                Vi() = tw->TVi(vi);

                assert((Vt()==NULL)||((tw->V(vi))==(Vt()->V(Vi()))));
}

};


template < class MTTYPE> 
class Pos
{
public:

        typedef MTTYPE TetraType;
        typedef typename TetraType::VertexType VertexType;
        typedef typename TetraType::VertexType::CoordType CoordType;
        typedef Pos<TetraType> BasePosType;

private:
        TetraType *_t;
        char _f;
        char _e;
        char _v;

public:
        Pos(){SetNull();};
        Pos(TetraType * const tp, char const fap,char const ep,
                char const vp){_t=tp;_f=fap;_e=ep;_v=vp;}

        ~Pos(){};
  
        inline TetraType* & T()
  {
                return _t;
        } 

        inline  TetraType* const & T() const
        {
                return _t;
        }

        inline char & F()
        {
                return _f;
        }

        inline const char & F() const
        {
                return _f;
        }

        inline char & E()
        {
                return _e;
        }

        inline const char & E() const
        {
                return _e;
        }

        inline char & V()
        {
                return _v;
        }

        inline const char & V() const
        {
                return _v;
        }

        inline bool operator == ( BasePosType const & p ) const {
                        return (T()==p.T() && F()==p.F() && E==p.E() && V==p.V());
        } 

        inline bool operator != ( BasePosType const & p ) const {
                        return (!((*this)==p));
        } 
   
        void SetNull(){
                T()=0;
                F()=-1;
                E()=-1;
                V()=-1;
        }

        bool IsNull() const {
                return ((T()==0) || (F()<0) || (E()<0) || (V()<0));
        }


        void FlipE()
        {
                
                //take the absolute index of the tree edges of the faces
    char e0=vcg::Tetra::EofF(_f ,0);
                char e1=vcg::Tetra::EofF(_f ,1);
                char e2=vcg::Tetra::EofF(_f ,2);
                //eliminate the same as himself
                if (e0==E())
                        {
                         e0=e1;
                         e1=e2;
                        }
                else
                if (e1==E())
                        {
                         e1=e2;
                        }

                //now choose the one that preserve the same vertex
     if ((vcg::Tetra::VofE(e1,0)==V())||(vcg::Tetra::VofE(e1,1)==V()))
                        E()=e1;
                else
                        E()=e0;
        }


        void FlipV()
        {
                // in the same edge choose the one that change
                char v0=vcg::Tetra::VofE(E(),0);
                char v1=vcg::Tetra::VofE(E(),1);
                if (v0!=V())
                        V()=v0;
                else
                        V()=v1;
        }

        void FlipF()
        {
    char f0=vcg::Tetra::FofE(E(),0);
                char f1=vcg::Tetra::FofE(E(),1);
                if (f0!=F())
                        F()=f0;
                else
                        F()=f1;
        }

        void FlipT()
        {
                
                //save the two vertices of the old edge
                VertexType *v0=T()->V(vcg::Tetra::VofE(E(),0));
                VertexType *v1=T()->V(vcg::Tetra::VofE(E(),1));

    //get the current vertex
    VertexType *vcurr=T()->V(V());

                //get new tetrahedron according to faceto face topology
                TetraType *nt=T()->TTp(F());
                char nfa=T()->TTi(F());
                if (nfa!=-1)
                {
                        //find the right edge
      char ne0=vcg::Tetra::EofF(nfa,0);
                        char ne1=vcg::Tetra::EofF(nfa,1);
                        char ne2=vcg::Tetra::EofF(nfa,2);
      
      //the vertices of new edges
      VertexType *vn0=nt->V(vcg::Tetra::VofE(ne0,0));
      VertexType *vn1=nt->V(vcg::Tetra::VofE(ne0,1));
                        //verify that the two vertices of tetrahedron are identical
                        if (((vn0==v0)&&(vn1==v1))||((vn1==v0)&&(vn0==v1)))
                          E()=ne0;
                        else
      {
        vn0=nt->V(vcg::Tetra::VofE(ne1,0));
        vn1=nt->V(vcg::Tetra::VofE(ne1,1));
                          if (((vn0==v0)&&(vn1==v1))||((vn1==v0)&&(vn0==v1)))
                            E()=ne1;
        else
        {
#ifdef _DEBUG
          vn0=nt->V(vcg::Tetra::VofE(ne2,0));
          vn1=nt->V(vcg::Tetra::VofE(ne2,1));
          assert(((vn0==v0)&&(vn1==v1))||((vn1==v0)&&(vn0==v1)));
#endif
          E()=ne2;
        }
      }

      //find the right vertex
      vn0=nt->V(vcg::Tetra::VofE(E(),0));
#ifdef _DEBUG
      vn1=nt->V(vcg::Tetra::VofE(E(),1));
      assert((vn0==vcurr)||(vn1==vcurr));
#endif
      if (vn0==vcurr)
        V()=vcg::Tetra::VofE(E(),0);
      else
        V()=vcg::Tetra::VofE(E(),1);

      T()=nt;
      assert(T()->V(V())==vcurr);
                        F()=nfa;
    }
  }

        void NextT( )
        {
                #ifdef _DEBUG
                VertexType *vold=T()->V(V());
                #endif
                FlipT();
                FlipF();
                #ifdef _DEBUG
                VertexType *vnew=T()->V(V());
                assert(vold==vnew);
                #endif  
        }

        void Assert()
        #ifdef _DEBUG
        {       
                HETYPE ht=*this;
                ht.FlipT();
                ht.FlipT();
                assert(ht==*this);

                ht=*this;
                ht.FlipF();
                ht.FlipF();
                assert(ht==*this);

                ht=*this;
                ht.FlipE();
                ht.FlipE();
                assert(ht==*this);

                ht=*this;
                ht.FlipV();
                ht.FlipV();
                assert(ht==*this);
        }
        #else
        {}
        #endif
};

template < class MTTYPE> 
class PosJump:public Pos<MTTYPE>
{
private:
        MTTYPE *_t_initial;
        short int _back;
public :
        typedef  MTTYPE  TetraType;
  PosJump(const TetraType*  tp,const int  fap,const int  ep,
                int  vp){this->T()=tp;this->F()=fap;this->E()=ep;this->V()=vp;_t_initial=tp;_back=0;}

        void NextT()
  {
#ifdef _DEBUG
                int cont=0;
#endif
                MTTYPE *tpred=this->T();
                Pos<MTTYPE>::NextT();
                //external face
                if (tpred==this->T())
                {
                        while (this->T()!=_t_initial)
                        {
                                Pos<MTTYPE>::NextT();
                                #ifdef _DEBUG
                                 cont++;
                                 assert (cont<500);
                                #endif
                        }
                        _back++;
                        if (_back==1)
                        {
                          Pos<MTTYPE>::NextT();
                        }       
    }
        }
};

template < class MTTYPE> 
class PosLoop:public Pos<MTTYPE>
{
private:
        MTTYPE *_t_initial;
        bool _jump;
  bool _loop;
public :
        typedef  MTTYPE  TetraType;
PosLoop(TetraType*  tp,const int  fap,const int  ep,
                int vp){this->T()=tp;this->F()=fap;this->E()=ep;this->V()=vp;_t_initial=tp;_jump=false;_loop=false;}

  bool LoopEnd()
  {
    return (_loop);
  }
  
  bool Jump()
  {
    return(_jump);
  }
  
  void Reset()
  {
    _loop=false;
    _jump=false;
  }

        void NextT()
  {     
#ifdef _DEBUG
    TetraType *t_old=this->T();
#endif
                TetraType *tpred=this->T();
                Pos<TetraType>::NextT();
    _loop=false;
    _jump=false;

                //external face
                if (tpred==this->T())
                {
      tpred=this->T();
      //jump next one
      Pos<TetraType>::NextT();
      //find the next external face
                        while (tpred!=this->T())
                        {
        tpred=this->T();
                                Pos<TetraType>::NextT();
                        }
                        //  Pos<TetraType>::NextT();
        _jump=true;
    }   
    if (this->T()==_t_initial)
      _loop=true;
#ifdef _DEBUG
    if (_loop==false)
      assert(t_old!=this->T());
#endif
  }

};
  }//end namespace tetra
}//end namespace vcg

#endif