Eigene Dateien/Vis/src/QVolRendCanvas.cpp

Go to the documentation of this file.

#include "QVolRendCanvas.h"

bool isfirstframe = true;


QVolRendCanvas::QVolRendCanvas(QWidget* parent /*= 0*/) : 
                        QObject(parent), 
                        QGLWidget(parent), 
                        m_TransferFunction(NULL), 
                        m_TransferFunction2D(NULL),
                        m_FramebufferObject(NULL),
                        m_MouseLastPos(0.0f,0.0f,0.0f), 
                        m_LookAtPoint(0.0f, 0.0f, 0.0f), 
                        m_CamDat(0.0f, 0.0f, 2.0f),
                        m_lightDir(0.0f, 1.0f, 0.0f),
                        m_modifyLight(false)
{
        glInit ();
        data_loaded = false;
        sliceview_active = true;
        apply_tf_in_sv = 0;
        apply_tf_in_vv = 0;

        m_MouseState = NO_DRAGGING;
        m_vecPosition = getSphereProjection(0.0f, 0.0f);
        m_LookAt = VVector(0.0f, 0.0f, 0.0f);
        m_Position = VVector(0.0f, 0.0f, 1.0f);
        m_Distance = 1.0f;
        m_PanOffset = VVector(0.0f, 0.0f, 0.0f);
        m_Rotation = VVector(0.0f, 0.0f, 0.0f);
        m_fAngle = 0.0f;

        view = VVector(0.0, 0.0, 1.0);
        up = VVector(0.0, 1.0, 0.0);

        side = view.getCross(up);
        side.normalize();
        up = side.getCross(view);
        up.normalize();

        lview = VVector(0.0, 0.0, 1.0);
        lup = VVector(0.0, 1.0, 0.0);

        lside = lview.getCross(lup);
        lside.normalize();
        lup = lside.getCross(lview);
        lup.normalize();
        m_VolumeRenderer.setLightDir(lview);

        //testImage.loadImage("textures/tree.png");
}


QVolRendCanvas::~QVolRendCanvas()
{
        if(m_FramebufferObject)
        {
                delete m_FramebufferObject;
        }
        m_TransferFunction = NULL;

        //delete m_BackgroundColor;
        m_BackgroundColor = NULL;

        
}

void QVolRendCanvas::setObjectName(const QString &name)
{
}

void QVolRendCanvas::setBackColorPtr(VVector *v)
{
        m_BackgroundColor = v;
}
void QVolRendCanvas::initializeGL()
{
        this->makeCurrent();
    // Set up the rendering context, define display lists etc.:
    //...
        glClearColor( 0.0, 0.0, 0.0, 1.0 );
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glEnable(GL_DEPTH_TEST);
    //...
}

void QVolRendCanvas::resizeGL( int w, int h )
{
        this->makeCurrent();
        glViewport(0, 0, w, h);

        if(sliceview_active)
        {
                
                //gluOrtho2D(0, w, h, 0);
                m_SliceRenderer.setHeight(h);
                m_SliceRenderer.setWidth(w);
        }
        if(m_FramebufferObject)
        {
                delete m_FramebufferObject;
                m_FramebufferObject = NULL;
        }

        m_FramebufferObject = new VFramebufferObject(width(), height(), GL_RGBA);
        m_FramebufferObject->init();

        m_VolumeRenderer.resize(w, h);
}

VVector QVolRendCanvas::getSphereProjection(float x, float y)
{
        VVector vecResult;
        vecResult.setX(cos(x) * sin(y));
        vecResult.setY(sin(x) * sin(y));
        const float fD = sqrtf(vecResult.getX() * vecResult.getX() + vecResult.getY() * vecResult.getY());
        vecResult.setZ(cosf((3.14159265f / 2.0f) * ((fD < 1.0f) ? fD : 1.0f)));
        //vecResult.setZ(cos(y));
        vecResult.normalize();
        return vecResult;
}

VVector QVolRendCanvas::getPlaneProjection(float x, float y)
{
        VVector vecResult;
        vecResult.setX(x);
        vecResult.setY(y);
        vecResult.setZ(0.0f);

        return vecResult;
}

void QVolRendCanvas::paintGL()
{       
        /*this*/makeCurrent();

        if(m_TransferFunction)
        {

                m_SliceRenderer.setTransferFunctionHandle(m_TransferFunction->getGLHandle());
                m_VolumeRenderer.setTransferFunctionHandle(m_TransferFunction->getGLHandle());
        }

        if(m_TransferFunction2D)
        {
                m_VolumeRenderer.setTransferFunction2DHandle(m_TransferFunction2D->getGLHandle());
        }
        
        if(sliceview_active)
        {
                glClearColor(0.0f,0.0f,0.0f,1.0f);
        }
        else if(!sliceview_active)
        {
                float color[3] = {m_BackgroundColor->getX(),m_BackgroundColor->getY(),m_BackgroundColor->getZ()};
                glClearColor(m_BackgroundColor->getX(),m_BackgroundColor->getY(),m_BackgroundColor->getZ(), 0.0f);
                m_VolumeRenderer.setClearColor(color);
        }
        
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);     // Clear Screen And Depth Buffer
    glEnable(GL_DEPTH_TEST);


        if(!m_SliceRenderer.getProgramLoaded())
        {
                m_SliceRenderer.loadProgram();
        }

        if(!m_VolumeRenderer.getProgramLoaded())
        {
                m_VolumeRenderer.loadProgram();
        }

        if(!m_FramebufferObject)
        {
                m_FramebufferObject = new VFramebufferObject(width(), height(), GL_RGBA);
                m_FramebufferObject->init();
        }

        
        // draw the scene:
                                                                                
        if(sliceview_active && data_loaded)
        {
                m_FramebufferObject->bind();

                m_SliceRenderer.draw();

                m_FramebufferObject->unbind();
        }

        else if(!sliceview_active && data_loaded)
        {
                m_VolumeRenderer.drawFrontFaces();
                m_VolumeRenderer.drawBackFaces();

                m_FramebufferObject->bind();

                m_VolumeRenderer.draw();

                m_FramebufferObject->unbind();
        }

        
        const GLenum glError = glGetError();

        if (glError != GL_NO_ERROR)
                std::cout << "Error Rendering Scene to FBO " << gluErrorString(glError) << std::endl;

        glDisable(GL_CULL_FACE);

        m_FramebufferObject->renderToFullScreen();


        /*if(!sliceview_active && data_loaded)
        {
                m_VolumeRenderer.drawFrontFacesToSmallQuad();
                m_VolumeRenderer.drawBackFacesToSmallQuad();
        }*/

        //testImage.renderToLowerRightQuad();
        /*if(m_TransferFunction2D)
        {
                m_TransferFunction2D->renderTest();
        }*/

        
//      m_VolumeRenderer.getNoiseTexHandle()->renderToLowerRightQuad();
//      m_VolumeRenderer.getToonTexHandle()->renderToLowerRightQuad();
//      m_VolumeRenderer.getMetalTexHandle()->renderToLowerRightQuad();

}

void QVolRendCanvas::paintEvent( QPaintEvent *e )
{
        QGLWidget::paintEvent(e);
};

void QVolRendCanvas::mousePressEvent ( QMouseEvent * e )
{               
        
        const VMouseEvent me(getMouseEvent(e));

        float x = me.getPosition().getX();
        float y = me.getPosition().getY();

        if(me.getLeftState())
        {
                m_MouseState = ROTATE;
                m_vecPosition = getPlaneProjection(x,y);
                m_vecPosition *= VVector((float)height(), (float)width(), 0.0f);
        }
        else if(me.getMiddleState())
        {
                m_MouseState = PAN;
                m_vecPosition = getPlaneProjection(x,y);
        }
        else
        {
                m_MouseState = ZOOM;
                m_vecPosition = getPlaneProjection(x,y);
        }
        if(m_FramebufferObject)
        {
                delete m_FramebufferObject;
                m_FramebufferObject = NULL;
                //glViewport(0, 0, width()/2, height()/2);
                m_FramebufferObject = new VFramebufferObject(256, 256, GL_RGBA);
                m_FramebufferObject->init();
        }
        //m_VolumeRenderer.resize(width()/2, height()/2);
};

void QVolRendCanvas::mouseReleaseEvent ( QMouseEvent * e )
{
        isfirstframe = true;

        setCursor(QCursor(Qt::CursorShape::OpenHandCursor));

        m_MouseState = NO_DRAGGING;
        //glViewport(0, 0, width(), height());
        delete m_FramebufferObject;
        m_FramebufferObject = NULL;
        m_FramebufferObject = new VFramebufferObject(width(), height(), GL_RGBA);
        m_FramebufferObject->init();
        //m_fAngle = 0.0f;
        //m_vecPosition = VVector(0.0f, 0.0f, 0.0f);
};
        
void QVolRendCanvas::mouseMoveEvent ( QMouseEvent * e )
{
        setCursor(QCursor(Qt::CursorShape::ClosedHandCursor));

        const VMouseEvent me(getMouseEvent(e));

        // v is the position of the mouse
        // cursor over canvas: v ranges in R, from -1 to 1 in both directions, left bottom corner is -1,-1
        // cursor n.o. canvas: if mouse was pressed before cursor left canvas, position is outside the range R 
        const VVector v  = me.getPosition();
        

        float x = v.getX();
        float y = v.getY();

        float ny = 0.0f;
        float nx = 0.0f;

        switch (m_MouseState)
        {
        case ROTATE:
                {
                        VVector vecPosition = getPlaneProjection(y,x);
                        vecPosition *= VVector((float)height(), (float)width(), 0.0f);
                        VVector vecDifference = vecPosition - m_vecPosition;

                        nx = vecDifference.getX();
                        ny = vecDifference.getY();

                        if(isfirstframe)
                        {
                                nx = 0.0f;
                                ny = 0.0f;

                                isfirstframe = false;
                        }

                        //vecDifference.setX(vecDifference.getX());

                        m_Rotation += vecDifference / 2.0f;
                        m_vecPosition = vecPosition;
                }
                break;

        case PAN:
                {
                        const VVector vecPosition = getPlaneProjection(x,y);
                        const VVector vecDifference = vecPosition - m_vecPosition;
                        
                        VVector side = -m_VolumeRenderer.getCameraSideVector() * vecDifference.getX();
                        VVector up = -m_VolumeRenderer.getCameraUpVector() * vecDifference.getY();

                        m_PanOffset += side + up;
                        
                        m_vecPosition = vecPosition;
                }
                break;

        case ZOOM:
                {
                        VVector vecPosition = getPlaneProjection(x,y);
                        VVector vecDifference = vecPosition - m_vecPosition;

                        vecDifference.setX(vecDifference.getX());
                        vecDifference.setY(vecDifference.getY());
                        vecDifference.setZ(0.0);

                        float offset = (vecDifference.getY() > 0.0) ? sqrt(vecDifference.getDot(vecDifference)) : -sqrt(vecDifference.getDot(vecDifference));
                        m_Distance += -offset;

                        m_vecPosition = vecPosition;
                }
                break;
        }


        if(m_modifyLight)
        {
                //m_Rotation.setY(ny);
                //m_Rotation.setX(nx);

                VQuaternion rotation = VQuaternion::generateRotationY(ny);
                rotation.applyRotationX(nx);

                VVector newPos = rotation.getForwardVector();
                VVector newUp = rotation.getUpVector();

                newPos.normalize();
                newPos *= -1;

                ny *= -0.005f;
                nx *= -0.005f;

                float viewx, viewy, viewz;
                float sidex, sidey, sidez;
                float upx, upy, upz;

                viewx = lview.getX();
                viewy = lview.getY();
                viewz = lview.getZ();

                sidex = lside.getX();
                sidey = lside.getY();
                sidez = lside.getZ();

                upx = lup.getX();
                upy = lup.getY();
                upz = lup.getZ();

                float vinverse00, vinverse01, vinverse02;
                float vinverse10, vinverse11, vinverse12;
                float vinverse20, vinverse21, vinverse22;

                vinverse00 = sidex;
                vinverse01 = sidey;
                vinverse02 = sidez;

                vinverse10 = upx;
                vinverse11 = upy;
                vinverse12 = upz;

                vinverse20 = viewx;
                vinverse21 = viewy;
                vinverse22 = viewz;


                //transform the viewing coord system to cartesian so we can apply normal rotations

                lside.setX( 1.0/*vinverse00*sidex + vinverse01*sidey + vinverse02*sidez*/ );
                lside.setY( 0.0/*vinverse10*sidex + vinverse11*sidey + vinverse12*sidez*/ );
                lside.setZ( 0.0/*vinverse20*sidex + vinverse21*sidey + vinverse22*sidez*/ );

                lup.setX( 0.0/*vinverse00*upx + vinverse01*upy + vinverse02*upz*/ );
                lup.setY( 1.0/*vinverse10*upx + vinverse11*upy + vinverse12*upz*/ );
                lup.setZ( 0.0/*vinverse20*upx + vinverse21*upy + vinverse22*upz*/ );

                lview.setX( 0.0/*vinverse00*viewx + vinverse01*viewy + vinverse02*viewz*/ );
                lview.setY( 0.0/*vinverse10*viewx + vinverse11*viewy + vinverse12*viewz*/ );
                lview.setZ( 1.0/*vinverse20*viewx + vinverse21*viewy + vinverse22*viewz*/ );


                lview.normalize();
                lside.normalize();
                lup.normalize();

                viewx = lview.getX();
                viewy = lview.getY();
                viewz = lview.getZ();

                sidex = lside.getX();
                sidey = lside.getY();
                sidez = lside.getZ();

                upx = lup.getX();
                upy = lup.getY();
                upz = lup.getZ();

                //rotation around y axis (represents the up vector) with the x vector
                lview.setX( cos(-ny) * viewx + sin(-ny) * viewz );
                //view.setY( viewy );
                lview.setZ(-sin(-ny) * viewx + cos(-ny) * viewz );

                lside.setX( cos(-ny) * sidex + sin(-ny) * sidez );
                //side.setY( sidey );
                lside.setZ(-sin(-ny) * sidex + cos(-ny) * sidez );

                lview.normalize();
                lside.normalize();
                lup.normalize();

                viewx = lview.getX();
                viewy = lview.getY();
                viewz = lview.getZ();

                sidex = lside.getX();
                sidey = lside.getY();
                sidez = lside.getZ();

                upx = lup.getX();
                upy = lup.getY();
                upz = lup.getZ();

                //rotation around x axis (represents the side vector) with the y vector
                //view.setX( viewx );
                lview.setY( cos(nx) * viewy - sin(nx) * viewz );
                lview.setZ( sin(nx) * viewy + cos(nx) * viewz );

                //up.setX( upx );
                lup.setY( cos(nx) * upy - sin(nx) * upz );
                lup.setZ( sin(nx) * upy + cos(nx) * upz );


                lview.normalize();
                lside.normalize();
                lup.normalize();

                viewx = lview.getX();
                viewy = lview.getY();
                viewz = lview.getZ();

                sidex = lside.getX();
                sidey = lside.getY();
                sidez = lside.getZ();

                upx = lup.getX();
                upy = lup.getY();
                upz = lup.getZ();

                float v00, v01, v02;
                float v10, v11, v12;
                float v20, v21, v22;

                v00 = vinverse00;
                v01 = vinverse10;
                v02 = vinverse20;

                v10 = vinverse01;
                v11 = vinverse11;
                v12 = vinverse21;

                v20 = vinverse02;
                v21 = vinverse12;
                v22 = vinverse22;

                //transform the viewing coord system to cartesian so we can apply normal rotations

                lview.setX( v00*viewx + v01*viewy + v02*viewz );
                lview.setY( v10*viewx + v11*viewy + v12*viewz );
                lview.setZ( v20*viewx + v21*viewy + v22*viewz );

                lside.setX( v00*sidex + v01*sidey + v02*sidez );
                lside.setY( v10*sidex + v11*sidey + v12*sidez );
                lside.setZ( v20*sidex + v21*sidey + v22*sidez );

                lup.setX( v00*upx + v01*upy + v02*upz );
                lup.setY( v10*upx + v11*upy + v12*upz );
                lup.setZ( v20*upx + v21*upy + v22*upz );

                lview.normalize();
                lside.normalize();
                lup.normalize();

                m_VolumeRenderer.setLightDir(lview);
        }
        else
        {
                //m_Rotation.setY(ny);
                //m_Rotation.setX(nx);

                VQuaternion rotation = VQuaternion::generateRotationY(ny);
                rotation.applyRotationX(nx);

                VVector newPos = rotation.getForwardVector();
                VVector newUp = rotation.getUpVector();

                newPos.normalize();
                newPos *= -1;

                ny *= -0.005f;
                nx *= -0.005f;

                float viewx, viewy, viewz;
                float sidex, sidey, sidez;
                float upx, upy, upz;

                viewx = view.getX();
                viewy = view.getY();
                viewz = view.getZ();

                sidex = side.getX();
                sidey = side.getY();
                sidez = side.getZ();

                upx = up.getX();
                upy = up.getY();
                upz = up.getZ();

                float vinverse00, vinverse01, vinverse02;
                float vinverse10, vinverse11, vinverse12;
                float vinverse20, vinverse21, vinverse22;

                vinverse00 = sidex;
                vinverse01 = sidey;
                vinverse02 = sidez;

                vinverse10 = upx;
                vinverse11 = upy;
                vinverse12 = upz;

                vinverse20 = viewx;
                vinverse21 = viewy;
                vinverse22 = viewz;


                //transform the viewing coord system to cartesian so we can apply normal rotations

                side.setX( 1.0/*vinverse00*sidex + vinverse01*sidey + vinverse02*sidez*/ );
                side.setY( 0.0/*vinverse10*sidex + vinverse11*sidey + vinverse12*sidez*/ );
                side.setZ( 0.0/*vinverse20*sidex + vinverse21*sidey + vinverse22*sidez*/ );

                up.setX( 0.0/*vinverse00*upx + vinverse01*upy + vinverse02*upz*/ );
                up.setY( 1.0/*vinverse10*upx + vinverse11*upy + vinverse12*upz*/ );
                up.setZ( 0.0/*vinverse20*upx + vinverse21*upy + vinverse22*upz*/ );

                view.setX( 0.0/*vinverse00*viewx + vinverse01*viewy + vinverse02*viewz*/ );
                view.setY( 0.0/*vinverse10*viewx + vinverse11*viewy + vinverse12*viewz*/ );
                view.setZ( 1.0/*vinverse20*viewx + vinverse21*viewy + vinverse22*viewz*/ );


                view.normalize();
                side.normalize();
                up.normalize();

                viewx = view.getX();
                viewy = view.getY();
                viewz = view.getZ();

                sidex = side.getX();
                sidey = side.getY();
                sidez = side.getZ();

                upx = up.getX();
                upy = up.getY();
                upz = up.getZ();

                //rotation around y axis (represents the up vector) with the x vector
                view.setX( cos(-ny) * viewx + sin(-ny) * viewz );
                //view.setY( viewy );
                view.setZ(-sin(-ny) * viewx + cos(-ny) * viewz );

                side.setX( cos(-ny) * sidex + sin(-ny) * sidez );
                //side.setY( sidey );
                side.setZ(-sin(-ny) * sidex + cos(-ny) * sidez );

                view.normalize();
                side.normalize();
                up.normalize();

                viewx = view.getX();
                viewy = view.getY();
                viewz = view.getZ();

                sidex = side.getX();
                sidey = side.getY();
                sidez = side.getZ();

                upx = up.getX();
                upy = up.getY();
                upz = up.getZ();

                //rotation around x axis (represents the side vector) with the y vector
                //view.setX( viewx );
                view.setY( cos(nx) * viewy - sin(nx) * viewz );
                view.setZ( sin(nx) * viewy + cos(nx) * viewz );

                //up.setX( upx );
                up.setY( cos(nx) * upy - sin(nx) * upz );
                up.setZ( sin(nx) * upy + cos(nx) * upz );


                view.normalize();
                side.normalize();
                up.normalize();

                viewx = view.getX();
                viewy = view.getY();
                viewz = view.getZ();

                sidex = side.getX();
                sidey = side.getY();
                sidez = side.getZ();

                upx = up.getX();
                upy = up.getY();
                upz = up.getZ();

                float v00, v01, v02;
                float v10, v11, v12;
                float v20, v21, v22;

                v00 = vinverse00;
                v01 = vinverse10;
                v02 = vinverse20;

                v10 = vinverse01;
                v11 = vinverse11;
                v12 = vinverse21;

                v20 = vinverse02;
                v21 = vinverse12;
                v22 = vinverse22;

                //transform the viewing coord system to cartesian so we can apply normal rotations

                view.setX( v00*viewx + v01*viewy + v02*viewz );
                view.setY( v10*viewx + v11*viewy + v12*viewz );
                view.setZ( v20*viewx + v21*viewy + v22*viewz );

                side.setX( v00*sidex + v01*sidey + v02*sidez );
                side.setY( v10*sidex + v11*sidey + v12*sidez );
                side.setZ( v20*sidex + v21*sidey + v22*sidez );

                up.setX( v00*upx + v01*upy + v02*upz );
                up.setY( v10*upx + v11*upy + v12*upz );
                up.setZ( v20*upx + v21*upy + v22*upz );

                view.normalize();
                side.normalize();
                up.normalize();

                m_VolumeRenderer.processGuiInput(m_Distance, newPos + m_PanOffset, view, up,  m_LookAt + m_PanOffset);
        }
        

};

void QVolRendCanvas::mouseDoubleClickEvent ( QMouseEvent * e )
{
        
        const VMouseEvent me(getMouseEvent(e));
        const VVector v  = me.getPosition();

        if (!sliceview_active) 
        {
                m_MouseLastPos = VVector(0.0f,0.0f,0.0f); 
                m_LookAtPoint = VVector(0.0f, 0.0f, 0.0f); 
                m_CamDat = VVector(0.0f, 0.0f, 2.0f);

                m_vecPosition = getSphereProjection(0.0f, 0.0f);
                m_LookAt = VVector(0.0f, 0.0f, 0.0f);
                m_Position = VVector(0.0f, 0.0f, 1.0f);
                m_Distance = 1.0f;
                m_PanOffset = VVector(0.0f, 0.0f, 0.0f);
                m_Rotation = VVector(0.0f, 0.0f, 0.0f);
                m_fAngle = 0.0f;

                view = VVector(0.0, 0.0, 1.0);
                up = VVector(0.0, 1.0, 0.0);

                side = view.getCross(up);
                side.normalize();
                up = side.getCross(view);
                up.normalize();

                lview = VVector(0.0, 0.0, 1.0);
                lup = VVector(0.0, 1.0, 0.0);

                lside = lview.getCross(lup);
                lside.normalize();
                lup = lside.getCross(lview);
                lup.normalize();

                isfirstframe = true;

                
                VQuaternion rotation = VQuaternion::generateRotationY(0.0f);
                rotation.applyRotationX(0.0f);

                VVector newPos = rotation.getForwardVector();
                VVector newUp = rotation.getUpVector();

                newPos.normalize();
                newPos *= -1;
                m_VolumeRenderer.processGuiInput(m_Distance, newPos + m_PanOffset, view, up,  m_LookAt + m_PanOffset);

                return;
        }

        if (m_SliceRenderer.getSliceMode() == ALL && v.getX() >= 0.0f && v.getY() >= 0.0f)
        {
                m_SliceRenderer.setSliceMode( TRANSVERSAL );
                repaint();
                return;
        }

        if (m_SliceRenderer.getSliceMode() == ALL && v.getX() < 0.0f && v.getY() >= 0.0f)
        {
                m_SliceRenderer.setSliceMode( SAGGITAL );
                repaint();
                return;
        }

        if (m_SliceRenderer.getSliceMode() == ALL && v.getX() < 0.0f && v.getY() < 0.0f)
        {
                m_SliceRenderer.setSliceMode( CORRONAL );
                repaint();
                return;
        }

        if (m_SliceRenderer.getSliceMode() != ALL )
        {
                m_SliceRenderer.setSliceMode( ALL );
                repaint();
                return;
        }


};

void QVolRendCanvas::keyPressEvent ( QKeyEvent * e )
{
        //const VKeyboardEvent ke(getKeyboardEvent(e));

};

void QVolRendCanvas::keyReleaseEvent ( QKeyEvent * e )
{
        //const VKeyboardEvent ke(getKeyboardEvent(e));
        
};

const VMouseEvent QVolRendCanvas::getMouseEvent (QMouseEvent *e)
{
        const VVector vecPosition( (2.0f * float(e->x()) - float(width()))  / float(width()),
                                      ( float(height()) - 2.0f * float(e->y())) / float(height()),
                                                           0.0f);
        const int iButton = 
                                ((e->button() == Qt::LeftButton)        ? VMouseEvent::BUTTON_LEFT       : 
                                ((e->button() == Qt::MidButton)         ? VMouseEvent::BUTTON_MIDDLE : 
                                ((e->button() == Qt::RightButton)       ? VMouseEvent::BUTTON_RIGHT      : VMouseEvent::BUTTON_NONE)));

        const int iStateLeft    = (e->buttons () & Qt::LeftButton)      ? VMouseEvent::STATE_DOWN : VMouseEvent::STATE_UP;
        const int iStateMiddle  = (e->buttons () & Qt::MidButton)       ? VMouseEvent::STATE_DOWN : VMouseEvent::STATE_UP;
        const int iStateRight   = (e->buttons () & Qt::RightButton) ? VMouseEvent::STATE_DOWN : VMouseEvent::STATE_UP;

        const int iModifiers =   ((e->modifiers()   & Qt::ShiftModifier)   ? VKeyboardEvent::MODIFIER_SHIFT : 0) 
                                                   | ((e->modifiers()   & Qt::ControlModifier) ? VKeyboardEvent::MODIFIER_CTRL  : 0) 
                                                   | ((e->modifiers()   & Qt::AltModifier)     ? VKeyboardEvent::MODIFIER_ALT   : 0);

        return VMouseEvent(vecPosition,iButton,iStateLeft,iStateMiddle,iStateRight,iModifiers);

};

const VKeyboardEvent QVolRendCanvas::getKeyboardEvent (QKeyEvent *e)
{
        const int iKey = e->key();

        const int iModifiers =    ((e->modifiers() & Qt::ShiftModifier)         ? VKeyboardEvent::MODIFIER_SHIFT : 0) 
                                                        | ((e->modifiers() & Qt::ControlModifier)       ? VKeyboardEvent::MODIFIER_CTRL  : 0) 
                                                        | ((e->modifiers() & Qt::AltModifier)           ? VKeyboardEvent::MODIFIER_ALT   : 0);

        return VKeyboardEvent(iKey,iModifiers);

};

void QVolRendCanvas::redraw()
{
        /*this*/makeCurrent();
        paintGL();
}

void QVolRendCanvas::activate_sliceview()
{
        sliceview_active = true;
}

void QVolRendCanvas::activate_volview()
{
        sliceview_active = false;
}

void QVolRendCanvas::setActiveSaggitalSlice(int s)
{
        m_SliceRenderer.setActiveSaggitalSlice(s);
}

void QVolRendCanvas::setActiveCorronalSlice(int s)
{
        m_SliceRenderer.setActiveCorronalSlice(s);
}

void QVolRendCanvas::setActiveTransversalSlice(int s)
{
        m_SliceRenderer.setActiveTransversalSlice(s);
}

bool QVolRendCanvas::load_data(QString filename, int *data)
{
        if(data_loaded)
        {
                m_Volume.clear();
                data_loaded = false;
        }

        /*this*/makeCurrent();

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

        data_loaded = m_Volume.loadVolume(tmp, data);

        if (!data_loaded) return false;

        m_SliceRenderer.setVolume(&m_Volume);
        m_VolumeRenderer.setVolume(&m_Volume);
        m_VolumeRenderer.resetProxyGeometry();
        m_TransferFunction->setMaxHist(data[3]);

        repaint();
        
        return true;

}

bool QVolRendCanvas::save_data(std::string filename)
{
        return m_Volume.saveVolume(filename);
}

void QVolRendCanvas::setApplyTFInSV(int v)
{
        apply_tf_in_sv = v;
        apply_tf_in_vv = v;
        m_SliceRenderer.activate_tf(v);
        m_VolumeRenderer.activate_tf(v);
        
}



void QVolRendCanvas::rendermode_changed(int i)
{
        std::cout << i << std::endl;

        switch(i)
        {
        case 0:
                {
                        m_RenderMode = MIP;
                        break;
                }
        case 1:
                {
                        m_RenderMode = DVR_FTB;
                        break;
                }
        case 2:
                {
                        m_RenderMode = DVR_BTF;
                        break;
                }
        case 3:
                {
                        m_RenderMode = COMB;
                        break;
                }
        case 4:
                {
                        m_RenderMode = CURVATURE;
                        break;
                }

        }

        m_VolumeRenderer.setRenderMode(m_RenderMode);
}

void QVolRendCanvas::lightmode_changed(int i)
{
        std::cout << i << std::endl;

        switch(i)
        {
        
        case 0:
                {
                        m_LightMode = PHONG;
                        break;
                }
        case 1:
                {
                        m_LightMode = TOON;
                        break;
                }
        case 2:
                {
                        m_LightMode = METAL;
                        break;
                }

        }

        m_VolumeRenderer.setLightMode(m_LightMode);
}


void QVolRendCanvas::setOrthoProjection(bool m_orth)
{
        m_VolumeRenderer.setOrthoMode(m_orth, width(), height());
}

std::vector<int> * QVolRendCanvas::getDataHistogram()
{
        return m_Volume.getHistogramPtr();
}

unsigned char * QVolRendCanvas::getData2DHistogram()
{
        return m_Volume.get2DHistogramPtr();
}

void QVolRendCanvas::setTransferFunctionPtr(VTransferFunction *transfunc)
{
        m_TransferFunction = transfunc;
        m_TransferFunction->setMainCanvas(this);
}

void QVolRendCanvas::setTransferFunction2DPtr(VTransferFunction2D * transfunc)
{
        m_TransferFunction2D = transfunc;
        m_TransferFunction2D->setMainCanvas(this);
}

void QVolRendCanvas::saveImage(std::string filename)
{
        if(m_FramebufferObject)
        {
                makeCurrent();
                m_FramebufferObject->saveImage(filename);
        }
}

void QVolRendCanvas::flipX()
{
        m_Volume.flipVolumeX();
}


void QVolRendCanvas::flipY()
{
        m_Volume.flipVolumeY();
}


void QVolRendCanvas::flipZ()
{
        m_Volume.flipVolumeZ();
}

void QVolRendCanvas::modifyLight(bool val)
{
        m_modifyLight = val;
}


void QVolRendCanvas::setContourMode(bool val)
{
        m_VolumeRenderer.setContours(val);
}

void QVolRendCanvas::setShadowMode(bool val)
{
        m_VolumeRenderer.setShadows(val);
}

---