vertex.h

/***************************************************************************
*   Copyright (C) 2007 by Pablo Diaz-Gutierrez   *
*   pablo@ics.uci.edu   *
*                                                                         *
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU Library 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 for more details.                          *
*                                                                         *
*   You should have received a copy of the GNU Library General Public     *
*   License along with this program; if not, write to the                 *
*   Free Software Foundation, Inc.,                                       *
*   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
***************************************************************************/

#ifndef __VERTEX_H__
#define __VERTEX_H__

#include "vector3.h"


namespace HE
{
  class HalfEdge;

  class Vertex
  {
      public:
        class edge_circulator;
        class const_edge_circulator;
        class edge_circulator
        {
          friend class const_edge_circulator;
          public:
              edge_circulator(const Vertex* v, HalfEdge* h) : _base(v), _here(h) {}

            const Vertex* base() const { return _base; };
            HalfEdge* operator*() { return _here; }
            void operator++();
            void operator++(int) { ++(*this); }
            bool operator==(const edge_circulator& e) const { return _base==e._base && _here==e._here; }
            bool operator!=(const edge_circulator& e) const { return !(e == *this); }
          protected:
            const Vertex* _base;
            HalfEdge* _here;
        };

        class const_edge_circulator
        {
          friend class edge_circulator;
            public:
              const_edge_circulator(const Vertex* v, const HalfEdge* h) : _base(v), _here(h) {}
              const_edge_circulator(const edge_circulator& ec) : _base(ec.base()), _here(ec._here) {}

              const Vertex* base() const { return _base; };
              const HalfEdge* operator*() const { return _here; }
              void operator++();
              void operator++(int) { ++(*this); }
              bool operator==(const const_edge_circulator& e) const { return _base==e._base && _here==e._here; }
              bool operator!=(const const_edge_circulator& e) const { return !(e == *this); }
            protected:
              const Vertex* _base;
              const HalfEdge* _here;
        };

        edge_circulator begin() { return edge_circulator(this, _edge); }
        const_edge_circulator begin() const { return const_edge_circulator(this, _edge); }

        explicit Vertex(int i=-1) : _edge(0), _index(i) {}    
        explicit Vertex(const Geometry::Vector3Df& pos, int i=-1) : _pos(pos), _edge(0), _index(i) {}    
        explicit Vertex(const Geometry::Vector3Df& pos, HalfEdge* e, int i=-1) : _pos(pos), _edge(e), _index(i) {}  

        // Set methods
        void index(int i) { _index = i; } 
        void position(const Geometry::Vector3Df& pos) { _pos = pos; } 
        void edge(HalfEdge* e) { _edge = e; }  

        // Get methods
        int index() const { return _index; }  
        const Geometry::Vector3Df& position() const { return _pos; } 
        HalfEdge* edge() { return _edge; }              
        const HalfEdge* edge() const { return _edge; }  

        // Simple computations
        Geometry::Vector3Df normal() const;    
        int valence() const;    
        int degree() const { return valence(); }    
                  bool isBoundary() const;
        
        bool operator==(const Vertex& v) const { return _index == v._index; } 

        HalfEdge* edgeTo(const Vertex* v) { return edgeTo(v->index()); }
        const HalfEdge* edgeTo(const Vertex* v) const { return edgeTo(v->index()); }

        HalfEdge* edgeTo(int v);
        const HalfEdge* edgeTo(int v) const;

      protected:
        Geometry::Vector3Df _pos;
        HalfEdge* _edge;
        int _index;
  };
  
  std::ostream& operator<< (std::ostream& out, const Vertex& v);
};

#endif // __VERTEX_H__

---