Eigene Dateien/Vis/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),
                                                                SLICE_VIEW_TAB(0),
                                                                VOL_VIEW_TAB(1),
                                                                PARALLELPROJECTION(1),
                                                                PERSPECTIVEPROJECTION(0)
{
        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());
        renderer_canvas->setTransferFunction2DPtr(tf_canvas->getTransferFunction2DPtr());


        m_BackgroundColor.setX(0.0f);
        m_BackgroundColor.setY(0.0f);
        m_BackgroundColor.setZ(0.0f);
        backgroundSelect->setVolBackColorPtr(&m_BackgroundColor);
        renderer_canvas->setBackColorPtr(&m_BackgroundColor);


        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);

        setMinimumSize(w_sizex,w_sizey);

        //std::cout << (int)(-0.05) << std::endl;
        
        connect( actionOpen,                            SIGNAL(triggered()),                    this, SLOT(load_data_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( actionNo_TF,                           SIGNAL(triggered()),                    this, SLOT(tf_menu_no())        );
        connect( actionTF_1D,                           SIGNAL(triggered()),                    this, SLOT(tf_menu_1d())        );
        connect( actionTF_2D,                           SIGNAL(triggered()),                    this, SLOT(tf_menu_2d())        );

        connect( mode_tab,                                      SIGNAL(currentChanged(int)),    this, SLOT(modetab_switched(int)) );
        connect( tfmode,                                        SIGNAL(activated(int)),                 this, SLOT(tf_menu(int)) );

        connect( sliceslider_corronal,          SIGNAL(valueChanged(int)),              this, SLOT(slicesslider_corronal_valuechanged(int)) );
        connect( sliceslider_saggital,          SIGNAL(valueChanged(int)),              this, SLOT(slicesslider_saggital_valuechanged(int)) );
        connect( sliceslider_transversal,       SIGNAL(valueChanged(int)),              this, SLOT(slicesslider_transversal_valuechanged(int)) );
        //connect( cb_apply_tf_to_slices,               SIGNAL(clicked(bool)),                  this, SLOT(apply_tf_in_slicieviewer(bool)) );
        connect( modes_combo,                           SIGNAL(activated(int)),                 this, SLOT(rendermode_changed(int)) );
        connect( lighttf_combo,                         SIGNAL(activated(int)),                 this, SLOT(lightmode_changed(int)) );
        connect( thresholdL_slider,                     SIGNAL(valueChanged(int)),              this, SLOT(thresholdvalL_valuechanged(int)) );
        connect( thresholdH_slider,                     SIGNAL(valueChanged(int)),              this, SLOT(thresholdvalH_valuechanged(int)) );

        connect( clipslider_xneg,                       SIGNAL(valueChanged(int)),              this, SLOT(clipxneg_valuechanged(int)) );
        connect( clipslider_xpos,                       SIGNAL(valueChanged(int)),              this, SLOT(clipxpos_valuechanged(int)) );
        connect( clipslider_yneg,                       SIGNAL(valueChanged(int)),              this, SLOT(clipyneg_valuechanged(int)) );
        connect( clipslider_ypos,                       SIGNAL(valueChanged(int)),              this, SLOT(clipypos_valuechanged(int)) );
        connect( clipslider_zneg,                       SIGNAL(valueChanged(int)),              this, SLOT(clipzneg_valuechanged(int)) );
        connect( clipslider_zpos,                       SIGNAL(valueChanged(int)),              this, SLOT(clipzpos_valuechanged(int)) );

        connect( clipcb_xneg,                           SIGNAL(clicked(bool)),                  this, SLOT(clipcb_xneg_clicked(bool)) );
        connect( clipcb_xpos,                           SIGNAL(clicked(bool)),                  this, SLOT(clipcb_xpos_clicked(bool)) );
        connect( clipcb_yneg,                           SIGNAL(clicked(bool)),                  this, SLOT(clipcb_yneg_clicked(bool)) );
        connect( clipcb_ypos,                           SIGNAL(clicked(bool)),                  this, SLOT(clipcb_ypos_clicked(bool)) );
        connect( clipcb_zneg,                           SIGNAL(clicked(bool)),                  this, SLOT(clipcb_zneg_clicked(bool)) );
        connect( clipcb_zpos,                           SIGNAL(clicked(bool)),                  this, SLOT(clipcb_zpos_clicked(bool)) );

        connect( proj_combo,                            SIGNAL(activated(int)),                 this, SLOT(projectionMode(int)) );

        connect( actionFlip_X,                          SIGNAL(triggered()),                            this, SLOT(flipX()));
        connect( actionFlip_Y,                          SIGNAL(triggered()),                            this, SLOT(flipY()));
        connect( actionFlip_Z,                          SIGNAL(triggered()),                            this, SLOT(flipZ()));
        connect( lightdir_cb,                           SIGNAL(clicked(bool)),                          this, SLOT(lightModification(bool)) );
        connect( contours_cb,                           SIGNAL(clicked(bool)),                          this, SLOT(setContourMode(bool)) );
        connect( contours_cb_2,                         SIGNAL(clicked(bool)),                          this, SLOT(setShadowMode(bool)) );

        connect( tfhorizscroll,                 SIGNAL(valueChanged(int)),              this, SLOT(tf_horizscroll_valuechanged(int)) );
        connect( tfvertscroll,                  SIGNAL(valueChanged(int)),              this, SLOT(tf_vertscroll_valuechanged(int)) );

        //disable in gui before data is loaded
        sliceslider_corronal->setEnabled(false);
        sliceslider_saggital->setEnabled(false);
        sliceslider_transversal->setEnabled(false);

        voldimx = 0;
        voldimy = 0;
        voldimz = 0;

        tfmode->setVisible(false);
        cb_apply_tf_to_slices->setVisible(false);
        cb_pcikdensity->setVisible(false);

        thresholdL_slider->setVisible(false);
        thresholdH_slider->setVisible(false);
        thresholdL_label->setVisible(false);
        thresholdH_label->setVisible(false);
        thresholdH_name->setVisible(false);
        thresholdL_name->setVisible(false);
        tfvertscroll->setVisible(false);
        tfhorizscroll->setVisible(false);

        tf_canvas->setCursor(Qt::CursorShape::ForbiddenCursor);
        tf_canvas->modeChanged(0);
        tf_canvas->setModePtr(tfmode);
        tf_canvas->setVScroll(tfvertscroll);
        tf_canvas->setHScroll(tfhorizscroll);
}


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::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;
        }

        tf_canvas->checkForLongClick();

}
void QMain::thresholdvalL_valuechanged(int val)
{

        renderer_canvas->m_VolumeRenderer.setThresholdL((float)val/100.0f);

        char buffer[16];
        sprintf_s(buffer, "%f", (float)val/100.0f);
        thresholdL_label->setText(buffer);

        if(thresholdH_slider->value() < val)
        {
                thresholdvalH_valuechanged(val);
                thresholdH_slider->setValue(val);
        }

}

void QMain::thresholdvalH_valuechanged(int val)
{

        renderer_canvas->m_VolumeRenderer.setThresholdH((float)val/100.0f);

        char buffer[16];
        sprintf_s(buffer, "%f", (float)val/100.0f);
        thresholdH_label->setText(buffer);

        if(thresholdL_slider->value() > val)
        {
                thresholdvalL_valuechanged(val);
                thresholdL_slider->setValue(val);
        }
}

void QMain::clipxneg_valuechanged(int val)
{
        char buffer[16];
        sprintf_s(buffer, "%f", (float)val/100.0f);
        clipxneg_val->setText(buffer);

        if (val > clipslider_xpos->value())
        {
                clipslider_xpos->setValue(val);
                clipxpos_val->setText(buffer);
                if(clipcb_xpos->checkState() == Qt::Checked)
                        renderer_canvas->setClipPlane(RIGHT_LEFT, (float)val/100.0f);

        }
        if(clipcb_xneg->checkState() == Qt::Checked)
                renderer_canvas->setClipPlane(LEFT_RIGHT, (float)val/100.0f);
}

void QMain::clipxpos_valuechanged(int val)
{
        char buffer[16];
        sprintf_s(buffer, "%f", (float)val/100.0f);
        clipxpos_val->setText(buffer);

        if (val < clipslider_xneg->value())
        {
                clipslider_xneg->setValue(val);
                clipxneg_val->setText(buffer);
                if(clipcb_xneg->checkState() == Qt::Checked)
                        renderer_canvas->setClipPlane(LEFT_RIGHT, (float)val/100.0f);

        }
        if(clipcb_xpos->checkState() == Qt::Checked)
                renderer_canvas->setClipPlane(RIGHT_LEFT, (float)val/100.0f);
}

void QMain::clipyneg_valuechanged(int val)
{
        char buffer[16];
        sprintf_s(buffer, "%f", (float)val/100.0f);
        clipyneg_val->setText(buffer);

        if (val > clipslider_ypos->value())
        {
                clipslider_ypos->setValue(val);
                clipypos_val->setText(buffer);
                if(clipcb_ypos->checkState() == Qt::Checked)
                        renderer_canvas->setClipPlane(TOP_BOTTOM, (float)val/100.0f);
        }
        if(clipcb_yneg->checkState() == Qt::Checked)
                renderer_canvas->setClipPlane(BOTTOM_TOP, (float)val/100.0f);
}

void QMain::clipypos_valuechanged(int val)
{
        char buffer[16];
        sprintf_s(buffer, "%f", (float)val/100.0f);
        clipypos_val->setText(buffer);

        if (val < clipslider_yneg->value())
        {
                clipslider_yneg->setValue(val);
                clipyneg_val->setText(buffer);
                if(clipcb_yneg->checkState() == Qt::Checked)
                        renderer_canvas->setClipPlane(BOTTOM_TOP, (float)val/100.0f);
        }
        if(clipcb_ypos->checkState() == Qt::Checked)
                renderer_canvas->setClipPlane(TOP_BOTTOM, (float)val/100.0f);
}

void QMain::clipzneg_valuechanged(int val)
{
        char buffer[16];
        sprintf_s(buffer, "%f", (float)val/100.0f);
        clipzneg_val->setText(buffer);

        if (val > clipslider_zpos->value())
        {
                clipslider_zpos->setValue(val);
                clipzpos_val->setText(buffer);
                if(clipcb_zneg->checkState() == Qt::Checked)
                        renderer_canvas->setClipPlane(BACK_FRONT, (float)val/100.0f);
        }
        if(clipcb_zpos->checkState() == Qt::Checked)
                renderer_canvas->setClipPlane(FRONT_BACK, (float)val/100.0f);
}

void QMain::clipzpos_valuechanged(int val)
{
        char buffer[16];
        sprintf_s(buffer, "%f", (float)val/100.0f);
        clipzpos_val->setText(buffer);

        if (val < clipslider_zneg->value())
        {
                clipslider_zneg->setValue(val);
                clipzneg_val->setText(buffer);
                if(clipcb_zpos->checkState() == Qt::Checked)
                        renderer_canvas->setClipPlane(FRONT_BACK, (float)val/100.0f);
        }
        if(clipcb_zneg->checkState() == Qt::Checked)
                renderer_canvas->setClipPlane(BACK_FRONT, (float)val/100.0f);
}

void QMain::clipcb_xneg_clicked(bool  val)
{
        if(val)
        {
                renderer_canvas->setClipPlane(LEFT_RIGHT, (float)clipslider_xneg->value()/100.0f);
        }
        else
        {
                renderer_canvas->setClipPlane(LEFT_RIGHT, 0.0f);
        }
}

void QMain::clipcb_xpos_clicked(bool val)
{
        if(val)
        {
                renderer_canvas->setClipPlane(RIGHT_LEFT, (float)clipslider_xpos->value()/100.0f);
        }
        else
        {
                renderer_canvas->setClipPlane(RIGHT_LEFT, 1.0f);
        }
}

void QMain::clipcb_yneg_clicked(bool val)
{
        if(val)
        {
                renderer_canvas->setClipPlane(BOTTOM_TOP, (float)clipslider_yneg->value()/100.0f);
        }
        else
        {
                renderer_canvas->setClipPlane(BOTTOM_TOP, 0.0f);
        }
}

void QMain::clipcb_ypos_clicked(bool val)
{
        if(val)
        {
                renderer_canvas->setClipPlane(TOP_BOTTOM, (float)clipslider_ypos->value()/100.0f);
        }
        else
        {
                renderer_canvas->setClipPlane(TOP_BOTTOM, 1.0f);
        }
}

void QMain::clipcb_zneg_clicked(bool val)
{
        if(val)
        {
                renderer_canvas->setClipPlane(BACK_FRONT, (float)clipslider_zpos->value()/100.0f);
        }
        else
        {
                renderer_canvas->setClipPlane(BACK_FRONT, 1.0f);
        }
}

void QMain::clipcb_zpos_clicked(bool val)
{
        if(val)
        {
                renderer_canvas->setClipPlane(FRONT_BACK, (float)clipslider_zneg->value()/100.0f);
        }
        else
        {
                renderer_canvas->setClipPlane(FRONT_BACK, 0.0f);
        }
}

void QMain::rendermode_changed(int mod)
{
        renderer_canvas->rendermode_changed(mod);

        thresholdH_slider->setVisible(mod>=3);
        thresholdH_label->setVisible(mod>=3);
        thresholdL_slider->setVisible(mod>=3);
        thresholdL_label->setVisible(mod>=3);
        thresholdH_name->setVisible(mod>=3);
        thresholdL_name->setVisible(mod>=3);
        
}

void QMain::lightmode_changed(int mod)
{
        renderer_canvas->lightmode_changed(mod);
}

void QMain::tf_menu(int index)
{

        switch(index)
        {
                case 0:
                        {
                                std::cout <<  "Transfer function disabled" << std::endl;
                                tf->setTitle("Transfer function (Disabled)");
                                tf_canvas->setCursor(Qt::CursorShape::ForbiddenCursor);
                                renderer_canvas->setApplyTFInSV(0);
                                tf_canvas->modeChanged(0);
                                renderer_canvas->repaint();
                                tf_canvas->repaint();
                                break;
                        }
                case 1:
                        {
                                std::cout <<  "Transfer function 1D set" << std::endl;
                                tf->setTitle("Transfer function (1D)");
                                tf_canvas->setCursor(Qt::CursorShape::CrossCursor);
                                renderer_canvas->setApplyTFInSV(1);
                                tf_canvas->modeChanged(1);
                                renderer_canvas->repaint();
                                tf_canvas->repaint();
                                break;
                        }
                case 2:
                        {
                                std::cout <<  "Transfer function 2D set" << std::endl;
                                tf->setTitle("Transfer function (2D)");
                                tf_canvas->setCursor(Qt::CursorShape::CrossCursor);
                                renderer_canvas->setApplyTFInSV(2);
                                tf_canvas->modeChanged(2);
                                renderer_canvas->repaint();
                                tf_canvas->repaint();
                                break;
                        }
        }

        tf_canvas->modeChanged(index);
        tfmode->setVisible(false);
}


//void QMain::rendermode_changed(int index)
//{}

void QMain::modetab_switched(int id){
        
        if(id == SLICE_VIEW_TAB)
        {
                renderer_canvas->activate_sliceview();
        }

        if(id == VOL_VIEW_TAB)
        {
                renderer_canvas->activate_volview();
        }

        renderer_canvas->repaint();
                
        renderer_canvas->repaint();

};


void QMain::slicesslider_corronal_valuechanged(int val){
        
        renderer_canvas->setActiveCorronalSlice(val);

        char buffer[16];
        sprintf_s(buffer, "(%d/%d)", val, voldimy);
        cor_slicenum->setText(buffer);

        renderer_canvas->repaint();
};

void QMain::slicesslider_saggital_valuechanged(int val){

        renderer_canvas->setActiveSaggitalSlice(val);char buffer[16];
        sprintf_s(buffer, "(%d/%d)", val, voldimx);
        sag_slicenum->setText(buffer);
        renderer_canvas->repaint();
};

void QMain::slicesslider_transversal_valuechanged(int val){

        renderer_canvas->setActiveTransversalSlice(val);
        char buffer[16];
        sprintf_s(buffer, "(%d/%d)", val, voldimz);
        tran_slicenum->setText(buffer);
        renderer_canvas->repaint();
};

void QMain::apply_tf_in_slicieviewer(bool val)
{
        renderer_canvas->setApplyTFInSV(val);
        renderer_canvas->repaint();
}

void QMain::load_data_file()
{

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

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

        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];

        tf_canvas->setHistogram(renderer_canvas->getDataHistogram(), renderer_canvas->getData2DHistogram());

        sliceslider_corronal->setEnabled(true);
        sliceslider_saggital->setEnabled(true);
        sliceslider_transversal->setEnabled(true);

        sliceslider_saggital->setRange(         1, voldimx);
        sliceslider_corronal->setRange(         1, voldimy);
        sliceslider_transversal->setRange(      1, voldimz);

        sliceslider_corronal->setValue(1);
        sliceslider_saggital->setValue(1);
        sliceslider_transversal->setValue(1);

        char buffer[16];
        sprintf_s(buffer, "(1/%d)", voldimy);
        cor_slicenum->setText(QString(buffer));
        sprintf_s(buffer, "(1/%d)", voldimx);
        sag_slicenum->setText(QString(buffer));
        sprintf_s(buffer, "(1/%d)", voldimz);
        tran_slicenum->setText(QString(buffer));

        apply_tf_in_slicieviewer(false);
        cb_apply_tf_to_slices->setCheckState(Qt::Unchecked);
        renderer_canvas->repaint();

        this->tf_menu_no();
        this->tf_menu(0);
        tfmode->setCurrentIndex(0);
        //tfmode->setCurrentIndex(0);
        //tf->setTitle("Transfer function (Disabled)");

        /*vTransferFunctionPoint tmpoint;
        tmpoint.m_Color = VVector(1.0, 1.0, 1.0);
        tmpoint.m_Alpha = 1.0;
        tf_canvas->getTransferFunctionPtr()->addTransferFunctionPoint(4095,tmpoint);
        tf_canvas->repaint();
        */
        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));
}

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"), ".", tr("Transferfunction Files (*.btf *.bt2f)"));

        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);

        if(filend.compare(".btf") == 0)
        {
                this->tf_menu_1d();
                this->tf_menu(1);
                tfmode->setCurrentIndex(1);
        }
        else if(filend.compare(".bt2f") == 0)
        {
                this->tf_menu_2d();
                this->tf_menu(2);
                tfmode->setCurrentIndex(2);
        }


        renderer_canvas->repaint();
}

void QMain::save_tf_file()
{
        QString filename = QFileDialog::getSaveFileName(this,
                tr("Save TransferFunction"), ".", tr("Transferfunction Files (*.btf *.bt2f)"));

        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::tf_menu_no()
{
        std::cout <<  "Transfer function disabled" << std::endl;
        tf->setTitle("Transfer function (Disabled)");
        tf_canvas->setCursor(Qt::CursorShape::ForbiddenCursor);
        renderer_canvas->setApplyTFInSV(0);
        tf_canvas->modeChanged(0);
        renderer_canvas->repaint();
        tf_canvas->repaint();
}

void QMain::tf_menu_1d()
{
        
        std::cout <<  "Transfer function 1D set" << std::endl;
        tf->setTitle("Transfer function (1D)");
        tf_canvas->setCursor(Qt::CursorShape::CrossCursor);
        renderer_canvas->setApplyTFInSV(1);
        renderer_canvas->repaint();
        tf_canvas->modeChanged(1);
}

void QMain::tf_menu_2d()
{

        
        std::cout <<  "Transfer function 2D set" << std::endl;
        tf->setTitle("Transfer function (2D)");
        tf_canvas->setCursor(Qt::CursorShape::CrossCursor);
        renderer_canvas->setApplyTFInSV(2);
        renderer_canvas->repaint();
        tf_canvas->modeChanged(2);
}

void QMain::projectionMode(int id)
{
        if(id == PERSPECTIVEPROJECTION)
        {
                renderer_canvas->setOrthoProjection(false);
        }
        else if(id == PARALLELPROJECTION)
        {
                renderer_canvas->setOrthoProjection(true);
        }
}

void QMain::flipX()
{
        renderer_canvas->flipX();
}

void QMain::flipY()
{
        renderer_canvas->flipY();
}

void QMain::flipZ()
{
        renderer_canvas->flipZ();
}

void QMain::lightModification(bool val)
{
        renderer_canvas->modifyLight(val);
}

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

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

---