mitkVolumeRendererSplatting.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 __mitkVolumeRendererSplatting_h
#define __mitkVolumeRendererSplatting_h

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

// Macro for absolute x
#define mitkAbsFuncMacro(x)     (((x) > 0.0)?(x):(-(x)))

class mitkMatrix;

class MITK_VISUALIZATION_API mitkVolumeRendererSplatting : public mitkVolumeRenderer
{
public:
    MITK_TYPE(mitkVolumeRendererSplatting, mitkVolumeRenderer)

    virtual void PrintSelf(ostream &os);

    mitkVolumeRendererSplatting();

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

    void SetGradientEstimator(mitkEncodedGradientEstimator *gradest);

    void SetPerspectiveSplatter(mitkVolumeSplatFunction *splatter);

    void SetParallelSplatter(mitkVolumeSplatFunction *splatter);

    mitkEncodedGradientEstimator* GetGradientEstimator(){return m_GradientEstimator;}

    mitkVolumeSplatFunction* GetPerspectiveSplatter();
    
    mitkVolumeSplatFunction* GetParallelSplatter();
    
    mitkEncodedGradientShader* GetEncodedGradientShader()
    {
        return m_GradientShader;
    }

    void SetKernelRadii(float radii)
    {
        m_KernelRadii = radii < 0.01f ? 0.01f : (radii > 10.0f ? 10.0f : radii); 
    }

    void SetCoefficient(float coeff)
    {
        m_Coeff = coeff < 0.01f ? 0.01f : (coeff > 10.0f ? 10.0f : coeff);
    }

    void SetAdjustRadii(float adjustRadii)
    {
        m_AdjustRadii = adjustRadii < 0.1f ? 0.1f : (adjustRadii > 20.f ? 20.f : adjustRadii);
    }
    
    float GetKernelRadii(){ return m_KernelRadii; }

    float GetCoefficient(){ return m_Coeff; }

    float GetAdjustRadii(){ return m_AdjustRadii; }

    void SetImageSampleDistance(float fVal)
    {
        m_ImageSampleDistance = fVal < 0.1f ? 0.1f : (fVal > 100.0f ? 100.0f : fVal);
    }

    void SetGridSampleDistance(int fVal)
    {
        m_GridSampleDistance = fVal < 1 ? 1 : (fVal > 50 ? 50 : fVal);
    }

    float GetImageSampleDistance() {return m_ImageSampleDistance;}
    
    int GetGridSampleDistance() {return m_GridSampleDistance;}

    float GetImageSampleDistanceMinValue(){ return 0.1f; }

    int GetGridSampleDistanceMinValue(){ return 1; }

    float GetImageSampleDistanceMaxValue(){ return 100.0f; }

    int GetGridSampleDistanceMaxValue(){ return 50; }

    void SetMinimumImageSampleDistance(float fVal)
    {
        m_MinimumImageSampleDistance = fVal < 0.1f ? 0.1f : (fVal > 100.0f ? 100.0f : fVal);
    }

    void SetMinimumGridSampleDistance(int fVal)
    {
        m_MinimumGridSampleDistance = fVal < 1 ? 1 : (fVal > 50 ? 50 : fVal);
    }

    float GetMinimumImageSampleDistanceMinValue(){ return 0.1f; }

    int GetMinimumGridSampleDistanceMinValue(){ return 1; }

    float GetMinimumImageSampleDistanceMaxValue(){ return 100.0f; }

    int GetMinimumGridSampleDistanceMaxValue(){ return 50; }

    float GetMinimumImageSampleDistance(){return m_MinimumImageSampleDistance;} 

    int GetMinimumGridSampleDistance(){return m_MinimumGridSampleDistance;} 

    void SetMaximumImageSampleDistance(float fVal)
    {
        m_MaximumImageSampleDistance = fVal < 0.1f ? 0.1f : (fVal > 100.0f ? 100.0f : fVal);
    }

    void SetMaximumGridSampleDistance(int fVal)
    {
        m_MaximumGridSampleDistance = fVal < 1 ? 1 : (fVal > 50 ? 50 : fVal);
    }

    float GetMaximumImageSampleDistanceMinValue(){ return 0.1f; }

    int GetMaximumGridSampleDistanceMinValue(){ return 1; }

    float GetMaximumImageSampleDistanceMaxValue(){ return 100.0f; }

    int GetMaximumGridSampleDistanceMaxValue(){ return 50; }

    float GetMaximumImageSampleDistance(){return m_MaximumImageSampleDistance;} 

    int GetMaximumGridSampleDistance(){return m_MaximumGridSampleDistance;} 
    
    bool GetAutoAdjustImageSampleDistances(){return m_AutoAdjustImageSampleDistances;}

    void AutoAdjustImageSampleDistancesOn(){ m_AutoAdjustImageSampleDistances = true;}

    void AutoAdjustImageSampleDistancesOff(){ m_AutoAdjustImageSampleDistances = false;}

    bool GetAutoAdjustGridSampleDistances(){return m_AutoAdjustGridSampleDistances;}

    void AutoAdjustGridSampleDistancesOn(){ m_AutoAdjustGridSampleDistances = true;}

    void AutoAdjustGridSampleDistancesOff(){ m_AutoAdjustGridSampleDistances = false;}
        
    virtual float GetGradientMagnitudeScale();

    virtual float GetGradientMagnitudeBias();

    void SetModeIntegral(){ m_Mode = INTEGRAL; }

    void SetModeMop(){ m_Mode = MOP; }

    int GetMode(){ return m_Mode; }

protected:
    virtual ~mitkVolumeRendererSplatting();

    void _updateShadingTables(mitkScene *scene, mitkVolumeModel *vol);  
    void _renderTexture(mitkVolumeModel *vol, mitkScene *scene, unsigned char *img);
    void _getTransformMatrix(mitkScene *scene, mitkVolumeModel *vol);
    int  _computeRowBounds(mitkVolumeModel *vol, mitkScene *scene);
    void _splatting(mitkScene *scene, mitkVolumeModel *vol);
    void _getSplatOrder();
    void _computeFootprint(float x, float y, float z, int offset);
    bool _cullVoxel(float x, float y, float z, float *clipPlane, int pCount);

    mitkRCPtr<mitkVolumeSplatFunction>       m_ParallelSplatter;
    mitkRCPtr<mitkVolumeSplatFunction>       m_PerspectiveSplatter;
    mitkRCPtr<mitkEncodedGradientEstimator>  m_GradientEstimator;
    mitkRCPtr<mitkEncodedGradientShader>     m_GradientShader;
    
    // Transformation information
    mitkMatrix *m_GridToView;
    mitkMatrix *m_ViewToGrid;
    mitkMatrix *m_GridToScreen;
    mitkMatrix *m_ProjectionToScreen;
    
    // This is how big the image would be if it covered the entire viewport
    int m_ImageViewportSize[2];
    
    // This is how big the allocated memory for image is. This may be bigger
    // or smaller than ImageFullSize - it will be bigger if necessary to 
    // ensure a power of 2, it will be smaller if the volume only covers a
    // small region of the viewport
    int m_ImageMemorySize[2];
    
    // This is the size of subregion in ImageSize image that we are using for
    // the current image. Since ImageSize is a power of 2, there is likely
    // wasted space in it. This number will be used for things such as clearing
    // the image if necessary.
    int m_ImageInUseSize[2];
    
    // This is the location in ImageFullSize image where our ImageSize image
    // is located.
    int m_ImageOrigin[2];

    // This is the allocated image
    unsigned char *m_Image;
    int           *m_RowBounds;
        
    // This is allocated for adding and compositing of splatting
    float *m_SheetBuffer;
    float *m_CompositeBuffer;
    
    // The distance between sample points along grid
    int  m_GridSampleDistance;
    int  m_MinimumGridSampleDistance;
    int  m_MaximumGridSampleDistance;
    bool m_AutoAdjustGridSampleDistances;

    // The distance between sample points along screen
    float m_ImageSampleDistance;
    float m_MinimumImageSampleDistance;
    float m_MaximumImageSampleDistance; 
    bool  m_AutoAdjustImageSampleDistances;
    
    // Splat related information
    float                   m_KernelRadii;
    float                   m_Coeff;
    float                   m_AdjustRadii;
    mitkSplat               *m_Splat;
    mitkFootprint2DGaussian *m_Footprint;
    mitkFootprint1DGaussian *m_Footprint1D;
    int m_Mode;
    enum
    {
        INTEGRAL,
        MOP
    };

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

};


//#define DEFINED_mitkVolumeRendererSplatting



#endif

---