vtkSmartVolumeMapper.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkSmartVolumeMapper.h
 
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
#ifndef vtkSmartVolumeMapper_h
#define vtkSmartVolumeMapper_h
 
#include "vtkRenderingVolumeOpenGL2Module.h" // For export macro
#include "vtkVolumeMapper.h"
#include "vtkImageReslice.h" // for VTK_RESLICE_NEAREST, VTK_RESLICE_CUBIC
 
class vtkFixedPointVolumeRayCastMapper;
class vtkGPUVolumeRayCastMapper;
class vtkImageResample;
class vtkRenderWindow;
class vtkVolume;
class vtkVolumeProperty;
 
class VTKRENDERINGVOLUMEOPENGL2_EXPORT vtkSmartVolumeMapper : public vtkVolumeMapper
{
public:
  static vtkSmartVolumeMapper *New();
  vtkTypeMacro(vtkSmartVolumeMapper,vtkVolumeMapper);
  void PrintSelf( ostream& os, vtkIndent indent );
 
 
  vtkSetMacro( FinalColorWindow, float );
 
 
  vtkGetMacro( FinalColorWindow, float );
 
 
  vtkSetMacro( FinalColorLevel,  float );
 
 
  vtkGetMacro( FinalColorLevel,  float );
 
//BTX
// The possible values for the default and current render mode ivars
  enum
  {
    DefaultRenderMode=0,
    RayCastAndTextureRenderMode,
    RayCastRenderMode,
    TextureRenderMode,
    GPURenderMode,
    UndefinedRenderMode,
    InvalidRenderMode
  };
//ETX
 
  void SetRequestedRenderMode(int mode);
 
  void SetRequestedRenderModeToDefault();
 
  void SetRequestedRenderModeToRayCast();
 
  void SetRequestedRenderModeToGPU();
 
 
  vtkGetMacro( RequestedRenderMode, int );
 
  int GetLastUsedRenderMode();
 
 
  vtkSetMacro( MaxMemoryInBytes, vtkIdType );
  vtkGetMacro( MaxMemoryInBytes, vtkIdType );
 
 
  vtkSetClampMacro( MaxMemoryFraction, float, 0.1f, 1.0f );
  vtkGetMacro( MaxMemoryFraction, float );
 
 
  vtkSetClampMacro(InterpolationMode, int,
                   VTK_RESLICE_NEAREST, VTK_RESLICE_CUBIC);
  vtkGetMacro(InterpolationMode, int);
  void SetInterpolationModeToNearestNeighbor();
  void SetInterpolationModeToLinear();
  void SetInterpolationModeToCubic();
 
 
  void CreateCanonicalView( vtkRenderer *ren,
                            vtkVolume *volume,
                            vtkVolume *volume2,
                            vtkImageData *image,
                            int blend_mode,
                            double viewDirection[3],
                            double viewUp[3] );
 
 
  vtkSetClampMacro( InteractiveUpdateRate, double, 1.0e-10, 1.0e10 );
 
 
  vtkGetMacro( InteractiveUpdateRate, double );
 
 
  vtkSetClampMacro( InteractiveAdjustSampleDistances, int, 0, 1);
  vtkGetMacro( InteractiveAdjustSampleDistances, int);
  vtkBooleanMacro( InteractiveAdjustSampleDistances, int);
 
 
  vtkSetClampMacro( AutoAdjustSampleDistances, int, 0, 1 );
  vtkGetMacro( AutoAdjustSampleDistances, int );
  vtkBooleanMacro( AutoAdjustSampleDistances, int );
 
 
  vtkSetMacro( SampleDistance, float );
  vtkGetMacro( SampleDistance, float );
 
 
//BTX
  void Render( vtkRenderer *, vtkVolume * );
 
 
  void ReleaseGraphicsResources(vtkWindow *);
//ETX
 
protected:
  vtkSmartVolumeMapper();
  ~vtkSmartVolumeMapper();
 
  void ConnectMapperInput(vtkVolumeMapper *m);
 
  void ConnectFilterInput(vtkImageResample *f);
 
  // Window / level ivars
  float   FinalColorWindow;
  float   FinalColorLevel;
 
  // GPU mapper-specific memory ivars.
  vtkIdType MaxMemoryInBytes;
  float MaxMemoryFraction;
 
  // Used for downsampling.
  int InterpolationMode;
 
  // The requested render mode is used to compute the current render mode. Note
  // that the current render mode can be invalid if the requested mode is not
  // supported.
  int     RequestedRenderMode;
  int     CurrentRenderMode;
 
  // Initialization variables.
  int          Initialized;
  vtkTimeStamp SupportStatusCheckTime;
  int          GPUSupported;
  int          RayCastSupported;
  int          LowResGPUNecessary;
 
  // This is the resample filter that may be used if we need to
  // create a low resolution version of the volume for GPU rendering
  vtkImageResample *GPUResampleFilter;
 
  // The initialize method. Called from ComputeRenderMode whenever something
  // relevant has changed.
  void  Initialize(vtkRenderer *ren,
                   vtkVolume *vol);
 
  // The method that computes the render mode from the requested render mode
  // based on the support status for each render method.
  void  ComputeRenderMode(vtkRenderer *ren,
                          vtkVolume *vol);
 
  // The three potential mappers
  vtkGPUVolumeRayCastMapper      *GPULowResMapper;
  vtkGPUVolumeRayCastMapper      *GPUMapper;
  vtkFixedPointVolumeRayCastMapper  *RayCastMapper;
 
 
  // We need to keep track of the blend mode we had when we initialized
  // because we need to reinitialize (and recheck hardware support) if
  // it changes
  int  InitializedBlendMode;
 
  // The distance between sample points along the ray
  float  SampleDistance;
 
  // Set whether or not the sample distance should be automatically calculated
  // within the internal volume mapper
  int    AutoAdjustSampleDistances;
 
  // If the DesiredUpdateRate of the vtkRenderWindow causing the Render is at
  // or above this value, the render is considered interactive. Otherwise it is
  // considered still.
  double InteractiveUpdateRate;
 
  // If the InteractiveAdjustSampleDistances flag is enabled,
  // vtkSmartVolumeMapper interactively sets and resets the
  // AutoAdjustSampleDistances flag on the internal volume mapper. This flag
  // along with InteractiveUpdateRate is useful to adjust volume mapper sample
  // distance based on whether the render is interactive or still.
  int InteractiveAdjustSampleDistances;
 
private:
  vtkSmartVolumeMapper(const vtkSmartVolumeMapper&);  // Not implemented.
  void operator=(const vtkSmartVolumeMapper&);  // Not implemented.
};
 
#endif