FlowVis/RenderWidget.cpp

#include "RenderWidget.h"
#include "Framework/vec3.h"

#include <QtGui/QFileDialog>
#include <iostream>
#include <cmath>

RenderWidget::RenderWidget(QWidget *parent)
: QGLWidget(parent),textures(NULL),channelCount(0),PI(3.14159265358979323846)
{
        QSizePolicy policy(QSizePolicy::Expanding, QSizePolicy::Expanding);
        policy.setHeightForWidth(true);

        setSizePolicy(policy );

        this->setSizeIncrement(30,30);
        arrowCount = 35;
        textureSize = 100;
        d_sep_val = 1.f / 100.f;
        d_sep = d_sep_val * (float)textureSize;
        d_test_val = 0.8f;
        d_test = d_test_val * d_sep;
        dt = 0.5f;
        sl_num_samples = 50;
        xdata = NULL;
        ydata = NULL;
        integration_mode = EULER;
        streamline_mode = NORMAL;
        arrowSize = 2.5;
}

RenderWidget::~RenderWidget()
{
        delete simple;
        delete arrows;
        delete slines;
        delete sltexture;
        delete textures;
        delete xdata;
        delete ydata;

        simple = NULL;
        arrows = NULL;
        slines = NULL;
        sltexture = NULL;

        glDeleteLists(disp_lists[0], 1);
        glDeleteLists(disp_lists[1], 1);
        delete[] disp_lists;

        for (int i=0; i < streamlines.size(); i++)
        {
                delete streamlines[i];
        }
}

void RenderWidget::loadChannels(FlowData* dataset)
{
        //Anzahl von channels sollt gleich bleiben sonst gibts hier fehler
        //alte texturen loeschen
        if(channelCount != 0)
                glDeleteTextures(channelCount, textures);
        
        if (textures != NULL)
                delete textures;
        
        channelCount = dataset->getNumChannels();
        textures = new GLuint[channelCount];
        
        //Texturen generieren
        glGenTextures(channelCount, textures);
        
        GLenum glError = GL_NO_ERROR;
        glError = glGetError();
        if (glError != GL_NO_ERROR)
        {
                std::cerr<<"Error generating texture: "<<gluErrorString(glError)<<std::endl;
        } 

        int w,h;
        dataset->getGeometry(w,h);
        
        textureWidth = (w < h) ? textureSize: (int)( (float)textureSize*(float)w/(float)h );
        textureHeight = (w < h) ? (int)( (float)textureSize*(float)h/(float)w ) : textureSize ;

        sl_num_samples = (float)textureSize/2.f;

        //int size = textureSize;
        float* vdata = new float[textureWidth*textureHeight];
        if (xdata != NULL)
                delete xdata;
        if (ydata != NULL)
                delete ydata;
        xdata = new float[textureWidth*textureHeight];
        ydata = new float[textureWidth*textureHeight];
        
        //create channels

        int vel = dataset->createChannelVectorLength(0,1,2);
        
        //range for velocity
        float range = dataset->getChannel(vel)->getRange();
        float min = dataset->getChannel(vel)->getMin();

        std::cout << "Texture size: " << textureWidth <<"x"<<textureHeight << std::endl;

        for(int x=0; x<textureWidth; x++)
        {
                for(int y=0; y<textureHeight; y++)
                {
                        float velocity = dataset->getChannel(vel)->getValueNormPos(vec3(((float)x)/(float)textureWidth,((float)y)/(float)textureHeight));
                        //float xd = dataset->getChannel(chX)->getValueNormPos(vec3(((float)x)/(float)size,((float)y)/(float)size));
                        //float yd = dataset->getChannel(chY)->getValueNormPos(vec3(((float)x)/(float)size,((float)y)/(float)size));
                        float xd = dataset->getChannel(0)->getValueNormPos(vec3(((float)x)/(float)textureWidth,((float)y)/(float)textureHeight));
                        float yd = dataset->getChannel(1)->getValueNormPos(vec3(((float)x)/(float)textureWidth,((float)y)/(float)textureHeight));

                        float vel = sqrtf(xd*xd+yd*yd);
                        xdata[x+y*textureWidth] = xd/vel/2.0+0.5;
                        ydata[x+textureWidth*y] = yd/vel/2.0+0.5;
                        
                        //if(xdata[x*size+y] > 1.0 || xdata[x*size+y] < 0.0 || ydata[x*size+y] > 1.0 || ydata[x*size+y] < 0.0)
                        //      std::cout << "Fehler, out of range" << std::endl;
                        vdata[x+y*textureWidth] = (velocity-min)/range;
                }
                std::cout << "\r- Calculating x,y channel textures (" << (float)x*100.f/(float)(textureWidth - 1) << "%) ...";
        }       
        std::cout << std::endl;


        computeStreamlines();


        //glClientActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D,textures[CHANNEL_VELOCITY]);
        glTexImage2D(GL_TEXTURE_2D,0,GL_LUMINANCE32F_ARB,textureWidth,textureHeight,0,GL_LUMINANCE,GL_FLOAT,vdata);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_REPLACE);

        //glClientActiveTexture(GL_TEXTURE1);
        glBindTexture(GL_TEXTURE_2D,textures[CHANNEL_X]);
        glTexImage2D(GL_TEXTURE_2D,0,GL_LUMINANCE32F_ARB,textureWidth,textureHeight,0,GL_LUMINANCE,GL_FLOAT,xdata);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);


        //glClientActiveTexture(GL_TEXTURE2);
        glBindTexture(GL_TEXTURE_2D,textures[CHANNEL_Y]);
        glTexImage2D(GL_TEXTURE_2D,0,GL_LUMINANCE32F_ARB,textureWidth,textureHeight,0,GL_LUMINANCE,GL_FLOAT,ydata);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

        delete vdata;
        //delete xdata;
        //delete ydata;

        float* data = new float[textureWidth*textureHeight];
        
        //int count = dataset->getNumChannels()-3;
        for(int i=3; i <channelCount; i++)              //Restliche channels einlesen
        {
                range = dataset->getChannel(i)->getRange();
                min = dataset->getChannel(i)->getMin();

                for(int x=0; x<textureWidth; x++)
                {
                        for(int y=0; y<textureHeight; y++)
                        {
                                float d = dataset->getChannel(i)->getValueNormPos(vec3(((float)x)/(float)textureWidth,((float)y)/(float)textureHeight));
                                data[x+y*textureWidth] = (d-min)/range;
                        }

                        std::cout << "\r- Calculating channel"<<i<<" textures (" << (float)x*100.f/(float)(textureWidth - 1) << "%) ...";
                }
                std::cout << std::endl;
                glBindTexture(GL_TEXTURE_2D,textures[i]);
                glTexImage2D(GL_TEXTURE_2D,0,GL_LUMINANCE32F_ARB,textureWidth,textureHeight,0,GL_LUMINANCE,GL_FLOAT,data);
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        }
        
        delete data;
        
        glActiveTexture(GL_TEXTURE1);
        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
        
        glActiveTexture(GL_TEXTURE2);
        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
        
        glActiveTexture(GL_TEXTURE0);

        initArrows(arrowCount,(float)textureWidth/(float)textureHeight);
}

void RenderWidget::computeStreamlines()
{
        streamlines.clear();
        // calculate streamlines
        d_sep = d_sep_val * (float)textureWidth;
        d_test = d_test_val * d_sep;
        int gridwidth = (int)( (float)(textureWidth) / d_sep );
        int gridheight = (int)( (float)(textureHeight) / d_sep );
        vector<vec3>* grid = new vector<vec3>[gridwidth*gridheight];

        vec3 seed(0.5 * textureWidth, 0.5 * textureHeight);

        Streamline *s = calculateStreamline(&seed, gridwidth, gridheight, &grid);
        streamlines.push_back(s);
        queue<Streamline*> lines;
        lines.push(s);

        Streamline *currentS = (lines.front());
        vector<vec3> *samplepoints = (currentS->getSamplePointsPtr(false));
        int i=0;
        bool found_candidate = false;
        bool finished_front = false;

        queue<vec3> cands;

        // seed point of current streamline is not taken into consideration for new seedpoints!!

        while (true) {
                vec3 candidate;

                while (i < samplepoints->size() && cands.empty()) {
                        vec3 p = (*samplepoints)[i];
                        i++;
                        int ind = (int)(p[0]) + ((int)p[1] * textureWidth);
                        vec3 dir(-(ydata[ind] - 0.5), xdata[ind] - 0.5);
                        dir = !dir * d_sep;

                        candidate = p + dir;

                        if (candidate[0] >= 0 && candidate[1] >= 0 && 
                                candidate[0] < textureWidth && candidate[1] < textureHeight && 
                                gridAroundOkay(grid, gridwidth, gridheight, candidate, NULL)) {
                                        cands.push(candidate);
                        }

                        candidate = p - dir;

                        if (candidate[0] >= 0 && candidate[1] >= 0 && 
                                candidate[0] < textureWidth && candidate[1] < textureHeight && 
                                gridAroundOkay(grid, gridwidth, gridheight, candidate, NULL)) {
                                        cands.push(candidate);
                        }

                        //set to back list
                        if (!finished_front && i == samplepoints->size()) {
                                samplepoints = (currentS->getSamplePointsPtr(true));
                                i=0;
                                finished_front = true;
                        }
                }

                if (!cands.empty()) {

                        try {
                                // compute new streamline
                                Streamline *snext = calculateStreamline(&cands.front(), gridwidth, gridheight, &grid);
                                streamlines.push_back(snext);

                                // add streamline to queue
                                lines.push(snext);
                        } catch (std::exception e) {
                                //std::cerr << "streamline \"NULL\"" << std::endl;
                        }
                        cands.pop();
                } else {
                        lines.pop();    // deletes the streamline!

                        if (lines.empty())
                                break;
                        else {
                                currentS = (lines.front());
                                samplepoints = (currentS->getSamplePointsPtr(false));
                                if (samplepoints->size() == 0)
                                        samplepoints = currentS->getSamplePointsPtr(true);
                                i=0;
                                finished_front = false;
                        }
                }
        }

        switch (streamline_mode) {
        case NORMAL:
                generateNormalStreamlineList();
                break;
        case TAPERING:
                generateTaperingStreamlineList();
                break;
        case GLYPH:
                generateGlyphStreamlineList();
                break;
        case TEXTURE:
                generateTextureStreamlineList();
                break;
        }
}

Streamline* RenderWidget::calculateStreamline(vec3* seed, int gridWidth, int gridHeight, vector<vec3>** grid)
{
        Streamline *s = new Streamline(*seed);
        const int QUEUE_SIZE = d_sep/dt + 1.f;
        queue<vec3>* lastones = new queue<vec3>;
        float dist;

        try     {
                if ((dist = minGridDistance(*grid, gridWidth, gridHeight, *seed, lastones)) > d_test)
                {
                        gridAddAt(*grid, gridWidth, gridHeight, *seed);
                        if (dist < d_sep)
                                s->setSeedPointThickness((dist - d_test) / (d_sep - d_test));
                        else
                                s->setSeedPointThickness(1.f);
                } else
                        throw std::exception("Index out of bounds");
        } catch (std::exception e) {
                //std::cerr << "Grid around seed point not ok" << std::endl;
                throw std::exception("Grid around seed point not ok");
        }

        // go back and forth
        vec3 *current = seed;
        vec3 *newpoint;
        lastones->push(s->getSeedPoint());
        try
        {       // forth
                vec3 pf;
                while (true) {
                        switch (integration_mode)
                        {
                        case EULER:
                                pf = getNextEulerPoint(*current, false);
                                break;
                        case RK2:
                                pf = getNextRungeKutta2Point(*current, false);
                                break;
                        case RK4:
                                pf = getNextRungeKutta4Point(*current, false);
                                break;
                        }
                        if (pf.v[0] >= textureWidth || pf.v[1] >= textureHeight || pf.v[0] < 0 || pf.v[1] < 0)
                                break;
                        if ((dist = minGridDistance(*grid, gridWidth, gridHeight, pf, lastones)) > d_test)
                        {
                                gridAddAt(*grid, gridWidth, gridHeight, pf);
                                newpoint = s->addSamplePoint(pf, false);
                                if (dist < d_sep)
                                        s->addSamplePointThickness((dist - d_test) / (d_sep - d_test), false);
                                else
                                        s->addSamplePointThickness(1.f, false);

                                if (lastones->size() == QUEUE_SIZE) lastones->pop();
                                lastones->push(*newpoint);
                        }
                        else
                                break;
                        current = &pf;
                }
        }
        catch (std::exception e)
        {
                //std::cerr << "Next point is outside the texture" << std::endl;
        }

        current = seed;
        if (lastones->size() == QUEUE_SIZE) lastones->pop();
        lastones->push(s->getSeedPoint());
        try
        {       // back
                vec3 pb;
                while (true) {
                        switch (integration_mode)
                        {
                        case EULER:
                                pb = getNextEulerPoint(*current, true);
                                break;
                        case RK2:
                                pb = getNextRungeKutta2Point(*current, true);
                                break;
                        case RK4:
                                pb = getNextRungeKutta4Point(*current, true);
                                break;
                        }
                        if (pb.v[0] >= textureWidth || pb.v[1] >= textureHeight || pb.v[0] < 0 || pb.v[1] < 0)
                                break;
                        //if ((int)pb[0] == 54 && (int)pb[1] == 54)
                        //      cout << endl;   // for box debug
                        if ((dist = minGridDistance(*grid, gridWidth, gridHeight, pb, lastones)) > d_test)
                        {
                                gridAddAt(*grid, gridWidth, gridHeight, pb);
                                newpoint = s->addSamplePoint(pb, true);
                                if (dist < d_sep)
                                        s->addSamplePointThickness((dist - d_test) / (d_sep - d_test), true);
                                else
                                        s->addSamplePointThickness(1.f, true);

                                if (lastones->size() == QUEUE_SIZE) lastones->pop();
                                lastones->push(*newpoint);
                        }
                        else
                                break;
                        current = &pb;
                }
        }
        catch (std::exception e)
        {
                //std::cerr << "Next point is outside the texture" << std::endl;
        }

        delete lastones;

        return s;
}

void RenderWidget::gridAddAt(vector<vec3>* grid, int gridwidth, int gridheight, vec3 pos)
{
        vec3 gpos = pos / d_sep;
        int ind = (int)(gpos.v[0]) + ((int)gpos.v[1] * gridwidth);
        if (ind >= gridwidth * gridheight) 
                throw std::exception("Index out of bounds");
        grid[ind].push_back(pos);
}

bool RenderWidget::gridAroundOkay(vector<vec3>* grid, int gridwidth, int gridheight, vec3 pos, queue<vec3>* lastones) // grid als pointer?
{
        vec3 gpos = pos / d_sep;
        int gridmax = gridwidth * gridheight;

        for (int i=-1; i < 2; i++) {
                for (int j=-1; j < 2; j++) {
                        int x = (int)(gpos.v[0] + i);
                        int y = (((int)gpos.v[1] + j) * gridwidth);
                        int ind = x + y;
                        if (x < 0 || y < 0 || ind >= gridmax)
                                continue;
                        vector<vec3> list = grid[ind];
                        for (int k=0; k < list.size(); k++) {
                                if (!distanceOkay(pos, (list[k]))) {
                                        if (lastones == NULL) 
                                                return false;
                                        bool cont = false;
                                        for (int l=0; l < lastones->size(); l++) {
                                                if (list[k][0] == lastones->_Get_container()[l].v[0] &&
                                                        list[k][1] == lastones->_Get_container()[l].v[1]) {
                                                        cont = true;
                                                        break;
                                                }
                                        }
                                        if (cont) continue;

                                        return false;
                                }
                        }
                }
        }
        return true;
}

float RenderWidget::minGridDistance(vector<vec3>* grid, int gridwidth, int gridheight, vec3 pos, queue<vec3>* lastones)
{
        float minDist = d_sep;
        float dis = d_sep;
        vec3 gpos = pos / d_sep;
        int gridmax = gridwidth * gridheight;

        for (int i=-1; i < 2; i++) {
                for (int j=-1; j < 2; j++) {
                        int x = (int)(gpos.v[0] + i);
                        int y = (((int)gpos.v[1] + j) * gridwidth);
                        int ind = x + y;
                        if (x < 0 || y < 0 || ind >= gridmax)
                                continue;
                        vector<vec3> list = grid[ind];
                        for (int k=0; k < list.size(); k++) {
                                if (!distanceOkay(pos, (list[k]))) {
                                        if (lastones == NULL) 
                                                return pos.dist(list[k]);
                                        bool cont = false;
                                        for (int l=0; l < lastones->size(); l++) {
                                                if (list[k][0] == lastones->_Get_container()[l].v[0] &&
                                                        list[k][1] == lastones->_Get_container()[l].v[1]) {
                                                                cont = true;
                                                                break;
                                                }
                                        }
                                        if (cont) continue;

                                        return pos.dist(list[k]);
                                } else if ((dis = pos.dist(list[k])) < minDist) {
                                        minDist = dis;
                                }
                        }
                }
        }
        return minDist;
}

bool RenderWidget::distanceOkay(vec3 from, vec3 to)
{
        return from.dist(to) > d_test;
}

vec3 RenderWidget::getNextEulerPoint(vec3 sample_point, bool backward)
{
        float signed_dt = backward ? -dt : dt;
        int ind = (int)(sample_point.v[0]) + ((int)sample_point.v[1] * textureWidth);
        if (ind >= textureWidth * textureHeight) 
                throw std::exception("Index out of bounds");
        vec3 dir((xdata)[ind] - 0.5, ((ydata)[ind] - 0.5));
        // break at undef values (box)
        if (!(dir[0] > -100 && dir[0] < 100 && dir[1] > -100 && dir[1] < 100))
                throw std::exception("Hopefully INDEF error");
        vec3 ret = sample_point + (!dir * signed_dt);
        return ret;
}

vec3 RenderWidget::getNextRungeKutta2Point(vec3 sample_point, bool backward)
{
        float signed_dt = backward ? -dt : dt;
        int ind = (int)(sample_point[0]) + ((int)sample_point[1]) * textureWidth;
        if (ind >= textureWidth * textureHeight) 
                throw std::exception("Index out of bounds");
        vec3 dir((xdata)[ind] - 0.5, ((ydata)[ind] - 0.5));
        // break at undef values (box)
        if (!(dir[0] > -100 && dir[0] < 100 && dir[1] > -100 && dir[1] < 100))
                throw std::exception("Hopefully INDEF error");
        vec3 step1 = sample_point + (!dir * signed_dt / 2.f);

        ind = (int)(step1[0]) + ((int)step1[1]) * textureWidth;
        if (ind >= textureWidth * textureHeight) 
                throw std::exception("Index out of bounds");
        vec3 newdir((xdata)[ind] - 0.5, ((ydata)[ind] - 0.5));
        // break at undef values (box)
        if (!(newdir[0] > -100 && newdir[0] < 100 && newdir[1] > -100 && newdir[1] < 100))
                throw std::exception("Hopefully INDEF error");
        vec3 ret = sample_point + (!newdir * signed_dt);

        return ret;
}

vec3 RenderWidget::getNextRungeKutta4Point(vec3 sample_point, bool backward)
{
        float signed_dt = backward ? -dt : dt;
        int ind = (int)(sample_point[0]) + ((int)sample_point[1]) * textureWidth;
        if (ind >= textureWidth * textureHeight) 
                throw std::exception("Index out of bounds");
        vec3 adir((xdata)[ind] - 0.5, ((ydata)[ind] - 0.5));
        // break at undef values (box)
        if (!(adir[0] > -100 && adir[0] < 100 && adir[1] > -100 && adir[1] < 100))
                throw std::exception("Hopefully INDEF error");
        vec3 a = (!adir * signed_dt);

        vec3 step1 = sample_point + a / 2.f;
        ind = (int)(step1[0]) + ((int)step1[1]) * textureWidth;
        if (ind >= textureWidth * textureHeight) 
                throw std::exception("Index out of bounds");
        vec3 bdir((xdata)[ind] - 0.5, ((ydata)[ind] - 0.5));
        // break at undef values (box)
        if (!(bdir[0] > -100 && bdir[0] < 100 && bdir[1] > -100 && bdir[1] < 100))
                throw std::exception("Hopefully INDEF error");
        vec3 b = (!bdir * signed_dt);

        vec3 step2 = sample_point + b / 2.f;
        ind = (int)(step2[0]) + ((int)step2[1]) * textureWidth;
        if (ind >= textureWidth * textureHeight) 
                throw std::exception("Index out of bounds");
        vec3 cdir((xdata)[ind] - 0.5, ((ydata)[ind] - 0.5));
        // break at undef values (box)
        if (!(cdir[0] > -100 && cdir[0] < 100 && cdir[1] > -100 && cdir[1] < 100))
                throw std::exception("Hopefully INDEF error");
        vec3 c = (!cdir * signed_dt);

        vec3 step3 = sample_point + c;
        ind = (int)(step3[0]) + ((int)step3[1]) * textureWidth;
        if (ind >= textureWidth * textureHeight) 
                throw std::exception("Index out of bounds");
        vec3 ddir((xdata)[ind] - 0.5, ((ydata)[ind] - 0.5));
        // break at undef values (box)
        if (!(ddir[0] > -100 && ddir[0] < 100 && ddir[1] > -100 && ddir[1] < 100))
                throw std::exception("Hopefully INDEF error");
        vec3 d = (!ddir * signed_dt);

        vec3 ret = sample_point + (a + b * 2.f + c * 2.f + d) / 6.f;

        return ret;
}

void RenderWidget::printGLError()
{
        GLenum glError = GL_NO_ERROR;
        glError = glGetError();
        if (glError != GL_NO_ERROR)
        {
                std::cerr<<"GLError: "<<gluErrorString(glError)<<std::endl;
        } 
}

void RenderWidget::loadData(std::string filename)
{
        FlowData* dataset = new FlowData();
        //load a dataset, an example path is given
        bool result = dataset->loadDataset(filename,false);
        //exit if the loading was not successful
        if (!result) { std::cout << "Loading failed" << std::endl; return;}
        

        loadChannels(dataset);
        emit dataLoaded(channelCount-2);
        //memory clean up
        delete dataset;

}

void RenderWidget::initializeGL()
{
        GLint num;
        glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &num);
        printGLError();
        std::cout << "max num of image units: " << num << std::endl;

        disp_lists = new GLuint[2];

        initGlew();
        loadData("data/hurricane_p_tc_singletime10");

        Shader::get_errors();

        // Load and compile Shader files
        simple = new Shader("Shader/simple");

        if (!simple) {
                cerr << "Could not compile simple shader program." << endl;
        }

        arrows = new Shader("Shader/arrows", true, GL_POINTS, GL_TRIANGLE_STRIP, 10);

        if (!arrows) {
                cerr << "Could not compile arrow shader program." << endl;
        }

        slines = new Shader("Shader/streamlines");

        if (!slines)
                cerr << "Could not compile streamline shader program." << endl;

        sltexture = new Shader("Shader/sltexture");

        if (!sltexture)
                cerr << "Could not compile streamline texture shader." << endl;

        shaders.append(simple);
        shaders.append(arrows);
        shaders.append(slines);
        shaders.append(sltexture);

        slines->bind();
        glUniform1i(slines->get_uniform_location("data"), UNIT_DATA);
        glUniform1i(slines->get_uniform_location("transfer_function"), UNIT_TRANSFER);
        slines->unbind();
        
        arrows->bind();
        glUniform1i(arrows->get_uniform_location("data"), UNIT_DATA);
        glUniform1i(arrows->get_uniform_location("xchannel"), UNIT_X);
        glUniform1i(arrows->get_uniform_location("ychannel"), UNIT_Y);
        glUniform1i(arrows->get_uniform_location("transfer_function"), UNIT_TRANSFER);
        glUniform1f(arrows->get_uniform_location("size"),arrowSize);
        arrows->unbind();
        
        simple->bind();
        glUniform1i(simple->get_uniform_location("data"), UNIT_DATA);
        glUniform1i(simple->get_uniform_location("transfer_function"), UNIT_TRANSFER);
        simple->unbind();

        sltexture->bind();
        glUniform1i(sltexture->get_uniform_location("transfer_function"), UNIT_TRANSFER);
        sltexture->unbind();
        

        layers.append(new LayerRenderable());

        glEnable( GL_LINE_SMOOTH );
        glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);

        glEnable (GL_BLEND);
        glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

        glGenTextures(1,&testTransferTexture);

        settingsEmitSliderValue(0);
        settingsEmitSliderValue(1);
        settingsEmitSliderValue(2);
        settingsEmitSliderValue(3);
        settingsEmitSliderValue(4);
        settingsEmitSliderValue(5);
}

void RenderWidget::initArrows(int n, float aspect)
{
        float w = (aspect > 1.f) ? 1.f : aspect;
        float h = (aspect > 1.f) ? 1.f/aspect : 1.f;

        float x = -w;
        float y = -h;

        float widthX = (int)(w * (float)n);
        float widthY = (int)(h * (float)n);

        disp_lists[0] = glGenLists(1);

        glNewList(disp_lists[0], GL_COMPILE);
        glColor4f(1.0,1.0,1.0,1.0);
        glBegin(GL_POINTS);

        float diffX = 2.f*w/(widthX+2);
        float diffY = 2.f*h/(widthY+2);

        for(int i=1; i <=widthX+1; i++)
                for(int j=1; j<=widthY+1; j++)
                {
                        glVertex2f(x+(float)i*diffX, y+(float)j*diffY);
                }

        glEnd();
        glEndList();
}

void RenderWidget::generateNormalStreamlineList()
{
        float aspect = (float)textureWidth/(float)textureHeight;

        float w = (aspect > 1.f) ? 1.f : aspect;
        float h = (aspect > 1.f) ? 1.f/aspect : 1.f;

        if (0 != disp_lists[1])
                glDeleteLists(disp_lists[1], 1);
        disp_lists[1] = glGenLists(1);

        glNewList(disp_lists[1], GL_COMPILE);

        for (int i=0; i < streamlines.size(); i++) {
                glBegin(GL_LINE_STRIP);
                vec3 p;
                vector<vec3> points = streamlines[i]->getSamplePoints(true);
                for (int j = points.size() - 1; j >= 0; j--) {
                        p = (
                                vec3(points[j][0] / (float)textureWidth, 
                                points[j][1] / (float)textureHeight)
                                - vec3(0.5, 0.5)) * 2.f;
                        glVertex2f(p[0] * w, p[1] * h);
                }

                p = (
                        vec3(streamlines[i]->getSeedPoint()[0] / (float)textureWidth, 
                        streamlines[i]->getSeedPoint()[1] / (float)textureHeight)
                        - vec3(0.5, 0.5)
                        ) * 2.f;
                glVertex2f(p[0] * w, p[1] * h);

                points = streamlines[i]->getSamplePoints(false);
                for (int j=0; j < points.size(); j++) {
                        p = (
                                vec3(points[j][0] / (float)textureWidth, 
                                points[j][1] / (float)textureHeight)
                                - vec3(0.5, 0.5)) * 2.f;
                        glVertex2f(p[0] * w, p[1] * h);
                }
                
                glEnd();
        }

        glEndList();
}

void RenderWidget::generateTaperingStreamlineList()
{
        float aspect = (float)textureWidth/(float)textureHeight;

        float w = (aspect > 1.f) ? 1.f : aspect;
        float h = (aspect > 1.f) ? 1.f/aspect : 1.f;

        if (0 != disp_lists[1])
                glDeleteLists(disp_lists[1], 1);
        disp_lists[1] = glGenLists(1);

        glNewList(disp_lists[1], GL_COMPILE);

        float line_width = 3.f;
        
        for (int i=0; i < streamlines.size(); i++) {
                glLineWidth(line_width * streamlines[i]->getSeedPointThickness());
                glBegin(GL_LINES);
                vec3 p = (
                        vec3(streamlines[i]->getSeedPoint()[0] / (float)textureWidth, 
                        streamlines[i]->getSeedPoint()[1] / (float)textureHeight)
                        - vec3(0.5, 0.5)
                        ) * 2.f;
                glVertex2f(p[0] * w, p[1] * h);
                vector<vec3> points = streamlines[i]->getSamplePoints(false);
                vector<float> thicknessess = streamlines[i]->getSamplePointThicknesses(false);
                for (int j=0; j < points.size(); j++) {
                        p = (
                                vec3(points[j][0] / (float)textureWidth, 
                                points[j][1] / (float)textureHeight)
                                - vec3(0.5, 0.5)) * 2.f;
                        glVertex2f(p[0] * w, p[1] * h);

                        glEnd();
                        glLineWidth(line_width * thicknessess[j]);
                        glBegin(GL_LINES);

                        glVertex2f(p[0] * w, p[1] * h);
                }
                glEnd();

                glLineWidth(line_width * streamlines[i]->getSeedPointThickness());
                glBegin(GL_LINES);
                p = (
                        vec3(streamlines[i]->getSeedPoint()[0] / (float)textureWidth, 
                        streamlines[i]->getSeedPoint()[1] / (float)textureHeight)
                        - vec3(0.5, 0.5)
                        ) * 2.f;
                glVertex2f(p[0] * w, p[1] * h);
                points = streamlines[i]->getSamplePoints(true);
                thicknessess = streamlines[i]->getSamplePointThicknesses(true);
                for (int j=0; j < points.size(); j++) {
                        p = (
                                vec3(points[j][0] / (float)textureWidth, 
                                points[j][1] / (float)textureHeight)
                                - vec3(0.5, 0.5)) * 2.f;
                        glVertex2f(p[0] * w, p[1] * h);

                        glEnd();
                        glLineWidth(line_width * thicknessess[j]);
                        glBegin(GL_LINES);

                        glVertex2f(p[0] * w, p[1] * h);
                }
                glEnd();
        }
        glLineWidth(1.f);

        glEndList();
}

void RenderWidget::generateGlyphStreamlineList()
{
        float factor = (float)textureSize/100.f;
        int step = (int)(5.f * factor);

        float aspect = (float)textureWidth/(float)textureHeight;

        float w = (aspect > 1.f) ? 1.f : aspect;
        float h = (aspect > 1.f) ? 1.f/aspect : 1.f;

        if (0 != disp_lists[1])
                glDeleteLists(disp_lists[1], 1);
        disp_lists[1] = glGenLists(1);

        glNewList(disp_lists[1], GL_COMPILE);

        for (int i=0; i < streamlines.size(); i++) {
                glBegin(GL_POINTS);
                vec3 p = (
                        vec3(streamlines[i]->getSeedPoint()[0] / (float)textureWidth, 
                        streamlines[i]->getSeedPoint()[1] / (float)textureHeight)
                        - vec3(0.5, 0.5)
                        ) * 2.f;
                glVertex2f(p[0] * w, p[1] * h);

                vector<vec3> points = streamlines[i]->getSamplePoints(false);
                for (int j=0; j < points.size(); j += step) {
                        p = (
                                vec3(points[j][0] / (float)textureWidth, 
                                points[j][1] / (float)textureHeight)
                                - vec3(0.5, 0.5)) * 2.f;
                        glVertex2f(p[0] * w, p[1] * h);
                }

                points = streamlines[i]->getSamplePoints(true);
                for (int j=0; j < points.size(); j += step) {
                        p = (
                                vec3(points[j][0] / (float)textureWidth, 
                                points[j][1] / (float)textureHeight)
                                - vec3(0.5, 0.5)) * 2.f;
                        glVertex2f(p[0] * w, p[1] * h);
                }
                glEnd();
        }

        glEndList();
}

void RenderWidget::generateTextureStreamlineList()
{
        float aspect = (float)textureWidth/(float)textureHeight;

        float w = (aspect > 1.f) ? 1.f : aspect;
        float h = (aspect > 1.f) ? 1.f/aspect : 1.f;

        if (0 != disp_lists[1])
                glDeleteLists(disp_lists[1], 1);
        disp_lists[1] = glGenLists(1);

        glNewList(disp_lists[1], GL_COMPILE);

        for (int i=0; i < streamlines.size(); i++) {
                int rank = 0;
                vec3 p;
                float intensity = 1.f;

                glBegin(GL_LINE_STRIP);
                vector<vec3> points = streamlines[i]->getSamplePoints(true);
                for (int j = points.size() - 1; j >= 0; j--) {
                        p = (
                                vec3(points[j][0] / (float)textureWidth, 
                                points[j][1] / (float)textureHeight)
                                - vec3(0.5, 0.5)) * 2.f;
                        intensity = getSLIntensityForRank(rank, 1);
                        glColor3f(intensity, intensity, intensity);
                        glVertex2f(p[0] * w, p[1] * h);
                        rank++;
                }

                p = (
                        vec3(streamlines[i]->getSeedPoint()[0] / (float)textureWidth, 
                        streamlines[i]->getSeedPoint()[1] / (float)textureHeight)
                        - vec3(0.5, 0.5)
                        ) * 2.f;
                intensity = getSLIntensityForRank(rank, 1);
                glColor3f(intensity, intensity, intensity);
                glVertex2f(p[0] * w, p[1] * h);
                rank++;

                points = streamlines[i]->getSamplePoints(false);
                for (int j=0; j < points.size(); j++) {
                        p = (
                                vec3(points[j][0] / (float)textureWidth, 
                                points[j][1] / (float)textureHeight)
                                - vec3(0.5, 0.5)) * 2.f;
                        intensity = getSLIntensityForRank(rank, 1);
                        glColor3f(intensity, intensity, intensity);
                        glVertex2f(p[0] * w, p[1] * h);
                        rank++;
                }
                glEnd();
        }

        glEndList();
}

float RenderWidget::getSLIntensityForRank(int rank, int function_type)
{
        switch (function_type) {
        case 0:
                return (1.f + sin(2.f * PI * (float)rank / (float)sl_num_samples) ) / 2.f;
        case 1:
                return (float)(rank % sl_num_samples) / (float)(sl_num_samples - 1);
        }
        return 0.f;
}

void RenderWidget::resizeGL(int w, int h)
{
        glViewport(0,0,w,h);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        glOrtho(-1,1,-1,1,1,100);
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
}

void RenderWidget::paintGL()
{
        glClear(GL_COLOR_BUFFER_BIT);
        //glEnable(GL_TEXTURE);
        glEnable(GL_TEXTURE_2D);
        glLoadIdentity();
        gluLookAt(0, 0, 10, 0, 0, 0, 0, 1, 0);

        for(int i=0; i< layers.count(); i++)
                layers[i]->draw(textures, shaders, disp_lists,(float)textureWidth/(float)textureHeight, 
                                                streamline_mode == GLYPH, streamline_mode == TEXTURE);
}

void RenderWidget::initGlew()
{
        // Initialize GLEW
        std::cout << "- Initializing GLEW ..." << std::endl;
         GLenum err = glewInit();
        if (err != GLEW_OK)
        {
                // glewInit failed, something is seriously wrong
                std::cerr << "Error initializing GLEW: " << glewGetErrorString(err) << std::endl;
        } 
        
        std::cout << "- GLEW initialized." << std::endl << std::endl;

}

int RenderWidget::heightForWidth(int w) const
{
        return w;
}

void RenderWidget::layerChannelChanged(int channel, int layer)
{
        
        if(layer < layers.count())
                layers[layer]->setChannel((channel == -1)?channel:channel+2);

        updateGL();
}

void RenderWidget::layerTypeChanged(int type, int layer)
{
        if(layer < layers.count())
                layers[layer]->setType(type);
        updateGL();

}

void RenderWidget::layerTransferImageChanged(const QImage& image, int layer)
{
        if(layer < layers.count())
                layers[layer]->setTransferFunction(image);

        updateGL();
}

void RenderWidget::layerAdd(int layer)  
{
        layers.append(new LayerRenderable());
        
        updateGL();
}

void RenderWidget::layerMove(int layer, int newPos) //checks done in gui.but...
{
        LayerRenderable* l = layers[layer];
        
        layers.remove(layer);
        layers.insert(newPos,l);
        
        updateGL();
}

void RenderWidget::layerRemove(int layer) //checks done in gui.but...
{
        LayerRenderable* l = layers[layer];
        layers.remove(layer);
        delete l;

        updateGL();
}

void RenderWidget::settingsSliderChanged(int value, int slider)
{
        //std::cout << "Slider "<<slider <<" changed to "<<value << std::endl;

        //Reihenfolge wie im GUI
        switch(slider)
        {
        case 0:         //Arrows Count
                glDeleteLists(disp_lists[0], 1);
                arrowCount = value/2+10;
                initArrows(arrowCount,(float)textureWidth/(float)textureHeight);
                break;

        case 1:         //Arrows Size
                shaders[SHADER_ARROWS]->bind();
                arrowSize = (float)value/25.f+0.5f;
                glUniform1f(shaders[SHADER_ARROWS]->get_uniform_location("size"),arrowSize);
                shaders[SHADER_ARROWS]->unbind();
                break;

        case 2:         //Texture Resolution
                textureSize = 100+value*10;
                break;

        case 3:         //Streamlines dsep
                d_sep_val = min((float)value / 10.f + 0.1, 10) / 100.f;
                break;

        case 4:         //Streamlines dtest
                d_test_val = min((float)value / 100.f + 0.05, 0.95);
                break;

        case 5:         //Streamlines dt
                dt = min((float)value / 100.f + 0.05, 1);
                break;
        }

        updateGL();
}

void RenderWidget::settingsEmitSliderValue(int slider)
{
        std::cout << "Renderer emit slider " << slider << std::endl;
        switch(slider)
        {
        case 0:
                emit emitSettingValues((arrowCount-10)*2,0);
                break;
                
        case 1:
                emit emitSettingValues((int)((arrowSize-0.5f)*25.f),1);
                break;

        case 2:
                emit emitSettingValues((int)( ((float)textureSize - 100.0) / 10.0 ),2);
                break;

        case 3:         //Streamlines dsep
                emit emitSettingValues(min((int)(d_sep_val * 1000), 100), slider);
                break;

        case 4:         //Streamlines dtest
                emit emitSettingValues((int)min((d_test_val - 0.05f) * 1000.f / 9.f, 100), slider);
                break;

        case 5:         //Streamlines dt
                emit emitSettingValues((int)min((dt - 0.05f) * 10000.f / 95.f, 100), slider);
                break;
        }
}

void RenderWidget::settingsSLModeChanged(int value)
{
        std::cout << "SLMode changed to "<< value << std::endl;

        switch(value)
        {
        case 0:         //standard
                streamline_mode = NORMAL;
                generateNormalStreamlineList();
                break;

        case 1:         //tapering
                streamline_mode = TAPERING;
                generateTaperingStreamlineList();
                break;

        case 2:         //glyph
                streamline_mode = GLYPH;
                generateGlyphStreamlineList();
                break;
        case 3:         //texture
                streamline_mode = TEXTURE;
                generateTextureStreamlineList();
                break;
        }

        updateGL();
}


void RenderWidget::settingsSLCompute()
{
        std::cout << "SLCompute clicked" << std::endl;

        computeStreamlines();

        updateGL();
}

void RenderWidget::settingsSLInverpolationChanged(int value)
{
        std::cout << "SLInterpolation changed to " << value << std::endl;

        switch (value) {
        case 0:
                integration_mode = EULER;
                break;
        case 1:
                integration_mode = RK2;
                break;
        case 2:
                integration_mode = RK4;
                break;
        }

        computeStreamlines();

        updateGL();
}

void RenderWidget::loadDataFile() {
        QString fileName = QFileDialog::getOpenFileName(this, tr("Open Input File"), ".", tr("Data Files (*.dat)"));

        fileName.remove(".dat");                //.dat wegmachen

        loadData(fileName.toStdString());
        
        updateGL();
}