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

Go to the documentation of this file.

#include "Navigation.h"

#include <QRect>
#include <QPixmap>
#include <QLinearGradient>
#include <QPainter>
#include <QLabel>
#include <QRect>
#include <QPointF>
#include <QColorDialog>
#include <QFileDialog>
#include <QRadioButton>
#include <QRgb>
#include <QMessageBox>
#include <fstream>

Navigation::Navigation(OpenGLWidget* ogl, QWidget* parent /*= 0*/, Qt::WFlags flags /*= 0*/) : QWidget(parent, flags)
{
  setupUi(this);
  m_parent = parent;
  m_ogl = ogl;
  m_isFileOpen = false;

  m_pointSize = QSize(10,10);
  m_pointBrush = QBrush(QColor(200,200,200,127));

  // nk - Dropdown
  connect(m_backgroundCB, SIGNAL(currentIndexChanged(int) ), m_ogl, SLOT(setActiveBackground(int)));

  // nk - PushButton
  connect(m_selectArrowColor, SIGNAL(pressed()), m_ogl, SIGNAL(setArrowColor()));
  connect(m_selectSLColor, SIGNAL(pressed()), m_ogl, SLOT(selectStreamLineColor()));
  connect(m_selectGlyphColor, SIGNAL(pressed()), m_ogl, SLOT(selectStreamGlyphColor()));
  connect(m_updateSL, SIGNAL(pressed()), m_ogl, SLOT(updateStreamLines()));

  connect(m_showArrows, SIGNAL(clicked(bool)), m_ogl, SLOT(setActiveArrows(bool)));
  connect(m_activateTF, SIGNAL(clicked(bool)), m_ogl, SLOT(setActiveTransferFunction(bool)));
  connect(m_activateSL, SIGNAL(clicked(bool)), m_ogl, SLOT(setLinesActive(bool)));
  connect(m_showTapering, SIGNAL(clicked(bool)), m_ogl, SLOT(setTaperingActive(bool)));
  connect(m_showGlyph, SIGNAL(clicked(bool)), m_ogl, SLOT(setGlyphActive(bool)));
  connect(m_scalePoints, SIGNAL(clicked(bool)), m_ogl, SIGNAL(setActivePointScale(bool)));

  connect(m_pointSizeSlider, SIGNAL(valueChanged(int)), m_ogl, SIGNAL(setPointSize(int)));
  connect(m_pointResSlider, SIGNAL(valueChanged(int)), m_ogl, SIGNAL(setResolution(int)));
  connect(m_dsepSlider, SIGNAL(valueChanged(int)), m_ogl, SLOT(setDSep(int)));
  connect(m_dtestSlider, SIGNAL(valueChanged(int)), m_ogl, SLOT(setDTest(int)));
  connect(m_glyphDistance, SIGNAL(valueChanged(int)), m_ogl, SLOT(setStreamGlyphDistance(int)));
  connect(m_glyphSize, SIGNAL(valueChanged(int)), m_ogl, SLOT(setStreamGlyphSize(int)));

  // nk - radio button
  connect(m_euler, SIGNAL(clicked()), m_ogl, SLOT(setEuler()));
  connect(m_runge, SIGNAL(clicked()), m_ogl, SLOT(setRungeKutta()));

  // set maximum slider value explicit for dtestSlider & dSepSlider
  m_dsepSlider->setMaximum(MAX_SLIDER_VALUE);
  m_dtestSlider->setMaximum(MAX_SLIDER_VALUE);
}

// nk - set gui elements dependent on file status
void Navigation::resetGuiElements(bool filestatus)
{
  if(filestatus == false)
  {
    // nk - does not work
    //m_showArrows->setChecked(filestatus);
    //m_scalePoints->setChecked(filestatus);
    //m_activateTF->setChecked(filestatus);
    //m_activateSL->setChecked(filestatus);

    //m_showGlyph->setChecked(filestatus);
    //m_showTapering->setChecked(filestatus);
  }

  m_selectArrowColor->setEnabled(filestatus);
  
  // nk - point depending state
  m_showArrows->setEnabled(filestatus);
  m_scalePoints->setEnabled(filestatus);
  m_pointSizeSlider->setEnabled(filestatus);
  m_pointResSlider->setEnabled(filestatus);

  m_activateTF->setEnabled(filestatus);
  
  m_dsepSlider->setEnabled(filestatus);
  m_dtestSlider->setEnabled(filestatus);

  m_activateSL->setEnabled(filestatus);
  m_showGlyph->setEnabled(filestatus);
  m_showTapering->setEnabled(filestatus);

  m_updateSL->setEnabled(filestatus);
  m_selectSLColor->setEnabled(filestatus);
  m_selectGlyphColor->setEnabled(filestatus);

  m_euler->setEnabled(filestatus);
  m_runge->setEnabled(filestatus);

  m_glyphSize->setEnabled(filestatus);
  m_glyphDistance->setEnabled(filestatus);
}

void Navigation::createColorBar(bool isFileOpen, bool update)
{
  m_isFileOpen = isFileOpen;

  m_colorBarRect = m_colorBar->frameRect();
  QPixmap* pixmap = new QPixmap(m_colorBarRect.width(), m_colorBarRect.height());

  pixmap->fill(Qt::transparent);

  if(isFileOpen)
  {
    QLinearGradient gradient(0, 0, m_colorBarRect.width(), 0);
    gradient.setSpread(QGradient::PadSpread);

    // set only on startup
    if(update == false)
    {
      m_gradientStops.clear();
      m_points.clear();

      m_gradientStops.push_back(QGradientStop(0, QColor::fromRgbF(1, 0, 0, 1))); 
      m_gradientStops.push_back(QGradientStop(0.5, QColor::fromRgbF(0.0, 1.0, 0.0, 1))); 
      m_gradientStops.push_back(QGradientStop(1, QColor::fromRgbF(0.0, 0.0, 1.0, 1))); 

      int xCenter = m_colorBarRect.left() + (m_colorBarRect.width()) / 2;
      int yCenter = m_colorBarRect.top() + ( m_colorBarRect.height() / 2);

      m_points.push_back(QPointF(m_colorBarRect.left(), yCenter )); // left
      m_points.push_back(QPointF(xCenter, yCenter)); // center
      m_points.push_back(QPointF(m_colorBarRect.right(), yCenter)); // right
      
    }
    
    for(int i = 0; i < m_gradientStops.size(); i++)
    {
      gradient.setColorAt(m_gradientStops.at(i).first, m_gradientStops.at(i).second);
    }

    QPainter painter(pixmap);
    painter.fillRect(0, 0, m_colorBarRect.width(), m_colorBarRect.height(), gradient);

    painter.setBrush(m_pointBrush);
    for(int i = 0; i < m_points.size(); i++)
    {
      painter.drawEllipse(getPointBounds(i));
    }
    painter.end();

    //pixmap->save("pixmap_test.png");
    m_colorBar->setPixmap(*pixmap);

     m_ogl->setColorBarTexture(m_gradientStops);
  }
  else // if file closed
  {
    // nk - transparent pixmap on file close && clear m_gradientStops
    m_colorBar->setPixmap(*pixmap);
    m_gradientStops.clear();
    m_points.clear();
  }

  if(!m_colorBar->pixmap())
    printf("ERROR in createColorBar\n");
}

QRectF Navigation::getPointBounds(int i)
{
  QPointF p = m_points.at(i);
  float w = m_pointSize.width();
  float h = m_pointSize.height();
  float x = p.x() - w / 2;
  float y = p.y() - h / 2;

  return QRectF(x, y, w, h);
}


Navigation::~Navigation()
{
  // do nothing
}

void Navigation::mousePressEvent(QMouseEvent* e)
{
  if(!m_isFileOpen)
    return;

  QRect c = m_colorBar->geometry();
  float yPos = c.height() / 2;
  float xPos = 0.0f;

  if(!(e->x() >= c.left() && e->x() <= c.right() + 1 && e->y() >= c.top() && e->y() <= c.bottom()))
  {
    return;
  }

  if(e->button() == Qt::LeftButton)
  {
    xPos = e->x() - c.x();
    float curPos = xPos / (float) c.width();
    // printf("CurPos: %f\n", curPos); // (nk) for control only

    // (nk) add new gradient stop & new cursor position
    m_gradientStops.push_back(QGradientStop(curPos, QColor::fromRgbF(1, 1, 1, 1)));
    m_points.push_back(QPointF(xPos, yPos));

    createColorBar(m_isFileOpen, true);
  }

  if(e->button() == Qt::MidButton)
  {
    xPos = e->x() - c.x();

    for(int i = 0; i < m_points.size(); i++)
    {
      QPointF curPoint = QPointF(xPos, yPos);
      QRectF bound = getPointBounds(i);
      if(bound.contains(curPoint))
      {
        QColor color = QColorDialog::getColor();

        qreal curStop = m_gradientStops.at(i).first;
        m_gradientStops.replace(i, QGradientStop(curStop, color));
        createColorBar(m_isFileOpen, true);
      }
    }
  }
  
  if(e->button() == Qt::RightButton)
  {
    xPos = e->x() - c.x();

    for(int i = 0; i < m_points.size(); i++)
    {
      QPointF curPoint = QPointF(xPos, yPos);
      QRectF bound = getPointBounds(i);
      if(bound.contains(curPoint))
      {
        m_points.remove(i);
        m_gradientStops.remove(i);
        createColorBar(m_isFileOpen, true);
      }
    }
  }
}

void Navigation::loadTF()
{
  QString fileName = QFileDialog::getOpenFileName(this, "Load Transfer Function", ".", "TransferFunction (*.tf)");
  std::string line; // buffer for read line
  qreal px, py; // save points read from file
  qreal stop, r, g, b, a; // save stops read from file
  QColor color;
  
  // return from function if no filename specified (e.g. dialog canceled) or no dataset open
  if(fileName.isNull() || !m_isFileOpen)
  {
    std::cerr << "No dataset load or no filename specifed to Load TF" << std::endl;
    return;
  }
  else
  {
    m_gradientStops.clear();
    m_points.clear();

    std::string strFileName = std::string(fileName.toLatin1());

    // Open File
    std::ifstream inFile (strFileName.c_str());

    if(!inFile)
    {
      std::cerr << "Error loading file!" << std::endl;
      return;
    }

    while(std::getline(inFile, line))
    {
      // search for string "Point" in line
      if(!line.compare("Point")) // line.compare returns zero if string is equal
      {
        std::getline(inFile, line);
        
        // read digits from line
        if(isdigit(line.at(0)))
        {
          sscanf_s(line.c_str(), "%lf %lf\n", &px, &py);
          m_points.push_back(QPointF(px, py));
        }
      }
      
      if(!line.compare("Stop")) // line.compare returns zero if string is equal
      {
        std::getline(inFile, line);

        // read only digits from line
        if(isdigit(line.at(0)))
        {
          sscanf_s(line.c_str(), "%lf %lf %lf %lf %lf\n", &stop, &r, &g, &b, &a);
          color.setRgbF(r, g, b, a);
          m_gradientStops.push_back(QGradientStop(stop, color));
        }
      }
    }
  }

  this->createColorBar(m_isFileOpen, true);
}

void Navigation::saveTF()
{
  if(m_gradientStops.isEmpty() || m_points.isEmpty())
  {
    printf("Error saving TF: Load dataset first\n");
    return;
  }

  QString fileName = QFileDialog::getSaveFileName(this, "Save Transfer Function", ".", "TransferFunction (*.tf)");

  if (!fileName.isNull())
  {
    std::string strFileName = std::string(fileName.toLatin1());

    FILE *fp = NULL;
    fopen_s(&fp, strFileName.c_str(), "w");

    if(!fp)
    {
      std::cerr << "Error saving file!" << std::endl;
      return;
    }

    for(int i = 0; i < m_gradientStops.size(); i++)
    {
      qreal pointX = m_points.at(i).x();
      qreal pointY = m_points.at(i).y();

      qreal gradPos = m_gradientStops.at(i).first;
      QColor gradCol = m_gradientStops.at(i).second;

      fprintf(fp, "Point\n");
      fprintf(fp, "%lf %lf\n", pointX, pointY);

      fprintf(fp, "Stop\n");
      fprintf(fp, "%lf %lf %lf %lf %lf\n", gradPos, gradCol.redF(), gradCol.greenF(), gradCol.blueF(), gradCol.alphaF());
    }

    fclose(fp);
  }
}




void Navigation::resetTF()
{
  printf("Reset TF\n");
  // reset transfer function
  createColorBar(m_isFileOpen, false);

  this->update();
  m_ogl->update();
}

void Navigation::setBackgroundChooser(int count)
{
  // at file close - no scalar channel 
  if ( count == 0 )
  {
    // clear string list
    m_bgList.clear();

    // clear backgroundChooser
    m_backgroundCB->clear();
  }
  else
  {
    QString str = "Background";
    QVariant var;

    for(int i = 0; i < count; i++)
    {
      var = i;

      // m_bgList.push_back( str + var.toString() );
      // gv Names just make it nicer
      switch ( i )
      {
        case 0:
            m_bgList.push_back( "Pressure" );
            break;

        case 1:
            m_bgList.push_back( "Vorticity" );
            break;

        default:
            m_bgList.push_back( str + var.toString() );
            break;
      }
    }

    m_bgList.push_back("None");

    // Add values to BackgroundChooser CB
    m_backgroundCB->addItems(m_bgList);

    m_backgroundCB->setCurrentIndex(count);
  }
}

---