C:/Projekte/C++/FlowVIS_107/src/Arrows.cpp

Go to the documentation of this file.

#include "Arrows.h"
#include "Texture.h"

#include <QColorDialog>

Arrows::Arrows(QWidget* parent /*= 0*/) : QObject(parent)
{
  m_flowData = NULL;
  m_pointSize = 2.0f;;
  // resolution of arrows -> (1 == 1 arrow), (100 == 100 in x/y arrows)
  m_resolution = 1;

  m_parent = parent;

  // nk - no background specified for scale coding
  m_backgroundData = NULL;

  // nk - deactive point scaling with background by default
  m_scalePoints = false;

  // nk - arrows are white by default
  m_arrowColor = QColor(Qt::white);

  connect(m_parent, SIGNAL(setPointSize(int)), this, SLOT(setPointSize(int)));
  connect(m_parent, SIGNAL(setResolution(int)), this, SLOT(setResolution(int)));
  connect(m_parent, SIGNAL(setActivePointScale(bool)), this, SLOT(setActivePointScale(bool)));

  connect(m_parent, SIGNAL(setArrowColor()), this, SLOT(setColor()));

  // nk - load shader
  m_psShader = new Shader();
  m_psShader->Load("sprite.vert", "sprite.frag");
  m_spriteTexLoc = glGetUniformLocation(m_psShader->GetProgram(), "SpriteTexture");
  m_angleLoc = glGetUniformLocation(m_psShader->GetProgram(), "angle");

  m_psShader->Bind();  
    glUniform1i( m_spriteTexLoc, 0 ); // nk - set sprite texture to texture unit 0
  m_psShader->Unbind();
}


Arrows::~Arrows()
{
  delete m_psShader;
}

void Arrows::setActiveBackground(int bg)
{
  // if file closed method is called with (-1)
  if(bg == -1)
  {
    m_backgroundData = NULL;
    return;
  }
    

  int backgroundId = -1;

  for(int i = 0; i < m_flowData->getChannelCount(); i++)
  {
    if(m_flowData->getIsScalar(i) == NORMALIZED)
    {
      backgroundId = i;
      break;
    }
  }

  if(bg < m_flowData->getScalarChannelCount())
  {
    backgroundId += bg;
    m_backgroundData = m_flowData->getChannel(backgroundId);
  }
  else
  {
    m_backgroundData = NULL;
  }
}

void Arrows::setResolution(int res)
{
  //printf("SetResolution %d\n", res);
  m_resolution = res;
  m_parent->update();
}

void Arrows::setPointSize(int size)
{
  //printf("SetPointSize %d\n", size);
  m_pointSize = (float) size;
  m_parent->update();
}

void Arrows::setActivePointScale(bool ps)
{
  m_scalePoints = ps;
  m_parent->update();
}

void Arrows::setColor()
{
  printf("Arrows: Set Color\n");
  QColor white = QColor(Qt::white);

  // nk - get new color from dialog
  m_arrowColor = QColorDialog::getColor(white);

  // if cancel button hit - color not valid -> set to white
  if(!m_arrowColor.isValid())
  {
    printf("New Arrow Color not valid - set to white\n");
    m_arrowColor = white;    
  }
}


void Arrows::setFlowData(FlowData* data)
{
  if(data == NULL)
  {
    printf("No flow data set in class Arrows\n");
    return;
  }

  m_flowData = data;
  m_geom = m_flowData->getGeometry();

  m_dataDimX = m_geom->getDimX();
  m_dataDimY = m_geom->getDimY();

  Texture texture;

  // generate textureID for glyph
  glGenTextures(1, &m_glyphTexID);

  // init glyph texture for point sprite
  m_glyphTexID = texture.CreateGlyph();
}


void Arrows::draw()
{
  float xTick = 1.0f / (float) m_resolution;
  float yTick = 1.0f / (float) m_resolution;
  
  float xRes = 0.0f;
  float yRes = 0.0f;

  glPushMatrix();

  float oldColor[4];
  glGetFloatv( GL_CURRENT_COLOR, oldColor );

  glEnable(GL_BLEND);
  glBlendFunc(GL_SRC_ALPHA, GL_ONE);

  glColor3f(m_arrowColor.redF(), m_arrowColor.greenF(), m_arrowColor.blueF());

  glActiveTexture(GL_TEXTURE0);
  glEnable(GL_TEXTURE_2D);
  glEnable(GL_POINT_SPRITE_ARB);
  glBindTexture(GL_TEXTURE_2D, m_glyphTexID);
  glTexEnvf(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE);
  glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_NONE);

  int index = 0;
  vec3 pos, vel;
  vec3 nullVel; 
  FlowChannel* chX = m_flowData->getChannel(X);
  FlowChannel* chY = m_flowData->getChannel(Y);


  for(int y = 0; y < m_dataDimY; y++)
  {
    // nk - get y-index of data (we have only rectlinear grids here)
    index = y * m_dataDimX;

    // nk - get position in geometry array
    pos = m_geom->getNormPos(index);

    // nk - yRes = distribution of arrows in y-direction
    if(pos[Y] < yRes)
      continue;

    // nk - if new value found -> increase value for next search
    yRes += yTick;

    // nk - set xRes to zero for inner loop
    xRes = 0.0f;

    for(int x = 0; x < m_dataDimX; x++)
    {
      // nk - get x-index within "row"
      index = y * m_dataDimX + x;

      // nk - get normalized position from grid
      pos = m_geom->getNormPos(index);

      // nk - xRes -> distribution of arrows in x-dir
      if(pos[X] < xRes)// || pos[Y] < yRes)
      {
        continue;
      }

      // nk - new value found -> increase value for next hit
      xRes += xTick;
      
      vel = vec3(chX->getValue(index), chY->getValue(index), 0.0); // , chZ->getValue(index));

      // if no velocity occurs (e.g. inside the block - continue drawing next index)
      if(vel == nullVel)
        continue;

      GLfloat angle = atan2(vel[Y], vel[X]);

      if((m_backgroundData != NULL) && (m_scalePoints == true))
      { 
        // nk - draw points scaled by background if selected
        glPointSize(m_pointSize * m_backgroundData->getValue(index));
      }
      else
      {
        glPointSize(m_pointSize);
      }
       printOglError("m_pointSize");

      m_psShader->Bind();

      glUniform1f( m_angleLoc, angle); 

      // nk - draw arrow with point sprites on grid
      glBegin(GL_POINTS);
        glVertex2f(pos.v[X], pos.v[Y]);
      glEnd();

      m_psShader->Unbind();
    }
  }

  glColor4fv(oldColor);

  glDisable(GL_POINT_SPRITE_ARB);
  glDisable(GL_TEXTURE_2D);
  glDisable(GL_BLEND);

  glPopMatrix();
}

---