E:/3pg/Studium/TU Wien/08 09 Wintersemester/Visualisierung/Aufgabe2/src_doxygen/LayerStreamlines.h

Go to the documentation of this file.

#ifndef H_LAYER_STREAMLINES
#define H_LAYER_STREAMLINES

#include "Layer.h"
#include <QPointF>
#include <QColor>
#include <queue>

class Grid;

class Streamline
{
public:
        Streamline();
        ~Streamline();
        //std::queue<QPointF*> *seedPoints;
        std::queue<QPointF> seedPoints;

private:

};

class SPointF : public QPointF
{
public:
        SPointF();
        SPointF(QPointF p, QColor color, double texIntensity, double width);
        ~SPointF();

        QColor color;
        double texIntensity;
        double width;
};

class LayerStreamlines : public Layer
{
        Q_OBJECT

public:
        LayerStreamlines();
        ~LayerStreamlines();

        void setWidget(QWidget *widget);

        void draw(const DrawInfo &drawInfo);
        std::list<SPointF> genStreamline(QPointF start);

public slots:
        void setFlowData(FlowData *flowData);
        void setSize(const QSize &size);
        void drawImage();
        void updateImage();
        void autoUpdateImage();

        void setEulerMethod();
        void setRungeKuttaMethod();
        void setStepSize(double size);
        void setLineWidth(int width);
        void setDSep(double dSep);
        void setDTest(double dTest);
        void toggleGlyphMapping(bool val);
        void setGlyphSize(int size);
        void toggleTexture(bool val);
        void setTextureLength(int length);
        void toggleTapering(bool val);
        void toggleAutoUpdate(bool val);


private:
        QPainter* initImageAndPainter();
        void invalidate();
        void calculate();
        void clearStreamlinesQueue();
        void addSeedPoints(QPointF p, Vector3 vec);
        double calcThicknessCoef(double d);
        double textureFunction(int x);
        QPen updatePen(SPointF point);
        QPainterPath getPath(std::vector<QPointF> points);
        QImage image;
        Grid* grid;
        std::queue<Streamline*> streamlineQueue;
        Streamline* curStreamline;
        std::vector<std::list<SPointF>> paths;
        QPointF nextPos(Vector3 vec, QPointF curPos, bool forward);
        double stepSize, lineWidth, dSep, dTest, glyphSize, textureLength; 
        int integrationMethod;
        bool autoUpdate, activeGlyph, activeTexture, activeTapering;
};

class Grid
{
public:
        Grid(float aspect, double dSep, double dTest, double StepSize);
        ~Grid();
        bool add(QPointF samplePoint, double* smallestDist);
        void toIgnore(QPointF samplePoint);
        void startNewStreamline();
        bool canAdd(QPointF samplePoint, double* smallestDist = 0);

        int queueMaxSize;

private:
        bool addWithoutQueue(QPointF samplePoint, double* smallestDist);
        int getIndex(QPointF samplePoint);
        std::vector<QPointF>* data;
        std::queue<QPointF> ignoredData;
        double dSep, dTest, stepSize, aspect;
        QSize gridSize;
};

#endif // H_LAYER_STREAMLINES

---