Eigene Dateien/FlowVis/src/VFlowData.h

Go to the documentation of this file.

#pragma once

#ifndef _v_flow_data_h
#define _v_flow_data_h

#include "VVector.h"

#include <string>
#include <vector>

#include "VgridHeader.h"
#include "VtimeStep.h"
#include "VProgram.h"
#include "VMatrix.h"
#include "VFramebufferObject.h"
#include "VStreamLine.h"
#include "VIcon.h"

struct vVector4Dim
{
        float x;
        float y;
        float z;
        float w;
};

enum PlacingMethod
{
        LEFT = 0,               
        TOP,                    
        BOTTOM,                 
        RIGHT,
        ALL,
        RANDOM,
        MANUAL,
        EVEN
};

class VFlowData
{
public:

        VFlowData();

        ~VFlowData();

        VFlowData( std::string m_FileName );

        bool loadData( std::string m_FileName );

        bool loadData( std::string m_FileName, std::string m_DatFilename);

        void draw( int m_TimeStep = 0 );

        void drawPoints( int m_TimeStep = 0 );

        void drawStreamLines( VVector  *col);

        void drawIcons();

        void addIconPoint(float x, float y);

        void drawTextureTest( int m_TimeStep = 0 );

        int getNumDataValues()
        {
                return mHeader.mNF + 1;
        }

        int getNumTimeSteps()
        {
                return mHeader.mNT;
        }

        VVector getFlowCenter()
        {
                return mCenterPos;
        }

        VVector getMinPos()
        {
                return mMinPos;
        }

        VVector getMaxPos()
        {
                return mMaxPos;
        }

        VVector getFlowExtends()
        {
                return mExtends;
        }

        float * getExtends()
        {
                return mExtends.getPtr();
        }

        float getMaximalMagnitude()
        {
                return maxDataValues[ 0 ];
        }

        float getMinimalMagnitude()
        {
                return minDataValues[ 0 ];
        }


        float getMaximalDatavalue( int index )
        {
                return maxDataValues[ index ];
        }

        float getMinimalDatavalue( int index )
        {
                return minDataValues[ index ];
        }

        bool getTexturesGenerated()
        {
                return mTexturesGenerated;
        }

        void setStreamlinesSeedSeparation( float val )
        {
                mStreamlinesSeedSeparation = val;
        }

        void setStreamlinesTestSeparation( float val )
        {
                mStreamlinesTestSeparation = val;
        }

        void setStreamlinesSteps( float val )
        {
                mStreamlinesSteps = val;
        }

        void setStreamlinesDt( float val )
        {
                mStreamlinesDt = val;
        }

        void setTaperingState( bool state )
        {
                mTapering = state;
        }

        void setStrGlyphes( bool state )
        {
                mStrGlyphes = state;
        }

        void setTaperingScale( float val )
        {
                mTaperingScale = val;
        }

        void setIntegrationMethod( bool val )
        {
                mEuler = (val) ? 1.0f : 0.0f;
        }

        void generateGlyphIndices( int m_NumX, int m_NumY );

        void generateTextures();

        void generateCPUStreamLines(  float m_MaxSteps, float m_StreamSeparation, int m_TimeStep = 0 );

        std::vector<VVector> VFlowData::generateCPUStreamSingleWithTests( std::vector<VStreamLine> otherStreamlines, 
                float x, float y, float m_MaxSteps, float dtest, int m_TimeStep /* = 0  */);

        std::vector<VVector> VFlowData::generateCPUStreamSingleWithoutTests( float x, float y, float dtest, 
                float m_MaxSteps, int m_TimeStep /* = 0  */ );


        void VFlowData::generateCPUStreamLinesLEFT( float m_MaxSteps, float m_StreamSeparation, int m_TimeStep /* = 0  */ );

        void VFlowData::generateCPUStreamLinesTOP( float m_MaxSteps, float m_StreamSeparation, int m_TimeStep /* = 0  */ );
 
        void VFlowData::generateCPUStreamLinesRIGHT( float m_MaxSteps, float m_StreamSeparation, int m_TimeStep /* = 0  */ );
         
        void VFlowData::generateCPUStreamLinesBOTTOM( float m_MaxSteps, float m_StreamSeparation, int m_TimeStep /* = 0  */ );
         
        void VFlowData::generateCPUStreamLinesALL( float m_MaxSteps, float m_StreamSeparation, int m_TimeStep /* = 0  */ );
         
        void VFlowData::generateCPUStreamLinesRANDOM( float m_MaxSteps, float m_StreamSeparation, int m_TimeStep /* = 0  */ );
         
        void VFlowData::generateCPUStreamLinesMANUAL( float m_MaxSteps, float m_StreamSeparation, int m_TimeStep /* = 0  */ );
 
        void VFlowData::generateCPUStreamLinesEVEN( float m_MaxSteps, float m_StreamSeparation, int m_TimeStep /* = 0  */ );

        void VFlowData::generateCPUStreamLinesLEFT_RK2( float m_MaxSteps, float m_StreamSeparation, int m_TimeStep /* = 0  */ );

        void VFlowData::generateCPUStreamLinesTOP_RK2( float m_MaxSteps, float m_StreamSeparation, int m_TimeStep /* = 0  */ );
 
        void VFlowData::generateCPUStreamLinesRIGHT_RK2( float m_MaxSteps, float m_StreamSeparation, int m_TimeStep /* = 0  */ );
         
        void VFlowData::generateCPUStreamLinesBOTTOM_RK2( float m_MaxSteps, float m_StreamSeparation, int m_TimeStep /* = 0  */ );
         
        void VFlowData::generateCPUStreamLinesALL_RK2( float m_MaxSteps, float m_StreamSeparation, int m_TimeStep /* = 0  */ );
         
        void VFlowData::generateCPUStreamLinesRANDOM_RK2( float m_MaxSteps, float m_StreamSeparation, int m_TimeStep /* = 0  */ );
         
        void VFlowData::generateCPUStreamLinesMANUAL_RK2( float m_MaxSteps, float m_StreamSeparation, int m_TimeStep /* = 0  */ );
 
        void VFlowData::generateCPUStreamLinesEVEN_RK2( float m_MaxSteps, float m_StreamSeparation, int m_TimeStep /* = 0  */ );

        void VFlowData::addManualSeedpoint( float x, float y );

        // * pushes the new seedpoint in texture space to the evenly sp. seedpoints list
        // * @param x is the world x-coordinate of the seedpoint in texture space to be added
        // * @param y is the world y-coordinate of the seedpoint in texture space to be added
        // */
        //void VFlowData::addManualSeedpointWithDsepTest( float m_TimeStep, float m_MaxSteps  );

        void drawStreamlinesFromSeedpoints( float m_MaxSteps, float m_TimeStep );

        // * draws the evenly spaced streamlines
        // */
        //void VFlowData::drawEvenlySpacedStreamlines( float m_TimeStep, float m_MaxSteps  );

        bool isIndexOfManualPlacingMethod( int val );

        bool isIndexOfEvenPlacingMethod( int val );

        void setPlacingMethod( int val );

        unsigned int getVelocityHandle( int m_TimeStep )
        {
                if(m_TimeStep > (int)mTimeSteps.size())
                {
                        m_TimeStep = 0;
                }
                return mTimeSteps[m_TimeStep].mFrameBufferObject->getTextureHandle();
        }

        float * getVertexToTexture()
        {
                return &mVertexToTexture[0];
        }

        float * getTextureToVertex()
        {
                return &mTextureToVertex[0];
        }

        void loadStreamLines( std::string m_FileName );

        void saveStreamLines( std::string m_FileName );

        void setIconScale( int m_IconScale )
        {
                if ( mIcons.empty() ) return;

                mIconScale = m_IconScale;
                mIcons[ mIcons.size() - 1 ].setScale( ( float )m_IconScale / 100.0f );
                mIcons[ mIcons.size() - 1 ].computeIcon( &mTimeSteps[0] , mActiveTimeStep );
        }

        void setTailLength( int m_TailLength )
        {
                if ( mIcons.empty() ) return;

                mTailLength = m_TailLength;
                mIcons[ mIcons.size() - 1 ].setTailLength( ( float )m_TailLength / 100.0f );
                mIcons[ mIcons.size() - 1 ].computeIcon( &mTimeSteps[0] , mActiveTimeStep );
        }

        void setTimeStep( int val )
        {
                mActiveTimeStep = val;
        }

        void computeIcons();

private:

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

        bool readGrid( std::string m_FileName );

        bool readDat( std::string m_FileName );

        void generateVBO();

        void activateVBO( int m_TimeStep = 0 );

        void deactivateVBO();

        void clear();


        double round(double Zahl, int Stellen)
        {
                double v[] = { 1, 10, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8 };  // mgl. verlängern
                return floor(Zahl * v[Stellen] + 0.5) / v[Stellen];
        }

        
        vGridHeader mHeader;                                                    
        std::vector<VVector> mVertexGrid;                               
        unsigned int mVertexVbo;                                                
        VMatrix mVertexToTexture;                                               
        VMatrix mTextureToVertex;                                               
        std::vector<int> mIndexGrid;                                    
        unsigned int mIndexVbo;                                                 
        std::vector<vTimeStep> mTimeSteps;                              
        int mActiveTimeStep;                                                    
        float mNumTriplets;                                                             
        std::vector<int> mGlyphIndexGrid;                               
        unsigned int mGlyphIndexVbo;                                    
        VVector mMinPos;                                                                
        VVector mMaxPos;                                                                
        VVector mCenterPos;                                                             
        VVector mExtends;                                                               
        VVector mMinDistance;                                                   
        bool mReverseX;                                                                 
        bool mReverseY;                                                                 
        std::vector< float > maxDataValues;                             
        std::vector< float > minDataValues;                             
        bool mTexturesGenerated;                                                
        float mStreamlinesTestSeparation;                               
        float mStreamlinesSeedSeparation;                               
        float mStreamlinesSteps;                                                
        float mStreamlinesDt;                                                   
        float mEuler;                                                                   
        bool mTapering;                                                                 
        float mTaperingScale;                                                           
        PlacingMethod mSeedPlacing;                                             
        std::vector<VVector> mManualSeedpoints;                                         
        std::vector<VVector> mEvenlySeedpoints;                                         
        VStreamLine *streamlines;
        int mNumStreamlines;

        static VProgram * mRenderTextureProgram;                
        float mIconScale;                                                               
        float mTailLength;                                                              
        std::vector<VIcon> mIcons;                                              
        bool mStrGlyphes;                                                               
};

#endif // _v_flow_data_h

---