/Users/mourrain/Devel/mmx/shape/include/shape/subdivision.hpp

Go to the documentation of this file.

/*****************************************************************************
 * M a t h e m a g i x
 *****************************************************************************
 * Bernard Mourrain
 *****************************************************************************
 *               Copyright (C) 2011 INRIA Sophia-Antipolis
 *****************************************************************************
 * Comments :
 ****************************************************************************/

# ifndef shape_subdivision_surface_hpp_H
# define shape_subdivision_surface_hpp_H

# include <shape/graphic.hpp>
# include <shape/vertex.hpp>
# include <shape/edge.hpp>
# include <shape/face.hpp>
# include <shape/kdtree.hpp>
# include <shape/list.hpp>
# include <shape/topology.hpp>
# include <shape/algebraic_curve.hpp>
# include <shape/surface_algebraic.hpp>
# include <shape/cell.hpp>
# include <shape/kdtree_cell.hpp>
# include <shape/cell3d_algebraic_curve.hpp>
# include <shape/cell3d_surface_algebraic.hpp>
# include <shape/cell3d_list.hpp>
# include <algorithm>

# define TMPL  template<class C,class V,  class SURFACE, class Cell>
# define TMPL1 template<class K>
# define SELF  subdivision<C,V,SURFACE,Cell> 

namespace mmx {
namespace shape {

TMPL struct subdivision;

template <class C> class surface ;
template <class Object, class CELL> class node;
template <class Object, class CELL> class kdtree;

//--------------------------------------------------------------------
struct subdivision_def {};

template<> struct use<subdivision_def, default_env>
  :public use<topology_def> 
  ,public use<cell3d_def> 
  ,public use<surface_def> 
{
  typedef cell<double> Cell;

  template<class Self, class CELL>
  static bool is_active(Self* self, CELL* cl) {
    return cl->is_active();
  }

  template<class Self, class CELL>
  static bool is_regular(Self* self, CELL* cl) {
    return cl->is_regular();
  }

  template<class Out, class CELL>  static void
  process_regular(Out* self, CELL* cl) {
    // put in the leaves and will be treated at the end
    self->m_leaves <<cl;
    //    return true; 
  }

  template<class Out, class CELL>  static void
  process_singular(Out* self, CELL* cl) {
    //    return true; 
  }

  template<class CI, class CO>  static int
  subdivide_cell(CI* cl, CO*& left, CO*& right) {
    typedef typename CO::CellBase CellBase;
    int v; double s;
    cl->split_position(v,s);
    cl->subdivide((CellBase*&)left,(CellBase*&)right,v,s);
    return v;
  }

  template<class Out, class CELL, class Node>  static unsigned 
  subdivide_node(Out* self, CELL* cl, Node * node) {
    CELL * left=0, * right=0;
    int v=subdivide_cell(cl,left,right);
    node->m_left = new Node(node, left,  Node::LEFT , v) ; self->m_nodes << node->m_left ;
    node->m_right= new Node(node, right, Node::RIGHT, v) ; self->m_nodes << node->m_right;
    self->m_map[node->m_left->get_cell()]= node->m_left;
    self->m_map[node->m_right->get_cell()]= node->m_right;
    return v ;
  }
};

//--------------------------------------------------------------------  
template<class C, class V, class Shape=typename SHAPE_OF(V), class Cell=cell<C,V> >
class subdivision {
public:

  typedef C                                  Scalar;
  typedef typename Cell::BoundingBox         BoundingBox;

  typedef node<Shape*, Cell*>                Node;
  typedef Cell                               Input;
  typedef kdtree_cell<Shape,Cell>            Output;
  
  subdivision(double e1= 0.1, double e2=0.01);

  ~subdivision(void) ;
  
  //  Node* root() {return m_output->m_tree.root();}
  
  Input*  input  (void)     { return m_input; }
  Output* output (void)     { return m_output; }

  void    set_input(Cell* bx);

  void    set_precision (double);
  void    set_smoothness(double);

  double  get_precision (void) const { return m_minprec ; }
  double  get_smoothness(void) const { return m_maxprec ; }

  void run(void);

  virtual void clear();

  //private:
  double              m_maxprec ;
  double              m_minprec ;
  
private:
  Cell*               m_input;

  Output*             m_output;
};
//--------------------------------------------------------------------
TMPL SELF::subdivision(double e1, double e2): m_maxprec(e1), m_minprec(e2)
{ 
  m_output = new Output;
}
//--------------------------------------------------------------------
TMPL SELF::~subdivision(void) {
  delete m_output;
}
//--------------------------------------------------------------------
TMPL void SELF::set_input(Cell* c0)
{ 
  Node* root = this->output()->root();
  root->set_cell(c0);
  m_output->m_nodes.push_back(root) ;
}
//--------------------------------------------------------------------
TMPL void SELF::set_smoothness(double eps) {
  m_maxprec = eps;
}
//--------------------------------------------------------------------
TMPL void SELF::set_precision(double eps) {
  m_minprec = eps;
}
//--------------------------------------------------------------------
TMPL void SELF::clear() {

}
//--------------------------------------------------------------------
TMPL void SELF::run() {

 typedef use<subdivision_def,V> ENV;

 double maxsz = this->get_smoothness()*this->output()->root()->get_cell()->size();
 double minsz = this->get_precision()*this->output()->root()->get_cell()->size();
    
 while(!this->output()->m_nodes.empty()) {
   Node* node = this->output()->m_nodes.front() ;
   Cell* cl = node->get_cell() ;
   
   if(ENV::is_active(this,cl)) {
     if(cl->size() > maxsz) 
       { 
         ENV::subdivide_node(this->output(), cl, node) ;
       } 
     else if(ENV::is_regular(this,cl)) 
       { 
         ENV::process_regular(this->output(),cl) ;
       } 
     else if(cl->size() > minsz ) 
       { 
         ENV::subdivide_node(this->output(), cl, node) ;
       } 
     else { 
       ENV::process_singular(this->output(), cl);
     }
   }
   this->output()->m_nodes.pop_front() ;
 }
}


//====================================================================
} ; // namespace shape
} ; // namespace mmx
//====================================================================
# undef TMPL1
# undef TMPL
# undef SELF 
# endif