Eigene Dateien/FlowVis/src/VFlowData.cpp

Go to the documentation of this file.

#include "VFlowData.h"
#include "glew.h"
#include <time.h>
#include <deque>


#define MINNUMBER 5.0f
#define MAXNUMBER 100.0f
#define MAXSTEPS 4 * 4096

VFlowData::VFlowData() : 
mVertexVbo( 0 ), 
mIndexVbo( 0 ),
mGlyphIndexVbo( 0 ), 
mTexturesGenerated( false ), 
mStreamlinesDt( 0.5f ),
mStreamlinesTestSeparation( 0.2f ),
mStreamlinesSeedSeparation( 0.5f ),
mStreamlinesSteps( 0.5f ),      
mEuler( 1.0f )  ,
mNumStreamlines( 0 ),
mTapering( false ),
mTaperingScale( 0.5f ),
mActiveTimeStep( 0 ),
mIconScale( 0.5f ),
mTailLength( 0.5f ),
mStrGlyphes(false)
{

        maxDataValues.push_back( 0.0f );
        minDataValues.push_back( 0.0f );
        mSeedPlacing = LEFT;
}

VFlowData::~VFlowData()
{
        clear();
}

VFlowData::VFlowData( std::string m_FileName ) : mVertexVbo( 0 ), mIndexVbo( 0 )
{
        loadData( m_FileName );
        mSeedPlacing = LEFT;
}

bool VFlowData::loadData( std::string m_FileName )
{
        maxDataValues.clear();
        minDataValues.clear();
        maxDataValues.push_back( 0.0f );
        minDataValues.push_back( 0.0f );

        int pointpos = ( int )m_FileName.find_last_of('.');
        
        std::string gridpath = m_FileName.substr( 0, pointpos ) + ".gri";

        if( !readGrid( gridpath ) )
        {
                return false;
        }

        std::cout << "loading "  << mHeader.mNT << " timesteps" << std::endl;
        
        for( int i = 0; i < mHeader.mNF; ++i )
        {
                maxDataValues.push_back( 0.0f );
                minDataValues.push_back( 0.0f );
        }

        for( int i = 0; i < mHeader.mNT; ++i )
        {
                std::string datfile;

                if( mHeader.mNT > 1 )
                {
                        std::string fullnumber;
                        int tmp = 100000 + i;
                        std::stringstream ss;
                        ss << tmp;
                        std::string tmpstr;
                        tmpstr = ss.str();
                        fullnumber = tmpstr.substr( 1,5 );
                        datfile = m_FileName.substr( 0, pointpos ) + "." + fullnumber + ".dat";
                }
                else
                {
                        datfile = m_FileName.substr( 0, pointpos ) + ".dat";
                }

                if( !readDat( datfile ) )
                {
                        return false;
                }
                std::cout << "\rtimestep " << i << " loaded!";
        }

        std::cout << std::endl;

        generateVBO();

        return true;
}

bool VFlowData::loadData( std::string m_FileName, std::string m_DatFilename)
{
        maxDataValues.clear();
        minDataValues.clear();
        maxDataValues.push_back( 0.0f );
        minDataValues.push_back( 0.0f );

        int pointpos = ( int )m_FileName.find_last_of('.');

        std::string gridpath = m_FileName.substr( 0, pointpos ) + ".gri";

        if( !readGrid( gridpath ) )
        {
                return false;
        }

        std::cout << "loading 1 timesteps" << std::endl;

        for( int i = 0; i < mHeader.mNF; ++i )
        {
                maxDataValues.push_back( 0.0f );
                minDataValues.push_back( 0.0f );
        }

                std::string datfile;
        mHeader.mNT = 1;


        if( !readDat( m_DatFilename ) )
        {
                return false;
        }
        std::cout << "\rtimestep 1 loaded!";


        std::cout << std::endl;

        generateVBO();

        return true;
}


bool VFlowData::readGrid( std::string m_FileName )
{

        FILE * gridfile;
        
        fopen_s( &gridfile, m_FileName.c_str(), "rb" );

        if( !gridfile )
        {
                return false;
        }

        char buf[40];
        fread( buf, sizeof(char),40, gridfile );
        
        sscanf_s( buf,"SN4DB %d %d %d %d %d %f",&mHeader.mSX,&mHeader.mSY,&mHeader.mSZ,&mHeader.mNF,&mHeader.mNT,&mHeader.mDT );
        
        if( mHeader.mSZ > 1 )
        {
                return false;
        }

        std::vector<float> input;
        int numValues = mHeader.mSX * mHeader.mSY * 3;

        input.resize( numValues );

        unsigned int rb = (unsigned int)fread( reinterpret_cast<char*>( &input[0] ), sizeof( float ), numValues, gridfile );

        int eo = feof(gridfile);
        int er = ferror(gridfile);

        

        for( int i = 0; i < numValues; i +=3 )
        {
                VVector tmp( -input[i], -input[i + 1], input[i + 2]);

                mVertexGrid.push_back( tmp );
        }

        mMinPos = mVertexGrid.front();
        mMaxPos = mVertexGrid.back();

        bool switchx = false;
        bool switchy = false;

        if((mMinPos.getX() > mMaxPos.getX()))
        {
                float tmp = mMinPos.getX();
                mMinPos.setX(mMaxPos.getX());
                mMaxPos.setX(tmp);
                switchx = true;
        }
        if((mMinPos.getY() > mMaxPos.getY()))
        {
                float tmp = mMinPos.getY();
                mMinPos.setY(mMaxPos.getY());
                mMaxPos.setY(tmp);
                switchy = true;
        }
        mExtends = mMaxPos - mMinPos;
        mCenterPos = mMinPos + mExtends/ 2.0f;

        float minxdistance = ( switchx ) ? abs( mVertexGrid[1].getX() - mVertexGrid[0].getX() ) : abs( mVertexGrid[0].getX() - mVertexGrid[1].getX() );
        float minydistance = ( switchy ) ? abs( mVertexGrid[mHeader.mSX].getY() - mVertexGrid[0].getY() ) : abs( mVertexGrid[0].getY() - mVertexGrid[mHeader.mSX].getY() );

        for( int i = 0; i < ( mHeader.mSX * ( mHeader.mSY - 1)  ); ++i )
        {
                if( (i != 0 ) && ((i + 1) % (mHeader.mSX)) == 0 )
                {
                        continue;
                }
                //QUAD Version
                /*mIndexGrid.push_back( i );
                mIndexGrid.push_back( i + mHeader.mSX );
                mIndexGrid.push_back( i + mHeader.mSX + 1 );
                mIndexGrid.push_back( i + 1 );*/
                
                //Triangle 1
                mIndexGrid.push_back( i );
                mIndexGrid.push_back( i + mHeader.mSX );
                mIndexGrid.push_back( i + 1 );

                //Triangle 2
                mIndexGrid.push_back( i + mHeader.mSX );
                mIndexGrid.push_back( i + mHeader.mSX + 1 );
                mIndexGrid.push_back( i + 1 );

                float tmpxdistance = ( switchx ) ? abs( mVertexGrid[i+1].getX() - mVertexGrid[i].getX() ) : abs( mVertexGrid[i].getX() - mVertexGrid[i+1].getX() );
                float tmpydistance = ( switchy ) ? abs( mVertexGrid[i+mHeader.mSX].getY() - mVertexGrid[i].getY() ) : abs( mVertexGrid[i].getY() - mVertexGrid[i+mHeader.mSX].getY() );

                if(tmpxdistance < minxdistance) minxdistance = tmpxdistance;
                if(tmpydistance < minydistance) minydistance = tmpydistance;
        }

        mMinDistance = VVector(minxdistance, minydistance, 0.0f);

        mReverseX = switchx;
        mReverseY = switchy;

        fclose(gridfile);       

        mVertexToTexture.clearMatrix();

        VVector scale(/*((mReverseX)?(-1.0f) : (1.0f)) * */-2.0f / mExtends.getX(), /*((mReverseY)?(-1.0f) : (1.0f)) * */2.0f / mExtends.getY(), 1.0f );

        mVertexToTexture.scale(scale);
        mVertexToTexture.translate(-mCenterPos);

        mTextureToVertex = mVertexToTexture.getInverse();

        return true;
}

bool VFlowData::readDat( std::string m_FileName )
{
        FILE * datfile;

        fopen_s( &datfile, m_FileName.c_str(), "rb" );

        if( !datfile )
        {
                return false;
        }

        std::vector<float> input;
        input.resize( ( 3 + mHeader.mNF ) * mHeader.mSX * mHeader.mSY );
        
        fread( reinterpret_cast<char*>( &input[0] ), sizeof( float ), ( 3 + mHeader.mNF ) * mHeader.mSX * mHeader.mSY, datfile );

        fclose(datfile);

        vTimeStep newStep;
        int numTriplets = 1;
        double d = ( ( float ) mHeader.mNF / 3.0f );
        int numAddTriplet = ( int ) ( d < 0 ? d - 0.5 : d + 0.5 );
        numTriplets += numAddTriplet;
        
        mNumTriplets = (float)numTriplets;

        /*std::vector<float> tmp;
        tmp.resize(input.size());
        int linefloats = ( mHeader.mSX * ( 3 + mHeader.mNF ) );
        for( int i = 0; i < mHeader.mSY; ++i )
        {
                int index = i;
                int reverseIndex = mHeader.mSY - i - 1; 
                for ( int j = 0; j < linefloats; ++j )
                {
                        tmp[reverseIndex * linefloats + j] = input[index * linefloats + j];
                }
        }

        input = tmp;
        */

        newStep.mTimeData.resize( numTriplets );

        for ( int i = 0; i < ( 3 + mHeader.mNF ) * mHeader.mSX * mHeader.mSY; i += ( 3 + mHeader.mNF ) )
        {
                //int signx = ( input[ i + 1 ] < 0.0 ) ? 0.0 : 1.0;
                VVector velocity( -input[i], -input[i + 1], input[i + 2] );
                newStep.mTimeData[0].mSet.push_back( velocity );

                float magnitude = sqrt( velocity.getX() * velocity.getX() + velocity.getY() * velocity.getY() + velocity.getZ() * velocity.getZ() );
                //magnitude = velocity.getY();

                if( maxDataValues[ 0 ] < magnitude )
                {
                        maxDataValues[ 0 ] = magnitude;
                }

                if( minDataValues[ 0 ] > magnitude )
                {
                        minDataValues[ 0 ] = magnitude;
                }


                for ( int j = 0; j < numAddTriplet; ++j )
                {
                        VVector addData;
                        if ( j == numAddTriplet - 1)
                        {
                                if ( (mHeader.mNF - j * 3) == 1)
                                {
                                        addData = VVector( input[i + (3 * (j + 1))], 0.0f, 0.0f );
                                }
                                else if ( (mHeader.mNF - j * 3) == 2)
                                {
                                        addData = VVector( input[i + (3 * (j + 1))], input[i + (3 * (j + 1) + 1)], 0.0f );
                                }
                                else if ( (mHeader.mNF - j * 3) == 3)
                                {
                                        addData = VVector( input[i + (3 * (j + 1))], input[i + (3 * (j + 1) + 1)], input[i + (3 * (j + 1) + 2)] );
                                }
                        }
                        else
                        {
                                addData = VVector( input[i + (3 * (j + 1))], input[i + (3 * (j + 1) + 1)], input[i + (3 * (j + 1) + 2)] );
                        }

                        newStep.mTimeData[ j + 1 ].mSet.push_back( addData );

                        if ( j == 0  )
                        {
/*pressure*/    
                                
                                float datavalue1 = addData.getX();

                                if( maxDataValues[ 1 ] < datavalue1 )
                                {
                                        maxDataValues[ 1 ] = datavalue1;
                                }

                                if( minDataValues[ 1 ] > datavalue1 )
                                {
                                        minDataValues[ 1 ] = datavalue1;
                                }
                        
/*vorticity,humidity*/ 
                                if ( mHeader.mNF > 1 )
                                {
                        
                                        float datavalue2 = addData.getY();

                                        if( maxDataValues[ 2 ] < datavalue2 )
                                        {
                                                maxDataValues[ 2 ] = datavalue2;
                                        }

                                        if( minDataValues[ 2 ] > datavalue2 )
                                        {
                                                minDataValues[ 2 ] = datavalue2;
                                        }

                                }
                        }
                }
        }

        mTimeSteps.push_back(newStep);
        return true;
}

void VFlowData::draw(int m_TimeStep /* = 0  */)
{
        activateVBO(m_TimeStep);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIndexVbo);
        //glPolygonMode(GL_FRONT, GL_LINE);
        glDrawElements(GL_TRIANGLES, (int) mIndexGrid.size(), GL_UNSIGNED_INT, 0);
        deactivateVBO();
}

void VFlowData::drawPoints(int m_TimeStep /* = 0  */)
{
        activateVBO(m_TimeStep);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mGlyphIndexVbo);
        //glPolygonMode(GL_FRONT, GL_LINE);
        glDrawElements(GL_POINTS, (int) mGlyphIndexGrid.size(), GL_UNSIGNED_INT, 0);
        deactivateVBO();
}

void VFlowData::drawStreamLines( VVector  *col )
{
        //on default white
        glColor4f( col->getX(), col->getY(), col->getZ(), 1.0f );

        for ( int i = 0; i < mNumStreamlines; i ++ )
        {
                //glColor4f( (float)i / (float)mNumStreamlines , ( (float)mNumStreamlines - (float)i ) / (float)mNumStreamlines, 0.0f, 1.0f );
                streamlines[ i ].draw( mTapering, mTaperingScale, mStrGlyphes );
        }
        
}

void VFlowData::drawIcons()
{
        for( int i = 0; i < (int)mIcons.size(); ++i )
        {
                mIcons[i].draw();
        }
}

void VFlowData::addIconPoint( float x, float y )
{
        // convert x and y from worlds space to texture space, if out, discard it

        float dataextent_x, dataextent_y;
        float minx, miny;

        dataextent_x = mExtends.getX();
        dataextent_y = mExtends.getY();
        minx = mMinPos.getX();
        miny = mMinPos.getY();


        VVector newpos_tex = VVector();
        newpos_tex.setX( ( x - minx ) / dataextent_x );
        newpos_tex.setY( ( y - miny ) / dataextent_y );

        if(             ( newpos_tex.getX() ) > 1.0f || ( newpos_tex.getY() ) > 1.0f 
                ||      ( newpos_tex.getX() ) < 0.0f || ( newpos_tex.getY() ) < 0.0f )
        {
                //the point is out of data
                return;
        }
        else
        {

                //TODO
                float data[ 4 ];
                data[ 0 ] = dataextent_x;
                data[ 1 ] = dataextent_y;
                data[ 2 ] = minx;
                data[ 3 ] = miny;

                mIcons.push_back( VIcon(newpos_tex, data ));
                mIcons.back().computeIcon( &mTimeSteps[0], mActiveTimeStep );
        }
}

void VFlowData::drawTextureTest( int m_TimeStep /* = 0  */ )
{
        if( m_TimeStep > ( ( int )mTimeSteps.size(  ) - 1) )
        {
                m_TimeStep = ( ( int )mTimeSteps.size(  ) - 1 );
        }
        mTimeSteps[m_TimeStep].mFrameBufferObject->renderToLowerLeftQuad();
}

void VFlowData::generateGlyphIndices( int m_NumX, int m_NumY )
{
        mGlyphIndexGrid.clear();

        float glyphspacex = mExtends.getX() / (float)( m_NumX + 1 );
        float glyphspacey = mExtends.getY() / (float)( m_NumY + 1 );

        float curX = mVertexGrid[0].getX();
        float curY = mVertexGrid[0].getY();

        if((mVertexGrid[0].getY()) == (mVertexGrid[mHeader.mSX].getY()))
        {
                for( int i = 0; i < mHeader.mSX; ++i )
                {
                        float distancex = ( mReverseX ) ? ( curX - mVertexGrid[i * mHeader.mSY].getX() ) : ( mVertexGrid[i * mHeader.mSY].getX() - curX );
                        if(distancex < glyphspacex)
                        {
                                continue;
                        }
                        else
                        {
                                for( int j = 0; j < mHeader.mSY - 1; ++j )
                                {
                                        float distancey = ( mReverseY ) ? ( curY - mVertexGrid[i * mHeader.mSY + j].getY() ) : ( mVertexGrid[i * mHeader.mSY + j].getY() - curY );
                                        if(distancey < glyphspacey)
                                        {
                                                continue;
                                        }
                                        else
                                        {
                                                mGlyphIndexGrid.push_back( i * mHeader.mSY + j );
                                                curY = mVertexGrid[i * mHeader.mSY + j].getY();
                                        }
                                }
                                curX = mVertexGrid[i * mHeader.mSY].getX();
                                curY = mVertexGrid[0].getY();
                        }
                }
        }
        else
        {
                for( int i = 0; i < mHeader.mSY; ++i )
                {
                        float distancey = ( mReverseY ) ? ( curY - mVertexGrid[i * mHeader.mSX].getY() ) : ( mVertexGrid[i * mHeader.mSX].getY() - curY );
                        if(distancey < glyphspacey)
                        {
                                continue;
                        }
                        else
                        {
                                for( int j = 0; j < mHeader.mSX - 1; ++j )
                                {
                                        float distancex = ( mReverseX ) ? ( curX - mVertexGrid[i * mHeader.mSX + j].getX() ) : ( mVertexGrid[i * mHeader.mSX + j].getX() - curX );
                                        if(distancex < glyphspacex)
                                        {
                                                continue;
                                        }
                                        else
                                        {
                                                mGlyphIndexGrid.push_back( i * mHeader.mSX + j );
                                                curX = mVertexGrid[i * mHeader.mSX + j].getX();
                                        }
                                }
                                curY = mVertexGrid[i * mHeader.mSX].getY();
                                curX = mVertexGrid[0].getX();
                        }
                }
        }

        if(mGlyphIndexVbo == 0)
        {
                glGenBuffersARB( 1, &(mGlyphIndexVbo) );
        }
        else
        {
                glDeleteBuffers( 1, &(mGlyphIndexVbo) );
                glGenBuffersARB( 1, &(mGlyphIndexVbo) );
        }

        glBindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, mGlyphIndexVbo );
        glBufferDataARB( GL_ELEMENT_ARRAY_BUFFER_ARB, sizeof(int) * (int)mGlyphIndexGrid.size(), &(mGlyphIndexGrid[0]), GL_STATIC_DRAW_ARB );
        glBindBufferARB( GL_ELEMENT_ARRAY_BUFFER, 0 );

}

void VFlowData::generateTextures()
{
        if(!mRenderTextureProgram)
        {
                mRenderTextureProgram = new VProgram(VVertexShader("shader/texture_vertex.glsl"), VFragmentShader("shader/texture_fragment.glsl"));
        }

        mRenderTextureProgram->bind();

        glUniformMatrix4fv(mRenderTextureProgram->getUniformLocation("mVertexToTexture"),1,false, &mVertexToTexture[0]);

        std::cout << "generating " << (int)mTimeSteps.size() << " textures!" << std::endl;

        for ( int i = 0; i < (int)mTimeSteps.size(); ++i )
        {
                if(!mTimeSteps[i].mFrameBufferObject)
                {
                        mTimeSteps[i].mFrameBufferObject = new VFramebufferObject(1024, 1024, GL_RGBA16F_ARB);
                        mTimeSteps[i].mFrameBufferObject->init();
                }

                mTimeSteps[i].mFrameBufferObject->bind();

                this->draw(i);          

                mTimeSteps[i].mFrameBufferObject->unbind();

                GLenum glError = glGetError();

                if (glError != GL_NO_ERROR)
                        std::cout << "Error rendering to TimeStep " << i << " " << gluErrorString(glError) << std::endl;

                std::cout << "\rtexture " << i << " generated!";
        }

        std::cout << std::endl;

        mRenderTextureProgram->release();

        mTexturesGenerated = true;

}

//void VFlowData::addManualSeedpointWithDsepTest( float m_TimeStep, float m_MaxSteps  )
//{
//
//      // convert x and y from worlds space to texture space, if out, discard it
//
//      float dataextent_x, dataextent_y;
//      float minx, miny;
//
//      dataextent_x = mExtends.getX();
//      dataextent_y = mExtends.getY();
//      minx = mMinPos.getX();
//      miny = mMinPos.getY();
//
//
//      //VVector newpos_tex = VVector();
//      //newpos_tex.setX( ( x - minx ) / dataextent_x );
//      //newpos_tex.setY( ( y - miny ) / dataextent_y );
//
//      //if(           ( newpos_tex.getX() ) > 1.0f || ( newpos_tex.getY() ) > 1.0f 
//      //      ||      ( newpos_tex.getX() ) < 0.0f || ( newpos_tex.getY() ) < 0.0f )
//      //{
//      //      //the point is out of data
//      //      return;
//      //}
//      //else
//      //{
//
//      srand( time( NULL ) );
//
//      VVector start( minx + dataextent_x * 0.5f, miny + dataextent_y * 0.5f, 0.0f );
//      mEvenlySeedpoints.push_back( start );
//      drawEvenlySpacedStreamlines( m_TimeStep, m_MaxSteps );
//
//      for ( int i = 0; i < 20; i++ )
//      {
//      
//              float r1 = (float)( rand() % (int)dataextent_x ) + minx + (float)( rand() % 10000 ) / 10000.0f;
//              float r2 = (float)( rand() % (int)dataextent_y ) + miny + (float)( rand() % 10000 ) / 10000.0f;
//
//      
//              //check
//              int cardstr = mEvenlySeedpoints.size();
//              bool streamline_allowed = false;
//
//              for( int i = 0; i < cardstr; i++)
//              {
//                      float dsepworld =  0.25f * mStreamlinesSeedSeparation * min( dataextent_x, dataextent_y );
//                      streamline_allowed = streamlines[ i ].isPointAllowed( VVector( r1 , r2, 0.0f ), dsepworld );
//
//                      if( !streamline_allowed )
//                      {
//                              break;
//                      }
//                      
//              }
//
//              mEvenlySeedpoints.push_back( VVector( r1 , r2, 0.0f ) );
//              drawEvenlySpacedStreamlines( m_TimeStep, m_MaxSteps );
//              
//      
//      }
//              
//      
//
//      //}
//
//}

//x and y are in world space
void VFlowData::addManualSeedpoint( float x, float y )
{

        // convert x and y from worlds space to texture space, if out, discard it

        float dataextent_x, dataextent_y;
        float minx, miny;

        dataextent_x = mExtends.getX();
        dataextent_y = mExtends.getY();
        minx = mMinPos.getX();
        miny = mMinPos.getY();


        VVector newpos_tex = VVector();
        newpos_tex.setX( ( x - minx ) / dataextent_x );
        newpos_tex.setY( ( y - miny ) / dataextent_y );

        if(             ( newpos_tex.getX() ) > 1.0f || ( newpos_tex.getY() ) > 1.0f 
                ||      ( newpos_tex.getX() ) < 0.0f || ( newpos_tex.getY() ) < 0.0f )
        {
                //the point is out of data
                return;
        }
        else
        {
                
                mManualSeedpoints.push_back( newpos_tex );
        }

}


//void VFlowData::drawEvenlySpacedStreamlines( float m_TimeStep, float m_MaxSteps  )
//{
//
//      if( mNumStreamlines != 0 )
//      {
//              if ( streamlines )
//              {
//                      delete[] streamlines;
//                      streamlines = NULL;
//                      mNumStreamlines = 0;
//              }
//      }
//      //float *pixeldata; // velocoty texture
//      std::vector< float > pixeldata;
//
//      int texsize_x, texsize_y;
//
//      float dataextent_x, dataextent_y;
//      float datacenter_x, datacenter_y;
//      float minx, miny;
//
//      dataextent_x = mExtends.getX();
//      dataextent_y = mExtends.getY();
//      datacenter_x = mCenterPos.getX();
//      datacenter_y = mCenterPos.getY();
//      minx = mMinPos.getX();
//      miny = mMinPos.getY();
//
//      //float keepratiox = ( dataextent_x > dataextent_y ) ? 1.0f  : dataextent_x / dataextent_y;
//      //float keepratioy = ( dataextent_y > dataextent_x ) ? 1.0f  : dataextent_y / dataextent_x;
//
//      // generate seedpoints in texture coordinates
//      float numbersteamlines = mEvenlySeedpoints.size();
//
//      pixeldata = mTimeSteps[m_TimeStep].getFullFBODataVector();
//      texsize_x = mTimeSteps[m_TimeStep].mFrameBufferObject->getWidth();
//      texsize_y = mTimeSteps[m_TimeStep].mFrameBufferObject->getHeight();
//
//      int size = (int)pixeldata.size();
//
//      
//      // for all streamlines
//      mNumStreamlines = numbersteamlines;
//      streamlines = new VStreamLine[ (int)numbersteamlines + 1 ];
//
//      for ( int j = 0; j < numbersteamlines; j++ )
//      {
//
//              std::vector< VVector > streamlinevertices;
//              std::vector< float > vertexthickness;
//              
//              bool outofdata = false;
//              bool dtestfail = false;
//
//              VVector start_world = VVector( mEvenlySeedpoints[ j ] );
//
//              float sactualpoint_x = ( start_world.getX() - minx ) / dataextent_x;
//              float sactualpoint_y = ( start_world.getY() - miny ) / dataextent_y;
//
//              for ( int i = 0; i < MAXSTEPS * m_MaxSteps ; i++)
//              {
//                      if ( outofdata ) break;
//                      if ( dtestfail ) break;
//
//                      // transform texture coordinates sactualpint_x and sactualpoint_y into world coords
//                      VVector arrayindex = VVector( texsize_x * sactualpoint_x, texsize_y * sactualpoint_y, 0.0f );
//                      int xfloor = (int) ( arrayindex.getX() - 0.5f ) - 1;
//                      int yfloor = (int) ( arrayindex.getY() - 0.5f ) - 1;
//                      int xceil  = (int) ( arrayindex.getX() + 0.5f ) - 1;
//                      int yceil  = (int) ( arrayindex.getY() + 0.5f ) - 1;
//
//                      if ( xfloor < 0 || yfloor < 0 || xceil >= texsize_x || yceil >= texsize_x )
//                      {
//                              // we have reached the border;
//                              outofdata = true;
//                              break;
//                      }
//                      //fetch velocity at the actual position in world coordinates
//                      
//                      //floorx floorz
//                      float velocity_x_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4     ];
//                      float velocity_y_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 1 ];
//                      float velocity_z_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 2 ];
//                                                              
//                      //floorx ceil           
//                      float velocity_x_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4      ];
//                      float velocity_y_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 1  ];
//                      float velocity_z_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 2  ];
//                                                                                 
//                      //floorx floorz                            
//                      float velocity_x_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4      ];
//                      float velocity_y_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 1  ];
//                      float velocity_z_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 2  ];
//                                                              
//                      //floorx floorz         
//                      float velocity_x_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4      ];
//                      float velocity_y_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 1  ];
//                      float velocity_z_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 2  ];
//
//                      float interpolval_x_L = ( arrayindex.getX() - xfloor ) * velocity_x_cf + ( xceil - arrayindex.getX() ) * velocity_x_ff;
//                      float interpolval_y_L = ( arrayindex.getX() - xfloor ) * velocity_y_cf + ( xceil - arrayindex.getX() ) * velocity_y_ff;
//                      float interpolval_z_L = ( arrayindex.getX() - xfloor ) * velocity_z_cf + ( xceil - arrayindex.getX() ) * velocity_z_ff;
//
//                      float interpolval_x_H = ( arrayindex.getX() - xfloor ) * velocity_x_cc + ( xceil - arrayindex.getX() ) * velocity_x_fc;
//                      float interpolval_y_H = ( arrayindex.getX() - xfloor ) * velocity_y_cc + ( xceil - arrayindex.getX() ) * velocity_y_fc;
//                      float interpolval_z_H = ( arrayindex.getX() - xfloor ) * velocity_z_cc + ( xceil - arrayindex.getX() ) * velocity_z_fc;
//
//                      float interpolval_x = ( arrayindex.getY() - yfloor ) * interpolval_x_H + ( yceil - arrayindex.getY() ) * interpolval_x_L;
//                      float interpolval_y = ( arrayindex.getY() - yfloor ) * interpolval_y_H + ( yceil - arrayindex.getY() ) * interpolval_y_L;
//                      float interpolval_z = ( arrayindex.getY() - yfloor ) * interpolval_z_H + ( yceil - arrayindex.getY() ) * interpolval_z_L;
//
//                      VVector interpolatedval = VVector( interpolval_x, interpolval_y, interpolval_z );
//                      VVector interp_mult = VVector( interpolatedval );
//                      interp_mult.setX( -interp_mult.getX(  ) );
//                      interp_mult *=  0.5f * mStreamlinesDt;
//
//                      //VVector oldpos_world = mVertexToTexture.homogenTransform( VVector ( sactualpoint_x, sactualpoint_y, 0.0f ) );
//                      VVector oldpos_world = VVector();
//                      oldpos_world.setX( sactualpoint_x * dataextent_x + minx );
//                      oldpos_world.setY( sactualpoint_y * dataextent_y + miny );
//
//                      VVector newpos_world = oldpos_world + interp_mult;
//
//                      VVector newpos_tex = VVector();
//                      newpos_tex.setX( ( newpos_world.getX() - minx ) / dataextent_x );
//                      newpos_tex.setY( ( newpos_world.getY() - miny ) / dataextent_y );
//
//                      if(             ( newpos_tex.getX() ) > 1.0f || ( newpos_tex.getY() ) > 1.0f 
//                              ||      ( newpos_tex.getX() ) < 0.0f || ( newpos_tex.getY() ) < 0.0f )
//                      {
//                              outofdata = true;
//                              break;
//                      }
//                              
//                      sactualpoint_x = newpos_tex.getX();
//                      sactualpoint_y = newpos_tex.getY();
//
//                      //convert to world space
//                      newpos_tex.setX( -( newpos_tex.getX() * dataextent_x ) + minx + dataextent_x);
//                      newpos_tex.setY( ( newpos_tex.getY() * dataextent_y ) + miny );
//
//                      //dtest
//                      int cardstr = mEvenlySeedpoints.size();
//                      bool streamline_allowed = false;
//                      for( int i = 0; i < cardstr - 1 ; i++)
//                      {
//                              float dsepworld =  0.25f * mStreamlinesTestSeparation * min( dataextent_x, dataextent_y );
//                              
//                              streamline_allowed = streamlines[ i ].isPointAllowed( VVector(  newpos_tex.getX() , newpos_tex.getY(), 0.0f ), dsepworld, mdistance );
//
//                              if( !streamline_allowed )
//                              {
//                                      dtestfail = true;
//                                      break;
//                              }
//                      }
//
//                      if ( dtestfail ) break;
//
//                      streamlinevertices.push_back( newpos_tex );
//                      vertexthickness.push_back( mdistance[ 0 ] );
//
//                      float epsilon = 0.0000001f;
//                      VVector posdifference = VVector();
//
//                      if( streamlinevertices.size() > 1 )
//                      {
//                              VVector posdifference = streamlinevertices[ streamlinevertices.size() - 1 ] - streamlinevertices[ streamlinevertices.size() - 2 ];
//                      }
//
//                      if ( posdifference.getMagnitude() < epsilon)
//                      {
//                              outofdata = true;
//                              break;
//                      }
//
//              }
//
//              if( !dtestfail )  // donot continue the streamline
//
//              {
//                      //revert the streamline poitns vector and ocntinue in the opposite direction
//                      if( !streamlinevertices.empty() ) 
//                      {
//                              std::vector< VVector > _streamlinesvertices;
//                              for( int k = 0; k < streamlinevertices.size(); k++)
//                              {
//                                      _streamlinesvertices.push_back( streamlinevertices[ streamlinevertices.size() - k - 1 ] );
//                                      
//                              }
//
//                              streamlinevertices.clear();
//                              streamlinevertices.swap( _streamlinesvertices );
//                              _streamlinesvertices.clear();
//                      }
//                      
//
//                      sactualpoint_x = 1.0 - mEvenlySeedpoints[ j ].getX();
//                      sactualpoint_y = mEvenlySeedpoints[ j ].getY();
//
//                      outofdata = false;
//
//                      //and go to the opposite direction
//                      for ( int i = 0; i <  MAXSTEPS * m_MaxSteps ; i++)
//                      {
//                              if ( outofdata ) break;
//                              if ( dtestfail ) break;
//                              
//                              // transform texture coordinates sactualpint_x and sactualpoint_y into world coords
//                              VVector arrayindex = VVector( texsize_x * sactualpoint_x, texsize_y * sactualpoint_y, 0.0f );
//                              int xfloor = (int) ( arrayindex.getX() - 0.5f ) - 1;
//                              int yfloor = (int) ( arrayindex.getY() - 0.5f ) - 1;
//                              int xceil  = (int) ( arrayindex.getX() + 0.5f ) - 1;
//                              int yceil  = (int) ( arrayindex.getY() + 0.5f ) - 1;
//
//                              if ( xfloor < 0 || yfloor < 0 || xceil >= texsize_x || yceil >= texsize_x )
//                              {
//                                      // we have reached the border;
//                                      outofdata = true;
//                                      break;
//                              }
//                              //fetch velocity at the actual position in world coordinates
//                              
//                              //floorx floorz
//                              float velocity_x_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4     ];
//                              float velocity_y_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 1 ];
//                              float velocity_z_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 2 ];
//                                                                      
//                              //floorx ceil           
//                              float velocity_x_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4      ];
//                              float velocity_y_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 1  ];
//                              float velocity_z_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 2  ];
//                                                                                         
//                              //floorx floorz                            
//                              float velocity_x_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4      ];
//                              float velocity_y_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 1  ];
//                              float velocity_z_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 2  ];
//                                                                      
//                              //floorx floorz         
//                              float velocity_x_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4      ];
//                              float velocity_y_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 1  ];
//                              float velocity_z_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 2  ];
//
//                              float interpolval_x_L = ( arrayindex.getX() - xfloor ) * velocity_x_cf + ( xceil - arrayindex.getX() ) * velocity_x_ff;
//                              float interpolval_y_L = ( arrayindex.getX() - xfloor ) * velocity_y_cf + ( xceil - arrayindex.getX() ) * velocity_y_ff;
//                              float interpolval_z_L = ( arrayindex.getX() - xfloor ) * velocity_z_cf + ( xceil - arrayindex.getX() ) * velocity_z_ff;
//
//                              float interpolval_x_H = ( arrayindex.getX() - xfloor ) * velocity_x_cc + ( xceil - arrayindex.getX() ) * velocity_x_fc;
//                              float interpolval_y_H = ( arrayindex.getX() - xfloor ) * velocity_y_cc + ( xceil - arrayindex.getX() ) * velocity_y_fc;
//                              float interpolval_z_H = ( arrayindex.getX() - xfloor ) * velocity_z_cc + ( xceil - arrayindex.getX() ) * velocity_z_fc;
//
//                              float interpolval_x = ( arrayindex.getY() - yfloor ) * interpolval_x_H + ( yceil - arrayindex.getY() ) * interpolval_x_L;
//                              float interpolval_y = ( arrayindex.getY() - yfloor ) * interpolval_y_H + ( yceil - arrayindex.getY() ) * interpolval_y_L;
//                              float interpolval_z = ( arrayindex.getY() - yfloor ) * interpolval_z_H + ( yceil - arrayindex.getY() ) * interpolval_z_L;
//
//                              VVector interpolatedval = VVector( interpolval_x, interpolval_y, interpolval_z );
//                              VVector interp_mult = VVector( interpolatedval );
//                              interp_mult.setX( -interp_mult.getX(  ) );
//                              interp_mult *=  0.5f *mStreamlinesDt;
//
//                              //VVector oldpos_world = mVertexToTexture.homogenTransform( VVector ( sactualpoint_x, sactualpoint_y, 0.0f ) );
//                              VVector oldpos_world = VVector();
//                              oldpos_world.setX( sactualpoint_x * dataextent_x + minx );
//                              oldpos_world.setY( sactualpoint_y * dataextent_y + miny );
//
//                              VVector newpos_world = oldpos_world - interp_mult;
//
//                              VVector newpos_tex = VVector();
//                              newpos_tex.setX( ( newpos_world.getX() - minx ) / dataextent_x );
//                              newpos_tex.setY( ( newpos_world.getY() - miny ) / dataextent_y );
//
//                              if(             ( newpos_tex.getX() ) > 1.0f || ( newpos_tex.getY() ) > 1.0f 
//                                      ||      ( newpos_tex.getX() ) < 0.0f || ( newpos_tex.getY() ) < 0.0f )
//                              {
//                                      outofdata = true;
//                                      break;
//                              }
//                                      
//                              sactualpoint_x = newpos_tex.getX();
//                              sactualpoint_y = newpos_tex.getY();
//                              
//                              //convert to world space
//                              newpos_tex.setX( -( newpos_tex.getX() * dataextent_x ) + minx + dataextent_x);
//                              newpos_tex.setY( ( newpos_tex.getY() * dataextent_y ) + miny );
//
//                              //dtest
//                              int cardstr = mEvenlySeedpoints.size();
//                              bool streamline_allowed = false;
//                              for( int i = 0; i < cardstr - 1; i++)
//                              {
//                                      float dsepworld =  0.25f * mStreamlinesTestSeparation * min( dataextent_x, dataextent_y );
//                                      
//                                      streamline_allowed = streamlines[ i ].isPointAllowed( VVector(  newpos_tex.getX() , newpos_tex.getY(), 0.0f ), dsepworld, mdistance );
//
//                                      if( !streamline_allowed )
//                                      {
//                                              dtestfail = true;
//                                              break;
//                                      }
//                              }
//
//                              if ( dtestfail ) break;
//
//                              streamlinevertices.push_back( newpos_tex );
//                              vertexthickness.push_back( mdistance[ 0 ] );
//
//                              float epsilon = 0.0000001f;
//                              VVector posdifference = streamlinevertices[ streamlinevertices.size() - 1 ] - streamlinevertices[ streamlinevertices.size() - 2 ];
//                              if ( posdifference.getMagnitude() < epsilon)
//                              {
//                                      outofdata = true;
//                                      break;
//                              }
//
//                      }
//
//              }
//
//              if( !streamlinevertices.empty() ) 
//              {
//                      streamlines[ j ] = VStreamLine( streamlinevertices ) ;
//                      float dsepworld =  0.25f * mStreamlinesSeedSeparation * min( dataextent_x, dataextent_y );
//                      float dtestworld =  0.25f * mStreamlinesTestSeparation * min( dataextent_x, dataextent_y );
//                      streamlines[ j ].setSeparation( dsepworld, dtestworld );
//              }
//      }
//      
//      //delete pixeldata;
//      pixeldata.clear();
//}
//


void VFlowData::drawStreamlinesFromSeedpoints( float m_TimeStep, float m_MaxSteps  )
{
        if( mNumStreamlines != 0 )
        {
                if ( streamlines )
                {
                        delete[] streamlines;
                        streamlines = NULL;
                        mNumStreamlines = 0;
                }
        }
        //float *pixeldata; // velocoty texture
        std::vector< float > pixeldata;

        int texsize_x, texsize_y;

        float dataextent_x, dataextent_y;
        float datacenter_x, datacenter_y;
        float minx, miny;

        dataextent_x = mExtends.getX();
        dataextent_y = mExtends.getY();
        datacenter_x = mCenterPos.getX();
        datacenter_y = mCenterPos.getY();
        minx = mMinPos.getX();
        miny = mMinPos.getY();

        //float keepratiox = ( dataextent_x > dataextent_y ) ? 1.0f  : dataextent_x / dataextent_y;
        //float keepratioy = ( dataextent_y > dataextent_x ) ? 1.0f  : dataextent_y / dataextent_x;

        // generate seedpoints in texture coordinates
        float numbersteamlines = mManualSeedpoints.size();

        pixeldata = mTimeSteps[m_TimeStep].getFullFBODataVector();
        texsize_x = mTimeSteps[m_TimeStep].mFrameBufferObject->getWidth();
        texsize_y = mTimeSteps[m_TimeStep].mFrameBufferObject->getHeight();

        int size = (int)pixeldata.size();

        
        // for all streamlines
        mNumStreamlines = numbersteamlines;
        streamlines = new VStreamLine[ (int)numbersteamlines + 1 ];

        for ( int j = 0; j < numbersteamlines; j++ )
        {

                std::vector< VVector > streamlinevertices;
                
                bool outofdata = false;

                float sactualpoint_x = 1.0f - mManualSeedpoints[ j ].getX();
                float sactualpoint_y = mManualSeedpoints[ j ].getY();

                VVector start_tex = VVector();
                start_tex.setX( sactualpoint_x  );
                start_tex.setY( sactualpoint_y  );

                VVector start_world = VVector( start_tex );
                
                //TODO:
                //convert to world space
                start_world.setX( -( start_world.getX() * dataextent_x ) + minx + dataextent_x);
                start_world.setY( ( start_world.getY() * dataextent_y ) + miny );
                streamlinevertices.push_back( start_world );

                for ( int i = 0; i <  MAXSTEPS * m_MaxSteps ; i++)
                {
                        if (outofdata ) break;

                        // transform texture coordinates sactualpint_x and sactualpoint_y into world coords
                        VVector arrayindex = VVector( texsize_x * sactualpoint_x, texsize_y * sactualpoint_y, 0.0f );
                        int xfloor = (int) ( arrayindex.getX() - 0.5f ) - 1;
                        int yfloor = (int) ( arrayindex.getY() - 0.5f ) - 1;
                        int xceil  = (int) ( arrayindex.getX() + 0.5f ) - 1;
                        int yceil  = (int) ( arrayindex.getY() + 0.5f ) - 1;

                        if ( xfloor < 0 || yfloor < 0 || xceil >= texsize_x || yceil >= texsize_x )
                        {
                                // we have reached the border;
                                outofdata = true;
                                break;
                        }
                        //fetch velocity at the actual position in world coordinates
                        
                        //floorx floorz
                        float velocity_x_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4     ];
                        float velocity_y_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 1 ];
                        float velocity_z_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 2 ];
                                                                
                        //floorx ceil           
                        float velocity_x_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4      ];
                        float velocity_y_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 1  ];
                        float velocity_z_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 2  ];
                                                                                   
                        //floorx floorz                            
                        float velocity_x_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4      ];
                        float velocity_y_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 1  ];
                        float velocity_z_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 2  ];
                                                                
                        //floorx floorz         
                        float velocity_x_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4      ];
                        float velocity_y_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 1  ];
                        float velocity_z_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 2  ];

                        float interpolval_x_L = ( arrayindex.getX() - xfloor ) * velocity_x_cf + ( xceil - arrayindex.getX() ) * velocity_x_ff;
                        float interpolval_y_L = ( arrayindex.getX() - xfloor ) * velocity_y_cf + ( xceil - arrayindex.getX() ) * velocity_y_ff;
                        float interpolval_z_L = ( arrayindex.getX() - xfloor ) * velocity_z_cf + ( xceil - arrayindex.getX() ) * velocity_z_ff;

                        float interpolval_x_H = ( arrayindex.getX() - xfloor ) * velocity_x_cc + ( xceil - arrayindex.getX() ) * velocity_x_fc;
                        float interpolval_y_H = ( arrayindex.getX() - xfloor ) * velocity_y_cc + ( xceil - arrayindex.getX() ) * velocity_y_fc;
                        float interpolval_z_H = ( arrayindex.getX() - xfloor ) * velocity_z_cc + ( xceil - arrayindex.getX() ) * velocity_z_fc;

                        float interpolval_x = ( arrayindex.getY() - yfloor ) * interpolval_x_H + ( yceil - arrayindex.getY() ) * interpolval_x_L;
                        float interpolval_y = ( arrayindex.getY() - yfloor ) * interpolval_y_H + ( yceil - arrayindex.getY() ) * interpolval_y_L;
                        float interpolval_z = ( arrayindex.getY() - yfloor ) * interpolval_z_H + ( yceil - arrayindex.getY() ) * interpolval_z_L;

                        VVector interpolatedval = VVector( interpolval_x, interpolval_y, interpolval_z );
                        VVector interp_mult = VVector( interpolatedval );
                        interp_mult.setX( -interp_mult.getX(  ) );
                        interp_mult *=  0.05f *mStreamlinesDt;

                        //VVector oldpos_world = mVertexToTexture.homogenTransform( VVector ( sactualpoint_x, sactualpoint_y, 0.0f ) );
                        VVector oldpos_world = VVector();
                        oldpos_world.setX( sactualpoint_x * dataextent_x + minx );
                        oldpos_world.setY( sactualpoint_y * dataextent_y + miny );

                        VVector newpos_world = oldpos_world + interp_mult;

                        VVector newpos_tex = VVector();
                        newpos_tex.setX( ( newpos_world.getX() - minx ) / dataextent_x );
                        newpos_tex.setY( ( newpos_world.getY() - miny ) / dataextent_y );

                        if(             ( newpos_tex.getX() ) > 1.0f || ( newpos_tex.getY() ) > 1.0f 
                                ||      ( newpos_tex.getX() ) < 0.0f || ( newpos_tex.getY() ) < 0.0f )
                        {
                                outofdata = true;
                                break;
                        }
                                
                        sactualpoint_x = newpos_tex.getX();
                        sactualpoint_y = newpos_tex.getY();

                        //TODO:
                        //convert to world space
                        newpos_tex.setX( -( newpos_tex.getX() * dataextent_x ) + minx + dataextent_x);
                        newpos_tex.setY( ( newpos_tex.getY() * dataextent_y ) + miny );
                        streamlinevertices.push_back( newpos_tex );

                        float epsilon = 0.0000001f;
                        VVector posdifference = streamlinevertices[ streamlinevertices.size() - 1 ] - streamlinevertices[ streamlinevertices.size() - 2 ];
                        if ( posdifference.getMagnitude() < epsilon)
                        {
                                outofdata = true;
                                break;
                        }

                }

                //revert the streamline poitns vector and ocntinue in the opposite direction
                if( !streamlinevertices.empty() ) 
                {
                        std::vector< VVector > _streamlinesvertices;
                        for( int k = 0; k < streamlinevertices.size(); k++)
                        {
                                _streamlinesvertices.push_back( streamlinevertices[ streamlinevertices.size() - k - 1 ] );
                                
                        }

                        streamlinevertices.clear();
                        streamlinevertices.swap( _streamlinesvertices );
                        _streamlinesvertices.clear();
                }
                

                sactualpoint_x = 1.0f - mManualSeedpoints[ j ].getX();
                sactualpoint_y = mManualSeedpoints[ j ].getY();

                outofdata = false;

                //and go to the opposite direction
                for ( int i = 0; i <  MAXSTEPS * m_MaxSteps ; i++)
                {
                        if (outofdata ) break;

                        
                        // transform texture coordinates sactualpint_x and sactualpoint_y into world coords
                        VVector arrayindex = VVector( texsize_x * sactualpoint_x, texsize_y * sactualpoint_y, 0.0f );
                        int xfloor = (int) ( arrayindex.getX() - 0.5f ) - 1;
                        int yfloor = (int) ( arrayindex.getY() - 0.5f ) - 1;
                        int xceil  = (int) ( arrayindex.getX() + 0.5f ) - 1;
                        int yceil  = (int) ( arrayindex.getY() + 0.5f ) - 1;

                        if ( xfloor < 0 || yfloor < 0 || xceil >= texsize_x || yceil >= texsize_x )
                        {
                                // we have reached the border;
                                outofdata = true;
                                break;
                        }
                        //fetch velocity at the actual position in world coordinates
                        
                        //floorx floorz
                        float velocity_x_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4     ];
                        float velocity_y_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 1 ];
                        float velocity_z_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 2 ];
                                                                
                        //floorx ceil           
                        float velocity_x_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4      ];
                        float velocity_y_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 1  ];
                        float velocity_z_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 2  ];
                                                                                   
                        //floorx floorz                            
                        float velocity_x_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4      ];
                        float velocity_y_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 1  ];
                        float velocity_z_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 2  ];
                                                                
                        //floorx floorz         
                        float velocity_x_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4      ];
                        float velocity_y_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 1  ];
                        float velocity_z_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 2  ];

                        float interpolval_x_L = ( arrayindex.getX() - xfloor ) * velocity_x_cf + ( xceil - arrayindex.getX() ) * velocity_x_ff;
                        float interpolval_y_L = ( arrayindex.getX() - xfloor ) * velocity_y_cf + ( xceil - arrayindex.getX() ) * velocity_y_ff;
                        float interpolval_z_L = ( arrayindex.getX() - xfloor ) * velocity_z_cf + ( xceil - arrayindex.getX() ) * velocity_z_ff;

                        float interpolval_x_H = ( arrayindex.getX() - xfloor ) * velocity_x_cc + ( xceil - arrayindex.getX() ) * velocity_x_fc;
                        float interpolval_y_H = ( arrayindex.getX() - xfloor ) * velocity_y_cc + ( xceil - arrayindex.getX() ) * velocity_y_fc;
                        float interpolval_z_H = ( arrayindex.getX() - xfloor ) * velocity_z_cc + ( xceil - arrayindex.getX() ) * velocity_z_fc;

                        float interpolval_x = ( arrayindex.getY() - yfloor ) * interpolval_x_H + ( yceil - arrayindex.getY() ) * interpolval_x_L;
                        float interpolval_y = ( arrayindex.getY() - yfloor ) * interpolval_y_H + ( yceil - arrayindex.getY() ) * interpolval_y_L;
                        float interpolval_z = ( arrayindex.getY() - yfloor ) * interpolval_z_H + ( yceil - arrayindex.getY() ) * interpolval_z_L;

                        VVector interpolatedval = VVector( interpolval_x, interpolval_y, interpolval_z );
                        VVector interp_mult = VVector( interpolatedval );
                        interp_mult.setX( -interp_mult.getX(  ) );
                        interp_mult *=  0.05f *mStreamlinesDt;

                        //VVector oldpos_world = mVertexToTexture.homogenTransform( VVector ( sactualpoint_x, sactualpoint_y, 0.0f ) );
                        VVector oldpos_world = VVector();
                        oldpos_world.setX( sactualpoint_x * dataextent_x + minx );
                        oldpos_world.setY( sactualpoint_y * dataextent_y + miny );

                        VVector newpos_world = oldpos_world - interp_mult;

                        VVector newpos_tex = VVector();
                        newpos_tex.setX( ( newpos_world.getX() - minx ) / dataextent_x );
                        newpos_tex.setY( ( newpos_world.getY() - miny ) / dataextent_y );

                        if(             ( newpos_tex.getX() ) > 1.0f || ( newpos_tex.getY() ) > 1.0f 
                                ||      ( newpos_tex.getX() ) < 0.0f || ( newpos_tex.getY() ) < 0.0f )
                        {
                                outofdata = true;
                                break;
                        }
                                
                        sactualpoint_x = newpos_tex.getX();
                        sactualpoint_y = newpos_tex.getY();

                        //TODO:
                        //convert to world space
                        newpos_tex.setX( -( newpos_tex.getX() * dataextent_x ) + minx + dataextent_x);
                        newpos_tex.setY( ( newpos_tex.getY() * dataextent_y ) + miny );
                        streamlinevertices.push_back( newpos_tex );

                        float epsilon = 0.0000001f;
                        VVector posdifference = streamlinevertices[ streamlinevertices.size() - 1 ] - streamlinevertices[ streamlinevertices.size() - 2 ];
                        if ( posdifference.getMagnitude() < epsilon)
                        {
                                outofdata = true;
                                break;
                        }

                }
                if( !streamlinevertices.empty() ) 
                {
                        streamlines[ j ] = VStreamLine( streamlinevertices ) ;
                        streamlines[ j ].regenerateVBO();
                }
        }
        
        //delete pixeldata;
        pixeldata.clear();

}

//declacrations

#define _LEFT           0
#define _TOP            1
#define _RIGHT          2
#define _BOTTOM         3
#define _ALL            4
#define _RANDOM         5
#define _MANUAL         6
#define _EVEN           7

bool VFlowData::isIndexOfManualPlacingMethod( int val )
{
        return ( val == _MANUAL );
}

bool VFlowData::isIndexOfEvenPlacingMethod( int val )
{
        return ( val == _EVEN);
}

void VFlowData::setPlacingMethod( int mode )
{
        
        mEvenlySeedpoints.clear();
        mManualSeedpoints.clear();
        
        if( mNumStreamlines != 0 )
        {
                if ( streamlines )
                {
                        delete[] streamlines;
                        streamlines = NULL;
                        mNumStreamlines = 0;
                }
        }

        switch ( mode )
        {
                case _LEFT:
                        {
                                mSeedPlacing = LEFT;
                                break;
                        }
                        
                case _TOP:
                        {
                                mSeedPlacing = TOP;
                                break;
                        }
                        
                case _RIGHT:
                        {
                                mSeedPlacing = RIGHT;
                                break;
                        }
                        
                case _BOTTOM:
                        {
                                mSeedPlacing = BOTTOM;
                                break;
                        }
                case _ALL:
                {
                        mSeedPlacing = ALL;
                        break;
                }
                        
                case _RANDOM:
                        {
                                mSeedPlacing = RANDOM;
                                break;
                        }
                        
                case _MANUAL:
                        {
                                mSeedPlacing = MANUAL;
                                break;
                        }
                        
                case _EVEN:
                        {
                                mSeedPlacing = EVEN;
                                break;
                        }
        
        }
        
        
}


void VFlowData::loadStreamLines( std::string m_FileName )
{
        if( mNumStreamlines != 0 )
        {
                for(int i = 0; i < mNumStreamlines; ++i)
                {
                        streamlines[i].clearVBO();
                }
                delete[] streamlines;
                streamlines = NULL;
        }

        if(m_FileName == "")
        {
                return;
        }
        FILE *fp = NULL;

        fopen_s(&fp,m_FileName.c_str(),"rb");

        if(!fp)
        {
                return;
        }
        unsigned int numLines;

        fread(&numLines,sizeof(unsigned int),1,fp);
        mNumStreamlines = (int)numLines;

        streamlines = new VStreamLine[numLines];
        
        for (int i = 0; i < numLines; ++i )
        {
                streamlines[ i ] = VStreamLine();
                streamlines[ i ].loadStreamLine(fp);
        }

        fclose(fp);

}

void VFlowData::saveStreamLines( std::string m_FileName )
{
        if(mNumStreamlines == 0)
        {
                return;
        }

        if(m_FileName == "")
        {
                return;
        }
        FILE *fp = NULL;



        fopen_s(&fp,m_FileName.c_str(),"wb");

        if(!fp)
        {
                return;
        }
        unsigned int numLines = (unsigned int)mNumStreamlines;

        fwrite(reinterpret_cast<char*>(&numLines), sizeof(unsigned int), 1,fp);

        for( int i = 0; i< mNumStreamlines; ++i )
        {
                streamlines[i].saveStreamLine(fp);
        }
        fclose(fp);
}

void VFlowData::computeIcons()
{
        for( int i = 0; i < (int)mIcons.size(); ++i )
        {
                mIcons[i].computeIcon( &mTimeSteps[0], mActiveTimeStep );
        }
}

bool VFlowData::getPointAt( VVector *next, std::vector<float> pixeldata, float px, float py, int texsize_x, int texsize_y)
{
        return false;
}

void VFlowData::generateCPUStreamLinesLEFT( float m_MaxSteps, float m_StreamSeparation, int m_TimeStep /* = 0  */ )
{
        if( mNumStreamlines != 0 )
        {
                if ( streamlines )
                {
                        delete[] streamlines;
                        streamlines = NULL;
                        mNumStreamlines = 0;
                }
        }
        //float *pixeldata; // velocoty texture
        std::vector< float > pixeldata;

        int texsize_x, texsize_y;

        float dataextent_x, dataextent_y;
        float datacenter_x, datacenter_y;
        float minx, miny;

        dataextent_x = mExtends.getX();
        dataextent_y = mExtends.getY();
        datacenter_x = mCenterPos.getX();
        datacenter_y = mCenterPos.getY();
        minx = mMinPos.getX();
        miny = mMinPos.getY();

        float keepratiox = ( dataextent_x > dataextent_y ) ? 1.0f  : dataextent_x / dataextent_y;
        float keepratioy = ( dataextent_y > dataextent_x ) ? 1.0f  : dataextent_y / dataextent_x;

        // generate seedpoints in texture coordinates
        float numbersteamlines = MINNUMBER +  ( 1.0f - m_StreamSeparation ) * ( MAXNUMBER - MINNUMBER );
        float spacing = 1.0f / numbersteamlines ;

        pixeldata = mTimeSteps[m_TimeStep].getFullFBODataVector();
        texsize_x = mTimeSteps[m_TimeStep].mFrameBufferObject->getWidth();
        texsize_y = mTimeSteps[m_TimeStep].mFrameBufferObject->getHeight();

        int size = (int)pixeldata.size();
        
        // for all streamlines
        mNumStreamlines = (int)numbersteamlines;
        streamlines = new VStreamLine[ (int)mNumStreamlines + 1 ];

        for ( int j = 0; j <= mNumStreamlines; j++ )
        {
        
                std::vector< VVector > streamlinevertices;
                
                bool outofdata = false;

                float offset = (float)( j + 1 ) / ( (float)numbersteamlines + 1.0f );

                // start left go to right
                float sactualpoint_y = offset - 0.5f * ( 1.0f / texsize_x );
                float sactualpoint_x = 0.0025f - 0.5f * ( 1.0f / texsize_x );
                
                VVector start_tex = VVector();
                start_tex.setX( sactualpoint_x  );
                start_tex.setY( sactualpoint_y  );

                VVector start_world = VVector( start_tex );
                
                //TODO:
                //convert to world space
                start_world.setX( -( start_world.getX() * dataextent_x ) + minx + dataextent_x);
                start_world.setY( ( start_world.getY() * dataextent_y ) + miny );
                streamlinevertices.push_back( start_world );

                for ( int i = 0; i <  MAXSTEPS * m_MaxSteps ; i++)
                {
                        if (outofdata ) break;


                        // transform texture coordinates sactualpint_x and sactualpoint_y into world coords
                        VVector arrayindex = VVector( texsize_x * sactualpoint_x, texsize_y * sactualpoint_y, 0.0f );
                        int xfloor = (int) ( arrayindex.getX() - 0.5f ) - 1;
                        int yfloor = (int) ( arrayindex.getY() - 0.5f ) - 1;
                        int xceil  = (int) ( arrayindex.getX() + 0.5f ) - 1;
                        int yceil  = (int) ( arrayindex.getY() + 0.5f ) - 1;

                        if ( xfloor < 0 || yfloor < 0 || xceil >= texsize_x || yceil >= texsize_x )
                        {
                                // we have reached the border;
                                outofdata = true;
                                break;
                        }
                        //fetch velocity at the actual position in world coordinates
                        
                        //floorx floorz
                        float velocity_x_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4     ];
                        float velocity_y_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 1 ];
                        float velocity_z_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 2 ];
                                                                
                        //floorx ceil           
                        float velocity_x_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4      ];
                        float velocity_y_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 1  ];
                        float velocity_z_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 2  ];
                                                                                   
                        //floorx floorz                            
                        float velocity_x_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4      ];
                        float velocity_y_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 1  ];
                        float velocity_z_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 2  ];
                                                                
                        //floorx floorz         
                        float velocity_x_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4      ];
                        float velocity_y_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 1  ];
                        float velocity_z_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 2  ];

                        float interpolval_x_L = ( arrayindex.getX() - xfloor ) * velocity_x_cf + ( xceil - arrayindex.getX() ) * velocity_x_ff;
                        float interpolval_y_L = ( arrayindex.getX() - xfloor ) * velocity_y_cf + ( xceil - arrayindex.getX() ) * velocity_y_ff;
                        float interpolval_z_L = ( arrayindex.getX() - xfloor ) * velocity_z_cf + ( xceil - arrayindex.getX() ) * velocity_z_ff;

                        float interpolval_x_H = ( arrayindex.getX() - xfloor ) * velocity_x_cc + ( xceil - arrayindex.getX() ) * velocity_x_fc;
                        float interpolval_y_H = ( arrayindex.getX() - xfloor ) * velocity_y_cc + ( xceil - arrayindex.getX() ) * velocity_y_fc;
                        float interpolval_z_H = ( arrayindex.getX() - xfloor ) * velocity_z_cc + ( xceil - arrayindex.getX() ) * velocity_z_fc;

                        float interpolval_x = ( arrayindex.getY() - yfloor ) * interpolval_x_H + ( yceil - arrayindex.getY() ) * interpolval_x_L;
                        float interpolval_y = ( arrayindex.getY() - yfloor ) * interpolval_y_H + ( yceil - arrayindex.getY() ) * interpolval_y_L;
                        float interpolval_z = ( arrayindex.getY() - yfloor ) * interpolval_z_H + ( yceil - arrayindex.getY() ) * interpolval_z_L;

                        VVector interpolatedval = VVector( interpolval_x, interpolval_y, interpolval_z );
                        VVector interp_mult = VVector( interpolatedval );
                        interp_mult.setX( -interp_mult.getX(  ) );
                        interp_mult *=  0.05f *mStreamlinesDt;

                        //VVector oldpos_world = mVertexToTexture.homogenTransform( VVector ( sactualpoint_x, sactualpoint_y, 0.0f ) );
                        VVector oldpos_world = VVector();
                        oldpos_world.setX( sactualpoint_x * dataextent_x + minx );
                        oldpos_world.setY( sactualpoint_y * dataextent_y + miny );

                        VVector newpos_world = oldpos_world + interp_mult;

                        VVector newpos_tex = VVector();
                        newpos_tex.setX( ( newpos_world.getX() - minx ) / dataextent_x );
                        newpos_tex.setY( ( newpos_world.getY() - miny ) / dataextent_y );

                        if(             ( newpos_tex.getX() ) > 1.0f || ( newpos_tex.getY() ) > 1.0f 
                                ||      ( newpos_tex.getX() ) < 0.0f || ( newpos_tex.getY() ) < 0.0f )
                        {
                                outofdata = true;
                                break;
                        }
                                
                        sactualpoint_x = newpos_tex.getX();
                        sactualpoint_y = newpos_tex.getY();

                        //TODO:
                        //convert to world space
                        newpos_tex.setX( -( newpos_tex.getX() * dataextent_x ) + minx + dataextent_x);
                        newpos_tex.setY( ( newpos_tex.getY() * dataextent_y ) + miny );
                        streamlinevertices.push_back( newpos_tex );

                        //if the streamline reached the sink
                        float epsilon = 0.0000001f;
                        VVector posdifference = streamlinevertices[ streamlinevertices.size() - 1 ] - streamlinevertices[ streamlinevertices.size() - 2 ];
                        if ( posdifference.getMagnitude() < epsilon)
                        {
                                outofdata = true;
                                break;
                        }

                }
                if( !streamlinevertices.empty() ) 
                {
                        streamlines[ j ] = VStreamLine( streamlinevertices ) ;
                        streamlines[ j ].regenerateVBO();
                }
        }

        
        //delete pixeldata;
        pixeldata.clear();

}


void VFlowData::generateCPUStreamLinesTOP( float m_MaxSteps, float m_StreamSeparation, int m_TimeStep /* = 0  */ )
{
        if( mNumStreamlines != 0 )
        {
                if ( streamlines )
                {
                        delete[] streamlines;
                        streamlines = NULL;
                        mNumStreamlines = 0;
                }
        }
        //float *pixeldata; // velocoty texture
        std::vector< float > pixeldata;

        int texsize_x, texsize_y;

        float dataextent_x, dataextent_y;
        float datacenter_x, datacenter_y;
        float minx, miny;

        dataextent_x = mExtends.getX();
        dataextent_y = mExtends.getY();
        datacenter_x = mCenterPos.getX();
        datacenter_y = mCenterPos.getY();
        minx = mMinPos.getX();
        miny = mMinPos.getY();

        float keepratiox = ( dataextent_x > dataextent_y ) ? 1.0f  : dataextent_x / dataextent_y;
        float keepratioy = ( dataextent_y > dataextent_x ) ? 1.0f  : dataextent_y / dataextent_x;

        // generate seedpoints in texture coordinates
        float numbersteamlines = MINNUMBER +  ( 1.0f - m_StreamSeparation ) * ( MAXNUMBER - MINNUMBER );
        float spacing = 1.0f / numbersteamlines ;

        pixeldata = mTimeSteps[m_TimeStep].getFullFBODataVector();
        texsize_x = mTimeSteps[m_TimeStep].mFrameBufferObject->getWidth();
        texsize_y = mTimeSteps[m_TimeStep].mFrameBufferObject->getHeight();

        int size = (int)pixeldata.size();
        
        // for all streamlines
        mNumStreamlines = (int)numbersteamlines;
        streamlines = new VStreamLine[ (int)mNumStreamlines + 1 ];

        for ( int j = 0; j <= mNumStreamlines; j++ )
        {
        
                std::vector< VVector > streamlinevertices;
                
                bool outofdata = false;

                float offset = (float)( j + 1 ) / ( (float)numbersteamlines + 1.0f );

                //start top go the bottom
                float sactualpoint_x = offset - 0.5f * ( 1.0f / texsize_x );
                float sactualpoint_y = 1.0f - 0.5f * ( 1.0f / texsize_y );
                
                VVector start_tex = VVector();
                start_tex.setX( sactualpoint_x  );
                start_tex.setY( sactualpoint_y  );

                VVector start_world = VVector( start_tex );
                
                //TODO:
                //convert to world space
                start_world.setX( -( start_world.getX() * dataextent_x ) + minx + dataextent_x);
                start_world.setY( ( start_world.getY() * dataextent_y ) + miny );
                streamlinevertices.push_back( start_world );

                for ( int i = 0; i <  MAXSTEPS * m_MaxSteps ; i++)
                {
                        if (outofdata ) break;


                        // transform texture coordinates sactualpint_x and sactualpoint_y into world coords
                        VVector arrayindex = VVector( texsize_x * sactualpoint_x, texsize_y * sactualpoint_y, 0.0f );
                        int xfloor = (int) ( arrayindex.getX() - 0.5f ) - 1;
                        int yfloor = (int) ( arrayindex.getY() - 0.5f ) - 1;
                        int xceil  = (int) ( arrayindex.getX() + 0.5f ) - 1;
                        int yceil  = (int) ( arrayindex.getY() + 0.5f ) - 1;

                        if ( xfloor < 0 || yfloor < 0 || xceil >= texsize_x || yceil >= texsize_x )
                        {
                                // we have reached the border;
                                outofdata = true;
                                break;
                        }
                        //fetch velocity at the actual position in world coordinates
                        
                        //floorx floorz
                        float velocity_x_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4     ];
                        float velocity_y_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 1 ];
                        float velocity_z_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 2 ];
                                                                
                        //floorx ceil           
                        float velocity_x_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4      ];
                        float velocity_y_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 1  ];
                        float velocity_z_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 2  ];
                                                                                   
                        //floorx floorz                            
                        float velocity_x_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4      ];
                        float velocity_y_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 1  ];
                        float velocity_z_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 2  ];
                                                                
                        //floorx floorz         
                        float velocity_x_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4      ];
                        float velocity_y_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 1  ];
                        float velocity_z_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 2  ];

                        float interpolval_x_L = ( arrayindex.getX() - xfloor ) * velocity_x_cf + ( xceil - arrayindex.getX() ) * velocity_x_ff;
                        float interpolval_y_L = ( arrayindex.getX() - xfloor ) * velocity_y_cf + ( xceil - arrayindex.getX() ) * velocity_y_ff;
                        float interpolval_z_L = ( arrayindex.getX() - xfloor ) * velocity_z_cf + ( xceil - arrayindex.getX() ) * velocity_z_ff;

                        float interpolval_x_H = ( arrayindex.getX() - xfloor ) * velocity_x_cc + ( xceil - arrayindex.getX() ) * velocity_x_fc;
                        float interpolval_y_H = ( arrayindex.getX() - xfloor ) * velocity_y_cc + ( xceil - arrayindex.getX() ) * velocity_y_fc;
                        float interpolval_z_H = ( arrayindex.getX() - xfloor ) * velocity_z_cc + ( xceil - arrayindex.getX() ) * velocity_z_fc;

                        float interpolval_x = ( arrayindex.getY() - yfloor ) * interpolval_x_H + ( yceil - arrayindex.getY() ) * interpolval_x_L;
                        float interpolval_y = ( arrayindex.getY() - yfloor ) * interpolval_y_H + ( yceil - arrayindex.getY() ) * interpolval_y_L;
                        float interpolval_z = ( arrayindex.getY() - yfloor ) * interpolval_z_H + ( yceil - arrayindex.getY() ) * interpolval_z_L;

                        VVector interpolatedval = VVector( interpolval_x, interpolval_y, interpolval_z );
                        VVector interp_mult = VVector( interpolatedval );
                        interp_mult.setX( -interp_mult.getX(  ) );
                        interp_mult *=  0.05f *mStreamlinesDt;

                        //VVector oldpos_world = mVertexToTexture.homogenTransform( VVector ( sactualpoint_x, sactualpoint_y, 0.0f ) );
                        VVector oldpos_world = VVector();
                        oldpos_world.setX( sactualpoint_x * dataextent_x + minx );
                        oldpos_world.setY( sactualpoint_y * dataextent_y + miny );

                        VVector newpos_world = oldpos_world + interp_mult;

                        VVector newpos_tex = VVector();
                        newpos_tex.setX( ( newpos_world.getX() - minx ) / dataextent_x );
                        newpos_tex.setY( ( newpos_world.getY() - miny ) / dataextent_y );

                        if(             ( newpos_tex.getX() ) > 1.0f || ( newpos_tex.getY() ) > 1.0f 
                                ||      ( newpos_tex.getX() ) < 0.0f || ( newpos_tex.getY() ) < 0.0f )
                        {
                                outofdata = true;
                                break;
                        }
                                
                        sactualpoint_x = newpos_tex.getX();
                        sactualpoint_y = newpos_tex.getY();

                        //TODO:
                        //convert to world space
                        newpos_tex.setX( -( newpos_tex.getX() * dataextent_x ) + minx + dataextent_x);
                        newpos_tex.setY( ( newpos_tex.getY() * dataextent_y ) + miny );
                        streamlinevertices.push_back( newpos_tex );

                        //if the streamline reached the sink
                        float epsilon = 0.0000001f;
                        VVector posdifference = streamlinevertices[ streamlinevertices.size() - 1 ] - streamlinevertices[ streamlinevertices.size() - 2 ];
                        if ( posdifference.getMagnitude() < epsilon)
                        {
                                outofdata = true;
                                break;
                        }

                }
                if( !streamlinevertices.empty() ) 
                {
                        streamlines[ j ] = VStreamLine( streamlinevertices ) ;
                        streamlines[ j ].regenerateVBO();
                }
        }

        
        //delete pixeldata;
        pixeldata.clear();
}

void VFlowData::generateCPUStreamLinesRIGHT( float m_MaxSteps, float m_StreamSeparation, int m_TimeStep /* = 0  */ )
{
        if( mNumStreamlines != 0 )
        {
                if ( streamlines )
                {
                        delete[] streamlines;
                        streamlines = NULL;
                        mNumStreamlines = 0;
                }
        }
        //float *pixeldata; // velocoty texture
        std::vector< float > pixeldata;

        int texsize_x, texsize_y;

        float dataextent_x, dataextent_y;
        float datacenter_x, datacenter_y;
        float minx, miny;

        dataextent_x = mExtends.getX();
        dataextent_y = mExtends.getY();
        datacenter_x = mCenterPos.getX();
        datacenter_y = mCenterPos.getY();
        minx = mMinPos.getX();
        miny = mMinPos.getY();

        float keepratiox = ( dataextent_x > dataextent_y ) ? 1.0f  : dataextent_x / dataextent_y;
        float keepratioy = ( dataextent_y > dataextent_x ) ? 1.0f  : dataextent_y / dataextent_x;

        // generate seedpoints in texture coordinates
        float numbersteamlines = MINNUMBER +  ( 1.0f - m_StreamSeparation ) * ( MAXNUMBER - MINNUMBER );
        float spacing = 1.0f / numbersteamlines ;

        pixeldata = mTimeSteps[m_TimeStep].getFullFBODataVector();
        texsize_x = mTimeSteps[m_TimeStep].mFrameBufferObject->getWidth();
        texsize_y = mTimeSteps[m_TimeStep].mFrameBufferObject->getHeight();

        int size = (int)pixeldata.size();
        
        // for all streamlines
        mNumStreamlines = (int)numbersteamlines;
        streamlines = new VStreamLine[ (int)mNumStreamlines + 1 ];

        for ( int j = 0; j <= mNumStreamlines; j++ )
        {
        
                std::vector< VVector > streamlinevertices;
                
                bool outofdata = false;

                float offset = (float)( j + 1 ) / ( (float)numbersteamlines + 1.0f );

                //start right go the left
                float sactualpoint_y = offset - 0.5f * ( 1.0f / texsize_y );
                float sactualpoint_x = 1.0f - 0.5f * ( 1.0f / texsize_x );
                
                VVector start_tex = VVector();
                start_tex.setX( sactualpoint_x  );
                start_tex.setY( sactualpoint_y  );

                VVector start_world = VVector( start_tex );
                
                //TODO:
                //convert to world space
                start_world.setX( -( start_world.getX() * dataextent_x ) + minx + dataextent_x);
                start_world.setY( ( start_world.getY() * dataextent_y ) + miny );
                streamlinevertices.push_back( start_world );

                for ( int i = 0; i <  MAXSTEPS * m_MaxSteps ; i++)
                {
                        if (outofdata ) break;

                        // transform texture coordinates sactualpint_x and sactualpoint_y into world coords
                        VVector arrayindex = VVector( texsize_x * sactualpoint_x, texsize_y * sactualpoint_y, 0.0f );
                        int xfloor = (int) ( arrayindex.getX() - 0.5f ) - 1;
                        int yfloor = (int) ( arrayindex.getY() - 0.5f ) - 1;
                        int xceil  = (int) ( arrayindex.getX() + 0.5f ) - 1;
                        int yceil  = (int) ( arrayindex.getY() + 0.5f ) - 1;

                        if ( xfloor < 0 || yfloor < 0 || xceil >= texsize_x || yceil >= texsize_x )
                        {
                                // we have reached the border;
                                outofdata = true;
                                break;
                        }
                        //fetch velocity at the actual position in world coordinates
                        
                        //floorx floorz
                        float velocity_x_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4     ];
                        float velocity_y_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 1 ];
                        float velocity_z_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 2 ];
                                                                
                        //floorx ceil           
                        float velocity_x_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4      ];
                        float velocity_y_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 1  ];
                        float velocity_z_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 2  ];
                                                                                   
                        //floorx floorz                            
                        float velocity_x_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4      ];
                        float velocity_y_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 1  ];
                        float velocity_z_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 2  ];
                                                                
                        //floorx floorz         
                        float velocity_x_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4      ];
                        float velocity_y_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 1  ];
                        float velocity_z_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 2  ];

                        float interpolval_x_L = ( arrayindex.getX() - xfloor ) * velocity_x_cf + ( xceil - arrayindex.getX() ) * velocity_x_ff;
                        float interpolval_y_L = ( arrayindex.getX() - xfloor ) * velocity_y_cf + ( xceil - arrayindex.getX() ) * velocity_y_ff;
                        float interpolval_z_L = ( arrayindex.getX() - xfloor ) * velocity_z_cf + ( xceil - arrayindex.getX() ) * velocity_z_ff;

                        float interpolval_x_H = ( arrayindex.getX() - xfloor ) * velocity_x_cc + ( xceil - arrayindex.getX() ) * velocity_x_fc;
                        float interpolval_y_H = ( arrayindex.getX() - xfloor ) * velocity_y_cc + ( xceil - arrayindex.getX() ) * velocity_y_fc;
                        float interpolval_z_H = ( arrayindex.getX() - xfloor ) * velocity_z_cc + ( xceil - arrayindex.getX() ) * velocity_z_fc;

                        float interpolval_x = ( arrayindex.getY() - yfloor ) * interpolval_x_H + ( yceil - arrayindex.getY() ) * interpolval_x_L;
                        float interpolval_y = ( arrayindex.getY() - yfloor ) * interpolval_y_H + ( yceil - arrayindex.getY() ) * interpolval_y_L;
                        float interpolval_z = ( arrayindex.getY() - yfloor ) * interpolval_z_H + ( yceil - arrayindex.getY() ) * interpolval_z_L;

                        VVector interpolatedval = VVector( interpolval_x, interpolval_y, interpolval_z );
                        VVector interp_mult = VVector( interpolatedval );
                        interp_mult.setX( -interp_mult.getX(  ) );
                        interp_mult *=  0.05f *mStreamlinesDt;

                        //VVector oldpos_world = mVertexToTexture.homogenTransform( VVector ( sactualpoint_x, sactualpoint_y, 0.0f ) );
                        VVector oldpos_world = VVector();
                        oldpos_world.setX( sactualpoint_x * dataextent_x + minx );
                        oldpos_world.setY( sactualpoint_y * dataextent_y + miny );

                        VVector newpos_world = oldpos_world + interp_mult;

                        VVector newpos_tex = VVector();
                        newpos_tex.setX( ( newpos_world.getX() - minx ) / dataextent_x );
                        newpos_tex.setY( ( newpos_world.getY() - miny ) / dataextent_y );

                        if(             ( newpos_tex.getX() ) > 1.0f || ( newpos_tex.getY() ) > 1.0f 
                                ||      ( newpos_tex.getX() ) < 0.0f || ( newpos_tex.getY() ) < 0.0f )
                        {
                                outofdata = true;
                                break;
                        }
                                
                        sactualpoint_x = newpos_tex.getX();
                        sactualpoint_y = newpos_tex.getY();

                        //TODO:
                        //convert to world space
                        newpos_tex.setX( -( newpos_tex.getX() * dataextent_x ) + minx + dataextent_x);
                        newpos_tex.setY( ( newpos_tex.getY() * dataextent_y ) + miny );
                        streamlinevertices.push_back( newpos_tex );

                        //if the streamline reached the sink
                        float epsilon = 0.0000001f;
                        VVector posdifference = streamlinevertices[ streamlinevertices.size() - 1 ] - streamlinevertices[ streamlinevertices.size() - 2 ];
                        if ( posdifference.getMagnitude() < epsilon)
                        {
                                outofdata = true;
                                break;
                        }

                }
                if( !streamlinevertices.empty() ) 
                {
                        streamlines[ j ] = VStreamLine( streamlinevertices ) ;
                        streamlines[ j ].regenerateVBO();
                }
        }

        
        //delete pixeldata;
        pixeldata.clear();
}

void VFlowData::generateCPUStreamLinesBOTTOM( float m_MaxSteps, float m_StreamSeparation, int m_TimeStep /* = 0  */ )
{
        if( mNumStreamlines != 0 )
        {
                if ( streamlines )
                {
                        delete[] streamlines;
                        streamlines = NULL;
                        mNumStreamlines = 0;
                }
        }
        //float *pixeldata; // velocoty texture
        std::vector< float > pixeldata;

        int texsize_x, texsize_y;

        float dataextent_x, dataextent_y;
        float datacenter_x, datacenter_y;
        float minx, miny;

        dataextent_x = mExtends.getX();
        dataextent_y = mExtends.getY();
        datacenter_x = mCenterPos.getX();
        datacenter_y = mCenterPos.getY();
        minx = mMinPos.getX();
        miny = mMinPos.getY();

        float keepratiox = ( dataextent_x > dataextent_y ) ? 1.0f  : dataextent_x / dataextent_y;
        float keepratioy = ( dataextent_y > dataextent_x ) ? 1.0f  : dataextent_y / dataextent_x;

        // generate seedpoints in texture coordinates
        float numbersteamlines = MINNUMBER +  ( 1.0f - m_StreamSeparation ) * ( MAXNUMBER - MINNUMBER );
        float spacing = 1.0f / numbersteamlines ;

        pixeldata = mTimeSteps[m_TimeStep].getFullFBODataVector();
        texsize_x = mTimeSteps[m_TimeStep].mFrameBufferObject->getWidth();
        texsize_y = mTimeSteps[m_TimeStep].mFrameBufferObject->getHeight();

        int size = (int)pixeldata.size();
        
        // for all streamlines
        mNumStreamlines = (int)numbersteamlines;
        streamlines = new VStreamLine[ (int)mNumStreamlines + 1 ];

        for ( int j = 0; j <= mNumStreamlines; j++ )
        {
        
                std::vector< VVector > streamlinevertices;
                
                bool outofdata = false;

                float offset = (float)( j + 1 ) / ( (float)numbersteamlines + 1.0f );

                //start bottom go the top
                float sactualpoint_x = offset - 0.5f * ( 1.0f / texsize_x );
                float sactualpoint_y = 0.0025f - 0.5f * ( 1.0f / texsize_y );

                
                VVector start_tex = VVector();
                start_tex.setX( sactualpoint_x  );
                start_tex.setY( sactualpoint_y  );

                VVector start_world = VVector( start_tex );
                
                //TODO:
                //convert to world space
                start_world.setX( -( start_world.getX() * dataextent_x ) + minx + dataextent_x);
                start_world.setY( ( start_world.getY() * dataextent_y ) + miny );
                streamlinevertices.push_back( start_world );

                for ( int i = 0; i <  MAXSTEPS * m_MaxSteps ; i++)
                {
                        if (outofdata ) break;

                        // transform texture coordinates sactualpint_x and sactualpoint_y into world coords
                        VVector arrayindex = VVector( texsize_x * sactualpoint_x, texsize_y * sactualpoint_y, 0.0f );
                        int xfloor = (int) ( arrayindex.getX() - 0.5f ) - 1;
                        int yfloor = (int) ( arrayindex.getY() - 0.5f ) - 1;
                        int xceil  = (int) ( arrayindex.getX() + 0.5f ) - 1;
                        int yceil  = (int) ( arrayindex.getY() + 0.5f ) - 1;

                        if ( xfloor < 0 || yfloor < 0 || xceil >= texsize_x || yceil >= texsize_x )
                        {
                                // we have reached the border;
                                outofdata = true;
                                break;
                        }
                        //fetch velocity at the actual position in world coordinates
                        
                        //floorx floorz
                        float velocity_x_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4     ];
                        float velocity_y_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 1 ];
                        float velocity_z_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 2 ];
                                                                
                        //floorx ceil           
                        float velocity_x_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4      ];
                        float velocity_y_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 1  ];
                        float velocity_z_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 2  ];
                                                                                   
                        //floorx floorz                            
                        float velocity_x_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4      ];
                        float velocity_y_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 1  ];
                        float velocity_z_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 2  ];
                                                                
                        //floorx floorz         
                        float velocity_x_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4      ];
                        float velocity_y_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 1  ];
                        float velocity_z_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 2  ];

                        float interpolval_x_L = ( arrayindex.getX() - xfloor ) * velocity_x_cf + ( xceil - arrayindex.getX() ) * velocity_x_ff;
                        float interpolval_y_L = ( arrayindex.getX() - xfloor ) * velocity_y_cf + ( xceil - arrayindex.getX() ) * velocity_y_ff;
                        float interpolval_z_L = ( arrayindex.getX() - xfloor ) * velocity_z_cf + ( xceil - arrayindex.getX() ) * velocity_z_ff;

                        float interpolval_x_H = ( arrayindex.getX() - xfloor ) * velocity_x_cc + ( xceil - arrayindex.getX() ) * velocity_x_fc;
                        float interpolval_y_H = ( arrayindex.getX() - xfloor ) * velocity_y_cc + ( xceil - arrayindex.getX() ) * velocity_y_fc;
                        float interpolval_z_H = ( arrayindex.getX() - xfloor ) * velocity_z_cc + ( xceil - arrayindex.getX() ) * velocity_z_fc;

                        float interpolval_x = ( arrayindex.getY() - yfloor ) * interpolval_x_H + ( yceil - arrayindex.getY() ) * interpolval_x_L;
                        float interpolval_y = ( arrayindex.getY() - yfloor ) * interpolval_y_H + ( yceil - arrayindex.getY() ) * interpolval_y_L;
                        float interpolval_z = ( arrayindex.getY() - yfloor ) * interpolval_z_H + ( yceil - arrayindex.getY() ) * interpolval_z_L;

                        VVector interpolatedval = VVector( interpolval_x, interpolval_y, interpolval_z );
                        VVector interp_mult = VVector( interpolatedval );
                        interp_mult.setX( -interp_mult.getX(  ) );
                        interp_mult *=  0.05f *mStreamlinesDt;

                        //VVector oldpos_world = mVertexToTexture.homogenTransform( VVector ( sactualpoint_x, sactualpoint_y, 0.0f ) );
                        VVector oldpos_world = VVector();
                        oldpos_world.setX( sactualpoint_x * dataextent_x + minx );
                        oldpos_world.setY( sactualpoint_y * dataextent_y + miny );

                        VVector newpos_world = oldpos_world + interp_mult;

                        VVector newpos_tex = VVector();
                        newpos_tex.setX( ( newpos_world.getX() - minx ) / dataextent_x );
                        newpos_tex.setY( ( newpos_world.getY() - miny ) / dataextent_y );

                        if(             ( newpos_tex.getX() ) > 1.0f || ( newpos_tex.getY() ) > 1.0f 
                                ||      ( newpos_tex.getX() ) < 0.0f || ( newpos_tex.getY() ) < 0.0f )
                        {
                                outofdata = true;
                                break;
                        }
                                
                        sactualpoint_x = newpos_tex.getX();
                        sactualpoint_y = newpos_tex.getY();

                        //TODO:
                        //convert to world space
                        newpos_tex.setX( -( newpos_tex.getX() * dataextent_x ) + minx + dataextent_x);
                        newpos_tex.setY( ( newpos_tex.getY() * dataextent_y ) + miny );
                        streamlinevertices.push_back( newpos_tex );

                        //if the streamline reached the sink
                        float epsilon = 0.0000001f;
                        VVector posdifference = streamlinevertices[ streamlinevertices.size() - 1 ] - streamlinevertices[ streamlinevertices.size() - 2 ];
                        if ( posdifference.getMagnitude() < epsilon)
                        {
                                outofdata = true;
                                break;
                        }

                }
                if( !streamlinevertices.empty() ) 
                {
                        streamlines[ j ] = VStreamLine( streamlinevertices ) ;
                        streamlines[ j ].regenerateVBO();
                }
        }

        
        //delete pixeldata;
        pixeldata.clear();

}

void VFlowData::generateCPUStreamLinesALL( float m_MaxSteps, float m_StreamSeparation, int m_TimeStep /* = 0  */ )
{

        if( mNumStreamlines != 0 )
        {
                if ( streamlines )
                {
                        delete[] streamlines;
                        streamlines = NULL;
                        mNumStreamlines = 0;
                }
        }
        //float *pixeldata; // velocoty texture
        std::vector< float > pixeldata;

        int texsize_x, texsize_y;

        float dataextent_x, dataextent_y;
        float datacenter_x, datacenter_y;
        float minx, miny;

        dataextent_x = mExtends.getX();
        dataextent_y = mExtends.getY();
        datacenter_x = mCenterPos.getX();
        datacenter_y = mCenterPos.getY();
        minx = mMinPos.getX();
        miny = mMinPos.getY();

        float keepratiox = ( dataextent_x > dataextent_y ) ? 1.0f  : dataextent_x / dataextent_y;
        float keepratioy = ( dataextent_y > dataextent_x ) ? 1.0f  : dataextent_y / dataextent_x;

        // generate seedpoints in texture coordinates
        float qnumbersteamlines = MINNUMBER +  ( 1.0f - m_StreamSeparation ) * ( MAXNUMBER - MINNUMBER );
        float spacing = 1.0f / qnumbersteamlines ;

        pixeldata = mTimeSteps[m_TimeStep].getFullFBODataVector();
        texsize_x = mTimeSteps[m_TimeStep].mFrameBufferObject->getWidth();
        texsize_y = mTimeSteps[m_TimeStep].mFrameBufferObject->getHeight();

        int size = (int)pixeldata.size();
        
        // for all streamlines
        mNumStreamlines = 4 * (int)qnumbersteamlines;
        streamlines = new VStreamLine[ (int)mNumStreamlines + 4 ];

        //from bottom to top
        for ( int j = 0; j <= qnumbersteamlines; j++ )
        {
        
                std::vector< VVector > streamlinevertices;
                
                bool outofdata = false;

                float offset = (float)( j + 1 ) / ( (float)qnumbersteamlines + 1.0f );

                //start bottom go the top
                float sactualpoint_x = offset - 0.5f * ( 1.0f / texsize_x );
                float sactualpoint_y = 0.0025f - 0.5f * ( 1.0f / texsize_y );
                
                VVector start_tex = VVector();
                start_tex.setX( sactualpoint_x  );
                start_tex.setY( sactualpoint_y  );

                VVector start_world = VVector( start_tex );
                
                //TODO:
                //convert to world space
                start_world.setX( -( start_world.getX() * dataextent_x ) + minx + dataextent_x);
                start_world.setY( ( start_world.getY() * dataextent_y ) + miny );
                streamlinevertices.push_back( start_world );

                for ( int i = 0; i <  MAXSTEPS * m_MaxSteps ; i++)
                {
                        if (outofdata ) break;


                        // transform texture coordinates sactualpint_x and sactualpoint_y into world coords
                        VVector arrayindex = VVector( texsize_x * sactualpoint_x, texsize_y * sactualpoint_y, 0.0f );
                        int xfloor = (int) ( arrayindex.getX() - 0.5f ) - 1;
                        int yfloor = (int) ( arrayindex.getY() - 0.5f ) - 1;
                        int xceil  = (int) ( arrayindex.getX() + 0.5f ) - 1;
                        int yceil  = (int) ( arrayindex.getY() + 0.5f ) - 1;

                        if ( xfloor < 0 || yfloor < 0 || xceil >= texsize_x || yceil >= texsize_x )
                        {
                                // we have reached the border;
                                outofdata = true;
                                break;
                        }
                        //fetch velocity at the actual position in world coordinates
                        
                        //floorx floorz
                        float velocity_x_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4     ];
                        float velocity_y_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 1 ];
                        float velocity_z_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 2 ];
                                                                
                        //floorx ceil           
                        float velocity_x_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4      ];
                        float velocity_y_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 1  ];
                        float velocity_z_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 2  ];
                                                                                   
                        //floorx floorz                            
                        float velocity_x_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4      ];
                        float velocity_y_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 1  ];
                        float velocity_z_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 2  ];
                                                                
                        //floorx floorz         
                        float velocity_x_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4      ];
                        float velocity_y_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 1  ];
                        float velocity_z_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 2  ];

                        float interpolval_x_L = ( arrayindex.getX() - xfloor ) * velocity_x_cf + ( xceil - arrayindex.getX() ) * velocity_x_ff;
                        float interpolval_y_L = ( arrayindex.getX() - xfloor ) * velocity_y_cf + ( xceil - arrayindex.getX() ) * velocity_y_ff;
                        float interpolval_z_L = ( arrayindex.getX() - xfloor ) * velocity_z_cf + ( xceil - arrayindex.getX() ) * velocity_z_ff;

                        float interpolval_x_H = ( arrayindex.getX() - xfloor ) * velocity_x_cc + ( xceil - arrayindex.getX() ) * velocity_x_fc;
                        float interpolval_y_H = ( arrayindex.getX() - xfloor ) * velocity_y_cc + ( xceil - arrayindex.getX() ) * velocity_y_fc;
                        float interpolval_z_H = ( arrayindex.getX() - xfloor ) * velocity_z_cc + ( xceil - arrayindex.getX() ) * velocity_z_fc;

                        float interpolval_x = ( arrayindex.getY() - yfloor ) * interpolval_x_H + ( yceil - arrayindex.getY() ) * interpolval_x_L;
                        float interpolval_y = ( arrayindex.getY() - yfloor ) * interpolval_y_H + ( yceil - arrayindex.getY() ) * interpolval_y_L;
                        float interpolval_z = ( arrayindex.getY() - yfloor ) * interpolval_z_H + ( yceil - arrayindex.getY() ) * interpolval_z_L;

                        VVector interpolatedval = VVector( interpolval_x, interpolval_y, interpolval_z );
                        VVector interp_mult = VVector( interpolatedval );
                        interp_mult.setX( -interp_mult.getX(  ) );
                        interp_mult *=  0.05f *mStreamlinesDt;

                        //VVector oldpos_world = mVertexToTexture.homogenTransform( VVector ( sactualpoint_x, sactualpoint_y, 0.0f ) );
                        VVector oldpos_world = VVector();
                        oldpos_world.setX( sactualpoint_x * dataextent_x + minx );
                        oldpos_world.setY( sactualpoint_y * dataextent_y + miny );

                        VVector newpos_world = oldpos_world + interp_mult;

                        VVector newpos_tex = VVector();
                        newpos_tex.setX( ( newpos_world.getX() - minx ) / dataextent_x );
                        newpos_tex.setY( ( newpos_world.getY() - miny ) / dataextent_y );

                        if(             ( newpos_tex.getX() ) > 1.0f || ( newpos_tex.getY() ) > 1.0f 
                                ||      ( newpos_tex.getX() ) < 0.0f || ( newpos_tex.getY() ) < 0.0f )
                        {
                                outofdata = true;
                                break;
                        }
                                
                        sactualpoint_x = newpos_tex.getX();
                        sactualpoint_y = newpos_tex.getY();

                        //TODO:
                        //convert to world space
                        newpos_tex.setX( -( newpos_tex.getX() * dataextent_x ) + minx + dataextent_x);
                        newpos_tex.setY( ( newpos_tex.getY() * dataextent_y ) + miny );
                        streamlinevertices.push_back( newpos_tex );

                        //if the streamline reached the sink
                        float epsilon = 0.0000001f;
                        VVector posdifference = streamlinevertices[ streamlinevertices.size() - 1 ] - streamlinevertices[ streamlinevertices.size() - 2 ];
                        if ( posdifference.getMagnitude() < epsilon)
                        {
                                outofdata = true;
                                break;
                        }

                }
                if( !streamlinevertices.empty() ) 
                {
                        streamlines[ j ] = VStreamLine( streamlinevertices ) ;
                        streamlines[ j ].regenerateVBO();
                }
        }

        //from left to right
        for ( int j = 0; j <= qnumbersteamlines; j++ )
        {
        
                std::vector< VVector > streamlinevertices;
                
                bool outofdata = false;

                float offset = (float)( j + 1 ) / ( (float)qnumbersteamlines + 1.0f );

                // start left go to right
                float sactualpoint_y = offset - 0.5f * ( 1.0f / texsize_x );
                float sactualpoint_x = 0.0025f - 0.5f * ( 1.0f / texsize_x );
                
                VVector start_tex = VVector();
                start_tex.setX( sactualpoint_x  );
                start_tex.setY( sactualpoint_y  );

                VVector start_world = VVector( start_tex );
                
                //TODO:
                //convert to world space
                start_world.setX( -( start_world.getX() * dataextent_x ) + minx + dataextent_x);
                start_world.setY( ( start_world.getY() * dataextent_y ) + miny );
                streamlinevertices.push_back( start_world );

                for ( int i = 0; i <  MAXSTEPS * m_MaxSteps ; i++)
                {
                        if (outofdata ) break;

                        // transform texture coordinates sactualpint_x and sactualpoint_y into world coords
                        VVector arrayindex = VVector( texsize_x * sactualpoint_x, texsize_y * sactualpoint_y, 0.0f );
                        int xfloor = (int) ( arrayindex.getX() - 0.5f ) - 1;
                        int yfloor = (int) ( arrayindex.getY() - 0.5f ) - 1;
                        int xceil  = (int) ( arrayindex.getX() + 0.5f ) - 1;
                        int yceil  = (int) ( arrayindex.getY() + 0.5f ) - 1;

                        if ( xfloor < 0 || yfloor < 0 || xceil >= texsize_x || yceil >= texsize_x )
                        {
                                // we have reached the border;
                                outofdata = true;
                                break;
                        }
                        //fetch velocity at the actual position in world coordinates
                        
                        //floorx floorz
                        float velocity_x_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4     ];
                        float velocity_y_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 1 ];
                        float velocity_z_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 2 ];
                                                                
                        //floorx ceil           
                        float velocity_x_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4      ];
                        float velocity_y_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 1  ];
                        float velocity_z_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 2  ];
                                                                                   
                        //floorx floorz                            
                        float velocity_x_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4      ];
                        float velocity_y_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 1  ];
                        float velocity_z_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 2  ];
                                                                
                        //floorx floorz         
                        float velocity_x_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4      ];
                        float velocity_y_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 1  ];
                        float velocity_z_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 2  ];

                        float interpolval_x_L = ( arrayindex.getX() - xfloor ) * velocity_x_cf + ( xceil - arrayindex.getX() ) * velocity_x_ff;
                        float interpolval_y_L = ( arrayindex.getX() - xfloor ) * velocity_y_cf + ( xceil - arrayindex.getX() ) * velocity_y_ff;
                        float interpolval_z_L = ( arrayindex.getX() - xfloor ) * velocity_z_cf + ( xceil - arrayindex.getX() ) * velocity_z_ff;

                        float interpolval_x_H = ( arrayindex.getX() - xfloor ) * velocity_x_cc + ( xceil - arrayindex.getX() ) * velocity_x_fc;
                        float interpolval_y_H = ( arrayindex.getX() - xfloor ) * velocity_y_cc + ( xceil - arrayindex.getX() ) * velocity_y_fc;
                        float interpolval_z_H = ( arrayindex.getX() - xfloor ) * velocity_z_cc + ( xceil - arrayindex.getX() ) * velocity_z_fc;

                        float interpolval_x = ( arrayindex.getY() - yfloor ) * interpolval_x_H + ( yceil - arrayindex.getY() ) * interpolval_x_L;
                        float interpolval_y = ( arrayindex.getY() - yfloor ) * interpolval_y_H + ( yceil - arrayindex.getY() ) * interpolval_y_L;
                        float interpolval_z = ( arrayindex.getY() - yfloor ) * interpolval_z_H + ( yceil - arrayindex.getY() ) * interpolval_z_L;

                        VVector interpolatedval = VVector( interpolval_x, interpolval_y, interpolval_z );
                        VVector interp_mult = VVector( interpolatedval );
                        interp_mult.setX( -interp_mult.getX(  ) );
                        interp_mult *=  0.05f *mStreamlinesDt;

                        //VVector oldpos_world = mVertexToTexture.homogenTransform( VVector ( sactualpoint_x, sactualpoint_y, 0.0f ) );
                        VVector oldpos_world = VVector();
                        oldpos_world.setX( sactualpoint_x * dataextent_x + minx );
                        oldpos_world.setY( sactualpoint_y * dataextent_y + miny );

                        VVector newpos_world = oldpos_world + interp_mult;

                        VVector newpos_tex = VVector();
                        newpos_tex.setX( ( newpos_world.getX() - minx ) / dataextent_x );
                        newpos_tex.setY( ( newpos_world.getY() - miny ) / dataextent_y );

                        if(             ( newpos_tex.getX() ) > 1.0f || ( newpos_tex.getY() ) > 1.0f 
                                ||      ( newpos_tex.getX() ) < 0.0f || ( newpos_tex.getY() ) < 0.0f )
                        {
                                outofdata = true;
                                break;
                        }
                                
                        sactualpoint_x = newpos_tex.getX();
                        sactualpoint_y = newpos_tex.getY();

                        //TODO:
                        //convert to world space
                        newpos_tex.setX( -( newpos_tex.getX() * dataextent_x ) + minx + dataextent_x);
                        newpos_tex.setY( ( newpos_tex.getY() * dataextent_y ) + miny );
                        streamlinevertices.push_back( newpos_tex );

                        //if the streamline reached the sink
                        float epsilon = 0.0000001f;
                        VVector posdifference = streamlinevertices[ streamlinevertices.size() - 1 ] - streamlinevertices[ streamlinevertices.size() - 2 ];
                        if ( posdifference.getMagnitude() < epsilon)
                        {
                                outofdata = true;
                                break;
                        }

                }
                if( !streamlinevertices.empty() ) 
                {
                        streamlines[ j + (int)qnumbersteamlines ] = VStreamLine( streamlinevertices ) ;
                        streamlines[ j + (int)qnumbersteamlines ].regenerateVBO();
                }
        }

        //start top to bottom
        for ( int j = 0; j <= qnumbersteamlines; j++ )
        {
        
                std::vector< VVector > streamlinevertices;
                
                bool outofdata = false;

                float offset = (float)( j + 1 ) / ( (float)qnumbersteamlines + 1.0f );

                //start top go the bottom
                float sactualpoint_x = offset - 0.5f * ( 1.0f / texsize_x );
                float sactualpoint_y = 1.0f - 0.5f * ( 1.0f / texsize_y );
                
                VVector start_tex = VVector();
                start_tex.setX( sactualpoint_x  );
                start_tex.setY( sactualpoint_y  );

                VVector start_world = VVector( start_tex );
                
                //TODO:
                //convert to world space
                start_world.setX( -( start_world.getX() * dataextent_x ) + minx + dataextent_x);
                start_world.setY( ( start_world.getY() * dataextent_y ) + miny );
                streamlinevertices.push_back( start_world );

                for ( int i = 0; i <  MAXSTEPS * m_MaxSteps ; i++)
                {
                        if (outofdata ) break;

                        // transform texture coordinates sactualpint_x and sactualpoint_y into world coords
                        VVector arrayindex = VVector( texsize_x * sactualpoint_x, texsize_y * sactualpoint_y, 0.0f );
                        int xfloor = (int) ( arrayindex.getX() - 0.5f ) - 1;
                        int yfloor = (int) ( arrayindex.getY() - 0.5f ) - 1;
                        int xceil  = (int) ( arrayindex.getX() + 0.5f ) - 1;
                        int yceil  = (int) ( arrayindex.getY() + 0.5f ) - 1;

                        if ( xfloor < 0 || yfloor < 0 || xceil >= texsize_x || yceil >= texsize_x )
                        {
                                // we have reached the border;
                                outofdata = true;
                                break;
                        }
                        //fetch velocity at the actual position in world coordinates
                        
                        //floorx floorz
                        float velocity_x_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4     ];
                        float velocity_y_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 1 ];
                        float velocity_z_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 2 ];
                                                                
                        //floorx ceil           
                        float velocity_x_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4      ];
                        float velocity_y_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 1  ];
                        float velocity_z_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 2  ];
                                                                                   
                        //floorx floorz                            
                        float velocity_x_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4      ];
                        float velocity_y_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 1  ];
                        float velocity_z_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 2  ];
                                                                
                        //floorx floorz         
                        float velocity_x_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4      ];
                        float velocity_y_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 1  ];
                        float velocity_z_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 2  ];

                        float interpolval_x_L = ( arrayindex.getX() - xfloor ) * velocity_x_cf + ( xceil - arrayindex.getX() ) * velocity_x_ff;
                        float interpolval_y_L = ( arrayindex.getX() - xfloor ) * velocity_y_cf + ( xceil - arrayindex.getX() ) * velocity_y_ff;
                        float interpolval_z_L = ( arrayindex.getX() - xfloor ) * velocity_z_cf + ( xceil - arrayindex.getX() ) * velocity_z_ff;

                        float interpolval_x_H = ( arrayindex.getX() - xfloor ) * velocity_x_cc + ( xceil - arrayindex.getX() ) * velocity_x_fc;
                        float interpolval_y_H = ( arrayindex.getX() - xfloor ) * velocity_y_cc + ( xceil - arrayindex.getX() ) * velocity_y_fc;
                        float interpolval_z_H = ( arrayindex.getX() - xfloor ) * velocity_z_cc + ( xceil - arrayindex.getX() ) * velocity_z_fc;

                        float interpolval_x = ( arrayindex.getY() - yfloor ) * interpolval_x_H + ( yceil - arrayindex.getY() ) * interpolval_x_L;
                        float interpolval_y = ( arrayindex.getY() - yfloor ) * interpolval_y_H + ( yceil - arrayindex.getY() ) * interpolval_y_L;
                        float interpolval_z = ( arrayindex.getY() - yfloor ) * interpolval_z_H + ( yceil - arrayindex.getY() ) * interpolval_z_L;

                        VVector interpolatedval = VVector( interpolval_x, interpolval_y, interpolval_z );
                        VVector interp_mult = VVector( interpolatedval );
                        interp_mult.setX( -interp_mult.getX(  ) );
                        interp_mult *=  0.05f *mStreamlinesDt;

                        //VVector oldpos_world = mVertexToTexture.homogenTransform( VVector ( sactualpoint_x, sactualpoint_y, 0.0f ) );
                        VVector oldpos_world = VVector();
                        oldpos_world.setX( sactualpoint_x * dataextent_x + minx );
                        oldpos_world.setY( sactualpoint_y * dataextent_y + miny );

                        VVector newpos_world = oldpos_world + interp_mult;

                        VVector newpos_tex = VVector();
                        newpos_tex.setX( ( newpos_world.getX() - minx ) / dataextent_x );
                        newpos_tex.setY( ( newpos_world.getY() - miny ) / dataextent_y );

                        if(             ( newpos_tex.getX() ) > 1.0f || ( newpos_tex.getY() ) > 1.0f 
                                ||      ( newpos_tex.getX() ) < 0.0f || ( newpos_tex.getY() ) < 0.0f )
                        {
                                outofdata = true;
                                break;
                        }
                                
                        sactualpoint_x = newpos_tex.getX();
                        sactualpoint_y = newpos_tex.getY();

                        //TODO:
                        //convert to world space
                        newpos_tex.setX( -( newpos_tex.getX() * dataextent_x ) + minx + dataextent_x);
                        newpos_tex.setY( ( newpos_tex.getY() * dataextent_y ) + miny );
                        streamlinevertices.push_back( newpos_tex );

                        //if the streamline reached the sink
                        float epsilon = 0.0000001f;
                        VVector posdifference = streamlinevertices[ streamlinevertices.size() - 1 ] - streamlinevertices[ streamlinevertices.size() - 2 ];
                        if ( posdifference.getMagnitude() < epsilon)
                        {
                                outofdata = true;
                                break;
                        }

                }
                if( !streamlinevertices.empty() ) 
                {
                        streamlines[ j + 2 * (int)qnumbersteamlines ] = VStreamLine( streamlinevertices ) ;
                        streamlines[ j + 2 * (int)qnumbersteamlines ].regenerateVBO();
                }
        }
        
        //start right go the left
        for ( int j = 0; j <= qnumbersteamlines; j++ )
        {
        
                std::vector< VVector > streamlinevertices;
                
                bool outofdata = false;

                float offset = (float)( j + 1 ) / ( (float)qnumbersteamlines + 1.0f );

                //start right go the left
                float sactualpoint_y = offset - 0.5f * ( 1.0f / texsize_y );
                float sactualpoint_x = 1.0f - 0.5f * ( 1.0f / texsize_x );
                
                VVector start_tex = VVector();
                start_tex.setX( sactualpoint_x  );
                start_tex.setY( sactualpoint_y  );

                VVector start_world = VVector( start_tex );
                
                //TODO:
                //convert to world space
                start_world.setX( -( start_world.getX() * dataextent_x ) + minx + dataextent_x);
                start_world.setY( ( start_world.getY() * dataextent_y ) + miny );
                streamlinevertices.push_back( start_world );

                for ( int i = 0; i <  MAXSTEPS * m_MaxSteps ; i++)
                {
                        if (outofdata ) break;

                        // transform texture coordinates sactualpint_x and sactualpoint_y into world coords
                        VVector arrayindex = VVector( texsize_x * sactualpoint_x, texsize_y * sactualpoint_y, 0.0f );
                        int xfloor = (int) ( arrayindex.getX() - 0.5f ) - 1;
                        int yfloor = (int) ( arrayindex.getY() - 0.5f ) - 1;
                        int xceil  = (int) ( arrayindex.getX() + 0.5f ) - 1;
                        int yceil  = (int) ( arrayindex.getY() + 0.5f ) - 1;

                        if ( xfloor < 0 || yfloor < 0 || xceil >= texsize_x || yceil >= texsize_x )
                        {
                                // we have reached the border;
                                outofdata = true;
                                break;
                        }
                        //fetch velocity at the actual position in world coordinates
                        
                        //floorx floorz
                        float velocity_x_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4     ];
                        float velocity_y_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 1 ];
                        float velocity_z_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 2 ];
                                                                
                        //floorx ceil           
                        float velocity_x_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4      ];
                        float velocity_y_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 1  ];
                        float velocity_z_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 2  ];
                                                                                   
                        //floorx floorz                            
                        float velocity_x_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4      ];
                        float velocity_y_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 1  ];
                        float velocity_z_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 2  ];
                                                                
                        //floorx floorz         
                        float velocity_x_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4      ];
                        float velocity_y_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 1  ];
                        float velocity_z_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 2  ];

                        float interpolval_x_L = ( arrayindex.getX() - xfloor ) * velocity_x_cf + ( xceil - arrayindex.getX() ) * velocity_x_ff;
                        float interpolval_y_L = ( arrayindex.getX() - xfloor ) * velocity_y_cf + ( xceil - arrayindex.getX() ) * velocity_y_ff;
                        float interpolval_z_L = ( arrayindex.getX() - xfloor ) * velocity_z_cf + ( xceil - arrayindex.getX() ) * velocity_z_ff;

                        float interpolval_x_H = ( arrayindex.getX() - xfloor ) * velocity_x_cc + ( xceil - arrayindex.getX() ) * velocity_x_fc;
                        float interpolval_y_H = ( arrayindex.getX() - xfloor ) * velocity_y_cc + ( xceil - arrayindex.getX() ) * velocity_y_fc;
                        float interpolval_z_H = ( arrayindex.getX() - xfloor ) * velocity_z_cc + ( xceil - arrayindex.getX() ) * velocity_z_fc;

                        float interpolval_x = ( arrayindex.getY() - yfloor ) * interpolval_x_H + ( yceil - arrayindex.getY() ) * interpolval_x_L;
                        float interpolval_y = ( arrayindex.getY() - yfloor ) * interpolval_y_H + ( yceil - arrayindex.getY() ) * interpolval_y_L;
                        float interpolval_z = ( arrayindex.getY() - yfloor ) * interpolval_z_H + ( yceil - arrayindex.getY() ) * interpolval_z_L;

                        VVector interpolatedval = VVector( interpolval_x, interpolval_y, interpolval_z );
                        VVector interp_mult = VVector( interpolatedval );
                        interp_mult.setX( -interp_mult.getX(  ) );
                        interp_mult *=  0.05f *mStreamlinesDt;

                        //VVector oldpos_world = mVertexToTexture.homogenTransform( VVector ( sactualpoint_x, sactualpoint_y, 0.0f ) );
                        VVector oldpos_world = VVector();
                        oldpos_world.setX( sactualpoint_x * dataextent_x + minx );
                        oldpos_world.setY( sactualpoint_y * dataextent_y + miny );

                        VVector newpos_world = oldpos_world + interp_mult;

                        VVector newpos_tex = VVector();
                        newpos_tex.setX( ( newpos_world.getX() - minx ) / dataextent_x );
                        newpos_tex.setY( ( newpos_world.getY() - miny ) / dataextent_y );

                        if(             ( newpos_tex.getX() ) > 1.0f || ( newpos_tex.getY() ) > 1.0f 
                                ||      ( newpos_tex.getX() ) < 0.0f || ( newpos_tex.getY() ) < 0.0f )
                        {
                                outofdata = true;
                                break;
                        }
                                
                        sactualpoint_x = newpos_tex.getX();
                        sactualpoint_y = newpos_tex.getY();

                        //TODO:
                        //convert to world space
                        newpos_tex.setX( -( newpos_tex.getX() * dataextent_x ) + minx + dataextent_x);
                        newpos_tex.setY( ( newpos_tex.getY() * dataextent_y ) + miny );
                        streamlinevertices.push_back( newpos_tex );

                        //if the streamline reached the sink
                        float epsilon = 0.0000001f;
                        VVector posdifference = streamlinevertices[ streamlinevertices.size() - 1 ] - streamlinevertices[ streamlinevertices.size() - 2 ];
                        if ( posdifference.getMagnitude() < epsilon)
                        {
                                outofdata = true;
                                break;
                        }

                }
                if( !streamlinevertices.empty() ) 
                {
                        streamlines[ j + 3 * (int)qnumbersteamlines ] = VStreamLine( streamlinevertices ) ;
                        streamlines[ j + 3 * (int)qnumbersteamlines ].regenerateVBO();
                }
        }


        //delete pixeldata;
        pixeldata.clear();

}

void VFlowData::generateCPUStreamLinesRANDOM( float m_MaxSteps, float m_StreamSeparation, int m_TimeStep /* = 0  */ )
{
        if( mNumStreamlines != 0 )
        {
                if ( streamlines )
                {
                        delete[] streamlines;
                        streamlines = NULL;
                        mNumStreamlines = 0;
                }
        }
        //float *pixeldata; // velocoty texture
        std::vector< float > pixeldata;

        int texsize_x, texsize_y;

        float dataextent_x, dataextent_y;
        float datacenter_x, datacenter_y;
        float minx, miny;

        dataextent_x = mExtends.getX();
        dataextent_y = mExtends.getY();
        datacenter_x = mCenterPos.getX();
        datacenter_y = mCenterPos.getY();
        minx = mMinPos.getX();
        miny = mMinPos.getY();

        float keepratiox = ( dataextent_x > dataextent_y ) ? 1.0f  : dataextent_x / dataextent_y;
        float keepratioy = ( dataextent_y > dataextent_x ) ? 1.0f  : dataextent_y / dataextent_x;

        // generate seedpoints in texture coordinates
        float numbersteamlines = MINNUMBER +  ( 1.0f - m_StreamSeparation ) * ( MAXNUMBER - MINNUMBER );
        float spacing = 1.0f / numbersteamlines ;

        pixeldata = mTimeSteps[m_TimeStep].getFullFBODataVector();
        texsize_x = mTimeSteps[m_TimeStep].mFrameBufferObject->getWidth();
        texsize_y = mTimeSteps[m_TimeStep].mFrameBufferObject->getHeight();

        int size = (int)pixeldata.size();

        
        // for all streamlines
        mNumStreamlines = (int)numbersteamlines;
        streamlines = new VStreamLine[ (int)numbersteamlines + 1 ];

        srand ( time(NULL) );;

        for ( int j = 0; j < numbersteamlines; j++ )
        {
                float randomf[ 2 ];
                randomf[ 0 ] = ( float )( rand(  ) % 10000 + 1 ) / 10000.0f;
                randomf[ 1 ] = ( float )( rand(  ) % 10000 + 1 ) / 10000.0f;

                std::vector< VVector > streamlinevertices;
                
                bool outofdata = false;

                float sactualpoint_x = randomf[ 0 ];
                float sactualpoint_y = randomf[ 1 ];

                VVector start_tex = VVector();
                start_tex.setX( sactualpoint_x  );
                start_tex.setY( sactualpoint_y  );

                VVector start_world = VVector( start_tex );
                
                //TODO:
                //convert to world space
                start_world.setX( -( start_world.getX() * dataextent_x ) + minx + dataextent_x);
                start_world.setY( ( start_world.getY() * dataextent_y ) + miny );
                streamlinevertices.push_back( start_world );

                for ( int i = 0; i <  MAXSTEPS * m_MaxSteps ; i++)
                {
                        if (outofdata ) break;

                        // transform texture coordinates sactualpint_x and sactualpoint_y into world coords
                        VVector arrayindex = VVector( texsize_x * sactualpoint_x, texsize_y * sactualpoint_y, 0.0f );
                        int xfloor = (int) ( arrayindex.getX() - 0.5f ) - 1;
                        int yfloor = (int) ( arrayindex.getY() - 0.5f ) - 1;
                        int xceil  = (int) ( arrayindex.getX() + 0.5f ) - 1;
                        int yceil  = (int) ( arrayindex.getY() + 0.5f ) - 1;

                        if ( xfloor < 0 || yfloor < 0 || xceil >= texsize_x || yceil >= texsize_x )
                        {
                                // we have reached the border;
                                outofdata = true;
                                break;
                        }
                        //fetch velocity at the actual position in world coordinates
                        
                        //floorx floorz
                        float velocity_x_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4     ];
                        float velocity_y_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 1 ];
                        float velocity_z_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 2 ];
                                                                
                        //floorx ceil           
                        float velocity_x_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4      ];
                        float velocity_y_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 1  ];
                        float velocity_z_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 2  ];
                                                                                   
                        //floorx floorz                            
                        float velocity_x_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4      ];
                        float velocity_y_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 1  ];
                        float velocity_z_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 2  ];
                                                                
                        //floorx floorz         
                        float velocity_x_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4      ];
                        float velocity_y_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 1  ];
                        float velocity_z_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 2  ];

                        float interpolval_x_L = ( arrayindex.getX() - xfloor ) * velocity_x_cf + ( xceil - arrayindex.getX() ) * velocity_x_ff;
                        float interpolval_y_L = ( arrayindex.getX() - xfloor ) * velocity_y_cf + ( xceil - arrayindex.getX() ) * velocity_y_ff;
                        float interpolval_z_L = ( arrayindex.getX() - xfloor ) * velocity_z_cf + ( xceil - arrayindex.getX() ) * velocity_z_ff;

                        float interpolval_x_H = ( arrayindex.getX() - xfloor ) * velocity_x_cc + ( xceil - arrayindex.getX() ) * velocity_x_fc;
                        float interpolval_y_H = ( arrayindex.getX() - xfloor ) * velocity_y_cc + ( xceil - arrayindex.getX() ) * velocity_y_fc;
                        float interpolval_z_H = ( arrayindex.getX() - xfloor ) * velocity_z_cc + ( xceil - arrayindex.getX() ) * velocity_z_fc;

                        float interpolval_x = ( arrayindex.getY() - yfloor ) * interpolval_x_H + ( yceil - arrayindex.getY() ) * interpolval_x_L;
                        float interpolval_y = ( arrayindex.getY() - yfloor ) * interpolval_y_H + ( yceil - arrayindex.getY() ) * interpolval_y_L;
                        float interpolval_z = ( arrayindex.getY() - yfloor ) * interpolval_z_H + ( yceil - arrayindex.getY() ) * interpolval_z_L;

                        VVector interpolatedval = VVector( interpolval_x, interpolval_y, interpolval_z );
                        VVector interp_mult = VVector( interpolatedval );
                        interp_mult.setX( -interp_mult.getX(  ) );
                        interp_mult *=  0.05f *mStreamlinesDt;

                        //VVector oldpos_world = mVertexToTexture.homogenTransform( VVector ( sactualpoint_x, sactualpoint_y, 0.0f ) );
                        VVector oldpos_world = VVector();
                        oldpos_world.setX( sactualpoint_x * dataextent_x + minx );
                        oldpos_world.setY( sactualpoint_y * dataextent_y + miny );

                        VVector newpos_world = oldpos_world + interp_mult;

                        VVector newpos_tex = VVector();
                        newpos_tex.setX( ( newpos_world.getX() - minx ) / dataextent_x );
                        newpos_tex.setY( ( newpos_world.getY() - miny ) / dataextent_y );

                        if(             ( newpos_tex.getX() ) > 1.0f || ( newpos_tex.getY() ) > 1.0f 
                                ||      ( newpos_tex.getX() ) < 0.0f || ( newpos_tex.getY() ) < 0.0f )
                        {
                                outofdata = true;
                                break;
                        }
                                
                        sactualpoint_x = newpos_tex.getX();
                        sactualpoint_y = newpos_tex.getY();

                        //TODO:
                        //convert to world space
                        newpos_tex.setX( -( newpos_tex.getX() * dataextent_x ) + minx + dataextent_x);
                        newpos_tex.setY( ( newpos_tex.getY() * dataextent_y ) + miny );
                        streamlinevertices.push_back( newpos_tex );

                        float epsilon = 0.0000001f;
                        VVector posdifference = streamlinevertices[ streamlinevertices.size() - 1 ] - streamlinevertices[ streamlinevertices.size() - 2 ];
                        if ( posdifference.getMagnitude() < epsilon)
                        {
                                outofdata = true;
                                break;
                        }

                }

                //revert the streamline poitns vector and ocntinue in the opposite direction
                if( !streamlinevertices.empty() ) 
                {
                        std::vector< VVector > _streamlinesvertices;
                        for( int k = 0; k < streamlinevertices.size(); k++)
                        {
                                _streamlinesvertices.push_back( streamlinevertices[ streamlinevertices.size() - k - 1 ] );
                                
                        }

                        streamlinevertices.clear();
                        streamlinevertices.swap( _streamlinesvertices );
                        _streamlinesvertices.clear();
                }
                

                sactualpoint_x = randomf[ 0 ];
                sactualpoint_y = randomf[ 1 ];

                outofdata = false;

                //and go to the opposite direction
                for ( int i = 0; i <  MAXSTEPS * m_MaxSteps ; i++)
                {
                        if (outofdata ) break;

                        
                        // transform texture coordinates sactualpint_x and sactualpoint_y into world coords
                        VVector arrayindex = VVector( texsize_x * sactualpoint_x, texsize_y * sactualpoint_y, 0.0f );
                        int xfloor = (int) ( arrayindex.getX() - 0.5f ) - 1;
                        int yfloor = (int) ( arrayindex.getY() - 0.5f ) - 1;
                        int xceil  = (int) ( arrayindex.getX() + 0.5f ) - 1;
                        int yceil  = (int) ( arrayindex.getY() + 0.5f ) - 1;

                        if ( xfloor < 0 || yfloor < 0 || xceil >= texsize_x || yceil >= texsize_x )
                        {
                                // we have reached the border;
                                outofdata = true;
                                break;
                        }
                        //fetch velocity at the actual position in world coordinates
                        
                        //floorx floorz
                        float velocity_x_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4     ];
                        float velocity_y_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 1 ];
                        float velocity_z_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 2 ];
                                                                
                        //floorx ceil           
                        float velocity_x_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4      ];
                        float velocity_y_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 1  ];
                        float velocity_z_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 2  ];
                                                                                   
                        //floorx floorz                            
                        float velocity_x_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4      ];
                        float velocity_y_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 1  ];
                        float velocity_z_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 2  ];
                                                                
                        //floorx floorz         
                        float velocity_x_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4      ];
                        float velocity_y_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 1  ];
                        float velocity_z_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 2  ];

                        float interpolval_x_L = ( arrayindex.getX() - xfloor ) * velocity_x_cf + ( xceil - arrayindex.getX() ) * velocity_x_ff;
                        float interpolval_y_L = ( arrayindex.getX() - xfloor ) * velocity_y_cf + ( xceil - arrayindex.getX() ) * velocity_y_ff;
                        float interpolval_z_L = ( arrayindex.getX() - xfloor ) * velocity_z_cf + ( xceil - arrayindex.getX() ) * velocity_z_ff;

                        float interpolval_x_H = ( arrayindex.getX() - xfloor ) * velocity_x_cc + ( xceil - arrayindex.getX() ) * velocity_x_fc;
                        float interpolval_y_H = ( arrayindex.getX() - xfloor ) * velocity_y_cc + ( xceil - arrayindex.getX() ) * velocity_y_fc;
                        float interpolval_z_H = ( arrayindex.getX() - xfloor ) * velocity_z_cc + ( xceil - arrayindex.getX() ) * velocity_z_fc;

                        float interpolval_x = ( arrayindex.getY() - yfloor ) * interpolval_x_H + ( yceil - arrayindex.getY() ) * interpolval_x_L;
                        float interpolval_y = ( arrayindex.getY() - yfloor ) * interpolval_y_H + ( yceil - arrayindex.getY() ) * interpolval_y_L;
                        float interpolval_z = ( arrayindex.getY() - yfloor ) * interpolval_z_H + ( yceil - arrayindex.getY() ) * interpolval_z_L;

                        VVector interpolatedval = VVector( interpolval_x, interpolval_y, interpolval_z );
                        VVector interp_mult = VVector( interpolatedval );
                        interp_mult.setX( -interp_mult.getX(  ) );
                        interp_mult *=  0.05f *mStreamlinesDt;

                        //VVector oldpos_world = mVertexToTexture.homogenTransform( VVector ( sactualpoint_x, sactualpoint_y, 0.0f ) );
                        VVector oldpos_world = VVector();
                        oldpos_world.setX( sactualpoint_x * dataextent_x + minx );
                        oldpos_world.setY( sactualpoint_y * dataextent_y + miny );

                        VVector newpos_world = oldpos_world - interp_mult;

                        VVector newpos_tex = VVector();
                        newpos_tex.setX( ( newpos_world.getX() - minx ) / dataextent_x );
                        newpos_tex.setY( ( newpos_world.getY() - miny ) / dataextent_y );

                        if(             ( newpos_tex.getX() ) > 1.0f || ( newpos_tex.getY() ) > 1.0f 
                                ||      ( newpos_tex.getX() ) < 0.0f || ( newpos_tex.getY() ) < 0.0f )
                        {
                                outofdata = true;
                                break;
                        }
                                
                        sactualpoint_x = newpos_tex.getX();
                        sactualpoint_y = newpos_tex.getY();

                        //TODO:
                        //convert to world space
                        newpos_tex.setX( -( newpos_tex.getX() * dataextent_x ) + minx + dataextent_x);
                        newpos_tex.setY( ( newpos_tex.getY() * dataextent_y ) + miny );
                        streamlinevertices.push_back( newpos_tex );

                        float epsilon = 0.0000001f;
                        VVector posdifference = streamlinevertices[ streamlinevertices.size() - 1 ] - streamlinevertices[ streamlinevertices.size() - 2 ];
                        if ( posdifference.getMagnitude() < epsilon)
                        {
                                outofdata = true;
                                break;
                        }

                }
                if( !streamlinevertices.empty() ) 
                {
                        streamlines[ j ] = VStreamLine( streamlinevertices ) ;
                        streamlines[ j ].regenerateVBO();
                }
        }
        
        //delete pixeldata;
        pixeldata.clear();
}
void VFlowData::generateCPUStreamLinesMANUAL( float m_MaxSteps, float m_StreamSeparation, int m_TimeStep /* = 0  */ )
{
        drawStreamlinesFromSeedpoints( m_TimeStep, m_MaxSteps  );
}

void VFlowData::generateCPUStreamLinesEVEN( float m_MaxSteps, float m_StreamSeparation, int m_TimeStep /* = 0  */ )
{
        //create a streamline in the middle
        //input x, y world returns a vector of points

        if( mNumStreamlines != 0 )
        {
                if ( streamlines )
                {
                        delete[] streamlines;
                        streamlines = NULL;
                        mNumStreamlines = 0;
                }
        }
        
        float dataextent_x = mExtends.getX();
        float dataextent_y = mExtends.getY();
        float datacenter_x = mCenterPos.getX();
        float datacenter_y = mCenterPos.getY();
        float minx = mMinPos.getX();
        float miny = mMinPos.getY();

        

        std::deque< VStreamLine > squeue;
        std::vector< VStreamLine > svector;

        //squeue.resize( 100 ); 
        //svector.resize( 100 );

        float dsep = 0.25f * mStreamlinesSeedSeparation * min( dataextent_x, dataextent_y ) ;
        float dtest = 0.25f * mStreamlinesTestSeparation * min( dataextent_x, dataextent_y ) ;

        squeue.resize( 1 ); 
        svector.resize( 1 );
        std::vector< float > thickness0;
        VStreamLine s0 = VStreamLine( generateCPUStreamSingleWithoutTests( datacenter_x , datacenter_y, dtest, m_MaxSteps, m_TimeStep ) );
        squeue[ 0 ] =  s0;
        svector[ 0 ] = s0;


        std::vector< VVector > candidateseeds;

        int cnt = 1;
        while( !squeue.empty() )
        {
                VStreamLine _s = squeue[ 0 ];
                squeue.pop_front();
                std::cout << "flushing streamline" << std::endl;

                candidateseeds = _s.getCandidateSeeds( dsep );

                if ( candidateseeds.empty() ) continue;

                for( int i  = 0; i < candidateseeds.size(); i++ )
                {
                        VVector seed = candidateseeds[ i ];

                        bool isseedvalid = true;

                        for( int i  = 0; i < svector.size(); i++ )
                        {
                                isseedvalid = svector[ i ].isPointAllowed( seed, dtest );
                                if ( !isseedvalid ) break;
                        }

                        if( isseedvalid )
                        {
                                std::vector< float > thickness1;
                                VStreamLine s1 = VStreamLine( generateCPUStreamSingleWithTests( svector, seed.getX() , seed.getY(), dtest,  m_MaxSteps, m_TimeStep ) );
                                
                                int linesize = s1.getNumberOfPoints();

                                if ( linesize < 5 )
                                {
                                        std::cout << "streamline too short" << std::endl;
                                        continue;
                                }

                                std::cout << "new streamline added" << std::endl;
                                cnt++;
                        
                                squeue.push_back(  s1 );
                                svector.push_back(  s1 );
                        }
                        
                }
        }       

        
        mNumStreamlines = cnt;
        streamlines = new VStreamLine[ mNumStreamlines ];

        
        for( int j  = 0 ; j < mNumStreamlines; j++)
        {
                streamlines[ j ] = svector[ j ];
                streamlines[ j ].setSeparation( dsep, dtest );
                std::cout << "Computing tapering coef for streamline "<< j << " out of " << mNumStreamlines<<"!" << std::endl;
                streamlines[ j ].computeThicknessCoefficients( dtest, dsep, svector, j, max ( dataextent_x, dataextent_y ) );
                std::cout << "Computing tapering coef for streamline "<< j << " out of " << mNumStreamlines<<" is done!" << std::endl;
                streamlines[ j ].regenerateVBO();

        }

        squeue.clear();
        svector.clear();

}

std::vector<VVector> VFlowData::generateCPUStreamSingleWithoutTests( float xw, float yw, float dtest, float m_MaxSteps, 
                                                                                                                                        int m_TimeStep /* = 0  */)
{

        std::vector<VVector> spoints;

        std::vector< float > pixeldata;

        int texsize_x, texsize_y;

        float dataextent_x, dataextent_y;
        float datacenter_x, datacenter_y;
        float minx, miny;

        dataextent_x = mExtends.getX();
        dataextent_y = mExtends.getY();
        datacenter_x = mCenterPos.getX();
        datacenter_y = mCenterPos.getY();
        minx = mMinPos.getX();
        miny = mMinPos.getY();

        pixeldata = mTimeSteps[m_TimeStep].getFullFBODataVector();
        texsize_x = mTimeSteps[m_TimeStep].mFrameBufferObject->getWidth();
        texsize_y = mTimeSteps[m_TimeStep].mFrameBufferObject->getHeight();

        int size = (int)pixeldata.size();


        bool outofdata = false;
        bool selfcross = false;

        float sactualpoint_x =  1.0 - (  xw - minx  ) / dataextent_x;
        float sactualpoint_y = ( yw - miny ) / dataextent_y;

        VVector start_world = VVector( xw, yw, 0.0f );
        spoints.push_back( start_world );
//      vthickness->push_back( dtest );

        for ( int i = 0; i <  MAXSTEPS * m_MaxSteps ; i++)
        {
                if ( outofdata ) break;
                if ( selfcross ) break;

                // transform texture coordinates sactualpint_x and sactualpoint_y into world coords
                VVector arrayindex = VVector( texsize_x * sactualpoint_x, texsize_y * sactualpoint_y, 0.0f );
                int xfloor = (int) ( arrayindex.getX() - 0.5f ) - 1;
                int yfloor = (int) ( arrayindex.getY() - 0.5f ) - 1;
                int xceil  = (int) ( arrayindex.getX() + 0.5f ) - 1;
                int yceil  = (int) ( arrayindex.getY() + 0.5f ) - 1;

                if ( xfloor < 0 || yfloor < 0 || xceil >= texsize_x || yceil >= texsize_x )
                {
                        // we have reached the border;
                        outofdata = true;
                        break;
                }
                //fetch velocity at the actual position in world coordinates
                
                //floorx floorz
                float velocity_x_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4     ];
                float velocity_y_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 1 ];
                float velocity_z_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 2 ];
                                                        
                //floorx ceil           
                float velocity_x_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4      ];
                float velocity_y_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 1  ];
                float velocity_z_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 2  ];
                                                                           
                //floorx floorz                            
                float velocity_x_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4      ];
                float velocity_y_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 1  ];
                float velocity_z_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 2  ];
                                                        
                //floorx floorz         
                float velocity_x_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4      ];
                float velocity_y_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 1  ];
                float velocity_z_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 2  ];

                float interpolval_x_L = ( arrayindex.getX() - xfloor ) * velocity_x_cf + ( xceil - arrayindex.getX() ) * velocity_x_ff;
                float interpolval_y_L = ( arrayindex.getX() - xfloor ) * velocity_y_cf + ( xceil - arrayindex.getX() ) * velocity_y_ff;
                float interpolval_z_L = ( arrayindex.getX() - xfloor ) * velocity_z_cf + ( xceil - arrayindex.getX() ) * velocity_z_ff;

                float interpolval_x_H = ( arrayindex.getX() - xfloor ) * velocity_x_cc + ( xceil - arrayindex.getX() ) * velocity_x_fc;
                float interpolval_y_H = ( arrayindex.getX() - xfloor ) * velocity_y_cc + ( xceil - arrayindex.getX() ) * velocity_y_fc;
                float interpolval_z_H = ( arrayindex.getX() - xfloor ) * velocity_z_cc + ( xceil - arrayindex.getX() ) * velocity_z_fc;

                float interpolval_x = ( arrayindex.getY() - yfloor ) * interpolval_x_H + ( yceil - arrayindex.getY() ) * interpolval_x_L;
                float interpolval_y = ( arrayindex.getY() - yfloor ) * interpolval_y_H + ( yceil - arrayindex.getY() ) * interpolval_y_L;
                float interpolval_z = ( arrayindex.getY() - yfloor ) * interpolval_z_H + ( yceil - arrayindex.getY() ) * interpolval_z_L;

                VVector interpolatedval = VVector( interpolval_x, interpolval_y, interpolval_z );
                VVector interp_mult = VVector( interpolatedval );
                interp_mult.setX( -interp_mult.getX(  ) );
                interp_mult.normalize();
                interp_mult *=  0.05f *mStreamlinesDt;

                //VVector oldpos_world = mVertexToTexture.homogenTransform( VVector ( sactualpoint_x, sactualpoint_y, 0.0f ) );
                VVector oldpos_world = VVector();
                oldpos_world.setX( sactualpoint_x * dataextent_x + minx );
                oldpos_world.setY( sactualpoint_y * dataextent_y + miny );

                VVector newpos_world = oldpos_world + interp_mult;

                VVector newpos_tex = VVector();
                newpos_tex.setX( ( newpos_world.getX() - minx ) / dataextent_x );
                newpos_tex.setY( ( newpos_world.getY() - miny ) / dataextent_y );

                if(             ( newpos_tex.getX() ) > 1.0f || ( newpos_tex.getY() ) > 1.0f 
                        ||      ( newpos_tex.getX() ) < 0.0f || ( newpos_tex.getY() ) < 0.0f )
                {
                        outofdata = true;
                        break;
                }
                        
                sactualpoint_x = newpos_tex.getX();
                sactualpoint_y = newpos_tex.getY();

                //TODO:
                //convert to world space
                newpos_tex.setX( -( newpos_tex.getX() * dataextent_x ) + minx + dataextent_x);
                newpos_tex.setY( ( newpos_tex.getY() * dataextent_y ) + miny );

                // test for spirals and selfcollision

                float selfdistance = 200.0f * dtest;
                
                
                for (int h = (int)(200.0f); h < spoints.size(); h++ )
                //for (int h = (int)(100.0f / mStreamlinesDt); h < spoints.size(); h++ )
                {
                        VVector sp = spoints[ h - (int)(200.0f) ];
                        //VVector sp = spoints[ h - (int)(100.0f / mStreamlinesDt) ];
                        float pdistance = ( newpos_tex - sp ).getMagnitude();

                        if ( pdistance < selfdistance ) 
                        {
                                selfdistance = pdistance;
                        }

                        if ( pdistance < dtest ) 
                        {
                                selfcross = true;
                                break;
                        }
                        
                }

                if ( selfcross ) break;

                spoints.push_back( newpos_tex );
                //vthickness->push_back( selfdistance );

                float epsilon = 0.000000f;
                VVector posdifference = spoints[ spoints.size() - 1 ] - spoints[ spoints.size() - 2 ];
                if ( posdifference.getMagnitude() <= epsilon)
                {
                        outofdata = true;
                        break;
                }

        }

        //revert the streamline poitns vector and ocntinue in the opposite direction
        if( !spoints.empty() ) 
        {
                std::vector< VVector > _streamlinesvertices;
                for( int k = 0; k < spoints.size(); k++)
                {
                        _streamlinesvertices.push_back( spoints[ spoints.size() - k - 1 ] );
                        
                        
                }
                spoints.clear();
                spoints.swap( _streamlinesvertices );
                
        }
        

        sactualpoint_x =  1.0 - (  xw - minx  ) / dataextent_x;
        sactualpoint_y = ( yw - miny ) / dataextent_y;

        outofdata = false;
        selfcross = false;

        //and go to the opposite direction
        for ( int i = 0; i <  MAXSTEPS * m_MaxSteps ; i++)
        {
                if ( outofdata ) break;
                if ( selfcross ) break;

                
                // transform texture coordinates sactualpint_x and sactualpoint_y into world coords
                VVector arrayindex = VVector( texsize_x * sactualpoint_x, texsize_y * sactualpoint_y, 0.0f );
                int xfloor = (int) ( arrayindex.getX() - 0.5f ) - 1;
                int yfloor = (int) ( arrayindex.getY() - 0.5f ) - 1;
                int xceil  = (int) ( arrayindex.getX() + 0.5f ) - 1;
                int yceil  = (int) ( arrayindex.getY() + 0.5f ) - 1;

                if ( xfloor < 0 || yfloor < 0 || xceil >= texsize_x || yceil >= texsize_x )
                {
                        // we have reached the border;
                        outofdata = true;
                        break;
                }
                //fetch velocity at the actual position in world coordinates
                
                //floorx floorz
                float velocity_x_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4     ];
                float velocity_y_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 1 ];
                float velocity_z_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 2 ];
                                                        
                //floorx ceil           
                float velocity_x_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4      ];
                float velocity_y_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 1  ];
                float velocity_z_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 2  ];
                                                                           
                //floorx floorz                            
                float velocity_x_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4      ];
                float velocity_y_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 1  ];
                float velocity_z_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 2  ];
                                                        
                //floorx floorz         
                float velocity_x_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4      ];
                float velocity_y_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 1  ];
                float velocity_z_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 2  ];

                float interpolval_x_L = ( arrayindex.getX() - xfloor ) * velocity_x_cf + ( xceil - arrayindex.getX() ) * velocity_x_ff;
                float interpolval_y_L = ( arrayindex.getX() - xfloor ) * velocity_y_cf + ( xceil - arrayindex.getX() ) * velocity_y_ff;
                float interpolval_z_L = ( arrayindex.getX() - xfloor ) * velocity_z_cf + ( xceil - arrayindex.getX() ) * velocity_z_ff;

                float interpolval_x_H = ( arrayindex.getX() - xfloor ) * velocity_x_cc + ( xceil - arrayindex.getX() ) * velocity_x_fc;
                float interpolval_y_H = ( arrayindex.getX() - xfloor ) * velocity_y_cc + ( xceil - arrayindex.getX() ) * velocity_y_fc;
                float interpolval_z_H = ( arrayindex.getX() - xfloor ) * velocity_z_cc + ( xceil - arrayindex.getX() ) * velocity_z_fc;

                float interpolval_x = ( arrayindex.getY() - yfloor ) * interpolval_x_H + ( yceil - arrayindex.getY() ) * interpolval_x_L;
                float interpolval_y = ( arrayindex.getY() - yfloor ) * interpolval_y_H + ( yceil - arrayindex.getY() ) * interpolval_y_L;
                float interpolval_z = ( arrayindex.getY() - yfloor ) * interpolval_z_H + ( yceil - arrayindex.getY() ) * interpolval_z_L;

                VVector interpolatedval = VVector( interpolval_x, interpolval_y, interpolval_z );
                VVector interp_mult = VVector( interpolatedval );
                interp_mult.setX( -interp_mult.getX(  ) );
                interp_mult.normalize();
                interp_mult *=  0.05f *mStreamlinesDt;

                //VVector oldpos_world = mVertexToTexture.homogenTransform( VVector ( sactualpoint_x, sactualpoint_y, 0.0f ) );
                VVector oldpos_world = VVector();
                oldpos_world.setX( sactualpoint_x * dataextent_x + minx );
                oldpos_world.setY( sactualpoint_y * dataextent_y + miny );

                VVector newpos_world = oldpos_world - interp_mult;

                VVector newpos_tex = VVector();
                newpos_tex.setX( ( newpos_world.getX() - minx ) / dataextent_x );
                newpos_tex.setY( ( newpos_world.getY() - miny ) / dataextent_y );

                if(             ( newpos_tex.getX() ) > 1.0f || ( newpos_tex.getY() ) > 1.0f 
                        ||      ( newpos_tex.getX() ) < 0.0f || ( newpos_tex.getY() ) < 0.0f )
                {
                        outofdata = true;
                        break;
                }
                        
                sactualpoint_x = newpos_tex.getX();
                sactualpoint_y = newpos_tex.getY();

                //TODO:
                //convert to world space
                newpos_tex.setX( -( newpos_tex.getX() * dataextent_x ) + minx + dataextent_x);
                newpos_tex.setY( ( newpos_tex.getY() * dataextent_y ) + miny );

                float selfdistance = 200.0f * dtest;
                
                
                for (int h = (int)(200.0f); h < spoints.size(); h++ )
                //for (int h = (int)(100.0f / mStreamlinesDt); h < spoints.size(); h++ )
                {
                        VVector sp = spoints[ h - (int)(200.0f) ];
                        //VVector sp = spoints[ h - (int)(100.0f / mStreamlinesDt) ];
                        float pdistance = ( newpos_tex - sp ).getMagnitude();

                        if ( pdistance < selfdistance ) 
                        {
                                selfdistance = pdistance;
                        }

                        if ( pdistance < dtest ) 
                        {
                                selfcross = true;
                                break;
                        }
                        
                }

                if ( selfcross ) break;

                spoints.push_back( newpos_tex );

                float epsilon = 0.000000f;
                VVector posdifference = spoints[ spoints.size() - 1 ] - spoints[ spoints.size() - 2 ];
                if ( posdifference.getMagnitude() <= epsilon)
                {
                        outofdata = true;
                        break;
                }

        }

        
        pixeldata.clear();

        return spoints;

}

std::vector<VVector> VFlowData::generateCPUStreamSingleWithTests( 
        std::vector<VStreamLine> otherStreamlines,
        float xw, float yw, float dtest, float m_MaxSteps, int m_TimeStep /* = 0  */ )
{
        std::vector<VVector> spoints;
        std::vector< float > pixeldata;

        int texsize_x, texsize_y;

        float dataextent_x, dataextent_y;
        float datacenter_x, datacenter_y;
        float minx, miny;

        dataextent_x = mExtends.getX();
        dataextent_y = mExtends.getY();
        datacenter_x = mCenterPos.getX();
        datacenter_y = mCenterPos.getY();
        minx = mMinPos.getX();
        miny = mMinPos.getY();

        pixeldata = mTimeSteps[m_TimeStep].getFullFBODataVector();
        texsize_x = mTimeSteps[m_TimeStep].mFrameBufferObject->getWidth();
        texsize_y = mTimeSteps[m_TimeStep].mFrameBufferObject->getHeight();

        int size = (int)pixeldata.size();


        bool outofdata = false;

        float sactualpoint_x =  1.0 - (  xw - minx  ) / dataextent_x;
        float sactualpoint_y = ( yw - miny ) / dataextent_y;

        VVector start_world = VVector( xw, yw, 0.0f );
        spoints.push_back( start_world );
//      vthickness->push_back( dtest );
        
        bool tooclose = false;
        bool selfcross = false;

        for ( int i = 0; i <  MAXSTEPS * m_MaxSteps ; i++)
        {
                if (outofdata ) break;
                if( tooclose ) break;
                if( selfcross ) break;

                // transform texture coordinates sactualpint_x and sactualpoint_y into world coords
                VVector arrayindex = VVector( texsize_x * sactualpoint_x, texsize_y * sactualpoint_y, 0.0f );
                int xfloor = (int) ( arrayindex.getX() - 0.5f ) - 1;
                int yfloor = (int) ( arrayindex.getY() - 0.5f ) - 1;
                int xceil  = (int) ( arrayindex.getX() + 0.5f ) - 1;
                int yceil  = (int) ( arrayindex.getY() + 0.5f ) - 1;

                if ( xfloor < 0 || yfloor < 0 || xceil >= texsize_x || yceil >= texsize_x )
                {
                        // we have reached the border;
                        outofdata = true;
                        break;
                }
                //fetch velocity at the actual position in world coordinates
                
                //floorx floorz
                float velocity_x_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4     ];
                float velocity_y_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 1 ];
                float velocity_z_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 2 ];
                                                        
                //floorx ceil           
                float velocity_x_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4      ];
                float velocity_y_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 1  ];
                float velocity_z_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 2  ];
                                                                           
                //floorx floorz                            
                float velocity_x_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4      ];
                float velocity_y_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 1  ];
                float velocity_z_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 2  ];
                                                        
                //floorx floorz         
                float velocity_x_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4      ];
                float velocity_y_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 1  ];
                float velocity_z_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 2  ];

                float interpolval_x_L = ( arrayindex.getX() - xfloor ) * velocity_x_cf + ( xceil - arrayindex.getX() ) * velocity_x_ff;
                float interpolval_y_L = ( arrayindex.getX() - xfloor ) * velocity_y_cf + ( xceil - arrayindex.getX() ) * velocity_y_ff;
                float interpolval_z_L = ( arrayindex.getX() - xfloor ) * velocity_z_cf + ( xceil - arrayindex.getX() ) * velocity_z_ff;

                float interpolval_x_H = ( arrayindex.getX() - xfloor ) * velocity_x_cc + ( xceil - arrayindex.getX() ) * velocity_x_fc;
                float interpolval_y_H = ( arrayindex.getX() - xfloor ) * velocity_y_cc + ( xceil - arrayindex.getX() ) * velocity_y_fc;
                float interpolval_z_H = ( arrayindex.getX() - xfloor ) * velocity_z_cc + ( xceil - arrayindex.getX() ) * velocity_z_fc;

                float interpolval_x = ( arrayindex.getY() - yfloor ) * interpolval_x_H + ( yceil - arrayindex.getY() ) * interpolval_x_L;
                float interpolval_y = ( arrayindex.getY() - yfloor ) * interpolval_y_H + ( yceil - arrayindex.getY() ) * interpolval_y_L;
                float interpolval_z = ( arrayindex.getY() - yfloor ) * interpolval_z_H + ( yceil - arrayindex.getY() ) * interpolval_z_L;

                VVector interpolatedval = VVector( interpolval_x, interpolval_y, interpolval_z );
                VVector interp_mult = VVector( interpolatedval );
                interp_mult.setX( -interp_mult.getX(  ) );
                interp_mult.normalize();
                interp_mult *=  0.05f *mStreamlinesDt;

                //VVector oldpos_world = mVertexToTexture.homogenTransform( VVector ( sactualpoint_x, sactualpoint_y, 0.0f ) );
                VVector oldpos_world = VVector();
                oldpos_world.setX( sactualpoint_x * dataextent_x + minx );
                oldpos_world.setY( sactualpoint_y * dataextent_y + miny );

                VVector newpos_world = oldpos_world + interp_mult;

                VVector newpos_tex = VVector();
                newpos_tex.setX( ( newpos_world.getX() - minx ) / dataextent_x );
                newpos_tex.setY( ( newpos_world.getY() - miny ) / dataextent_y );

                if(             ( newpos_tex.getX() ) > 1.0f || ( newpos_tex.getY() ) > 1.0f 
                        ||      ( newpos_tex.getX() ) < 0.0f || ( newpos_tex.getY() ) < 0.0f )
                {
                        outofdata = true;
                        break;
                }
                        
                sactualpoint_x = newpos_tex.getX();
                sactualpoint_y = newpos_tex.getY();

                //TODO:
                //convert to world space
                newpos_tex.setX( -( newpos_tex.getX() * dataextent_x ) + minx + dataextent_x);
                newpos_tex.setY( ( newpos_tex.getY() * dataextent_y ) + miny );

                float selfdistance = 200.0f * dtest;
                
                
                for (int h = (int)(200.0f); h < spoints.size(); h++ )
                //for (int h = (int)(100.0f / mStreamlinesDt); h < spoints.size(); h++ )
                {
                        VVector sp = spoints[ h - (int)(200.0f) ];
                        //VVector sp = spoints[ h - (int)(100.0f / mStreamlinesDt) ];
                        float pdistance = ( newpos_tex - sp ).getMagnitude();

                        if ( pdistance < selfdistance ) 
                        {
                                selfdistance = pdistance;
                        }

                        if ( pdistance < dtest ) 
                        {
                                selfcross = true;
                                break;
                        }
                        
                }

                if ( selfcross ) break;

                //control
                float mdistance[ 1 ];
                for( int k = 0; k < otherStreamlines.size(); k++)
                {
                        tooclose = !otherStreamlines[ k ].isPointAllowed( newpos_tex /*this is in world despite the name*/, dtest, mdistance );
                        if ( tooclose ) break;
                        
                }

                

                if ( !tooclose && !selfcross )
                {
                
                                
                        spoints.push_back( newpos_tex );


                        float epsilon = 0.000000f;
                        VVector posdifference = spoints[ spoints.size() - 1 ] - spoints[ spoints.size() - 2 ];
                        if ( posdifference.getMagnitude() <= epsilon)
                        {
                                outofdata = true;
                                break;
                        }
                
                }

        }

        //if ( tooclose  || selfcross ) return spoints;

        //revert the streamline poitns vector and ocntinue in the opposite direction
        if( !spoints.empty() ) 
        {
                std::vector< VVector > _streamlinesvertices;
                for( int k = 0; k < spoints.size(); k++)
                {
                        _streamlinesvertices.push_back( spoints[ spoints.size() - k - 1 ] );
                }
                spoints.clear();
                spoints.swap( _streamlinesvertices );
                
        }
        

        sactualpoint_x =  1.0 - (  xw - minx  ) / dataextent_x;
        sactualpoint_y = ( yw - miny ) / dataextent_y;

        outofdata = false;
        selfcross = false;

        //and go to the opposite direction
        for ( int i = 0; i <  MAXSTEPS * m_MaxSteps ; i++)
        {
                if ( outofdata ) break;
                if ( tooclose ) break;
                if ( selfcross ) break;
                
                // transform texture coordinates sactualpint_x and sactualpoint_y into world coords
                VVector arrayindex = VVector( texsize_x * sactualpoint_x, texsize_y * sactualpoint_y, 0.0f );
                int xfloor = (int) ( arrayindex.getX() - 0.5f ) - 1;
                int yfloor = (int) ( arrayindex.getY() - 0.5f ) - 1;
                int xceil  = (int) ( arrayindex.getX() + 0.5f ) - 1;
                int yceil  = (int) ( arrayindex.getY() + 0.5f ) - 1;

                if ( xfloor < 0 || yfloor < 0 || xceil >= texsize_x || yceil >= texsize_x )
                {
                        // we have reached the border;
                        outofdata = true;
                        break;
                }
                //fetch velocity at the actual position in world coordinates
                
                //floorx floorz
                float velocity_x_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4     ];
                float velocity_y_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 1 ];
                float velocity_z_ff = pixeldata[ xfloor * 4 + yfloor * texsize_x * 4 + 2 ];
                                                        
                //floorx ceil           
                float velocity_x_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4      ];
                float velocity_y_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 1  ];
                float velocity_z_fc =  pixeldata[ xfloor * 4 + yceil * texsize_x * 4 + 2  ];
                                                                           
                //floorx floorz                            
                float velocity_x_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4      ];
                float velocity_y_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 1  ];
                float velocity_z_cf =  pixeldata[ xceil * 4 + yfloor* texsize_x * 4 + 2  ];
                                                        
                //floorx floorz         
                float velocity_x_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4      ];
                float velocity_y_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 1  ];
                float velocity_z_cc = pixeldata[ xceil * 4 + yceil * texsize_x * 4 + 2  ];

                float interpolval_x_L = ( arrayindex.getX() - xfloor ) * velocity_x_cf + ( xceil - arrayindex.getX() ) * velocity_x_ff;
                float interpolval_y_L = ( arrayindex.getX() - xfloor ) * velocity_y_cf + ( xceil - arrayindex.getX() ) * velocity_y_ff;
                float interpolval_z_L = ( arrayindex.getX() - xfloor ) * velocity_z_cf + ( xceil - arrayindex.getX() ) * velocity_z_ff;

                float interpolval_x_H = ( arrayindex.getX() - xfloor ) * velocity_x_cc + ( xceil - arrayindex.getX() ) * velocity_x_fc;
                float interpolval_y_H = ( arrayindex.getX() - xfloor ) * velocity_y_cc + ( xceil - arrayindex.getX() ) * velocity_y_fc;
                float interpolval_z_H = ( arrayindex.getX() - xfloor ) * velocity_z_cc + ( xceil - arrayindex.getX() ) * velocity_z_fc;

                float interpolval_x = ( arrayindex.getY() - yfloor ) * interpolval_x_H + ( yceil - arrayindex.getY() ) * interpolval_x_L;
                float interpolval_y = ( arrayindex.getY() - yfloor ) * interpolval_y_H + ( yceil - arrayindex.getY() ) * interpolval_y_L;
                float interpolval_z = ( arrayindex.getY() - yfloor ) * interpolval_z_H + ( yceil - arrayindex.getY() ) * interpolval_z_L;

                VVector interpolatedval = VVector( interpolval_x, interpolval_y, interpolval_z );
                VVector interp_mult = VVector( interpolatedval );
                interp_mult.setX( -interp_mult.getX(  ) );
                interp_mult.normalize();
                interp_mult *=  0.05f *mStreamlinesDt;

                //VVector oldpos_world = mVertexToTexture.homogenTransform( VVector ( sactualpoint_x, sactualpoint_y, 0.0f ) );
                VVector oldpos_world = VVector();
                oldpos_world.setX( sactualpoint_x * dataextent_x + minx );
                oldpos_world.setY( sactualpoint_y * dataextent_y + miny );

                VVector newpos_world = oldpos_world - interp_mult;

                VVector newpos_tex = VVector();
                newpos_tex.setX( ( newpos_world.getX() - minx ) / dataextent_x );
                newpos_tex.setY( ( newpos_world.getY() - miny ) / dataextent_y );

                if(             ( newpos_tex.getX() ) > 1.0f || ( newpos_tex.getY() ) > 1.0f 
                        ||      ( newpos_tex.getX() ) < 0.0f || ( newpos_tex.getY() ) < 0.0f )
                {
                        outofdata = true;
                        break;
                }
                        
                sactualpoint_x = newpos_tex.getX();
                sactualpoint_y = newpos_tex.getY();

                //TODO:
                //convert to world space
                newpos_tex.setX( -( newpos_tex.getX() * dataextent_x ) + minx + dataextent_x);
                newpos_tex.setY( ( newpos_tex.getY() * dataextent_y ) + miny );

                float selfdistance = 200.0f * dtest;
                
                
                for (int h = (int)(200.0f); h < spoints.size(); h++ )
                //for (int h = (int)(100.0f / mStreamlinesDt); h < spoints.size(); h++ )
                {
                        VVector sp = spoints[ h - (int)(200.0f) ];
                        //VVector sp = spoints[ h - (int)(100.0f / mStreamlinesDt) ];
                        float pdistance = ( newpos_tex - sp ).getMagnitude();

                        if ( pdistance < selfdistance ) 
                        {
                                selfdistance = pdistance;
                        }

                        if ( pdistance < dtest ) 
                        {
                                selfcross = true;
                                break;
                        }
                        
                }

                if ( selfcross ) break;

                //control
                float mdistance[ 1 ];
                for( int k = 0; k < otherStreamlines.size(); k++)
                {
                        tooclose = !otherStreamlines[ k ].isPointAllowed( newpos_tex /*this is in world despite the name*/, dtest, mdistance );
                        if ( tooclose ) break;
                        
                }

                if ( !tooclose && ! selfcross )
                {
                        spoints.push_back( newpos_tex );
                        //vthickness->push_back( min ( mdistance[ 0 ], selfdistance ) );


                        float epsilon = 0.000000f;
                        VVector posdifference = spoints[ spoints.size() - 1 ] - spoints[ spoints.size() - 2 ];
                        if ( posdifference.getMagnitude() <= epsilon)
                        {
                                outofdata = true;
                                break;
                        }
                }
                

        }

        
        pixeldata.clear();
        

        return spoints;

}


void VFlowData::generateCPUStreamLines( float m_MaxSteps, float m_StreamSeparation, int m_TimeStep /* = 0  */ )
{

        switch ( mSeedPlacing )
        {
                case LEFT:
                {
                        if ( mEuler )
                        {
                                generateCPUStreamLinesLEFT( m_MaxSteps, m_StreamSeparation, m_TimeStep /* = 0  */ );
                        }
                        else
                        {
                                generateCPUStreamLinesLEFT_RK2( m_MaxSteps, m_StreamSeparation, m_TimeStep /* = 0  */ );
                        }
                        break;
                }
                        
                case TOP:
                {
                        if ( mEuler )
                        {
                                generateCPUStreamLinesTOP( m_MaxSteps, m_StreamSeparation, m_TimeStep /* = 0  */ );
                        }
                        else
                        {
                                generateCPUStreamLinesTOP_RK2( m_MaxSteps, m_StreamSeparation, m_TimeStep /* = 0  */ );
                        }
                        break;
                }
                        
                case RIGHT:
                {
                        if ( mEuler )
                        {
                                generateCPUStreamLinesRIGHT( m_MaxSteps, m_StreamSeparation, m_TimeStep /* = 0  */ );
                        }
                        else
                        {
                                generateCPUStreamLinesRIGHT_RK2( m_MaxSteps, m_StreamSeparation, m_TimeStep /* = 0  */ );
                        }
                        
                        break;
                }
                        
                case BOTTOM:
                {
                        if ( mEuler )
                        {
                                generateCPUStreamLinesBOTTOM( m_MaxSteps, m_StreamSeparation, m_TimeStep /* = 0  */ );
                        }
                        else
                        {
                                generateCPUStreamLinesBOTTOM_RK2( m_MaxSteps, m_StreamSeparation, m_TimeStep /* = 0  */ );
                        }
                        
                        break;
                }
                        
                case ALL:
                {
                        if ( mEuler )
                        {
                                generateCPUStreamLinesALL( m_MaxSteps, m_StreamSeparation, m_TimeStep /* = 0  */ );
                        }
                        else
                        {
                                generateCPUStreamLinesALL_RK2( m_MaxSteps, m_StreamSeparation, m_TimeStep /* = 0  */ );
                        }
                        
                        break;
                }
                case RANDOM:
                {
                        if ( mEuler )
                        {
                                generateCPUStreamLinesRANDOM( m_MaxSteps, m_StreamSeparation, m_TimeStep /* = 0  */ );
                        }
                        else
                        {
                                generateCPUStreamLinesRANDOM_RK2( m_MaxSteps, m_StreamSeparation, m_TimeStep /* = 0  */ );
                        }
                        
                        break;
                }
                        
                case MANUAL:
                {
                        if ( mEuler )
                        {
                                generateCPUStreamLinesMANUAL( m_MaxSteps, m_StreamSeparation, m_TimeStep /* = 0  */ );
                        }
                        else
                        {
                                generateCPUStreamLinesMANUAL_RK2( m_MaxSteps, m_StreamSeparation, m_TimeStep /* = 0  */ );
                        }
                        
                        break;
                }
                        
                case EVEN:
                {
                        if ( mEuler )
                        {
                                generateCPUStreamLinesEVEN( m_MaxSteps, m_StreamSeparation, m_TimeStep /* = 0  */ );
                        }
                        else
                        {
                                generateCPUStreamLinesEVEN_RK2( m_MaxSteps, m_StreamSeparation, m_TimeStep /* = 0  */ );
                        }
                        
                        break;
                }
        
        }

        

}

void VFlowData::generateVBO()
{
        glGenBuffersARB( 1, &(mVertexVbo) );
        glBindBufferARB( GL_ARRAY_BUFFER_ARB, mVertexVbo );
        glBufferDataARB( GL_ARRAY_BUFFER_ARB, sizeof(float) * (int)mVertexGrid.size() * 3, &(mVertexGrid[0]), GL_STATIC_DRAW_ARB );

        glGenBuffersARB( 1, &(mIndexVbo) );
        glBindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, mIndexVbo );
        glBufferDataARB( GL_ELEMENT_ARRAY_BUFFER_ARB, sizeof(int) * (int)mIndexGrid.size(), &(mIndexGrid[0]), GL_STATIC_DRAW_ARB );

        for ( int i = 0; i < (int)mTimeSteps.size(); ++i )
        {
                for ( int j = 0; j < (int) mTimeSteps[i].mTimeData.size(); ++j )
                {
                        glGenBuffersARB(1, &( mTimeSteps[i].mTimeData[j].mSetVbo) );

                        glBindBufferARB(GL_ARRAY_BUFFER_ARB, mTimeSteps[i].mTimeData[j].mSetVbo);
                        glBufferDataARB(GL_ARRAY_BUFFER_ARB, 
                                                        sizeof(float) * (int)(mTimeSteps[i].mTimeData[j].mSet.size()) * 3, 
                                                        &(mTimeSteps[i].mTimeData[j].mSet[0]), 
                                                        GL_STATIC_DRAW_ARB);

                        mTimeSteps[i].mTimeData[j].mTexCoordChannel = GL_TEXTURE0 + j;
                }
        }

        glBindBufferARB( GL_ELEMENT_ARRAY_BUFFER, 0 );
        glBindBufferARB( GL_ARRAY_BUFFER, 0 );
}

void VFlowData::activateVBO( int m_TimeStep )
{
        if( m_TimeStep > ( ( int )mTimeSteps.size(  ) - 1) )
        {
                m_TimeStep = ( ( int )mTimeSteps.size(  ) - 1 );
        }
        for( int i = 0; i < ( int ) mTimeSteps[ m_TimeStep ].mTimeData.size(  ); ++i )
        {
                glActiveTextureARB( mTimeSteps[ m_TimeStep ].mTimeData[ i ].mTexCoordChannel );
                glClientActiveTextureARB( mTimeSteps[ m_TimeStep ].mTimeData[ i ].mTexCoordChannel );
                glEnableClientState( GL_TEXTURE_COORD_ARRAY_EXT );
                glBindBuffer( GL_ARRAY_BUFFER, mTimeSteps[ m_TimeStep ].mTimeData[ i ].mSetVbo );
                glTexCoordPointerEXT( 3, GL_FLOAT, 0, 0, 0 );
        }
        
        glEnableClientState( GL_VERTEX_ARRAY );
        glBindBuffer( GL_ARRAY_BUFFER, mVertexVbo );
        glVertexPointer( 3, GL_FLOAT, 0, 0 );
}

void VFlowData::deactivateVBO()
{
        glDisableClientState(GL_VERTEX_ARRAY);

        for ( int i = 0; i < (int)mTimeSteps[0].mTimeData.size(); ++i )
        {
                glClientActiveTextureARB(GL_TEXTURE0_ARB + i);
                glDisableClientState(GL_TEXTURE_COORD_ARRAY);
        }

        glClientActiveTextureARB(GL_TEXTURE0_ARB);

        glBindBufferARB(GL_ARRAY_BUFFER, 0);
        glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);



}

void VFlowData::clear()
{
        glDeleteBuffersARB( 1, &mVertexVbo );
        mVertexGrid.clear();
        
        glDeleteBuffersARB( 1, &mIndexVbo );
        mIndexGrid.clear();

        if(mGlyphIndexVbo != 0)
        {
                glDeleteBuffers( 1, &(mGlyphIndexVbo) );
                mGlyphIndexGrid.clear();
        }

        for ( int i = 0; i < (int)mTimeSteps.size(); ++i )
        {
                for ( int j = 0; j < (int) mTimeSteps[i].mTimeData.size(); ++j )
                {
                        glDeleteBuffersARB(1, &mTimeSteps[i].mTimeData[j].mSetVbo );
                        mTimeSteps[i].mTimeData[j].mSet.clear();
                }
                mTimeSteps[i].mTimeData.clear();
        }
        mTimeSteps.clear();

        glBindBufferARB( GL_ELEMENT_ARRAY_BUFFER, 0 );
        glBindBufferARB( GL_ARRAY_BUFFER, 0 );

                

        
}

VProgram * VFlowData::mRenderTextureProgram = NULL;

---