src/MainWindow.cpp

Go to the documentation of this file.

#include "compiler_options.h"
#include "MainWindow.h"
#include "common.h"
#include <QtGui/QPainter>
#include <QtGui/QGradient>
#include <QtGui/QRadioButton>


MainWindow::MainWindow( QWidget* parent /* = 0 */, Qt::WindowFlags flags /* = 0 */) : QMainWindow(parent, flags)
{
        setupUi(this);

        isFileOpen = false;   // used to switch gui-elements on/off

        glWidgets[0] = 0; // Widget to share

        // add, layout and configure glWidgets
        for ( int i=0; i<NUMBER_OF_GL_WIDGETS; i++ )
        {
                glWidgets[i] = new OpenGLWidget( 0, glWidgets[0] );
        }

  //m_histogram = new Histogram(this);
  //m_histogram->Clear();
  m_volume = new Volume();

  //m_renderer = new GradientRenderer(this);
  m_editor   = new GradientEditor(this, Qt::Tool);
  m_editor->setFixedSize(514,300);

  //m_editor->setRenderer(m_renderer);
  //m_editor->setHistogram(m_histogram);

        gridLayout->addWidget ( glWidgets[ X_AXIS ] );
        gridLayout1->addWidget( glWidgets[ Y_AXIS ] );
        gridLayout2->addWidget( glWidgets[ Z_AXIS ] );
        gridLayout3->addWidget( glWidgets[ OPENGL_3D_VIEW ] );

  //hboxLayout1->addWidget( m_editor );
  //hboxLayout2->addWidget( m_renderer );
  //hboxLayout3->addWidget( m_histogram );

        glWidgets[ X_AXIS ]->m_Axis = X_AXIS;
        glWidgets[ Y_AXIS ]->m_Axis = Y_AXIS;
        glWidgets[ Z_AXIS ]->m_Axis = Z_AXIS;
  glWidgets[ OPENGL_3D_VIEW ]->m_Axis = NO_RENDER_3D_VIEW;

        configureSlider( m_verticalSlider_x );
        configureSlider( m_verticalSlider_y );
        configureSlider( m_verticalSlider_z );
        //configureSlider( m_verticalSlider_stepSize );

  configureStepSizeSlider();
  
        // Connect GUI Elements with methods
        connect( m_actionOpen,   SIGNAL( triggered() ), this, SLOT( openFile()  ));
        connect( m_actionClose,  SIGNAL( triggered() ), this, SLOT( closeFile() ));
        connect( m_actionQuit,   SIGNAL( triggered() ), this, SLOT( closeProgram() ));

  connect( m_button_tf, SIGNAL(clicked()), m_editor, SLOT( showTransferFunction() ));

  // TF Load/Save/Preset connections
  connect( m_tfPreset0, SIGNAL (triggered() ), this, SLOT( setDefault0() ));
  connect( m_tfPreset1, SIGNAL (triggered() ), this, SLOT( setDefault1() ));
  connect( m_tfPreset2, SIGNAL (triggered() ), this, SLOT( setDefault2() ));
  connect( m_tfPreset3, SIGNAL (triggered() ), this, SLOT( setDefault3() ));

  connect( m_actionSaveTF, SIGNAL( triggered() ), this, SLOT( saveTransferFunction() ));
  connect( m_actionLoadTF, SIGNAL( triggered() ), this, SLOT( loadTransferFunction() ));

  connect( m_radioButton_comp,   SIGNAL( clicked() ), this, SLOT ( setComp()   ));
  connect( m_radioButton_mip,    SIGNAL( clicked() ), this, SLOT ( setMIP()    ));
  connect( m_radioButton_avg,    SIGNAL( clicked() ), this, SLOT ( setAvg()    ));
  connect( m_radioButton_avgTF,  SIGNAL( clicked() ), this, SLOT ( setAvgTF()  ));
  connect( m_radioButton_fh,     SIGNAL( clicked() ), this, SLOT ( setFH()     ));
  connect( m_radioButton_compPh, SIGNAL( clicked() ), this, SLOT ( setCompPh() ));

  connect( m_slider_ka, SIGNAL (valueChanged (int)), this, SLOT(setAmbient (int) ));
  connect( m_slider_kd, SIGNAL (valueChanged (int)), this, SLOT(setDiffuse (int) ));
  connect( m_slider_ks, SIGNAL (valueChanged (int)), this, SLOT(setSpecular (int) ));
  connect( m_slider_kg, SIGNAL (valueChanged (int)), this, SLOT(setGloss (int) ));

  configureLightSlider(m_slider_ka);
  configureLightSlider(m_slider_kd);
  configureLightSlider(m_slider_ks);
  configureGlossLightSlider();

  // set composition button checked
  m_radioButton_comp->click();

        connect( m_verticalSlider_x, SIGNAL( valueChanged( int )), this, SLOT(setXAxisValue( int )) );
        connect( m_verticalSlider_y, SIGNAL( valueChanged( int )), this, SLOT(setYAxisValue( int )) );
        connect( m_verticalSlider_z, SIGNAL( valueChanged( int )), this, SLOT(setZAxisValue( int )) );
        connect( m_verticalSlider_stepSize, SIGNAL( valueChanged( int )), this, SLOT(setStepSize( int )) );

  // gradient changes - create new 1d-texture in glWidgets[0]
  connect(m_editor,     SIGNAL( gradientStopsChanged(    const QGradientStops &) ),
          glWidgets[ OPENGL_3D_VIEW ], SLOT(   GenerateGradientTexture( const QGradientStops &) ));

  //connect(m_editor,   SIGNAL( gradientStopsChanged(const QGradientStops &) ),
  //        m_renderer, SLOT(   setGradientStops(    const QGradientStops &) ));

  connect(this, SIGNAL( updateHistogram(const int*) ), m_editor, SLOT( showHistogram( const int*) ));
  connect(this, SIGNAL( releaseHistogram()          ), m_editor, SLOT( clearHistogram()           ));

  QTimer::singleShot( 50, this, SLOT( setDefault0() ));
}


MainWindow::~MainWindow()
{
  // no need to delete child widgets, QT does it all for us
}

void MainWindow::resizeEvent(QResizeEvent* re)
{
  if(re->size() != re->oldSize())
  {
    printf("RESIZE\n");

    QRect rect3d = m_openGL3DView->geometry();

    // Space left to resize window
    int margin = 10;
    int space;
    int hspace = re->size().width() - rect3d.x() - rect3d.width();
    int vspace = re->size().height() - rect3d.y() - rect3d.height();

    // width & height must me equal
    if(hspace >= vspace)
    {
      space = vspace - margin;
    }
    else
    {
      space = hspace - margin;
    }

    // resize symmetrical
    m_openGL3DView->setGeometry(rect3d.x(), rect3d.y(), rect3d.width() + space, rect3d.height() + space);

  }
}


void MainWindow::configureSlider( QSlider *slider )
{
        slider->setRange( 0, SLIDER_RANGE );
        slider->setSingleStep( 1 );
        slider->setPageStep( SLIDER_RANGE / 64 );
        slider->setTickInterval( SLIDER_RANGE / 4 );
        slider->setTickPosition( QSlider::TicksLeft );
//  slider->setValue( SLIDER_RANGE / 2 );
        slider->setEnabled( isFileOpen );
}

void MainWindow::configureLightSlider(QSlider *slider)
{
  int sliderRange = LIGHT_SLIDER_RANGE;

  slider->setRange(0, sliderRange);
  slider->setSingleStep(1);
  slider->setPageStep(sliderRange/10);
  slider->setTickInterval(sliderRange/10);
  slider->setTickPosition(QSlider::TicksLeft);
  slider->setEnabled(isFileOpen);
}


void MainWindow::configureGlossLightSlider()
{
  int sliderRange = LIGHT_SLIDER_RANGE;

  m_slider_kg->setRange(1, sliderRange-1);
  m_slider_kg->setSingleStep(1);
  m_slider_kg->setPageStep(sliderRange/10);
  m_slider_kg->setTickInterval(sliderRange/10);
  m_slider_kg->setTickPosition(QSlider::TicksLeft);
  m_slider_kg->setEnabled(isFileOpen);
}


void MainWindow::configureStepSizeSlider()
{
  int sliderRange = STEP_SLIDER_RANGE;

        m_verticalSlider_stepSize->setRange( 1, sliderRange );
        m_verticalSlider_stepSize->setSingleStep( 1 );
        m_verticalSlider_stepSize->setPageStep( sliderRange / 64 );
        m_verticalSlider_stepSize->setTickInterval( sliderRange / 4 );
        m_verticalSlider_stepSize->setTickPosition( QSlider::TicksLeft );
//      m_verticalSlider_stepSize->setValue( sliderRange / 2 );
        m_verticalSlider_stepSize->setEnabled( isFileOpen );
}


void MainWindow::activateSliders()
{
  m_verticalSlider_x->setEnabled( isFileOpen );
  m_verticalSlider_y->setEnabled( isFileOpen );
  m_verticalSlider_z->setEnabled( isFileOpen );

  m_slider_ka->setEnabled( isFileOpen );
  m_slider_kd->setEnabled( isFileOpen );
  m_slider_ks->setEnabled( isFileOpen );
  m_slider_kg->setEnabled( isFileOpen );

  m_slider_ka->setValue (LIGHT_SLIDER_RANGE / 2);
  m_slider_kd->setValue (LIGHT_SLIDER_RANGE / 2);
  m_slider_ks->setValue (LIGHT_SLIDER_RANGE / 2);
  m_slider_kg->setValue (LIGHT_SLIDER_RANGE / 2);

  m_verticalSlider_stepSize->setEnabled( isFileOpen );

  m_verticalSlider_x->setValue( SLIDER_RANGE / 2);
  m_verticalSlider_y->setValue( SLIDER_RANGE / 2);
  m_verticalSlider_z->setValue( SLIDER_RANGE / 2);
  m_verticalSlider_stepSize->setValue( STEP_SLIDER_RANGE / 2);
}


void MainWindow::setAxisValue( int axis, int value )
{
  //std::cout << "- new " << axis << "-axis value: " << value << std::endl;
  glWidgets[ axis ]->m_AxisValue = value;
  glWidgets[ axis ]->updateGL();
}

void MainWindow::setStepSize( int value )
{
  //std::cout << "- new stepsize-value: " << value << std::endl;

  //float fStepSize = 0.0;
  //m_verticalSlider_stepSize->getRange( 0, SLIDER_RANGE );
  //fStepSize = (float)value; // / SLIDER_RANGE;
  //std::cout << "- stepsize-value: " << fStepSize << std::endl;

  glWidgets[ OPENGL_3D_VIEW ]->m_rayStepSize = (float)value; // / SLIDER_RANGE;
  glWidgets[ OPENGL_3D_VIEW ]->updateGL();
}



// --- private slots ---

void MainWindow::setXAxisValue( int xVal ) { setAxisValue( X_AXIS, xVal ); }
void MainWindow::setYAxisValue( int yVal ) { setAxisValue( Y_AXIS, yVal ); }
void MainWindow::setZAxisValue( int zVal ) { setAxisValue( Z_AXIS, zVal ); }


void MainWindow::setAmbient(int val)
{ 
  glWidgets[ OPENGL_3D_VIEW ]->setLightValue(ambient, val/(float) LIGHT_SLIDER_RANGE); 
}

void MainWindow::setDiffuse(int val)
{
  glWidgets[ OPENGL_3D_VIEW ]->setLightValue(diffuse, val/(float) LIGHT_SLIDER_RANGE); 
}

void MainWindow::setSpecular(int val)
{
  glWidgets[ OPENGL_3D_VIEW ]->setLightValue(specular, val/(float) LIGHT_SLIDER_RANGE); 
}


void MainWindow::setGloss(int val)
{
  //printf("Gloss: %d\n",  val);
  glWidgets[ OPENGL_3D_VIEW ]->setLightValue(gloss, (float) val); 
}



void MainWindow::openFile()
{
  if ( isFileOpen ) closeFile();

  std::cout << "- opening file..." << std::endl;
        QString fileName = QFileDialog::getOpenFileName( this, tr("Load Volume Data"), ".", tr("Data Sets (*.dat)") );

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

    if( m_volume != NULL )
      m_volume->load( strFileName );
      emit updateHistogram(m_volume->getDensityDistribution());

    if ( glWidgets[0]->create3DTexture( m_volume ) )
      std::cout << "3D-Texture-creation successful." << std::endl;
      // hint: do NOT delete volume already here (as it is not needed for the planes anymore),
      // but it will still be needed later for raycasting?! (at least gv thinks so ;-)

    glWidgets[ OPENGL_3D_VIEW ]->m_Axis = RENDER_3D_VIEW;

  // for histogram
//    transferFunction->createDensityArray ( volume );

    isFileOpen = true;
    setDefaultGradient( 0 );
    activateSliders();

    // Update TF points to generate textur after loading file
    m_editor->pointsUpdated();
        }
}

void MainWindow::closeFile()
{
  std::cout << "- closing file..." << std::endl;

  m_volume->release();
  emit releaseHistogram();

  for (int i=0; i<NUMBER_OF_GL_WIDGETS; i++ )
    glWidgets[i]->release();

  //transferFunction->release();

  isFileOpen = false;

  glWidgets[ OPENGL_3D_VIEW ]->m_Axis = NO_RENDER_3D_VIEW;

  m_verticalSlider_x->setValue( 0 );
  m_verticalSlider_y->setValue( 0 );
  m_verticalSlider_z->setValue( 0 );

  activateSliders();

  // update gl views
  for(int i = 0; i < NUMBER_OF_GL_WIDGETS; i++)
  {
    glWidgets[i]->update();
  }
}


void MainWindow::closeProgram()
{
        std::cout << "Exiting ..." << std::endl;

  if ( isFileOpen ) closeFile();
}

//
//void MainWindow::render()
//{
//      std::cout << "Render-button pressed..." << std::endl;
//
//  // set render-flag
//  glWidgets[ OPENGL_3D_VIEW ]->m_Axis = RENDER_3D_VIEW;
//
//  // repaint to render
//  glWidgets[ OPENGL_3D_VIEW ]->updateGL();
//}


void MainWindow::setDefaultGradient(int i)
{
    QGradientStops stops;
    QPolygonF points;
    switch (i) {

    case 0:
        stops << QGradientStop(0.00, QColor::fromRgba(0xff000000));
        stops << QGradientStop(1.00, QColor::fromRgba(0xffffffff));
        break;

    case 1:
        stops << QGradientStop(0.00, QColor::fromRgba(0));
        stops << QGradientStop(0.04, QColor::fromRgba(0xff131360));
        stops << QGradientStop(0.08, QColor::fromRgba(0xff202ccc));
        stops << QGradientStop(0.42, QColor::fromRgba(0xff93d3f9));
        stops << QGradientStop(0.51, QColor::fromRgba(0xffb3e6ff));
        stops << QGradientStop(0.73, QColor::fromRgba(0xffffffec));
        stops << QGradientStop(0.92, QColor::fromRgba(0xff5353d9));
        stops << QGradientStop(0.96, QColor::fromRgba(0xff262666));
        stops << QGradientStop(1.00, QColor::fromRgba(0));
        break;

    case 2:
        stops << QGradientStop(0.00, QColor::fromRgba(0xffffffff));
        stops << QGradientStop(0.11, QColor::fromRgba(0xfff9ffa0));
        stops << QGradientStop(0.13, QColor::fromRgba(0xfff9ff99));
        stops << QGradientStop(0.14, QColor::fromRgba(0xfff3ff86));
        stops << QGradientStop(0.49, QColor::fromRgba(0xff93b353));
        stops << QGradientStop(0.87, QColor::fromRgba(0xff264619));
        stops << QGradientStop(0.96, QColor::fromRgba(0xff0c1306));
        stops << QGradientStop(1.00, QColor::fromRgba(0));
        break;

    case 3:
        stops << QGradientStop(0.00, QColor::fromRgba(0));
        stops << QGradientStop(0.10, QColor::fromRgba(0xffe0cc73));
        stops << QGradientStop(0.17, QColor::fromRgba(0xffc6a006));
        stops << QGradientStop(0.46, QColor::fromRgba(0xff600659));
        stops << QGradientStop(0.72, QColor::fromRgba(0xff0680ac));
        stops << QGradientStop(0.92, QColor::fromRgba(0xffb9d9e6));
        stops << QGradientStop(1.00, QColor::fromRgba(0));
        break;

    default:
        qWarning("bad default: %d\n", i);
        break;
    }

    //QPolygonF pts;
    //int h_off = m_renderer->width() / 10;
    //int v_off = m_renderer->height() / 8;
    //pts << QPointF(m_renderer->width() / 2, m_renderer->height() / 2)
    //    << QPointF(m_renderer->width() / 2 - h_off, m_renderer->height() / 2 - v_off);

    //TODO: Hover Points in ALPHA not set correctely
    m_editor->setGradientStops(stops);
    //m_renderer->setGradientStops(stops);
    m_editor->pointsUpdated();
}

void MainWindow::saveTransferFunction()
{
  printf("Save TF\n");

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

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

    if( m_editor != NULL )
      m_editor->saveTransferFunction( strFileName );
  }
}

void MainWindow::loadTransferFunction()
{
  printf("Load TF\n");

  QString fileName = QFileDialog::getOpenFileName( this, tr("Load Transfer Function"), ".", tr("TransferFunction (*.tf)") );

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

    if( m_editor != NULL )
      m_editor->loadTransferFunction( strFileName );
  }

  m_editor->pointsUpdated();
  glWidgets[ OPENGL_3D_VIEW ]->updateGL();
}

void MainWindow::keyPressEvent( QKeyEvent *e )
{
  //std::cout << "pressed button: " << e->key() << std::endl;

  /*
  w = 87
  s = 83
  a = 65
  d = 68
  q = 81
  e = 69
  */

  switch ( e->key() )
  {
    case 87: case 83: // w, s
    case 65: case 68: // a, d
    case 81: case 69: // q, e
    case 89: case 77: // y, m
      glWidgets[ OPENGL_3D_VIEW ]->keyEvent( e->key() );
      break;

    case 79: // o
      openFile();
      break;

    case 16777216: // ESC
      // quit application
      break;

    default:
      break;
  }
}

---