include/adaptivepolicies.hh

Go to the documentation of this file.

#ifndef A48_ADAPTIVE_POLICIES_HH
#define A48_ADAPTIVE_POLICIES_HH

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

#include <limits>

#include <adaptivemesht.hh>

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

namespace a48 {

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

template< class Traits = DefaultAdaptiveTraits >
class ContainerBasedAP : public virtual BaseAdaptivePolicy< Traits > {

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

    typedef AdaptiveMeshT< Traits > mesh_type; 
    typedef typename mesh_type::vertex_iterator vertex_iterator; 
    typedef typename mesh_type::halfedge_iterator halfedge_iterator; 

    typedef typename std::set< vertex_type* > simplification_container; 
    typedef typename std::set< halfedge_type* > refinement_container; 

    typedef typename simplification_container::iterator simplification_iterator; 
    typedef typename refinement_container::iterator refinement_iterator; 

public:

    ContainerBasedAP( mesh_type *_m = 0 ) : m(_m) { }

    void set_mesh( mesh_type *_m ) { m = _m; }

    mesh_type* get_mesh( void ) { return m; }

    virtual void update_simplification( void ) {
        s.clear();
        for (vertex_iterator vit = m->vertices_begin(); vit != m->vertices_end(); ++vit)
            if( needs_simplification( *vit ) )
                s.insert( *vit );
    }

    virtual void update_refinement( void ) {
        r.clear();
        for (halfedge_iterator hit = m->halfedges_begin(); hit != m->halfedges_end(); ++hit)
            if( (*hit)->is_split() and (*hit)->opposite() < (*hit) and needs_refinement( *hit ) )
                r.insert( *hit );
    }

    virtual vertex_type* next_simplify_vertex( void ) {
        if( s.empty() ) return 0;
        vertex_type *v = *s.begin();
        s.erase(v);
        return v;
    }

    virtual halfedge_type* next_refine_halfedge( void ){
        if( r.empty() ) return 0;
        halfedge_type *h = *r.begin();
        r.erase(h);
        return h;
    }

    virtual void update_simplification( vertex_type *v ) {
        s.erase( v );
        for (halfedge_type *h = v->halfedge(); h != 0; h = v->star_next(h)) {
            r.erase( h );
            if( !h->is_boundary() )
                r.erase( h->opposite() );
        }
    }

    virtual void update_simplification( halfedge_type *h ) {
        if( h->opposite() < h and needs_refinement( h ) )
            r.insert( h );
        vertex_type *v = h->next()->vertex();
        if( h->face()->weld_vertex() == v and needs_simplification(v) )
            s.insert( v );
        if( h->is_boundary() ) return;
        v = h->opposite()->next()->vertex();
        if( h->opposite()->face()->weld_vertex() == v and needs_simplification(v) )
            s.insert( v );
    }

    virtual void update_refinement( halfedge_type *h ) {
        r.erase( h );
        s.erase( h->next()->vertex() );
        if( !h->is_boundary() )
            s.erase( h->opposite()->next()->vertex() );
    }

    virtual void update_refinement( vertex_type *v ) {
        if( needs_simplification(v) )
            s.insert( v );
        for (halfedge_type *hcurr = v->halfedge(); hcurr != 0; hcurr = v->star_next(hcurr)) {
            halfedge_type *h = hcurr->previous();
            if( h->is_split() and h->opposite() < h and needs_refinement(h) )
                r.insert( h );
        }
    }

protected:

    virtual bool needs_simplification( vertex_type *v ) = 0;

    virtual bool needs_refinement( halfedge_type *h ) = 0;

private:

    simplification_container s; 
    refinement_container r; 

    mesh_type *m; 

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

template< class Traits >
class UniformLevelAP : public ContainerBasedAP< Traits > {

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

    typedef AdaptiveMeshT< Traits > mesh_type; 

public:

    UniformLevelAP( mesh_type *_m = 0,
                    const unsigned int& _tl = 0 ) : ContainerBasedAP< Traits >( _m ), tl( _tl ) { }

    void set_target_level( const unsigned int& _tl ) { tl = _tl; }

    unsigned int get_target_level( void ) const { return tl; }

    void inc_target_level( const unsigned int& _max = std::numeric_limits<unsigned int>::max() ) { if( tl < _max ) ++tl; }

    void dec_target_level( const unsigned int& _min = 0 ) { if( tl > _min ) --tl; }

protected:

    bool needs_simplification( vertex_type *v ) {
        return v->level() > tl;
    }

    bool needs_refinement( halfedge_type *h ) {
        return h->next()->vertex()->level() < tl;
    }

private:

    unsigned int tl; 

};

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

template< class Traits >
class RangeLevelAP : public ContainerBasedAP< Traits > {

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

    typedef AdaptiveMeshT< Traits > mesh_type; 

public:

    RangeLevelAP( mesh_type *_m,
                  float (*_fp)( vertex_type* ),
                  const unsigned int& _minl,
                  const unsigned int& _maxl ) : ContainerBasedAP< Traits >( _m ), fp( _fp ),
                                                minl( _minl ), maxl( _maxl ) { }

    void set_min_level( const unsigned int& _minl ) { minl = _minl; }

    unsigned int get_min_level( void ) const { return minl; }

    void set_max_level( const unsigned int& _maxl ) { maxl = _maxl; }

    unsigned int get_max_level( void ) const { return maxl; }

    void inc_min_level( const unsigned int& _max = std::numeric_limits<unsigned int>::max() ) { if( minl < _max ) ++minl; }

    void dec_min_level( const unsigned int& _min = 0 ) { if( minl > _min ) --minl; }

    void inc_max_level( const unsigned int& _max = std::numeric_limits<unsigned int>::max() ) { if( maxl < _max ) ++maxl; }

    void dec_max_level( const unsigned int& _min = 0 ) { if( maxl > _min ) --maxl; }

protected:

    inline unsigned int target_level( vertex_type *v ) const {
        float t = fp(v);
        return (unsigned int)( t * maxl + (1.f - t) * minl );
    }

    bool needs_simplification( vertex_type *v ) {
        return v->level() > target_level(v);
    }

    bool needs_refinement( halfedge_type *h ) {
        return h->next()->vertex()->level() < target_level(h->next()->vertex());
    }

private:

    float (*fp)( vertex_type* ); 
    unsigned int minl, maxl; 

};

//=============================================================================
} // namespace a48
//=============================================================================
#endif // A48_ADAPTIVEPOLICIES_HH
//=============================================================================