Eigene Dateien/FlowVis/src/VStreamLine.cpp

Go to the documentation of this file.

#include "VStreamLine.h"
#include "glew.h"

VStreamLine::VStreamLine() : mPositionVBOHandle( 0 ), mIndexVBOHandle( 0 )
{

}

VStreamLine::VStreamLine(std::vector<VVector> m_Positions) : mPositionVBOHandle( 0 ), mIndexVBOHandle( 0 )
{

        mPositions = m_Positions;

        for(int i = 0; i < (int)mPositions.size(); ++i)
        {
                mIndices.push_back(i);
                mTaperFactors.push_back(1.0f);
                mTaperVectors.push_back(VVector());
        }

        //generateVBO();
}

VStreamLine::VStreamLine(std::vector<VVector> m_Positions, std::vector<float> m_TaperFactors) : mPositionVBOHandle( 0 ), mIndexVBOHandle( 0 )
{

        mPositions = m_Positions;
        mTaperFactors = m_TaperFactors;

        for(int i = 0; i < (int)mPositions.size(); ++i)
        {
                mIndices.push_back(i);
        }

        //generateVBO();
}



void VStreamLine::draw( bool tap, float scale , bool glyph)
{
        
        //glDisable (GL_DEPTH_TEST);
        
        if( tap )
        {
                if( glyph )
                {
                        glBegin(GL_TRIANGLES);
                        for(int i = 0; i < (mPositions.size() - 10) && ( (i + 10) < (int)mPositions.size()); i = i + 10)
                        {
                                VVector c1 = mPositions[ i     ];
                                VVector c2 = mPositions[ i + 10 ];

                                VVector normalVec(-(c2.getY() - c1.getY()), c2.getX() - c1.getX(), 0.0f);
                                normalVec.normalize();
                                VVector offset_p1 = normalVec * mTaperFactors[i] * pow( ( scale ) * 2.0f, 3.0f );
                                VVector offset_p2 = normalVec * mTaperFactors[i + 10] * pow( ( scale ) * 2.0f, 3.0f );


                                /*VVector p1 = c1 - offset_p1;
                                VVector p2 = c2 - offset_p2;
                                VVector p3 = c2;
                                VVector p4 = c1;

                                glColor4f( 1.0f, 0.0f, 0.0f, 0.0f );
                                glMultiTexCoord2f( GL_TEXTURE0, offset_p1.getX(), offset_p1.getY() );
                                glMultiTexCoord2f( GL_TEXTURE1, 0.0f, 0.0f );
                                glVertex3fv( p1.getPtr() );
                                glMultiTexCoord2f( GL_TEXTURE0, offset_p2.getX(), offset_p2.getY() );
                                glMultiTexCoord2f( GL_TEXTURE1, 1.0f, 0.0f );
                                glVertex3fv( p2.getPtr() );
                                glColor4f( 1.0f, 0.0f, 0.0f, 1.0f );
                                glMultiTexCoord2f( GL_TEXTURE0, -offset_p2.getX(), -offset_p2.getY() );
                                glMultiTexCoord2f( GL_TEXTURE1, 1.0f, 0.5f );
                                glVertex3fv( p3.getPtr() );
                                glMultiTexCoord2f( GL_TEXTURE0, -offset_p1.getX(), -offset_p1.getY() );
                                glMultiTexCoord2f( GL_TEXTURE1, 0.0f, 0.5f );
                                glVertex3fv( p4.getPtr() );*/

                                VVector p1 = c1;
                                VVector p2 = c2;
                                //p3 = c2 + offset_p2;
                                VVector p4 = c2 - offset_p2 * 2.0f;

                                glColor4f( 1.0f, 0.0f, 0.0f, 1.0f );
                                glMultiTexCoord2f( GL_TEXTURE0, offset_p1.getX(), offset_p1.getY() );
                                glMultiTexCoord2f( GL_TEXTURE1, 0.0f, 0.5f );
                                glVertex3fv( p1.getPtr() );
                                glMultiTexCoord2f( GL_TEXTURE0, offset_p2.getX(), offset_p2.getY() );
                                glMultiTexCoord2f( GL_TEXTURE1, 1.0f, 0.5f );
                                glVertex3fv( p2.getPtr() );
                                /*glColor4f( 1.0f, 0.0f, 0.0f, 0.0f );
                                glMultiTexCoord2f( GL_TEXTURE0, -offset_p2.getX(), -offset_p2.getY() );
                                glMultiTexCoord2f( GL_TEXTURE1, 1.0f, 1.0f );
                                glVertex3fv( p3.getPtr() );*/
                                glMultiTexCoord2f( GL_TEXTURE0, -offset_p1.getX(), -offset_p1.getY() );
                                glMultiTexCoord2f( GL_TEXTURE1, 0.0f, 1.0f );
                                glVertex3fv( p4.getPtr() );

                        }
                        glEnd();
                }
                else
                {
                        glBegin(GL_QUADS);
                        for(int i = 0; i < mPositions.size() - 1; i++)
                        {
                                VVector offset_p1 = mTaperVectors[ i     ] * pow( ( scale ) * 2.0f, 3.0f );
                                VVector offset_p2 = mTaperVectors[ i + 1 ] * pow( ( scale ) * 2.0f, 3.0f );

                                VVector c1 = mPositions[ i     ];
                                VVector c2 = mPositions[ i + 1 ];

                                VVector p1 = c1 - offset_p1;
                                VVector p2 = c2 - offset_p2;
                                VVector p3 = c2;
                                VVector p4 = c1;

                                glColor4f( 1.0f, 0.0f, 0.0f, 0.0f );
                                glMultiTexCoord2f( GL_TEXTURE0, offset_p1.getX(), offset_p1.getY() );
                                glMultiTexCoord2f( GL_TEXTURE1, 0.0f, 0.0f );
                                glVertex3fv( p1.getPtr() );
                                glMultiTexCoord2f( GL_TEXTURE0, offset_p2.getX(), offset_p2.getY() );
                                glMultiTexCoord2f( GL_TEXTURE1, 1.0f, 0.0f );
                                glVertex3fv( p2.getPtr() );
                                glColor4f( 1.0f, 0.0f, 0.0f, 1.0f );
                                glMultiTexCoord2f( GL_TEXTURE0, -offset_p2.getX(), -offset_p2.getY() );
                                glMultiTexCoord2f( GL_TEXTURE1, 1.0f, 0.5f );
                                glVertex3fv( p3.getPtr() );
                                glMultiTexCoord2f( GL_TEXTURE0, -offset_p1.getX(), -offset_p1.getY() );
                                glMultiTexCoord2f( GL_TEXTURE1, 0.0f, 0.5f );
                                glVertex3fv( p4.getPtr() );

                                p1 = c1;
                                p2 = c2;
                                p3 = c2 + offset_p2;
                                p4 = c1 + offset_p1;

                                glColor4f( 1.0f, 0.0f, 0.0f, 1.0f );
                                glMultiTexCoord2f( GL_TEXTURE0, offset_p1.getX(), offset_p1.getY() );
                                glMultiTexCoord2f( GL_TEXTURE1, 0.0f, 0.5f );
                                glVertex3fv( p1.getPtr() );
                                glMultiTexCoord2f( GL_TEXTURE0, offset_p2.getX(), offset_p2.getY() );
                                glMultiTexCoord2f( GL_TEXTURE1, 1.0f, 0.5f );
                                glVertex3fv( p2.getPtr() );
                                glColor4f( 1.0f, 0.0f, 0.0f, 0.0f );
                                glMultiTexCoord2f( GL_TEXTURE0, -offset_p2.getX(), -offset_p2.getY() );
                                glMultiTexCoord2f( GL_TEXTURE1, 1.0f, 1.0f );
                                glVertex3fv( p3.getPtr() );
                                glMultiTexCoord2f( GL_TEXTURE0, -offset_p1.getX(), -offset_p1.getY() );
                                glMultiTexCoord2f( GL_TEXTURE1, 0.0f, 1.0f );
                                glVertex3fv( p4.getPtr() );

                        }
                        glEnd();
                }
                
        
                
        }
        else
        {
                if(glyph)
                {
                        glBegin(GL_TRIANGLES);
                        for(int i = 0; (i < mPositions.size() - 10) && ( (i + 10) < (int)mPositions.size()); i = i + 10)
                        {
                                VVector c1 = mPositions[ i     ];
                                VVector c2 = mPositions[ i + 10 ];

                                VVector normalVec(-(c2.getY() - c1.getY()), c2.getX() - c1.getX(), 0.0f);
                                normalVec.normalize();
                                VVector offset_p1 = normalVec * ( scale / 10.0f );
                                VVector offset_p2 = normalVec * ( scale / 10.0f );

                                VVector p1 = c1/* - offset_p1*/;
                                VVector p2 = c2/* - offset_p2*/;
                                /*VVector p3 = c2 + offset_p2;*/
                                VVector p4 = c2 - offset_p2 * 2.0f;

                                glColor4f( 1.0f, 0.0f, 0.0f, 1.0f );
                                glMultiTexCoord2f( GL_TEXTURE1, 0.0f, 0.0f );
                                glVertex3fv( p1.getPtr() );
                                glMultiTexCoord2f( GL_TEXTURE1, 1.0f, 0.0f );
                                glVertex3fv( p2.getPtr() );
                                glColor4f( 1.0f, 0.0f, 0.0f, 1.0f );
                                /*glMultiTexCoord2f( GL_TEXTURE1, 1.0f, 1.0f );
                                glVertex3fv( p3.getPtr() );*/
                                glMultiTexCoord2f( GL_TEXTURE1, 0.0f, 1.0f );
                                glVertex3fv( p4.getPtr() );

                        }
                        glEnd();
                }
                else
                {
                        glColor4f( 1.0f, 0.0f, 0.0f, 1.0f );
                        activateVBO();
                        glDrawElements(GL_LINE_STRIP, (int) mIndices.size(), GL_UNSIGNED_INT, 0);
                        deactivateVBO();

                }
        }

        //glEnable (GL_DEPTH_TEST);


}

void VStreamLine::clearVBO()
{
        if( mPositionVBOHandle != 0 )
        {
                glDeleteBuffersARB( 1, &mPositionVBOHandle );
                mPositionVBOHandle = 0;
        }
        if( mIndexVBOHandle != 0)
        {
                glDeleteBuffersARB( 1, &mIndexVBOHandle );
                mIndexVBOHandle = 0;
        }
        if( mTaperVBOHandle != 0)
        {
                glDeleteBuffersARB( 1, &mTaperVBOHandle );
                mTaperVBOHandle = 0;
        }
}

std::vector< VVector > VStreamLine::getCandidateSeeds( float dsep  )
{
        std::vector< VVector > cand;

        int size = getNumberOfPoints();

        if ( size == 0 ) return cand;

        int factor = 10;
        // I want like 10 new seeds for each streamline
        for(int i = ( size - 2 ) / factor ; i > 1; i--)
        {
                VVector c1 = mPositions[ i * factor ];
                VVector c2 = mPositions[ i * factor - 1 ];

                VVector orientation = c2 - c1;
                VVector normorient = VVector( - orientation.getY(), orientation.getX(), 0.0f );

                normorient.normalize();
                normorient = ( normorient ) *  dsep;

                VVector s1 = c2 + normorient;
                VVector s2 = c2 - normorient;

                if ( i == ( size - 2 ) / factor )
                {
                        cand.push_back( s1 );
                        cand.push_back( s2 );
                }
                else
                {
                        bool distanceok = true;
                        for ( int j = 0; j < cand.size(); j++ )
                        {
                                VVector _pt = cand[ j ];
                                float tmpDistance = (_pt - s1).getMagnitude();

                                if ( tmpDistance < dsep )
                                {
                                        distanceok = false;
                                        break;
                                }
                        
                        }

                        if( distanceok )
                        {
                                cand.push_back( s1 );
                        }

                        distanceok = true;
                        for ( int j = 0; j < cand.size(); j++ )
                        {
                                VVector _pt = cand[ j ];
                                float tmpDistance = (_pt - s2).getMagnitude();

                                if ( tmpDistance < dsep )
                                {
                                        distanceok = false;
                                        break;
                                }
                        
                        }

                        if( distanceok )
                        {
                                cand.push_back( s2 );
                        }
                }
                
        }

        return cand;
}

void VStreamLine::computeThicknessCoefficients( float dtest, float dsep, std::vector<  VStreamLine > others, int itself, float datasizemax  )
{
        
        mTaperVectors.resize( mPositions.size() );
        mTaperFactors.resize( mPositions.size() );

        for( int h = 0; h < mPositions.size(); h++ )
        {
                float mind = 10000.0f;

                for ( int j = 0; j < others.size(); j++ )
                {
                        //dont look for collapse with himself for now
                        if ( j == itself ) continue;
        
                        float d = others[ j ].getMinimalDistance( mPositions[ h ] ); 
                        
                        mind = ( d < mind ) ? d : mind;
                
                }

                mTaperFactors[ h ] = ( mind >= dsep ) ? 1.0f : ( mind - dtest) / ( dsep - dtest );
                mTaperFactors[ h ] /= 18.0f;
                
                
        }

        mTaperVectors[ 0 ] = VVector();
        mTaperVectors[ mPositions.size() - 2 ] = VVector();

        for( int h = 1; h < mPositions.size() - 1; h++ )
        {
                VVector c0 = mPositions[ h - 1 ];
                VVector c2 = mPositions[ h + 1 ];

                VVector orientation = c2 - c0;
                VVector normorient = VVector( - orientation.getY(), orientation.getX(), 0.0f );

                normorient.normalize();
                normorient = ( normorient ) * mTaperFactors[ h ];

                mTaperVectors[ h ] = - normorient;

        }
        
}

float VStreamLine::getMinimalDistance( VVector m_Point )
{
        float mind;

        if ( !mPositions.empty() )
        {
                mind = ( mPositions[ 0 ] - m_Point ).getMagnitude();
        }
        else
        {
                //such streams are not allowed, so this case should not happen
                return 100000.0;
        }

        for ( int i = 1; i < mPositions.size() /10 ; i++ )
        {
                float _d = ( mPositions[ i * 10 ] - m_Point ).getMagnitude();

                if ( _d < mind )
                {
                
                        mind = _d;
                }
        }

        return mind;
}

bool VStreamLine::isPointAllowed( VVector m_Point, float m_Epsilon )
{
        float pointdistance;
        int mindistanceIndex;

        
        for( int i = 0; i < (int)mPositions.size() / 5; ++i )
        {
                VVector _pt = VVector( mPositions[ 5 * i].getX(), mPositions[ 5  * i ].getY(), mPositions[ 5 * i ].getZ() );
                float tmpDistance = (_pt - m_Point).getMagnitude();

                if( i == 0 )
                {
                        pointdistance = tmpDistance;
                        mindistanceIndex = 5 * i;
                }
                if(tmpDistance < pointdistance)
                {
                        pointdistance = tmpDistance;
                        mindistanceIndex = 5 * i;
                }

                if((pointdistance) < m_Epsilon)
                {
                        return false;
                }
        }


        //if( mindistanceIndex > 0)
        //{
        //      VVector l1P1 = mPositions[mindistanceIndex - 1];
        //      VVector l1P2 = mPositions[mindistanceIndex];

        //      float l1distance = (abs( (l1P2.getX() - l1P1.getX()) * (l1P1.getY() - m_Point.getY())  - (l1P1.getX() - m_Point.getX()) * (l1P2.getY() - l1P1.getY() ) ) 
        //              / sqrt( pow((l1P2.getX() - l1P1.getX()), 2) + pow((l1P2.getY() - l1P1.getY() ), 2) ) );

        //      if( (abs(l1distance) < m_Epsilon))
        //      {
        //              return false;
        //      }
        //}
        //

        //if(mindistanceIndex < ((int)mPositions.size() - 2))
        //{
        //      VVector l2P1 = mPositions[mindistanceIndex];
        //      VVector l2P2 = mPositions[mindistanceIndex + 1];

        //      float l2distance = (abs( (l2P2.getX() - l2P1.getX()) * (l2P1.getY() - m_Point.getY())  - (l2P1.getX() - m_Point.getX()) * (l2P2.getY() - l2P1.getY() ) ) 
        //              / sqrt( pow((l2P2.getX() - l2P1.getX()), 2) + pow((l2P2.getY() - l2P1.getY() ), 2) ) );

        //      if( (abs(l2distance) < m_Epsilon) )
        //      {
        //              return false;
        //      }
        //}
        
        return true;
}

bool VStreamLine::isPointAllowed( VVector m_Point, float m_Epsilon, float * m_Distance )
{
        float pointdistance;
        int mindistanceIndex;

        m_Distance[ 0 ] = m_Epsilon * 2.0f;
        
        for( int i = 0; i < (int)mPositions.size() / 5; ++i )
        {
                VVector _pt = VVector( mPositions[ 5 * i].getX(), mPositions[ 5  * i ].getY(), mPositions[ 5 * i ].getZ() );
                float tmpDistance = (_pt - m_Point).getMagnitude();

                if( i == 0 )
                {
                        pointdistance = tmpDistance;
                        mindistanceIndex = 5 * i;
                }
                if(tmpDistance < pointdistance)
                {
                        pointdistance = tmpDistance;
                        mindistanceIndex = 5 * i;
                }

                if((pointdistance) < m_Epsilon)
                {
                        return false;
                }
        }

        m_Distance[ 0 ] = pointdistance;
        return true;
}

bool VStreamLine::interSectsStreamLine( VVector m_Point1, VVector m_Point2 )
{
        float x1 = m_Point1.getX();
        float x2 = m_Point2.getX();

        float y1 = m_Point1.getY();
        float y2 = m_Point2.getY();

        float x3, x4;
        float y3, y4;

        for( int i = 0; i < (int)mPositions.size() - 1; ++i )
        {
                x3 = mPositions[i].getX();
                y3 = mPositions[i].getY();

                x4 = mPositions[i+1].getX();
                y4 = mPositions[i+1].getY();

                float s = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) 
                        / ((y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1));

                float t = ((x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3))
                        / ((y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1));
                
                if( (0.0f <= s) && (s <= 1.0f) &&
                        (0.0f <= t) && (t <= 1.0f)        )
                {
                        return true;
                }
        }

        return false;
}

void VStreamLine::loadStreamLine( FILE * m_FilePointer )
{
        clearVBO();
        mPositions.clear();
        mIndices.clear();
        mTaperFactors.clear();
        mTaperVectors.clear();

        int numPoints;
        fread( &numPoints, sizeof(int),1, m_FilePointer );

        std::vector<float> input;
        input.resize(numPoints * 5);

        fread( &input[0], sizeof(float), numPoints * 5, m_FilePointer);

        for ( int i = 0; i < numPoints * 5; i = i + 5 )
        {
                VVector newPos(input[i], input[i + 1], 0.0f);
                mPositions.push_back(newPos);
                mTaperFactors.push_back(input[i + 2]);
                VVector taperVec(input[ i + 3], input[ i + 4], 0.0f);
                mTaperVectors.push_back(taperVec);
        }

        for(int i = 0; i < (int)mPositions.size(); ++i)
        {
                mIndices.push_back(i);
        }

        generateVBO();
}

void VStreamLine::saveStreamLine( FILE * m_FilePointer )
{
        int numPoints = (int)mPositions.size();

        fwrite(reinterpret_cast<char*>(&numPoints), sizeof(unsigned int), 1, m_FilePointer);

        std::vector<float> output;

        for ( int i = 0; i < numPoints; ++i )
        {
                output.push_back(mPositions[i].getX());
                output.push_back(mPositions[i].getY());
                output.push_back(mTaperFactors[i]);
                output.push_back(mTaperVectors[i].getX());
                output.push_back(mTaperVectors[i].getY());
        }

        fwrite(reinterpret_cast<char*>(&output[0]), sizeof(float), 5 * numPoints, m_FilePointer);
}


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

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

        glGenBuffersARB(1, &( mTaperVBOHandle) );
        glBindBufferARB(GL_ARRAY_BUFFER_ARB, mTaperVBOHandle);
        glBufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(float) * (int)(mTaperVectors.size()) * 3, &(mTaperVectors[0]), GL_STATIC_DRAW_ARB);
        
        glBindBufferARB( GL_ELEMENT_ARRAY_BUFFER, 0 );
        glBindBufferARB( GL_ARRAY_BUFFER, 0 );
}

void VStreamLine::activateVBO()
{
        //generateVBO();

        glActiveTextureARB( GL_TEXTURE0_ARB );
        glClientActiveTextureARB( GL_TEXTURE0_ARB );
        glEnableClientState( GL_TEXTURE_COORD_ARRAY_EXT );
        glBindBuffer( GL_ARRAY_BUFFER, mTaperVBOHandle );
        glTexCoordPointerEXT( 3, GL_FLOAT, 0, 0, 0 );

        glEnableClientState( GL_VERTEX_ARRAY );
        glBindBuffer( GL_ARRAY_BUFFER, mPositionVBOHandle );
        glVertexPointer( 3, GL_FLOAT, 0, 0 );

        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIndexVBOHandle);
}

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

        glClientActiveTextureARB(GL_TEXTURE0_ARB);
        glDisableClientState(GL_TEXTURE_COORD_ARRAY);

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

---