glwidget.cpp

Go to the documentation of this file.

#define GL_GLEXT_PROTOTYPES

#include <QtWidgets>
#include <QImage>


#include "glwidget.h"

GLWidget::GLWidget(QWidget *parent) : QGLWidget(parent)
{
    //Specifies an OpenGL 3.3 format using the Core profile
    QGLFormat glFormat;
    glFormat.setVersion(3, 3);
    glFormat.setProfile(QGLFormat::CoreProfile);
    glFormat.setSampleBuffers(true);
    glFormat.setDepth(true);

    this->setFormat(glFormat);

    m_boxPosVBO = new QOpenGLBuffer(QOpenGLBuffer::VertexBuffer);
    m_texCoordVBO = new QOpenGLBuffer(QOpenGLBuffer::VertexBuffer);
    m_boxIBO = new QOpenGLBuffer(QOpenGLBuffer::IndexBuffer);

    m_squarePosVBO = new QOpenGLBuffer(QOpenGLBuffer::VertexBuffer);
    m_squareTexCoordVBO = new QOpenGLBuffer(QOpenGLBuffer::VertexBuffer);
    m_squareIBO = new QOpenGLBuffer(QOpenGLBuffer::IndexBuffer);

    m_volumeShader = NULL;
    m_videoDiffShader = NULL;

    //p_cameraMatrix = new QMatrix4x4();
    //p_viewMatrix = new QMatrix4x4();
    //p_projectionMatrix = new QMatrix4x4();

    p_videoFrameToTextureLoader = NULL;

    m_drawMode = VV_DRAWMODE_VOLUME;

    m_frameOffset = 0;
    m_cameraAngleSide = 0;
    m_cameraAngleUp = 0;
    m_cameraDistance = 10;

    m_cameraCenter = QVector3D(0, 0, 0);

    m_backgroundColor = QVector3D(1.0f, 1.0f, 1.0f);

    m_horseShowView = true;

    m_stepSize = 0.01;
    m_boxSize = 4;

    p_videoBuffer = NULL;
    p_videoDiffBuffer = NULL;
    p_videoNDiffBuffer = NULL;
    //pVideoDiffMeanBuffer = NULL;

    m_videoWidth = 4;
    m_videoHeight = 3;
    m_frameCount = 0;

    m_metric = VV_METRIC_NONE;
}

GLWidget::~GLWidget()
{
    delete m_boxPosVBO;
    delete m_texCoordVBO;
    delete m_boxIBO;
    delete m_volumeShader;

    if (!p_videoFrameToTextureLoader)
        delete p_videoFrameToTextureLoader;
}

QSize GLWidget::minimumSizeHint() const {
    return QSize(400, 400);
}
QSize GLWidget::sizeHint() const {
    return QSize(700, 700);
}


void GLWidget::initializeGL()
{
    initializeOpenGLFunctions();

    glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC) wglGetProcAddress("glGenVertexArrays");
    glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC) wglGetProcAddress("glBindVertexArray");
    glTexImage3D = (PFNGLTEXIMAGE3DPROC) wglGetProcAddress("glTexImage3D");

    QGLFormat glFormat = QGLWidget::format();
    if (!glFormat.sampleBuffers())
        qWarning() << "Could not enable sample buffers";

    //Set the clear color to black
    glClearColor(m_backgroundColor.x(), m_backgroundColor.y(), m_backgroundColor.z(), 1.0f);

    //Enable Z-Buffer
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LEQUAL);

    //Prepare a complete shader program...
    if (!loadShaders())
        return;

    createBufferObjects();

    glGenTextures(1, &m_videoTexture);
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_3D, m_videoTexture);

   // glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_REPEAT);
    glTexParameterf(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
    glTexParameterf(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameterf(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexParameterf(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameterf(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

    //Initialize the transfer function texture
    glActiveTexture(GL_TEXTURE0 + 1);
    glGenTextures(1, &m_transferTexture);
    glBindTexture(GL_TEXTURE_1D, m_transferTexture);

    glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

    //Initalize the mean texture
    glActiveTexture(GL_TEXTURE0 + 2);
    glGenTextures(1, &m_meanTexture);
    glBindTexture(GL_TEXTURE_1D, m_meanTexture);

    glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

    //Initalize the variance texture
    glActiveTexture(GL_TEXTURE0 + 3);
    glGenTextures(1, &m_transferTexture);
    glBindTexture(GL_TEXTURE_1D, m_transferTexture);

    glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

    setupCamera();
    setupModelMatrix();
}

void GLWidget::paintGL()
{
    // Clear the color and the depth buffer
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    switch (m_drawMode)
    {
    case VV_DRAWMODE_VOLUME:
        m_volumeShader->bind();
        m_volumeShader->setUniformValue("u_videoTexture", 0);
        m_volumeShader->setUniformValue("u_transferTexture", 1);
        m_volumeShader->setUniformValue("u_frameOffset", m_frameOffset);
        m_volumeShader->setUniformValue("u_backColor", m_backgroundColor);
        m_volumeShader->setUniformValue("u_MVPMatrix", m_projectionMatrix * m_viewMatrix * m_modelMatrix);
        m_volumeShader->setUniformValue("u_MMatrix", m_modelMatrix);
        m_volumeShader->setUniformValue("u_invM", m_modelMatrix.inverted());
        m_volumeShader->setUniformValue("u_cameraPos", m_cameraPosition);
        m_volumeShader->setUniformValue("u_horseShoeView", m_horseShowView);
        m_volumeShader->setUniformValue("u_stepSize", m_stepSize);
        m_volumeShader->setUniformValue("u_metric", m_metric);

        //Draw
        glBindVertexArray(m_boxVAO);
        glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_BYTE, 0);
        break;

    case VV_DRAWMODE_VIDEODIFF:
        glBindVertexArray(m_squareVAO);
        glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, 0);
        break;
    }
}

void GLWidget::resizeGL(int width, int height)
{
    m_projectionMatrix.setToIdentity();
    m_projectionMatrix.perspective(60,(float) width / (float) height, (0.001f), 50.0f);

    // Set the viewport to window dimensions
    glViewport(0, 0, width, height);

}

VFLResult GLWidget::openVideoFile(const QString &videoFilePath, int *hRes, int *vRes)
{
    LPWSTR pVideoFilePath;
    pVideoFilePath = new WCHAR[videoFilePath.length() + 1];
    videoFilePath.toWCharArray(pVideoFilePath);
    pVideoFilePath[videoFilePath.length()] = '\0';

    if (p_videoFrameToTextureLoader == NULL)
        p_videoFrameToTextureLoader = new CVideoFrameToTextureLoader();

    VFLResult vr = p_videoFrameToTextureLoader->setVideoPath(pVideoFilePath);

    delete pVideoFilePath;

    if (vr != VFL_OK)
    {
        *hRes = 0;
        *vRes = 0;
        return vr;
    }

    return p_videoFrameToTextureLoader->getVideoResolution(hRes, vRes);
}

VFLResult GLWidget::loadVideoFile(int startFrame, int stepSize, int endFrame)
{
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_3D, m_videoTexture);

    //p_videoFrameToTextureLoader->loadAllFramesIntoTexture(0, 0);

    if (p_videoBuffer != NULL)
        delete p_videoBuffer;

    if (p_videoDiffBuffer != NULL)
    {
        delete p_videoDiffBuffer;
        p_videoDiffBuffer = NULL;
    }

    if (p_videoNDiffBuffer != NULL)
    {
        delete p_videoNDiffBuffer;
        p_videoNDiffBuffer = NULL;
    }
/*
    if(pVideoDiffMeanBuffer != NULL)
    {
        delete pVideoDiffMeanBuffer;
        pVideoDiffMeanBuffer = NULL;

        delete p_videoDiffDeviationBuffer;
    }
*/
    VFLResult vr = p_videoFrameToTextureLoader->loadAllFramesIntoTexture(startFrame - 1,stepSize - 1, endFrame);

    if (vr != VFL_OK && vr != VFL_NO_MORE_FRAMES)
        return vr;

    p_videoFrameToTextureLoader->getVideoBuffer(&p_videoBuffer);

    p_videoFrameToTextureLoader->getBufferFrameCount(&m_frameCount);
    p_videoFrameToTextureLoader->getVideoResolution(&m_videoWidth, &m_videoHeight);

    setupModelMatrix();

    m_frameOffset = 0;

    VVMetric tempMetric = m_metric;
    m_metric = VV_METRIC_NONE;

    setMetric(tempMetric);

    return VFL_OK;
}

bool GLWidget::prepareShaderProgram(const QString &vertexShaderPath, const QString &fragmentShaderPath, QOpenGLShaderProgram **shader)
{
    if (*shader != NULL)
        delete *shader;

    *shader = new QOpenGLShaderProgram();

    // First we load and compile the vertex shader...
    bool result = (*shader)->addShaderFromSourceFile( QOpenGLShader::Vertex, vertexShaderPath );
    if ( !result )
        qWarning() << m_volumeShader->log();

    // ...now the fragment shader...
    result = (*shader)->addShaderFromSourceFile( QOpenGLShader::Fragment, fragmentShaderPath );
    if ( !result )
        qWarning() << m_volumeShader->log();

    // ...and finally we link them to resolve any references.
    result = (*shader)->link();
    if ( !result )
        qWarning() << "Could not link shader program:" << m_volumeShader->log();
    

    return result;
}

void GLWidget::createBufferObjects()
{
     float boxPos[] = { -1.0f, -1.0f, 1.0f,
                              1.0f, -1.0f, 1.0f,
                             -1.0f,  1.0f, 1.0f,
                              1.0f,  1.0f, 1.0f,

                             -1.0f, -1.0f, -1.0f,
                              1.0f, -1.0f, -1.0f,
                             -1.0f,  1.0f, -1.0f,
                              1.0f,  1.0f, -1.0f
                           };

     float boxTexCoord[] = { 0.0f, 1.0f, 0.0f,
                                  1.0f, 1.0f, 0.0f,
                                  0.0f, 0.0f, 0.0f,
                                  1.0f, 0.0f, 0.0f,

                                  0.0f, 1.0f, 1.0f,
                                  1.0f, 1.0f, 1.0f,
                                  0.0f, 0.0f, 1.0f,
                                  1.0f, 0.0f, 1.0f
                                };

     GLubyte boxIndexes[] = {0, 1, 2,  //+z
                                  1, 3, 2,

                                  5, 4 ,7,  //-z
                                  4, 6, 7,

                                  2, 3, 6, //+y
                                  3, 7 ,6,

                                  4 ,5, 0, //-y
                                  5, 1, 0,

                                  1, 5, 3, //+x
                                  5, 7, 3,

                                  4, 0, 6, //-x
                                  0, 2, 6
                                 };

     float squarePos[] = { -1.0f, -1.0f, 0.0f,
                                 1.0f, -1.0f, 0.0f,
                                -1.0f,  1.0f, 0.0f,
                                 1.0f,  1.0f, 0.0f,
                              };

     float squareTexCoord[] = { 0.0f, 1.0f,
                                     1.0f, 1.0f,
                                     0.0f, 0.0f,
                                     1.0f, 0.0f
                                };

     GLubyte squareIndexes[] = { 0, 1, 2,
                                      1, 3, 2
                                    };



    //Bind the shader program
    if (!m_volumeShader->bind())
    {
        qWarning() << "Could not bind shader program to context";
        return;
    }

    glGenVertexArrays(1, &m_boxVAO);
    glBindVertexArray(m_boxVAO);

    m_boxPosVBO->create();
    m_boxPosVBO->setUsagePattern(QOpenGLBuffer::StaticDraw);
    m_boxPosVBO->bind();
    m_boxPosVBO->allocate(boxPos, 8 * 3 * sizeof(float));

    //Enable the "vertex" attribute to bind in to our currently bound vertex buffer
    m_volumeShader->setAttributeBuffer("pos", GL_FLOAT, 0, 3);

    m_texCoordVBO->create();
    m_texCoordVBO->setUsagePattern(QOpenGLBuffer::StaticDraw);
    m_texCoordVBO->bind();
    m_texCoordVBO->allocate(boxTexCoord, 8 * 3 * sizeof(float));

    m_volumeShader->setAttributeBuffer("texCoord", GL_FLOAT, 0, 3);

    m_boxIBO->create();
    m_boxIBO->setUsagePattern(QOpenGLBuffer::StaticDraw);
    m_boxIBO->bind();
    m_boxIBO->allocate(boxIndexes, 36 * sizeof(GLubyte));

    m_volumeShader->enableAttributeArray("pos");
    m_volumeShader->enableAttributeArray("texCoord");


    glGenVertexArrays(1, &m_squareVAO);
    glBindVertexArray(m_squareVAO);

    m_squarePosVBO->create();
    m_squarePosVBO->setUsagePattern(QOpenGLBuffer::StaticDraw);
    m_squarePosVBO->bind();
    m_squarePosVBO->allocate(squarePos, 4 * 3 * sizeof(float));

    //Enable the "vertex" attribute to bind in to our currently bound vertex buffer
    m_videoDiffShader->setAttributeBuffer("pos", GL_FLOAT, 0, 3);

    m_squareTexCoordVBO->create();
    m_squareTexCoordVBO->setUsagePattern(QOpenGLBuffer::StaticDraw);
    m_squareTexCoordVBO->bind();
    m_squareTexCoordVBO->allocate(squareTexCoord, 4 * 3 * sizeof(float));

    m_videoDiffShader->setAttributeBuffer("texCoord", GL_FLOAT, 0, 2);

    m_squareIBO->create();
    m_squareIBO->setUsagePattern(QOpenGLBuffer::StaticDraw);
    m_squareIBO->bind();
    m_squareIBO->allocate(squareIndexes, 6 * sizeof(GLubyte));

    m_videoDiffShader->enableAttributeArray("pos");
    m_videoDiffShader->enableAttributeArray("texCoord");
}

int GLWidget::getFrameCount()
{
    if (p_videoFrameToTextureLoader == NULL)
        return 0;

    int frameCount = 0;

    p_videoFrameToTextureLoader->getBufferFrameCount(&frameCount);

    return frameCount;
}

void GLWidget::setFrameOffset(int frameOffset)
{
    m_frameOffset = (float)frameOffset/(float)m_frameCount; //((float)frameOffset + 0.5)/(float)getFrameCount();
    m_volumeShader->setUniformValue("u_frameOffset", m_frameOffset);
    updateGL();
}

void GLWidget::setStyle(bool horseShoeView)
{
    m_horseShowView = horseShoeView;
    setupModelMatrix();
    updateGL();
}

void GLWidget::setupCamera()
{
    QMatrix4x4 cameraRotation, cameraTransformation;

    //cameraPositioning.translate(m_cameraCenter);

    cameraTransformation.translate(0, 0, m_cameraDistance);

    cameraRotation.rotate(m_cameraAngleSide, 0, 1, 0);
    cameraRotation.rotate(m_cameraAngleUp, 1, 0, 0);

    QVector3D cameraUpDirection = cameraRotation * QVector3D(0, 1, 0);

    cameraTransformation = cameraRotation * cameraTransformation;

    QMatrix4x4 cameraPositioning;

    cameraPositioning.translate(m_cameraCenter.x(), m_cameraCenter.y(), m_cameraCenter.z());

    cameraTransformation = cameraPositioning * cameraTransformation;

    m_cameraPosition = cameraTransformation * QVector3D(0, 0, 0);
   // m_cameraPosition =  cameraPositioning * m_cameraPosition;


    m_viewMatrix.setToIdentity();
    m_viewMatrix.lookAt(m_cameraPosition, m_cameraCenter, cameraUpDirection);
}

void GLWidget::setupModelMatrix()
{
   float aspectRatio = (float) m_videoHeight / (float) m_videoWidth;

    m_modelMatrix.setToIdentity();

    if (m_horseShowView)
        m_modelMatrix.scale(4, aspectRatio , 2);
    else
        m_modelMatrix.scale(1, aspectRatio, m_boxSize);
}

void GLWidget::calculateVideoDiffBuffer(bool normalized)
{
    QOpenGLFramebufferObject videoDiffFBO(m_videoWidth, m_videoHeight, QOpenGLFramebufferObject::NoAttachment, GL_TEXTURE_2D, GL_RGBA);

    glViewport(0, 0, m_videoWidth, m_videoHeight);

    bool test = videoDiffFBO.bind();

    if (test != true)
        return;

    PBYTE *resultBuffer = NULL;

    m_videoDiffShader->bind();

    m_videoDiffShader->setUniformValue("u_videoTexture", 0);
    m_videoDiffShader->setUniformValue("u_meanTexture", 2);
    m_videoDiffShader->setUniformValue("u_devTexture", 3);
    m_videoDiffShader->setUniformValue("u_frameCount", m_frameCount);
    m_videoDiffShader->setUniformValue("u_nTrans", normalized);

    if (normalized)
    {
        calculateMeanAndStdDev();
        resultBuffer = &p_videoNDiffBuffer;
    }
    else
    {
        resultBuffer = &p_videoDiffBuffer;
    }


    m_drawMode = VV_DRAWMODE_VIDEODIFF;

    int frameSize = m_videoWidth * m_videoHeight * 4;

    if (*resultBuffer != NULL)
        delete *resultBuffer;

    *resultBuffer = new BYTE[(long) frameSize * (long) m_frameCount];

    for (int frameCounter = 0; frameCounter < m_frameCount; frameCounter++)
    {
        m_videoDiffShader->setUniformValue("u_currentFrame", frameCounter);
        paintGL();

        QImage image = videoDiffFBO.toImage();

        PBYTE imageData = (PBYTE) image.constBits();

        long offset = (long) frameCounter * (long) frameSize;

        for (int byteCounter = 0; byteCounter < frameSize; byteCounter++)
        {
            (*resultBuffer)[offset + byteCounter] = imageData[byteCounter];
        }
    }

    glViewport(0, 0, size().width(), size().height());

    m_drawMode = VV_DRAWMODE_VOLUME;
    videoDiffFBO.release();
}

void GLWidget::calculateMeanAndStdDev()
{
    GLfloat* pVideoDiffMeanBuffer = new GLfloat[m_frameCount];
    GLfloat* pVideoDiffDeviationBuffer = new GLfloat[m_frameCount];

    long byteCount = m_videoWidth * m_videoHeight;
    long sampleSize = byteCount * 4;

    for (int frameCounter = 0; frameCounter < m_frameCount; frameCounter++)
    {
        double *YValues = new double[byteCount];

        long byteSum = 0;
        long offset = sampleSize * frameCounter;

        for (long byteCounter = 0; byteCounter < byteCount; byteCounter++)
        {
            YValues[byteCounter] =  (double) p_videoBuffer[offset + byteCounter * 4 + 2] * 0.299 +
                                    (double) p_videoBuffer[offset + byteCounter * 4 + 1] * 0.587 +
                                    (double) p_videoBuffer[offset + byteCounter * 4] * 0.144;

            byteSum += YValues[byteCounter];
        }

        double meanValue = (double)byteSum / (double)byteCount;

        double sum = 0;

        for (long byteCounter = 0; byteCounter < byteCount; byteCounter++)
        {
            sum += pow((double) YValues[byteCounter] - meanValue, 2);
        } 

        double standardDeviation = sqrt(sum / (double) byteCount);

        pVideoDiffMeanBuffer[frameCounter] = meanValue / 255.0;
        pVideoDiffDeviationBuffer[frameCounter] = standardDeviation / 255.0;

        delete YValues;
    }

    glActiveTexture(GL_TEXTURE0 + 2);
    glTexImage1D(GL_TEXTURE_1D, 0, GL_RGB32F, m_frameCount, 0, GL_RED, GL_FLOAT, pVideoDiffMeanBuffer);

    glActiveTexture(GL_TEXTURE0 + 3);
    glTexImage1D(GL_TEXTURE_1D, 0, GL_RGB32F, m_frameCount, 0, GL_RED, GL_FLOAT, pVideoDiffDeviationBuffer);

    delete pVideoDiffMeanBuffer;
    delete pVideoDiffDeviationBuffer;
}

bool GLWidget::loadShaders()
{
    if (!prepareShaderProgram(":/ShaderFiles/volume.vert", ":/ShaderFiles/volume.frag", &m_volumeShader))
        return false;

    if (!prepareShaderProgram(":/ShaderFiles/videoDiff.vert", ":/ShaderFiles/videoDiff.frag", &m_videoDiffShader))
        return false;

        return true;
}

void GLWidget::mousePressEvent(QMouseEvent *event)
{
    if (event->buttons() & Qt::RightButton || event->buttons() & Qt::MidButton)
    {
        m_oldMousePos = mapFromGlobal(QCursor::pos());
        setCursor(Qt::BlankCursor);
    }


}

void GLWidget::mouseReleaseEvent(QMouseEvent *event)
{
     //if (event->buttons() & Qt::RightButton)
     //{
         setCursor(Qt::ArrowCursor);
         //}
}

void GLWidget::wheelEvent(QWheelEvent *event)
{
    m_cameraDistance += (float)event->delta() / (float) 100;
    setupCamera();

    updateGL();
}

void GLWidget::mouseMoveEvent(QMouseEvent *event)
{
    //DEBUG
    //qDebug() << dx << " " << dy;
    if(event->buttons() & Qt::RightButton || event->buttons() & Qt::MidButton)
    {
        QPoint mousePos = mapFromGlobal(QCursor::pos());
        GLfloat dx = GLfloat(mousePos.x() - m_oldMousePos.x()) / width();
        GLfloat dy = GLfloat(mousePos.y() - m_oldMousePos.y()) / height();

        if (event->buttons() & Qt::RightButton)
        {
            m_cameraAngleSide -= dx * 180;
            m_cameraAngleUp -= dy * 180;

            if (m_cameraAngleSide < 0)
                m_cameraAngleSide = 360 + m_cameraAngleSide;

            if (m_cameraAngleSide > 360)
                m_cameraAngleSide = m_cameraAngleSide - 360;

            if (m_cameraAngleUp < -90)
                m_cameraAngleUp = -90;

            if (m_cameraAngleUp > 90)
                m_cameraAngleUp = 90;
        }

        if (event->buttons() & Qt::MidButton)
        {
            QMatrix4x4 cameraTransformation;

            QVector3D cameraMotion;
            cameraMotion.setX(- dx * 50);
            cameraMotion.setY(dy * 50);

            cameraTransformation.rotate(m_cameraAngleSide, 0, 1, 0);
            cameraTransformation.rotate(m_cameraAngleUp, 1, 0, 0);

            cameraMotion = cameraTransformation * cameraMotion;

            QMatrix4x4 cameraPositioning;

            cameraPositioning.translate(cameraMotion);

            m_cameraCenter = cameraPositioning * m_cameraCenter;

            //m_cameraCenter.setX(m_cameraCenter.x() - );
           // m_cameraCenter.setY(m_cameraCenter.y() - dy * 50);
        }

        QCursor::setPos(mapToGlobal(m_oldMousePos));

        setupCamera();
        updateGL();
    }
}

void GLWidget::setStepSize(float stepSize)
{
    m_stepSize = stepSize;
    updateGL();
}

void GLWidget::setBoxSize(int boxSize)
{
    m_boxSize = boxSize;
    setupModelMatrix();
    updateGL();
}

void GLWidget::setMetric(VVMetric metric)
{
    VVMetric old_metric = m_metric;

    m_metric = metric;

    switch (metric)
    {
    case VV_METRIC_NONE:
        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_3D, m_videoTexture);
        glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB, m_videoWidth, m_videoHeight, m_frameCount, 0, GL_BGRA, GL_UNSIGNED_BYTE, p_videoBuffer);
        updateGL();
        break;

    case VV_METRIC_IQDIF:
    case VV_METRIC_YDIF:
    case VV_METRIC_YMSE:
        if (p_videoDiffBuffer == NULL)
        {
            if (old_metric != VV_METRIC_NONE)
            {
                glActiveTexture(GL_TEXTURE0);
                glBindTexture(GL_TEXTURE_3D, m_videoTexture);
                glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB, m_videoWidth, m_videoHeight, m_frameCount, 0, GL_BGRA, GL_UNSIGNED_BYTE, p_videoBuffer);
            }
            calculateVideoDiffBuffer(false);
        }

        if (old_metric == VV_METRIC_NONE || old_metric == VV_METRIC_YNDIF || old_metric == VV_METRIC_YNMSE)
        {
            glActiveTexture(GL_TEXTURE0);
            glBindTexture(GL_TEXTURE_3D, m_videoTexture);
            glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB, m_videoWidth, m_videoHeight, m_frameCount, 0, GL_BGRA, GL_UNSIGNED_BYTE, p_videoDiffBuffer);
        }
        updateGL();
        break;

    case VV_METRIC_YNDIF:
    case VV_METRIC_YNMSE:
        if (p_videoNDiffBuffer == NULL)
        {
            if (old_metric != VV_METRIC_NONE)
            {
                glActiveTexture(GL_TEXTURE0);
                glBindTexture(GL_TEXTURE_3D, m_videoTexture);
                glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB, m_videoWidth, m_videoHeight, m_frameCount, 0, GL_BGRA, GL_UNSIGNED_BYTE, p_videoBuffer);
            }
            calculateVideoDiffBuffer(true);
        }

        if (old_metric == VV_METRIC_NONE || old_metric == VV_METRIC_IQDIF || old_metric == VV_METRIC_YDIF || old_metric == VV_METRIC_YMSE)
        {
            glActiveTexture(GL_TEXTURE0);
            glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB, m_videoWidth, m_videoHeight, m_frameCount, 0, GL_BGRA, GL_UNSIGNED_BYTE, p_videoNDiffBuffer);
        }
        updateGL();
        break;

    }
}

void GLWidget::setTransferFunction(GLfloat *tfArray, int arraySize)
{
    glActiveTexture(GL_TEXTURE0 + 1);
    glBindTexture(GL_TEXTURE_1D, m_transferTexture);
    glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA32F, arraySize, 0, GL_RGBA, GL_FLOAT, tfArray);

    delete tfArray;

    updateGL();
    //p_transferFunction = value;
}