include/shape/bcell2d_voronoi_impl2d.hpp

Go to the documentation of this file.

/*****************************************************************************
 * M a t h e m a g i x
 *****************************************************************************
 * bcell2d_voronoi_site2d.hpp
 * 2010-04-05
 * Angelos Mantzaflaris
 *****************************************************************************
 *               Copyright (C) 2010 INRIA Sophia-Antipolis
 *****************************************************************************
 * Comments :
 ****************************************************************************/

# ifndef shape_bcell2d_voronoi_impl2d_hpp
# define shape_bcell2d_voronoi_impl2d_hpp

# include <realroot/Interval.hpp>
# include <realroot/ring_bernstein_tensor.hpp>
# include <realroot/Seq.hpp>
# include <shape/point.hpp>
# include <shape/solver_implicit.hpp>
# include <shape/bcell2d.hpp>
# include <shape/voronoi_site2d.hpp>

# include <shape/bcell3d_algebraic_surface.hpp>

# include <stack>
# define  STACK std::stack<Point*>

# define TMPL template<class C, class V>
# define VoronoiSite2d voronoi_site2d<C,V>
# define SELF bcell2d_voronoi_impl2d<C,V>
# define Cell3dAlgebraicSurface bcell3d_algebraic_surface<C,V>
# define REF REF_OF(V)

# undef Cell_t
//====================================================================
namespace mmx {
namespace shape {
//====================================================================
// TMPL struct bcell2d_voronoi_impl2d;
// //--------------------------------------------------------------------
// TMPL struct with_cell2d_voronoi_impl2d { 
//   typedef bcell2d_voronoi_impl2d<C,V> Cell2dVoronoiSite2d; 
// };
//--------------------------------------------------------------------
struct bcell2d_voronoi_impl2d_def {};
template<> struct use<bcell2d_voronoi_impl2d_def> 
//  :public use<bcell2d_algebraic_curve_def> 
//   ,public with_voronoi_impl2d<K>
//   ,public with_algebraic_set<K>
//   ,public with_cell2d_voronoi_impl2d<K>
{
  typedef bounding_box<double,double> Bounding_Box;
  //  typedef typename bcell2d_def<K>::Point Vector;
  //  typedef polynomial< Interval<double>, with<Bernstein> > Polynomial;
  typedef polynomial< double, with<Bernstein> > Polynomial;
//    typedef polynomial< mmx::GMP::rational, with<Bernstein> > Polynomial;
  
  typedef solver_implicit<double,double> Solver;
  
//   template<class CELL> static void 
//   subdivisor(CELL & cl, CELL*&, CELL*&, int v, double s);

};

//--------------------------------------------------------------------
// TMPL1
// template<class CELL> void 
// use<bcell2d_voronoi_impl2d_def,V>::subdivisor(CELL& cl, CELL*& left, CELL*& right, int v, double s)  
// {
//   use<bcell2d_algebraic_curve_def,V>::subdivisor(cl,left,right,v,s);
// }

//====================================================================
TMPL struct bcell2d_voronoi_impl2d : public  bcell3d_algebraic_surface<C,V> 
{
public:
  typedef typename mesher2d<C,V>::Point          Point;
  typedef point<C,2,REF> Vector; 
  typedef typename mesher2d<C,V>::Edge                          Edge;
  typedef bcell<C,REF>           Cell;

  typedef typename bcell2d_voronoi_impl2d<C,V>::Polynomial     Polynomial;
  typedef bounding_box<C,REF>  BoundingBox;

//  typedef typename use<bcell2d_voronoi_impl2d_def,V>::Solver         Solver;
  typedef topology<C,V>     Topology;
  typedef mesher2d<C,V>     Mesher2d;

  bcell2d_voronoi_impl2d(const Polynomial &, const BoundingBox&);
  bcell2d_voronoi_impl2d(const char*, const BoundingBox&);
  bcell2d_voronoi_impl2d(VoronoiSite2d*, const BoundingBox &);
  bcell2d_voronoi_impl2d(const SELF& cl)
  : Cell3dAlgebraicSurface(cl) {}

  Polynomial equation(void) { return  this->m_polynomial; }
  
  bool  is_active (void) ;
  bool  is_regular(void) ;
  bool  is_intersected(void) {return (this->nb_intersect()>0);};

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

  virtual bool insert_regular (Topology*);// = 0;
  virtual bool insert_singular(Topology*);// = 0;
  virtual void subdivide(Cell*& left, Cell*& right, int v, double s);
  Vector gradient(const Point& p);

  inline double lower();
  inline double upper();

  void compute_boundary();

  Seq<Point *>  s_intersections ;
  Seq<Point *>  e_intersections ;
  Seq<Point *>  n_intersections ;
  Seq<Point *>  w_intersections ;


  virtual Seq<Point *> intersections() const{
    std::cout<<"NEED intersections \n";
      Seq<Point *> r;
      r<< this->s_intersections;
      r<< this->e_intersections;
      r<< this->n_intersections.reversed();
      r<< this->w_intersections.reversed();
  return ( r ); 
  }
    
  unsigned nb_intersect(void) const {
    return (this->n_intersections.size()+
                  this->s_intersections.size()+
            this->e_intersections.size()+
            this->w_intersections.size() );
  }

private:

//  double upp, low; //upper and lower bound on the value in the domain
};

//====================================================================
  TMPL inline double
  SELF::lower()
  {
    return  double(*std::min_element( this->m_polynomial.begin(), 
                                         this->m_polynomial.end() ) );
  }
//====================================================================
  TMPL inline double
  SELF::upper()
  {
    return double(*std::max_element( this->m_polynomial.begin(),
                                     this->m_polynomial.end() ) );
  }

//====================================================================
  TMPL void 
  SELF::compute_boundary()
  {
    
    //   BoundingBox * b( (BoundingBox*)this );
    //Seq<mmx::GMP::rational> bx;
    //bx<<as<mmx::GMP::rational>( ((BoundingBox*)this)->xmin());
    //bx<<as<mmx::GMP::rational>(this->xmax());
    //bx<<as<mmx::GMP::rational>(this->ymin());
    //bx<<as<mmx::GMP::rational>(this->ymax());
    
    //Solver::edge_point(this->n_intersections, this->m_polynomial, Solver::north_edge, b);
    //Solver::edge_point(this->s_intersections, this->m_polynomial, Solver::south_edge, b);
    //Solver::edge_point(this->w_intersections, this->m_polynomial, Solver::west_edge , b);
    //Solver::edge_point(this->e_intersections, this->m_polynomial, Solver::east_edge , b);
    // Solver::extremal(this->m_singular, this->m_polynomial, b); 

  }

//====================================================================
TMPL inline void 
print(SELF* cv) {
  typedef typename SELF::Point Point;
  std::cout << "point(s) b: "; 
  foreach(Point* p, cv->n_intersections)  
    std::cout <<" ["<<p->x()<<" "<<p->y()<<"]";
  foreach(Point* p, cv->s_intersections)  
    std::cout <<" ["<<p->x()<<" "<<p->y()<<"]";
  foreach(Point* p, cv->w_intersections)  
    std::cout <<" ["<<p->x()<<" "<<p->y()<<"]";
  foreach(Point* p, cv->e_intersections)  
    std::cout <<" ["<<p->x()<<" "<<p->y()<<"]";
  std::cout<<std::endl;
  
  std::cout << "Point(s) s: "; 
  foreach(Point* p, cv->m_singular)  
    std::cout <<" ["<<p->x()<<" "<<p->y()<<"]";
  std::cout<<std::endl;
}
//--------------------------------------------------------------------
TMPL
SELF::bcell2d_voronoi_impl2d(const Polynomial& pol, const BoundingBox& bx)
  : Cell3dAlgebraicSurface(pol,bx)
{
  //low=upp=NULL;
}

//--------------------------------------------------------------------
TMPL
SELF::bcell2d_voronoi_impl2d(const char* s, const BoundingBox & b)
  : Cell3dAlgebraicSurface(s,b)
{
  //low=upp=NULL;
}
//--------------------------------------------------------------------  
TMPL
SELF::bcell2d_voronoi_impl2d(VoronoiSite2d* cv, const BoundingBox & b)
  : Cell3dAlgebraicSurface(cv->distfunc(),b)
{
  //low=upp=NULL;
  std::cout<<"created voronoi bcell, "<< this->equation() <<std::endl;    
  std::cout<<"box "<< b<<", zmax "<< b.zmax() <<std::endl;    
  

}
//--------------------------------------------------------------------
TMPL bool 
SELF::is_regular() {

    return true;
}
//--------------------------------------------------------------------
TMPL bool 
SELF::is_active() {

    return ( false );

}
//--------------------------------------------------------------------
TMPL bool 
SELF::insert_regular(Topology* t) {

  //std::cout<<"regular voronoi bcell" <<std::endl;    
    t->insert((BoundingBox*)this,false);
    return true;

}
//--------------------------------------------------------------------
TMPL bool 
SELF::insert_singular(Topology* t) {

    return true;
  }

//--------------------------------------------------------------------
TMPL void
SELF::subdivide(Cell*& Left, Cell*& Right, int v, double s) {

  std::cout<<"NEED to subdivide!\n";
//  bcell3d_subdivisor<C,V>::subdivide( *this,(SELF*&)Left,(SELF*&)Right,v,s);
}
//--------------------------------------------------------------------
TMPL  typename SELF::Vector
SELF::gradient(const Point& p) {
  Polynomial 
    dx= diff(this->m_polynomial,0),
    dy= diff(this->m_polynomial,1);
  double 
    u0= (p[0]-this->xmin())/(this->xmax()-this->xmin()),
    u1= (p[1]-this->ymin())/(this->ymax()-this->ymin());
  Vector v;
  v[0] = dx(u0,u1);
  v[1] = dy(u0,u1);
  return v;
}

//--------------------------------------------------------------------
TMPL typename SELF::Point*
SELF::starting_point(int sgn) {//

//std::cout<<"startingPoint.site2d"<<std::endl;

      Seq<Point*> all;
      unsigned a;
      all = this->intersections();
      a   = all.size();

      //std::cout<<this<<" , "<<a<<std::endl;
      //foreach(Point*p,all)
      //  std::cout<<p->x()<<" "<<p->y()<<" "<<p->z()<<std::endl;

      assert(a==2);

      int ev(0);
      int u ;//position of p
      unsigned
          s=this->s_intersections.size() ,// ~0
          e=this->e_intersections.size() ,// ~1
          //n=this->n_intersections.size() ,// ~2
          w=this->w_intersections.size() ;// ~3

      u= ( 0<s   ? 0 :
         ( 0<s+e ? 1 :
         ( 0<a-w ? 2 :
                   3 )));

      int * sz = this->m_polynomial.rep().szs();
      int * st = this->m_polynomial.rep().str();

          switch (u){
          case 0:
              ev= (this->m_polynomial[0] >0 ? 1:-1);
         break;
          case 1:
              ev= (this->m_polynomial[(sz[0]-1)*st[0]] >0 ? 1:-1);      
         break;
          case 2:
              ev= (this->m_polynomial[sz[0]*sz[1]-1]>0 ? 1:-1);
          break;
          case 3:
              ev= (this->m_polynomial[(sz[1]-1)*st[1]] >0 ? 1:-1);
          break;
          }

          if (ev*sgn>0)  
            return all[0]; 
          else                
            return all[1];
}

//--------------------------------------------------------------------
TMPL typename SELF::Point*
SELF::pair( typename SELF::Point* p, int& sgn) {
     // Pair: returns a neighboring point on the component (p,sgn)
     // The candidates are the 2 neighbor intersections of p in *this

      Seq<Point*> all;
      int a;
      all= this->intersections();
      a   = all.size();
      if (a==2)// regular bcell with a single branch
         { return (all[0]==p ? all[1]: all[0]);  }

        std::cout<<"...pair Trouble"<< this<<std::endl;
        return (all[0]); 
}

//====================================================================
} ; // namespace shape
} ; // namespace mmx
# undef Solver
# undef SELF
# undef TMPL
# undef Cell3dAlgebraicSurface
# undef STACK
# undef REF
# undef VoronoiSite2d
# endif // shape_cell2d_voronoi_impl2d_hpp

---