/Users/mourrain/Devel/mmx/shape/include/shape/cell3d.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 & Angelos Mantzaflaris
 *****************************************************************************
 *               Copyright (C) 2008 INRIA Sophia-Antipolis
 *****************************************************************************
 * Comments :
 ****************************************************************************/
# ifndef shape_cell3d_hpp
# define shape_cell3d_hpp

# include <shape/vertex.hpp>
# include <shape/edge.hpp>
# include <shape/face.hpp>
# include <shape/bounding_box.hpp>
# include <shape/cell.hpp>
# include <shape/graph.hpp>
# include <shape/topology.hpp>
//# include <shape/tpl3d.hpp>
# define TMPL template<class C, class V>
# define TMPL1 template<class K>
# define SELF cell3d<C,V>
//====================================================================
namespace mmx { namespace shape {

TMPL struct cell3d;
TMPL struct tpl3d;
//--------------------------------------------------------------------
struct cell3d_def {};
template<> struct use<cell3d_def>
  :public use<cell_def>
{
  typedef cell3d<double,double> Cell3d;
};

//--------------------------------------------------------------------
template<class C, class V=default_env>
class cell3d : public  bounding_box<C,V>
{
public:
  typedef topology<C,REF_OF(V)>         Topology;  
  typedef tpl3d<C,V>                    Topology3d;  
  typedef typename Topology::Point      Point;  
  typedef typename Topology::Edge       Edge;

  typedef cell3d<C,V>                   CellBase;
  typedef cell<C,V>                     Cell;
  typedef typename Cell::BoundingBox    BoundingBox;

  cell3d(void) {};
  cell3d(const BoundingBox& bx): BoundingBox(bx) {} ;
  virtual ~cell3d(void) {};

  virtual bool        is_regular(void) = 0 ;
  virtual bool        is_active (void) const = 0 ;
  virtual bool        is_intersected(void)   = 0 ;
  virtual int         subdivide(SELF*& left, SELF*& right);
  virtual void        subdivide(SELF*& left, SELF*& right, int v, double s)=0;

  virtual void        split_position(int &v, double& s) ;
  virtual bool        insert_regular (Topology*) = 0 ;
  virtual bool        insert_singular(Topology*) = 0 ;
  
  virtual Point       center(void) const { 
    // XXX ???
    return Point(this->xmax()-this->xmin(),
                 this->ymax()-this->ymin(),
                 this->zmax()-this->zmin()); 
  }

  BoundingBox boundingBox() const { return (BoundingBox)*this; }


  virtual bool topology_regular (Topology*) = 0 ;
  virtual void polygonise (Topology3d*) =0;

  inline void disconnect();
  inline void connect0(SELF * a, SELF * b);
  inline void connect1(SELF * a, SELF * b) ;
  inline void connect2(SELF * a, SELF * b) ;
  inline void join0( SELF * b) ;
  inline void join1( SELF * b) ;
  inline void join2( SELF * b) ;

  Seq<Point *>  m_boundary;
  Seq<Point *>  m_singular ;
  int           m_type;

  /*Pointer to graph instance of this cell*/
  gNode<cell3d*>* m_gnode;

  /*Neighbor cells*/
  Seq<cell3d *>  neighbors(){ 
    Seq<cell3d *> t;
    t<< s_neighbors ;
    t<< e_neighbors ;
    t<< n_neighbors ;
    t<< b_neighbors ;
    t<< w_neighbors ;
    t<< f_neighbors ;
    return t;     } ;

  Seq<cell3d *>  s_neighbors ;
  Seq<cell3d *>  e_neighbors ;
  Seq<cell3d *>  n_neighbors ;
  Seq<cell3d *>  w_neighbors ;
  Seq<cell3d *>  f_neighbors ;
  Seq<cell3d *>  b_neighbors ;

};

//====================================================================
TMPL int
SELF::subdivide(SELF*& Left, SELF*& Right) {
  int v; double s;
  this->split_position(v,s);
  this->subdivide(Left,Right,v,s);
  return v;
}
//====================================================================
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 inline void 
SELF::join0(SELF * b) //left,right
{
    this->e_neighbors << b; 
    b->w_neighbors << this; 
}
    
TMPL inline void 
SELF::join1(SELF * b) //up,down
{
    b->s_neighbors << this;
    this->n_neighbors << b;
}

TMPL inline void 
SELF::join2(SELF * b) //front,back
{
    b->f_neighbors << this;
    this->b_neighbors << b;
}

TMPL inline void 
SELF::connect0(SELF * a, SELF * b) 
{
    int i;
    bool flag;

    //copy horizontally
    b->e_neighbors= this->e_neighbors ;
    foreach(SELF* cl,b->e_neighbors) {
      i= cl->w_neighbors.search(this);
      cl->w_neighbors[i]= b;
    }

    a->w_neighbors= this->w_neighbors ;
    foreach(SELF* cl,a->w_neighbors) {
      i= cl->e_neighbors.search(this);
      cl->e_neighbors[i]= a;
    }

    //update vertically
    foreach(SELF* cl,this->s_neighbors) {
      flag=false;
      if ( check_overlap(cl,a,0) //)
           && ( check_overlap(cl,a,1) || check_overlap(cl,a,2)) )
        {
          //assert( cl->ymax()== a->ymin() );
          a->s_neighbors<< cl;
          i= cl->n_neighbors.search(this);
          cl->n_neighbors[i]= a;
          flag=true;
        }
      if ( check_overlap(cl,b,0) //)
           && ( check_overlap(cl,a,1) || check_overlap(cl,a,2)) )
        {
          //assert( cl->ymax()== b->ymin() );
          b->s_neighbors<< cl;
          if (!flag)
            {
              i= cl->n_neighbors.search(this);
              cl->n_neighbors[i]= b;
            }
          else
            cl->n_neighbors << b;
        }
    }
    foreach(SELF* cl,this->n_neighbors) {
        flag=false;
        if ( check_overlap(cl,a,0) //)
             && ( check_overlap(cl,a,1) || check_overlap(cl,a,2)) ) 
        {
            a->n_neighbors<< cl;
            i= cl->s_neighbors.search(this);
            cl->s_neighbors[i]= a;
            flag=true;
        }
        if ( check_overlap(cl,b,0) //)
             && ( check_overlap(cl,a,1) || check_overlap(cl,a,2)) )
        {
            b->n_neighbors<< cl;
            if (!flag)
            {
              i= cl->s_neighbors.search(this);
              cl->s_neighbors[i]= b;
            }
            else
              cl->s_neighbors << b;
        }
    } 

    //update depth
    foreach(SELF* cl,this->f_neighbors) {
      flag=false;
      if ( check_overlap(cl,a,0) //)
           && ( check_overlap(cl,a,1) || check_overlap(cl,a,2)) )
        {
          //assert( cl->ymax()== a->ymin() );
          a->f_neighbors<< cl;
          i= cl->b_neighbors.search(this);
          cl->b_neighbors[i]= a;
          flag=true;
        }
      if ( check_overlap(cl,b,0) //)
           && ( check_overlap(cl,a,1) || check_overlap(cl,a,2)) )
        {
          //assert( cl->ymax()== b->ymin() );
          b->f_neighbors<< cl;
          if (!flag)
            {
              i= cl->b_neighbors.search(this);
              cl->b_neighbors[i]= b;
            }
          else
            cl->b_neighbors << b;
        }
    }
    foreach(SELF* cl,this->b_neighbors) {
        flag=false;
        if ( check_overlap(cl,a,0) //)
           && ( check_overlap(cl,a,1) || check_overlap(cl,a,2)) ) 
        {
            a->b_neighbors<< cl;
            i= cl->f_neighbors.search(this);
            cl->f_neighbors[i]= a;
            flag=true;
        }
        if ( check_overlap(cl,b,0) //)
           && ( check_overlap(cl,a,1) || check_overlap(cl,a,2)) )
        {
            b->b_neighbors<< cl;
            if (!flag)
            {
              i= cl->f_neighbors.search(this);
              cl->f_neighbors[i]= b;
            }
            else
              cl->f_neighbors << b;
        }
    }
}

TMPL inline void 
SELF::connect1(SELF * a, SELF * b) 
{
    int i;
    bool flag;

    //copy vertically
    a->s_neighbors= this->s_neighbors ;
    foreach(SELF* cl,a->s_neighbors) {
      i= cl->n_neighbors.search(this);
      cl->n_neighbors[i]= a;
    }
    b->n_neighbors= this->n_neighbors ;
    foreach(SELF* cl,b->n_neighbors) {
      i= cl->s_neighbors.search(this);
      cl->s_neighbors[i]= b;
    }
    
    //update horizontally
    foreach(SELF* cl,this->w_neighbors) {
      flag=false;
      if ( check_overlap(cl,a,1) //) 
        && ( check_overlap(cl,a,0) || check_overlap(cl,a,2)) ) 
        {
          //assert( cl->xmax()== a->xmin() );
          a->w_neighbors<< cl;
          i= cl->e_neighbors.search(this);
          cl->e_neighbors[i]= a;
          flag=true;
        }
      if ( check_overlap(cl,b,1) //)
        && ( check_overlap(cl,a,0) || check_overlap(cl,a,2)) ) 
        {
          //assert( cl->xmax()== b->xmin() );
          b->w_neighbors<< cl;
          if (!flag)
            {
              i= cl->e_neighbors.search(this);
              cl->e_neighbors[i]= b;
            }
          else
            cl->e_neighbors << b;
        }
    }
    foreach(SELF* cl,this->e_neighbors) {
      flag=false;
      if ( check_overlap(cl,a,1) //)
        && ( check_overlap(cl,a,0) || check_overlap(cl,a,2)) )  
        {
          a->e_neighbors<< cl;
          i= cl->w_neighbors.search(this);
          cl->w_neighbors[i]= a;
          flag=true;
        }
      if ( check_overlap(cl,b,1) //)
        && ( check_overlap(cl,a,0) || check_overlap(cl,a,2)) ) 
        {
          b->e_neighbors<< cl;
          if (!flag)
            {
              i= cl->w_neighbors.search(this);
              cl->w_neighbors[i]= b;
            }
          else
            cl->w_neighbors << b;
        }
    }


    //update depth
    foreach(SELF* cl,this->f_neighbors) {
      flag=false;
      if ( check_overlap(cl,a,1) //)
        && ( check_overlap(cl,a,0) || check_overlap(cl,a,2)) )  
        {
          //assert( cl->xmax()== a->xmin() );
          a->f_neighbors<< cl;
          i= cl->b_neighbors.search(this);
          cl->b_neighbors[i]= a;
          flag=true;
        }
      if ( check_overlap(cl,b,1) //)
        && ( check_overlap(cl,a,0) || check_overlap(cl,a,2)) ) 
        {
          //assert( cl->xmax()== b->xmin() );
          b->f_neighbors<< cl;
          if (!flag)
            {
              i= cl->b_neighbors.search(this);
              cl->b_neighbors[i]= b;
            }
          else
            cl->b_neighbors << b;
        }
    }
    foreach(SELF* cl,this->b_neighbors) {
      flag=false;
      if ( check_overlap(cl,a,1) //)
        && ( check_overlap(cl,a,0) || check_overlap(cl,a,2)) )  
        {
          a->b_neighbors<< cl;
          i= cl->f_neighbors.search(this);
          cl->f_neighbors[i]= a;
          flag=true;
        }
      if ( check_overlap(cl,b,1) //)
        && ( check_overlap(cl,a,0) || check_overlap(cl,a,2)) ) 
        {
          b->b_neighbors<< cl;
          if (!flag)
            {
              i= cl->f_neighbors.search(this);
              cl->f_neighbors[i]= b;
            }
          else
            cl->f_neighbors << b;
        }
    }
}

//--------------------------------------------------------------------
TMPL inline void 
SELF::connect2(SELF * a, SELF * b) 
{
    int i;
    bool flag;

    //copy vertically
    a->f_neighbors= this->f_neighbors ;
    foreach(SELF* cl,a->f_neighbors) {
      i= cl->b_neighbors.search(this);
      cl->b_neighbors[i]= a;
    }
    b->b_neighbors= this->b_neighbors ;
    foreach(SELF* cl,b->b_neighbors) {
      i= cl->f_neighbors.search(this);
      cl->f_neighbors[i]= b;
    }
    
    //update horizontally
    foreach(SELF* cl,this->w_neighbors) {
      flag=false;
      if ( check_overlap(cl,a,2) //)
        && ( check_overlap(cl,a,0) || check_overlap(cl,a,1)) )  
        {
          //assert( cl->xmax()== a->xmin() );
          a->w_neighbors<< cl;
          i= cl->e_neighbors.search(this);
          cl->e_neighbors[i]= a;
          flag=true;
        }
      if ( check_overlap(cl,b,2) //)
        && ( check_overlap(cl,a,0) || check_overlap(cl,a,1)) )  
        {
          //assert( cl->xmax()== b->xmin() );
          b->w_neighbors<< cl;
          if (!flag)
            {
              i= cl->e_neighbors.search(this);
              cl->e_neighbors[i]= b;
            }
          else
            cl->e_neighbors << b;
        }
    }
    foreach(SELF* cl,this->e_neighbors) {
      flag=false;
      if ( check_overlap(cl,a,2) //)
        && ( check_overlap(cl,a,0) || check_overlap(cl,a,1)) )   
        {
          a->e_neighbors<< cl;
          i= cl->w_neighbors.search(this);
          cl->w_neighbors[i]= a;
          flag=true;
        }
      if ( check_overlap(cl,b,2) //)
        && ( check_overlap(cl,a,0) || check_overlap(cl,a,1)) )  
        {
          b->e_neighbors<< cl;
          if (!flag)
            {
              i= cl->w_neighbors.search(this);
              cl->w_neighbors[i]= b;
            }
          else
            cl->w_neighbors << b;
        }
    }
    //update vertically
    foreach(SELF* cl,this->s_neighbors) {
      flag=false;
      if ( check_overlap(cl,a,0) //)
        && ( check_overlap(cl,a,0) || check_overlap(cl,a,1)) )  
        {
          //assert( cl->ymax()== a->ymin() );
          a->s_neighbors<< cl;
          i= cl->n_neighbors.search(this);
          cl->n_neighbors[i]= a;
          flag=true;
        }
      if ( check_overlap(cl,b,0) //)
        && ( check_overlap(cl,a,0) || check_overlap(cl,a,1)) )  
        {
          //assert( cl->ymax()== b->ymin() );
          b->s_neighbors<< cl;
          if (!flag)
            {
              i= cl->n_neighbors.search(this);
              cl->n_neighbors[i]= b;
            }
          else
            cl->n_neighbors << b;
        }
    }
    foreach(SELF* cl,this->n_neighbors) {
        flag=false;
        if ( check_overlap(cl,a,2) //)
        && ( check_overlap(cl,a,0) || check_overlap(cl,a,1)) )  
        {
          a->n_neighbors<< cl;
          i= cl->s_neighbors.search(this);
          cl->s_neighbors[i]= a;
          flag=true;
        }
        if ( check_overlap(cl,b,2) //)
        && ( check_overlap(cl,a,0) || check_overlap(cl,a,1)) )  
          {
            b->n_neighbors<< cl;
            if (!flag) {
              i= cl->s_neighbors.search(this);
              cl->s_neighbors[i]= b;
            }
            else
              cl->s_neighbors << b;
        }
    }
}
//--------------------------------------------------------------------
TMPL inline void 
SELF::disconnect()
{
    this->e_neighbors.clear();  
    this->w_neighbors.clear();  
    this->n_neighbors.clear();  
    this->s_neighbors.clear();  
    this->b_neighbors.clear();  
    this->f_neighbors.clear();  
}
//--------------------------------------------------------------------
TMPL
inline bool check_overlap(SELF * a, SELF * b, int v) //left,right or up,down
{// check if a,b overlap wrt v-th coordinate
    if (v==0)  //direction v=0
      return !( a->xmax()<= b->xmin() ||
                b->xmax()<= a->xmin() );
    if (v==1)  //direction v=1
      return !( a->ymax()<= b->ymin() ||
                b->ymax()<= a->ymin() );
    if (v==2)  //direction v=2
      return !( a->zmax()<= b->zmin() ||
                b->zmax()<= a->zmin() );
    return false;
}

  //--------------------------------------------------------------------
template<class CELL> inline void 
cell3d_split(CELL * left, CELL * right, CELL* cl, int v, double s) {
 if(v==0) {
   left = new CELL(*cl);
   right = new CELL(*cl);
   left->set_xmax(s);
   right->set_xmin(s);
   cl->connect0(left,right);
   left->join0(right);
 } else if (v==1) {
   left = new CELL(*cl);
   right = new CELL(*cl);
   left->set_ymax(s);
   right->set_ymin(s);
   cl->connect1(left,right);
   left->join2(right);
 } else if (v==2) {
   left = new CELL(*cl);
   right = new CELL(*cl);
   left->set_zmax(s);
   right->set_zmin(s);
   cl->connect2(left,right);
   left->join2(right);
 }
}
//--------------------------------------------------------------------
template<class CELL> bool 
is_adjacentpl3d(CELL* c1,CELL* c2){
  if(c1->xmax()<c2->xmin() || c2->xmax()<c1->xmin())
    return false;
  if(c1->ymax()<c2->ymin() || c2->ymax()<c1->ymin())
    return false;
  if(c1->zmax()<c2->zmin() || c2->zmax()<c1->zmin())
    return false;
  if((c1->xmax()==c2->xmin() || c2->xmax()==c1->xmin())) {
    if((c1->ymax()==c2->ymin() || c2->ymax()==c1->ymin()) ||
       (c1->zmax()==c2->zmin() || c2->zmax()==c1->zmin()) )
      return false;
  } else if((c1->ymax()==c2->ymin() || c2->ymax()==c1->ymin()) &&
            (c1->zmax()==c2->zmin() || c2->zmax()==c1->zmin()) )
    return false;
  return true;
}
//--------------------------------------------------------------------
#define xMIN (c2->xmin()<c3->xmin()?c3->xmin():c2->xmin())
#define xMAX (c2->xmax()<c3->xmax()?c2->xmax():c3->xmax())
#define yMIN (c2->ymin()<c3->ymin()?c3->ymin():c2->ymin())
#define yMAX (c2->ymax()<c3->ymax()?c2->ymax():c3->ymax())
#define zMIN (c2->zmin()<c3->zmin()?c3->zmin():c2->zmin())
#define zMAX (c2->zmax()<c3->zmax()?c2->zmax():c3->zmax())

template<class CELL> bool 
is_adjacentpl3d(CELL* c1,CELL* c2, CELL* c3){

  if(c1->xmax()< xMIN || xMAX <c1->xmin())
    return false; 
  if(c1->ymax()<yMIN || yMAX<c1->ymin())
    return false;
  if(c1->zmax()<zMIN || zMAX<c1->zmin())
    return false;

  if((c1->xmax()==xMIN || xMAX==c1->xmin())) {
    if((c1->ymax()==yMIN || yMAX==c1->ymin()) ||
       (c1->zmax()==zMIN || zMAX==c1->zmin()) )
      return false;
  } else if((c1->ymax()==yMIN || yMAX==c1->ymin()) &&
            (c1->zmax()==zMIN || zMAX==c1->zmin()) )
    return false;
  return true;
}
#undef xMIN
#undef xMAX
#undef yMIN
#undef yMAX
#undef zMIN
#undef zMAX
//====================================================================
} ; // namespace shape
} ; // namespace mmx
# undef TMPL
# undef TMPL1
# undef SELF
# endif // shape_cell3d_hpp