include/shape/bcell2d.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_bcell2d_hpp
# define shape_bcell2d_hpp


# include <realroot/Seq.hpp>
# include <shape/point.hpp>
# include <shape/edge.hpp>
# include <shape/bounding_box.hpp>
# include <shape/bcell.hpp>
# include <shape/graph.hpp>

# define TMPL  template<class C, class V>
# define TMPL1 template<class V>
# define SELF bcell2d<C,V>
# define REF REF_OF(V)
# undef Topology
# undef Mesher2d
# undef Point
# undef Edge
//====================================================================
namespace mmx {
namespace shape {

// TMPL struct mesher2d;
// TMPL struct bcell2d;

TMPL class mesher2d;
TMPL class bcell2d;

//--------------------------------------------------------------------
TMPL
class bcell2d : public bcell<C,REF> {
public:

  typedef  topology<C,V>    Topology;
  //  typedef typename use<bcell2d_def,K>::Mesher2d  Mesher2d;

  typedef typename topology<C,V>::Point       Point;  
  typedef typename topology<C,V>::Edge        Edge;
  typedef bounding_box<C,REF>                 BoundingBox;
  typedef bcell<C,REF>                        Cell;

  bcell2d(void) ;
  bcell2d(const BoundingBox & bx): Cell(bx) {}
  bcell2d(double xmin, double xmax): Cell(xmin,xmax) {};
  bcell2d(double xmin, double xmax, double ymin, double ymax): Cell(xmin,xmax,ymin,ymax) {} ;


  virtual ~bcell2d(void) ;

//  virtual bool is_active  (void) const = 0;
//  virtual bool is_regular (void) = 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& t); 

  virtual Point* pair(Point * p, int & sgn) = 0;
  virtual Point* starting_point( int sgn)=0 ;

  bool  is_corner (void) const ;

  virtual unsigned nb_intersect(void) const {
    return (this->n_intersections.size()+
            this->s_intersections.size()+
            this->e_intersections.size()+
            this->w_intersections.size() );
  }

  virtual Seq<Point *> intersections() const{
//      std::cout<<"Intersection "
//              << this->n_intersections.size()<<" "
//              << this->s_intersections.size()<<" "
//              << this->e_intersections.size()<<" "
//              << this->w_intersections.size()<<std::endl;
      Seq<Point *> r;
      r<< this->s_intersections;
      r<< this->e_intersections;
      r<< this->n_intersections.reversed();
      r<< this->w_intersections.reversed();
  return ( r ); 
  }

  virtual Seq<Point *> intersections(int i) const{
      switch(i) {
      case 0:
          return s_intersections;
      case 1:
          return e_intersections;
      case 2:
          return n_intersections.reversed();
      case 3:
          return w_intersections.reversed();
      default:
          return (Seq<Point *>());
      }

  }

  inline bool is_border(void) const {
      return (  this->s_neighbors.size()==0 ||
                this->e_neighbors.size()==0 ||
                this->n_neighbors.size()==0 ||
                this->w_neighbors.size()==0  );
  }


  Seq<Point *>  s_intersections ;
  Seq<Point *>  e_intersections ;
  Seq<Point *>  n_intersections ;
  Seq<Point *>  w_intersections ;
  Seq<Point *>  m_singular ;
        /* Adjacency information */

  /*Pointer to graph instance of this bcell*/
  gNode<bcell2d*>* m_gnode;

  int side(Point *p)   {
      Seq<Point*> all;
      int s,i,a;
      s   = s_intersections.size();
      all = this->intersections();
      a   = all.size();
      i   = all.search(p);
      if (i==-1) return (-1);
      else return
         ( i<s                             ? 0 :
         ( i<s+(int)e_intersections.size() ? 1 :
         ( i<a-(int)w_intersections.size() ? 2 :
                                      3 )));
  }

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


  virtual Seq<bcell2d *>  neighbors()   {
      Seq<bcell2d *> r;
      r<< this->s_neighbors; 
      r<< this->e_neighbors; 
      r<< this->n_neighbors; 
      r<< this->w_neighbors;
  return ( r ); }

  Seq<bcell2d *>  s_neighbors ;
  Seq<bcell2d *>  e_neighbors ;
  Seq<bcell2d *>  n_neighbors ;
  Seq<bcell2d *>  w_neighbors ;

  virtual bcell2d * neighbor(Point * p)  {
      foreach( bcell2d *c, this->s_neighbors     )
          if ( c->n_intersections.member(p) )
          { 
              return c;
          }
      foreach( bcell2d *c, this->e_neighbors     )
          if ( c->w_intersections.member(p) )
          { 
              return c;
          }
      foreach( bcell2d *c, this->n_neighbors     )
          if ( c->s_intersections.member(p) )
          { 
              return c;
          }
      foreach( bcell2d *c, this->w_neighbors     )
          if ( c->e_intersections.member(p) )
          { 
              return c;
          }

      // Point p on boundary.
      //std::cout<<"... Point ("<<p->x()<<","<<p->y()<<") not found on neighbors of "<< this<<"("<<this->neighbors().size() <<")"<<std::endl; 
      return NULL;
  }

};

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

TMPL SELF::bcell2d(void) { }

TMPL SELF::~bcell2d(void) {}

// TMPL bool 
// SELF::insert_regular(Topology* t) {
//   Mesher2d* s= dynamic_cast<Mesher2d*>(t);
//   int n0=s->nbv();

//   foreach(Point* p, this->n_intersections) s->insert(p);
//   foreach(Point* p, this->e_intersections) s->insert(p);
//   foreach(Point* p, this->s_intersections) s->insert(p);
//   foreach(Point* p, this->w_intersections) s->insert(p);

//   if(s->nbv()> n0)
//     for(int i=n0; i<((int)s->nbv()-1);i+=2) {
//       s->insert( s->vertices(i),s->vertices(i+1) ) ;
//       //s->m_edges << new Edge(s->vertices(i),s->vertices(i+1));
//     }
//   return true;
// }


// TMPL bool 
// SELF::insert_singular(Topology* t) {
//     unsigned ni= this->nb_intersect() ;

// // std::cout<<"singular bcell with "<<ni<<" pts"<<std::endl;

//   if(ni>1)
//     t->insert((BoundingBox*)this,true);
//   else
//     t->insert((BoundingBox*)this,false);

//   if(this->m_singular.size()>0) {
//     Mesher2d* s= dynamic_cast<Mesher2d*>(t);
//     Point *c=this->m_singular[0];
//     s->m_specials<<c;
//     foreach(Point* p, this->n_intersections) s->insert(new Edge(p,c));
//     foreach(Point* p, this->e_intersections) s->insert(new Edge(p,c));
//     foreach(Point* p, this->s_intersections) s->insert(new Edge(p,c));
//     foreach(Point* p, this->w_intersections) s->insert(new Edge(p,c));
//   }
//   return true;
// }


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::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))
        {
          //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) )
        {
          //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)) 
        {
            a->n_neighbors<< cl;
            i= cl->s_neighbors.search(this);
            cl->s_neighbors[i]= a;
            flag=true;
        }
        if ( check_overlap(cl,b,0) )
        {
            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::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)) 
            {
                //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) )
            {
                //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)) 
        {
            a->e_neighbors<< cl;
            i= cl->w_neighbors.search(this);
            cl->w_neighbors[i]= a;
            flag=true;
        }
        if ( check_overlap(cl,b,1) )
        {
            b->e_neighbors<< cl;
            if (!flag)
            {
                i= cl->w_neighbors.search(this);
                cl->w_neighbors[i]= b;
            }
            else
                cl->w_neighbors << b;
        }
    }
}

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() );
    else       //direction v=1
        return !( a->ymax()<= b->ymin() ||
                  b->ymax()<= a->ymin() );
}

TMPL inline void 
SELF::disconnect()
{
    this->e_neighbors.clear();
    this->w_neighbors.clear();
    this->n_neighbors.clear();
    this->s_neighbors.clear();
}

TMPL bool 
SELF::is_corner() const {

    if (this->s_neighbors.size()==0 &&
        this->e_neighbors.size()==0  )
        return true;
    else if (this->e_neighbors.size()==0 &&
             this->n_neighbors.size()==0 )
        return true;
    else if (this->n_neighbors.size()==0 &&
             this->w_neighbors.size()==0  )
        return true;
    else if (this->w_neighbors.size()==0 &&
             this->s_neighbors.size()==0 )
        return true;
    
    return false;
}


TMPL
inline void print_neighbors(SELF * a) //for testing 
{
                std::cout<< "Cell               : " << a  <<std::endl;
    std::cout<< "EAST, " <<a->e_neighbors.size()  << std::endl;
    foreach(SELF* cl,a->e_neighbors)
                                std::cout<< cl << std::endl;
    std::cout<< "WEST, " <<a->w_neighbors.size() << std::endl;
    foreach(SELF* cl,a->w_neighbors)
                                std::cout<< cl << std::endl;
    std::cout<< "NORTH, " <<a->n_neighbors.size() << std::endl;
    foreach(SELF* cl,a->n_neighbors)
                                std::cout<< cl << std::endl;
    std::cout<< "SOUTH, " <<a->s_neighbors.size() <<std::endl;
    foreach(SELF* cl,a->s_neighbors)
                                std::cout<< cl << std::endl;
}

TMPL
inline void print_intersections(SELF * a) //for testing 
{
    typedef typename topology<C,V>::Point Point;
                std::cout<< "Cell               : " << a  <<std::endl;
    std::cout<< "EAST, " <<a->e_intersections.size()  << std::endl;
    foreach(Point* cl,a->e_intersections)
                                std::cout<< cl->x()<<"  "<<cl->y() << std::endl;
    std::cout<< "WEST, " <<a->w_intersections.size() << std::endl;
    foreach(Point* cl,a->w_intersections)
                                std::cout<< cl->x()<<"  "<<cl->y() << std::endl;
    std::cout<< "NORTH, " <<a->n_intersections.size() << std::endl;
    foreach(Point* cl,a->n_intersections)
                                std::cout<< cl->x()<<"  "<<cl->y() << std::endl;
    std::cout<< "SOUTH, " <<a->s_intersections.size() <<std::endl;
    foreach(Point* cl,a->s_intersections)
                                std::cout<< cl->x()<<"  "<<cl->y() << std::endl;
}


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

---