beziermesh.h

Go to the documentation of this file.

#ifndef BEZIERMESH_H
#define BEZIERMESH_H

#include <iostream>
#include <cstddef>
#include <vector>
#include <queue>
#include <deque>

#include "beziercomplex.h"
#include "cell.h"
#include "cellcomplex.h"
#include "celltuple.h"
#include "fibonacci_heap.h"
#include "globals.h"
#include "hash_classes.h"
#include "hash_map.h"
#include "hash_set.h"
#include "util.h"

/* forward declaration */
class BoundaryMesh;
class DataStore;

class BezierMesh : public BezierComplex {
  private:
    int orient_edge_triangle(const BezierEdge *e, const BezierTriangle *t) const;
    void tri_cps_off_edge(BezierEdge *e, BezierTriangle *t, ControlPoint &cp3, ControlPoint &cp4, ControlPoint &cp5);
    void tri_param_to_edge_param(const BezierEdge *e, const BezierTriangle *t,  double& u, double alpha, double beta) const;
    void edge_param_to_tri_param(const BezierEdge *e, const BezierTriangle *t,  double u, double &alpha, double &beta) const;
    static bool robust_smooth( Point2D poly[], const Point2D &primary, const Point2D &secondary, Point2D &new_pt);
    static bool smooth_point( double x_ary[], double y_ary[], const Point2D &p, Point2D &new_pt);
#ifdef false
    void reinterpolate(std::list<BezierTriangle*> new_triangles,std::list<GhostTriangle*> old_triangles);
#endif
    void reinterpolate(BezierEdge* e, BezierTriangle **newt, GhostTriangle **oldt);
    bool interpolant_error(BezierTriangle *t, GhostTriangle **oldt, double alpha, double beta, LinearData &interp_err);
    double phi_evaluate(bool *tri_orientation, double alpha, double beta);
    int devillers(BezierVertex *v, std::list<BezierVertex*> &link, int stop_degree);
    void get_link(BezierTuple start_tup, std::list<BezierVertex*> &link);
    int check_bdry_vertex_removal_degeneracies(std::list<BezierVertex*> &link, BezierVertex *v);
    double ear_priority(BezierVertex *v, std::list<BezierVertex*>::iterator ear, const std::list<BezierVertex*> &link);
    void flip_out_cavity(std::list<BezierEdge*> &cavity, std::list<BezierEdge*> &new_cavity, BezierVertex *vert);
    BezierVertex* insert_point(BezierTriangle *t, double alpha, double beta);
    BezierVertex* insert_edge_midpoint(BezierEdge *e,double u);
    void get_edge_neighbor_cells( BezierEdge *e, BezierVertex* vs[], BezierEdge* es[], BezierTriangle* ts[] );
    void split_return_adjacent(BezierEdge *e, std::vector<BezierEdge*> &new_edges);
    void split_edge_near_unflippable(BezierEdge *e, std::vector<BezierEdge*> &new_edges );
 public:
    bool debug_flip(BezierEdge *e);
    bool debug_smooth(BezierEdge *e);
    void draw_smooth_error(const char *name, BezierEdge *e, Point2D poly[], const Point2D &prim, const Point2D &secd, BezierTriangle* ts[]);
    void draw_insert_error(const char* name, BezierTriangle* bt);
    void get_smooth_polygon(Point2D poly[], BezierVertex* vs[], BezierEdge* es[]);
    void get_flip_polygon(Point2D poly[], BezierVertex* vs[], BezierEdge* es[]);
 private:
    bool consistency_check_helper(const BezierTriangle *t, const BezierEdge *e,
                                  const int p[3]) const;
    bool print_check_inverted(const char *message, int expected = 0);
    std::vector<BezierTriangle*> sampler;
    hashers::hash_map<BezierTriangle*,int> sample_id_map;
    BezierTriangle* find_start_triangle(const Point2D &pt);
    int locate_point_in_quadratic_triangle(const Point2D&,
        BezierTriangle*, BezierTuple&, double& u, double& v);
    int locate_point_in_linear_mesh(const Point2D&, BezierTriangle*,
        bool allow_cross_bdry, BezierTuple&);
    typedef hashers::hash_map<BezierEdge*, double> EdgeLengthMapT;
    typedef hashers::hash_map<BezierVertex*, double> BallRadiusMapT;
    typedef hashers::hash_set<BezierVertex*> VertexSetT;
    typedef FHeap<BezierVertex> CoarsenQueueT;
    typedef std::list<BezierVertex*> CoarsenKillListT;
    void coarsen_calculate_edge_lengths(EdgeLengthMapT &edge_length);
    void coarsen_keep_boundary(double dp_epsilon, VertexSetT &keep);
    void coarsen_keep_large_function_angles(double angle_const, double min_area_const, VertexSetT &keep);
    void coarsen_approximate_sizing_func(double size_const, double nn_const, CoarsenQueueT &queue, VertexSetT &keep, EdgeLengthMapT &edge_length);
    void coarsen_make_lipshitz(double lip_const, CoarsenQueueT &queue, EdgeLengthMapT &edge_length, BallRadiusMapT &radius);
    void coarsen_find_verts_to_remove(VertexSetT &keep, EdgeLengthMapT &edge_length, BallRadiusMapT &radius, CoarsenKillListT &tokill);
    int  coarsen_remove_verts(CoarsenKillListT &tokill);
    void coarsen_draw_debug(VertexSetT &keep, BallRadiusMapT &radius, CoarsenKillListT &tokill);
  private:
    /* Define copy and assignment constructors as private to prevent thier use */
    BezierMesh( const BezierMesh &o);
    const BezierMesh& operator=( const BezierMesh &o);

 private:
    /* Data members. */
    BoundaryMesh *boundarymesh; 
    DataStore *datastore; 
    bool linear_flips;


 public:
    typedef Vertex_Hash_T Bezier_Vertex_Hash_T;
    typedef Edge_Hash_T Bezier_Edge_Hash_T;
    typedef Face_Hash_T Bezier_Face_Hash_T;
    BezierMesh(PersistantStore&, DataStore*);
    void set_bdry_mesh(BoundaryMesh*);

    ~BezierMesh();

    /*Member Functions */
    void set_linear_flips(bool val) { linear_flips=val; }

    /* use these to add an interior bezier vertex */
    BezierVertex* add_bezier_vertex(const Point2D &p);
    BezierVertex* add_bezier_vertex(const Point2D &p,const LinearData &d);

    /* use these to add an bezier vertex on the boundary
     * where cp is the cooresponding control point from the
     * boundary
     */
    BezierVertex* add_bezier_vertex(ControlPoint cp);
    BezierVertex* add_bezier_vertex(ControlPoint cp,const LinearData &d);

    /* Use these to add an interior edge */
    BezierEdge* add_bezier_edge(const Point2D &p, BezierVertex *v0, BezierVertex *v1);
    BezierEdge* add_bezier_edge(const Point2D &p,const LinearData &d, BezierVertex *v0, BezierVertex *v1);
    BezierEdge* add_straight_bezier_edge(BezierVertex*, BezierVertex*);
    BezierEdge* add_straight_bezier_edge(const LinearData&,
                                                BezierVertex*, BezierVertex*);

    /* Use these to add an bezier edge on the boundary
     * where cp is the cooresponding control point from the spline
     */
    BezierEdge* add_bezier_edge(ControlPoint cp, BezierVertex *v0, BezierVertex *v1);
    BezierEdge* add_bezier_edge(ControlPoint cp,const LinearData &d, BezierVertex *v0, BezierVertex *v1);

    /* use this too add a new triangle */
    BezierTriangle* add_bezier_triangle(BoundaryFace *face,BezierEdge *e0,BezierEdge *e1,BezierEdge *e2, bool inverse_handed=false);
    virtual void delete_vertex(BezierVertex *vert);
    virtual void delete_edge(BezierEdge *edge);
    virtual void delete_face(BezierTriangle *face);
    /* Use these to replace the ControlPoints; mostly useful in the
     * bootstrapping phase. */
    void replace_control_point(BezierVertex*, const ControlPoint& newp);
    void replace_control_point(BezierEdge*, const ControlPoint& newp);
    BezierVertex* clean_insert_point(Point2D p,
                                     BezierTriangle* start_tri = NULL,
                                     bool over_bdry = true,
                                     bool force = true);
    BezierVertex* clean_insert_point(BezierTriangle *t, double alpha,
                                     double beta, bool force = false);
    BezierVertex* clean_insert_edge_midpoint(BezierEdge *e, double u,
                                             bool force = true);
    BezierVertex* clean_insert_circumcenter(BezierTriangle *t);
    BezierTuple remove_vertex(BezierVertex *v);
    bool smooth_edge(BezierEdge *e);
    bool flip(BezierEdge *e, BezierTuple &tup);
    int blind_locate_point(Point2D pt, BezierTuple&, double &u, double &v);
    int locate_point(Point2D pt, BezierTriangle *start_tri, bool over_bdry,
                     BezierTuple&, double &u, double &v);
    bool should_flip(BezierEdge *e);
    bool can_flip(BezierEdge *e);
    bool can_flip(BezierEdge *e, bool &is_typeA, bool &is_typeB);
    bool can_smooth(BezierEdge *e);
    bool should_refine_func_angle(BezierEdge *e, double angle_const, double min_area_const);
    double function_angle(BezierEdge *e, double u, int func_idx);
    int find_inverted_triangles(std::vector<BezierTriangle*> &inverted);
    int classify_inverted_triangles(std::vector<BezierTriangle*> &normal, std::vector<BezierTriangle*> &inverted, std::vector<BezierTriangle*> &unknown);
    bool check_consistency() const;

    int smooth_mesh(double jacobian_bound, int passes=1);
    int make_delaunay();
    int make_delaunay(double angle_const, double min_area_const);
    int make_delaunay(std::deque<BezierEdge*> flip_list);
    int make_delaunay(std::deque<BezierEdge*> flip_list, double angle_const, double min_area_const);
    int protect_boundarys();
    int remove_small_angles();
    int remove_large_triangles(double size_const);
    int function_angle_refine(double angle_const, double size_const);
    int coarsen_const_size(double size_const, double lip_const, double nn_const, double dp_epsilon);
    int coarsen_func_angle(double size_const, double lip_const, double nn_const, double dp_epsilon, double angle_const, double min_area_const);
    int coarsen_func_angle_debug(double size_const, double lip_const, double nn_const, double dp_epsilon, double angle_const, double min_area_const);
    /* TODO: make this private! Or an argument of coarsen_func_angle. */
    double func_angle_x_cuttoff;

    int data_length() const;

 protected:
    friend std::ostream& operator<<( std::ostream &stream, const BezierMesh &bm);
};
#endif /* BEZIERMESH_H */

---