D:/Timo/Visualisierung/LU/Aufgabe1/src/TransferFunction.cpp

Go to the documentation of this file.

#include <math.h>
#include <QPainter>
#include <QPainterPath>
#include <QtDebug>
#include <QFileDialog>
#include <QMessageBox>
#include <QMouseEvent>
#include "TransferFunction.h"
#include "ColorPicker.h"

TransferFunction::TransferFunction(QWidget *parent) : QWidget(parent)
{
        this->parent = parent;
        volume = 0;
        height = -1;
        widthMax = -1;
        normHistoVals = 0;
        normHistoVals = 0;
        normScaledHistoVals = 0;
        zoomFactor = 0;
        scaleFactor = 1.0;
        marginBottom = marginRight = 0;
        transferFunction = 0;

        updateAsked = false;
        timerIdentifier = startTimer(50);
}

TransferFunction::~TransferFunction()
{
        killTimer(timerIdentifier);
        if(normHistoVals)
        {
                delete [] normHistoVals;
        }
        if(normScaledHistoVals)
        {
                delete [] normScaledHistoVals;
        }
        if(transferFunction)
        {
                delete [] transferFunction;
        }
        removeAllVertices();    
}

void TransferFunction::update()
{
        updateAsked = true;
}

void TransferFunction::timerEvent(QTimerEvent *event)
{
        if(updateAsked)
        {
                updateAsked = false;
                QWidget::update();
        }
}

QSize TransferFunction::sizeHint() const
{       
        return QSize(scaledWidth, height);
}


void TransferFunction::loadTfFile()
{
        QString fileName = QFileDialog::getOpenFileName(0,
        "Load Transfer Function", curDir,
                "Transfer Function (*.tf);;All Files (*)");
         if(fileName!=0) {
                curDir = fileName;
                qDebug() << "Pfad vom File: " << fileName;

                QFile *file = new QFile(fileName);

                if(!file->open(QIODevice::ReadOnly | QIODevice::Unbuffered))
                {
                        qDebug() <<  "could not open";
                        return;
                }

                int count, tmpInt;
                Vertex *v;
                QColor color;

                file->read((char*)&count, 4);

                removeAllVertices();
                for(int i = 0;i < count;++i)
                {
                        v = new Vertex();
                        file->read((char*)&tmpInt, 4);
                        v->x = tmpInt;
                        v->xScaled = (int)floor(tmpInt / scaleFactor + 0.5);

                        file->read((char*)&tmpInt, 4);
                        v->color.setRed(tmpInt);
                        file->read((char*)&tmpInt, 4);
                        v->color.setGreen(tmpInt);
                        file->read((char*)&tmpInt, 4);
                        v->color.setBlue(tmpInt);
                        file->read((char*)&tmpInt, 4);
                        v->color.setAlpha(tmpInt);

                        vertices.insert(v);
                }
                file->close();
                delete file;

                updateTransferfunction();
                update();
                qDebug() <<  "loaded";
         }
}

void TransferFunction::saveTfFile()
{
        QString fileName = QFileDialog::getSaveFileName(0,
        "Save Transfer Function", curDir,
        "Transfer Function (*.tf);;All Files (*)");
         if(fileName!=0) {
                curDir = fileName;
                qDebug() << "Pfad vom File: " << fileName;

                QFile *file = new QFile(fileName);

                if(!file->open(QIODevice::WriteOnly | QIODevice::Unbuffered))
                {
                        qDebug() <<  "could not open";
                        return;
                }

                int tmpInt = vertices.size();
                file->write((char*)&tmpInt, 4);

                IteratorVertices iter;
                for(iter = vertices.begin();iter != vertices.end(); ++iter)
                {
                        tmpInt = (*iter)->x;
                        file->write((char*)&tmpInt, 4);
                        tmpInt = (*iter)->color.red();
                        file->write((char*)&tmpInt, 4);
                        tmpInt = (*iter)->color.green();
                        file->write((char*)&tmpInt, 4);
                        tmpInt = (*iter)->color.blue();
                        file->write((char*)&tmpInt, 4);
                        tmpInt = (*iter)->color.alpha();
                        file->write((char*)&tmpInt, 4);
                }
                file->close();
                delete file;

                qDebug() <<  "saved";
         }
}

void TransferFunction::mousePressEvent(QMouseEvent *event)
{       
        unselectAllVertices();
        Vertex *tempV = newVertex(event->x(), event->y());
        IteratorVertices iterHit = containsNearVertex(tempV);
        if(iterHit._Has_container())
        {
                Vertex *hit = *iterHit;
                select(hit);
                movingVertex = iterHit; 
        }
        update();
}

void TransferFunction::mouseReleaseEvent(QMouseEvent * event)
{
        /*
        if((*movingVertex)->selected) {
                updateTransferfunction();
        }*/
}

void TransferFunction::mouseMoveEvent(QMouseEvent* event)
{
        if(event->buttons() == Qt::LeftButton) 
        {
                if((*movingVertex)->selected) {
                        
                        int xNew = event->pos().x();
                        int yNew = event->pos().y();

                        // Start and End point only move in y
                        if(movingVertex==vertices.begin() || movingVertex==(--vertices.end()))
                        {
                                xNew = (*movingVertex)->xScaled;
                        } 
                        else
                        {
                                IteratorVertices iterTemp = movingVertex;
                                
                                iterTemp++;
                                if((*iterTemp)->xScaled <= xNew)
                                {
                                        xNew = (*iterTemp)->xScaled - 1;
                                } 
                                else 
                                {
                                        iterTemp--;
                                        iterTemp--;
                                        if((*iterTemp)->xScaled >= xNew)
                                        {
                                                xNew = (*iterTemp)->xScaled + 1;
                                        }
                                }       
                        }

                        if(yNew<0)
                        {
                                yNew = 0;
                        } else if(yNew>255)
                        {
                                yNew = 255;
                        }                       

                        (*movingVertex)->setPos(xNew*scaleFactor, xNew, yNew);  
                        updateTransferfunction();
                        update();
                }
        }
}


void TransferFunction::mouseDoubleClickEvent(QMouseEvent* event) 
{
        if(event->button() == Qt::LeftButton) 
        {
                unselectAllVertices();
                Vertex *tempV = newVertex(event->x(), event->y());
                IteratorVertices iterHit = containsNearVertex(tempV);
                if(iterHit._Has_container())
                {
                        Vertex *hit = *iterHit;
                        select(hit);
                        delete tempV;
                        ColorPicker colorPicker(this);
                        colorPicker.setColor(hit->color);
                        if(colorPicker.startPicker())
                        {
                                QColor newColor = colorPicker.getColor();
                                newColor.setAlpha(hit->color.alpha());
                                hit->color = newColor;
                                updateTransferfunction();
                        }
                } 
                else
                {
                        addVertex(tempV);
                        select(tempV);
                }

                update();
        } 
        else if(event->button() == Qt::RightButton)
        {
                Vertex *tempV = newVertex(event->x(), event->y());
                IteratorVertices iterHit = containsNearVertex(tempV);
                if(*iterHit)
                {
                        Vertex *hit = *iterHit;
                        unselect(hit);
                        removeVertex(hit);
                        delete tempV;
                        
                        update();
                } 

        }
}

int TransferFunction::width() const
{
        return ((QScrollArea*)parent)->viewport()->width();
}

void TransferFunction::setVolume(Volume *volume)
{
        this->volume = volume;
        height = 255;
        widthMax = volume->getDataRange();
        //parent->setMaximumWidth(widthMax);
        initHisto();
        initTransferfunction();
        this->adjustSize();
        update();
}

void TransferFunction::setZoomFactor(int value)
{
        zoomFactor = value;
        updateSize();
}

void TransferFunction::updateSize()
{
        updateScale();
        this->adjustSize();
}

void TransferFunction::initTransferfunction()
{
        if(transferFunction)
        {
                delete [] transferFunction;
        }
        transferFunction = new TransferColor[widthMax];
        
        unselectAllVertices();
        removeAllVertices();

        addVertex(0, QColor(255, 255, 255, 255));
        addVertex(scaledWidth, 0);
        movingVertex = vertices.begin();
        updateTransferfunction();
        
}

void TransferFunction::initHisto()
{
        if(normHistoVals)
        {
                delete [] normHistoVals;
        }
        normHistoVals = new unsigned int[widthMax];
        // fuer normScaledHistoVals soviel genausoviel Speicher reservieren
        normScaledHistoVals = new unsigned int[widthMax];

        const std::vector<unsigned int>* histoVals = volume->getHistogramm();

        double histoMaxValue = (double)volume->getHistHeight();
        double logBasis = log(pow(histoMaxValue + 1, 1.0/(double)height));
        //double invRootBasis = 1/(log(histoMaxValue)/log((double)height));

        for(int x = 0;x<widthMax;x++) 
        {       
                // linear
                double y2_lin = ((double)(*histoVals)[x]/histoMaxValue)*height;
                // logarithm
                double y2_log = log((double)(*histoVals)[x]+1)/logBasis;
                // root
                //double y2_root = pow((double)(*histoVals)[x], invRootBasis);
                //double ratio = sqrt((*histoVals)[x]/histoMaxValue);
                //double ratio = 0.3;
                double ratio = y2_log / height;
                normHistoVals[x] = height - (ratio*y2_log+(1-ratio)*y2_lin);
        }

        updateScale();
}

void TransferFunction::updateTransferfunction()
{
        IteratorVertices iter = vertices.begin(), iterPrev = iter;
        iter++;
        for(; iter != vertices.end(); iterPrev = iter, ++iter)
        {       
                int r1 = (*iterPrev)->color.red();
                int g1 = (*iterPrev)->color.green();
                int b1 = (*iterPrev)->color.blue();
                int r2 = (*iter)->color.red();
                int g2 = (*iter)->color.green();
                int b2 = (*iter)->color.blue();

                int x1 = (*iterPrev)->x;
                int y1 = 255-(*iterPrev)->color.alpha();
                int x2 = (*iter)->x;
                int y2 = 255-(*iter)->color.alpha();
                
                // Cubic Spline Interpolation: f(x) = a+b(x-x1)+c(x-x1)^2+d(x-x1)^3
                // a = f(x1); b = 0; c = 3(f(x2)-f(x1)); d = -2(f(x2)-f(x1))
                double a = y1;
                double c = 3.0*(y2-y1);
                double d = (-2)*(y2-y1);

                transferFunction[x1].r = (unsigned char)r1;
                transferFunction[x1].g = (unsigned char)g1;
                transferFunction[x1].b = (unsigned char)b1; 
                transferFunction[x1].a = (unsigned char)y1;
                for(int i=x1+1;i<x2;i++)
                {
                        double part = (i-x1)/((double)abs(x2-x1));
                        double xi = (i-x1)/((double)(x2-x1));
                        transferFunction[i].r = (unsigned char)floor((1.0-part)*r1 + part*r2 +0.5);
                        transferFunction[i].g = (unsigned char)floor((1.0-part)*g1 + part*g2 +0.5);
                        transferFunction[i].b = (unsigned char)floor((1.0-part)*b1 + part*b2 +0.5);
                        transferFunction[i].a = (unsigned char)floor((a+c*xi*xi+d*xi*xi*xi)+0.5);
                }
        }
        emit getTransferFunction((unsigned int*)transferFunction, widthMax);
}

void TransferFunction::paintEvent(QPaintEvent* event)
{
        if(volume!=0) {
                QPainter painter(this);
                
                
                painter.setPen(Qt::blue);
                //painter.translate(0, height());
                //painter.scale(100, 100);
                
                // draw histogramm as background
                for(int x = 0;x<scaledWidth;x++) 
                {                       
                        if(normScaledHistoVals[x] != height)
                        {
                                QColor color(transferFunction[(int)(x*scaleFactor)].r, 
                                                         transferFunction[(int)(x*scaleFactor)].g, 
                                                         transferFunction[(int)(x*scaleFactor)].b);
                                painter.setPen(color);
                                //  int x1, int y1, int x2, int y2
                                painter.drawLine(x, height, x, normScaledHistoVals[x]);
                        }
                }

                // draw vertices and line
                
                QPainterPath path;
                path.moveTo(0, (*vertices.begin())->color.alpha());

                IteratorVertices iter = vertices.begin(), iterPrev = iter;
                (*iter)->drawVertex(painter);
                iter++;
                for(; iter != vertices.end(); iterPrev = iter, ++iter)
                {
                        int y = (*iter)->color.alpha();
                        int x = (*iter)->xScaled;
                        int prevY = (*iterPrev)->color.alpha();
                        int prevX = (*iterPrev)->xScaled;
                        // path line part
                        path.cubicTo(prevX+(x-prevX)/2, prevY, x-(x-prevX)/2, y, x, y);

                        (*iter)->drawVertex(painter);                   
                }
                // draw line
                painter.setPen(QPen(QColor(0, 0, 0), 1, Qt::SolidLine, Qt::FlatCap, Qt::RoundJoin));
                painter.setBrush(Qt::NoBrush);
                painter.setRenderHint(QPainter::Antialiasing);
                painter.drawPath(path);
        }
}

void TransferFunction::Vertex::drawVertex(QPainter& painter)
{
        int alphaFill;
        QColor borderColor;

        if(selected) 
        {
                alphaFill = 255;
                borderColor = QColor(Qt::gray);
        } else
        {
                alphaFill = 100;
                borderColor = QColor(Qt::black);
        }                       

        QColor curColor = color;
        painter.setPen(borderColor);
        painter.setBrush(QBrush(QColor(curColor.red(), curColor.green(), curColor.blue(), alphaFill)));
        painter.drawRect(xScaled - Vertex::DRAW_SIZE/2, 
        color.alpha() - Vertex::DRAW_SIZE/2, Vertex::DRAW_SIZE, Vertex::DRAW_SIZE);
}

void TransferFunction::updateScale()
{

        scaledWidth = ((double)(widthMax - width())) / 1000.0 * zoomFactor + width();
        scaleFactor = ((double)widthMax)/((double)scaledWidth);
                
        for(int i=0;i<widthMax;i++)
        {
                normScaledHistoVals[i] = 0;
        }
        // update histogramm
        for(int x=0;x<widthMax;x++)
        {
                //qDebug() << "x= " << x;
                int targetIndex = (int)(floor((x/scaleFactor)+0.5));
                //qDebug() << "targetIndex = " << targetIndex;
                //qDebug() << "targetValue = " << normHistoVals[x];
                if(normScaledHistoVals[targetIndex] == 0) {
                        normScaledHistoVals[targetIndex] = normHistoVals[x];
                } else {
                        normScaledHistoVals[targetIndex] = (normScaledHistoVals[targetIndex] + normHistoVals[x])/2;
                }
        }
        // update vertices
        for(IteratorVertices iter = vertices.begin(); iter != vertices.end(); ++iter)
        {
                (*iter)->xScaled = (int)(floor(((*iter)->x/scaleFactor)+0.5));
        }
}



TransferFunction::Vertex* TransferFunction::newVertex(int xScaled, int alpha)
{
        return new Vertex((int)floor(xScaled*scaleFactor+0.5), xScaled, QColor(255, 255, 255, alpha));
}


TransferFunction::Vertex* TransferFunction::addVertex(int scaledX, int y)
{
        Vertex *v = new Vertex((int)floor(scaledX*scaleFactor+0.5), scaledX, QColor(255, 255, 255, y));
        if(!containsVertex(v))
        {
                this->vertices.insert(v);
                updateTransferfunction();
        }
        else
        {
                // TODO: Vertex already exists. 
        }
        return v;
}

TransferFunction::Vertex* TransferFunction::addVertex(int scaledX, QColor color)
{
        Vertex *v = new Vertex((int)floor(scaledX*scaleFactor+0.5), scaledX, color);
        if(!containsVertex(v))
        {
                this->vertices.insert(v);
                updateTransferfunction();
        }
        else
        {
                // TODO: Vertex already exists. 
        }
        return v;

}


void TransferFunction::addVertex(Vertex* v)
{
        v->x = ((int)floor(v->xScaled*scaleFactor+0.5));
        if(!containsVertex(v))
        {
                this->vertices.insert(v);
                updateTransferfunction();
        }
        else
        {
                // TODO: Vertex already exists. 
        }
}

void TransferFunction::removeVertex(Vertex* v)
{
        if(containsVertex(v) && v->xScaled != 0 && v->x != widthMax)
        {
                vertices.erase(v);
                delete v;
                movingVertex = vertices.begin();
                updateTransferfunction();
        }       
}

void TransferFunction::removeAllVertices()
{
        for(IteratorVertices iter = vertices.begin(); iter!=vertices.end(); ++iter)
        {
                delete (*iter);
        }
        vertices.clear();
}

bool TransferFunction::containsVertex(Vertex *v)
{
        return vertices.find(v) != vertices.end();
}

TransferFunction::IteratorVertices TransferFunction::containsNearVertex(Vertex *v)
{
        IteratorVertices iterNext = vertices.lower_bound(v);
        int margin = floor(Vertex::DRAW_SIZE/2+0.5)+2;
        
        if(((*iterNext)->xScaled - margin) <= v->xScaled)
        {
                int y1 = v->color.alpha();
                int y2 = (*iterNext)->color.alpha();
                if(((y2+margin) >= y1) && (y2-margin-1 <= y1))
                {
                        return iterNext;
                }
        } 
        iterNext--;
        if(((*iterNext)->xScaled + margin+1) >= v->xScaled)
        {
                int y1 = v->color.alpha();
                int y2 = (*iterNext)->color.alpha();
                if(((y2+margin) >= y1) && (y2-margin <= y1))
                {
                        return iterNext;
                }
        }
        return IteratorVertices();

}
 
void TransferFunction::unselectAllVertices()
{
        for(IteratorVertices iter = selectedVertices.begin(); iter!=selectedVertices.end(); ++iter)
        {
                (*iter)->selected = false;
        }
        selectedVertices.clear();
}

void TransferFunction::unselect(Vertex* v)
{
        if(v->selected)
        {
                v->selected = false;
                selectedVertices.erase(v);
        }
}

void TransferFunction::select(Vertex *v)
{
        selectedVertices.insert(v);
        v->selected = true;
}

TransferFunction::Vertex::Vertex()
{       
        selected = false;
}

TransferFunction::Vertex::Vertex(int x, int xScaled, QColor color)
{
        this->x = x;
        this->xScaled = xScaled;
        this->color = color;
        selected = false;
}

void TransferFunction::Vertex::setPos(int x, int xScaled, int y)
{
        this->x = x;
        this->xScaled = xScaled;
        this->color.setAlpha(y);
}

TransferFunction::Vertex::~Vertex()
{
}

---