mitkOoCVolumeRendererRayCastingEx.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 __mitkOoCVolumeRendererRayCastingEx_h
#define __mitkOoCVolumeRendererRayCastingEx_h

#include "mitkVolumeRenderer.h"
#include "mitkRCPtr.h"
#include "mitkVolumeRayCastFunction.h"
#include "mitkEncodedGradientEstimator.h"
#include "mitkEncodedGradientShader.h"
#include "mitkVolumeDivider.h"
class mitkMatrix;
class mitkVolumeProperty;

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

    virtual void PrintSelf(ostream &os);

    mitkOoCVolumeRendererRayCastingEx();

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

    void SetSubVolumeSize(int wmin, int wmax, int hmin, int hmax, int dmin, int dmax);

    void SetSubVolumeSize(int sizemin[3], int sizemax[3]);
    
    void SplitYFirst(bool yf=true) { m_SplitYFirst = yf; m_SubVolSizeChanged = true; }

protected:
    virtual ~mitkOoCVolumeRendererRayCastingEx();

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

    int _computeClippingPlanes(int planeCount, mitkVector *planeEqus);
    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 _drawBSPTree(CuboidBSPTree *tree, float eye[3], mitkScene *scene, mitkVolumeModel *vol);

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

    bool _initBlocks(mitkVolumeProperty *prop);
    //by xiang dehui
    //void _classifyBlocks(CuboidBSPTree *tree, float *sotf, float *gotf);
    void _classifyBlocks(CuboidBSPTree *tree, mitkVolumeProperty *prop);

    bool _initBuffers(int pixbytes);
    void _deleteBuffers();

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

    mitkVolume *m_EncodedNormalsVol;
    mitkVolume *m_GradientMagnitudesVol;

    unsigned int m_BlockNum;
    unsigned char *m_BlockFlags;

    void *m_SrcBuf;
    unsigned short *m_NormBuf;
    unsigned char *m_GradBuf;

    int m_SubVolSizeMin[3];
    int m_SubVolSizeMax[3];

    int m_Shading;
    int m_GradOn;

    mitkVolumeDivider *m_VolDivider;

    bool m_SplitYFirst;
    bool m_FirstRendering;

    bool m_AutoAdjustSampleDistances;
    bool m_IntermixIntersectingGeometry;

    bool m_SubVolSizeChanged;


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

};


//#define DEFINED_mitkOoCVolumeRendererRayCastingEx



#endif

---