C:/Projekte/C++/FlowVIS_107/src/StreamLine.h

Go to the documentation of this file.

#ifndef STREAMLINE_H
#define STREAMLINE_H

#include "common.h"
#include "FlowGeometry.h"
#include "FlowData.h"
#include "StreamLineGrid.h"

#include <vector>


using namespace std;


#define FORWARD       0   // forward-integration
#define BACKWARD      1   // backward-integration


struct slSamplePoint
{  
  vec3  point;      // sample-point
  vec3  tPoint;     // 2nd point used for tapering-effect (distance to point == thickness)
  vec3  direction;  // direction of the movement in the current point; needed for glyphs
};

struct slStreamLine
{
  vector<slSamplePoint> streamLine;   // list of sample-points of one streamline, i.e., this IS one streamline
};


class StreamLine
{
  friend class StreamLineGrid;

public:

  StreamLine( FlowData *fd );

  ~StreamLine();

  void create();

  void create( float dSep, float dTest, bool linesActive, bool taperingActive, bool glyphActive );

  void draw();

  void reset();


  // --- Getter and Setter --- //

  void setDSep( float dSep ) { m_dSep = dSep; }

  float getDSep() { return m_dSep; }

  void setDTest( float dTest ) { m_dTest = m_dSep * dTest; }

  float getDTest() { return (m_dTest / m_dSep); }

  void setGlyphSize( int size ) { m_glyphSize = size; }

  int getGlyphSize() { return m_glyphSize; }

  void setGlyphDistance( int distance ) { m_glyphDistance = distance; }

  int getGlyphDistance() { return m_glyphDistance; }

  void setLineColor( float* color )
  { 
    // seems to be a safe way in c++ :(
    m_lineColor = new float[4];

    m_lineColor[0] = color[0]; 
    m_lineColor[1] = color[1]; 
    m_lineColor[2] = color[2]; 
    m_lineColor[3] = color[3]; 
  }

  float* getLineColor() { return m_lineColor; }

  void setGlyphColor( float* color )
  { 
    // seems to be a safe way in c++ :(
    m_glyphColor = new float[4];

    m_glyphColor[0] = color[0]; 
    m_glyphColor[1] = color[1]; 
    m_glyphColor[2] = color[2]; 
    m_glyphColor[3] = color[3]; 
  }

  float* getGlyphColor() { return m_glyphColor; }

  void setIntegrationMethod( short method ) { m_integrationMethod = method; }

  short getIntegrationMethod() { return m_integrationMethod; }

  void setLinesActive( bool isActive ) { m_isLinesActive = isActive; }

  bool getLinesActive() { return m_isLinesActive; }

  void setTaperingActive( bool isActive ) { m_isTaperingActive = isActive; }

  bool getTaperingActive() { return m_isTaperingActive; }

  void setGlyphActive( bool isActive ) { m_isGlyphActive = isActive; }

  bool getGlyphActive() { return m_isGlyphActive; }


private:

  float getRandomFloat( int rnd );

  float toRad( float grad );

  vec3 rotateVector( vec3 vector, float phi );

  void createInitialStreamLine();

  void createStreamLine( vec3 pos );

  vector<slSamplePoint> doIntegration( vec3 pos, bool integration );

  void createSeedPoints();

  bool isValidSeedPoint( vec3 point );

  vec3 calculateEulerPosition( vec3 pos, vec3 vel );

  vec3 calculateRungeKutta2Position( vec3 pos, vec3 vel, bool integration );

  float calculateThicknessCoeff( float distance );

  void drawStreamLines();

  void drawStreamLinesWithoutTapering();

  void drawStreamLinesWithTapering();

  void drawGlyphs();

  bool createGlyphTexture();

  void setTestParameters();


private:
  
  FlowData *m_flowData;

  FlowGeometry *m_flowGeometry;

  StreamLineGrid *m_slgGrid;

  vector<slStreamLine> m_streamLines;

  vector<vec3> m_seedPoints;

  float m_dSep;

  float m_dTest;

  float m_d;

  int m_maxSteps;

  int m_maxLines;

  int m_glyphSize;

  int m_glyphDistance;

  float m_maxLineThickness;

  short m_integrationMethod;

  float *m_lineColor;

  float *m_glyphColor;

  GLuint m_glyphTexId;

  bool m_isLinesActive;

  bool m_isTaperingActive;

  bool m_isGlyphActive;

};


#endif

---