mitkCUDAValueBasedStateVRScene.h

/*=========================================================================

  Program:   3DMed
  Date:      $Date: 2014-02-25 18:30:00 +0800 $
  Version:   $Version: 4.6.0 $
  Copyright: MIPG, Institute of Automation, Chinese Academy of Sciences

=========================================================================*/

#ifndef __mitkCUDAValueBasedStateVRScene_h
#define __mitkCUDAValueBasedStateVRScene_h

#include "mitkRCPtr.h"
#include "mitkVis2Scene3D.h"
#include "mitkCUDAVolumeRenderingIncludes.h"

#include "modules/StateRayCaster/mitkCUDAValueBasedStateVR.h"
#include "modules/StateRayCaster/mitkCUDAValueBasedBackwardsTest.h"
#include "modules/mitkCUDASegmentedVolumeLut.h"

#include "mitkICVolume.h"
#include "mitkRGBATransferFunction1D.h"

#include "mitkPerformanceCounter.h"

class mitkSegmentedVolumeLut;

class MITK_CUDA_VOLUME_RENDERING_API mitkCUDAValueBasedStateVRScene : public mitkVis2Scene3D
{
public:
    MITK_TYPE(mitkCUDAValueBasedStateVRScene,mitkVis2Scene3D)
    mitkCUDAValueBasedStateVRScene();

    virtual void RenderGL();

    void SetData(mitkICVolume *data);

    void SetDataModified();

    void SetBackGroundColor(float r,float g, float b);

    void GetBackGroundColor(float &r,float &g, float &b);

    void SetMaxLayer(int maxLayer);

    int GetMaxLayer();

    void SetStateController(int id, int less_more, float value);

    void GetStateController(int id, int &less_more, float &value);

    void SetThicknessThreshold(float thincknessThresh);

    float GetThicknessThreshold();

    mitkRGBATransferFunction1D* GetTransferFunction(int index);

    void SetTransferFunction(int index, mitkRGBATransferFunction1D* tf);

    void SetStdSampleDistance(float stdSampleDistance);

    float GetStdSampleDistance();

    void SetShade(bool shade);
    
    bool GetShade();

    void ShadeOn();
    
    void ShadeOff();

    void SetLightDirection(float x,float y,float z);
    
    void GetLightDirection(float &x,float &y,float &z);

    void SetLightIntensity(float intensity);
    
    void SetLightColor(float r,float g,float b);

    void SetAmbient(float value);
    
    float GetAmbient();

    void SetDiffuse(float value);
    
    float GetDiffuse();

    void SetSpecular(float value);
    
    float GetSpecular();

    void SetSpecularPower(float value);
    
    float GetSpecularPower();

    void RotateLightDirection(bool turnOn);

    virtual void OnMouseDown(int mouseButton, bool ctrlDown, bool shiftDown, int xPos, int yPos);
    virtual void OnMouseUp(int mouseButton, bool ctrlDown, bool shiftDown, int xPos, int yPos);
    virtual void OnMouseMove(bool ctrlDown, bool shiftDown, int xPos, int yPos);

    void SetIllustrativeShading(int illustrative);

    bool GetIllustrativeShading();

    void SetLayerShadingMode(int layer, ShadingMode mode);

    void SetCroppingBounds(const float CroppingBounds[6]);

    void GetCroppingBounds(float CroppingBounds[6]);

    void SetBackwardsTest(bool test) { m_BackwardsTest=test; }

    bool GetBackwardsTest() { return m_BackwardsTest; }

    mitkCUDAValueBasedStateVR& GetKernelModule() { return m_module; }


protected:
    virtual ~mitkCUDAValueBasedStateVRScene();
    virtual void GetSize3D(float size[3]);

private:
    mitkCUDAValueBasedStateVRScene(const mitkCUDAValueBasedStateVRScene&);
    void operator = (const mitkCUDAValueBasedStateVRScene&);

private:
    mitkRCPtr<mitkICVolume> m_Data;
    mitkRCPtr<mitkRGBATransferFunction1D>* m_TFs;
    mitkLocalVersion* m_TFVersions;

    int m_SampleNumber;

    mitkSegmentedVolumeLut *m_CPU_LUT;

    // control
    int* m_less_more;
    float* m_value;

    mitkCUDAValueBasedStateVR m_module;
    mitkCUDAValueBasedBackwardsTest m_backwards;

    
    bool m_glewInit;
    bool m_dataModified;
    bool m_controllerModified;

    bool m_RotateLightDirection;
    bool m_RotatingLightDirection;

    mitkVis2Vector4 m_OldLightDirection;

    bool m_BackwardsTest;

    TimeAverager m_TimeAverager1,m_TimeAverager2;
};

#endif

---