flowvis_canvas.h

Go to the documentation of this file.

#ifndef FLOWVIS_CANVAS_H
#define FLOWVIS_CANVAS_H

#include <wx/glcanvas.h>
#include <wx/colour.h>

#include <memory>
#include <vector>

#include "flowvis_data.h"
#include "flowvis_program.h"
#include "streamlines.h"

class TransferFunctionSampler {
public:
    struct Color {
        float r, g, b, a;
    };


    virtual Color MapDensity(float density) = 0;
};

namespace
{
    float AngleR(vec3 velocity)
    {
        float pi = 3.14159265f;

        vec3 basic(0, 1);

        //Normalize, just in case
        velocity[2] = 0;
        velocity = !velocity;
        float radians = acos(basic * velocity) / (basic.length() * velocity.length());
        
        if(velocity[0] < 0)
        {
            radians = (2 * pi) - radians;
        }
        
        return radians;
    }

    float Angle(vec3 velocity)
    {
        return 180 / 3.14159265f * AngleR(velocity);
    }
}

struct ArrowPoint
{
    ArrowPoint(float pos_x, float pos_y, vec3 velocity)
        : x(pos_x)
        , y(pos_y)
    {
        length = velocity.length();
        rotation = Angle(velocity);
    }
    
    float x; 

    float y; 

    float rotation; 

    float length; 
};

typedef std::vector<ArrowPoint> ArrowPoints_T;

struct F_RGB
{

    float red;
    float green;
    float blue;

    F_RGB operator =(const wxColor &color)
    {
        red = static_cast<float>(color.Red()) / 255.0f;
        green = static_cast<float>(color.Green()) / 255.0f;
        blue = static_cast<float>(color.Blue()) / 255.0f;

        return *this;
    }
};

struct StreamlinePlotSettings
{
    bool plot;
    F_RGB color;
    bool plot_tapering;
    bool plot_glyphs;
    int glyph_density;
    GLuint glyph_texture;
};

struct StreamlineAlgSettings
{
    float stepsize;
    float dsep;
    float dtest;
    SLIterAlg interploation;
    int maxiter;
};

struct Arrows
{
    Arrows()
        : plot(false)
        , nr_x(0)
        , nr_y(0)
        , arrow_texture(-1)
    {
    }

    ArrowPoints_T arrow_points;

    bool plot; 
    int nr_x; 
    int nr_y; 
    GLuint arrow_texture; 
};

class FlowVisCanvas : public wxGLCanvas
{
public:
    enum RenderMode_E
    {
        FVC_SCREEN,
        FVC_VALUE_INTER,
        FVC_ARROW_INTER
    };

    FlowVisCanvas(wxWindow *parent, wxWindowID id = wxID_ANY);

    ~FlowVisCanvas() { SetCurrent(); }

    void SetData(std::auto_ptr<FlowVisData> data);

    void SetBackgroundSet(int set_nr);

    void UpdateTransferFunction(TransferFunctionSampler *sampler, int set_to_update);

    void LoadArrowTexture();
    
    void LoadGlyphTexture();

    void SetArrows(int x, int y);
    
    void SetArrowPlot(bool plot_arrows);
    void SetStreamlinePlot(bool plot_streamlines);
    void SetBackgroundPlot(bool plot_background);

    void SetLineColor(wxColour new_color);
    void SetLineTapering(bool plot_tapering);
    void SetLineGlyphs(bool plot_glyphs);
    void SetGlyphDensity(int new_density);

    void SetDsep(float dsep);
    void SetDtest(float dtest);
    void SetIntegType(int integ_index);
    void SetMaxIter(int maxiter);
    void SetStepSize(float step_size);

    void Prepare_Streamlines();

    void RenderToFile(const wxString& file_name, int width, int height);

    RenderMode_E m_mode;

protected:

    void OnPaint(wxPaintEvent &event );

    void OnSize(wxSizeEvent &event);

    void OnEraseBackground(wxEraseEvent &event);


private:
    DECLARE_EVENT_TABLE()

    
    void Render();

    void Render_Background();
    void Render_Arrows();
    void Render_ToScreen();
    void Render_ValueInter(int set);
    void Render_ArrowInter();
    void Render_Streamlines();
    
    bool InitGL();

    bool CheckGL();

    void InitTextures();

    void CreateEvenlySpacedArrows();

    enum GLStatus {
        GLS_INIT_PENDING,
        GLS_INIT_FAILED,
        GLS_OK
    };

    GLStatus m_glstatus; 
    std::auto_ptr<FlowVisData> m_data; 
    std::auto_ptr<FlowVisProgram> m_program; 

    std::vector<GLuint> m_tex_background; 
    std::vector<GLuint> m_tex_bg_trafu; 
    int m_background_set; 
    GLint m_viewport_width; 
    GLint m_viewport_height; 

    std::vector<Streamline> m_streamlines; 
    bool m_plot_background;
    
    StreamlinePlotSettings m_sl_settings;
    StreamlineAlgSettings m_sl_algorithm;

    float m_line_base_thickness;

    Arrows m_arrow_data;
};

#endif // FLOWVIS_CANVAS_H

---