halfedge.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 __HALFEDGE_H__
#define __HALFEDGE_H__

#include <ostream>
#include "vector3.h"

namespace HE
{
        class Vertex;
        class Face;
        
        class HalfEdge
        {
                public:
                        explicit HalfEdge(Vertex* v, Face* f, HalfEdge* t, HalfEdge* n)
                        : _dst(v), _face(f), _twin(t), _next(n) {}
                        explicit HalfEdge(Vertex* v, Face* f)
                        : _dst(v), _face(f), _twin(0), _next(0) {}
                        
                        // Set methods
                        void next(HalfEdge* n) { _next = n; } 
                        void twin(HalfEdge* p) { _twin = p; } 
                        void face(Face* f) { _face = f; }     
                        void dst(Vertex* v) { _dst = v; }     
                        
                        // Get methods
                        HalfEdge* next() { return _next; }             
                        const HalfEdge* next() const { return _next; } 
                        HalfEdge* prev();                              
                        const HalfEdge* prev() const;                  
                        HalfEdge* twin() { return _twin; }             
                        const HalfEdge* twin() const { return _twin; } 
                        Face* face() { return _face; }                 
                        const Face* face() const { return _face; }     
                        Vertex* dst() { return _dst; }                 
                        const Vertex* dst() const { return _dst; }     

         Vertex* src() { return _twin->dst(); }
         const Vertex* src() const { return _twin->dst(); }
                        
                        // Simple computations
                        Geometry::Vector3Df normal() const;   
         Geometry::Vector3Df tangent() const;  
         Geometry::Vector3Df midpoint() const;  
         float squaredLength() const { return tangent().squaredModule(); } 
                        float length() const { return tangent().module(); }  
                        bool isBoundary() const;  

                protected:
                        Vertex* _dst;
                        Face* _face;
                        HalfEdge* _twin;
                        HalfEdge* _next;
        };
        
        std::ostream& operator<< (std::ostream& out, const HalfEdge& he);
};

#endif // __HALFEDGE_H__

---