Eigene Dateien/FlowVis/src/QMain.cpp

Go to the documentation of this file.

#include "QMain.h"
#include "QtGui/QFileDialog.h"
#include <iostream>

QMain::QMain(QWidget* parent /*= 0*/, Qt::WFlags flags /*= 0*/) 
                                                                : QMainWindow(parent, flags)
{
        setupUi(this);
        GLenum err = glewInit();
        if (err != GLEW_OK)
        {
                // glewInit failed, something is seriously wrong
                std::cerr << "Error initializing GLEW: " << glewGetErrorString(err) << std::endl;
                std::cout << "Press a button to continue" << std::endl;
                std::cin.get();
//              exit(-1);
        }
        std::cout << "- GLEW initialized." << std::endl << std::endl;

        renderer_canvas->setTransferFunctionPtr(tf_canvas->getTransferFunctionPtr());

        m_ArrowsColor.setX(0.0f);
        m_ArrowsColor.setY(0.0f);
        m_ArrowsColor.setZ(0.0f);
        select_arrowlinescolor->setArrowsColorPtr(&m_ArrowsColor);
        renderer_canvas->setArrowsColorPtr(&m_ArrowsColor);

        m_StreamlinesColor.setX(1.0f);
        m_StreamlinesColor.setY(1.0f);
        m_StreamlinesColor.setZ(1.0f);
        select_streamlinescolor->setStreamlinesColorPtr(&m_StreamlinesColor);
        renderer_canvas->setStreamlinesColorPtr(&m_StreamlinesColor);


        activeTF = 0;
        arrowTFactivated = false;
        streamLineTFactivated = false;
        licTFactivated = false;

        int _c_x2, _c_y2;
        renderer_canvas->geometry().getCoords(&pixposx_rcanvas, &pixposy_rcanvas, &_c_x2, &_c_y2);

        w_sizex = size().rwidth();
        w_sizey = size().rheight();

        pixoffsetx_rcanvas = pixposx_rcanvas + ( (w_sizex -1) - _c_x2 );
        pixoffsety_rcanvas = pixposy_rcanvas + ( (w_sizey -1) - _c_y2 );

        pTimer = new QTimer( this);
        connect( pTimer, SIGNAL(timeout()), this, SLOT(watch()) );
        pTimer->start(0);

        pTimer_redraw = new QTimer( this);
        connect( pTimer_redraw, SIGNAL(timeout()), this, SLOT(redraw()) );
        pTimer_redraw->start(30);

        m_streamlinesinteractive = false;
        comboseeds_active = 0;

        setMinimumSize(w_sizex,w_sizey);

        //std::cout << (int)(-0.05) << std::endl;
        
        //actions
        connect( actionOpen,                            SIGNAL(triggered()),                    this, SLOT(load_data_file()) );
        connect( actionOpen_Single_Dat,         SIGNAL(triggered()),                    this, SLOT(load_single_file()) );
        connect( actionSave_Volume,                     SIGNAL(triggered()),                    this, SLOT(save_data_file()) );
        connect( actionClose,                           SIGNAL(triggered()),                    this, SLOT(close()) );
        connect( actionLoad,                            SIGNAL(triggered()),                    this, SLOT(load_tf_file()) );
        connect( actionSave,                            SIGNAL(triggered()),                    this, SLOT(save_tf_file()) );
        connect( actionSave_Image,                      SIGNAL(triggered()),                    this, SLOT(save_image())        );
        connect( actionSave_Big_Image,          SIGNAL(triggered()),                    this, SLOT(save_big_image()) );
        connect( actionStreamlineLoad,          SIGNAL(triggered()),                    this, SLOT(loadStreamLines()) );
        connect( actionStreamlineSave,          SIGNAL(triggered()),                    this, SLOT(saveStreamLines()) );

        //check boxes
        connect( checkBox_activatearrows,                       SIGNAL(clicked( bool )),                this, SLOT(activate_arrows( bool )));
        connect( checkBox_activatestreamlines,          SIGNAL(clicked( bool )),                this, SLOT(activate_streamlines( bool )));
        connect( checkBox_streamlinesinteractive,       SIGNAL(clicked( bool )),                this, SLOT(interactivate(bool)));
        connect( checkBox_enableTF_arrows,                      SIGNAL(clicked( bool )),                this, SLOT(enableArrowTF(bool)));
        connect( checkBox_enableTF_streamlines,         SIGNAL(clicked( bool )),                this, SLOT(enableStreamLineTF(bool)));
        connect( checkBox_activateLIC,                          SIGNAL(clicked(bool)),                  this, SLOT(activateLIC(bool)));
        connect( checkBox_enableIcons,                          SIGNAL(clicked(bool)),                  this, SLOT(enableIcons(bool)));
        connect( checkBox_tapering,                                     SIGNAL(clicked(bool)),                  this, SLOT(activateTapering(bool)));
        connect( checkBox_strglyphes,                           SIGNAL(clicked(bool)),                  this, SLOT(activateStrGlyphes(bool)) );
        connect( checkBox_enableTF_lic,                         SIGNAL(clicked(bool)),                  this, SLOT(enableLicTF(bool)) );
        connect( checkBox_animateLic,                           SIGNAL(clicked(bool)),                  this, SLOT(animateLic(bool)) );
        //scrolls
        connect( tfhorizscroll,                         SIGNAL(valueChanged(int)),              this, SLOT(tf_horizscroll_valuechanged(int)) );
        connect( tfvertscroll,                          SIGNAL(valueChanged(int)),              this, SLOT(tf_vertscroll_valuechanged(int)) );

        //sliders
        connect( slider_timestep,                       SIGNAL(valueChanged(int)),              this, SLOT(slider_timestep_valuechanged(int)) );
        connect( slider_colmapping,                     SIGNAL(valueChanged(int)),              this, SLOT(slider_colprop_valuechanged(int)) );
        connect( slider_arrowscale,                     SIGNAL(valueChanged(int)),              this, SLOT(slider_arrowscale_valuechanged(int)) );
        connect( slider_arrowspacing,           SIGNAL(valueChanged(int)),              this, SLOT(slider_arrowspacing_valuechanged(int)) );
        connect( slider_dsep,                           SIGNAL(valueChanged(int)),              this, SLOT(slider_dsep_valuechanged(int)) );
        connect( slider_dtest,                          SIGNAL(valueChanged(int)),              this, SLOT(slider_dtest_valuechanged(int)) );
        connect( slider_steps,                          SIGNAL(valueChanged(int)),              this, SLOT(slider_steps_valuechanged(int)) );
        connect( slider_dt,                                     SIGNAL(valueChanged(int)),              this, SLOT(slider_dt_valuechanged(int)) );
        connect( slider_arrowalpha,                     SIGNAL(valueChanged(int)),              this, SLOT(slider_arrowalpha_valuechanged(int)) );
        connect( slider_stralpha,                       SIGNAL(valueChanged(int)),              this, SLOT(slider_salpha_valuechanged(int)) );
        connect( slider_licalpha,                       SIGNAL(valueChanged(int)),              this, SLOT(slider_licalpha_valuechanged(int)) );
        connect( slider_licsteps,                       SIGNAL(valueChanged(int)),              this, SLOT(slider_licsteps_valuechanged(int)) );
        connect( slider_licstepsize,            SIGNAL(valueChanged(int)),              this, SLOT(slider_licstepsize_valuechanged(int)) );
        connect( slider_tapering,                       SIGNAL(valueChanged(int)),              this, SLOT(slider_tapering_scale(int)) );
        connect( slider_iconscale,                      SIGNAL(valueChanged(int)),              this, SLOT(slider_iconscale_valuechanged(int)) );
        connect( slider_taillength,                     SIGNAL(valueChanged(int)),              this, SLOT(slider_icontail_valuechanged(int)) );
        
        
        //radiobuttons
        connect( rb_arrowscale_norm,            SIGNAL(toggled(bool)),                  this, SLOT(rb_arrowscale_norm_clicked(bool)) );
        connect( rb_euler,                                      SIGNAL(toggled(bool)),                  this, SLOT(rb_euler_clicked(bool)) );
        connect( rb_arrowcol_datavalue,         SIGNAL(toggled(bool)),                  this, SLOT(rb_arrowcol_tf(bool)) );
        connect( rb_strcol_datavalue,           SIGNAL(toggled(bool)),                  this, SLOT(rb_strcol_tf(bool)) );

        //buttons
        connect( button_computecpu,                     SIGNAL(clicked(bool)),                  this, SLOT(button_computecpu_clicked(bool)) );

        //combos
        connect( combo_seedplacing,                     SIGNAL(activated(int)),         this, SLOT(combo_seedsplacing_switched(int)));
        connect( comboBox,                                      SIGNAL(activated(int)),         this, SLOT(combo_choose_arrow(int)) );

        tf_canvas->setVScroll(tfvertscroll);
        tf_canvas->setHScroll(tfhorizscroll);

        tfvertscroll->setVisible(false);
        tfhorizscroll->setVisible(false);

        combo_seedsplacing_switched( 0 );

}


QMain::~QMain()
{

        delete pTimer;
}

void QMain::redraw()
{
        renderer_canvas->repaint();
}

void QMain::tf_vertscroll_valuechanged(int val)
{
        int x1, y1, x2, y2;
        tf_canvas->geometry().getCoords(&x1, &y1, &x2, &y2);

        float sizex = x2-x1 + 1.0f;
        float sizey = y2-y1 + 1.0f;

        float factor = (100.0f-(float)val)/(100.0f) * (sizey - sizey/3.0f -27.0f);

        tf_canvas->setGeometry( QRect(x1, -(int)factor, sizex, sizey));
}



void QMain::tf_horizscroll_valuechanged(int val)
{
        
        int x1, y1, x2, y2;
        tf_canvas->geometry().getCoords(&x1, &y1, &x2, &y2);

        float sizex = x2-x1 + 1.0f;
        float sizey = y2-y1 + 1.0f;

        float factor = ((float)val)/100.0f * (sizex - sizex/3);

        tf_canvas->setGeometry( QRect(-(int)factor, y1, sizex, sizey));

}

void QMain::slider_timestep_valuechanged(int val)
{
        char buffer[ 64 ];

        sprintf_s(buffer, "Active Time Step: %d", val );
        label_activetimestep->setText( buffer );

        renderer_canvas->timestep_changed_event( val );

        if ( m_streamlinesinteractive ) 
        {
                renderer_canvas->computeCPUStreamlines(  );
        }
        
}


void QMain::slider_colprop_valuechanged(int val)
{
        char buffer[ 64 ];

        switch (val)
        {
                case 1:
                {
                        renderer_canvas->coloringproperty_changed_event( val );
                        if(!arrowTFactivated && !streamLineTFactivated && !licTFactivated)
                        {
                                sprintf_s(buffer, "Color Mapping Property: %d (Flow)", val );
                                label_colmapping->setText( buffer );
                                tf_canvas->setActiveTF( val );
                                renderer_canvas->setTransferFunctionPtr(tf_canvas->getTransferFunctionPtr());
                        }
                        else
                        {
                                renderer_canvas->setTransferFunctionPtr(tf_canvas->getTransferFunctionPtr( val ));
                        }
                        break;
                }
                case 2:
                {
                        renderer_canvas->coloringproperty_changed_event( val );
                        if(!arrowTFactivated && !streamLineTFactivated && !licTFactivated)
                        {
                                sprintf_s(buffer, "Color Mapping Property: %d (.)", val );
                                label_colmapping->setText( buffer );
                                tf_canvas->setActiveTF( val );
                                renderer_canvas->setTransferFunctionPtr(tf_canvas->getTransferFunctionPtr());
                        }
                        else
                        {
                                renderer_canvas->setTransferFunctionPtr(tf_canvas->getTransferFunctionPtr( val ));
                        }
                        break;
                }
                case 3:
                {
                        renderer_canvas->coloringproperty_changed_event( val );
                        if(!arrowTFactivated && !streamLineTFactivated && !licTFactivated)
                        {
                                sprintf_s(buffer, "Color Mapping Property: %d (.)", val );
                                label_colmapping->setText( buffer );
                                tf_canvas->setActiveTF( val );
                                renderer_canvas->setTransferFunctionPtr(tf_canvas->getTransferFunctionPtr());
                        }
                        else
                        {
                                renderer_canvas->setTransferFunctionPtr(tf_canvas->getTransferFunctionPtr( val ));
                        }
                        break;
                }
                default:
                {
                        renderer_canvas->coloringproperty_changed_event( 1 );
                        if(!arrowTFactivated && !streamLineTFactivated && !licTFactivated)
                        {
                                sprintf_s(buffer, "Color Mapping Property: %d (Flow)", 1 );
                                label_colmapping->setText( buffer );
                                tf_canvas->setActiveTF( 1 );
                                renderer_canvas->setTransferFunctionPtr(tf_canvas->getTransferFunctionPtr());
                        }
                        else
                        {
                                renderer_canvas->setTransferFunctionPtr(tf_canvas->getTransferFunctionPtr( 1 ));
                        }
                        break;
                }
        }


        activeTF = val;

        if( renderer_canvas->getLoaded() )
        {
                int decint = renderer_canvas->getFlowDataMin();
                int udecint = (int)(100.0f * abs( renderer_canvas->getFlowDataMin() - (float)decint));
                sprintf_s(buffer, "%d.%d", decint, udecint );
                label_min->setText( buffer );

                decint = renderer_canvas->getFlowDataMax();
                udecint = (int)(100.0f * abs( renderer_canvas->getFlowDataMax() - (float)decint));
                sprintf_s(buffer, "%d.%d", decint, udecint );
                label_maximum->setText( buffer );

        }
        
        
        
}

void QMain::slider_arrowalpha_valuechanged(int val)
{
        char buffer[ 64 ];

        int alpha = (float)val / 100.0f;
        int nalpha = (int)(100.0f * abs( ((float)val / 100.0f) - (float)alpha));

        sprintf_s(buffer, "Alpha %d.%d",alpha, nalpha );
        label_arrowalpha->setText( buffer );

        renderer_canvas->arrowalpha_changed_event( (float)val / 100.0f );
}

void QMain::slider_salpha_valuechanged(int val)
{
        char buffer[ 64 ];

        int alpha = (float)val / 100.0f;
        int nalpha = (int)(100.0f * abs( ((float)val / 100.0f) - (float)alpha));

        sprintf_s(buffer, "Alpha %d.%d",alpha, nalpha );
        label_stralpha->setText( buffer );

        renderer_canvas->salpha_changed_event( (float)val / 100.0f );
}

void QMain::slider_arrowscale_valuechanged(int val)
{
        renderer_canvas->arrowscale_valuechanged(val);
}

void QMain::slider_iconscale_valuechanged(int val)
{
        renderer_canvas->iconscale_valuechanged(val);
}

void QMain::slider_icontail_valuechanged(int val)
{
        renderer_canvas->icontail_valuechanged(val);
}

void QMain::slider_arrowspacing_valuechanged(int val)
{
        renderer_canvas->arrowspacing_valuechanged(val);
}

void QMain::slider_dsep_valuechanged( int val )
{
        char buffer[ 64 ];
        sprintf_s(buffer, "%f", (float)val / 100.0f );
        label_valdsep->setText( buffer );
        renderer_canvas->dsep_valuechanged(val);

        if ( m_streamlinesinteractive ) 
        {
                renderer_canvas->computeCPUStreamlines(  );
        }
}

void QMain::slider_dtest_valuechanged( int val )
{
        char buffer[ 64 ];
        sprintf_s(buffer, "%f", (float)val / 100.0f );
        label_valdtest->setText( buffer );
        renderer_canvas->dtest_valuechanged(val);

        if ( m_streamlinesinteractive ) 
        {
                renderer_canvas->computeCPUStreamlines(  );
        }
}

        
void QMain::slider_steps_valuechanged( int val )
{
        char buffer[ 64 ];
        sprintf_s(buffer, "%f", (float)val / 100.0f );
        label_valsteps->setText( buffer );
        renderer_canvas->steps_valuechanged(val);

        if ( m_streamlinesinteractive ) 
        {
                renderer_canvas->computeCPUStreamlines(  );
        }
}

        
void QMain::slider_dt_valuechanged( int val )
{
        char buffer[ 64 ];
        sprintf_s(buffer, "%f", (float)val / 100.0f );
        label_valdt->setText( buffer );
        renderer_canvas->dt_valuechanged(val);

        if ( m_streamlinesinteractive ) 
        {
                renderer_canvas->computeCPUStreamlines(  );
        }

}

void QMain::slider_licalpha_valuechanged(int val)
{
        char buffer[ 64 ];

        int alpha = (float)val / 100.0f;
        int nalpha = (int)(100.0f * abs( ((float)val / 100.0f) - (float)alpha));

        sprintf_s(buffer, "Alpha %d.%d",alpha, nalpha );
        label_licalpha->setText( buffer );

        renderer_canvas->licalpha_changed_event( (float)val / 100.0f );
}

void QMain::slider_licsteps_valuechanged(int val)
{
        char buffer[ 64 ];

        sprintf_s(buffer, "%d",val );
        label_valdt_2->setText( buffer );

        renderer_canvas->licsteps_changed_event( val );
}

void QMain::slider_licstepsize_valuechanged(int val)
{
        char buffer[ 64 ];

        sprintf_s(buffer, "1 / %d",val );
        label_valsteps_2->setText( buffer );

        renderer_canvas->licstepsize_changed_event( val );
}

void QMain::rb_arrowscale_norm_clicked( bool val )
{
        //true normalized scale toggled
        //false adaptive size toggled
        renderer_canvas->setArrowScaleModus( val );

}

void QMain::rb_euler_clicked( bool val )
{
        //true euler toggled
        //false runge-kutta toggled
        renderer_canvas->setIntegrationMethod( val );

        if ( m_streamlinesinteractive ) 
        {
                renderer_canvas->computeCPUStreamlines(  );
        }
}


void QMain::rb_arrowcol_tf( bool val )
{
        renderer_canvas->setArrowTF(val);
}

void QMain::rb_strcol_tf( bool val )
{
        renderer_canvas->setStrTF(val);
}


void QMain::button_computecpu_clicked( bool val )
{
        //true normalized scale toggled
        //false adaptive size toggled
        renderer_canvas->computeCPUStreamlines(  );

}

void QMain::combo_seedsplacing_switched( int val )
{
        comboseeds_active = val;

        renderer_canvas->setPlacingMethod( val );

        if ( m_streamlinesinteractive ) 
        {
                renderer_canvas->computeCPUStreamlines(  );
        }
}

void QMain::combo_choose_arrow( int val )
{
        comboseeds_active = val;

        renderer_canvas->setGlyph( (val == 0) ? true : false );
        renderer_canvas->repaint();
}

void QMain::activate_arrows( bool state )
{
        
        renderer_canvas->setArrowplotState( state );
        renderer_canvas->repaint();
}

void QMain::activateLIC( bool state )
{
        renderer_canvas->setLicplotState( state );
        renderer_canvas->repaint();
}

void QMain::enableIcons( bool state )
{
        renderer_canvas->enableIcons( state );
        renderer_canvas->repaint();
}

void QMain::activateTapering( bool state )
{
        renderer_canvas->setTaperingState( state );
        renderer_canvas->repaint();
}

void QMain::activateStrGlyphes( bool state )
{
        renderer_canvas->setStrGlyphes( state );
        renderer_canvas->repaint();
}

void QMain::slider_tapering_scale( int val )
{
        char buffer[ 64 ];

        int alpha = val / 10;
        int nalpha = val - 10 * alpha;

        sprintf_s(buffer, "Tapering (0.%d%d)",alpha, nalpha );
        checkBox_tapering->setText( buffer );

        renderer_canvas->setTaperingScale( ( float )val / 100.0f );
        renderer_canvas->repaint();
}

void QMain::enableArrowTF( bool state )
{
        arrowTFactivated = state;
        if(state)
        {
                //sprintf_s(buffer, "Color Mapping Property: %d (Flow)", val );
                //label_colmapping->setText( buffer );
                //renderer_canvas->coloringproperty_changed_event( val );
                tf_canvas->setActiveTF( 4 );
                renderer_canvas->setArrowTransferFunctionPtr(tf_canvas->getTransferFunctionPtr());
        }
        else
        {
                slider_colprop_valuechanged( activeTF );
        }       
}

void QMain::enableStreamLineTF( bool state )
{
        streamLineTFactivated = state;
        if(state)
        {
                //sprintf_s(buffer, "Color Mapping Property: %d (Flow)", val );
                //label_colmapping->setText( buffer );
                //renderer_canvas->coloringproperty_changed_event( val );
                tf_canvas->setActiveTF( 5 );
                renderer_canvas->setStreamLineTransferFunctionPtr(tf_canvas->getTransferFunctionPtr());
        }
        else
        {
                slider_colprop_valuechanged( activeTF );
        }       
}

void QMain::enableLicTF( bool state )
{
        licTFactivated = state;
        if(state)
        {
                //sprintf_s(buffer, "Color Mapping Property: %d (Flow)", val );
                //label_colmapping->setText( buffer );
                //renderer_canvas->coloringproperty_changed_event( val );
                tf_canvas->setActiveTF( 6 );
                renderer_canvas->setLicTransferFunctionPtr(tf_canvas->getTransferFunctionPtr());
                
        }
        else
        {
                slider_colprop_valuechanged( activeTF );
        }       
        renderer_canvas->setLicTF(state);
}

void QMain::animateLic( bool state )
{
        renderer_canvas->animateLic(state);
}

void QMain::activate_streamlines( bool state )
{
        
        renderer_canvas->setStreamlinesState( state );
        renderer_canvas->repaint();
}

void QMain::interactivate(bool state )
{
        m_streamlinesinteractive = state;
}

void QMain::watch()
{

        int _w_sizex, _w_sizey;
        _w_sizex = size().rwidth();
        _w_sizey = size().rheight();

        if (_w_sizex != w_sizex || _w_sizey != w_sizey)
        {

                int _c_sizex, _c_sizey;
                _c_sizex = _w_sizex - pixoffsetx_rcanvas;
                _c_sizey = _w_sizey - pixoffsety_rcanvas;

                renderer_canvas->setGeometry(
                        QRect(pixposx_rcanvas, pixposy_rcanvas, _c_sizex, _c_sizey));

                
                renderer_canvas->resizeGL( _c_sizex, _c_sizey );

                w_sizex = _w_sizex;
                w_sizey = _w_sizey;
        }


}


void QMain::load_data_file()
{


        std::cout << "load data" << std::endl;

        //file dialog, retrieve filename and path
        QString filename = QFileDialog::getOpenFileName(this,
                tr("Open Grid"), ".", tr("Grid Files (*.gri)"));

        std::string tmp(filename.toAscii());

        if(tmp == "")
        {
                return;
        }

        int data[4];
        if ( !( renderer_canvas->load_data(filename, data) ) )
        {
                std::cerr << "Error loading file" << std::endl;
                return;
        }
        
        //voldimx = data[0];
        //voldimy = data[1];
        //voldimz = data[2];

        std::string tmpfilename(filename.toAscii());

        tmpfilename = tmpfilename.substr(tmpfilename.find_last_of('/') + 1, filename.length() - 1);

        std::string test = "VisLU Volume Renderer: ";
        test += tmpfilename;

        this->setWindowTitle(QApplication::translate("QMain", test.c_str() , 0, QApplication::UnicodeUTF8));

        
        slider_colmapping->setValue( 1 );
        slider_timestep->setValue( 1 );
        slider_colprop_valuechanged( 1 );
        slider_timestep_valuechanged( 1 );
        checkBox_tapering->setChecked( false );

        char buffer[16];

        sprintf_s(buffer, "%d", (int)renderer_canvas->getNumTimeSteps( ) );
        label_maxtimesteps->setText( buffer );
        slider_timestep->setMaximum( (int)renderer_canvas->getNumTimeSteps( ) );

        sprintf_s(buffer, "%d", (int)renderer_canvas->getNumDataValues( ) );
        label_maxcolmapping->setText( buffer );
        slider_colmapping->setMaximum( (int)renderer_canvas->getNumDataValues( ) );

        int decint = renderer_canvas->getFlowDataMin();
        int udecint = (int)(100.0f * abs( renderer_canvas->getFlowDataMin() - (float)decint));
        sprintf_s(buffer, "%d.%d", decint, udecint );
        label_min->setText( buffer );

        decint = renderer_canvas->getFlowDataMax();
        udecint = (int)(100.0f * abs( renderer_canvas->getFlowDataMax() - (float)decint));
        sprintf_s(buffer, "%d.%d", decint, udecint );
        label_maximum->setText( buffer );

        combo_seedsplacing_switched( comboseeds_active );

        
        renderer_canvas->repaint();
        tf_canvas->repaint();
}

void QMain::load_single_file()
{
        

        std::cout << "load data" << std::endl;

        //file dialog, retrieve filename and path
        QString filename = QFileDialog::getOpenFileName(this,
                tr("Open Grid"), ".", tr("Grid Files (*.gri)"));

        QString datfilename = QFileDialog::getOpenFileName(this,
                tr("Open Dat"), ".", tr("Dat Files (*.dat)"));

        std::string tmp(filename.toAscii());

        if(tmp == "")
        {
                return;
        }

        std::string dtmp(filename.toAscii());

        if(dtmp == "")
        {
                return;
        }

        int data[4];
        if ( !( renderer_canvas->load_single_data(filename, datfilename) ) )
        {
                std::cerr << "Error loading file" << std::endl;
                return;
        }

        //voldimx = data[0];
        //voldimy = data[1];
        //voldimz = data[2];

        std::string tmpfilename(filename.toAscii());

        tmpfilename = tmpfilename.substr(tmpfilename.find_last_of('/') + 1, filename.length() - 1);

        std::string test = "VisLU Volume Renderer: ";
        test += tmpfilename;

        this->setWindowTitle(QApplication::translate("QMain", test.c_str() , 0, QApplication::UnicodeUTF8));

        slider_colmapping->setValue( 1 );
        slider_timestep->setValue( 1 );
        slider_colprop_valuechanged( 1 );
        slider_timestep_valuechanged( 1 );
        checkBox_tapering->setChecked( false );

        char buffer[16];

        sprintf_s(buffer, "%d", (int)renderer_canvas->getNumTimeSteps( ) );
        label_maxtimesteps->setText( buffer );
        slider_timestep->setMaximum( (int)renderer_canvas->getNumTimeSteps( ) );

        sprintf_s(buffer, "%d", (int)renderer_canvas->getNumDataValues( ) );
        label_maxcolmapping->setText( buffer );
        slider_colmapping->setMaximum( (int)renderer_canvas->getNumDataValues( ) );

        int decint = renderer_canvas->getFlowDataMin();
        int udecint = (int)(100.0f * abs( renderer_canvas->getFlowDataMin() - (float)decint));
        sprintf_s(buffer, "%d.%d", decint, udecint );
        label_min->setText( buffer );

        decint = renderer_canvas->getFlowDataMax();
        udecint = (int)(100.0f * abs( renderer_canvas->getFlowDataMax() - (float)decint));
        sprintf_s(buffer, "%d.%d", decint, udecint );
        label_maximum->setText( buffer );

        combo_seedsplacing_switched( comboseeds_active );


        renderer_canvas->repaint();
        tf_canvas->repaint();
}

void QMain::save_data_file()
{

        std::cout << "saving data" << std::endl;

        //file dialog, retrieve filename and path
        QString filename = QFileDialog::getSaveFileName(this,
                tr("Save Volume with Gradient"), ".", tr("Volume Files with Gradient(*.gdat)"));

        std::string tmp(filename.toAscii());

        if(tmp == "")
        {
                return;
        }

        std::string fileend = tmp.substr(tmp.size()-5, tmp.size()-1);
        if(fileend.compare(".gdat") != 0)
        {
                tmp += ".gdat";
        }

        if ( !( renderer_canvas->save_data(tmp) ) )
        {
                std::cerr << "Error saving file" << std::endl;
                return;
        }

        
}

void QMain::load_tf_file()
{
        QString filename = QFileDialog::getOpenFileName(this,
                tr("Open TransferFunction"));

        std::string tmp(filename.toAscii());

        if(tmp == "")
        {
                return;
        }

        tf_canvas->loadTf(tmp);
        tf_canvas->defaultSize();

        std::string filend = tmp.substr(tmp.find_last_of('.'), tmp.size()-1);

        


        renderer_canvas->repaint();
        tf_canvas->repaint();
}

void QMain::save_tf_file()
{
        QString filename = QFileDialog::getSaveFileName(this,
                tr("Save TransferFunction"));

        std::string tmp(filename.toAscii());
        
        if(tmp == "")
        {
                return;
        }

        tf_canvas->saveTf(tmp);
}

void QMain::save_image()
{
        QString filename = QFileDialog::getSaveFileName(this,
                tr("Save Image"), ".", tr("Image Files (*.tga)"));
        
        std::string tmp(filename.toAscii());

        if(tmp == "")
        {
                return;
        }

        std::string fileend = tmp.substr(tmp.size()-4, tmp.size()-1);
        if(fileend.compare(".tga") != 0)
        {
                tmp += ".tga";
        }
        renderer_canvas->saveImage(tmp);
}

void QMain::save_big_image()
{
        QString filename = QFileDialog::getSaveFileName(this,
                tr("Save Image"), ".", tr("Image Files (*.tga)"));

        std::string tmp(filename.toAscii());

        if(tmp == "")
        {
                return;
        }

        std::string fileend = tmp.substr(tmp.size()-4, tmp.size()-1);
        if(fileend.compare(".tga") != 0)
        {
                tmp += ".tga";
        }
        renderer_canvas->saveBigImage(tmp);
}

void QMain::loadStreamLines()
{
        QString filename = QFileDialog::getOpenFileName(this,
                tr("Open StreamLines"), ".", tr("Streamline Files (*.bsl)"));

        std::string tmp(filename.toAscii());

        if(tmp == "")
        {
                return;
        }

        renderer_canvas->loadStreamLines(tmp);


        renderer_canvas->repaint();
}

void QMain::saveStreamLines()
{

        QString filename = QFileDialog::getSaveFileName(this,
                tr("Save Streamlines"), ".", tr("Streamline Files(*.bsl)"));

        std::string tmp(filename.toAscii());

        if(tmp == "")
        {
                return;
        }

        std::string fileend = tmp.substr(tmp.size()-4, tmp.size()-1);
        if(fileend.compare(".bsl") != 0)
        {
                tmp += ".bsl";
        }

        renderer_canvas->saveStreamLines(tmp);

}

---