mesh.h

Go to the documentation of this file.

/* Copyright (C) 2004 Luiz Velho. */

#ifndef MESH_H
#define MESH_H

namespace A48 {

class Surface {
 public:
  virtual void base_mesh(int *np, int **fcs, int *nf) = 0;

  virtual void sample(int i, Vertex* v) = 0;

  virtual void sample(Edge* e, Vertex* v) = 0;

  virtual void sample(Face* f, Vertex* v) = 0;

  virtual float elenght(Edge* e) = 0;

  virtual float ref_rank(Edge* e) = 0;

  virtual float simpl_rank(Vertex* v) = 0;

  virtual Vertex* new_vertex(void) = 0;

  virtual void del_vertex(Vertex *v) = 0;
};


class Mesh {
  Surface      *surf_; 
  FaceContainer   fc_; 
  EdgeContainer   ec_; 
  VertexContainer vc_; 
  MxHeap          sf_; 
  MxHeap          rf_; 

 public:
  Mesh(Surface *s);

  ~Mesh();

  Surface* surf() { return surf_; };
 
  VertexIter verts_begin(){ return vc_.begin(); };

  VertexIter verts_end(){ return vc_.end(); };

  int num_verts() { return vc_.size(); };

  EdgeIter edges_begin() { return ec_.begin(); };

  EdgeIter edges_end() { return ec_.end(); };

  int num_edges() { return ec_.size(); };

  FaceIter faces_begin() { return fc_.begin(); };

  FaceIter faces_end() { return fc_.end(); };

  int num_faces() { return fc_.size(); };

  void adapt_refine(double t);

  void adapt_simplify(double t);

  Vertex* refine(Hedge* e);

  Hedge* simplify(Vertex* w);

  Vertex* split(Face* f);

  Vertex* split(Hedge* e);

  Hedge* weld(Vertex* w);

  Hedge* flip(Hedge *h);

 private:
        
  Vertex *add_vertex(void);

  bool add_vertex(Vertex *v) 
    { std::pair<VertexIter, bool> r = vc_.insert(v); return r.second; };

  void del_vertex(Vertex* v) { vc_.erase(v); surf()->del_vertex(v); };

  Hedge *add_edge(Vertex *v0, Vertex *v1);

  bool add_edge(Edge *e) 
    { std::pair<EdgeIter, bool> r = ec_.insert(e);  return r.second;};

  void del_edge(Edge* e) { ec_.erase(e); delete(e); }

  Face* add_face(Hedge* e0, Hedge* e1, Hedge* e2);

  bool add_face(Face* f) 
    { std::pair<FaceIter, bool> r = fc_.insert(f); return r.second;}

  void del_face(Face* f) { fc_.erase(f); delete(f); }

  void link_mesh();

  Vertex* bisect(Hedge* e, Hedge** el, Hedge** er);

  Hedge* bisect(Face *f, Hedge *e1, Hedge *e2, Hedge *el, Hedge *er);

  void new_front();

  void update_ref_front(Edge* e);

  void update_ref_front(Vertex* v);

  void update_simpl_front(Vertex* v);

  void update_simpl_front(Edge* e);

  bool is_triquad(void);

  void make_triquad(void);

  void set_base_mesh(int np, int* tris, int nf);

  Hedge* get_hedge(int i0, int i1, Vertex* verts[], HedgeMap* edges);

  void put_face(int i0, int i1, int i2, Vertex* verts[], HedgeMap* edges);
};


}

#endif

---