mitkVolumeRendererRayCastingLoD.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 __mitkVolumeRendererRayCastingLoD_h
#define __mitkVolumeRendererRayCastingLoD_h

#include "mitkVolumeRendererRayCasting.h"
#include "mitkSPMD.h"

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

    virtual void PrintSelf(ostream &os);

    mitkVolumeRendererRayCastingLoD();

    virtual int Render(mitkScene *scene, mitkVolumeModel *vol);
    
    void  SetSampleDistance(float fVal) { m_SampleDistance = fVal; }

    float GetSampleDistance() { return m_SampleDistance; }

    void SetVolumeRayCastFunction(mitkVolumeRayCastFunction* oVal)
    {
        m_VolumeRayCastFunction = oVal;
    }

    mitkVolumeRayCastFunction* GetVolumeRayCastFunction()
    {
        return m_VolumeRayCastFunction;
    }   

    void SetGradientEstimator(mitkEncodedGradientEstimator *gradest);

    mitkEncodedGradientEstimator* GetGradientEstimator(){return m_GradientEstimator;};
    
    mitkEncodedGradientShader* GetEncodedGradientShader()
    {
        return m_GradientShader;
    }
    
    float GetImageSampleDistanceMinValue() { return 0.1f; }

    float GetImageSampleDistanceMaxValue() { return 100.0f; }

    void SetImageSampleDistance(float fVal)
    {
        m_ImageSampleDistance = fVal < GetImageSampleDistanceMinValue()
            ? GetImageSampleDistanceMinValue()
            : (fVal > GetImageSampleDistanceMaxValue()
            ? GetImageSampleDistanceMaxValue() : fVal);
    }

    float GetImageSampleDistance() { return m_ImageSampleDistance; }
    
    float GetMinimumImageSampleDistanceMinValue() { return 0.1f; }

    float GetMinimumImageSampleDistanceMaxValue() { return 100.0f; }

    float GetMaximumImageSampleDistanceMinValue() { return 0.1f; }

    float GetMaximumImageSampleDistanceMaxValue() { return 100.0f; }

    void SetMinimumImageSampleDistance(float fVal)
    {
        m_MinimumImageSampleDistance = fVal < GetMinimumImageSampleDistanceMinValue()
            ? GetMinimumImageSampleDistanceMinValue()
            : (fVal > GetMinimumImageSampleDistanceMaxValue() 
            ? GetMinimumImageSampleDistanceMaxValue() : fVal);
    }

    void SetMaximumImageSampleDistance(float fVal)
    {
        m_MaximumImageSampleDistance = fVal < GetMaximumImageSampleDistanceMinValue()
            ? GetMaximumImageSampleDistanceMinValue()
            : (fVal > GetMaximumImageSampleDistanceMaxValue()
            ? GetMaximumImageSampleDistanceMaxValue() : fVal);
    }

    float GetMinimumImageSampleDistance() { return m_MinimumImageSampleDistance; }  
    
    float GetMaximumImageSampleDistance() { return m_MaximumImageSampleDistance; }  
    
    void SetAutoAdjustSampleDistances(int val)
    {
        m_AutoAdjustSampleDistances = val < 0 ? 0 : (val > 1 ? 1 : val);
    }
    
    int GetAutoAdjustSampleDistances() { return m_AutoAdjustSampleDistances; }

    void AutoAdjustSampleDistancesOn() { SetAutoAdjustSampleDistances(1); }

    void AutoAdjustSampleDistancesOff() { SetAutoAdjustSampleDistances(0); }

    void SetIntermixIntersectingGeometry(int fVal)
    {
        m_IntermixIntersectingGeometry = fVal < 0 ? 0 : (fVal > 1 ? 1 : fVal);
    }   
    
    int GetIntermixIntersectingGeometry() { return m_IntermixIntersectingGeometry; }    

    void IntermixIntersectingGeometryOn() { SetIntermixIntersectingGeometry(1); }

    void IntermixIntersectingGeometryOff() { SetIntermixIntersectingGeometry(0); }  

    virtual float GetGradientMagnitudeScale();
    
    virtual float GetGradientMagnitudeBias();

protected:
    virtual ~mitkVolumeRendererRayCastingLoD();
    void _updateShadingTables(mitkScene *scene, mitkVolumeModel *vol);  
    void _renderTexture(mitkVolumeModel *vol, mitkScene *scene, unsigned char *img);
    int _computeClippingPlanes(float *planes, mitkScene *scene);
    int _computeRowBounds(mitkVolumeModel *vol, mitkScene *scene);
    int _clipRayAgainstVolume(mitkRay *rayInfo, float bounds[6] );
    int _clipRayAgainstClippingPlanes(int planeCount, float *planeEqus, mitkRay *rayInfo);  
            
    // Get the ZBuffer value corresponding to location (x,y) where (x,y)
    // are indexing into the ImageInUse image. This must be converted to
    // the zbuffer image coordinates. Nearest neighbor value is returned.
    float _getZBufferValue(int x, int y);   

    void _castRayMT(int tid,int tnum,void*,mitkBarrier*);
    
    void _castRaysClipOffCropOff(int tid,int tnum); 
    void _castRaysClipOnCropOff(int tid,int tnum); 
    void _castRaysClipOffCropSub(int tid,int tnum); 
    void _castRaysClipOffCropNonSub(int tid,int tnum); 
    void _castRaysClipOnCropSub(int tid,int tnum); 
    void _castRaysClipOnCropNonSub(int tid,int tnum); 

    mitkScene *m_curscene;
    mitkVolumeModel *m_curvol;

    mitkRCPtr<mitkVolumeRayCastFunction>     m_VolumeRayCastFunction;
    mitkRCPtr<mitkEncodedGradientEstimator>  m_GradientEstimator;
    mitkRCPtr<mitkEncodedGradientShader>     m_GradientShader;

    mitkVolumeModel **m_RenderVolumeTable;
    mitkScene        **m_RenderSceneTable;
    
    mitkMatrix *m_PerspectiveMatrix;
    mitkMatrix *m_ViewToWorldMatrix;
    mitkMatrix *m_ViewToVoxelsMatrix;
    mitkMatrix *m_VoxelsToViewMatrix;
    mitkMatrix *m_WorldToVoxelsMatrix;
    mitkMatrix *m_VoxelsToWorldMatrix;
    
    // 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;
    int *m_OldRowBounds;    
    
    int m_RenderTableSize;
    int m_RenderTableEntries;
    
    int m_IntermixIntersectingGeometry;
    
    float *m_ZBuffer;
    int   m_ZBufferSize[2];
    int   m_ZBufferOrigin[2];
    
    float m_MinimumViewDistance;
    
    // The distance between sample points along the ray
    float m_SampleDistance;

    float m_ImageSampleDistance;
    float m_oldImageSampleDistance ;
    float m_MinimumImageSampleDistance;
    float m_MaximumImageSampleDistance;
    int   m_AutoAdjustSampleDistances;
    
    float m_WorldSampleDistance;
    int   m_ScalarDataType;
    void  *m_ScalarDataPointer;
    mitkRay *m_Ray;

    // information needed for interactive clipping. 
    bool m_DepthTest;
    bool *m_Clips;
    bool m_AutoReslice;
    bool m_Break;
    
private:
    mitkVolumeRendererRayCastingLoD(const mitkVolumeRendererRayCastingLoD&);
    void operator = (const mitkVolumeRendererRayCastingLoD&);

};


//#define DEFINED_mitkVolumeRendererRayCastingLoD



#endif

---