slicewidget1.cpp

Go to the documentation of this file.

#include "VolumeBuffer.h"
#include <QtGui>
#include <QtOpenGL>

#include <math.h>

#include "sliceWidget1.h"
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>

CGcontext s1cgContext;

void s1cgErrorCallback()
{
    CGerror lastError = cgGetError();
    if(lastError)
    {
        printf("%s\n", cgGetErrorString(lastError));
        printf("%s\n", cgGetLastListing(s1cgContext));
        exit(1);
    }
}

sliceWidget1::sliceWidget1(QWidget *parent)
    : QGLWidget(parent)
{
        setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);

        m_vb = new VolumeBuffer(GL_UNSIGNED_BYTE, 256, 256, 256, 0);
        s1cgContext = cgCreateContext();
        cgSetErrorCallback(s1cgErrorCallback);

        m_draw_selection = 0;

        selection_quad.first = QPointF(0.0f,0.0f);
        selection_quad.second = QPointF(0.0f,0.0f);

        m_current_slice = 0;

}

sliceWidget1::~sliceWidget1()
{
    makeCurrent();
}

QSize sliceWidget1::minimumSizeHint() const
{
    return QSize(50, 50);
}

QSize sliceWidget1::sizeHint() const
{
    return QSize(256, 256);
}

void sliceWidget1::initializeGL()
{
        glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE);
        glewInit();
    qglClearColor(trolltechPurple.dark());
        glShadeModel (GL_FLAT);

        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        
        m_vr = new VolumeRender(s1cgContext,m_vb);
}

void sliceWidget1::paintGL()
{
        makeCurrent();
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        glLoadIdentity();
    glTranslated(0.0, 0.0, 0.0);
        glColor4f(1.0f,1.0f,1.0f,1.0f);

        glEnable(GL_TEXTURE_2D);
        glEnable(GL_BLEND); // Turn Blending On
        glDisable(GL_DEPTH_TEST); // Turn Depth Testing Off
        //glBlendEquation(GL_FUNC_ADD_EXT);
        glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);

        /*
        //enable maximum selection
        glBlendEquation(GL_MAX_EXT);
        // setup arguments for the blending equation
        glBlendFunc(GL_SRC_ALPHA,GL_DST_ALPHA);
        */

        //m_vr->setVolume(m_vb);
        glEnable(GL_TEXTURE_2D);
        m_vb->drawZSlice(m_current_slice);

        if (m_draw_selection)
        {
                //disable before drawing
                glDisable(GL_TEXTURE_2D);
                glEnable(GL_DEPTH_TEST);
                glDepthFunc(GL_ALWAYS);
                glColor4f(1.0f,1.0f,0.0f,0.2f);
                glBegin(GL_QUADS);
                /*
                        glVertex3f (-0.5f, -0.5f, 0.0f); //bottom left
                        glVertex3f (0.5f, -0.5f, 0.0f); //bottom right
                        glVertex3f (0.5f, 0.5f, 0.0f); //top right
                        glVertex3f (-0.5f, 0.5f, 0.0f); //top left
                        */
                        glVertex3f (m_bl_x, m_bl_y, 0.0f); //bottom left
                        glVertex3f (m_br_x, m_br_y, 0.0f); //bottom right
                        glVertex3f (m_tr_x, m_tr_y, 0.0f); //top right
                        glVertex3f (m_tl_x, m_tl_y, 0.0f); //top left
                glEnd();
        }

        glFlush();
        glDisable(GL_TEXTURE_2D);
}

void sliceWidget1::resizeGL(int width, int height)
{
    int side = qMin(width, height);
    //glViewport((width - side) / 2, (height - side) / 2, side, side);

   glViewport (0, 0, (GLsizei) width, (GLsizei) height); 
   glMatrixMode (GL_PROJECTION);
   glLoadIdentity ();
   glFrustum (-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
   glMatrixMode (GL_MODELVIEW);
}

void sliceWidget1::mousePressEvent(QMouseEvent *event)
{
        if(event->button() == Qt::RightButton)
                m_draw_selection = 0;

        if(event->button() == Qt::LeftButton)
                m_draw_selection = 1;

        if(m_draw_selection)
        {
                int ww = this->width() - 1;
                int wh = this->height() - 1;

                int x_mouse = event->x();
                if(x_mouse <= 0)
                        x_mouse = 0;
                else if(x_mouse >= ww)
                        x_mouse = ww;

                int y_mouse = event->y();
                if(y_mouse <= 0)
                        y_mouse = 0;
                else if(y_mouse >= wh)
                        y_mouse = wh;

                int x_real = x_mouse;
                int y_real = wh - y_mouse;

                selection_quad.first = QPointF((float)x_real, (float)y_real);

                selection_quad.second = selection_quad.first;

                std::cout << "start x:" << selection_quad.first.x() << ", y:" << selection_quad.first.y() << "\n";

                int bl_x = qMin(selection_quad.first.x(), selection_quad.second.x());
                int bl_y = qMax(selection_quad.first.y(), selection_quad.second.y());
                
                int br_x = qMax(selection_quad.first.x(), selection_quad.second.x());
                int br_y = qMax(selection_quad.first.y(), selection_quad.second.y());

                int tr_x = qMax(selection_quad.first.x(), selection_quad.second.x());
                int tr_y = qMin(selection_quad.first.y(), selection_quad.second.y());

                int tl_x = qMin(selection_quad.first.x(), selection_quad.second.x());
                int tl_y = qMin(selection_quad.first.y(), selection_quad.second.y());

                m_bl_x = -1.0 + (2*(float)bl_x/(float)ww);
                m_bl_y = -1.0 + (2*(float)bl_y/(float)wh);
                m_br_x = -1.0 + (2*(float)br_x/(float)ww);
                m_br_y = -1.0 + (2*(float)br_y/(float)wh);
                m_tr_x = -1.0 + (2*(float)tr_x/(float)ww);
                m_tr_y = -1.0 + (2*(float)tr_y/(float)wh);
                m_tl_x = -1.0 + (2*(float)tl_x/(float)ww);
                m_tl_y = -1.0 + (2*(float)tl_y/(float)wh);

                //std::cout << m_bl_x << " " << m_bl_y << " "  << m_br_x << " "  << m_br_y << " "  << m_tr_x << " "  << m_tr_y  << " " << m_tl_x << " "  << m_tl_y << "\n";

                updateGL();
        }
}

void sliceWidget1::mouseReleaseEvent(QMouseEvent *event)
{
        m_draw_selection = 1;
        
        int ww = this->width() - 1;
        int wh = this->height() - 1;
        
        int x_mouse = event->x();
        if(x_mouse <= 0)
                x_mouse = 0;
        else if(x_mouse >= ww)
                x_mouse = ww;

        int y_mouse = event->y();
        if(y_mouse <= 0)
                y_mouse = 0;
        else if(y_mouse >= wh)
                y_mouse = wh;

        int x_real = x_mouse;
        int y_real = wh - y_mouse;

        selection_quad.second = QPointF((float)x_real, (float)y_real);

        //selection_quad.second = event->pos();

        std::cout << "stop x:" << selection_quad.second.x() << ", y:" << selection_quad.second.y() << "\n";

        int bl_x = qMin(selection_quad.first.x(), selection_quad.second.x());
        int bl_y = qMax(selection_quad.first.y(), selection_quad.second.y());
        
        int br_x = qMax(selection_quad.first.x(), selection_quad.second.x());
        int br_y = qMax(selection_quad.first.y(), selection_quad.second.y());

        int tr_x = qMax(selection_quad.first.x(), selection_quad.second.x());
        int tr_y = qMin(selection_quad.first.y(), selection_quad.second.y());

        int tl_x = qMin(selection_quad.first.x(), selection_quad.second.x());
        int tl_y = qMin(selection_quad.first.y(), selection_quad.second.y());

        m_bl_x = -1.0 + (2*(float)bl_x/(float)ww);
        m_bl_y = -1.0 + (2*(float)bl_y/(float)wh);
        m_br_x = -1.0 + (2*(float)br_x/(float)ww);
        m_br_y = -1.0 + (2*(float)br_y/(float)wh);
        m_tr_x = -1.0 + (2*(float)tr_x/(float)ww);
        m_tr_y = -1.0 + (2*(float)tr_y/(float)wh);
        m_tl_x = -1.0 + (2*(float)tl_x/(float)ww);
        m_tl_y = -1.0 + (2*(float)tl_y/(float)wh);
        
        //std::cout << m_bl_x << " " << m_bl_y << " "  << m_br_x << " "  << m_br_y << " "  << m_tr_x << " "  << m_tr_y  << " " << m_tl_x << " "  << m_tl_y << "\n";

        emit selectionChanged(selection_quad);
        updateGL();
}

void sliceWidget1::mouseMoveEvent(QMouseEvent *event)
{

        if(m_draw_selection)
        {
                        int ww = this->width() - 1;
                        int wh = this->height() - 1;
                        
                        int x_mouse = event->x();
                        if(x_mouse <= 0)
                                x_mouse = 0;
                        else if(x_mouse >= ww)
                                x_mouse = ww;

                        int y_mouse = event->y();
                        if(y_mouse <= 0)
                                y_mouse = 0;
                        else if(y_mouse >= wh)
                                y_mouse = wh;

                        int x_real = x_mouse;
                        int y_real = wh - y_mouse;

                        selection_quad.second = QPointF((float)x_real, (float)y_real);

                        //std::cout << "x:" << selection_quad.second.x() << ", y:" << selection_quad.second.y() << "\n";

                        int bl_x = qMin(selection_quad.first.x(), selection_quad.second.x());
                        int bl_y = qMax(selection_quad.first.y(), selection_quad.second.y());
                        
                        int br_x = qMax(selection_quad.first.x(), selection_quad.second.x());
                        int br_y = qMax(selection_quad.first.y(), selection_quad.second.y());

                        int tr_x = qMax(selection_quad.first.x(), selection_quad.second.x());
                        int tr_y = qMin(selection_quad.first.y(), selection_quad.second.y());

                        int tl_x = qMin(selection_quad.first.x(), selection_quad.second.x());
                        int tl_y = qMin(selection_quad.first.y(), selection_quad.second.y());

                        //std::cout << bl_x << " " << bl_y << " "  << br_x << " "  << br_y << " "  << tr_x << " "  << tr_y  << " " << tl_x << " "  << tl_y << "\n";

                        m_bl_x = -1.0 + (2*(float)bl_x/(float)ww);
                        m_bl_y = -1.0 + (2*(float)bl_y/(float)wh);
                        m_br_x = -1.0 + (2*(float)br_x/(float)ww);
                        m_br_y = -1.0 + (2*(float)br_y/(float)wh);
                        m_tr_x = -1.0 + (2*(float)tr_x/(float)ww);
                        m_tr_y = -1.0 + (2*(float)tr_y/(float)wh);
                        m_tl_x = -1.0 + (2*(float)tl_x/(float)ww);
                        m_tl_y = -1.0 + (2*(float)tl_y/(float)wh);
                        
                        //std::cout << m_bl_x << " " << m_bl_y << " "  << m_br_x << " "  << m_br_y << " "  << m_tr_x << " "  << m_tr_y  << " " << m_tl_x << " "  << m_tl_y << "\n";
                        updateGL();
        }
}

void sliceWidget1::wheelEvent(QWheelEvent *event)
{

        int max_slices = m_vb->getDepth() - 1;

        int mul = 1;

        int numDegrees = event->delta() / 8;
    int numSteps = numDegrees / 15;
        
        //std::cout << "wheel numDegrees:" <<  numDegrees << "\n";
        //std::cout << "wheel numSteps:" <<  numSteps << "\n";

        m_current_slice = m_current_slice + mul*numSteps;
        
        if(m_current_slice <= 0)
                m_current_slice = 0;
        else if(m_current_slice >= max_slices)
                m_current_slice = max_slices;

        emit sliceChanged(m_current_slice);
        updateGL();
}

void sliceWidget1::vr_load_data2(VolumeBuffer *vb1)
{
        //grab GL context
        makeCurrent();

        std::cout << "Data loading...";
        //VolumeBuffer *vb1 = new VolumeBuffer(GL_UNSIGNED_BYTE, 256, 256, 256, 0);
        
        glEnable(GL_TEXTURE_2D);
        vb1->create2DTexturesZ(GL_UNSIGNED_BYTE);

        delete m_vb;
        m_vb = vb1;

        //m_vr->loaddata();
        //updateTransferFunction();
        //m_data_loaded = 1;
        std::cout << "loaded\n";
        updateGL();
}

---