cell.h

Go to the documentation of this file.

#ifndef CELL_H
#define CELL_H

#include <iostream>
#include <list>

#include "hash_set.h" // for namespace hashers
#include "hash_classes.h" // for CastHash
#include "iterator_wrapper.h"
#include "globals.h"
#include "persistance.h"
#include "util.h"

/* Forward declarations. */
class Cell;

class VertexCell;
class EdgeCell;
class FaceCell;

class BoundaryMesh;
class BoundaryVertex;
class BoundaryEdge;
class BoundaryFace;

class BezierMesh;
class BezierVertex;
class BezierEdge;
class BezierTriangle;

class DataStore;
class QBSpline;

/* operators << */
extern std::ostream& operator<< (std::ostream &stream, const BoundaryVertex&);
extern std::ostream& operator<< (std::ostream &stream, const BoundaryEdge&);
extern std::ostream& operator<< (std::ostream &stream, const BoundaryFace&);

extern std::ostream& operator<< (std::ostream &stream, const BezierVertex&);
extern std::ostream& operator<< (std::ostream &stream, const BezierEdge&);
extern std::ostream& operator<< (std::ostream &stream, const BezierTriangle&);

#ifndef SWIG
/* Default hash functions.  Don't create wrappers for them. */
namespace hashers {
template <> class hash<Cell*> : public CastHash<Cell*> { };
template <> class hash<VertexCell*> : public CastHash<VertexCell*> { };
template <> class hash<EdgeCell*> : public CastHash<EdgeCell*> { };
template <> class hash<FaceCell*> : public CastHash<FaceCell*> { };
template <> class hash<BoundaryVertex*> : public CastHash<BoundaryVertex*> { };
template <> class hash<BoundaryEdge*> : public CastHash<BoundaryEdge*> { };
template <> class hash<BoundaryFace*> : public CastHash<BoundaryFace*> { };
template <> class hash<BezierVertex*> : public CastHash<BezierVertex*> { };
template <> class hash<BezierEdge*> : public CastHash<BezierEdge*> { };
template <> class hash<BezierTriangle*> : public CastHash<BezierTriangle*> { };

/* const versions of the same thing */
template <> class hash<const Cell*> : public CastHash<const Cell*> { };
template <> class hash<const VertexCell*> : public CastHash<const VertexCell*> { };
template <> class hash<const EdgeCell*> : public CastHash<const EdgeCell*> { };
template <> class hash<const FaceCell*> : public CastHash<const FaceCell*> { };
template <> class hash<const BoundaryVertex*> : public CastHash<const BoundaryVertex*> { };
template <> class hash<const BoundaryEdge*> : public CastHash<const BoundaryEdge*> { };
template <> class hash<const BoundaryFace*> : public CastHash<const BoundaryFace*> { };
template <> class hash<const BezierVertex*> : public CastHash<const BezierVertex*> { };
template <> class hash<const BezierEdge*> : public CastHash<const BezierEdge*> { };
template <> class hash<const BezierTriangle*> : public CastHash<const BezierTriangle*> { };
};
#endif


enum Movement
{
    FixedNone,         
    FixedHorizontal,   
    FixedVertical,     
    FixedAll           
};


class Cell {
    public:
        const unsigned long id; 
        Cell();
        virtual ~Cell() { }
};

class VertexCell : public Cell {
  private:
    typedef PersistantVector<EdgeCell*> vector;
    vector edges_;

  public:
    /* Constructors */
    VertexCell(PersistantStore&);

    /* Destructor */
    virtual ~VertexCell();

    /* Member functions */
    void add_edge(EdgeCell *e);
    void delete_edge(EdgeCell *e);
    bool has_edge(const EdgeCell *e) const;
    bool has_face(const FaceCell *f) const;
    int num_edges() const { return edges_.size(); }

    typedef vector::iterator edge_iterator;
    typedef vector::const_iterator edge_const_iterator;

    edge_iterator begin_edges() { return edges_.begin(); }
    edge_const_iterator begin_edges() const { return edges_.begin(); }

    edge_iterator end_edges() { return edges_.end(); }
    edge_const_iterator end_edges() const { return edges_.end(); }

    EdgeCell *get_any_edge();
    const EdgeCell *get_any_edge() const;

 private:
    /* illegal */
    VertexCell(const VertexCell &o);
    VertexCell& operator=(const VertexCell &o);
};

class EdgeCell : public Cell {
  private:
    PersistantArray<VertexCell*, 2> vertices_;
    PersistantArray<FaceCell*, 2> faces_;

 public:
    /* Constructors */
    EdgeCell(PersistantStore&, VertexCell *v1, VertexCell *v2);

    /* Destructor */
    virtual ~EdgeCell() {}

    /* Member functions */
    void add_face(FaceCell *f);
    void delete_face(FaceCell *f);
    bool has_vertex(const VertexCell *v) const;
    bool has_face(const FaceCell *f) const;
    int num_faces() const;

    typedef PersistantArray<VertexCell*,2>::iterator vertex_iterator;
    typedef PersistantArray<VertexCell*,2>::const_iterator vertex_const_iterator;
    typedef PersistantArray<FaceCell*,2>::iterator face_iterator;
    typedef PersistantArray<FaceCell*,2>::const_iterator face_const_iterator;

    vertex_iterator begin_vertices() { return vertices_; }
    vertex_const_iterator begin_vertices() const { return vertices_; }

    vertex_iterator end_vertices() { return vertices_ + 2; }
    vertex_const_iterator end_vertices() const { return vertices_ + 2; }

    VertexCell *get_canon_vertex();
    const VertexCell *get_canon_vertex() const;

    /* There are exactly two vertices, always, so allow this access. */
    VertexCell *get_vertex(int i) {
      assert(i >= 0); assert(i < 2);
      return vertices_[i];
    }
    const VertexCell *get_vertex(int i) const {
      assert(i >= 0); assert(i < 2);
      return vertices_[i];
    }

    face_iterator begin_faces() { return faces_; }
    face_const_iterator begin_faces() const { return faces_; }

    face_iterator end_faces() { return faces_ + num_faces(); }
    face_const_iterator end_faces() const { return faces_ + num_faces(); }

    FaceCell *get_any_face();
    const FaceCell *get_any_face() const;

 private:
    /* illegal */
    EdgeCell(const EdgeCell &o);
    EdgeCell& operator=(const EdgeCell &o);
};


class FaceCell : public Cell {
  private:
    typedef PersistantVector<EdgeCell*> vector;
    vector edges_;

 public:
    /* Constructors */
    FaceCell(PersistantStore&);

    /* Destructor */
    virtual ~FaceCell();

    /* Member functions */
    void add_edge(EdgeCell *e);
    void delete_edge(EdgeCell *e);

    /* Constant Member Functions */
    bool has_vertex(const VertexCell *v) const;
    bool has_edge(const EdgeCell *e) const;
    int num_edges() const { return edges_.size(); }

    typedef vector::iterator edge_iterator;
    typedef vector::const_iterator edge_const_iterator;

    edge_iterator begin_edges() { return edges_.begin(); }
    edge_const_iterator begin_edges() const { return edges_.begin(); }

    edge_iterator end_edges() { return edges_.end(); }
    edge_const_iterator end_edges() const { return edges_.end(); }

    EdgeCell *get_canon_edge();
    const EdgeCell *get_canon_edge() const;

 private:
    /* illegal */
    FaceCell(const FaceCell&);
    FaceCell& operator=(const FaceCell &o);
};

#define declare_iterators_any(cell, plural, out)                                  \
    typedef Tumble::iterators::caster<super::cell##_iterator, out*, out*>        \
      cell##_iterator;                                                       \
    typedef Tumble::iterators::caster<super::cell##_const_iterator, const out*, const out*>  \
      cell##_const_iterator;                                                 \
    cell##_iterator begin_##plural();                                        \
    cell##_const_iterator begin_##plural() const;                            \
    cell##_iterator end_##plural();                                          \
    cell##_const_iterator end_##plural() const;                              \
    out *get_any_##cell();                                                   \
    const out *get_any_##cell() const;

#define declare_iterators_canon(cell, plural, out)                                  \
    typedef Tumble::iterators::caster<super::cell##_iterator, out*, out*>        \
      cell##_iterator;                                                       \
    typedef Tumble::iterators::caster<super::cell##_const_iterator, const out*, const out*>  \
      cell##_const_iterator;                                                 \
    cell##_iterator begin_##plural();                                        \
    cell##_const_iterator begin_##plural() const;                            \
    cell##_iterator end_##plural();                                          \
    cell##_const_iterator end_##plural() const;                              \
    out *get_canon_##cell();                                                   \
    const out *get_canon_##cell() const;

class BoundaryVertex : public VertexCell {
  private:
    typedef VertexCell super;

 public:
    /* Constructors */
    BoundaryVertex(PersistantStore&, const ControlPoint&);

    /* Destructor */
    virtual ~BoundaryVertex() {} 
    /* Member functions */
    void set_bezier(BezierVertex *bv);
    void increase_fixed(Movement);
    void set_cp(const Point2D &p);

    /* Constant Member Functions */
    const Point2D& get_cp() const;
    Point2D& access_cp();
    const ControlPoint& get_control_point() const;
    const BezierVertex *get_bezier() const;
    BezierVertex *get_bezier();
    Movement get_fixed() const;
    void print() const;

    declare_iterators_any(edge, edges, BoundaryEdge);

 private:
    /* Data members */
    BezierVertex* bezier_vertex_; 
    ControlPoint cp_; 
    Movement fixed_; 
    /* illegal */
    BoundaryVertex(const BoundaryVertex &other);
    BoundaryVertex& operator=(const BoundaryVertex &o);
};


class BoundaryEdge : public EdgeCell {
 public:
    typedef EdgeCell super;


    /* Constructors */
    BoundaryEdge(PersistantStore&, BoundaryVertex *v0, BoundaryVertex *v1,
                 const std::vector<ControlPoint> &deboor,
                 const std::vector<double> &knots,
                 DataStore *_data_store);

    /* Destructor */
    virtual ~BoundaryEdge();

    /* Member functions */
    void set_fixed(Movement fixed);
    void set_color(int _color);
    void set_restlength(double _restlength);

    /* Constant Member Functions */
    const BoundaryVertex* get_vertex(int i) const;
    BoundaryVertex* get_vertex(int i);
    const BezierVertex* get_d0_vertex(int i) const;
    BezierVertex* get_d0_vertex(int i);
    const BezierVertex* get_d1_vertex(int i) const;
    BezierVertex* get_d1_vertex(int i);
    const BezierVertex* get_bezier_vertex(int i) const;
    BezierVertex* get_bezier_vertex(int i);
    int get_num_d1_vertexs() const;

    const QBSpline *get_spline() const;
    QBSpline *get_spline();
    Movement get_fixed() const;
    int get_color() const;

    /* Friend Functions */
    void print() const;

    /* Iterators; begin_ and end_ are provided, along with get_any_ */
    declare_iterators_canon(vertex, vertices, BoundaryVertex);
    declare_iterators_any(face, faces, BoundaryFace);

 private:
    /* Data members */
    QBSpline *spline_; 
    Movement fixed_; 
    int color_; 
    /* illegal */
    BoundaryEdge(const BoundaryEdge &o);
    BoundaryEdge& operator=(const BoundaryEdge &o);
};

class BoundaryFace : public FaceCell {
 public:
    typedef FaceCell super;

    /* Constructors */
    BoundaryFace(PersistantStore&, double min_angle = 0, int color = 0);

    /* Destructor */
    virtual ~BoundaryFace() {} 
    /* Member functions */
    void set_min_angle(double);
    void set_color(int);

    double get_min_angle() const;
    int get_color() const;

    /* Friend Functions */
    void print() const;
    friend std::ostream &operator<<( std::ostream &stream, const BoundaryFace& v);

    /* iterators */
    declare_iterators_canon(edge, edges, BoundaryEdge);

 private:
    /* Data members */
    double min_angle_; 
    int color_; 
 private:
    /* illegal */
    BoundaryFace(const BoundaryFace &other);
    BoundaryFace& operator=(const BoundaryFace &o);
};

class BezierVertex : public VertexCell {
  private:
    typedef VertexCell super;
 public:
    //friend class BezierMesh;

    /* Constructors */
    BezierVertex(PersistantStore&, const ControlPoint&, const DataPoint&);

    /* Destructor */
    virtual ~BezierVertex() {} 
    /* Member functions */
    void set_bdry(BoundaryEdge *e, double alpha);
    void set_bdry(BoundaryEdge *e, int idx);
    void set_bdry(BoundaryVertex *v);
    void set_cp(const Point2D &p );
    void set_dp(const LinearData &d );
    void set_data(int pos, double data);
    double get_data(int pos) const;

    /* Constant member functions */
    const Point2D& get_cp() const;
    Point2D& access_cp();
    ControlPoint get_control_point() const;

    const LinearData& get_dp() const;
    LinearData& access_dp();
    DataPoint get_data_point() const;

    int containment_dimension() const;
    bool is_boundary() const;

    const BoundaryEdge *get_bdry_edge() const;
    BoundaryEdge *get_bdry_edge();
    const BoundaryVertex *get_bdry_vertex() const;
    BoundaryVertex *get_bdry_vertex();

    double get_u(const BoundaryEdge *be, const BezierVertex *opposite) const;
    double get_u(const BezierEdge *e) const;
    double get_u() const; /* only allowed on D1 vertices */
    void print() const;

    declare_iterators_any(edge, edges, BezierEdge);

 private:
    /* Only BezierMesh can use this. */
    friend class BezierMesh;
    void replace_cp(const ControlPoint& newp);

 private:
    /* Data members */
    ControlPoint cp_; 
    DataPoint dp_; 
    BoundaryEdge *bdry_edge_; 
    BoundaryVertex *bdry_vertex_;
    double u_; 
 private:
    /* illegal */
    BezierVertex(const BezierVertex &o);
    BezierVertex& operator=(const BezierVertex &o);
};

class BezierEdge : public EdgeCell {
 public:
    typedef EdgeCell super;
    friend class BezierMesh;

    /* Constructors */
    BezierEdge(PersistantStore&, BezierVertex *v1, BezierVertex *v2, 
               const ControlPoint&, const DataStore&);

    /* Destructor */
    virtual ~BezierEdge() {} 
    /* Member Functions */
    void set_bdry(BoundaryEdge *be,double u0,double u1);
    void set_cp(const Point2D &p, int i);
    void set_dp(const LinearData &d, int i);
    void set_data(int i, int pos, double data);

    /* Constant Member Functions */
    int get_num_cp() const { return 3; }

    const Point2D& get_cp(int i) const;
    Point2D& access_cp(int i);
    ControlPoint get_control_point(int i) const;

    const LinearData& get_dp(int i) const;
    LinearData& access_dp(int i);
    DataPoint get_data_point(int i) const;

    const BezierVertex* get_vertex(int i) const;
    BezierVertex* get_vertex(int i);

    bool is_boundary() const;
    const BoundaryEdge *get_bdry_edge() const;
    BoundaryEdge *get_bdry_edge();

    /* Get the u value on either end of this sub-segment. */
    double get_u(int i) const;

    Point2D eval(double u) const;
    LinearData dataeval(double u) const;
    void evalIntermediate(double u,Point2D &p,Point2D &pc0,Point2D &pc1) const;
    void dataevalIntermediate(double u,LinearData &d,LinearData &dc0,LinearData &dc1) const;
    bool is_encroached(const Point2D&) const;
    template <typename iterator> static bool encroaches(Point2D p,
            const iterator& bounding_start, const iterator& bounding_end);
    int left_of_curve(Point2D&,int,double&) const;
    double curvature_angle() const;
    void print() const;

    /* Friend Functions */
    friend std::ostream &operator<<( std::ostream &stream, const BezierEdge& e);

    declare_iterators_canon(vertex, vertices, BezierVertex);
    declare_iterators_any(face, faces, BezierTriangle);

 private:
    void replace_cp(const ControlPoint& oldp, const ControlPoint& newp);

 private:
    /* Data members */
    ControlPoint cp_[3]; 
    DataPoint dp_[3]; 
    BoundaryEdge *bdry_edge_; 
    double u_[2]; 
 private:
    /* illegal */
    BezierEdge(const BezierEdge &o);
    BezierEdge& operator=(const BezierEdge &o);
};

class CurvedTriangle {
public:
    bool newton_find(const Point2D &p, double &u, double &v, int &niter, int &edge_num) const;
    bool newton_find(const Point2D &p, double &u, double &v) const;
    virtual void jacobian_matrix(double u,double v,Point2D &pdu,Point2D &pdv) const =0;
    virtual Point2D eval(double u,double v) const =0;
    CurvedTriangle() {} 
    virtual ~CurvedTriangle() {} 
};


/*  This is the triangle orientation for both
 *  BezierTriangles and GhostTriangles
 *
 *    ^     5
 *    |    / \
 *    u   /   \
 *    |  3     4
 *    | / ccw   \
 *     /  --->   \
 *    0_____1_____2
 *
 *      ----v--->
 *
 * ccw_order: [0, 1, 2, 4, 5, 3]
 */

class BezierTriangle : public FaceCell, public CurvedTriangle
{
public:
    typedef FaceCell super; // ignore CurvedTriangle
    friend class BezierMesh;

    /* Constructors */
    BezierTriangle(PersistantStore&, 
                   BezierEdge * const es[3], const DataStore&, bool inverse_handed=false);
    void set_boundary_face(BoundaryFace *f);

    /* Destructor */
    virtual ~BezierTriangle() {} 
    /* Point access */
    int get_num_cp() const { return 6; }
    const Point2D& get_cp(int i) const;
    Point2D& access_cp(int i);
    void set_cp(int i, const Point2D &p);
    ControlPoint get_control_point(int i) const;

    /* Data access */
    int get_num_dp() const { return get_num_cp(); }
    const LinearData& get_dp(int i) const;
    LinearData& access_dp(int i);
    void set_dp(int i, const LinearData &p);
    DataPoint get_data_point(int i) const;

    /* Index-based accessors, since BezierTriangles always have exactly
       three edges. */
    int get_num_edges() const { return 3; }
    BezierEdge *get_edge(int i);
    const BezierEdge *get_edge(int i) const;

    bool has_bdry_face() const;
    const BoundaryFace *get_bdry_face() const;
    BoundaryFace *get_bdry_face();
    BoundaryFace *get_bdry_face_or_null(); // used in splitting the face

    double get_min_angle() const;
    int get_color() const;

    /* Constant Member Functions */
    const BezierEdge* get_edge(int p0, int p1) const;
    BezierEdge* get_edge(int p0, int p1);
    Point2D eval(double alpha, double beta) const;
    LinearData dataeval(double alpha, double beta) const;
    void evalIntermediate(double alpha, double beta, Point2D &p, Point2D &pc0, Point2D &pc1, Point2D &pc2) const;
    void dataevalIntermediate(double alpha, double beta, LinearData &d,  LinearData &dc0, LinearData &dc1, LinearData &dc2) const;
    double jacobian(double alpha ,double beta) const;
    void jacobian_matrix(double alpha, double beta, Point2D &pdu, Point2D &pdv) const;
    void bound_jacobian(double &min, double &max, double &area) const;
    bool newton_find(const Point2D &p, double &u, double &v, int &niter, int &edge_num);
    double area() const;

    bool small_angle() const;
    bool is_linear_inverted() const;
    int is_inverted() const;
    bool is_definitely_inverted() const;
    bool is_definitely_not_inverted() const;

    Point2D circumcenter() const;
    Point2D offcenter() const;
    Point2D offcenter(double beta) const;
    void print() const;
    void print_mathematica() const;

    /* Friend Functions */
    friend std::ostream &operator<<( std::ostream &stream, const BezierTriangle& t);

    declare_iterators_canon(edge, edges, BezierEdge);

private:
    int get_edge_index_by_cps(int p0, int p1) const;
    void replace_cp(const ControlPoint& oldp, const ControlPoint& newp);

private:
    /* Data members */
    ControlPoint cp_[6]; 
    DataPoint dp_[6]; 
    BoundaryFace *bdry_face_; 
private:
    /* illegal */
    BezierTriangle(const BezierTriangle &o);
    BezierTriangle& operator=(const BezierTriangle &o);
};


class GhostTriangle : public CurvedTriangle {
 public:
    /* Data members */
    Point2D cp[6]; 
    LinearData dp[6]; 
    /* Constructors */
    GhostTriangle(const BezierTriangle &bt);
    GhostTriangle();

    /* Destructor */
    virtual ~GhostTriangle() {} 
    void set_cp(int i,Point2D p);
    Point2D get_cp(int i) const;

    /* Constant Member Functions */
    void jacobian_matrix(double u,double v,Point2D &pdu,Point2D &pdv) const;
    double jacobian(double alpha ,double beta) const;
    LinearData dataeval(double u, double v) const;
    Point2D eval(double u, double v) const;
    void print() const;
    void print_mathematica() const;

    /* Friend Functions */
    friend std::ostream &operator<<( std::ostream &stream, const GhostTriangle& t);

 private:
    /* illegal */
    GhostTriangle(const GhostTriangle&);
    GhostTriangle& operator=(const GhostTriangle&);
};


/*############################# BEGIN INLINE FUNCTIONS #######################*/

/*******************************************/
/*               BezierEdge                */
/*******************************************/

template <typename iterator>
inline bool BezierEdge::encroaches(Point2D p,
        const iterator& bounding_start, const iterator& bounding_end)
{
  for(iterator outer = bounding_start; outer != bounding_end; ++outer) {
    iterator inner = outer;
    ++inner;
    for(; inner != bounding_end; ++inner) {
      /* compute the angle at p; if >90 then p is inside the circle
         (at 90, p would be on, <90, p is outside) */
      double dotproduct = (*outer - p) .dot (*inner - p);
      if(dotproduct < 0.0) {
        return true;
      }
    }
  }
  return false;
}

#undef declare_iterators_any
#undef declare_iterators_canon
#endif /* CELL_H */

---