mitkOoCVolumeRendererRayCasting.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 __mitkOoCVolumeRendererRayCasting_h
#define __mitkOoCVolumeRendererRayCasting_h

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

class mitkMatrix;

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

    virtual void PrintSelf(ostream &os);

    mitkOoCVolumeRendererRayCasting();

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

    void SetGradientEstimator(mitkEncodedGradientEstimator *gradest);

    mitkEncodedGradientEstimator* GetGradientEstimator(){return m_GradientEstimator;};



protected:
    virtual ~mitkOoCVolumeRendererRayCasting();

    void _deleteCastingRays();
    void _clearCastingRays();
    int _newCastingRays();
    int _initCastingRays(mitkScene *scene, mitkVolumeModel *vol);

    int _computeClippingPlanes(int planeCount, mitkVector *planeEqus, mitkScene *scene);
    int _computeRowBounds(mitkScene *scene, mitkVolumeModel *vol);
    int _clipRayAgainstVolume(mitkVector &rayStart, mitkVector &rayEnd, float bounds[6]);
    int _clipRayAgainstClippingPlanes(mitkVector &rayStart, mitkVector &rayEnd, int planeCount, mitkVector *planeEqus); 

    int _updateShadingTables(mitkScene *scene, mitkVolumeModel *vol);
    
    void _renderTexture(mitkScene *scene, mitkVolumeModel *vol);

    // 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);   

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

    mitkRay *m_Ray;
    mitkVector *m_RayCurPos;
//  mitkVector *m_RayEndPos;
    mitkVector *m_RayCastStep;
    int *m_RayStepsLeft;
    int *m_RayStatus;

    mitkMatrix *m_WorldToViewMatrix;
    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;
    float *m_AccumColors;
    
    int *m_RowBounds;
    int *m_OldRowBounds;    

    float m_MinimumViewDistance;

    // The distance between sample points along the ray
    float m_SampleDistance;
    
    float *m_ZBuffer;
    int   m_ZBufferSize[2];
    int   m_ZBufferOrigin[2];

    float m_ImageSampleDistance;
    float m_MinimumImageSampleDistance;
    float m_MaximumImageSampleDistance;

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

    mitkVolume *m_EncodedNormalsVol;
    mitkVolume *m_GradientMagnitudesVol;

    bool m_AutoAdjustSampleDistances;
    bool m_IntermixIntersectingGeometry;
    bool m_HasForwardRay;
    bool m_HasReverseRay;

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

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

};


//#define DEFINED_mitkOoCVolumeRendererRayCasting



#endif

---