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

Go to the documentation of this file.

#include "OpenGLWidget.h"
#include <iostream>
#include <QColorDialog>
#include <QMouseEvent>
#include <QColor>

using namespace std;

OpenGLWidget::OpenGLWidget(QWidget* parent /*= 0*/, Qt::WFlags flags /*= 0*/) : QGLWidget(parent)
{
  setupUi(this);
  m_parent = parent;
  cout << "Creating OpenGLWidget..." << endl;

  m_isActiveBackground = false;
  m_isActiveArrows = false;

  m_isActiveStreamlines = false;
  m_isActiveTransferFunction = false;

  m_clearColor = QColor(Qt::black);
  m_flowData = NULL;

  m_librariesInitialised = false;
  m_isFileOpen = false;
  m_aspectRatio = 1.0f;

  m_streamLine = NULL;

  m_defaultOrtho.left = 0.0;
  m_defaultOrtho.right = 1.0;
  m_defaultOrtho.bottom = 1.0;
  m_defaultOrtho.top = 0.0;

  // nk - set current view to default at startup/reset
  m_currentOrtho = m_defaultOrtho;

  // generate textureIDs for backgroundTexture
  //glGenTextures(max_channels, m_backgroundTexID);
}



OpenGLWidget::~OpenGLWidget()
{
}

void OpenGLWidget::initializeGL()
{
        cout << "initializeGL... " << endl;
        // qDebug() << "init";

  if ( !m_librariesInitialised )
  {
          initGlew();  // Initialize Glew Extension Wrangler
          initDevIL(); // Initialize Image Library Lib (for textures)

    if ( !glewIsSupported( "GL_VERSION_2_0" ) )
    {
      cout << "OpenGL-Version 2.0 not supported!" << endl;
      exit( 1 );
    }

    m_librariesInitialised = true;
  }

  // load shader
  m_colorLookupShader = new Shader();
  m_colorLookupShader->Load("colorLookup.vert", "colorLookup.frag");

  m_tfTextureLocation = glGetUniformLocation(m_colorLookupShader->GetProgram(), "tfTexture");
  m_bgTextureLocation = glGetUniformLocation(m_colorLookupShader->GetProgram(), "bgTexture");
  m_showTfLocation = glGetUniformLocation(m_colorLookupShader->GetProgram(), "showTF");

  m_colorLookupShader->Bind();
  glUniform1i( m_bgTextureLocation, 0); // nk - set bg texture to texture unit 0
  glUniform1i( m_tfTextureLocation, 1 ); // nk - set tf texture to texture unit 1
  m_colorLookupShader->Unbind();

  m_arrows = new Arrows(this);

  // set clear color
  qglClearColor( m_clearColor );
  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}

void OpenGLWidget::resizeGL(int width, int height)
{
  printf("Resize GL\n");

  m_windowWidth = width;
  m_windowHeight = height;

  setDataView();
}

void OpenGLWidget::resetDataView()
{
  setDataView(true);
  this->update();
}

void OpenGLWidget::setDataView(bool reset)
{
  // set aspect ratio of viewport
  if(m_isFileOpen)
  {
    if(m_dataDimY <= 0)
    {
      printf("m_dataDimY invalid\n");
      exit(-1);
    }

    //TODO: WindowAspect
    m_aspectRatio = m_dataDimX / (float) m_dataDimY;

    if(m_aspectRatio < 1.0)
    {
      int centerX = m_windowWidth / 2;
      glViewport(centerX - m_dataDimX / 2, 0, m_windowWidth * m_aspectRatio, m_windowHeight);
    }
    else
    {
      glViewport(0, 0, m_windowWidth, m_windowHeight);
    }

    if(reset == true)
    {
      printf("Reset DataView\n");
      m_currentOrtho = m_defaultOrtho;
    }

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(m_currentOrtho.left, m_currentOrtho.right, m_currentOrtho.bottom, m_currentOrtho.top);

    //gluOrtho2D(0.0, 1.0, 1.0, 0.0); // because of left-handed y-axes, flip view!
    //was: gluOrtho2D(0.0, 1.0, 0.0, 1.0);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity ();
  }
  else
  {
    glViewport(0, 0, m_windowWidth, m_windowHeight);

    glMatrixMode(GL_PROJECTION);
          glLoadIdentity();

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity ();
  }
}

void OpenGLWidget::setActiveBackground(int bg)
{
  if(!m_isFileOpen)
    return;

  printf("SetBackground\n");

  int bgCount = m_flowData->getScalarChannelCount();

  if(bg >= bgCount) // background: none
  {
    m_isActiveBackground = false;
    m_arrows->setActiveBackground(-1);
    this->update();
  }
  else
  {
    m_isActiveBackground = true;
    m_activeBackground = bg;
    m_arrows->setActiveBackground(bg);
    this->update();
  }
}


void OpenGLWidget::setColorBarTexture(QGradientStops stops)
{
  printf("setColorBarTexture\n");
  Texture texture;
  glGenTextures(1, &m_colorBarTexID);
  glBindTexture(GL_TEXTURE_1D, m_colorBarTexID);
  m_colorBarTexID = texture.CreateColorBar(stops);
  printOglError("CreateColorBar");

  update();
}

void OpenGLWidget::updateStreamLines()
{
  printf("Update Streamlines\n");

  if(m_isActiveStreamlines)
  {
    m_streamLine->create();
    this->update();
  }
}

void OpenGLWidget::selectStreamLineColor()
{
  printf("Select Streamline Color\n");

  QColor white = QColor(Qt::white);
  QColor color;

  color = QColorDialog::getColor(white);

  if(!color.isValid())
  {
    printf("New Streamline color not valid - set to white\n");
    color = white;
  }
  float slColor[4];

  slColor[0] = (float) color.redF();
  slColor[1] = (float) color.greenF();
  slColor[2] = (float) color.blueF();
  slColor[3] = (float) color.alphaF();

  // nk - set color in streamline
  m_streamLine->setLineColor(slColor);
}

void OpenGLWidget::setStreamGlyphSize(int gs)
{
  m_streamLine->setGlyphSize(gs);
}

void OpenGLWidget::setStreamGlyphDistance(int gd)
{
  m_streamLine->setGlyphDistance(gd); 
}

void OpenGLWidget::setEuler()
{
  m_streamLine->setIntegrationMethod(EULER);
}

void OpenGLWidget::setRungeKutta()
{
  m_streamLine->setIntegrationMethod(RUNGE_KUTTA2);
}


void OpenGLWidget::selectStreamGlyphColor()
{
  printf("Select Streamline Glyph Color\n");

  QColor white = QColor(Qt::white);
  QColor color;

  color = QColorDialog::getColor(white);

  if(!color.isValid())
  {
    printf("New Streamline Glyph Color not valid - set to white\n");
    color = white;
  }

  float slColor[4];

  slColor[0] = (float) color.redF();
  slColor[1] = (float) color.greenF();
  slColor[2] = (float) color.blueF();
  slColor[3] = (float) color.alphaF();

  m_streamLine->setGlyphColor(slColor);
}


void OpenGLWidget::createStreamLines()
{
  cout << "createStreamLines..." << endl;
/*
  // create streamlines
  if ( m_flowData != NULL ) 
  {
    m_streamLine = new StreamLine( m_flowData );
    m_streamLine->create();
  }
*/
}


void OpenGLWidget::setFlowData(FlowData* data)
{
  m_flowData = data;

  // nk - moved into 
  // Init flow textures
  // if(m_flowData != NULL) ...

  //if ( m_flowData == NULL && m_streamLine != NULL )
  //{
  //  m_streamLine->reset();
  //}
  //else // if ( m_flowData != NULL ) <-- else error
  //{
  //  // throws exception at file close when nothing is openend
  //  m_streamLine = new StreamLine( m_flowData );
  //  //m_streamLine->create(); // via update button
  //}

  Texture texture;

  // Init flow textures
  if(m_flowData != NULL)
  {
    m_isFileOpen = true;

    m_geomData = m_flowData->getGeometry();

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

    m_arrows->setFlowData(data);

    setDataView();

    if(m_streamLine == NULL)
    {
      m_streamLine = new StreamLine(m_flowData);
    }
    else
    {
      m_streamLine->reset();
    }

    int bgTexture = 0;

    // TODO: Texture generation for scalar data
    for(int i = 0; i < data->getChannelCount(); i++)
    {
      if(data->getIsScalar(i) == NORMALIZED)
      {
        printf("ChannelCount: %d, Channel(%d): Background\n",data->getChannelCount(), i);
        texture.CreateBackground(data->getChannel(i), m_dataDimX, m_dataDimY, m_backgroundTexID, bgTexture);
        bgTexture++;
      }
    }
  }
  else
  {
    m_isFileOpen = false;
    int bgTexture = 0;

    delete m_streamLine;
    m_streamLine = NULL;

    // TODO: delete textures
    for(int i = 0; i < max_channels; i++)
    {
       texture.Delete(i);
    }

  }
}

void OpenGLWidget::setActiveArrows(bool gl)
{
  m_isActiveArrows = gl;
  this->update();
}

void OpenGLWidget::setActiveTransferFunction(bool tf)
{
  m_isActiveTransferFunction = tf;
  this->update();
}

void OpenGLWidget::setLinesActive(bool isActive)
{
  m_isActiveStreamlines = isActive;
  m_streamLine->setLinesActive(m_isActiveStreamlines);
  if(isActive)
  {
    m_streamLine->create();    
  }

  this->update();
}

void OpenGLWidget::setDSep( int dSep )
{
  float value = dSep / (float) MAX_SLIDER_VALUE;
  m_streamLine->setDSep(value);

  //printf("dsep: %f\n", value); nk - values ok
}
void OpenGLWidget::setDTest( int dTest )
{
  float value = dTest / (float) MAX_SLIDER_VALUE;
  m_streamLine->setDTest(value);

  //printf("dtest: %f\n", value); // nk - values ok
}

void OpenGLWidget::setTaperingActive( bool isActive )
{
  m_streamLine->setTaperingActive(isActive);
  this->update();
}
void OpenGLWidget::setGlyphActive( bool isActive )
{
  m_streamLine->setGlyphActive(isActive);
  this->update();
} 

void OpenGLWidget::drawBackground()
{
  glActiveTexture(GL_TEXTURE0);
  glEnable(GL_TEXTURE_2D);
  glBindTexture(GL_TEXTURE_2D, m_backgroundTexID[m_activeBackground]);
  glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_NONE);
  
  glActiveTexture(GL_TEXTURE1);
  glEnable(GL_TEXTURE_1D);
  glBindTexture(GL_TEXTURE_1D, m_colorBarTexID);
  glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_NONE);
  
  glPushMatrix();

  vec3 pos;
  int index;
  float texX, texY;
  
  // use shader program
  m_colorLookupShader->Bind();

    glUniform1i(m_showTfLocation, m_isActiveTransferFunction);

    for(int y = 1; y < m_geomData->getDimY(); y++)
    {
      glBegin(GL_TRIANGLE_STRIP);
      //glBegin(GL_POINTS); /// shows grid
      for(int x = 0; x < m_geomData->getDimX(); x++)
      {
        index = y * m_dataDimX + x;

        // nk - get normalized position from geometry data array
        pos = m_geomData->getNormPos(index);
        
        // nk - texX stays constant for this and 2nd index
        texX = x / (float) (m_geomData->getDimX() - 1);

        // nk - texture generation must be ok - but assigning to grid was wrong indeed
        texY = y / (float) (m_geomData->getDimY() - 1);
        glTexCoord2f(texX, texY);
        glVertex2fv(pos.v);

        index = (y-1) * m_dataDimX + x;
        pos = m_geomData->getNormPos(index);
        texY = (y-1) / (float) (m_geomData->getDimY() - 1);
        //nk - wrong glTexCoord2f(pos[X], pos[Y]);
        glTexCoord2f(texX, texY);
        glVertex2fv(pos.v);
      }
      glEnd();
    }
  
  m_colorLookupShader->Unbind();

  glDisable(GL_TEXTURE_1D);
  glDisable(GL_TEXTURE_2D);

  glPopMatrix();
}

void OpenGLWidget::paintGL()
{
  glClear( GL_COLOR_BUFFER_BIT );
  glDisable( GL_DEPTH_TEST );

  // do nothing if no file loaded
  if ( !m_isFileOpen )
    return;

  glColor3f(0.0f, 0.0f, 0.0f);

  //TEST: enable background texture
  if ( m_isActiveBackground )
  {
    drawBackground();
  }

  if ( m_isActiveArrows )
  {
    m_arrows->draw();
  }

  // gv show for streamlines
  if ( m_isActiveStreamlines )
  {
    m_streamLine->draw();
  }

}



void OpenGLWidget::wheelEvent(QWheelEvent *we)
{
  //nk - use mouse wheel for zoom
  float zoom = 0.0f;

  if(we->delta() > 0) // zoom in
  {
    zoom = 0.01f;

  }
  else // zoom out
  {
    zoom = -0.01f;
  }

  // nk - add zoom to current ortho matrix
  m_currentOrtho.left   += zoom;
  m_currentOrtho.right  -= zoom;
  m_currentOrtho.bottom -= zoom;
  m_currentOrtho.top    += zoom;

  // nk - update view
  setDataView();
  this->update();

  //printf("Zoom: %f\n", zoom);
}

void OpenGLWidget::mouseMoveEvent(QMouseEvent* me)
{
  float panX = 0.01f;
  float panY = 0.01f;

  // nk - left button -> panX
  if(m_panXButton == Qt::LeftButton)
  {
    if(me->x() > m_currentMousePos.x())
    {
      m_currentOrtho.left += panX;
      m_currentOrtho.right += panX;
    }
    else
    {
      m_currentOrtho.left -= panX;
      m_currentOrtho.right -= panX;
    }

    setDataView();
    this->update();
  }
  else 
    if (m_panYButton == Qt::RightButton)
    {
      if(me->y() > m_currentMousePos.y())
      {
        m_currentOrtho.bottom += panY;
        m_currentOrtho.top += panY;
      }
      else
      {
        m_currentOrtho.bottom -= panY;
        m_currentOrtho.top -= panY;
      }
      
      setDataView();
      this->update();
    }
}

void OpenGLWidget::mousePressEvent(QMouseEvent *pe)
{
  // nk - use left button for panX
  if(pe->button() == Qt::LeftButton)
  {
    m_panXButton = pe->button();
    m_currentMousePos = pe->pos();
  }

  // nk - use right button for panY
  if(pe->button() == Qt::RightButton)
  {
    m_panYButton = pe->button();
    m_currentMousePos = pe->pos();
  }
}

void OpenGLWidget::mouseReleaseEvent(QMouseEvent* re)
{
  // nk - release button
  m_panXButton = Qt::NoButton;
  m_panYButton = Qt::NoButton;
}

void OpenGLWidget::initGlew()
{
        // Initialize GLEW
        cout << "- Initializing GLEW ..." << endl;
        GLenum err = glewInit();

        if (err != GLEW_OK)
        {
                // glewInit failed, something is seriously wrong
                cerr << "Error initializing GLEW: " << glewGetErrorString(err) << endl;
                return;
        }
        cout << "- GLEW initialized." << endl << endl;
}

void OpenGLWidget::initDevIL()
{
  // Initialize DevIL (an image library)
        cout << "- Initializing DevIL ..." << endl;
        ilInit();

        if (ilGetError() != IL_NO_ERROR)
        {
                cerr << "Error initializing DevIL" << endl;
                return;
        }

        ilEnable(IL_ORIGIN_SET);
        ilOriginFunc(IL_ORIGIN_LOWER_LEFT);
        cout << "- DevIL initialized." << endl << endl;
}

---