include/adaptivemesht.hh

Go to the documentation of this file.

#ifndef A48_ADAPTIVEMESHT_HH
#define A48_ADAPTIVEMESHT_HH

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

#include <stellarmesht.hh>

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

namespace a48 {

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

class DefaultAdaptiveTraits {
public:
    typedef AdaptiveVertexT< DefaultAdaptiveTraits > vertex_type; 
    typedef AdaptiveHalfedgeT< DefaultAdaptiveTraits > halfedge_type; 
    typedef AdaptiveFaceT< DefaultAdaptiveTraits > face_type; 
};
//== CLASS DEFINITION =========================================================

template< class Traits = DefaultAdaptiveTraits >
class BaseAdaptivePolicy {

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

public:

    virtual void update_simplification( vertex_type *v ) = 0;

    virtual void update_simplification( halfedge_type *h ) = 0;

    virtual void update_simplification( void ) = 0;

    virtual void update_refinement( halfedge_type *h ) = 0;

    virtual void update_refinement( vertex_type *v ) = 0;

    virtual void update_refinement( void ) = 0;

    virtual vertex_type* next_simplify_vertex( void ) = 0;

    virtual halfedge_type* next_refine_halfedge( void ) = 0;

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

template< class Traits = DefaultAdaptiveTraits >
class AdaptiveMeshT : public StellarMeshT< Traits > {

public:

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

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

    AdaptiveMeshT() : StellarMeshT< Traits >(), ap(0) { }

    AdaptiveMeshT( adaptive_policy *_ap ) : StellarMeshT< Traits >(), ap(_ap) { }

    AdaptiveMeshT( items_policy *_ip,
                   stellar_policy *_sp = 0,
                   adaptive_policy *_ap = 0 ) :
        StellarMeshT< Traits >(_ip,_sp), ap(_ap) { }

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

    AdaptiveMeshT< Traits >& operator = ( const AdaptiveMeshT< Traits >& _m ) {
        this->ap = _m.get_adaptive_policy();
        StellarMeshT< Traits >::operator = ( _m );
        return *this;
    }

    // @name Query functions

    bool is_triquad( void ) const {
        unsigned int she = 0; 
        for (typename StellarMeshT< Traits >::halfedge_const_iterator
                 hit = this->halfedges_begin(); hit != this->halfedges_end(); ++hit)
            if( (*hit)->is_split() and ( (*hit)->is_boundary() or (*hit)->opposite()->is_split() ) )
                ++she;
        // Boundary faces are considered to have a matching
        // null face so their corresponding split halfedge can
        // be at the boundary
        if( she != this->size_of_faces() ) return false;
        return true;
    }


    // @name Set functions

    void set_adaptive_policy( adaptive_policy *_ap ) { ap = _ap; }


    // @name Get functions

    adaptive_policy* get_adaptive_policy( void ) { return ap; }

    const adaptive_policy* get_adaptive_policy( void ) const { return ap; }


    // @name Adaptation methods for a stellar mesh

    void simplify( vertex_type *v ) {
        if( v->level() == 0 ) return;
        unsigned int d = v->degree(), weld_deg = v->is_boundary() ? 3 : 4;
        unsigned int max_level;
        vertex_type *vneigh, *vmax;
        halfedge_type *hcurr;
        do {
            max_level = v->level();
            vmax = 0;
            hcurr = v->halfedge();
            do { // Trying to find a max-level neighbor vertex
                vneigh = hcurr->next()->vertex();
                hcurr = hcurr->next()->opposite();
                if( vneigh->level() > max_level ) {
                    max_level = vneigh->level();
                    vmax = vneigh;
                }
            } while( hcurr and hcurr != v->halfedge() );
            if( vmax ) // If there is such a vertex
                simplify( vmax ); // Simplify it
            else break; // If not, leave
            d = v->degree(); // degree may change in recursion
        } while( d > weld_deg );
        if( !v->is_weld() ) return; // verify if this vertex may be welded
        hcurr = v->halfedge();
        if( ap ) ap->update_simplification( v ); // @see BaseAdaptivePolicy
        this->weld( v );
        if( ap ) ap->update_simplification( hcurr ); // @see BaseAdaptivePolicy
    }

    void refine( halfedge_type *h ) {
        halfedge_type *h0 = h->face()->split_halfedge();
        halfedge_type *h1 = ( h->is_boundary() ) ? 0 :
            h->opposite()->face()->split_halfedge();
        if( h0 != h ) refine( h0 );
        if( h1 and h1 != h->opposite() ) refine( h1 );
        if( ap ) ap->update_refinement( h ); // @see BaseAdaptivePolicy
        unsigned int l0 = h->face()->level(),
            l1 = ( h->is_boundary() ) ? 0 : h->opposite()->face()->level();
        this->split( h );
        h->vertex()->set_level( std::max( l0, l1 ) + 1 );
        if( ap ) ap->update_refinement( h->vertex() ); // @see BaseAdaptivePolicy
    }

    void adapt_simplify( void ) {
        if( !ap ) return; // @see BaseAdaptivePolicy
        ap->update_simplification();
        vertex_type *v = ap->next_simplify_vertex();
        while( v ) {
            this->simplify( v );
            v = ap->next_simplify_vertex();
        }
    }

    void adapt_refine( void ) {
        if( !ap ) return; // @see BaseAdaptivePolicy
        ap->update_refinement();
        halfedge_type *h = ap->next_refine_halfedge();
        while( h ) {
            this->refine( h );
            h = ap->next_refine_halfedge();
        }
    }


private:

    adaptive_policy *ap; 

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