00001
00006
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
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
00446 Edge(Vertex *p0, Vertex *p1);
00447
00449 ~Edge() {};
00450
00451
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;
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