mesh.h

Go to the documentation of this file.
00001 
00006 /* Copyright (C) 2006 Luiz Velho, Hélio Lopes and Esdras Medeiros*/
00007 
00008 #ifndef MESH_H
00009 #define MESH_H
00010 
00011 #include <cstdio>
00012 #include <iostream>
00013 #include <list>
00014 #include <set>
00015 #include <iterator>
00016 #include <utility>
00017 #include "../algebra/algebra3.h"
00018 
00019 using namespace std;
00024 namespace Mesh {
00025 
00026 typedef double Real;
00027 class Point;
00028 
00029 class Obj;
00030 class Surf;
00031 class Face;
00032 class Edge;
00033 class Hedge;
00034 class Vertex;
00035 
00036 class Error;
00037 
00042 typedef std::set<Surf*>   SurfContainer; 
00043 
00048 typedef std::set<Face*>   FaceContainer;
00049 
00054 typedef std::set<Edge*>   EdgeContainer;
00055 
00060 typedef std::set<Vertex*> VertexContainer;
00061 
00066 typedef SurfContainer::iterator SurfIter;
00067 
00072 typedef FaceContainer::iterator FaceIter;
00073 
00078 typedef EdgeContainer::iterator EdgeIter;
00079 
00084 typedef VertexContainer::iterator VertexIter;
00085 
00091 class Obj {
00092  private:
00093   SurfContainer sc_; 
00094 
00095  public:
00097   Obj() {};
00098 
00102   ~Obj() {};
00103 
00106   SurfIter surfs_begin() { return sc_.begin(); };
00107 
00110   SurfIter surfs_end() { return sc_.end(); };
00111 
00115   bool add_surf(Surf *s) { std::pair<SurfIter, bool> r = sc_.insert(s); return r.second; }
00116 
00119   void rm_surf(Surf *s) { sc_.erase(s); };
00120 };
00121 
00126 class Surf {
00127  private:
00128   VertexContainer vc_; 
00129   EdgeContainer   ec_; 
00130   FaceContainer   fc_; 
00131   EdgeContainer   bc_; 
00132   
00133 
00134  public:
00135   
00137    Surf(){};
00138 
00140    ~Surf();
00141 
00144   VertexIter verts_begin(){ return vc_.begin(); };
00145 
00148   VertexIter verts_end(){ return vc_.end(); };
00149 
00152   int num_verts() { return vc_.size(); };
00153 
00156   EdgeIter edges_begin() { return ec_.begin(); };
00157 
00160   EdgeIter edges_end() { return ec_.end(); };
00161 
00164   int num_edges() { return ec_.size(); };
00165 
00168   FaceIter faces_begin() { return fc_.begin(); };
00169 
00172   FaceIter faces_end() { return fc_.end(); };
00173 
00176   int num_faces() { return fc_.size(); };
00177 
00180   EdgeIter bdries_begin() { return bc_.begin(); };
00181 
00184   EdgeIter bdries_end() { return bc_.end(); };
00185 
00188   int num_bdries() { return bc_.size(); };
00189 
00191   Hedge* lookup_hedge(Point *p0, Point *p1);
00192   
00194   Vertex* split(Face *f);
00195 
00197   Vertex* split(Hedge* e);
00198 
00202   Hedge* weld(Vertex* w);
00203 
00205   Hedge* flip(Hedge *h);
00206 
00208   Face* create(Point *p0, Point *p1, Point *p2);
00209 
00211   void destroy(Face *f);
00212 
00214   Edge* glue(Hedge *e1, Hedge *e2);
00215 
00217   Edge* unglue(Hedge *e1, Hedge *e2);
00218 
00219  private:
00221   Vertex *add_new_vertex(Point *p);
00222 
00226   bool add_vertex(Vertex *v) 
00227   { std::pair<VertexIter, bool> r = vc_.insert(v);return r.second;};
00228 
00231   void del_vertex(Vertex* v) { vc_.erase(v);};
00232 
00234   Hedge *add_new_edge(Vertex *v0, Vertex *v1);
00235 
00239   bool add_edge(Edge *e) 
00240   { std::pair<EdgeIter, bool> r = ec_.insert(e); return r.second;};
00241 
00244   void del_edge(Edge* e) { ec_.erase(e);};
00245 
00249   bool add_face(Face* f) { std::pair<FaceIter, bool> r = fc_.insert(f); return r.second;};
00250 
00252   void del_face(Face* f) { fc_.erase(f);};
00253 
00257   bool add_bdry(Edge* e) { std::pair<EdgeIter, bool> r = bc_.insert(e); return r.second;};
00258 
00261   void del_bdry(Edge* e) { bc_.erase(e);};
00262 
00268   void transfer_cells(Surf* s2);
00269 
00271   Vertex* bisect(Hedge* e, Hedge** el, Hedge** er);
00272 
00274   Hedge* bisect(Face *f, Hedge *e1, Hedge *e2, Hedge *el, Hedge *er);
00275 
00277   Edge* attach_handle_0(Hedge *e1, Hedge *e2);
00278 
00280   Edge* attach_handle_1(Hedge *e1, Hedge *e2);
00281 
00283   Edge* attach_handle_2(Hedge *e1, Hedge *e2);
00284 
00286   Edge* attach_handle_3(Hedge *e1, Hedge *e2);
00287 
00289   Edge* attach_handle_4(Hedge *e1, Hedge *e2);
00290 
00292   Edge* detach_handle_1(Hedge *e1, Hedge *e2);
00293 
00295   Edge* detach_handle_2(Hedge *e1, Hedge *e2);
00296 
00298   Edge* detach_handle_3(Hedge *e1, Hedge *e2);
00299 
00301   Edge* detach_handle_4(Hedge *e1, Hedge *e2);
00302   
00303 };
00304 
00309 class Face {
00310  private:
00311   Hedge    *e_; 
00312   Surf     *s_; 
00313 
00314  public:
00315 
00321   Face(Surf *s, Hedge* e0, Hedge* e1, Hedge* e2);
00322 
00324   ~Face() {};
00325 
00328   Surf* surf() { return s_;};
00329 
00332   Hedge* hedge(int k);
00333 
00336   Vertex* vertex(int k);
00337 
00339   void set_hedge(int k, Hedge* h);
00340 
00342   void set_surf(Surf* s) {s_ = s; };
00343 
00344   /*@brief Updates the half-edges references to the face.*/
00345   void link_edges();
00346 
00348   Face* reuse(Hedge *e0, Hedge *e1, Hedge *e2);
00349 
00351   int reuse(Hedge *he, Hedge *ne);
00352 };
00353 
00354 
00355 
00368 class Hedge {
00369  private:
00370   Vertex    *o_; 
00371   Hedge     *n_; 
00372   Face      *f_; 
00373   Edge      *e_; 
00374 
00375  public:
00377   Hedge() {};
00379   ~Hedge() {};
00380 
00383   Face* face() { return f_; };
00384   
00387   Vertex* org() { return o_; };
00388 
00391   Vertex* dst() { return mate()->org(); };
00392 
00395   Edge*  edge() { return e_; };
00396 
00399   Hedge* mate();
00400 
00403   Hedge* prev() { return (n_)? n_->next() : NULL; };
00404 
00407   Hedge* next() { return n_; };
00408 
00411   Hedge* prev_on_bdry() { return mate()->next(); };
00412 
00415   Edge* get_bdry() { return (mate()->face()==NULL)? mate()->edge() : NULL; };
00416 
00418   void set_face(Face* f) { f_ = f; };
00419 
00421   void set_org(Vertex* v) { o_ = v; };
00422 
00424   void set_next(Hedge* h) { n_ = h; };
00425 
00427   void set_edge(Edge* e) { e_ = e; };
00428 
00430   void set_prev_on_bdry(Hedge *e) { if (mate()->face()==NULL) mate()->set_next(e); };
00431 
00433   Hedge* reuse(Vertex *v0, Vertex *v1);
00434 };
00435 
00440 class Edge  {
00441  private:
00442   Hedge h_[2]; 
00443 
00444  public:
00445   /* @brief The construtctor initializes the vertices of the edge.*/
00446   Edge(Vertex *p0, Vertex *p1);
00447 
00449   ~Edge() {};
00450 
00451   /* @brief Returns a half-edge specified by the index i.*/
00452   Hedge* hedge(int i);
00453  
00455   Vertex* org() { return h_[0].org(); };
00456 
00458   Vertex* dst() { return h_[1].org(); };
00459 
00462   bool is_bdry() { return (h_[0].face() == NULL || h_[1].face() == NULL); };
00463 
00464 
00468   void set_bdry(Edge *b) { 
00469     if (h_[0].face() != NULL) h_[1].set_edge(b);
00470     else if (h_[1].face() != NULL) h_[0].set_edge(b);
00471   };
00472 };
00473 
00479 class Vertex  {
00480  private: 
00481   Hedge*      s_; 
00482   Point*      p_; 
00483 
00484  public:
00485 
00487   Vertex(Point *p) {p_ = p; s_ = NULL;};
00488 
00490   ~Vertex() {};
00491 
00493   Point*  p() { return p_; }; 
00494 
00497   void set_star(Hedge* h) { s_ = h; }; 
00498 
00501   Hedge*  star_first() { return s_; }; 
00502 
00506   Hedge*  star_next(Hedge* h) {
00507     if (h->face() ==NULL ) return NULL; // other side of bdry
00508     else { Hedge *n = h->next()->mate(); return (n == s_)? NULL : n; }
00509   }
00510 
00513   bool    is_bdry() { return s_->edge()->is_bdry(); };
00514 };
00515 
00520 class Point{
00521 private:
00522   vec3 _p; 
00523   vec3 _n; 
00524   list<Vertex*> _vl; 
00525   int _index; 
00526 
00527  public:
00528 
00530          Point(){_p=vec3(0, 0, 0);_index = 0;; _n=vec3(0, 0, 0);};
00531 
00533   Point(vec3 p, vec3 n, int index) { _p=p; _index=index; _n=n;};
00534 
00536   ~Point();
00537 
00541   float operator [] (int i) {
00542     if (i < 0 || i > 2)
00543       return 0.0;
00544     return _p[i];
00545   };
00546   
00548   vec3 p() {return _p;};
00549 
00551   vec3 n() {return _n;};
00552 
00554   int  get_index(){return _index;};
00555 
00559   void add(vec3 v){_p =_p+v;};
00560 
00566   void set_normal(float nx, float ny, float nz){_n[0]=nx; _n[1]=ny; _n[2]=nz;};
00567 
00573   Hedge* lookup_hedge(Point *p){
00574    Hedge* he = NULL;
00575    for (list<Vertex*>::iterator viter = _vl.begin(); viter!=_vl.end();viter++)
00576      if ((*viter)->star_first()->org()->p()==p){
00577          he = (*viter)->star_first();
00578          break;
00579      }
00580     return he;
00581   };
00582 
00585   bool on_bdry() {return (_vl.size()>0)? 
00586           (*_vl.begin())->star_first()->edge()->is_bdry(): false;};
00587 
00591   void add_vert(Vertex *v) {_vl.push_back(v);};
00592 
00596   void del_vert(Vertex *v) {_vl.remove(v);};
00597 
00598 };
00599 
00604 class Error {
00605  public:
00607   Error(char *s=""){ std::cerr<<"mesh error: "<<s<<std::endl; exit(0); };
00608 };
00609 }
00610 
00611 
00612 #endif

Generated on Fri Feb 24 12:23:21 2006 for TOPs by  doxygen 1.4.6-NO