vtkGPUVolumeRayCastMapper.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkGPUVolumeRayCastMapper.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 vtkGPUVolumeRayCastMapper_h
#define vtkGPUVolumeRayCastMapper_h
 
#include "vtkRenderingVolumeModule.h" // For export macro
#include "vtkVolumeMapper.h"
 
class vtkVolumeProperty;
class vtkRenderWindow;
 
//class vtkKWAMRVolumeMapper; // friend class.
 
class VTKRENDERINGVOLUME_EXPORT vtkGPUVolumeRayCastMapper : public vtkVolumeMapper
{
public:
  static vtkGPUVolumeRayCastMapper *New();
  vtkTypeMacro(vtkGPUVolumeRayCastMapper,vtkVolumeMapper);
  void PrintSelf( ostream& os, vtkIndent indent );
 
 
  vtkSetClampMacro( AutoAdjustSampleDistances, int, 0, 1 );
  vtkGetMacro( AutoAdjustSampleDistances, int );
  vtkBooleanMacro( AutoAdjustSampleDistances, int );
 
 
  vtkSetMacro( SampleDistance, float );
  vtkGetMacro( SampleDistance, float );
 
 
  vtkSetClampMacro( ImageSampleDistance, float, 0.1f, 100.0f );
  vtkGetMacro( ImageSampleDistance, float );
 
 
  vtkSetClampMacro( MinimumImageSampleDistance, float, 0.1f, 100.0f );
  vtkGetMacro( MinimumImageSampleDistance, float );
 
 
  vtkSetClampMacro( MaximumImageSampleDistance, float, 0.1f, 100.0f );
  vtkGetMacro( MaximumImageSampleDistance, float );
 
 
 
  vtkSetMacro( FinalColorWindow, float );
  vtkGetMacro( FinalColorWindow, float );
  vtkSetMacro( FinalColorLevel,  float );
  vtkGetMacro( FinalColorLevel,  float );
 
 
  vtkSetMacro( MaxMemoryInBytes, vtkIdType );
  vtkGetMacro( MaxMemoryInBytes, vtkIdType );
 
 
  vtkSetClampMacro( MaxMemoryFraction, float, 0.1f, 1.0f );
  vtkGetMacro( MaxMemoryFraction, float );
 
 
  vtkSetMacro(ReportProgress,bool);
  vtkGetMacro(ReportProgress,bool);
 
 
  virtual int IsRenderSupported(vtkRenderWindow *vtkNotUsed(window),
                                vtkVolumeProperty *vtkNotUsed(property))
    {
      return 0;
    }
 
  void CreateCanonicalView( vtkRenderer *ren,
                            vtkVolume *volume,
                            vtkImageData *image,
                            int blend_mode,
                            double viewDirection[3],
                            double viewUp[3] );
 
 
  void SetMaskInput(vtkImageData *mask);
  vtkGetObjectMacro(MaskInput, vtkImageData);
 
  //BTX
  enum { BinaryMaskType = 0, LabelMapMaskType };
  //ETX
 
 
  vtkSetMacro( MaskType, int );
  vtkGetMacro( MaskType, int );
  void SetMaskTypeToBinary();
  void SetMaskTypeToLabelMap();
 
 
  vtkSetClampMacro(MaskBlendFactor,float,0.0f,1.0f);
  vtkGetMacro(MaskBlendFactor,float);
 
//BTX
  void Render( vtkRenderer *, vtkVolume * );
 
  virtual void GPURender( vtkRenderer *, vtkVolume *) {}
 
  void ReleaseGraphicsResources(vtkWindow *) {}
 
  virtual void GetReductionRatio(double ratio[3])=0;
 
//ETX
 
protected:
  vtkGPUVolumeRayCastMapper();
  ~vtkGPUVolumeRayCastMapper();
 
  // Check to see that the render will be OK
  int ValidateRender( vtkRenderer *, vtkVolume * );
 
 
  // Special version of render called during the creation
  // of a canonical view.
  void CanonicalViewRender( vtkRenderer *, vtkVolume * );
 
  // Methods called by the AMR Volume Mapper.
  virtual void PreRender(vtkRenderer *ren,
                         vtkVolume *vol,
                         double datasetBounds[6],
                         double scalarRange[2],
                         int numberOfScalarComponents,
                         unsigned int numberOfLevels)=0;
 
  // \pre input is up-to-date
  virtual void RenderBlock(vtkRenderer *ren,
                           vtkVolume *vol,
                           unsigned int level)=0;
 
  virtual void PostRender(vtkRenderer *ren,
                          int numberOfScalarComponents)=0;
 
  void SetCellFlag(int cellFlag);
 
  // The distance between sample points along the ray
  float  SampleDistance;
 
 
  float  ImageSampleDistance;
  float  MinimumImageSampleDistance;
  float  MaximumImageSampleDistance;
  int    AutoAdjustSampleDistances;
 
  int    SmallVolumeRender;
  double BigTimeToDraw;
  double SmallTimeToDraw;
 
  float FinalColorWindow;
  float FinalColorLevel;
 
  vtkIdType MaxMemoryInBytes;
  float MaxMemoryFraction;
 
 
  // 1 if we are generating the canonical image, 0 otherwise
  int   GeneratingCanonicalView;
  vtkImageData *CanonicalViewImageData;
 
 
  vtkSetClampMacro(AMRMode,int,0,1);
  vtkGetMacro(AMRMode,int);
  vtkBooleanMacro(AMRMode,int);
 
  int AMRMode;
  int CellFlag; // point data or cell data (or field data, not handled) ?
 
  virtual void ClipCroppingRegionPlanes();
 
  double         ClippedCroppingRegionPlanes[6];
  bool           ReportProgress;
  vtkImageData * MaskInput;
  float          MaskBlendFactor;
  int            MaskType;
  vtkImageData * TransformedInput;
 
  vtkGetObjectMacro(TransformedInput, vtkImageData);
  void SetTransformedInput(vtkImageData*);
 
  vtkImageData* LastInput;
 
private:
  vtkGPUVolumeRayCastMapper(const vtkGPUVolumeRayCastMapper&);  // Not implemented.
  void operator=(const vtkGPUVolumeRayCastMapper&);  // Not implemented.
};
 
#endif