glwidget.h

#ifndef GLWIDGET_H
#define GLWIDGET_H

#define GL_GLEXT_PROTOTYPES
#include <GL/glew.h>
#include <QGLWidget>
#include <GL/glext.h>
#include <algorithm>
#include <math.h>
#include <queue>
#include "FlowData.h"
#include "gradienteditor.h"

class GLWidget : public QGLWidget
{
        Q_OBJECT

public:
        GLWidget(QWidget *parent = 0);
        ~GLWidget();

        QSize minimumSizeHint() const;
        QSize sizeHint() const;
        void setFlowData(FlowData *newFlowData);
        void setBackgroundColorsPtr(QRgb* colorsPtr);
        void setArrowColorsPtr(QRgb* colorsPtr);
        void setStreamlineColorsPtr(QRgb* colorsPtr);
        
public slots:
        void setBackgroundColors();
        void setArrowColors();
        void setStreamlineColors();     
        void setDrawBackground(bool state);
        void setBackgroundColorChannel(int channel);
        void setDrawArrows(bool state);
        void setArrowQuantity(int quantity);
        void setArrowColorChannel(int channel);
        void setDrawStreamlines(bool state);
        void setStreamlineMode(int mode);
        void setStreamlineDtest(int newDtest);
        void setStreamlineDsep(int newDsep);
        void setStreamlineDt(int newDt);
        void setStreamlinePeriod(int Period);
        void setStreamlineLineMode(int mode);
        void setStreamlineColorChannel(int channel);    

signals:

protected:
        void initializeGL();
        void paintGL();
        void resizeGL(int width, int height);
        void mousePressEvent(QMouseEvent *event);
        void mouseReleaseEvent(QMouseEvent *event);
        void mouseMoveEvent(QMouseEvent *event);
        void wheelEvent(QWheelEvent *event);

private:
        void draw();
        void normalizeAngle(int *angle);
        void buildTexture(void);
        char *file2string(const std::string & strFilename);
        GLuint loadShader(const std::string & strFilename);
        void printLog(GLuint obj);
        void drawArrowPlot(const int xScaler, const int yScaler);
        void calcEuler(float x, float y);
        void calcRunge(float x, float y);
        void calculateBackground();
        void drawStreamline(int mode);
        bool testRange(vec3 point);
        bool testCell(int cellx, int celly, vec3 point);
        float getTapering(vec3 point, vector<vec3> line, unsigned int i);
        float testCellTapering(int cellx, int celly, vec3 point, vector<vec3> line, unsigned int i);
        bool testSLDist(vec3 point, vector<vec3> line, unsigned int i);
        void calculateEvenStreamlines();
        void addPoint2Grid(vec3 point);
        void calcStartCandidates(vec3 pos);
        void initStreamlines();
        void removeLastPointfromCell(vec3 point);

        
        float flowDataWidthRatio;
        float flowDataHeightRatio;
        bool drawBackground;
        int backgroundColorChannel;
        bool drawArrows;
        int arrowQuantity;
        int arrowColorChannel;
        bool drawStreamlines;
        float dtest_factor;
        float dt_factor;
        int streamlineLineMode;
        int streamlineColorChannel;
        QRgb* backgroundColors;
        QRgb* arrowColors;
        QRgb* streamlineColors;
        FlowData* dataset;
        vector<vector<vec3> > streamlines;
        vector<vector<vec3> > pointgrid;
        queue<vec3> startCandidates;
        float dsep;
        float dtest;
        float dt;
        float cellSize;
        int gridSize[2];
        int cells;
        int period;
        bool integrationMode;
        
        GLuint channelTextureId;
};

#endif

---