pcwidget.cpp

Go to the documentation of this file.

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

#include <math.h>

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


pcWidget::pcWidget(QWidget *parent)
    : QGLWidget(parent)
{
        setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
        m_data_available = 0;

        m_current_slice = 0;

        m_selection_quad.first = QPointF(0.0f,0.0f);
        m_selection_quad.second = QPointF(0.0f,0.0f);
        
        m_tfimg = QImage(256, 4, QImage::Format_ARGB32_Premultiplied);
        m_tfimg.fill(0);
}

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

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

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

void pcWidget::initializeGL()
{
        //glewInit();
        qglClearColor(QColor::fromRgb(255,255,255));
        glShadeModel (GL_FLAT);
        glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE);
        gluOrtho2D(0.0, 256.0, 0.0, 512.0);
        glEnable(GL_BLEND);
}

void pcWidget::paintGL()
{
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        glLoadIdentity();

        glTranslated(0.0, 0.0, 0.0);

        glColor3f(0.0f,0.0f,0.0f);

        glBegin(GL_LINES);
                glVertex2f(0, 64);
                glVertex2f(256, 64);

                glVertex2f(0, 192);
                glVertex2f(256, 192);

                glVertex2f(0, 320);
                glVertex2f(256, 320);

                glVertex2f(0, 448);
                glVertex2f(256, 448);
        glEnd();

        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

        //readPCLines();

        //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);


        QListIterator<ParralelCoordinatesLine> pc_lineslist_i(pc_lines_list);
        ParralelCoordinatesLine pc_line;
        QList<QPointF> pc_line_vertices;
        QColor pc_line_color;
        while(pc_lineslist_i.hasNext())
        {
                pc_line = pc_lineslist_i.next();
                pc_line_vertices = pc_line.first;
                pc_line_color = pc_line.second;

                //define mode for polygon drawing
                glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
                //define color of poly-line e.g. black
                //glColor3f(0.0, 0.0, 0.0);
                qglColor(pc_line_color);

                //draw poly-line
                glBegin(GL_POLYGON);
                        QListIterator<QPointF> i(pc_line_vertices);
                        QPointF poly_vertex;
                        while (i.hasNext())
                        {
                                poly_vertex = (QPointF)i.next();
                                
                                //we don't want loop
                                if(i.hasNext())
                                        glEdgeFlag(GL_TRUE);
                                else
                                        glEdgeFlag(GL_FALSE);
                                
                                glVertex2f(poly_vertex.x(),poly_vertex.y());
                        }
                        /*
                        glEdgeFlag(GL_TRUE);
                        glVertex2f(v0.x(),v0.y());
                        glEdgeFlag(GL_TRUE);
                        glVertex2f(v1.x(),v1.y());
                        glEdgeFlag(GL_TRUE);
                        glVertex2f(v2.x(),v2.y());
                        glEdgeFlag(GL_TRUE);
                        glVertex2f(v3.x(),v3.y());
                        glEdgeFlag(GL_FALSE);
                        glVertex2f(v4.x(),v4.y());
                        */
                glEnd();
        }

        /*
        //define mode for polygon drawing
        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
        //define color of poly-line e.g. black
        //glColor3f(0.0, 0.0, 0.0);
        qglColor(line_color);
        
        //draw poly-line
        glBegin(GL_POLYGON);
                QListIterator<QPointF> i(vertices);
                QPointF poly_vertex;
                while (i.hasNext())
                {
                        poly_vertex = (QPointF)i.next();
                        
                        //we don't want loop
                        if(i.hasNext())
                                glEdgeFlag(GL_TRUE);
                        else
                                glEdgeFlag(GL_FALSE);
                        
                        glVertex2f(poly_vertex.x(),poly_vertex.y());
                }
        glEnd();
        */

        glFlush ();

}

void pcWidget::resizeGL(int width, int height)
{
   int side = qMin(width, height);

   glViewport (0, 0, (GLsizei) width, (GLsizei) height); 
   glMatrixMode (GL_PROJECTION);
   glLoadIdentity ();
}

void pcWidget::readPCLines()
{
        int v0,v1,v2,v3;

        QPointF l0,l1,l2,l3;
        QColor line_color;

        //m_tfimg.fill(0);

        if(m_data_available)
        {
                pc_lines_list.clear();

                int vw= m_vb->getWidth();
                int vh= m_vb->getHeight();
                int vd= m_vb->getDepth();

                //m_selection_quad.first = QPointF(30.0f,40.0f);
                //m_selection_quad.second = QPointF(50.0f,70.0f);

                int start_y = qMin(m_selection_quad.first.x(), m_selection_quad.second.x());
                int end_y = qMax(m_selection_quad.first.x(), m_selection_quad.second.x());
                int start_x = qMin(m_selection_quad.first.y(), m_selection_quad.second.y());
                int end_x = qMax(m_selection_quad.first.y(), m_selection_quad.second.y());

                int ix, iy, iz;
                iz=m_current_slice;
                //fill slice values from datagrid
                for (iy = start_y; iy < end_y; iy++)
                {
                        for (ix = start_x; ix <= end_x; ix++)
                        {
                                v0 = m_vb->m_volume_data_raw[(vh*vw)*iz + (vw)*iy + ix];
                                v1 = m_vb->m_scale1_raw[(vh*vw)*iz + (vw)*iy + ix];
                                v2 = m_vb->m_scale2_raw[(vh*vw)*iz + (vw)*iy + ix];
                                v3 = m_vb->m_scale3_raw[(vh*vw)*iz + (vw)*iy + ix];

                                l0 = QPointF(v0, 64.0);
                                l1 = QPointF(v1, 192.0);
                                l2 = QPointF(v2, 320.0);
                                l3 = QPointF(v3, 448.0);
                                //line_color = QColor(0,0,255,20);
                                //line_color = m_tfimg.pixel(v0,0);
                                QRgb lc0 = m_tfimg.pixel(v0,0);
                                QRgb lc1 = m_tfimg.pixel(v1,1);
                                QRgb lc2 = m_tfimg.pixel(v2,2);
                                QRgb lc3 = m_tfimg.pixel(v3,3);

                                int rlc0 = qRed(lc0);
                                int glc0 = qGreen(lc0);
                                int blc0 = qBlue(lc0);
                                int alc0 = qAlpha(lc0);
                                float p0 = (float)alc0/255;

                                int rlc1 = qRed(lc1);
                                int glc1 = qGreen(lc1);
                                int blc1 = qBlue(lc1);
                                int alc1 = qAlpha(lc1);
                                float p1 = (float)alc1/255;

                                int rlc2 = qRed(lc2);
                                int glc2 = qGreen(lc2);
                                int blc2 = qBlue(lc2);
                                int alc2 = qAlpha(lc2);
                                float p2 = (float)alc2/255;

                                int rlc3 = qRed(lc3);
                                int glc3 = qGreen(lc3);
                                int blc3 = qBlue(lc3);
                                int alc3 = qAlpha(lc3);
                                float p3 = (float)alc3/255;

                                float pi = 1.0f;
                                int rlc=0,glc=0,blc=0,alc=0;
                                if((rlc0 > 0) || (glc0 > 0) || (blc0>0))
                                {
                                        rlc = rlc0;
                                        glc = glc0;
                                        blc = blc0;
                                        pi = pi*p0;
                                }

                                if((rlc1 > 0) || (glc1 > 0) || (blc1>0))
                                {
                                        rlc = rlc1;
                                        glc = glc1;
                                        blc = blc1;
                                        pi = pi*p1;
                                }

                                if((rlc2 > 0) || (glc2 > 0) || (blc2>0))
                                {
                                        rlc = rlc2;
                                        glc = glc2;
                                        blc = blc2;
                                        pi = pi*p2;
                                }
                                
                                if((rlc3 > 0) || (glc3 > 0) || (blc3>0))
                                {
                                        rlc = rlc3;
                                        glc = glc3;
                                        blc = blc3;
                                        pi = pi*p3;
                                }

                                alc = (int)255*pi;
                                //int ai = (int)255*pi;

                                /*
                                QRgb lc = lc0;
                                if(alc1 > 0)
                                        lc = lc1;
                                
                                if(alc2 > 0)
                                        lc = lc2;

                                if(alc3 > 0)
                                        lc = lc3;
                                        */

                                //int rlc = qRed(lc);
                                //int glc = qGreen(lc);
                                //int blc = qBlue(lc);
                                //int alc = qAlpha(lc);
                                
                                line_color = QColor(rlc,glc,blc,alc);


                                //add points of poly-line to list
                                QList<QPointF> vertices;
                                vertices.append(l0);
                                vertices.append(l1);
                                vertices.append(l2);
                                vertices.append(l3);

                                pc_lines_list.append(qMakePair(vertices,line_color));
                        }
                }
        }

        //ad-hoc solution

        /*
        //define points of poly-line
        QPointF v00 = QPointF(10.0, 0.0);
        QPointF v01 = QPointF(200.0, 128.0);
        QPointF v02 = QPointF(100.0, 256.0);
        QPointF v03 = QPointF(20.0, 384.0);
        QPointF v04 = QPointF(140.0, 512.0);
        QColor line_color0 = QColor(255,0,0,255);

        //add points of poly-line to list
        QList<QPointF> vertices0;
        vertices0.append(v00);
        vertices0.append(v01);
        vertices0.append(v02);
        vertices0.append(v03);
        vertices0.append(v04);

        //define points of poly-line
        QPointF v10 = QPointF(100.0, 0.0);
        QPointF v11 = QPointF(150.0, 128.0);
        QPointF v12 = QPointF(200.0, 256.0);
        QPointF v13 = QPointF(126.0, 384.0);
        QPointF v14 = QPointF(10.0, 512.0);
        QColor line_color1 = QColor(0,0,255,255);

        //add points of poly-line to list
        QList<QPointF> vertices1;
        vertices1.append(v10);
        vertices1.append(v11);
        vertices1.append(v12);
        vertices1.append(v13);
        vertices1.append(v14);

        pc_lines_list.append(qMakePair(vertices0,line_color0));
        pc_lines_list.append(qMakePair(vertices1,line_color1));
        */
}

void pcWidget::mousePressEvent(QMouseEvent *event)
{
}

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

void pcWidget::set_pc_data(VolumeBuffer *vb1)
{
        //grab GL context
        makeCurrent();

        std::cout << "Parallel data changed...\n";
        
        m_vb = vb1;

        m_data_available = 1;

        updateGL();
}

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

void pcWidget::sedSelectionQuad(QPair<QPointF,QPointF> &sel_quad)
{
        makeCurrent();
        m_selection_quad = sel_quad;
        //m_current_slice = slice;
        readPCLines();
        updateGL();
}

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

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

        readPCLines();
        updateGL();
}

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

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

        readPCLines();
        updateGL();
}

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

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

        readPCLines();
        updateGL();
}

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

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

        readPCLines();
        updateGL();
}

---