include/halfedget.hh

Go to the documentation of this file.

#ifndef A48_HALFEDGET_HH
#define A48_HALFEDGET_HH

//== INCLUDES =================================================================

#include <algorithm>

//== NAMESPACES ===============================================================

namespace a48 {

//== CLASS DEFINITION =========================================================

template< class Traits >
class HalfedgeT {

public:

    typedef typename Traits::vertex_type vertex_type; 
    typedef typename Traits::halfedge_type halfedge_type; 
    typedef typename Traits::face_type face_type; 

    typedef typename std::pair< const vertex_type*, const vertex_type* > edge_type; 

    HalfedgeT() : v(0), n(0), o(0), f(0) { }

    HalfedgeT( vertex_type *_v,
               halfedge_type *_n = 0,
               halfedge_type *_o = 0,
               face_type *_f = 0 ) : v(_v), n(_n), o(_o), f(_f) { }

    bool is_boundary( void ) const { return (o == 0); }

    bool is_consistent( void ) const { return (o == 0) or (o->vertex() != v); }

    // @name Get functions

    const vertex_type* from_vertex( void ) const { return previous()->vertex(); }
    vertex_type* from_vertex( void ) { return previous()->vertex(); }

    const vertex_type* vertex( void ) const { return v; }
    vertex_type* vertex( void ) { return v; }

    const halfedge_type* next( void ) const { return n; }
    halfedge_type* next( void ) { return n; }

    const halfedge_type* previous( void ) const {
        const halfedge_type *_h = n->next();
        while( _h->next() != this ) { _h = _h->next(); }
        return _h;
    }
    halfedge_type* previous( void ) {
        halfedge_type *_h = n->next();
        while( _h->next() != this ) { _h = _h->next(); }
        return _h;
    }

    const halfedge_type* opposite( void ) const { return o; }
    halfedge_type* opposite( void ) { return o; }

    const face_type* face( void ) const { return f; }
    face_type* face( void ) { return f; }

    unsigned int adjacent_faces( void ) const { return this->is_boundary() ? 1 : 2; }

    edge_type edge( void ) const {
        edge_type e;
        this->edge(e);
        return e;
    }
    void edge( edge_type& e ) const {
        const vertex_type *v0 = this->from_vertex();
        const vertex_type *v1 = this->vertex();
        if( v0 < v1 ) e = std::make_pair( v0, v1 );
        else e = std::make_pair( v1, v0 );
    }

    bool is_flip_ok( void ) const {
        const vertex_type *v0 = this->from_vertex(); // Verify left-side closed loop
        const vertex_type *v1 = this->vertex(); // Verify right-side closed loop
        return ( v0->is_flip_ok() ) and ( v1->is_flip_ok() );
    }


    // @name Set functions

    void set_vertex( vertex_type *_v ) { v = _v; }

    void set_next( halfedge_type *_n ) { n = _n; }

    void set_opposite( halfedge_type *_o ) { o = _o; }

    void set_face( face_type *_f ) { f = _f; }

    void set( vertex_type *_v, halfedge_type *_n, halfedge_type *_o ) { v = _v; n = _n; o = _o; }
    void set( vertex_type *_v, halfedge_type *_n, face_type *_f ) { v = _v; n = _n; f = _f; }
    void set( vertex_type *_v, halfedge_type *_n ) { v = _v; n = _n; }
    void set( halfedge_type *_n, face_type *_f ) { n = _n; f = _f; }
    void set( halfedge_type *_n, face_type *_f, halfedge_type *_o ) { n = _n; f = _f; o = _o; }
    void set( face_type *_f, halfedge_type *_o ) { f = _f; o = _o; }
    void set( vertex_type *_v, halfedge_type *_n,
          halfedge_type *_o, face_type *_f ) { v = _v; n = _n; o = _o; f = _f; }


private:

    vertex_type *v; 
    halfedge_type *n; 
    halfedge_type *o; 
    face_type *f; 

};

//== CLASS DEFINITION =========================================================

template< class Traits >
class AdaptiveHalfedgeT : public HalfedgeT< Traits > {

public:

    typedef typename Traits::vertex_type   vertex_type;
    typedef typename Traits::halfedge_type halfedge_type;
    typedef typename Traits::face_type     face_type;

    AdaptiveHalfedgeT() : HalfedgeT< Traits >() { }

    AdaptiveHalfedgeT( vertex_type *_v,
                       halfedge_type *_n = 0,
                       halfedge_type *_o = 0,
                       face_type *_f = 0 ) : HalfedgeT< Traits >(_v,_n,_o,_f) { }

    // @name Get functions

    bool is_split( void ) const { return this->face()->split_halfedge() == this; }

    unsigned int level( void ) const {
        return std::max( this->vertex()->level(),
                 this->from_vertex()->level() );
    }


};

//=============================================================================
} // namespace a48
//=============================================================================
#endif // A48_HALFEDGET_HH
//=============================================================================