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

Go to the documentation of this file.

/*****************************************************************************
 * M a t h e m a  g i x
 *****************************************************************************
 * Cell
 * 2008-03-20
 * Julien Wintz & Bernard Mourrain
 *****************************************************************************
 *               Copyright (C) 2008 INRIA Sophia-Antipolis
 *****************************************************************************
 * Comments :
 ****************************************************************************/

# ifndef shape_cell3d_list_hpp
# define shape_cell3d_list_hpp

# include <shape/cell3d.hpp>
# include <shape/solver_implicit.hpp>

# define TMPL template<class C, class V>
# define REF  REF_OF(V)
# define Point      point<C,REF>
# define SELF       cell3d_list<C,V>
# define Solver     solver_implicit<C,V>
# undef Cell
# undef Topology
//====================================================================
namespace mmx {
namespace shape {

template<class C, class V=default_env>
class cell3d_list: public cell3d<C,V>  {
public:
  typedef bounding_box<C,REF>      BoundingBox;
  typedef cell3d<C,REF>              Cell;
  typedef topology<C,V>          Topology;

  cell3d_list(void) ;
  cell3d_list(double xmin, double xmax) ;
  cell3d_list(double xmin, double xmax, double ymin, double ymax) ;
  cell3d_list(double xmin, double xmax, double ymin, double ymax, bool itr) ;
  cell3d_list(double xmin, double xmax, double ymin, double ymax, double zmin, double zmax) ;
  cell3d_list(const BoundingBox& bx);
  virtual ~cell3d_list(void) ;

  virtual bool is_active  (void) const;
  virtual bool is_regular (void) ;

  virtual bool insert_regular(Topology*);// = 0 ;
  virtual bool insert_singular(Topology*);// = 0 ;
  

  void push_back(Cell *) ; 
  int  count(void) { return m_objects.size() ; }


  virtual bool is_intersected(){return true;}

  virtual bool topology_regular(Topology*);// = 0 ;
  virtual void subdivide(Cell*& left, Cell*& right, int v, double s);// = 0 ;
  virtual void split_position(int& v, double& s);// = 0 ;

protected:
  Seq<Cell *>        m_objects  ;
  Seq<Point*>        m_singulars;
  mutable bool       m_intersect;
};
    
TMPL SELF::cell3d_list(void): m_intersect(false) {}
TMPL SELF::cell3d_list(double xmin, double xmax) : Cell(xmin, xmax), m_intersect(true) {}
TMPL SELF::cell3d_list(double xmin, double xmax, double ymin, double ymax) :  Cell(xmin, xmax, ymin, ymax), m_intersect(true) {}
TMPL SELF::cell3d_list(double xmin, double xmax, double ymin, double ymax, bool itr) : Cell(xmin, xmax, ymin, ymax), m_intersect(itr) {}
TMPL SELF::cell3d_list(double xmin, double xmax, double ymin, double ymax, double zmin, double zmax) : Cell(xmin, xmax, ymin, ymax, zmin, zmax), m_intersect(false) {}
TMPL SELF::cell3d_list(const BoundingBox& bx): Cell(bx), m_intersect(true)  {};

TMPL SELF::~cell3d_list(void) {
  foreach (Cell* m, m_objects) delete m;
}
  
TMPL  bool 
SELF::is_active() const {
  foreach (Cell* m, m_objects) 
    if(m->is_active()) return true;
  return false;
}

TMPL bool 
SELF::insert_regular(Topology* s) {
  //    foreach(Point* p, m_singulars) s->insert_singular(p);
  foreach(Cell*  m, m_objects)   m->insert_regular(s);
  return true;
}
  
TMPL bool 
SELF::insert_singular(Topology* s) {
  //s->singular(this);
  foreach(Cell * m, m_objects) m->insert_singular(s);
  return true;
}

TMPL void 
SELF::push_back(Cell *cv) {
  m_objects.push_back(cv);
}

TMPL bool 
SELF::is_regular() {
  foreach (Cell* m, this->m_objects) 
    if(!m->is_regular()) return false;
  
  if(this->m_objects.size() >1 && m_intersect) {
    //       for(unsigned i=0; i<m_objects.size();i++)
//              for(unsigned j=i+1; j< m_objects.size(); j++)
//                Solver::intersection(m_singulars, m_objects[i]->equation(), m_objects[j], (BoundingBox)*this);
    m_intersect = false;
  }
  
  if (m_singulars.size() > 1) return false;
  
  return true;
}

TMPL bool SELF::topology_regular (Topology* s) { 
  return true; 
}


TMPL void SELF::split_position(int& v, double& s) {
  double sx = (this->xmax()-this->xmin());
  double sy = (this->ymax()-this->ymin());
  double sz = (this->zmax()-this->zmin());
  
  if(sx<sy)
      if(sy<sz) {
        v=2;
        s=(this->zmax()+this->zmin())/2;
      } else {
        v=1;
        s=(this->ymax()+this->ymin())/2;
      }
    else
      if(sx<sz) {
        v=2;
        s=(this->zmax()+this->zmin())/2;
      } else {
        v=0;
        s=(this->xmax()+this->xmin())/2;
      }
}

TMPL void
SELF::subdivide(Cell*& , Cell*& , int , double ) {
  
  typedef SELF Cell_t;

}
  
} ; // namesapce shape
} ; // namespace mmx
# undef TMPL 
# undef SELF
# undef REF
# undef Point
# undef Solver 
# endif // shape_cell3d_list_hpp