mitkOoCVolumeShearFunction.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 __mitkOoCVolumeShearFunction_h
#define __mitkOoCVolumeShearFunction_h

#include "mitkObject.h"
#include "mitkVolumeDivider.h"

#define SHEAR_FORWARD 0
#define SHEAR_BACKWARD 1

#define SHEAR_SLICEX 0
#define SHEAR_SLICEY 1
#define SHEAR_SLICEZ 2

#define SHEAR_OPACITY 0.98
#define SHEAR_ZERO 0.000001f

// Macro for absolute x
#define mitkAbsMacro(x)     (((x) > 0.0)?(x):(-(x)))
#define mitkFloorMacro(x)   (((x) < 0.0)?((int)((x)-1.0)):((int)(x)))
#define mitkCeilingMacro(x)   (((x) < 0.0)?((int)(x)):((int)((x)+1.0)))
#define mitkRoundMacro(x)   (((x) < 0.0)?((int)((x)-0.5)):((int)((x)+0.5)))

class mitkMatrix;
class mitkScene;
class mitkVolumeModel;
class mitkVolume;
struct mitkShear
{
    //  float m_Color[4];

    //volume information
    int   m_ScalarDataType;
    int   m_DataIncrement[3];
    int   m_DataSize[3];
    float m_DataSpacing[3]; 
    int   m_BlockStart, m_BlockEnd; //in case of out-of-core data
    int   m_BufferSliceNum;
    int   m_Offset;
    union
    {
//      void  *m_ScalarDataPointer;
        void const **m_ScalarDataSlices; //in case of out-of-core data
        mitkVolume *m_ScalarDataVol;
    };
    
    //Shading
    int            m_Shading;   
    float          *m_RedDiffuseShadingTable;
    float          *m_GreenDiffuseShadingTable;
    float          *m_BlueDiffuseShadingTable;
    float          *m_RedSpecularShadingTable;
    float          *m_GreenSpecularShadingTable;
    float          *m_BlueSpecularShadingTable; 
    union
    {
//      unsigned short *m_EncodedNormals;
        unsigned short const **m_EncodedNormalSlices; //in case of out-of-core data
        mitkVolume *m_EncodedNormalVol;
    };

    union
    {
//      unsigned char  *m_GradientMagnitudes;
        unsigned char const **m_GradientMagnitudeSlices; //in case of out-of-core data
        mitkVolume *m_GradientMagnitudeVol;
    };

    //Transfer Function
    int   m_TF_Dimension;
    int   m_TF_ScalarOpacityMaxX;
    int   m_TF_ScalarOpacityMaxY;   
    float *m_TF_ScalarOpacity;
    float *m_TF_GradientOpacity;
    float *m_TF_ScalarColorRed;
    float *m_TF_ScalarColorGreen;
    float *m_TF_ScalarColorBlue;

    float *m_TF_2DOpacity;
    float *m_TF_2DRed;
    float *m_TF_2DGreen;
    float *m_TF_2DBlue;

    //transformation matrix
    mitkMatrix *m_ShearMatrix;
    mitkMatrix *m_ShearOnlyMatrix;
    float m_Sx;
    float m_Sy;
    float m_Sz;

    // classification and interpolation information
    int   m_InterpolationType;      
    int   m_ClassificationMethod;

    //Integral, MIP and X-Ray option information
    int m_Mode;
    enum
    {
        INTEGRAL,
        MOP
    };
    
    // image related information
    int           *m_GridOrigin;
    int           *m_GridSize;
    int           *m_ImageSize;
    int           *m_ImageMemorySize;
    float         *m_CompositeBuffer;


    // shear order
    int m_SliceOrder;
    int m_XOrder;
    int m_YOrder;
    int m_ZOrder;

    //crop and clip information
    int   *m_CropBounds;
    float *m_ClipInformation;
    int   m_ClipCount;
    bool  m_NeedVoxelCull;

    //scene and model information
    mitkScene        *m_Scene;
    mitkVolumeModel *m_Vol;

    //Grid/Image sample distance
    float m_ImageSampleDistance;

};


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

    virtual void PrintSelf(ostream &os);

    mitkOoCVolumeShearFunction();

    virtual bool IsParallel(){ return true; }

    virtual void Shear(mitkShear *shearInform) = 0;

protected:
    virtual ~mitkOoCVolumeShearFunction();

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

};


//#define DEFINED_mitkOoCVolumeShearFunction



#endif

---