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

$Log: not supported by cvs2svn $
Revision 1.2  2004/05/10 14:40:47  ganovelli
name of adhacency function updated

Revision 1.1  2004/05/10 14:01:56  ganovelli
created

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


#ifndef __VCG_EDGE_POS
#define __VCG_EDGE_POS

namespace vcg {
namespace edge {

// Needed Prototypes (pos is include before topology)
template <class EDGETYPE>
bool IsEdgeBorder(EDGETYPE const & e,  const int j );
template <class EDGETYPE>
bool IsEdgeManifold(EDGETYPE const & e,  const int j );

/*
 Vertex_Edge: run over the fan of a vertex (no order is specified)
*/
template <class EDGETYPE> 
class VertexStar
{
public:
        EDGETYPE *e;
        int z;
  VertexStar() : e(0), z(0) {}
        VertexStar(EDGETYPE  * const ep, int const zp)
        {
                e=ep;
                z=zp;
        }

        void NextF()
        {
                EDGETYPE * t = e;
                e = (EDGETYPE *)t->VEp(z);
                z = t->VEi(z);
        }
};


/*
 
*/
template <class EDGETYPE> 
class Pos
{
public:

        typedef typename EDGETYPE::VertexType VertexType;
        typedef Pos< EDGETYPE> POSTYPE;

        EDGETYPE *e;
        VertexType *v;

        Pos(){}
  Pos(EDGETYPE  * ep, int zp) {e=ep;v=ep->V(zp);}
  Pos(EDGETYPE  * ep, VertexType  *vp){e=ep;v=vp;}


  // Official Access functions functions
   VertexType *& V(){ return v; }
   EDGETYPE   *& E(){ return e; }
   int VInd(){
     return (e->V(0)==v)?0:1;
     }

        inline bool operator == ( POSTYPE const & p ) const {
                        return (e==p.e &&v==p.v);
        } 

        inline bool operator != ( POSTYPE const & p ) const {
                        return (e!=p.e || v!=p.v);
        } 
        inline bool operator <= ( POSTYPE const & p) const {
    return      (e!=p.e)?(e<p.e):
                                                (v<=p.v);
        }       

        inline POSTYPE & operator = ( const POSTYPE & h ){
                e=h.e;
                v=h.v;
                return *this;
                }
        void SetNull(){
                e=0;
                v=0;
        }
        bool IsNull() const {
                return e==0 || v==0 ;
        }


        void NextE()
        {
       FlipE();
       FlipV();
        }
  
        void FlipV()
        {
                v = (e->V(0)==v)?e->V(1):e->V(0);
        }
        void FlipE()
        {
                assert( (e->V(0)==v) ||(e->V(1)==v));
                e = (e->V(0)==v)?e->EEp(0):e->EEp(1);
        }
  // return the vertex that it should have if we make FlipV;
        VertexType *VFlip()
        {
                return (e->V(0)==v)?e->V(1):e->V(0);
        }

        // Trova il prossimo half-edge di bordo (nhe)
        // tale che 
        // --nhe.f adiacente per vertice a he.f
        // --nhe.v adiacente per edge di bordo a he.v 
        // l'idea e' che se he e' un half edge di bordo 
        // si puo scorrere tutto un bordo facendo 
        //
        //              hei=he;
        //              do
        //                      hei.Nextb()
        //              while(hei!=he);
        

  bool IsBorder()
  {
    return edge::IsEdgeBorder(*e,VInd());
  }

  bool IsManifold()
  {
    return edge::IsEdgeManifold(*e,VInd());
  }


  void Set(EDGETYPE  * const ep, VertexType  * const vp)
        {
                e=ep;v=vp;
        }

};



template <typename EdgeType>
class VEIterator
{
public:

        typedef typename EdgeType::VertexType VertexType;
        typedef  EdgeType  VFIEdgeType;
        typedef typename VertexType::CoordType CoordType;
        typedef typename VertexType::ScalarType ScalarType;

        EdgeType *e;
        int z;

        VEIterator(){}
        VEIterator(EdgeType * _e,  const int &  _z){e = _e; z = _z;}

    VEIterator(const VertexType * _v){
      e = _v->cVEp(); z = _v->cVEi();
          assert(z>=0 && "VE adjacency not initialized");
        }

        VFIEdgeType * &E() { return e;}
        int     &                                         I() { return z;}

  // Access to the vertex. Having a VEIterator vfi, it corresponds to
  // vfi.V() = vfi.I()->V(vfi.I())
  inline VertexType *V() const { return e->V(z);}

  inline VertexType * const & V0() const { return e->V0(z);}
  inline VertexType * const & V1() const { return e->V1(z);}

  bool End() const {return e==0;}
  VFIEdgeType *operator++() {
    EdgeType* t = e;
        e = e->VEp(z);
        z = t->VEi(z);
    return e;
  }

};


        }        // end namespace
}        // end namespace
#endif