StreamlineRenderer.h

Go to the documentation of this file.

// vim:set ts=4 sw=4 noet cin:
#ifndef STREAMLINERENDERER_H_
#define STREAMLINERENDERER_H_

#include <queue>
#include <QColor>
#include <QBrush>
#include <QPainter>
#include "ARender.h"


class StreamlineRenderer : public ARender {
        public:
                enum StreamlineMode {
                        Regular,      
                        Interactive,  
                        EvenlySpaced  

                };
                enum Direction {
                        Front, 
                        Back,  
                        Both   
                };

                StreamlineRenderer(const Data& aData);

                virtual void render(QPixmap* pixmap);

                void setStreamlinePen(QPen pen) { mStreamlinePen = pen; }

                void setStreamlineMode(StreamlineMode mode) {
                        if (mode != mMode) {
                                mMode = mode;
                                clearStreamlines();
                        }
                }

                void clearStreamlines() {
                        mStreamlinePoints.clear();
                }

                void addStreamLinePoint(const Vector<>& aPoint, Direction dir) {
                        mStreamlinePoints.push_back(std::pair<Vector<>, Direction>(aPoint, dir));
                }
                void addStreamLinePoint(int x, int y, Direction dir) {
                        QMatrix m;
                        setupCoordSystem(m);
                        QPointF transformed(m.inverted().map(QPointF(x, y)));
                        addStreamLinePoint(Vector<>(transformed.x(), transformed.y()), dir);
                }

                void setDT(float dt) { mDT = dt; }

                void setDSep(float dsep) { mDSep = dsep; }

                void setDTest(float dtest) { mDTest = dtest; }
                
        protected: 
                float mDT;
                
                Vector<> v(const Vector<>& s) const { return mData.getFlow(s.x(),s.y());}
                
        private:
                virtual Vector<> newPoint(const Vector<>& oldPoint, Direction dir) const = 0;

                void drawStreamline(QPainter& painter, const Vector<>& point, Direction dir);

                void streamLinePoints(const Vector<>& point, Direction dir, QVector<QPointF>& pointPairs);

                void markSamplePoint(const QPointF& p);

                float minDistance(const QPointF& p);

                float minDistance(const Vector<>& v) {
                        return minDistance(QPointF(v.x(), v.y()));
                }

                // FIXME: Make this a grid
                std::vector<QPointF> mSamplePoints;

                std::queue< Vector<> > mPendingSeedPoints;

                QPen mStreamlinePen;
                typedef std::vector< std::pair<Vector<>, Direction> > PointList;
                PointList mStreamlinePoints;
                StreamlineMode mMode;

                float mDSep;
                float mDTest;
};

class EulerRenderer : public StreamlineRenderer{

        public:
                EulerRenderer(const Data& aData): StreamlineRenderer(aData){}
                EulerRenderer(const StreamlineRenderer& aRenderer): StreamlineRenderer(aRenderer){}

        private:
                virtual Vector<> newPoint(const Vector<>& s0, Direction dir) const;     
};

class Rk2Renderer : public StreamlineRenderer{
        public:
                Rk2Renderer(const Data& aData): StreamlineRenderer(aData){}
                Rk2Renderer(const StreamlineRenderer& aRenderer): StreamlineRenderer(aRenderer){}
                
        private:
                virtual Vector<> newPoint(const Vector<>& s0, Direction dir) const;     
};

class Rk4Renderer : public StreamlineRenderer{
        public:
                Rk4Renderer(const Data& aData): StreamlineRenderer(aData){}
                Rk4Renderer(const StreamlineRenderer& aRenderer): StreamlineRenderer(aRenderer){}
                
        private:
                virtual Vector<> newPoint(const Vector<>& s0, Direction dir) const;     
};

#endif

---