mitkOoCVolumeRendererShearWarp.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 __mitkOoCVolumeRendererShearWarp_h
#define __mitkOoCVolumeRendererShearWarp_h

#include "mitkVolumeRenderer.h"
#include "mitkOoCVolumeShearFunction.h"
#include "mitkRCPtr.h"
#include "mitkEncodedGradientEstimator.h"
#include "mitkEncodedGradientShader.h"

// 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 MITK_VISUALIZATION_API mitkOoCVolumeRendererShearWarp : public mitkVolumeRenderer
{
public:
    MITK_TYPE(mitkOoCVolumeRendererShearWarp, mitkVolumeRenderer)

    virtual void PrintSelf(ostream &os);

    mitkOoCVolumeRendererShearWarp();

    virtual int Render(mitkScene *scene, mitkVolumeModel *vol);

    void SetGradientEstimator(mitkEncodedGradientEstimator *gradest)
    { 
        m_GradientEstimator = gradest; 
    }

    mitkEncodedGradientEstimator* GetGradientEstimator(){return m_GradientEstimator;}
    
    mitkEncodedGradientShader* GetEncodedGradientShader()
    {
        return m_GradientShader;
    }

    void SetPerspectiveShearer(mitkOoCVolumeShearFunction *shearer);

    void SetParallelShearer(mitkOoCVolumeShearFunction *shearer);

    mitkOoCVolumeShearFunction* GetPerspectiveShearer();
    
    mitkOoCVolumeShearFunction* GetParallelShearer();

    void SetImageSampleDistance(float val)
    {
        m_ImageSampleDistance = val;
    }

    float GetImageSampleDistance() {return m_ImageSampleDistance;}

    float GetMinimumImageSampleDistance(){return m_MinimumImageSampleDistance;} 

    float GetMaximumImageSampleDistance(){return m_MaximumImageSampleDistance;} 
    
    bool GetAutoAdjustImageSampleDistances(){return m_AutoAdjustImageSampleDistances;}

    void AutoAdjustImageSampleDistancesOn(){ m_AutoAdjustImageSampleDistances = true;}

    void AutoAdjustImageSampleDistancesOff(){ m_AutoAdjustImageSampleDistances = false;}
        
    virtual float GetGradientMagnitudeScale();

    virtual float GetGradientMagnitudeBias();

    void SetModeIntegral(){ m_Mode = INTEGRAL; }

    void SetModeMop(){ m_Mode = MOP; }

    int GetMode(){ return m_Mode; }

    void SetLevelOfDetail(bool lod){ m_LOD = lod; }

protected:
    virtual ~mitkOoCVolumeRendererShearWarp();

    int _computeClippingPlanes(int planeCount, mitkScene *scene);
    void _updateShadingTables(mitkScene *scene, mitkVolumeModel *vol);  
    void _renderTexture(mitkVolumeModel *vol, mitkScene *scene, unsigned char *img);
    void _getTransformMatrix(mitkScene *scene, mitkVolumeModel *vol);
    int  _computeGridBounds(mitkVolumeModel *vol, mitkScene *scene);
    void _shear(mitkScene *scene, mitkVolumeModel *vol, mitkShear *m_Shear);
    void _getShearOrder(mitkScene *scene);
//  bool _cullVoxel(float x, float y, float z, float *clipPlane, int pCount);

    mitkRCPtr<mitkOoCVolumeShearFunction>       m_ParallelShearer;
    mitkRCPtr<mitkOoCVolumeShearFunction>       m_PerspectiveShearer;
    mitkRCPtr<mitkEncodedGradientEstimator>  m_GradientEstimator;
    mitkRCPtr<mitkEncodedGradientShader>     m_GradientShader;

    // Transformation information
    mitkMatrix *m_GridToWorld;
    mitkMatrix *m_ViewToGrid;
    mitkMatrix *m_ShearMatrix;
    mitkMatrix *m_InverseShearMatrix;
    mitkMatrix *m_ShearOnlyMatrix;

    // The distance between sample points along shear space.
    float m_ImageSampleDistance;
    float   m_MinimumImageSampleDistance;
    float   m_MaximumImageSampleDistance;   
    bool  m_AutoAdjustImageSampleDistances;
    float m_AdjustDistance;
    
    // This is the size of the intermediate image region in sheared space. 
    int m_GridSize[2];
    
    // This is the location in sheared space where the intermediate image region
    // is located.
    int m_GridOrigin[2];

    // This is the size of samples in intermediate image that we use for real display.
    int m_ImageSize[2];
    int m_OldImageSize[2];

    // This is the size of the allocated memory for image. This may be bigger
    // or smaller than Intermediate Image's full size - it will be bigger if necessary to 
    // ensure a power of 2, it will be smaller if the intermediate image region only covers 
    // a small region of the allocated memory.
    int m_ImageMemorySize[2];

    // This is allocated for final displayed image.
    unsigned char *m_Image;
        
    // This is allocated for compositing of sheared slices.
    float *m_CompositeBuffer;

    //shear related information.
    mitkShear *m_Shear;
    int m_Mode;
    enum
    {
        INTEGRAL,
        MOP
    };

    int m_SlicePtrNum;
    void const **m_Slices;
    int m_BufSliceNum;
    unsigned short const **m_EncodedNormalSlices;
    unsigned char const **m_GradientMagnitudeSlices;

    mitkVolume *m_EncodedNormalsVol;
    mitkVolume *m_GradientMagnitudesVol;

    // information needed for interactive clipping. 
    bool m_DepthTest;
    bool *m_Clips;
    bool m_AutoReslice;

    // information needed for level-of-detail display.
    bool m_LOD;

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

};


//#define DEFINED_mitkOoCVolumeRendererShearWarp



#endif

---