visualization.h

Go to the documentation of this file.

#ifndef VISUALIZATION_H
#define VISUALIZATION_H

//#include <vector>

#include "pic.h"

#include "globals.h"
#include "color.h"
#include "util.h"
#include "cell.h"
#include "celltuple.h"


/*This makes all triangles no matter how small be drawn */
/* as of riught now turingin this off draw less triangles, but may leave empty regions on the screen */
#define DRAW_SMALL_TRIS


/* Forward declarations */
class BezierMesh;
class BoundaryMesh;
class Simulation;

class Visualization {
    private:
        Pic* dump_pixels(Pic* &p);
        void init_zoom();
        void initialize(BezierMesh *_bezier_mesh, BoundaryMesh *_bdry_mesh, int _screen_width=-1, int _screen_height=-1,bool _project=false);

        /* visibility predicates*/
        bool is_visible(const Point2D &p);
        bool is_visible(const BoundaryVertex *v);
        bool is_visible(const BezierVertex *v);
        bool is_visible(const BezierEdge *e);
        bool is_visible(const BezierTriangle *t);

    public:
        Point2D world_top; 
        Point2D world_bot; 
        Point2D world_center; 
        double world_width; 
        double world_height; 
        double world_ratio; 

        Point2D zoom_top; 
        Point2D zoom_bot; 
        Point2D zoom_center; 
        double zoom_width; 
        double zoom_height; 
        double zoom_ratio; 
        bool zoomed; 

        Point2D view_top; 
        Point2D view_bot;
        double pixel_area; 



        int screen_width; 
        int screen_height; 
        double screen_ratio; 

        ColorMap colormap;

        int edge_draw_acc; 
        int face_draw_acc; 
        BezierMesh *bezier_mesh; 
        BoundaryMesh *bdry_mesh; 
        /* Constructor */
        Visualization(Simulation *sim, int _screen_width, int _screen_height);
        Visualization(Simulation *_sim);
        Visualization(BezierMesh *_bezier_mesh, BoundaryMesh *_bdry_mesh, int _screen_width, int _screen_height);
        Visualization(BezierMesh *_bezier_mesh, BoundaryMesh *_bdry_mesh);
        Visualization(BezierMesh *_bezier_mesh, BoundaryMesh *_bdry_mesh, bool _project);

        /* Destructor */
        ~Visualization();

        /* Control for colormap */
        int map_color(int idx, const Color &color);

        /* Set drawing accuracy */
        void set_accuracy(int edge_acc, int face_acc)
        {
            assert(edge_acc>0);
            assert(face_acc>0);
            edge_draw_acc = edge_acc;
            face_draw_acc = face_acc;
        }

        /* Image ouput via libpicio */
        int write_jpeg(char *filename);
        int write_tiff(char *filename);
        int write_ppm(char *filename);

        /* Functions to control projection onto screen */
        void resize(int width, int height);
        void get_bbox(BezierTriangle* t[], int num, Point2D &top, Point2D &bot);
        void compute_world_size();
        void project();
        Point2D convert_from_screen_coords(int x, int y);
        void zoomin(Point2D zt, Point2D zb);
        void zoomout();

        /* Normzalization functions */
        int get_norms(std::vector<double> &min, std::vector<double> &max);

        /* High Level Drawing functions to draw entire mesh */
        void draw( const Color &bdry_color, const Color &edge_color);
        void draw_bezier( const Color &edge_color, const Color &tri_color);
        void draw_solid( const Color &bdry_color, const Color &edge_color);
        void draw_data( const Color &bdry_color, const Color &edge_color, unsigned rp, unsigned gp, unsigned bp);
        void draw_debug( const Color &bdry_vert_color, const Color &bdry_edge_color, const Color &mesh_color );
        void draw_debug( const Color &bdry_vert_color, const Color &bdry_edge_color, const Color &mesh_color, const Color &tri_color );
        void draw_bdry_debug( const Color &vert_color, const Color &edge_color,const Color &control_color, const Color &deboor_color);

        /* High level drawing functions to work with tumble-view.rb */
        void draw_skeleton( const Color &bdry_color, const Color &edge_color, bool draw_edges);
        void draw_solid( const Color &bdry_color, const Color &edge_color, bool draw_edges);
        void draw_data_channel(const Color &bdry_color, const Color &edge_color, unsigned channel, double min, double max, bool draw_edges);

        /* Low level drawing functions to draw individual elements */
        void draw_tuple(const BezierTuple &tup, const Color &vc, const Color &ec, const Color &fc);
        void draw_point(BezierTriangle *t, double u, double v, const Color &tc, const Color &vc);
        void draw_point(BezierEdge *e, double u, const Color &ec, const Color &vc);
        void draw_point(const Point2D &p, const Color &color, double size);
        void draw_circle(const Color &color, const Point2D &p, double radius);
        void draw_boundary_vertex(BoundaryVertex *v, const Color &color);
        void draw_boundary_edge(const BoundaryEdge *e, const Color &color);
        void draw_boundary_edge_debug(const BoundaryEdge *e, const Color &edge, const Color &control, const Color &deboor);
        void draw_bezier_vertex(BezierVertex *v, const Color &color);
        void draw_bezier_edge(BezierEdge *e, const Color &color);
        void draw_bezier_triangle(BezierTriangle *f);
        void draw_bezier_triangle(BezierTriangle *f, const Color &color);
        void draw_bezier_triangle(BezierTriangle *f, unsigned r, unsigned g, unsigned b);
        void draw_bezier_triangle(BezierTriangle *f, unsigned channel, double min, double max);
        void draw_control_net(BezierTriangle *t, const Color &color);
        void draw_polygon(Point2D ps[], int len, const Color &color);
        void draw_smooth_debug(BezierEdge *e, Point2D poly[], const Point2D &primary, const Point2D &secodary);
        void draw_flip_debug(BezierEdge *e, Point2D poly[], const Point2D &primary, const Point2D &secodary);

        void start_draw();
        void finish_draw();



        /* Debugging functions for ruby */
        BezierTuple visual_locate(Point2D pt);
        void visual_switch(int snum,BezierTuple &tup);
        void draw_newton();
        void draw_inverted_classes();
        int draw_smoothable_edges();
        int draw_flippable_edges();

        /* Obsolete Debugging functions
        double get_jacobian(BezierTriangle *t, Point2D p);
        void check_for_inversions();
        void draw_troubled_triangles(BezierTriangle *t1, BezierTriangle *t2, Point2D pt, Point2D *poly);
        void draw_troubled_interp_triangles(BezierTriangle *t1, GhostTriangle **oldts, Point2D pt);
        */

};
#endif /* VISUALIZATION_H */

---