Eigene Dateien/FlowVis/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)
{
        glInit ();
        //initIcon();
        tfbig = false;

        m_TFVector.resize( 6 );
        /*m_TFVector.push_back( VTransferFunction() );
        m_TFVector.push_back( VTransferFunction() );
        m_TFVector.push_back( VTransferFunction() );*/

        m_TransferFunction = &( m_TFVector[ 0 ] );
}


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

        m_TFVector.clear();
        
}

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

void QTFCanvas::setActiveTF( int index )
{

        switch ( index )
        {
                case 1:
                {
                        m_TransferFunction = &( m_TFVector[ 0 ] );
                        break;
                }
                case 2:
                {
                        m_TransferFunction = &( m_TFVector[ 1 ] );
                        break;
                }
                case 3:
                {
                        m_TransferFunction = &( m_TFVector[ 2 ] );
                        break;
                }
                case 4:
                {
                        m_TransferFunction = &( m_TFVector[ 3 ] );
                        break;
                }
                case 5:
                {
                        m_TransferFunction = &( m_TFVector[ 4 ] );
                        break;
                }
                case 6:
                {
                        m_TransferFunction = &( m_TFVector[ 5 ] );
                        break;
                }
                default :
                {
                        m_TransferFunction = &( m_TFVector[ 0 ] );
                        break;
                }
        
        }

        repaint();
}

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()
{
        //makeCurrent();

        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
        

        m_TransferFunction->draw1d();

        /*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 )
{

        //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 )
{
        
        const VMouseEvent me(getMouseEvent(e));
        const VVector v = me.getPosition();

        m_TransferFunction->setZoomPoint(false, 0, tfbig);

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

};

void QTFCanvas::mouseClickEvent(VMouseEvent me)
{

        const VVector v = globalmetf.getPosition();

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

        
        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);*/
                        }
                }
        }       
        
        

        repaint();


}

void QTFCanvas::mouseDoubleClickEvent ( QMouseEvent * e )
{

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

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

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

VTransferFunction * QTFCanvas::getTransferFunctionPtr( int index )
{
        return &(m_TFVector[index - 1]);
}


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

        
        if(fileend.size() == 4)
        {
                if(fileend.compare(".btf") != 0)
                {
                        filename = filename.substr(0, filename.find_last_of('.'));
                        filename += ".btf";
                }
        }
        m_TransferFunction->save(filename);
        

}

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

---