slicewidget2.cpp

Go to the documentation of this file.

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

#include <math.h>

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

CGcontext s2cgContext;

#include <iostream>
#include <fstream>
using namespace std;

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

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

        m_vb = new VolumeBuffer(GL_UNSIGNED_BYTE, 256, 256, 256, 0);
        s2cgContext = cgCreateContext();
        cgSetErrorCallback(s2cgErrorCallback);

        m_tf_texture = new unsigned char [256*256*4];

        m_current_slice = 0;

        m_tfimg = QImage(256, 4, QImage::Format_ARGB32_Premultiplied);
        m_tfimg.fill(0);
}

sliceWidget2::~sliceWidget2()
{
    makeCurrent();
        delete [] m_tf_texture;
}

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

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

void sliceWidget2::initializeGL()
{
        //glutInitDisplayMode (GLUT_RGBA | GLUT_DOUBLE);
        glewInit();
    //qglClearColor(trolltechPurple.dark());
        qglClearColor(QColor::fromRgb(255,255,255));
        glShadeModel (GL_FLAT);

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

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

        glLoadIdentity();
    glTranslated(0.0, 0.0, 0.0);

        glEnable(GL_TEXTURE_1D);
        //glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

        //set transfer function
        deleteTexture(m_vr->m_tfid);
        //m_vr->m_tfid = bindTexture(m_tfimg, GL_TEXTURE_2D, GL_RGBA);
        
        glGenTextures(1, &(m_vr->m_tfid));

        int iy = 0;
        int ix;
        //reset transfer function values to zeros
        memset(m_tf_texture,0,256*4*sizeof(unsigned char));

        ofstream tf_r_file;
        tf_r_file.open ("tf_red.txt");
        ofstream tf_g_file;
        tf_g_file.open ("tf_green.txt");
        ofstream tf_b_file;
        tf_b_file.open ("tf_blue.txt");
        ofstream tf_a_file;
        tf_a_file.open ("tf_alpha.txt");

        //fill values of transfer functions from image
        //for (iy = 0; iy < 256; iy++)
        //{
                for (ix = 0; ix < 256; ix++)
                {
                        QRgb tfc = m_tfimg.pixel(ix,iy);

                        m_tf_texture[ix*4 + 0] = (GLubyte) qRed(tfc);
                        m_tf_texture[ix*4 + 1] = (GLubyte) qGreen(tfc);
                        m_tf_texture[ix*4 + 2] = (GLubyte) qBlue(tfc);
                        m_tf_texture[ix*4 + 3] = (GLubyte) qAlpha(tfc);


                        tf_r_file << qRed(tfc) << " ";
                        tf_g_file << qGreen(tfc) << " ";
                        tf_b_file << qBlue(tfc) << " ";
                        tf_a_file << qAlpha(tfc) << " ";

                }
        //}
        tf_r_file.close();
        tf_g_file.close();
        tf_b_file.close();
        tf_a_file.close();

        //bind texture with texture name
        glBindTexture(GL_TEXTURE_1D,m_vr->m_tfid);
        
        //texture setup
        glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        
        glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

        //set transfer function data
        glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, m_tf_texture);

        //send scale 1 tf to gpu
        glEnable(GL_TEXTURE_1D);
        //glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

        //set transfer function
        deleteTexture(m_vr->m_tfid_s1);
        //m_vr->m_tfid = bindTexture(m_tfimg, GL_TEXTURE_2D, GL_RGBA);
        
        glGenTextures(1, &(m_vr->m_tfid_s1));

        //reset transfer function values to zeros
        memset(m_tf_texture,0,256*4*sizeof(unsigned char));

        tf_r_file.open ("tf_red_s1.txt");
        tf_g_file.open ("tf_green_s1.txt");
        tf_b_file.open ("tf_blue_s1.txt");
        tf_a_file.open ("tf_alpha_s1.txt");

        //fill values of transfer functions from image
        //for (iy = 0; iy < 256; iy++)
        //{
                for (ix = 0; ix < 256; ix++)
                {
                        //line 1 is scale 1
                        QRgb tfc = m_tfimg.pixel(ix,1);

                        m_tf_texture[ix*4 + 0] = (GLubyte) qRed(tfc);
                        m_tf_texture[ix*4 + 1] = (GLubyte) qGreen(tfc);
                        m_tf_texture[ix*4 + 2] = (GLubyte) qBlue(tfc);
                        m_tf_texture[ix*4 + 3] = (GLubyte) qAlpha(tfc);


                        tf_r_file << qRed(tfc) << " ";
                        tf_g_file << qGreen(tfc) << " ";
                        tf_b_file << qBlue(tfc) << " ";
                        tf_a_file << qAlpha(tfc) << " ";

                }
        //}
        tf_r_file.close();
        tf_g_file.close();
        tf_b_file.close();
        tf_a_file.close();

        //bind texture with texture name
        glBindTexture(GL_TEXTURE_1D,m_vr->m_tfid_s1);
        
        //texture setup
        glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        
        glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

        //set transfer function data
        glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, m_tf_texture);
        // scale 1 tf

        //send scale 2 tf to gpu
        glEnable(GL_TEXTURE_1D);
        //glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

        //set transfer function
        deleteTexture(m_vr->m_tfid_s2);
        //m_vr->m_tfid = bindTexture(m_tfimg, GL_TEXTURE_2D, GL_RGBA);
        
        glGenTextures(1, &(m_vr->m_tfid_s2));

        //reset transfer function values to zeros
        memset(m_tf_texture,0,256*4*sizeof(unsigned char));

        tf_r_file.open ("tf_red_s2.txt");
        tf_g_file.open ("tf_green_s2.txt");
        tf_b_file.open ("tf_blue_s2.txt");
        tf_a_file.open ("tf_alpha_s2.txt");

        //fill values of transfer functions from image
        //for (iy = 0; iy < 256; iy++)
        //{
                for (ix = 0; ix < 256; ix++)
                {
                        //line 2 is scale 2
                        QRgb tfc = m_tfimg.pixel(ix,2);

                        m_tf_texture[ix*4 + 0] = (GLubyte) qRed(tfc);
                        m_tf_texture[ix*4 + 1] = (GLubyte) qGreen(tfc);
                        m_tf_texture[ix*4 + 2] = (GLubyte) qBlue(tfc);
                        m_tf_texture[ix*4 + 3] = (GLubyte) qAlpha(tfc);


                        tf_r_file << qRed(tfc) << " ";
                        tf_g_file << qGreen(tfc) << " ";
                        tf_b_file << qBlue(tfc) << " ";
                        tf_a_file << qAlpha(tfc) << " ";

                }
        //}
        tf_r_file.close();
        tf_g_file.close();
        tf_b_file.close();
        tf_a_file.close();

        //bind texture with texture name
        glBindTexture(GL_TEXTURE_1D,m_vr->m_tfid_s2);
        
        //texture setup
        glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        
        glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

        //set transfer function data
        glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, m_tf_texture);
        // scale 2 tf

        //send scale 3 tf to gpu
        glEnable(GL_TEXTURE_1D);
        //glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

        //set transfer function
        deleteTexture(m_vr->m_tfid_s3);
        //m_vr->m_tfid = bindTexture(m_tfimg, GL_TEXTURE_2D, GL_RGBA);
        
        glGenTextures(1, &(m_vr->m_tfid_s3));

        //reset transfer function values to zeros
        memset(m_tf_texture,0,256*4*sizeof(unsigned char));

        tf_r_file.open ("tf_red_s3.txt");
        tf_g_file.open ("tf_green_s3.txt");
        tf_b_file.open ("tf_blue_s3.txt");
        tf_a_file.open ("tf_alpha_s3.txt");

        //fill values of transfer functions from image
        //for (iy = 0; iy < 256; iy++)
        //{
                for (ix = 0; ix < 256; ix++)
                {
                        //line 3 is scale 3
                        QRgb tfc = m_tfimg.pixel(ix,3);

                        m_tf_texture[ix*4 + 0] = (GLubyte) qRed(tfc);
                        m_tf_texture[ix*4 + 1] = (GLubyte) qGreen(tfc);
                        m_tf_texture[ix*4 + 2] = (GLubyte) qBlue(tfc);
                        m_tf_texture[ix*4 + 3] = (GLubyte) qAlpha(tfc);


                        tf_r_file << qRed(tfc) << " ";
                        tf_g_file << qGreen(tfc) << " ";
                        tf_b_file << qBlue(tfc) << " ";
                        tf_a_file << qAlpha(tfc) << " ";

                }
        //}
        tf_r_file.close();
        tf_g_file.close();
        tf_b_file.close();
        tf_a_file.close();

        //bind texture with texture name
        glBindTexture(GL_TEXTURE_1D,m_vr->m_tfid_s3);
        
        //texture setup
        glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameterf(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        
        glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

        //set transfer function data
        glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, m_tf_texture);
        // scale 3 tf

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


        m_vr->setVolume(m_vb);
        glEnable(GL_TEXTURE_2D);
        m_vr->renderSlice(m_current_slice);
        //m_vb->drawXSlice(128);

        glFlush();
        glDisable(GL_TEXTURE_2D);

}

void sliceWidget2::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 sliceWidget2::mousePressEvent(QMouseEvent *event)
{
}

void sliceWidget2::mouseMoveEvent(QMouseEvent *event)
{
}

void sliceWidget2::vr_load_data3(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->create2DTextures(GL_UNSIGNED_BYTE);

        delete m_vb;
        m_vb = vb1;

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

void sliceWidget2::setSlice(int slice)
{
        makeCurrent();
        m_current_slice = slice;
        updateGL();
}

void sliceWidget2::setTFtexture(QImage &tfimg)
{
        makeCurrent();
        int ix = 0;

        for (ix = 0; ix < m_tfimg.width(); ix++)
                m_tfimg.setPixel(ix, 0, tfimg.pixel(ix,0));

        updateGL();
}

void sliceWidget2::setTFtexture1(QImage &tfimg)
{
        makeCurrent();
        int ix = 0;

        for (ix = 0; ix < m_tfimg.width(); ix++)
                m_tfimg.setPixel(ix, 1, tfimg.pixel(ix,0));

        updateGL();
}

void sliceWidget2::setTFtexture2(QImage &tfimg)
{
        makeCurrent();
        int ix = 0;

        for (ix = 0; ix < m_tfimg.width(); ix++)
                m_tfimg.setPixel(ix, 2, tfimg.pixel(ix,0));

        updateGL();
}

void sliceWidget2::setTFtexture3(QImage &tfimg)
{
        makeCurrent();
        int ix = 0;

        for (ix = 0; ix < m_tfimg.width(); ix++)
                m_tfimg.setPixel(ix, 3, tfimg.pixel(ix,0));

        updateGL();
}

---