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

Go to the documentation of this file.

/*****************************************************************************
 * M a t h e m a g i x
 *****************************************************************************
 * Edge
 * 2008-03-21
 * Julien Wintz & Bernard Mourrain
 *****************************************************************************
 *               Copyright (C) 2006 INRIA Sophia-Antipolis
 *****************************************************************************
 * Comments :
 ****************************************************************************/
# ifndef shape_face_hpp
# define shape_face_hpp
//====================================================================
# include <realroot/Seq.hpp> 
# include <shape/shape.hpp> 
# include <shape/point.hpp> 
# include <shape/edge.hpp> 

# define TMPL   template<class C, class V, class POINT>
# define TMPL1  template<class K>
# define SELF   face<C,V,POINT>
# define Viewer viewer<axel,I>
//====================================================================
namespace mmx {
namespace shape {

TMPL struct face;

// TMPL1 struct with_face {
//   typedef face<K,typename with_point<K>::Point> Face;};

// TMPL1 struct face_def
//   :public with_shape<K>
//   ,public with_point<K> 
//   ,public with_edge<K> 
//   ,public with_face<K> {};

struct face_def {};

TMPL1 struct use<face_def,K>  {
  typedef face<typename use<scalar_def,K>::Scalar, default_env,
                typename use<point_def,K>::Point>  Face;
};

template<> struct use<face_def> 
{
   //  typedef typename use<point_def,K>::Point Point;
  typedef face<double, default_env, point<double> > Face;
};

template<class C, class V=default_env, class POINT= point<C,V> >
class face : public use<shape_def,V>::Shape 
{
public:
  typedef typename use<shape_def,V>::Shape                Shape;
  typedef POINT             Point;
  typedef edge<C,V,POINT>   Edge;
  //  typedef edge<typename use<scalar_def,K>::Scalar,POINT>  Edge;
  typedef typename Seq<Point*>::const_iterator const_iterator;

  face(void) : m_index(0) { };
  face(Point * p1, Point * p2, Point * p3): Shape() {
    m_points<<p1;
    m_points<<p2;
    m_points<<p3;
    m_index=0;
  }; 

  const_iterator begin() const {return m_points.begin();}
  const_iterator end()   const {return m_points.end();}

  unsigned       size()  const {return m_points.size();}
  Seq<Point*>&   points()      {return m_points;}
  Point*         points(int i) {return m_points[i];}
  Point*         operator[](int i) {return m_points[i];}
  void           insert     (Point * p) { m_points<<p; } ;
  void           push_vertex(Point * p) { m_points<<p; } ;

  void           set_index(const int & i) { m_index=i; } ;
  int            get_index() { return m_index; } ;

  bool is_ccw();

  void         reverse() { m_points.reverse(); } ;

//  void refine(Edge &a, Edge& b);

  Point * not_on(Edge * a)
    {
  foreach( Point * p, m_points)
    if ( !equal( a->destination(), p ) &&
         !equal( a->source()     , p ) )
      return p;
  std::cout<<" ! not_on(Edge) not found"<<std::endl;
  return NULL;};

private:
  Seq<Point*> m_points;
  int m_index;

  inline bool equal( Point * u, Point * v )
    { return ( u->x() == v->x()  &&
               u->y() == v->y() ); }
};


// // Splits exsisting edge a by inserting edge b
// TMPL void
// SELF::refine(Edge &a, Edge& b)
// {
//   unsigned i= m_points.search( a.source() );
//   //unsigned j= (i==m_points.size()-1 ? 0 : i+1 );
//   unsigned j= m_points.search( a.destination() );
  
//   // std::cout<<" "<< a.source() << " -> "
//   //          << a.destination() <<std::endl;
//   // std::cout<< a.source()->x()     <<","<<a.source()->y()      <<" --->"
//   //          << a.destination()->x()<<","<<a.destination()->y() <<"\n";
//   // std::cout<<" "<< b.source() << " -> "
//   //          << b.destination() <<std::endl;
//   // std::cout<< b.source()->x()     <<","<<b.source()->y()      <<" --->"
//   //          << b.destination()->x()<<","<<b.destination()->y() <<"\n";
//   std::cout<<"inds="<<i<<" "<<j<<std::endl;
  
//   if ( equal(b.source(),m_points[i]) &&
//        !equal( b.destination(),m_points[j]) ) 
// //  if ( b.source()==m_points[i] )
// //    if ( b.destination()!=m_points[j] )
//   {
//     insert_vertex( b.destination(), i);
//     return;
//   }  
//   if ( equal(b.destination(),m_points[i]) &&
//        !equal( b.source(),m_points[i]) ) 
//     // if ( b.destination()==m_points[i] )
//     //   if ( b.source()!=m_points[i] )
//   {
//     insert_vertex( b.source(), i);
//     return;
//   }
//   if ( equal(b.destination(),m_points[j]) &&
//        !equal( b.source(),m_points[i]) )
//     // if ( b.destination()==m_points[j] )
//     //   if ( b.source()!=m_points[i] )
//   {
//     insert_vertex( b.source(), i);
//     return;
//   }
//   if ( equal(b.source(),m_points[j]) &&
//        !equal( b.destination(),m_points[i]) )
//     // if ( b.source()==m_points[j] )
//     //   if ( b.destination()!=m_points[i] )
//   {
//     insert_vertex( b.destination(), i);
    
//     return;
//   }
//   std::cout<<"not refined." <<std::endl;
// //  exit(0);
// }




// TMPL void 
// SELF::insert_vertex(Point*v, unsigned& k)
// {// insert v at position k+1
//   Seq<Point*> t;
 
//   if (k!=0)
//   std::cout<<"inserting vertex at position "<< k  <<std::endl;

//   for ( unsigned n=0;n<=k;n++ )
//     t<< m_points[n];
//   t<< v;
//   for ( unsigned n=k+1;n< m_points.size();n++ )
//     t<< m_points[n];
  
//   m_points.clear();
//   m_points=t;
// }

TMPL bool 
SELF::is_ccw()
{
   double z(0);
   int    n=this->size();
   
   if (n < 3)
       return(0);
   n--;
   for (int i=0;i<n;i++) 
   {
       z+= m_points[i  ]->x() * m_points[i+1]->y() -
           m_points[i+1]->x() * m_points[i  ]->y() ;
   }
   z+= m_points[n]->x() * m_points[0]->y() -
       m_points[0]->x() * m_points[n]->y() ;

   return (z>0);
}

//--------------------------------------------------------------------
template<class C,class V> struct viewer; struct axel;

  template<class C, class V, class I, class POINT> Viewer&
operator<<(Viewer& out, SELF* p) {
  using namespace shape;
  
  out<<"<domain type=\"mesh\" name=\"face_"
     << p->get_index()<<"\"color=\""
     << out.color.r   <<" "
     << out.color.g   <<" "
     << out.color.r   <<"\">\n";
  
  out<<"<off>\n";
  out<<p->size()<<" "<<1<<" "<<0<<"\n";
  //foreach(Point* pt, *p)
  for (unsigned i=0;i<p->size();i++)
    {
      out<<(*p)[i]->x()<<" "<<(*p)[i]->y()<<" "<<(*p)[i]->z()<<"\n";
    }
  out<<p->size();
  for (unsigned i=0;i<p->size();i++)
    out<<" "<<i;
  out<<"\n</off>\n";
  out<<"</domain>\n";
  return out;
}
//--------------------------------------------------------------------
TMPL void
face_refine(SELF* f0, SELF* f1, double s, int v) {

  typedef typename SELF::Point Point;
  Seq<Point*> l1;
  for(unsigned j=0;j<3;j++)
        if ( ((*f1->points(j))[v]==s) )
          for(unsigned i=0;i<3;i++) {
              if ( ((*f0->points(i))[v]==s) && 
                   (i+1<f0->size()) && 
                   ((*f0->points(i+1))[v]==s) ) {
                l1<<(f1->points(j));
              }
              if ( (i==(f0->size()-1)) && 
                   ((*f0->points(i))[v]==s) && 
                   ((*f0->points(0))[v]==s) ){
                l1<<(f1->points(j));
              }
            }
//  std::cout<<"Add "<<l1.size()<<" point(s) to face of size "<<f0->size()<<std::endl;
  foreach(Point* p1,l1) f0->insert(p1);
}



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