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

Go to the documentation of this file.

/*****************************************************************************
 * M a t h e m a g i x
 *****************************************************************************
 * TopologyCurve
 * 2008-05-16
 * Julien Wintz & Bernard Mourrain
 *****************************************************************************
 *               Copyright (C) 2006 INRIA Sophia-Antipolis
 *****************************************************************************
 * Comments :
 ****************************************************************************/

# ifndef shape_topology_surface_hpp_H
# define shape_topology_surface_hpp_H

# include <shape/graphic.hpp>
# include <shape/vertex.hpp>
# include <shape/edge.hpp>
# include <shape/face.hpp>
# include <shape/kdtree.hpp>
# include <shape/list.hpp>
# include <shape/topology.hpp>
# include <shape/cell3d_factory.hpp>
# include <algorithm>

# define TMPL   template<class C,class V>
# define TMPL1  template<class V>
# define Viewer viewer<axel,V>
# define SELF   tpl3d<C,V> 

namespace mmx {
namespace shape {

//--------------------------------------------------------------------
struct tpl3d_def {};

template<> struct use<tpl3d_def>
  :public use<topology_def>
  ,public use<surface_def>
{

  typedef graphic<double> Graphic;

  template<class TOPOLOGY> 
  static Graphic* as_graphic(const TOPOLOGY& tp) {

    typedef typename TOPOLOGY::Point  Point; 
    typedef typename TOPOLOGY::Edge   Edge;
    typedef typename TOPOLOGY::Face   Face;
  
    int nbi=0;
    
    if( tp.nbe()>0){
      nbi=2*tp.nbe();
      int c=0;
      Graphic* res = new Graphic( Graphic::E_LINE, nbi, nbi);
      foreach(Edge* e, tp.edges()) { 
        res->vertices[3*c]  =e->source()->x();
        res->vertices[3*c+1]=e->source()->y();
        res->vertices[3*c+2]=e->source()->z();
        c++;
        res->vertices[3*c]  =e->destination()->x();
        res->vertices[3*c+1]=e->destination()->y();
        res->vertices[3*c+2]=e->destination()->z();
        c++;
        res->indices[c-2]=c-1;
        res->indices[c-1]=c-2;
      }
      return res;
    }
    
    if( tp.nbf()>0){
      foreach(Face* f, tp.faces()) 
        nbi += f->size()-2;
      nbi*=3;
      Graphic* res = new Graphic( Graphic::E_TRIANGLE, tp.nbv(), nbi);
      std::map<Point*,int> index;
      
      if(tp.nbv()>0){
        unsigned cp=0;
        foreach(Point* p, tp.vertices()) {
          res->vertices[3*cp]  =p->x();
          res->vertices[3*cp+1]=p->y();
          res->vertices[3*cp+2]=p->z();
          index[p]=cp;cp++;
        }
      }
      
      unsigned n=0;
      foreach(Face* f, tp.faces()) {
        for(unsigned i=1;i<f->size();i++) {
          if( i+1 < f->size()) {
            res->indices[n]=index[f->points(0)];
            res->indices[n+1]=index[f->points(i)];
            res->indices[n+2]=index[f->points(i+1)]; 
            n+=3;
          }
        }
      }
      return res;
    }
    return NULL;
  }

  //--------------------------------------------------------------------
  template<class VIEWER, class TOPOLOGY> 
  static VIEWER& print_as_graphic(VIEWER& out, const TOPOLOGY& tp, unsigned d=0) {
  
  typedef typename TOPOLOGY::Point  Point; 
  typedef typename TOPOLOGY::Edge   Edge;
  typedef typename TOPOLOGY::Face   Face;
  
  if (d<1 && tp.nbv()>0){
    out<<"<pointset size=\""<<tp.nbv()<<"\" color=\"rgb\">\n";
    foreach(Point* p, tp.vertices()) {
      out <<" "<<p->x()<<" "<<p->y()<<" "<<p->z()<<" 255 75 75\n";
    }
    out<<" </pointset>\n ";
  }
  
  
  if (d<2 && tp.nbe()>0){
    out<<" <curve type=\"mesh\">\n<vect>\nVECT\n";
    out<<tp.nbe()<<" "
       <<2*tp.nbe()<<" "
       <<tp.nbe()<<"\n";
    
    for(int i=0; i<tp.nbe();i++) out<<"2 ";
    out<<"\n";
    for(int i=0; i<tp.nbe();i++) out<<"1 ";
    out<<"\n";
    foreach(Edge* e, tp.edges()) {
      out <<e->source()->x()<<" "<<e->source()->y()<<"  "<<e->source()->z()<<" "
          <<e->destination()->x()<<" "<<e->destination()->y()<<" "<<e->destination()->z()
          <<"\n";
    }
    for(unsigned i=0; i<tp.edges().size();i++) 
      out<< "0.814 0.279 0.2 1\n";
    out<<" </vect>\n </curve>\n";
  }

//  std::srand((unsigned)time(0));
//  foreach(Face* f, tp.faces()) 
//    out << f;

//  out<< "<camera>\n<Parameters fieldOfView=\"0.785398\" Type=\"PERSPECTIVE\" zNearCoefficient=\"0.005\" orthoCoef=\"0.414214\" zClippingCoefficient=\"1.73205\"/>\n  <Stereo distToScreen=\"0.5\" focusDistance=\"19.3137\" physScreenWidth=\"0.4\" IODist=\"0.062\"/>\n  <ManipulatedCameraFrame>\n   <position x=\"2.95543\" y=\"0.574994\" z=\"-0.756089\"/>\n   <orientation q0=\"0.0149472\" q1=\"-0.910158\" q2=\"-0.0595418\" q3=\"-0.409687\"/>\n   <ManipulatedParameters transSens=\"1\" rotSens=\"1\" wheelSens=\"1\" spinSens=\"0.3\"/>\n   <ManipulatedCameraParameters flySpeed=\"0.08\">\n    <flyUpVector x=\"0\" y=\"1\" z=\"0\"/>\n   </ManipulatedCameraParameters>\n  </ManipulatedCameraFrame>\n </camera>\n";

  if(tp.nbf()>0) {
    std::map<Point*,int> index;
    int c=0;
    foreach(Point* p, tp.vertices()) {
      index[p]=c;c++;
    }

    out<<"<surface type=\"mesh\" color=\"255 10 0\">\n<off>\n";
    out<<c<<" "<<tp.nbf()<<" 0\n";
    foreach(Point* p, tp.vertices()) {
      out <<p->x()<<" "<<p->y()<<" "<<p->z()<<" \n";
    }

    foreach(Face* f, tp.faces()) {
      //      out<<"3 ";
      out<<f->size()<<" ";
      int n=0;
      foreach(Point* p, f->points())
        //      if (n<3) 
        {
          out <<index[p]<<" ";
          n++;
        }
      out <<"\n";
    }
    out<<"</off>\n</surface>\n";
    }

  return out;
  }
};
//--------------------------------------------------------------------
TMPL  class cell_list ;
TMPL1 class surface ;
template <class Object, class CELL> class node;
template <class Object, class CELL> class kdtree;

//--------------------------------------------------------------------  
template<class C,class V=default_env>
class tpl3d : public topology<C,V> {
public:
  typedef topology<C,V> Topology;
  typedef REF_OF(V)     Ref;
  typedef typename Topology::Point    Point;  
  typedef typename Topology::Edge     Edge;
  typedef typename Topology::Face     Face;
  typedef cell<C,Ref>        Cell;
  typedef cell3d<C,Ref>      Cell3d;
  typedef surface<Ref>       Surface;
  typedef typename Cell::BoundingBox         BoundingBox;

  tpl3d(){};
   tpl3d(const BoundingBox & bx);
  ~tpl3d(void) ;
  
  virtual void clear();

  virtual void insert(Point*);
  virtual void insert(Edge *);
  virtual void insert(Face *);
  
  virtual void insert_singular(Point*); ;
  virtual void insert_singular(BoundingBox*);

  int nbv() const { return m_vertices.size(); }
  int nbe() const { return m_edges.size(); }
  int nbf() const { return m_faces.size(); }
  
  inline Seq<Point *> vertices(void) const { return m_vertices ; }
  inline Seq<Edge *>  edges(void)    const { return m_edges ; }
  inline Seq<Face *>  faces(void)    const { return m_faces ; }
  
  virtual Point* vertices(int i)     { return m_vertices[i] ; }
  virtual Face*  faces(int i)        { return m_faces[i] ; }
  
  //  protected:
  bool insert_regular (Cell * cell);

  //private:

  Seq<Point *>        m_vertices ;
  Seq<Edge  *>        m_edges ;
  Seq<Face  *>        m_faces ;
};
//--------------------------------------------------------------------
TMPL SELF::tpl3d(const BoundingBox & bx) : Topology(bx) {
}

TMPL SELF::~tpl3d(void) {
}


TMPL bool 
SELF::insert_regular(Cell* cl) {
  //  m_leaves <<cl;// put in the leaves and will be treated at the end
  return cl->insert_regular(this);
//  return true; 
}


TMPL void 
SELF::insert(Point * p) {
  use<point_def,V>::point_insertor(m_vertices, p); 
}

TMPL void 
SELF::insert(Edge* e) { 
  m_edges<<e; 
}

TMPL void 
SELF::insert(Face * f) { 
  m_faces<<f; 
}

TMPL void 
SELF::insert_singular(BoundingBox * ) {
}

TMPL void 
SELF::insert_singular(Point * ) {
  //  m_specials<<p;
}

TMPL void
SELF::clear() {
  // Should we clean up these points?
  m_faces.resize( 0 );
  m_edges.resize( 0 );
  m_vertices.resize( 0 );
}

//--------------------------------------------------------------------
TMPL Viewer&
operator<<(Viewer& out, const SELF& tp) {
  use<tpl3d_def,V>::print_as_graphic(out,tp);
  return out;
}
//--------------------------------------------------------------------
TMPL typename use<tpl3d_def,V>::Graphic*
as_graphic(const SELF& tp) {
  return use<tpl3d_def,V>::as_graphic(tp);
}
//====================================================================
} ; // namespace shape
} ; // namespace mmx
//====================================================================
# undef TMPL
# undef TMPL1
# undef AlgebraicCurve 
# undef AlgebraicSurface
# undef Cell
# undef Cell3dAlgebraicCurve
# undef Cell3dAlgebraicSurface
# undef Cell3dParametricCurve
# undef Cell3dList
# undef Cell3dFactory
# undef Shape
# undef Viewer
# undef Graphic
# undef SELF 
# endif