Eigene Dateien/Vis/src/VTransferFunction.h

Go to the documentation of this file.

#pragma once

#ifndef __v_transfer_function_h
#define __v_transfer_function_h

#include <map>
#include <vector>

#include "VVector.h"
#include "VFramebufferObject.h"

class QVolRendCanvas;

struct vTransferFunctionPoint
{
        vTransferFunctionPoint() : m_Color(), m_Alpha(1.0f)
        {

        }

        VVector m_Color;        
        float m_Alpha;          
};

class VTransferFunction
{
public:

        VTransferFunction() :   m_VolumeHistogram(0), 
                                                        m_VolumeHistogramDisplayList(0), 
                                                        m_hasChanged(true), 
                                                        bigzoom(true),
                                                        m_TransferFunctionHandle(0), 
                                                        m_FramebufferObject(NULL)
        {
                
        }

        ~VTransferFunction();

        void draw1d();

        void setHistogram(std::vector<int> * volumeHistogram)
        {
                this->clear();
                m_VolumeHistogram = volumeHistogram;
                generateDisplayList();
        }

        void setZoomPoint(bool zoom_active, float x, bool bigcanvas)
        {
                zoom_ptx = x;
                m_zoom_active = zoom_active;
                bigzoom = !bigcanvas;

        }

        float getAlpha(int index)
        {
                return m_FuncControlPoints[index].m_Alpha;
        }


        void addTransferFunctionPoint(int density, vTransferFunctionPoint newPoint);

        int transferFunctionPointInRange(int selectedDensity, float alpha, int range)
        {
                int searchStart;
                int searchEnd;
                if(selectedDensity - range < 0)
                {
                        searchStart = 0;
                }
                else
                {
                        searchStart = selectedDensity - range;
                }
                if((selectedDensity + range) > 4095)
                {
                        searchEnd = 4095;
                }
                else 
                {
                        searchEnd = selectedDensity + range;
                }

                float a_range = 5.0f*(float)range/4095.0f;
                alpha = (alpha+0.8f)/1.8f;
                alpha = (alpha-a_range < 0.0f) ? 0.0f :alpha;
                alpha = (alpha+a_range > 1.0f) ? 1.0f :alpha;

                int position = selectedDensity;
                int upperbound  = max( (searchEnd - position), (position - searchStart));
                for(int i = 0; i <= upperbound; i++)
                {
                        position = selectedDensity - i;

                        if( position >= searchStart && 
                                m_FuncControlPoints.find( position ) != m_FuncControlPoints.end() && 
                                abs( m_FuncControlPoints[ position ].m_Alpha - alpha) < a_range )
                        {
                                return position;
                                
                        }

                        position = selectedDensity + i;

                        if( position >= searchStart && 
                                m_FuncControlPoints.find(position) != m_FuncControlPoints.end() &&
                                abs(m_FuncControlPoints[position].m_Alpha - alpha) < a_range )
                        {
                                return position;
                        }
                }

                

                
                return -1;
        }

        vTransferFunctionPoint getTransferFunctionPoint(int density)
        {
                return m_FuncControlPoints[density];
        }

        void removeTransferFunctionPoint(int density);

        std::vector<vTransferFunctionPoint> getFullTransferFunction()
        {
                if(m_hasChanged)
                {
                        this->interpolateTransferPoints();
                }
                return m_TransferFunction;
        }

        unsigned int getGLHandle()
        {
                if(m_hasChanged)
                {
                        this->interpolateTransferPoints();
                }
                return m_FramebufferObject->getTextureHandle();
                //return m_TransferFunctionHandle;
        }

        void setMainCanvas(QVolRendCanvas * maincanvas)
        {
                m_MainCanvas = maincanvas;
        }

        void setMaxHist(float val)
        {
                m_maxdensity = val;
        }
        
        bool load(std::string filename);

        bool save(std::string filename);

        void clear()
        {
                m_FuncControlPoints.clear();
                m_TransferFunction.clear();
                m_TransferFunctionHandle = 0;
                m_hasChanged =  true;
        }

private:
        
        void generateDisplayList();
        void generateDisplayList2D();

        void interpolateTransferPoints();

        double round(double Zahl, int Stellen)
        {
                double v[] = { 1, 10, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8 };  // mgl. verlängern
                return floor(Zahl * v[Stellen] + 0.5) / v[Stellen];
        }

        std::map<int, vTransferFunctionPoint> m_FuncControlPoints;      
        std::vector<vTransferFunctionPoint> m_TransferFunction;                 
        std::vector<int> * m_VolumeHistogram;                                                   
        unsigned int m_VolumeHistogramDisplayList;                                              
        unsigned int m_TransferFunctionHandle;                                                  
        bool m_hasChanged;                                                                                              
        QVolRendCanvas * m_MainCanvas;                                                                  
        float m_maxdensity;                                                                                             
        VFramebufferObject * m_FramebufferObject;                                               
        float zoom_ptx;                                                                                                 
        bool m_zoom_active;                                                                                             
        bool bigzoom;                                                                                                   
};

#endif //__v_transfer_function_h

---