Eigene Dateien/Vis/src/QTFCanvas.cpp

Go to the documentation of this file.

#include "glew.h"
#include "QTFCanvas.h"
#include "icon.img"

const int THRESHOLD_DETAIL = 8;
const int THRESHOLD_OVERVIEW = 25;

const DWORD dtClick = 250;
DWORD clicked = 0;
int dragging_tfpt = -1;
int dragging_tfpt2d = -1;
int modifytriangle = -1;

VMouseEvent globalmetf = VMouseEvent();

int RIGHT_PRESSED = 0;

bool firstframeh = true;
bool firstframew = true;
bool firstframes = true;



QTFCanvas::QTFCanvas(QWidget* parent /*= 0*/) : QObject(parent), QGLWidget(parent)
{
        m_tfmode = 0;
        glInit ();
        //initIcon();
        tfbig = false;
}


QTFCanvas::~QTFCanvas()
{
        //glDeleteTextures(1, &icon_texturehandle);
        
}

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

void QTFCanvas::setModePtr(QComboBox* cb)
{
        m_tfmode_cb_Ptr = cb;
}

void QTFCanvas::checkForLongClick()
{
        
        DWORD elapsed = GetTickCount() - clicked;
        VVector pos = globalmetf.getPosition();

        if (RIGHT_PRESSED == 1 &&  
                elapsed    >  1.3f*dtClick /*&&
                pos.getX() > (1.0f - 16.0f/391.0f) &&
                pos.getY() > (1.0f - 16.0f/121.0f)*/)
        {
                m_tfmode_cb_Ptr->setVisible(true);
                return;
        }

        m_tfmode_cb_Ptr->setVisible(false);
}

void QTFCanvas::initializeGL()
{
        /*this*/makeCurrent();
    // Set up the rendering context, define display lists etc.:
    //...
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glClearColor( 1.0, 1.0, 1.0, 1.0 );
    glEnable(GL_DEPTH_TEST);
    //...
}

void QTFCanvas::resizeGL( int w, int h )
{
        /*this*/makeCurrent();
    glViewport(0, 0, w, h);
        gluOrtho2D(0, w, h, 0);

}

void QTFCanvas::paintGL()
{
        
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glEnable(GL_DEPTH_TEST);

    // draw the scene:
    glPushAttrib(GL_ALL_ATTRIB_BITS);
        
        glMatrixMode(GL_PROJECTION);
        glPushMatrix();

        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();

        glLoadIdentity();       // Reset The Current Modelview Matrix
        
        if(m_tfmode == 1)
                m_TransferFunction.draw1d();

        if(m_tfmode == 2)
                m_TransferFunction2d.draw2d();

        /*glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
        glGenTextures(1, &icon_texturehandle);

        glEnable(GL_TEXTURE_2D);
        glActiveTextureARB(GL_TEXTURE0_ARB);
        glBindTexture(GL_TEXTURE_2D,icon_texturehandle);
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP);
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP);
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);

        glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,16,16,0,GL_RGBA,GL_UNSIGNED_BYTE,vcImage);
        glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);

        float x1 = 1.0f - 16.0f/391.0f;
        float x2 = 1.0f;
        float y1 = 1.0f - 16.0f/121.0f;
        float y2 = 1.0f;

        glBegin(GL_QUADS);
                glTexCoord2f(0.0, 1.0); glVertex3f(x1,y1, -0.05f);
                glTexCoord2f(1.0, 1.0); glVertex3f(x2,y1, -0.05f);
                glTexCoord2f(1.0, 0.0); glVertex3f(x2,y2, -0.05f);
                glTexCoord2f(0.0, 0.0); glVertex3f(x1,y2, -0.05f);
        glEnd();

        glBindTexture(GL_TEXTURE_2D, 0);
        glDisable(GL_TEXTURE_2D);*/

        glMatrixMode(GL_PROJECTION);
        glPopMatrix();

        glMatrixMode(GL_MODELVIEW);
        glPopMatrix();

        glPopAttrib();
        
}


void QTFCanvas::paintEvent( QPaintEvent *e )
{
        QGLWidget::paintEvent(e);
};

void QTFCanvas::mousePressEvent ( QMouseEvent * e )
{               
        clicked = GetTickCount();
        globalmetf  = getMouseEvent(e);

        RIGHT_PRESSED = (globalmetf.getRightState());
        
};

void QTFCanvas::mouseReleaseEvent ( QMouseEvent * e )
{
        m_tfmode_cb_Ptr->setVisible(false);

        //const VMouseEvent me(getMouseEvent(e));
        m_TransferFunction.setZoomPoint(false, 0, tfbig);
        dragging_tfpt = -1;
        dragging_tfpt2d = -1;
        modifytriangle = -1;

        //handle mouse click
        DWORD elapsed = GetTickCount() - clicked;
        if (elapsed < dtClick)
        {
                mouseClickEvent(globalmetf);
        }
        
        //clicked = 0;
        RIGHT_PRESSED = 0;

        repaint();
        
};
        
void QTFCanvas::mouseMoveEvent ( QMouseEvent * e )
{
        if(m_tfmode == 0)
                return;

        const VMouseEvent me(getMouseEvent(e));
        const VVector v = me.getPosition();

        m_TransferFunction.setZoomPoint(false, 0, tfbig);


        if(m_tfmode == 1)
        {
                if(me.getLeftState() == 1)
                {
                        float x = v.getX();
                        float y = v.getY();

                        x = (x >  1.0f) ?  1.0f : x;
                        x = (x < -1.0f) ? -1.0f : x;
                        y = (y >  1.0f) ?  1.0f : y;
                        y = (y < -1.0f) ? -1.0f : y;

                        int density = (int)((x * 0.5f + 0.5f) * 4095.0f);
                        
                        if(dragging_tfpt > -1)
                        {

                                //drag a tf point also in x-y direction, not only alpha
                                vTransferFunctionPoint tmpPoint = m_TransferFunction.getTransferFunctionPoint(dragging_tfpt);
                                m_TransferFunction.removeTransferFunctionPoint(dragging_tfpt);

                                int index =0;
                                if(tfbig)
                                {
                                         index= m_TransferFunction.transferFunctionPointInRange(density, y, THRESHOLD_DETAIL);
                                }else
                                {
                                        index= m_TransferFunction.transferFunctionPointInRange(density, y, THRESHOLD_OVERVIEW);
                                }

                                if(index == -1)
                                {
                                        tmpPoint.m_Alpha = (y + 0.8f)/1.8f;
                                        if(tmpPoint.m_Alpha < 0.0f)
                                                tmpPoint.m_Alpha = 0.0f;
                                        m_TransferFunction.addTransferFunctionPoint(density, tmpPoint);
                                        dragging_tfpt = density;
                                        
                                }
                                else
                                {
                                        m_TransferFunction.addTransferFunctionPoint(dragging_tfpt, tmpPoint);
                                }
                                
                                }
                        else //if (dragging_tfpt == -1)
                        {

                                int index =0;

                                if(tfbig)
                                {
                                         index= m_TransferFunction.transferFunctionPointInRange(density, y, THRESHOLD_DETAIL);
                                }else
                                {
                                        index= m_TransferFunction.transferFunctionPointInRange(density, y, THRESHOLD_OVERVIEW);
                                }

                                dragging_tfpt = index;
                                /*density = m_TransferFunction.transferFunctionPointInRange(density, v.getY(), THRESHOLD);
                                vTransferFunctionPoint tmpPoint = m_TransferFunction.getTransferFunctionPoint(density);
                                tmpPoint.m_Alpha = v.getY() * 0.5f + 0.5f;
                                m_TransferFunction.addTransferFunctionPoint(density, tmpPoint);*/

                        }
                        repaint();
                        this->swapBuffers();
                        return;
                }
                
                if (me.getMiddleState() == 1)
                {
                        m_TransferFunction.setZoomPoint(true, v.getX(), tfbig);
                        repaint();
                        this->swapBuffers();
                        return;
                        
                }
        }

        if(m_tfmode == 2)
        {
                if(me.getModifiers() != me.MODIFIER_CTRL && me.getLeftState() == 1)
                {
                        float x = v.getX();
                        float y = v.getY();

                        x = (x >  1.0f) ?  1.0f : x;
                        x = (x < -1.0f) ? -1.0f : x;
                        y = (y >  1.0f) ?  1.0f : y;
                        y = (y < -1.0f) ? -1.0f : y;

                        float density = x * 0.5f + 0.5f;
                        float gmag =    y * 0.5f + 0.5f;

                        int tmptres = 0;

                        if(tfbig)
                        {
                                tmptres = THRESHOLD_DETAIL;
                        }else
                        {
                                tmptres = THRESHOLD_OVERVIEW;
                        }

                        if( dragging_tfpt2d > -1)
                        {
                                m_TransferFunction2d.changePointPosition(dragging_tfpt2d, x, y );
                                m_TransferFunction.setZoomPoint(true, v.getX(), tfbig);
                                
                                repaint();
                                this->swapBuffers();
                                return;
                        }
                        else{
                        
                                dragging_tfpt2d = m_TransferFunction2d.findIndexTransferFunctionPoint( density, gmag, (float)tmptres/1024.0f );
                        }
                }

                if(me.getModifiers() == me.MODIFIER_CTRL )
                {

                        if(me.getLeftState() == 1)
                        {
                                float x2 = v.getX();
                                float y2 = v.getY();

                                float x1 = globalmetf.getPosition().getX();
                                float y1 = globalmetf.getPosition().getY();

                                
                                float offsetw = x2 - x1;
                                float offseth = y2 - y1;

                                offsetw *= 0.5f;
                                offseth *= 0.5f;

                                float density = x1 * 0.5f + 0.5f;
                                float gmag =    y1 * 0.5f + 0.5f;

                                int tmptres = 0;

                                if(tfbig)
                                {
                                        tmptres = THRESHOLD_DETAIL;
                                }else
                                {
                                        tmptres = THRESHOLD_OVERVIEW;
                                }

                                if(modifytriangle == -1) 
                                {
                                        modifytriangle = m_TransferFunction2d.findIndexTransferFunctionPoint( density, gmag, (float)tmptres/1024.0f );
                                }
                                else
                                {
                                        m_TransferFunction2d.changeTriangleSize( modifytriangle, offsetw, offseth );                            
                                }


                                globalmetf = me;

                                repaint();
                                this->swapBuffers();
                                return;
                        }

                        if(me.getRightState() == 1)
                        {
                                float x2 = v.getX();

                                float x1 = globalmetf.getPosition().getX();
                                float y1 = globalmetf.getPosition().getY();
                                
                                float offset = x2 - x1;
                                offset *= 0.5f;

                                float density = x1 * 0.5f + 0.5f;
                                float gmag =    y1 * 0.5f + 0.5f;

                                int tmptres = 0;

                                if(tfbig)
                                {
                                        tmptres = THRESHOLD_DETAIL;
                                }else
                                {
                                        tmptres = THRESHOLD_OVERVIEW;
                                }

                                if(modifytriangle == -1) 
                                {
                                        modifytriangle = m_TransferFunction2d.findIndexTransferFunctionPoint( density, gmag, (float)tmptres/1024.0f );
                                }
                                else
                                {
                                        m_TransferFunction2d.changeTriangleSkew( modifytriangle, offset );                              
                                }


                                globalmetf = me;

                                repaint();
                                this->swapBuffers();
                                return;
                        }
                        

                        
                }
        }

};

void QTFCanvas::mouseClickEvent(VMouseEvent me)
{
        if(m_tfmode == 0)
                return;

        const VVector v = globalmetf.getPosition();

        if(me.getModifiers() == me.MODIFIER_ALT)return;

        if(m_tfmode == 1)
        {
                if(globalmetf.getLeftState() == 1)
                {
                        if(v.getY() >= -0.8f)
                        {
                                int density = (int)((v.getX() * 0.5f + 0.5f) * 4095.0f);

                                //add new point
                                int tmptres =0;
                                if(tfbig)
                                {
                                         tmptres = THRESHOLD_DETAIL;
                                }else
                                {
                                         tmptres = THRESHOLD_OVERVIEW;
                                }

                                if(m_TransferFunction.transferFunctionPointInRange(density, v.getY(), tmptres)==-1)
                                {
                                        QColor qcolor = QColorDialog::getColor();
                                        VVector color((float)qcolor.red()/255.0f, (float)qcolor.green()/255.0f, (float)qcolor.blue()/255.0f);
                                        float alpha = (v.getY() + 0.8f)/1.8f;
                                        if(alpha < 0.0f)
                                                alpha = 0.0f;
                                        vTransferFunctionPoint tmpPoint;
                                        tmpPoint.m_Alpha = alpha;
                                        tmpPoint.m_Color = color;
                                        m_TransferFunction.addTransferFunctionPoint(density, tmpPoint);
                                }
                                else
                                {
                                        /*density = m_TransferFunction.transferFunctionPointInRange(density, v.getY(), THRESHOLD);
                                        vTransferFunctionPoint tmpPoint = m_TransferFunction.getTransferFunctionPoint(density);
                                        tmpPoint.m_Alpha = v.getY() * 0.5f + 0.5f;
                                        m_TransferFunction.addTransferFunctionPoint(density, tmpPoint);*/
                                }
                        }
                }       
        }

        if(m_tfmode == 2)
        {
                if(me.getModifiers() != me.MODIFIER_CTRL && globalmetf.getLeftState() == 1)
                {
                        //insert  a tf point

                        float density = (v.getX() * 0.5f + 0.5f);

                        //add new point
                        int tmptres =0;
                        if(tfbig)
                        {
                                 tmptres = THRESHOLD_DETAIL;
                        }else
                        {
                                 tmptres = THRESHOLD_OVERVIEW;
                        }
                        VVector result = m_TransferFunction2d.transferFunctionPointInRange(density, v.getY()*0.5 + 0.5, (float)tmptres/4095.0f);

                        if(result.getZ() == -1.0f)
                        {
                                QRgb qrgba = QColorDialog::getRgba(0xffffffff);

                                QColor qcolor;
                                qcolor.setRgba(qrgba);

                                VVector color((float)qcolor.red()/255.0f, (float)qcolor.green()/255.0f, (float)qcolor.blue()/255.0f);

                                vTransferFunction2DPoint tmpPoint;
                                tmpPoint.m_Alpha = (float)qcolor.alpha()/255.0f;
                                tmpPoint.m_Color = color;
                                tmpPoint.m_gmag = v.getY()*0.5f + 0.5f;
                                tmpPoint.m_density = (float)density;

                                m_TransferFunction2d.addTransferFunctionPoint(tmpPoint);

                                repaint();
                        }
                }       
        }
        

        repaint();


}

void QTFCanvas::mouseDoubleClickEvent ( QMouseEvent * e )
{
        if(m_tfmode == 0)
                return;

        const VMouseEvent me(getMouseEvent(e));
        const VVector v = me.getPosition();

        

        if(m_tfmode == 1)
        {
                if(me.getModifiers() == me.MODIFIER_ALT && me.getLeftState() == 1)
                {
                        if(tfbig)
                        {
                                setGeometry(0,0,381,121);
                                hbar->setVisible(false);
                                vbar->setVisible(false);
                        }
                        else
                        {
                                setGeometry(0,-215,1143,363);
                                hbar->setVisible(true);
                                vbar->setVisible(true);
                                hbar->setValue(0);
                                vbar->setValue(0);
                        }
                        
                        tfbig = !tfbig;
                }
                
                int density = (int)((v.getX() * 0.5f + 0.5f) * 4095.0f);

                int tmptres =0;
                if(tfbig)
                {
                         tmptres= THRESHOLD_DETAIL;
                }else
                {
                         tmptres= THRESHOLD_OVERVIEW;
                }

                if(me.getLeftState() == 1)
                {
                        //doubleclick with left mouse
                        //detect if there is a TF Point in range
                        //if Y, call the QDialog to change its color
                        
                        int index = m_TransferFunction.transferFunctionPointInRange(density,v.getY(), tmptres);

                        if (index == -1) return;

                        QColor qcolor = QColorDialog::getColor();
                        VVector color((float)qcolor.red()/255.0f, (float)qcolor.green()/255.0f, (float)qcolor.blue()/255.0f);
                        float a = m_TransferFunction.getAlpha(index);
                        m_TransferFunction.removeTransferFunctionPoint(index);

                        vTransferFunctionPoint tmpPoint;
                        tmpPoint.m_Color = color;
                        tmpPoint.m_Alpha = a;
                        m_TransferFunction.addTransferFunctionPoint(index, tmpPoint);

                }
                else if(me.getRightState() == 1)
                {
                        //doubleclick with right mouse
                        //detect if there is a TF Point in range
                        //delete this TF Pt fromt the list
                        
                        if(m_TransferFunction.transferFunctionPointInRange(density,v.getY(), tmptres)==-1)
                        {
                                
                        }
                        else
                        {
                                density = m_TransferFunction.transferFunctionPointInRange(density, v.getY(), tmptres);
                                m_TransferFunction.removeTransferFunctionPoint(density);
                        }
                        
                }
        }

        if(m_tfmode == 2)
        {

                int tmptres =0;
                if(tfbig)
                {
                         tmptres= THRESHOLD_DETAIL;
                }else
                {
                         tmptres= THRESHOLD_OVERVIEW;
                }

                if(me.getModifiers() == me.MODIFIER_ALT && me.getLeftState() == 1)
                {
                        if(tfbig)
                        {
                                setGeometry(0,0,381,121);
                                hbar->setVisible(false);
                                vbar->setVisible(false);
                        }
                        else
                        {
                                setGeometry(0,-242,1143,363);
                                hbar->setVisible(true);
                                vbar->setVisible(true);
                                hbar->setValue(0);
                                vbar->setValue(0);
                        }
                        
                        tfbig = !tfbig;

                        return;
                }

                float density = v.getX() * 0.5f + 0.5f;
                float gmag =    v.getY() * 0.5f + 0.5f;

                if(me.getLeftState() == 1 && me.getModifiers() == me.MODIFIER_CTRL)
                {
                        //find a point
                        //change its color
                        QRgb qrgba = QColorDialog::getRgba(0xffffffff);

                        QColor qcolor;
                        qcolor.setRgba(qrgba);

                        VVector color((float)qcolor.red()/255.0f, (float)qcolor.green()/255.0f, (float)qcolor.blue()/255.0f);
                        float alpha = (float)qcolor.alpha()/255.0f;

                        m_TransferFunction2d.changePointColor( density, gmag, color, alpha, (float)tmptres/1024.0f );

                }
                else if(me.getRightState() == 1)
                {
                        //remove a point
                        m_TransferFunction2d.removeTransferFunctionPoint( density, gmag, (float)tmptres/1024.0f );
                        
                }
        }


};

void QTFCanvas::keyPressEvent ( QKeyEvent * e )
{
        //const VMouseEvent me(getMouseEvent(e));

};

void QTFCanvas::keyReleaseEvent ( QKeyEvent * e )
{
        //const VMouseEvent me(getMouseEvent(e));
        

};

const VMouseEvent QTFCanvas::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 QTFCanvas::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 QTFCanvas::redraw()
{
        /*this*/makeCurrent();
        paintGL();
}

void QTFCanvas::setHistogram(std::vector<int> *histogram, unsigned char *histogram2d)
{
        /*this*/makeCurrent();
        m_TransferFunction.setHistogram(histogram);
        m_TransferFunction2d.setHistogram2D(histogram2d);
        this->repaint();
}

VTransferFunction * QTFCanvas::getTransferFunctionPtr()
{
        return &m_TransferFunction;
}

VTransferFunction2D * QTFCanvas::getTransferFunction2DPtr()
{
        return &m_TransferFunction2d;
}

void QTFCanvas::modeChanged(int index)
{
        
        RIGHT_PRESSED = 0;

        m_tfmode = index;
}

void QTFCanvas::saveTf(std::string filename)
{
        std::string fileend = filename.substr(filename.find_last_of('.'), filename.size()-1);

        switch(m_tfmode)
        {
        case 1:
                
                if(fileend.size() == 4)
                {
                        if(fileend.compare(".btf") != 0)
                        {
                                filename = filename.substr(0, filename.find_last_of('.'));
                                filename += ".btf";
                        }
                }
                else if(fileend.size() == 5)
                {

                        filename = filename.substr(0, filename.find_last_of('.'));
                        filename += ".btf";
                }
                m_TransferFunction.save(filename);
                break;
        case 2:
                if(fileend.size() == 5)
                {
                        if(fileend.compare(".bt2f") != 0)
                        {
                                filename = filename.substr(0, filename.find_last_of('.'));
                                filename += ".bt2f";
                        }
                }
                else if(fileend.size() == 4)
                {

                        filename = filename.substr(0, filename.find_last_of('.'));
                        filename += ".bt2f";
                }
                m_TransferFunction2d.save(filename);
                break;
        }

}

void QTFCanvas::loadTf(std::string filename)
{
        std::string filend = filename.substr(filename.find_last_of('.'), filename.size()-1);

        if(filend.compare(".btf") == 0)
        {
                m_TransferFunction.load(filename);
        }
        else if(filend.compare(".bt2f") == 0)
        {
                m_TransferFunction2d.load(filename);
        }
}

---