include/stellarmesht.hh

Go to the documentation of this file.

#ifndef A48_STELLARMESHT_HH
#define A48_STELLARMESHT_HH

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

#include <mesht.hh>

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

namespace a48 {

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

template< class Traits = DefaultTraits >
class BaseStellarPolicy {

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

public:

    virtual void sample_vertex( const face_type *f, vertex_type *v ) = 0;

    virtual void sample_vertex( const halfedge_type *h, vertex_type *v ) = 0;

    virtual void remove_vertex( const face_type *f, const vertex_type *v ) = 0;

    virtual void remove_vertex( const halfedge_type *h, const vertex_type *v ) = 0;

    virtual void flip_halfedge( const halfedge_type *h ) = 0;

};
//== CLASS DEFINITION =========================================================

template< class Traits = DefaultTraits >
class StellarMeshT : public MeshT< Traits > {

public:

    typedef BaseItemsPolicy< Traits > items_policy; 
    typedef BaseStellarPolicy< Traits > stellar_policy; 

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

    StellarMeshT() : MeshT< Traits >(), sp(0) { }

    StellarMeshT( stellar_policy *_sp ) :
        MeshT< Traits >(), sp(_sp) { }

    StellarMeshT( items_policy *_ip,
                  stellar_policy *_sp = 0 ) :
        MeshT< Traits >(_ip), sp(_sp) { }

    StellarMeshT( const StellarMeshT< Traits >& _m ) { *this = _m; }

    StellarMeshT< Traits >& operator = ( const StellarMeshT< Traits >& _m ) {
        this->sp = _m.get_stellar_policy();
        MeshT< Traits >::operator = ( _m );
        return *this;
    }

    // @name Query functions

    bool is_tri( void ) const {
        for (typename MeshT< Traits >::face_iterator fit = this->faces_begin(); fit != this->faces_end(); ++fit)
            if( !(*fit)->is_triangle() ) return false;
        return true;
    }


    // @name Set functions

    void set_stellar_policy( stellar_policy *_sp ) { sp = _sp; }


    // @name Get functions

    stellar_policy* get_stellar_policy( void ) { return sp; }

    const stellar_policy* get_stellar_policy( void ) const { return sp; }


    // @name Stellar operators for a triangulated mesh

    void edge_weld( halfedge_type *h1, halfedge_type *h2 ) {
        if( h1->is_boundary() and h2->is_boundary() ) {
            // Remove vertex attributes at the base halfedge
            if( sp ) sp->remove_vertex( h1, h1->vertex() ); // @see BaseStellarPolicy
            delete_vertex( h1->vertex() ); // After saving base halfedge it can be deleted
            half_weld( h1 ); // Half weld using base halfedge (unfolding two faces in one)
        } else if( h1->vertex()->degree() == 4 ) { weld( h1->vertex() ); }
    }

    void face_weld( halfedge_type *h1, halfedge_type *h2, halfedge_type *h3  ) {
        if( h1->vertex()->degree() == 3 and h1->vertex() == h2->vertex() == h3->vertex() )
            weld( h1->vertex() );
    }

    void edge_split( halfedge_type *h ) { split( h ); }

    void face_split( face_type *f ) { split( f ); }

    void flip( halfedge_type *h ) {
        if( h->is_boundary() ) return;
        if( !h->is_flip_ok() ) return; // Verify if the halfedge can be flipped
        // inform policy of the incoming flip
        if( sp ) sp->flip_halfedge( h ); // @see BaseStellarPolicy
        halfedge_type *ph = h->previous();
        halfedge_type *nh = h->next();
        ph->set_next( h->opposite()->next() );
        nh->set_next( h->opposite() );
        if( h->vertex()->halfedge() == h )
            h->vertex()->set_halfedge( h->opposite()->previous() );
        if( h->opposite()->vertex()->halfedge() == h->opposite() )
            h->opposite()->vertex()->set_halfedge( ph );
        h->set_vertex( h->next()->vertex() );
        h->set_next( ph );
        if( h->face()->halfedge() == nh )
            h->face()->set_halfedge( h );
        ph = h->opposite()->previous();
        ph->set_next( nh );
        h->opposite()->next()->set_next( h );
        h->opposite()->next()->set_face( h->face() );
        if( h->opposite()->face()->halfedge() == h->opposite()->next() )
            h->opposite()->face()->set_halfedge( h->opposite() );
        nh->set_face( h->opposite()->face() );
        h->opposite()->set_vertex( h->previous()->vertex() );
        h->opposite()->set_next( ph );
    }

    void unflip( halfedge_type *h ) {
        if( h->is_boundary() ) return;
        if( !h->is_flip_ok() ) return; // Verify if the halfedge can be flipped
        // inform policy of the incoming flip
        if( sp ) sp->flip_halfedge( h ); // @see BaseStellarPolicy
        halfedge_type *ph = h->previous();
        halfedge_type *nh = h->next();
        ph->set_next( h->opposite()->next() );
        ph->set_face( h->opposite()->face() );
        if( h->vertex()->halfedge() == h )
            h->vertex()->set_halfedge( h->opposite()->previous() );
        if( h->opposite()->vertex()->halfedge() == h->opposite() )
            h->opposite()->vertex()->set_halfedge( ph );
        h->set_vertex( h->opposite()->next()->vertex() );
        h->set_next( h->opposite()->previous() );
        if( h->face()->halfedge() == ph )
            h->face()->set_halfedge( h );
        ph = h->opposite()->previous();
        ph->set_next( nh );
        ph->set_face( h->face() );
        h->opposite()->next()->set_next( h->opposite() );
        if( h->opposite()->face()->halfedge() == ph )
            h->opposite()->face()->set_halfedge( h->opposite() );
        h->opposite()->set_vertex( nh->vertex() );
        h->opposite()->set_next( nh->next() );
        nh->set_next( h );
    }

    void weld( vertex_type *v ) {
        if( !v->is_weld_ok() ) return; // Verify if the vertex can be welded
        unsigned int nf = v->incident_faces(); // Number of incident faces
        halfedge_type *bh = v->halfedge(); // Base halfedge
        halfedge_type *oh; // Opposed halfedge
        if( sp and ( nf == 2 or nf == 4 ) ) sp->remove_vertex( bh, v ); // @see BaseStellarPolicy
        if( sp and nf == 3 ) sp->remove_vertex( bh->face(), v ); // @see BaseStellarPolicy
        delete_vertex( v ); // After saving base halfedge it can be deleted
        half_weld( bh ); // Half weld using base halfedge (unfolding two faces in one)
        if( nf == 2 ) return; // It is done if there is only two faces incident
        else if( nf == 3 ) { // Delete third face below the unfold face
            // The opposed halfedge to bh outside third face
            oh = bh->opposite()->next()->opposite();
            // Set proper halfedges for vertices in the base halfedge
            if( bh->vertex()->halfedge() == bh->opposite()->next() )
                bh->vertex()->set_halfedge( bh );
            if( bh->opposite()->vertex()->halfedge() == bh->opposite() )
                bh->opposite()->vertex()->set_halfedge( bh->previous() );
            // Delete third face and its halfedges
            delete_face( bh->opposite()->face() );
            delete_halfedge( bh->opposite()->previous() );
            delete_halfedge( bh->opposite()->next() );
            delete_halfedge( bh->opposite() );
            // Set opposite halfedges of the base edge properly
            bh->set_opposite( oh );
            if( oh ) oh->set_opposite( bh );
        } else if( nf == 4 ) {
            // The opposed halfedge to bh pointing to the weld vertex
            oh = bh->opposite()->previous()->opposite()->previous();
            // Half weld using opposed halfedge (unfolding two faces in one)
            half_weld( oh );
            // Set opposite halfedge of the base edge properly
            bh->set_opposite( oh );
            oh->set_opposite( bh );
        }
    }

    void split( halfedge_type *h ) {
        unsigned int nf = h->adjacent_faces(); // Number of adjacent faces
        vertex_type *v = this->add_vertex(); // Common middle vertex to create
        v->set_halfedge( h );
        if( sp ) sp->sample_vertex( h, v ); // @see BaseStellarPolicy
        half_split( h, v ); // Half split using input halfedge (folding one face in two)
        if( nf == 1 ) return; // It is done if there is only one adjacent face
        halfedge_type *oh = h->opposite(); // The other-side halfedge
        half_split( oh, v ); // Half split the opposite input halfedge
        // Fix pointers of the four splitted halfedges
        h->next()->opposite()->next()->set_opposite( oh );
        oh->set_opposite( h->next()->opposite()->next() );
        oh->next()->opposite()->next()->set_opposite( h );
        h->set_opposite( oh->next()->opposite()->next() );
    }

    void split( face_type *f0 ) {
        halfedge_type *h00 = f0->halfedge();
        halfedge_type *h10 = h00->next();
        halfedge_type *h20 = h10->next();
        // Add new mesh elements
        vertex_type *v = this->add_vertex();
        if( sp ) sp->sample_vertex( f0, v ); // @see BaseStellarPolicy
        halfedge_type *h01 = this->add_halfedge();
        halfedge_type *h02 = this->add_halfedge();
        halfedge_type *h11 = this->add_halfedge();
        halfedge_type *h12 = this->add_halfedge();
        halfedge_type *h21 = this->add_halfedge();
        halfedge_type *h22 = this->add_halfedge();
        face_type *f1 = this->add_face();
        face_type *f2 = this->add_face();
        // Set proper pointers of new elements
        f1->set_halfedge( h10 );
        f2->set_halfedge( h20 );
        h01->set( v, h02, h12, f0 ); h02->set( h20->vertex(), h00, h21, f0 );
        h11->set( v, h12, h22, f1 ); h12->set( h00->vertex(), h10, h01, f1 );
        h21->set( v, h22, h02, f2 ); h22->set( h10->vertex(), h20, h11, f2 );
        v->set_halfedge( h01 );
        // Fix pointers of reused elements
        h00->set_next( h01 );
        h10->set( h11, f1 );
        h20->set( h21, f2 );
    }


private:

    void half_weld( halfedge_type *h ) {
        // Previous and next halfedge and opposed vertex (see figure above)
        halfedge_type *ph = h->previous();
        halfedge_type *nh = h->next()->opposite()->previous();
        vertex_type *ov = h->next()->opposite()->next()->vertex();
        // Set proper halfedges for pointed vertices
        if( ov->halfedge() == h->next()->opposite()->next() )
            ov->set_halfedge( h );
        if( h->next()->vertex()->halfedge() == h->next() )
            h->next()->vertex()->set_halfedge( nh );
        // Set proper halfedge for reused face
        h->face()->set_halfedge( h );
        // Delete second face and its halfedges (unfolding two faces in one)
        delete_face( h->next()->opposite()->face() );
        delete_halfedge( h->next()->opposite()->next() );
        delete_halfedge( h->next()->opposite() );
        delete_halfedge( h->next() );
        // Fix pointers of reused halfedges
        nh->set_face( h->face() );
        nh->set_next( ph );
        h->set_next( nh );
        h->set_vertex( ov );
    }

    void half_split( halfedge_type *h, vertex_type *v ) {
        halfedge_type *nh = h->next();
        vertex_type *ov = h->vertex();
        // Add new mesh elements
        face_type *f = this->add_face();
        halfedge_type *h1 = this->add_halfedge();
        halfedge_type *h2 = this->add_halfedge();
        halfedge_type *h3 = this->add_halfedge();
        // Set proper pointers of new elements
        f->set_halfedge( nh );
        h1->set( ov, nh, f );
        h2->set( v, h1, h3, f );
        h3->set( nh->vertex(), h->previous(), h2, h->face() );
        // Fix pointers of reused elements
        if( ov->halfedge() == h ) ov->set_halfedge( h1 );
        h->face()->set_halfedge( h->previous() );
        h->set( v, h3 );
        nh->set( h2, f );
    }

    stellar_policy *sp; 

};
//=============================================================================
} // namespace a48
//=============================================================================
#endif // A48_STELLARMESHT_HH
//=============================================================================