---

Data.h

#if !defined(__FLOWVIZ_H)
#define __FLOWVIZ_H

#include "MyMathUtils.h"
#include "Streamline.h"


const int rasterPosX=350;     //raster position in x where pixel image output starts
const int rasterPosY=70;      //raster position in y where pixel image output starts
const int xOut=350;           //dimension in x of output array
const int yOut=560;           //dimension in y of output array
//const int maxIntegrationSteps=10000; //maximum number of integration steps
const int maxIntegrationSteps=1000; //maximum number of integration steps
const float eps = static_cast<float>(0.0001);   //error bound for float calculations
const float stride = static_cast<float>(0.1);  //stride for integration


class Data
{
public:
        Vektor2f *position; //data structure to keep position data (no equidistant grid!)
        GLubyte *show;    //data to be shown
        float *flowX;     //data structure to keep flow data in x-direction
        float *flowY;     //data structure to keep flow data in y-direction
        float *pressure;  //pressure data
        float *vorticity; //vorticity data
        float *fx;
        float *fy;
        float *fv;
        float *fp;
        float *fvor;
        float length_interval_x;
        float length_interval_y;
        int dsep;
        float dtest;
        float dtestfactor;
        int method;
        int background;
        bool hedgehog;
        bool vel;
        float scale_SmallToBig_x;
        float scale_SmallToBig_y;
        float scale_BigToSmall_x;
        float scale_BigToSmall_y;
        int cells[9];
        Streamline *slByHand;
        vector<Streamline*> streamLines;
        vector<Vektor2i*> seedCandidates;

        struct Header
        {
                short xDim;
                short yDim;
                short zDim;
                short nf;       //number of additional sets
                short nt;   //number of time steps
                double dt;   //time between 2 time steps
        };

        Header header;

public:

        Data()
        {
                Initialize();
        }

        virtual ~Data()
        {
                Destroy();
        }

        void getData(CString fileName);

        void showData();

        void drawHedgehogPlot(int length);

        void drawStreamlines();

        void drawSingleStreamline(Streamline *sl);

        void showSingleStreamline(int x, int y);

        void processUserInput();



private:

        void Initialize();

        void Destroy();

        void initializeGlobals();

        void doCleanUp();

        void extractData();

        void addSamplePointsToCells(Streamline *sl);

        void calculateStreamlines();

        void addStreamLineToVector(Streamline *sl);

        Streamline getStreamLineFromVector(int pos);

        void calculateSeedCandidates(Streamline *sl);

        void addSeedCandidate(int x, int y);

        Vektor2i getSeedCandidate(int pos);

        void deleteFirstSeedCandidate();

        float* getInterpolatedMatrix(float *in, float *out, float *minval, float *maxval);

        float getMaxValue(float *in, int xDim, int yDim);

        float getMinValue(float *in, int xDim, int yDim);

        float getMaxAbs(float a, float b);

        float* getVelocityMatrix(float *in1, float *in2, float *out, int xDim, int yDim);

        void generateShowArray(float *in, float posFactor, float negFactor);

        float* addToMatrix(float *in, float val, int xDim, int yDim);

        float round(float a);

        float getDistance(Vektor2i v1, Vektor2i v2);

        Vektor2f integrateEuler(Vektor2f old, float dt, int direction);

        Vektor2f integrateRK2(Vektor2f old, float dt, int direction);

        Vektor2f integrateRK4(Vektor2f old, float dt, int direction);

        bool checkPoint(Vektor2f point);

        bool checkCoordinates(int x, int y);

        Vektor2f getFlow(Vektor2f in);

        Vektor2f getInitialStreamlineSeedPoint();

        bool checkValidity(Vektor2i sp, float mindistance);

        void integrateStreamline(Streamline* sl, Vektor2f seed, int method, int direction, bool single);

        Streamline* getStreamline(Vektor2f seed, int method, bool single);

        void transformSmallToBig(float x, float y, int *res_x, int *res_y);

        void transformBigToSmall(float *res_x, float *res_y, int x, int y);

        int getAddress(float x, float y, int old_adr);

        void drawLine(int x1, int y1, int x2, int y2);

        float bilinearInterpolationRegular(float x,                             //x-coordinate to interpolate
                                                                           float y,                             //y-coordinate to interpolate
                                                                           float val_lxly,              //value on lower x/lower y
                                                                           float val_uxly,              //value on upper x/lower y
                                                                           float val_lxuy,              //value on lower x/upper y
                                                                           float val_uxuy);             //value on upper x/upper y


        float bilinearInterpolationIrregular(float x,                   //x-coordinate to interpolate
                                                                             float y,                   //y-coordinate to interpolate
                                                                                 float lxb,                     //lower x bound
                                                                                 float lyb,                     //lower y bound
                                                                                 float uxb,                     //upper x bound
                                                                                 float uyb,                     //upper y bound
                                                                                 float val_lxly,        //value on lower x/lower y
                                                                                 float val_uxly,        //value on upper x/lower y
                                                                                 float val_lxuy,        //value on lower x/upper y
                                                                                 float val_uxuy);       //value on upper x/upper y

};
#endif //#if !defined(__FLOWVIZ_H)

---