Eigene Dateien/FlowVis/src/QVolRendCanvas.cpp

Go to the documentation of this file.

#include "QVolRendCanvas.h"
#include "VQuaternion.h"

bool isfirstframe = true;


QVolRendCanvas::QVolRendCanvas(QWidget* parent /*= 0*/) : 
                        QObject(parent), 
                        QGLWidget(parent), 
                        m_TransferFunction(NULL),
                        m_ArrowTransferFunction(NULL),
                        m_StreamLineTransferFunction(NULL),
                        m_FramebufferObject(NULL),
                        m_LicTransferFunction(NULL),
                        m_SaveImageFBO(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),
                        m_IsSaving(false),
                        m_SaveFileName(""),
                        m_FlowData(),
                        m_FlowRenderer(),
                        mArrowSize( 0.5f ),
                        mArrowSpacing( 0.5f ),
                        mStreamSeedSpacing( 0.5f ),
                        mStreamTestSpacing( 0.2f ),
                        mStremSteps( 0.5f ),
                        mStreamDT( 0.5 ),
                        m_EnableSeedpointsSetting( false ),
                        m_EnableEvenSeedpointsSetting( false ),
                        lic_activated(false),
                        m_EnableIconSetting(false),
                        tapering_activated( 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, -10.0f);
        m_Distance = 20.0f;
        m_PanOffset = VVector(5.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();

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

        //relevant to GUI

        arrows_activated = false;
        streamlines_activated = false;
        timestep_activated = 1;
        coloring_property = 1;
}


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

        //delete m_BackgroundColor;
        m_ArrowsColor = NULL;
        m_StreamlinesColor = NULL;

        
}

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

void QVolRendCanvas::timestep_changed_event( int val)
{
        timestep_activated = val;
        m_FlowData.setTimeStep( val - 1 );
        if ( m_EnableIconSetting )
        {
                m_FlowData.computeIcons(  );
        }
        repaint();

}

void QVolRendCanvas::coloringproperty_changed_event( int val)
{
        coloring_property = val;
        m_FlowRenderer.setCurrentShader( val );
        repaint();

}


void QVolRendCanvas::setStreamlinesColorPtr(VVector *v)
{
        m_StreamlinesColor = v;
        m_FlowRenderer.setStreamlinesColorPtr(v);
}


void QVolRendCanvas::setArrowsColorPtr(VVector *v)
{
        m_ArrowsColor =v;
        m_FlowRenderer.setArrowColorPtr(v);
}


void QVolRendCanvas::initializeGL()
{
        this->makeCurrent();
    // Set up the rendering context, define display lists etc.:
    //...
        glClearColor( 0.0, 0.0, 0.0, 0.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(m_FramebufferObject)
        {
                delete m_FramebufferObject;
                m_FramebufferObject = NULL;
        }

        m_FramebufferObject = new VFramebufferObject(width(), height(), GL_RGBA);
        m_FramebufferObject->init();
        m_FlowRenderer.resize(w, h);

        if( data_loaded )
        {
                m_PanOffset = m_FlowData.getFlowCenter();
                m_Position.setZ(-m_FlowData.getFlowExtends().getMagnitude());
                VVector extends = m_FlowData.getFlowExtends();
                float halfExdends = (extends.getX() < extends.getY()) ? extends.getY() : extends.getX();
                if( halfExdends == extends.getY())
                {
                        halfExdends /= 2.0f;
                }
                else
                {
                        halfExdends /= 2.0f;
                        halfExdends /= m_FlowRenderer.getCameraAspect();
                }

                float fov = m_FlowRenderer.getCameraFOV();
                fov /= 2.0f;


                m_Distance = halfExdends / tan(fov * 3.14159265f / 180.0f);
                m_FlowRenderer.processGuiInput(m_Distance, m_Position + m_PanOffset, view, up,  m_LookAt + m_PanOffset);
        }
}

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_FlowRenderer.setTransferFunctionHandle(m_TransferFunction->getGLHandle());
        }

        if(m_ArrowTransferFunction)
        {
                m_FlowRenderer.setArrowTransferFunctionHandle(m_ArrowTransferFunction->getGLHandle());
        }

        if(m_StreamLineTransferFunction)
        {
                m_FlowRenderer.setStreamLineTransferFunctionHandle(m_StreamLineTransferFunction->getGLHandle());
        }

        if(m_LicTransferFunction)
        {
                m_FlowRenderer.setLicTransferFunctionHandle(m_LicTransferFunction->getGLHandle());
        }

        if(!m_FlowRenderer.getProgramLoaded())
        {
                m_FlowRenderer.loadProgram();
        }
        
        if(sliceview_active)
        {
                glClearColor(0.0f,0.0f,0.0f,0.0f);
        }
        
        
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);     // Clear Screen And Depth Buffer
    glEnable(GL_DEPTH_TEST);


        if(m_IsSaving && data_loaded)
        {
                

                bool finished = true;

                if(!m_FlowData.getTexturesGenerated())
                {
                        m_FlowData.generateTextures();
                        //m_FlowData.generateStreamLines(1024, 0.02f, 0);
                }

                m_SaveImageFBO->bind();

                glDisable(GL_DEPTH_TEST);

                m_FlowRenderer.draw( timestep_activated - 1 );

                if( lic_activated )
                {
                        m_FlowRenderer.drawLic( timestep_activated - 1 );
                }

                if( arrows_activated )
                {
                        m_FlowRenderer.drawGlyphes( timestep_activated - 1 );
                }
                if (streamlines_activated) 
                {
                        m_FlowRenderer.drawStreamLines(  );
                }

                if( m_EnableIconSetting )
                {
                        m_FlowRenderer.drawIcons();
                }


                glEnable(GL_DEPTH_TEST);

                m_SaveImageFBO->unbind();

                glDisable(GL_CULL_FACE);

                m_SaveImageFBO->renderToFullScreen();

                m_SaveImageFBO->saveImage(m_SaveFileName);
                m_IsSaving = false;
                m_SaveFileName = "";
                m_SaveImageFBO->destroy();
                delete m_SaveImageFBO;
                m_SaveImageFBO = NULL;
        }
        else
        {
                if(!m_FramebufferObject)
                {
                        m_FramebufferObject = new VFramebufferObject(width(), height(), GL_RGBA);
                        m_FramebufferObject->init();
                }


                // draw the scene:
                if(data_loaded)
                {
                        if(!m_FlowData.getTexturesGenerated())
                        {
                                m_FlowData.generateTextures();
                                //m_FlowData.generateStreamLines(1024, 0.02f, 0);
                        }
                        

                        
                        m_FramebufferObject->bind();
                        
                        glDisable(GL_DEPTH_TEST);
                        
                        m_FlowRenderer.draw( timestep_activated - 1 );

                        if( lic_activated )
                        {
                                m_FlowRenderer.drawLic( timestep_activated - 1 );
                        }

                        if( arrows_activated )
                        {
                                m_FlowRenderer.drawGlyphes( timestep_activated - 1 );
                        }
                        if (streamlines_activated) 
                        {
                                m_FlowRenderer.drawStreamLines();
                        }
                        
                        if( m_EnableIconSetting )
                        {
                                m_FlowRenderer.drawIcons();
                        }

                        glEnable(GL_DEPTH_TEST);

                        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(data_loaded)
        {
                
                //m_FlowData.drawTextureTest( timestep_activated - 1 );
        }
        //if(m_TransferFunction)
        //{
        //      m_TransferFunction->renderTest();
        //}


}

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.getModifiers() == me.MODIFIER_ALT && ( m_EnableSeedpointsSetting || m_EnableEvenSeedpointsSetting || m_EnableIconSetting) ) 
        {
                setCursor(QCursor(Qt::CursorShape::CrossCursor));

                VMatrix proj = m_FlowRenderer.getCameraProjMatrix();
                VMatrix view = m_FlowRenderer.getCameraViewMatrix();

                VMatrix iviewproj = ( proj * view).getInverse();

                //params are in world space
                if ( m_EnableSeedpointsSetting )
                {
                        //transform 2 points to create a ray
                        VVector p1              = iviewproj * VVector( x, y, 1.0 );
                        VVector p2              = iviewproj * VVector( x, y, -1.0 );

                        m_PanOffset;

                        //intersect with the plane z = 0, where all data lie in the world space
                        float sumz = p2.getZ() - p1.getZ();
                        VVector pintersect = VVector( p1.getX() * p2.getZ() / sumz + p2.getX() * ( - p1.getZ() / sumz ),
                                                                                  p1.getY() * p2.getZ() / sumz + p2.getY() * ( - p1.getZ() / sumz ),
                                                                                  0.0f );
                        m_FlowData.addManualSeedpoint( pintersect.getX(), pintersect.getY() );
                        m_FlowData.drawStreamlinesFromSeedpoints( timestep_activated - 1, mStremSteps );
                }
                else if( m_EnableIconSetting )
                {
                        //transform 2 points to create a ray
                        VVector p1              = iviewproj * VVector( x, y, 1.0 );
                        VVector p2              = iviewproj * VVector( x, y, -1.0 );

                        m_PanOffset;

                        //intersect with the plane z = 0, where all data lie in the world space
                        float sumz = p2.getZ() - p1.getZ();
                        VVector pintersect = VVector( p1.getX() * p2.getZ() / sumz + p2.getX() * ( - p1.getZ() / sumz ),
                                p1.getY() * p2.getZ() / sumz + p2.getY() * ( - p1.getZ() / sumz ),
                                0.0f );
                        m_FlowData.addIconPoint( pintersect.getX(), pintersect.getY() );
                }
                else
                {
                        //VVector p1            = iviewproj * VVector( x, y, 1.0 );
                        //VVector p2            = iviewproj * VVector( x, y, -1.0 );

                        //m_PanOffset;

                        //float sumz = p2.getZ() - p1.getZ();
                        //VVector pintersect = VVector( p1.getX() * p2.getZ() / sumz + p2.getX() * ( - p1.getZ() / sumz ),
                        //                                                        p1.getY() * p2.getZ() / sumz + p2.getY() * ( - p1.getZ() / sumz ),
                        //                                                        0.0f );

                        //m_FlowData.addManualSeedpointWithDsepTest( timestep_activated - 1, mStremSteps /*pintersect.getX(), pintersect.getY()*/ );
                
                }
                
        }


        if(me.getLeftState())
        {
                m_MouseState = PAN;
                m_vecPosition = getPlaneProjection(x,y);
                //m_vecPosition *= VVector((float)height(), (float)width(), 0.0f);
        }
        /*else if(me.getMiddleState())
        {
                m_MouseState = ROTATE;
                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;

        if ( !m_EnableSeedpointsSetting && ! m_EnableEvenSeedpointsSetting) 
        {
                setCursor(QCursor(Qt::CursorShape::OpenHandCursor));
        }
        else
        {
                setCursor(QCursor(Qt::CursorShape::CrossCursor));
        }


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


        const VMouseEvent me(getMouseEvent(e));

        const VVector v  = me.getPosition();
        
        if(me.getModifiers() == me.MODIFIER_ALT ) return;
        
        setCursor(QCursor(Qt::CursorShape::ClosedHandCursor));

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

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

        switch (m_MouseState)
        {

                case PAN:
                {
                        const VVector vecPosition = getPlaneProjection(x,y);
                        const VVector vecDifference = vecPosition - m_vecPosition;
                        
                        VVector side = -m_FlowRenderer.getCameraSideVector() * vecDifference.getX();
                        VVector up = -m_FlowRenderer.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;
                
        }


        m_FlowRenderer.processGuiInput(m_Distance, m_Position + m_PanOffset, view, up,  m_LookAt + m_PanOffset);
        
        

};

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

        


};

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

bool QVolRendCanvas::load_data(QString filename, int *data)
{
        if(data_loaded)
        {
                m_FlowData = VFlowData();
                data_loaded = false;
        }

        /*this*/makeCurrent();

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

        data_loaded = m_FlowData.loadData(tmp);
        m_FlowRenderer.setFlowData(&m_FlowData);
        if (!data_loaded) return false;

        computeGlyphs();
        //m_FlowData.generateGlyphIndices(30, 10);

        //m_TransferFunction->setMaxHist(data[3]);
        m_PanOffset = m_FlowData.getFlowCenter();
        m_Position.setZ(-m_FlowData.getFlowExtends().getMagnitude());
        VVector extends = m_FlowData.getFlowExtends();

        //m_FlowRenderer.generateFrolic(extends.getX(), extends.getY());

        float halfExdends = (extends.getX() < extends.getY()) ? extends.getY() : extends.getX();
        if( halfExdends == extends.getY())
        {
                halfExdends /= 2.0f;
        }
        else
        {
                halfExdends /= 2.0f;
                halfExdends /= m_FlowRenderer.getCameraAspect();
        }
        
        float fov = m_FlowRenderer.getCameraFOV();
        fov /= 2.0f;


        m_Distance = halfExdends / tan(fov * 3.14159265f / 180.0f);
        m_FlowRenderer.processGuiInput(m_Distance, m_Position + m_PanOffset, view, up,  m_LookAt + m_PanOffset);

        repaint();
        return true;

}

bool QVolRendCanvas::load_single_data(QString filename, QString datfilename)
{
        if(data_loaded)
        {
                m_FlowData = VFlowData();
                data_loaded = false;
        }

        /*this*/makeCurrent();

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

        data_loaded = m_FlowData.loadData(tmp, dtmp);
        m_FlowRenderer.setFlowData(&m_FlowData);
        if (!data_loaded) return false;

        computeGlyphs();
        //m_FlowData.generateGlyphIndices(30, 10);

        //m_TransferFunction->setMaxHist(data[3]);
        m_PanOffset = m_FlowData.getFlowCenter();
        m_Position.setZ(-m_FlowData.getFlowExtends().getMagnitude());
        VVector extends = m_FlowData.getFlowExtends();

        //m_FlowRenderer.generateFrolic(extends.getX(), extends.getY());

        float halfExdends = (extends.getX() < extends.getY()) ? extends.getY() : extends.getX();
        if( halfExdends == extends.getY())
        {
                halfExdends /= 2.0f;
        }
        else
        {
                halfExdends /= 2.0f;
                halfExdends /= m_FlowRenderer.getCameraAspect();
        }

        float fov = m_FlowRenderer.getCameraFOV();
        fov /= 2.0f;


        m_Distance = halfExdends / tan(fov * 3.14159265f / 180.0f);
        m_FlowRenderer.processGuiInput(m_Distance, m_Position + m_PanOffset, view, up,  m_LookAt + m_PanOffset);

        repaint();
        return true;
}

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

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

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

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

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

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

void QVolRendCanvas::setArrowTF(bool val)
{
        m_FlowRenderer.enableArrowTF(val);
}

void QVolRendCanvas::setLicTF(bool val)
{
        m_FlowRenderer.enableLicTF(val);
}

void QVolRendCanvas::animateLic(bool val)
{
        m_FlowRenderer.animateLic(val);
}

void QVolRendCanvas::setStrTF(bool val)
{
        m_FlowRenderer.enableStrTF(val);
}

void QVolRendCanvas::saveImage(std::string filename)
{
        makeCurrent();

        /*if(!m_SaveImageFBO)
        {
                m_SaveImageFBO = new VFramebufferObject(3000, 3000, GL_RGBA);
                m_SaveImageFBO->init();
        }
        m_SaveImageFBO->bind();
        m_SaveImageFBO->unbind();

        m_IsSaving = true;
        m_SaveFileName = filename;*/

        if(data_loaded)
        {
                m_FramebufferObject->saveImage(filename);
        }
        /*
        
        if(!sliceview_active && data_loaded)
        {
                m_SaveImageFBO->bind();

                m_VolumeRenderer.draw();

                m_SaveImageFBO->unbind();

                m_SaveImageFBO->saveImage(filename);
        }       */
        std::cout << "Saving Image finished" << std::endl;


}

void QVolRendCanvas::saveBigImage(std::string filename)
{
        if(!m_SaveImageFBO)
        {
        m_SaveImageFBO = new VFramebufferObject(3000, 3000, GL_RGBA);
        m_SaveImageFBO->init();
        }
        m_SaveImageFBO->bind();
        m_SaveImageFBO->unbind();

        m_IsSaving = true;
        m_SaveFileName = filename;
}


void QVolRendCanvas::saveStreamLines(std::string filename)
{
        if( data_loaded )
        {
                m_FlowData.saveStreamLines( filename );
        }
}

void QVolRendCanvas::loadStreamLines(std::string filename)
{
        if( data_loaded )
        {
                m_FlowData.loadStreamLines( filename );
        }
}

void QVolRendCanvas::arrowscale_valuechanged(int val)
{
        mArrowSize = (float)val / 100.0f;
        computeGlyphs();
}

void QVolRendCanvas::iconscale_valuechanged(int val)
{
        m_FlowData.setIconScale(val);
}

void QVolRendCanvas::icontail_valuechanged(int val)
{
        m_FlowData.setTailLength(val);
}

void QVolRendCanvas::arrowspacing_valuechanged(int val)
{
        mArrowSpacing = (float)val / 1000.0f;
        computeGlyphs();
}

void QVolRendCanvas::arrowalpha_changed_event(float val)
{
        m_FlowRenderer.setArrowAlpha(val);
}

void QVolRendCanvas::salpha_changed_event(float val)
{
        m_FlowRenderer.setStreamLineAlpha(val);
}

void QVolRendCanvas::licalpha_changed_event(float val)
{
        m_FlowRenderer.setLicAlpha(val);
}

void QVolRendCanvas::licsteps_changed_event(int val)
{
        m_FlowRenderer.setLicSteps(val);
}

void QVolRendCanvas::licstepsize_changed_event(int val)
{
        m_FlowRenderer.setLicStepSize(val);
}



void QVolRendCanvas::dsep_valuechanged(int val)
{
        mStreamSeedSpacing = (float)val/ 100.0f;

        //TODO 
        m_FlowData.setStreamlinesSeedSeparation( mStreamSeedSpacing );
        //computeStreamlines();
        
}

void QVolRendCanvas::dtest_valuechanged(int val)
{
        mStreamTestSpacing = (float)val/ 100.0f;

        //TODO 
        m_FlowData.setStreamlinesTestSeparation( mStreamTestSpacing );
        //computeStreamlines();
        
}

void QVolRendCanvas::steps_valuechanged(int val)
{
        mStremSteps = (float)val / 100.0f;

        //TODO 
        m_FlowData.setStreamlinesSteps( mStremSteps );
        //computeStreamlines();
        
}

void QVolRendCanvas::dt_valuechanged(int val)
{
        mStreamDT = (float)val/ 100.0f;

        //TODO 
        m_FlowData.setStreamlinesDt( mStreamDT );
        //computeStreamlines();
}

void QVolRendCanvas::setGlyph( bool val )
{
        m_FlowRenderer.setGlyph(val);
}

void QVolRendCanvas::computeGlyphs()
{
        if(!data_loaded)
        {
                return;
        }
        VVector extends = m_FlowData.getExtends();

        float smallestSize;
        if(extends.getX() < extends.getY())
        {
                smallestSize = extends.getX();
        }
        else
        {
                smallestSize = extends.getY();
        }

        float minGlyphSize = smallestSize / 10.0f;

        float glyphSize = minGlyphSize + mArrowSize * (smallestSize - minGlyphSize);
        float glyphSpacing = 0.0f + mArrowSpacing * glyphSize;

        float factorX = (extends.getX() < 1.0f) ? (1.0f / extends.getX()) : extends.getX();
        float factorY = (extends.getY() < 1.0f) ? (1.0f / extends.getY()) : extends.getY();

        float numGlyphX = ((extends.getX() - glyphSpacing) / (glyphSize + glyphSpacing)) * factorX;
        float numGlyphY = ((extends.getY() - glyphSpacing) / (glyphSize + glyphSpacing)) * factorY;

        m_FlowData.generateGlyphIndices((int)round(numGlyphX + 0.5f, 0), (int)round((numGlyphY + 0.5f),0));
        m_FlowRenderer.setBasicGlyphSize(glyphSize);
}

---