vtkGPUVolumeRayCastMapper.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#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"
#include "vtkWrappingHints.h" // For VTK_MARSHALAUTO
 
VTK_ABI_NAMESPACE_BEGIN
class vtkContourValues;
class vtkRenderWindow;
class vtkVolumeProperty;
 
class VTKRENDERINGVOLUME_EXPORT VTK_MARSHALAUTO 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);
 
  std::vector<int> GetPorts() { return this->Ports; }
  void SetPorts(std::vector<int> ports) { this->Ports = ports; }
 
 
  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();
  void SetDepthPassContourValues(vtkContourValues*);
 
 
  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);
 
 
  vtkSetClampMacro(GlobalIlluminationReach, float, 0.0f, 1.0f);
  vtkGetMacro(GlobalIlluminationReach, float);
 
 
  vtkSetClampMacro(VolumetricScatteringBlending, float, 0.0f, 2.0f);
  vtkGetMacro(VolumetricScatteringBlending, 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);
 
  vtkDataSet* 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();
 
  vtkDataSet* GetTransformedInput(int port = 0);
 
  double* GetBoundsFromPort(int port) VTK_SIZEHINT(6);
 
 
  vtkSetStringMacro(Transfer2DYAxisArray);
  vtkGetStringMacro(Transfer2DYAxisArray);
 
protected:
  vtkGPUVolumeRayCastMapper();
  ~vtkGPUVolumeRayCastMapper() override;
 
  int FillInputPortInformation(int port, vtkInformation* info) override;
 
  void TransformInput(int port);
 
 
  int ValidateRender(vtkRenderer*, vtkVolume*);
  int ValidateInputs();
  int ValidateInput(vtkVolumeProperty* property, int port);
 
 
  void CloneInputs();
  void CloneInput(vtkDataSet* input, 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;
  vtkDataSet* GetInput(int port) override;
 
  void SetCellFlag(int cellFlag);
  void RemovePortInternal(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;
 
  // Secondary rays ambient/global adjustment coefficient
  float GlobalIlluminationReach = 0.0;
 
  float VolumetricScatteringBlending = 0.0;
 
  // 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, vtkDataSet*>;
  void SetTransformedInput(vtkDataSet*);
  vtkDataSet* 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;
 
  char* Transfer2DYAxisArray;
 
private:
  vtkGPUVolumeRayCastMapper(const vtkGPUVolumeRayCastMapper&) = delete;
  void operator=(const vtkGPUVolumeRayCastMapper&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif