G:/src/TransferFunktion.cpp

Go to the documentation of this file.

#include "TransferFunktion.h"
#include <glew.h>
#include <openglut.h>
#include <math.h>

TransferFunktion::TransferFunktion()
{ 
        renderListBackGround=glGenLists(1);
        renderListData=glGenLists(1);
        width =500;
        height =300;
        maxDichte =4096;
        leftBorder=10;
        rightBorder=10;
        upBorder=10;
        downBorder=10;
        background= new Color(200,200,200,255);
        xPos=0;
        yPos=0;
        selectRange=10;
        hist=NULL;

        TransferFunktionPunkt* punkt;
        punkte = new std::list<TransferFunktionPunkt*>();

        punkt=new TransferFunktionPunkt();
        punkt->setColor(new Color(0,0,0,127));
        punkte->push_back(punkt);

        punkt=new TransferFunktionPunkt();
        punkt->setColor(new Color(255,255,255,127));
        punkt->setDichte(maxDichte);
        punkte->push_back(punkt);

        punkte->sort(TransferFunktionPunkt::compare);
        dataChanged=true;
        visDataChanged=true;
        visBackChanged=true;

}
bool TransferFunktion::isInFunktionArea(int x, int y,float borderRatio)
{
        bool xpart = x>(xPos+(borderRatio*leftBorder)) && x<(xPos+width-(borderRatio*rightBorder));
        bool ypart = y>(yPos+(borderRatio*upBorder)) && y<(yPos+height-(borderRatio*downBorder));

        return xpart&&ypart;
}
unsigned char TransferFunktion::getAlfa(int y)
{
        float funktionHeight = (float)(height-(upBorder+downBorder));
        float relativeY = (float)(y-(yPos+upBorder));
        return (unsigned char)(255-(relativeY/funktionHeight)*255);
}
int TransferFunktion::getDichte(int x)
{
        float funktionWidth = (float)(width-(leftBorder+rightBorder));
        float relativeX = (float)(x-(xPos+leftBorder));
        return (int)((relativeX/funktionWidth)*maxDichte);
}
int TransferFunktion::getX(int dichte)
{
        return (int)((((float)dichte/maxDichte)*(width-(leftBorder+rightBorder)))+(xPos+leftBorder));
}
int TransferFunktion::getY(unsigned char alfa)
{
        return (int)((((float)(255-alfa)/255)*(height-(upBorder+downBorder)))+(yPos+upBorder));
}
void TransferFunktion::sortList()
{
        punkte->sort(TransferFunktionPunkt::compare);
}
TransferFunktionPunkt* TransferFunktion::addPunkt(int x, int y)
{
        dataChanged=true;
        visDataChanged=true;
        std::list<TransferFunktionPunkt*>::iterator it;
        TransferFunktionPunkt * lastPunkt;
        TransferFunktionPunkt * newPunkt =NULL;
        int dichte;
        unsigned char alfa;
        if(isInFunktionArea(x,y,1))
        {

                dichte = getDichte(x);
                alfa = getAlfa(yPos+height/2);

                for (it=punkte->begin(); it!=punkte->end(); ++it)
                {        
                        if((*it)->getDichte()>dichte)
                        {
                                newPunkt = new TransferFunktionPunkt(lastPunkt,(*it),dichte,alfa);
                                punkte->insert(it,newPunkt);
                                return newPunkt;
                        }
                        lastPunkt=(*it);
                }
        }
        return NULL;
}
TransferFunktionPunkt* TransferFunktion::getPunkt(int x, int y, bool firstPunkt)
{
        std::list<TransferFunktionPunkt*>::iterator it=punkte->begin();
        int xPunktPos;
        int yPunktPos;
        int distance;
        if (!firstPunkt) it++;

        for (; it!=punkte->end(); ++it)
        {        
                yPunktPos=getY((*it)->getAlfa());
                xPunktPos=getX((*it)->getDichte());

                distance=(abs(x-xPunktPos)+abs(y-yPunktPos));
                if(distance<=selectRange)
                {
                        return(*it);
                }
        }
        return NULL;
}
TransferFunktionPunkt* TransferFunktion::updatePunkt(TransferFunktionPunkt* punkt,int x, int y)
{
        dataChanged=true;
        visDataChanged=true;
        if(punkt==punkte->back() || punkt==punkte->front())
        {
                y=yPos+height/2;//std::min(std::max(y,yPos+upBorder),yPos+height-downBorder);
                punkt->setAlfa(getAlfa(y));     
                return punkt;
        }

        //make values outside the window valid negative numbers
        if (x > 60000) x -= 65535;
        if (y > 60000) y -= 65535;

        if(!isInFunktionArea(x,y,-2))
        {
                punkte->remove(punkt);
                return NULL;
        }

        x=std::min(std::max(x,xPos+leftBorder),xPos+width-rightBorder);
        y=yPos+height/2;//std::min(std::max(y,yPos+upBorder),yPos+height-downBorder);
        punkt->setAlfa(getAlfa(y));
        punkt->setDichte(getDichte(x));
        sortList();
        return punkt;
}
bool TransferFunktion::setColor(int x,int y)
{
        TransferFunktionPunkt* punkt = getPunkt(x,y, true);
        if(punkt!=NULL)
        {
                punkt->setColor();
                dataChanged=true;
                visDataChanged=true;
                return true;
        }
        return false;
}
void TransferFunktion::reshape(int width, int height)
{
        visDataChanged=true;
        visBackChanged=true;
        this->width=width;
        this->height=55;
}
void TransferFunktion::setPosition(int xpos, int ypos)
{
        visDataChanged=true;
        visBackChanged=true;
        this->xPos=xpos;
        this->yPos=ypos;
}
void TransferFunktion::setHist(std::vector<int>* hist)
{
        visBackChanged=true;
        this->hist=hist;
}
float * TransferFunktion::getTransferFunktionLookUP(float* lookUp)
{
        if(!dataChanged)
        {
                return lookUp;
        }
        dataChanged=false;
        delete lookUp;
        lookUp = new float[(maxDichte+1)*4];
        std::list<TransferFunktionPunkt*>::iterator it;
        TransferFunktionPunkt * punkt1 =punkte->front();
        TransferFunktionPunkt * punkt2;
        Color* color1;
        Color* color2;
        float deltaR;
        float deltaG;
        float deltaB;
        float deltaA;
        float red;
        float green;
        float blue;
        float alfa;
        int deltaD;
        int dichte=0;
        for (it=++(punkte->begin()); it!=punkte->end(); ++it)
        {       
                punkt2 =(*it);

                deltaD =(punkt2->getDichte()-punkt1->getDichte());
                dichte=punkt1->getDichte();
                if(deltaD>0)
                {
                        color1=punkt1->getColor();
                        color2=punkt2->getColor();
                        deltaR = (color2->GetNormalizedRed()-color1->GetNormalizedRed())/deltaD;
                        deltaG = (color2->GetNormalizedGreen()-color1->GetNormalizedGreen())/deltaD;
                        deltaB = (color2->GetNormalizedBlue()-color1->GetNormalizedBlue())/deltaD;
                        deltaA = (color2->GetNormalizedAlpha()-color1->GetNormalizedAlpha())/deltaD;

                        red = (float)color1->GetNormalizedRed();
                        green= (float)color1->GetNormalizedGreen();
                        blue= (float)color1->GetNormalizedBlue();
                        alfa= (float)color1->GetNormalizedAlpha();

                        for(int i=0; i<deltaD;i++)
                        {
                                lookUp[(i+dichte)*4]=(red+(deltaR*i));
                                lookUp[(i+dichte)*4+1]=(green+(deltaG*i));
                                lookUp[(i+dichte)*4+2]=(blue+(deltaB*i));
                                lookUp[(i+dichte)*4+3]=(alfa+(deltaA*i));
                        }
                }
                punkt1=punkt2;
        }
        return lookUp;
}
int TransferFunktion::genderateRenderListBack()
{

        if(!visBackChanged)
        {
                return renderListBackGround;
        }
        visBackChanged =false;
        std::vector<int>::iterator histIt;

        TransferFunktionPunkt * punkt1 =punkte->front();
        int x;
        int y;
        int i=0;
        int lastX=0;
        int sumHist=0;
        int max=0;
        int activeWidth=width-(leftBorder+rightBorder);
        float histBucketWidth=(float)maxDichte/activeWidth;
        int actualHistBucket=0;

        glNewList (renderListBackGround, GL_COMPILE);

        //glBegin (GL_QUADS);
        //glColor4f(background->GetNormalizedRed(),background->GetNormalizedGreen(),background->GetNormalizedBlue(),background->GetNormalizedAlpha());
        //glVertex2i(xPos,yPos);
        //glVertex2i(xPos+width,yPos);
        //glVertex2i(xPos+width,yPos+height);
        //glVertex2i(xPos,yPos+height);
        //glColor4f(1.0,1.0,1.0,1.0);
        //glTexCoord2f(0.0f, 0.0f);                                                                                                                                     glVertex2i(xPos+leftBorder-1,yPos+upBorder-1);
        //glTexCoord2f(0.0f, (float)(height-(upBorder+downBorder))/20);                                                                 glVertex2i(xPos+leftBorder-1,yPos+height-downBorder+1);
        //glTexCoord2f((float)(width-(rightBorder+leftBorder))/20, (float)(height-(upBorder+downBorder))/20);   glVertex2i(xPos+width-rightBorder+1,yPos+height-downBorder+1); 
        //glTexCoord2f((float)(width-(rightBorder+leftBorder))/20, 0.0f);                                                                       glVertex2i(xPos+width-rightBorder+1,yPos+upBorder-1); 
        //glEnd();

        
        
        //if(hist!=NULL)
        //{
        //      i=0;
        //      actualHistBucket=0;
        //      sumHist=0;
        //      for (histIt=hist->begin(); histIt!=hist->end(); ++histIt)
        //      {
        //              if(histBucketWidth*(actualHistBucket+1)>i)
        //              {
        //                      sumHist+= (*histIt);
        //              }
        //              else
        //              {
        //                      sumHist+=(histBucketWidth*(actualHistBucket+1)-(i-1))*(*histIt);
        //                      max=std::max(max,sumHist);
        //                      actualHistBucket++;
        //                      sumHist=((float)i-(histBucketWidth*(actualHistBucket)))*(*histIt);
        //              }
        //              i++;

        //      }
        //      i=0;
        //      actualHistBucket=0;
        //      sumHist=0;
        //      double maxPow=pow(1.05,255.0);
        //      double log1050m =log(1.05);
        //      for (histIt=hist->begin(); histIt!=hist->end(); ++histIt)
        //      {

        //              if(histBucketWidth*(actualHistBucket+1)>i)
        //              {
        //                      sumHist+= (*histIt);
        //              }
        //              else
        //              {
        //                      sumHist+=(histBucketWidth*(actualHistBucket+1)-(i-1))*(*histIt);
        //                      if(sumHist!=0)
        //                      {
        //                              glColor4f(0.4f,0.4f,0.4f,1.0f);
        //                              y=(int)std::max(log(maxPow*sumHist/max)/log1050m,0.0);
        //                              glVertex2i(actualHistBucket+xPos+leftBorder,getY(std::max(y-10,0)));
        //                              glVertex2i(actualHistBucket+xPos+leftBorder,getY(y));

        //                              y=sumHist*255/max;
        //                              glColor4f(0.2f,0.2f,0.2f,1.0f);
        //                              glVertex2i(actualHistBucket+xPos+leftBorder,getY(0));
        //                              glVertex2i(actualHistBucket+xPos+leftBorder,getY(y));
        //                      }
        //                      actualHistBucket++;
        //                      sumHist=((float)i-(histBucketWidth*(actualHistBucket)))*(*histIt);
        //              }
        //              i++;

        //      }
        //}
        glColor4f(0.0,0.0,0.0,1.0);
        glBegin (GL_POLYGON);
        glVertex2i (xPos+leftBorder-1,yPos+upBorder-1);
        //glVertex2i (xPos+leftBorder,yPos+height-downBorder+1);

        glVertex2i (xPos+leftBorder-1,yPos+height-downBorder+1);
        //glVertex2i (xPos+width-rightBorder+1,yPos+height-downBorder+1);

        glVertex2i (xPos+width-rightBorder+1,yPos+height-downBorder+1);
        //glVertex2i (xPos+width-rightBorder+1,yPos+upBorder);

        glVertex2i (xPos+width-rightBorder+1,yPos+upBorder-1);
        //glVertex2i (xPos+leftBorder,yPos+upBorder);
        glEnd();

        glEndList();

        return renderListBackGround;
}
int TransferFunktion::genderateRenderListFront()
{
        if(!visDataChanged)
        {
                return renderListData;
        }
        visDataChanged =false;
        std::list<TransferFunktionPunkt*>::iterator it;

        TransferFunktionPunkt * punkt1 =punkte->front();
        TransferFunktionPunkt * punkt2;
        Color* color1;
        Color* color2;
        int x;
        int y;
        int oldX;
        int oldY;

        glNewList (renderListData, GL_COMPILE);

                glBegin (GL_LINES);

        punkt1 =punkte->front();
        oldX= getX((punkt1)->getDichte());
        oldY= getY((punkt1)->getAlfa());
        glColor4f(0.0,0.0,0.0,1.0);

        for (it=++punkte->begin(); it!=punkte->end(); ++it)
        {

                x= getX((*it)->getDichte());
                y= getY((*it)->getAlfa());

                glVertex2i (x,y);
                glVertex2i (oldX,oldY);

                oldX=x;
                oldY=y;

        }

        glEnd();

        glBegin (GL_QUADS);

        //FunktionsWerte
        for (it=++(punkte->begin()); it!=punkte->end(); ++it)
        {       
                punkt2 =(*it);
                color1=punkt1->getColor();
                color2=punkt2->getColor();
                glColor4f(color1->GetNormalizedRed(),color1->GetNormalizedGreen(),color1->GetNormalizedBlue(),1.0);
                //glColor4f(color1->GetNormalizedRed(),color1->GetNormalizedGreen(),color1->GetNormalizedBlue(),0.0);
                glVertex2i(getX(punkt1->getDichte()),getY(0));
                glVertex2i(getX(punkt1->getDichte()),getY(255));
                glColor4f(color2->GetNormalizedRed(),color2->GetNormalizedGreen(),color2->GetNormalizedBlue(),1.0);
                glVertex2i(getX(punkt2->getDichte()),getY(255));
                //glColor4f(color2->GetNormalizedRed(),color2->GetNormalizedGreen(),color2->GetNormalizedBlue(),0.0);
                glVertex2i(getX(punkt2->getDichte()),getY(0));

                punkt1=punkt2;
        }

        glEnd();
        it=(punkte->end());
        do
        {       
                glBegin(GL_QUADS);
                it--;
                color1=(*it)->getColor();
                glColor4f((float)color1->GetNormalizedRed(),(float)color1->GetNormalizedGreen(),(float)color1->GetNormalizedBlue(),0.7f);
                x= getX((*it)->getDichte());
                y= getY((*it)->getAlfa());
                glVertex2i (x-selectRange,y);
                glVertex2i (x,y+selectRange);
                glVertex2i (x+selectRange,y);
                glVertex2i (x,y-selectRange);

                glEnd();
                glBegin (GL_LINES);

                glColor4f(1.0-(*it)->getColor()->GetNormalizedRed(),1.0-(*it)->getColor()->GetNormalizedGreen(),1.0-(*it)->getColor()->GetNormalizedBlue(),1.0);

                glVertex2i (x-selectRange,y);
                glVertex2i (x,y+selectRange);

                glVertex2i (x,y+selectRange);
                glVertex2i (x+selectRange,y);

                glVertex2i (x+selectRange,y);
                glVertex2i (x,y-selectRange);

                glVertex2i (x,y-selectRange);
                glVertex2i (x-selectRange,y);

                glEnd();


        }while(it!=(punkte->begin()));



        glEndList();

        return renderListData;
}
void TransferFunktion::loadPunkte(const std::string & strFilename)
{
        std::cout << "- Loading file '" << strFilename << "' ... " << std::endl;
        FILE *fp = NULL;

        fopen_s(&fp,strFilename.c_str(),"rb");

        if (!fp)
        {
                std::cerr << "+ Error loading file." << std::endl << std::endl;
        }
        else
        {

                unsigned short size;
                unsigned char alfa;
                unsigned char red;
                unsigned char green;
                unsigned char blue;
                int dichte;
                TransferFunktionPunkt *punkt;

                fread(&size,sizeof(unsigned short),1,fp);

                punkte->clear();
                for( int i=0; i<size; i++)
                {
                        fread(&alfa,sizeof(unsigned char),1,fp);
                        fread(&red,sizeof(unsigned char),1,fp);
                        fread(&green,sizeof(unsigned char),1,fp);
                        fread(&blue,sizeof(unsigned char),1,fp);
                        fread(&dichte,sizeof(int),1,fp);
                        punkt=new TransferFunktionPunkt();
                        punkt->setColor(new Color(red,green,blue,alfa));
                        punkt->setDichte(dichte);
                        punkte->push_back(punkt);
                }
                fclose(fp);
                punkte->sort(TransferFunktionPunkt::compare);

                std::cout << "File '" << strFilename << "' loaded!" << std::endl;
        }

        this->visDataChanged=true;
        this->dataChanged=true;
}
void TransferFunktion::savePunkte(const std::string & strFilename)
{
        std::cout << "- Saving file '" << strFilename << "' ... " << std::endl;
        FILE *fp = NULL;

        fopen_s(&fp,strFilename.c_str(),"wb");

        if (!fp)
        {
                std::cerr << "+ Error saving file." << std::endl << std::endl;
        }
        else
        {

                std::list<TransferFunktionPunkt*>::iterator it;
                unsigned short size = punkte->size();
                unsigned char alfa;
                unsigned char red;
                unsigned char green;
                unsigned char blue;
                int dichte;
                Color *color;

                fwrite(&size,sizeof(unsigned short),1,fp);

                for (it=(punkte->begin()); it!=punkte->end(); ++it)
                {
                        color=(*it)->getColor();
                        red = color->GetRed();
                        green = color->GetGreen();
                        blue = color->GetBlue();
                        alfa = color->GetAlpha();
                        dichte=(*it)->getDichte();
                        fwrite(&alfa,sizeof(unsigned char),1,fp);
                        fwrite(&red,sizeof(unsigned char),1,fp);
                        fwrite(&green,sizeof(unsigned char),1,fp);
                        fwrite(&blue,sizeof(unsigned char),1,fp);
                        fwrite(&dichte,sizeof(int),1,fp);
                }
                
                fclose(fp);

                std::cout << "File '" << strFilename << "' saved!" << std::endl;
        }
}

---