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 <unordered_map>              // For std::unordered_map
#include <vector>                     // For std::vector

#include <vtkRenderingVolumeModule.h> // For export macro
#include "vtkVolumeMapper.h"


class vtkContourValues;
class vtkRenderWindow;
class vtkVolumeProperty;

class VTKRENDERINGVOLUME_EXPORT vtkGPUVolumeRayCastMapper : public vtkVolumeMapper
{
public:
  static vtkGPUVolumeRayCastMapper *New();
  vtkTypeMacro(vtkGPUVolumeRayCastMapper,vtkVolumeMapper);
  void PrintSelf( ostream& os, vtkIndent indent ) override;


  vtkSetClampMacro( AutoAdjustSampleDistances, vtkTypeBool, 0, 1 );
  vtkGetMacro( AutoAdjustSampleDistances, vtkTypeBool );
  vtkBooleanMacro( AutoAdjustSampleDistances, vtkTypeBool );


  vtkSetClampMacro( LockSampleDistanceToInputSpacing, vtkTypeBool, 0, 1 );
  vtkGetMacro( LockSampleDistanceToInputSpacing, vtkTypeBool );
  vtkBooleanMacro( LockSampleDistanceToInputSpacing, vtkTypeBool );


  vtkSetClampMacro( UseJittering, vtkTypeBool, 0, 1 );
  vtkGetMacro( UseJittering, vtkTypeBool );
  vtkBooleanMacro( UseJittering, vtkTypeBool );


  vtkSetClampMacro( UseDepthPass, vtkTypeBool, 0, 1 );
  vtkGetMacro( UseDepthPass, vtkTypeBool );
  vtkBooleanMacro( UseDepthPass, vtkTypeBool );

  vtkContourValues* GetDepthPassContourValues();


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

  enum { BinaryMaskType = 0, LabelMapMaskType };


  vtkSetMacro( MaskType, int );
  vtkGetMacro( MaskType, int );
  void SetMaskTypeToBinary();
  void SetMaskTypeToLabelMap();


  vtkSetClampMacro(MaskBlendFactor,float,0.0f,1.0f);
  vtkGetMacro(MaskBlendFactor,float);


  vtkSetMacro(RenderToImage, vtkTypeBool);
  vtkGetMacro(RenderToImage, vtkTypeBool);
  vtkBooleanMacro(RenderToImage, vtkTypeBool);


  vtkSetMacro(DepthImageScalarType, int);
  vtkGetMacro(DepthImageScalarType, int);
  void SetDepthImageScalarTypeToUnsignedChar();
  void SetDepthImageScalarTypeToUnsignedShort();
  void SetDepthImageScalarTypeToFloat();


  vtkSetMacro(ClampDepthToBackface, vtkTypeBool);
  vtkGetMacro(ClampDepthToBackface, vtkTypeBool);
  vtkBooleanMacro(ClampDepthToBackface, vtkTypeBool);

  virtual void GetDepthImage(vtkImageData*) {};

  virtual void GetColorImage(vtkImageData*) {};

  void Render( vtkRenderer *, vtkVolume * ) override;

  virtual void GPURender( vtkRenderer *, vtkVolume *) {}

  void ReleaseGraphicsResources(vtkWindow *) override {}

  virtual void GetReductionRatio(double ratio[3])=0;

  enum TFRangeType
  {
    SCALAR = 0, // default
    NATIVE
  };


  vtkSetMacro(ColorRangeType, int);
  vtkGetMacro(ColorRangeType, int);
  vtkSetMacro(ScalarOpacityRangeType, int);
  vtkGetMacro(ScalarOpacityRangeType, int);
  vtkSetMacro(GradientOpacityRangeType, int);
  vtkGetMacro(GradientOpacityRangeType, int);

  vtkImageData* GetInput() override
  {
    return this->GetInput(0);
  };


  void RemoveInputConnection(int port, vtkAlgorithmOutput* input) override;
  void RemoveInputConnection(int port, int idx) override;
  void SetInputConnection(int port, vtkAlgorithmOutput* input) override;
  void SetInputConnection(vtkAlgorithmOutput* input) override
  {
    this->SetInputConnection(0, input);
  }

  int GetInputCount();

  vtkImageData* GetTransformedInput(const int port = 0);

  double* GetBoundsFromPort(const int port) VTK_SIZEHINT(6);

protected:
  vtkGPUVolumeRayCastMapper();
  ~vtkGPUVolumeRayCastMapper() override;

  int FillInputPortInformation(int port, vtkInformation* info) override;

  void TransformInput(const int port);


  int ValidateRender( vtkRenderer *, vtkVolume * );
  int ValidateInputs();
  int ValidateInput(vtkVolumeProperty* property, const int port);


  void CloneInputs();
  void CloneInput(vtkImageData* input, const int port);

  // 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;
  vtkImageData* GetInput(const int port) override;

  void SetCellFlag(int cellFlag);
  void RemovePortInternal(const int port);

  vtkTypeBool LockSampleDistanceToInputSpacing;
  vtkTypeBool    AutoAdjustSampleDistances;
  float  ImageSampleDistance;
  float  MinimumImageSampleDistance;
  float  MaximumImageSampleDistance;

  // Render to texture mode flag
  vtkTypeBool RenderToImage;

  // Depth image scalar type
  int DepthImageScalarType;

  // Clamp depth values to the depth of the face at which the ray
  // exits the volume
  vtkTypeBool ClampDepthToBackface;

  // Enable / disable stochastic jittering
  vtkTypeBool UseJittering;

  // Enable / disable two pass rendering
  vtkTypeBool UseDepthPass;
  vtkContourValues* DepthPassContourValues;

  // The distance between sample points along the ray
  float  SampleDistance;

  int    SmallVolumeRender;
  double BigTimeToDraw;
  double SmallTimeToDraw;

  float FinalColorWindow;
  float FinalColorLevel;

  // 1 if we are generating the canonical image, 0 otherwise
  int   GeneratingCanonicalView;
  vtkImageData *CanonicalViewImageData;


  vtkSetClampMacro(AMRMode,vtkTypeBool,0,1);
  vtkGetMacro(AMRMode,vtkTypeBool);
  vtkBooleanMacro(AMRMode,vtkTypeBool);

  vtkImageData * MaskInput;
  float          MaskBlendFactor;
  int            MaskType;

  vtkTypeBool AMRMode;

  // Transfer function range type
  int ColorRangeType;
  int ScalarOpacityRangeType;
  int GradientOpacityRangeType;

  // Point data or cell data (or field data, not handled) ?
  int CellFlag;

  virtual void ClipCroppingRegionPlanes();

  using DataMap = std::unordered_map<int, vtkImageData*>;
  void SetTransformedInput(vtkImageData*);
  vtkImageData* FindData(int port, DataMap& container);

  double         ClippedCroppingRegionPlanes[6];

  vtkIdType MaxMemoryInBytes;
  float MaxMemoryFraction;

  bool           ReportProgress;
  std::vector<int> Ports;
  std::vector<int> RemovedPorts;
  DataMap TransformedInputs;

  DataMap LastInputs;

private:
  vtkGPUVolumeRayCastMapper(const vtkGPUVolumeRayCastMapper&) = delete;
  void operator=(const vtkGPUVolumeRayCastMapper&) = delete;
};

#endif