mitkVolumeRendererRayCasting.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 __mitkVolumeRendererRayCasting_h
#define __mitkVolumeRendererRayCasting_h

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

class mitkMatrix;

class MITK_VISUALIZATION_API mitkVolumeRendererRayCasting : public mitkVolumeRenderer
{
public:
    MITK_TYPE(mitkVolumeRendererRayCasting,mitkVolumeRenderer)
        
    mitkVolumeRendererRayCasting(); 

    virtual void PrintSelf(ostream& os);            
    
    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:
    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_MinimumImageSampleDistance;
    float m_MaximumImageSampleDistance;
    int   m_AutoAdjustSampleDistances;
    
    float m_WorldSampleDistance;
    int   m_ScalarDataType;
    void  *m_ScalarDataPointer;
    mitkRay *m_Ray;
    
    virtual ~mitkVolumeRendererRayCasting();
    void _updateShadingTables(mitkScene *scene, mitkVolumeModel *vol);  
    void _renderTexture(mitkVolumeModel *vol, mitkScene *scene);    
    int _computeRowBounds(mitkVolumeModel *vol, mitkScene *scene);
    int _computeClippingPlanes(float *planes);
    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 _castRaysClipOffCropOff(mitkScene *scene, mitkVolumeModel *vol); 
    void _castRaysClipOnCropOff(mitkScene *scene, mitkVolumeModel *vol); 
    void _castRaysClipOffCropSub(mitkScene *scene, mitkVolumeModel *vol); 
    void _castRaysClipOffCropNonSub(mitkScene *scene, mitkVolumeModel *vol); 
    void _castRaysClipOnCropSub(mitkScene *scene, mitkVolumeModel *vol); 
    void _castRaysClipOnCropNonSub(mitkScene *scene, mitkVolumeModel *vol); 

private:
    mitkVolumeRendererRayCasting(const mitkVolumeRendererRayCasting&);
    void operator=(const mitkVolumeRendererRayCasting&);
};

 
//#define DEFINED_mitkVolumeRendererRayCasting
 


#endif

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    $RCSfile$
  Language:  C++
  Date:      $Date: 2009-04-19 14:50:25 +0800 (ÐÇÆÚÈÕ, 19 ËÄÔÂ 2009) $
  Version:   $Revision: 231 $


Copyright (c) 1993-2002 Ken Martin, Will Schroeder, Bill Lorensen 
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

 * Redistributions of source code must retain the above copyright notice,
   this list of conditions and the following disclaimer.

 * Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation
   and/or other materials provided with the distribution.

 * Neither name of Ken Martin, Will Schroeder, or Bill Lorensen nor the names
   of any contributors may be used to endorse or promote products derived
   from this software without specific prior written permission.

 * Modified source versions must be plainly marked as such, and must not be
   misrepresented as being the original software.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

=========================================================================*/ 

---