Eigene Dateien/FlowVis/src/QVolRendCanvas.h

Go to the documentation of this file.

#ifndef QVOLRENDCANVAS_H_
#define QVOLRENDCANVAS_H_

#include <Qt/qobject.h>

#include <QtGui/QWidget>
#include <QtOpenGL/QGLWidget>
#include <QtGui/QKeyEvent>
#include <QtGui/QMouseEvent>

#include "VEvent.h"
#include "VTransferFunction.h"
#include "VImage.h"

#include "VFlowData.h"
#include "VFlowRenderer.h"

class VFramebufferObject;

enum MouseState
{
        NO_DRAGGING = 0,                
        ROTATE,                                 
        ZOOM,                                   
        PAN,                                    
};


class QVolRendCanvas : public QObject, public QGLWidget
{
        Q_OBJECT

public:

        QVolRendCanvas(QWidget* parent = 0);
        
        virtual ~QVolRendCanvas();

        void setObjectName(const QString &name);

        float getNumTimeSteps()
        {
                
                return m_FlowData.getNumTimeSteps();
        }

        float getNumDataValues()
        {
                
                return m_FlowData.getNumDataValues();
        }

        float getFlowDataMin()
        {
        
                return m_FlowRenderer.getFlowDataMin(  );
        }

        float getFlowDataMax()
        {
        
                return m_FlowRenderer.getFlowDataMax(  );
        }

        void timestep_changed_event( int val );

        void coloringproperty_changed_event( int val );

        void arrowscale_valuechanged(int val);

        void iconscale_valuechanged(int val);

        void icontail_valuechanged(int val);

        void arrowspacing_valuechanged(int val);

        void arrowalpha_changed_event(float val);

        void salpha_changed_event(float val);

        void licalpha_changed_event(float val);

        void licsteps_changed_event(int val);

        void licstepsize_changed_event(int val);

        void dsep_valuechanged(int val);

        void dtest_valuechanged(int val);

        void steps_valuechanged(int val);

        void dt_valuechanged(int val);

        void setGlyph( bool val );

    virtual void resizeGL( int w, int h );

        virtual void paintEvent( QPaintEvent *e );

        virtual void mousePressEvent ( QMouseEvent * e );

        virtual void mouseReleaseEvent ( QMouseEvent * e );

        virtual void mouseMoveEvent ( QMouseEvent * e );


        virtual void mouseDoubleClickEvent ( QMouseEvent * e );


        virtual void keyPressEvent ( QKeyEvent * e );


        virtual void keyReleaseEvent ( QKeyEvent * e );

        const VMouseEvent getMouseEvent (QMouseEvent *e);

        const VKeyboardEvent getKeyboardEvent (QKeyEvent *e);

        virtual void redraw();

        void setStreamlinesColorPtr(VVector *v);

        void setArrowsColorPtr(VVector *v);

        void setArrowplotState( bool state )
        {
                arrows_activated = state;
        }

        void setLicplotState( bool state )
        {
                lic_activated = state;
        }

        void enableIcons( bool state )
        {
                m_EnableIconSetting = state;
                if ( state ) m_FlowData.computeIcons(  );
        }

        void setTaperingState( bool state )
        {
                tapering_activated = state;
                m_FlowData.setTaperingState( state );
        }

        void setStrGlyphes( bool state )
        {
                //tapering_activated = state;
                m_FlowData.setStrGlyphes( state );
                m_FlowRenderer.setStrGlyphes( state );
        }

        void setTaperingScale( float val )
        {
                m_FlowData.setTaperingScale( val );
        }

        void setStreamlinesState( bool state )
        {
                streamlines_activated = state;
        }

        void setArrowScaleModus( bool state)
        {
                m_FlowRenderer.setArrowScaleMode( state );
        }

        

        void setIntegrationMethod( bool state)
        {
                m_FlowData.setIntegrationMethod( state );
        }
        
        void computeStreamlines(  )
        {
                if ( ! streamlines_activated ) return;

                //m_FlowData.generateStreamLines( mStremSteps, mStreamSpacing, timestep_activated - 1 /*this a poitner index*/ );
                repaint();
        }
        
        void computeCPUStreamlines(  )
        {
                if ( ! streamlines_activated ) return;

                m_FlowData.generateCPUStreamLines( mStremSteps, mStreamSeedSpacing, timestep_activated - 1 /*this a poitner index*/ );
                repaint();
        }


        void setPlacingMethod(int val)
        {
                m_FlowData.setPlacingMethod( val );

                if ( m_FlowData.isIndexOfManualPlacingMethod( val ) ) 
                {
                        m_EnableSeedpointsSetting = true;
                        m_EnableEvenSeedpointsSetting = false;
                        setCursor(QCursor(Qt::CursorShape::CrossCursor));
                }
                else if( m_FlowData.isIndexOfEvenPlacingMethod ( val ) )
                {
                        m_EnableEvenSeedpointsSetting = true;
                        m_EnableSeedpointsSetting = false;
                        setCursor(QCursor(Qt::CursorShape::CrossCursor));
                        
                }
                else
                {
                        m_EnableSeedpointsSetting = false;
                        m_EnableEvenSeedpointsSetting = false;
                        setCursor(QCursor(Qt::CursorShape::OpenHandCursor));
                }

                repaint();
        }

        bool getLoaded(){return data_loaded;};

        void setTransferFunctionPtr(VTransferFunction * transfunc);

        void setArrowTransferFunctionPtr(VTransferFunction * transfunc);

        void setArrowTF(bool val);

        void setLicTF(bool val);

        void animateLic(bool val);

        void setStrTF(bool val);


        void setStreamLineTransferFunctionPtr(VTransferFunction * transfunc);

        void setLicTransferFunctionPtr(VTransferFunction * transfunc);


        void modifyLight(bool val);


        virtual bool load_data(QString filename, int *volsize);

        virtual bool load_single_data(QString filename, QString datfilename);

        bool save_data(std::string filename);

        virtual void saveImage(std::string filename);

        virtual void saveBigImage(std::string filename);

        virtual void saveStreamLines(std::string filename);

        virtual void loadStreamLines(std::string filename);

        void setOrthoProjection(bool m_orth);   
        
        VTransferFunction * m_TransferFunction;         
        VTransferFunction * m_ArrowTransferFunction;    
        VTransferFunction * m_StreamLineTransferFunction;       
        VTransferFunction * m_LicTransferFunction;                      
        float m_bgColor[4];                                                     
        VVector up;                                                                     
        VVector view;                                                           
        VVector side;                                                           
        VVector lup;                                                            
        VVector lview;                                                          
        VVector lside;                                                          
        VVector m_lightDir;                                                     
        bool m_modifyLight;                                                     
        VImage testImage;                                                       
protected:

        virtual void initializeGL();

        virtual void paintGL();


private:

        VVector getSphereProjection(float x, float y);

        VVector getPlaneProjection(float x, float y);

        void computeGlyphs();

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


        bool sliceview_active;                                  
        bool data_loaded;                                               
        int apply_tf_in_sv;                                             
        int apply_tf_in_vv;                                             
        VFramebufferObject * m_FramebufferObject;       
        VVector *m_ArrowsColor;                                 
        VVector *m_StreamlinesColor;                    
        VVector m_MouseLastPos;                                 
        MouseState m_MouseState;                                
        VVector m_CamDat;                                               
        VVector m_LookAtPoint;                                  
        VVector m_Position;                                             
        VVector m_LookAt;                                               
        float m_Distance;                                               
        VVector m_vecPosition;                                  
        VVector m_PanOffset;                                    
        VVector m_Rotation;                                             
        float m_fAngle;                                                 
        bool m_EnableSeedpointsSetting;                 
        bool m_EnableEvenSeedpointsSetting;             
        VFramebufferObject * m_SaveImageFBO;
        bool m_IsSaving;
        std::string m_SaveFileName;

        VFlowData m_FlowData;
        VFlowRenderer m_FlowRenderer;

        float mArrowSize;
        float mArrowSpacing;
        float mStreamSeedSpacing;
        float mStreamTestSpacing;
        float mStremSteps;
        float mStreamDT;

        //relevant to GUI
        bool arrows_activated;                                  
        bool streamlines_activated;                             
        int timestep_activated;                                 
        int coloring_property;                                  
        bool lic_activated;                                             
        bool tapering_activated;                                
        float m_EnableIconSetting;                              
};
#endif

---