Eigene Dateien/FlowVis/src/VStreamLine.h

Go to the documentation of this file.

#pragma once

#ifndef _v_stream_line_h
#define _v_stream_line_h

#include "VVector.h"
#include <vector>
class VStreamLine
{
public:
        
        VStreamLine();

        VStreamLine(std::vector<VVector> m_Positions);

        VStreamLine(std::vector<VVector> m_Positions, std::vector<float> m_TaperFactors);

        VStreamLine(const VStreamLine & rhs)
        {
                if(this != &rhs)
                {

                                clearVBO();

                                mPositions.clear();
                                mIndices.clear();
                                mTaperFactors.clear();

                        
                        mPositions = rhs.mPositions;
                        mIndices = rhs.mIndices;
                        mIndexVBOHandle = rhs.mIndexVBOHandle;
                        mPositionVBOHandle = rhs.mPositionVBOHandle;
                        mTaperFactors = rhs.mTaperFactors;
                        mTaperVectors = rhs.mTaperVectors;

                }
        }

        
        ~VStreamLine()
        {

                        clearVBO();

                mPositions.clear();
                mIndices.clear();
                mTaperFactors.clear();
                mTaperVectors.clear();
        }

        VStreamLine & operator=(const VStreamLine & rhs)
        {
                if(this != &rhs)
                {

                        clearVBO();

                        mPositions.clear();
                        mIndices.clear();
                        mTaperFactors.clear();
                        mTaperVectors.clear();

                
                        mPositions = rhs.mPositions;
                        mIndices = rhs.mIndices;
                        mIndexVBOHandle = rhs.mIndexVBOHandle;
                        mPositionVBOHandle = rhs.mPositionVBOHandle;
                        mTaperFactors = rhs.mTaperFactors;
                        mTaperVectors = rhs.mTaperVectors;

                }
                return (*this);
        }

        void draw( bool tap, float scale  , bool glyph);

        int getNumberOfPoints( )
        {
                return (int)mPositions.size();
        }


        void setSeparation( float dsep, float dtest )
        {
                m_Separation_dsep = dsep;
                m_Separation_dtest = dtest;
        }

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


        void computeThicknessCoefficients( float dtest, float dsep, std::vector<  VStreamLine > others, int itself, float datasizemax  );

        void clearVBO();

        bool isPointAllowed(VVector m_Point, float m_Epsilon);

        float getMinimalDistance( VVector m_Point );

        void setThicknessCoefficient( std::vector< float > thickness )
        {
                mTaperFactors = thickness;
        }

        bool isPointAllowed(VVector m_Point, float m_Epsilon, float * m_Distance);

        bool interSectsStreamLine(VVector m_Point1, VVector m_Point2);

        void regenerateVBO()
        {
                generateVBO();
        }

        void loadStreamLine( FILE * m_FilePointer );

        void saveStreamLine( FILE * m_FilePointer );

private:

        void generateVBO();

        void activateVBO();

        void deactivateVBO();

        
        std::vector<VVector> mPositions;                
        std::vector<int> mIndices;                              
        unsigned int mPositionVBOHandle;                
        unsigned int mIndexVBOHandle;                   
        std::vector<float> mTaperFactors;               
        std::vector<VVector> mTaperVectors;             
        unsigned int mTaperVBOHandle;                   
        float m_Separation_dsep;
        float m_Separation_dtest;

};

#endif //_v_stream_line_h

---