mitkVolumeProperty.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 __mitkVolumeProperty_h
#define __mitkVolumeProperty_h

#include "mitkObject.h"
#include "mitkRCPtr.h"
#include "mitkTransferFunction1D.h"
#include "mitkTransferFunction2DRGBA.h" // by xiang dehui
#include "mitkColorTransferFunction.h"


class MITK_VISUALIZATION_API mitkVolumeProperty : public mitkObject
{
public:
    MITK_TYPE(mitkVolumeProperty,mitkObject)

    virtual void PrintSelf(ostream& os);

    mitkVolumeProperty();

    void SetInterpolationType(int intpType) { m_InterpolationType = intpType; m_Modified = true; }

    int  GetInterpolationType() { return m_InterpolationType; }

    void SetInterpolationTypeToNearest() { this->SetInterpolationType(MITK_NEAREST_INTERPOLATION); }

    void SetInterpolationTypeToLinear() { this->SetInterpolationType(MITK_LINEAR_INTERPOLATION); }

    const char *GetInterpolationTypeAsString();

    void SetScalarColor(mitkColorTransferFunction *scFunction);

    void SetScalarOpacity(mitkTransferFunction1D *soFunction);

    void SetGradientOpacity(mitkTransferFunction1D *goFunction); 
    
    // by xiang dehui
    void SetTF2DRGBA( mitkTransferFunction2DRGBA *tf2drgba );
    
    mitkColorTransferFunction* GetScalarColor();

    mitkTransferFunction1D* GetScalarOpacity();

    mitkTransferFunction1D* GetGradientOpacity();
    
    //by xiang dehui
    mitkTransferFunction2DRGBA* GetTF2DRGBA();
    
    void CorrectScalarOpacity(float sampleDistance);

    void SetOpacityTransferFunction(mitkTransferFunction *moFunction);

    mitkTransferFunction* GetOpacityTransferFunction(); 

    enum TransferFunctionStyle
    {
        Classical,      
        TwoDimensionalRGBA, // by xiang dehui
        ThreeDimensional        
    };

    void SetTransferFunctionStyle(TransferFunctionStyle tfStyle)
    {
        m_TransferFunctionStyle = tfStyle;
        m_Modified = true;
    }
    
    TransferFunctionStyle GetTransferFunctionStyle()
    {
        return m_TransferFunctionStyle;
    }

    void SetShade(bool shade) { m_Shade = shade; m_Modified = true; }

    int  GetShade() { return m_Shade; }

    void ShadeOn() { this->SetShade(true); }

    void ShadeOff() { this->SetShade(false); }

    void SetGradientOpacityCalculation(bool goEnable) { m_GOEnable = goEnable; m_Modified = true; }

    int  GetGradientOpacityCalculation() { return m_GOEnable; }

    void GradientOpacityCalculationOn() { this->SetGradientOpacityCalculation(true); }

    void GradientOpacityCalculationOff() { this->SetGradientOpacityCalculation(false); }

    //by xiang dehui
    void SetTF2DRGBACalculation(bool TF2DRGBAEnable) 
    { 
        if (TF2DRGBAEnable==m_TF2DRGBAEnable) return;
        m_TF2DRGBAEnable = TF2DRGBAEnable;
        m_Modified = true; 
    }

    //by xiang dehui
    int  GetTF2DRGBACalculation() { return m_TF2DRGBAEnable; }

    //by xiang dehui
    void TF2DRGBACalculationOn() { this->SetTF2DRGBACalculation(true); }

    //by xiang dehui
    void TF2DRGBACalculationOff() { this->SetTF2DRGBACalculation(false); }

    void SetAmbient(float value) { m_Ambient = value; m_Modified = true; }

    float GetAmbient() { return m_Ambient; }

    void SetDiffuse(float value) { m_Diffuse = value; m_Modified = true; }

    float GetDiffuse() { return m_Diffuse; }

    void SetSpecular(float value) { m_Specular = value; m_Modified = true; }

    float GetSpecular() { return m_Specular; }

    void SetSpecularPower(float value) { m_SpecularPower = value; m_Modified = true; }

    float GetSpecularPower() { return m_SpecularPower; }  

    bool IsModified() const;

    void SetUnmodified();

protected:
    virtual ~mitkVolumeProperty();

    mitkRCPtr<mitkColorTransferFunction>  m_ScalarColor;
    mitkRCPtr<mitkTransferFunction1D>     m_ScalarOpacity;
    mitkRCPtr<mitkTransferFunction1D>     m_GradientOpacity;
    mitkRCPtr<mitkTransferFunction2DRGBA> m_TF2DRGBA;
    mitkRCPtr<mitkTransferFunction>       m_Opacity;
    
    float *m_CorrectedScalarOpacity;
    int m_OldArraySize;
    float m_OldSampleDistance;
    
    int   m_InterpolationType;  
    float m_Ambient;
    float m_Diffuse;
    float m_Specular;
    float m_SpecularPower;
    TransferFunctionStyle m_TransferFunctionStyle;

    bool  m_Shade;
    bool  m_GOEnable;
    bool  m_Modified;
    bool  m_TF2DRGBAEnable;

private:
    mitkVolumeProperty(const mitkVolumeProperty&);
    void operator=(const mitkVolumeProperty&);
};

inline const char *mitkVolumeProperty::GetInterpolationTypeAsString()
{
    if(m_InterpolationType == MITK_NEAREST_INTERPOLATION)
    {
        return "Nearest Neighbor";
    }
    else if(m_InterpolationType == MITK_LINEAR_INTERPOLATION)
    {
        return "Linear";
    }
    else
    {
        return "Unknown";
    }
}

 
//#define DEFINED_mitkVolumeProperty
 


#endif

---