vtkSmartVolumeMapper.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 vtkSmartVolumeMapper_h
#define vtkSmartVolumeMapper_h
 
#include "vtkImageReslice.h"                 // for VTK_RESLICE_NEAREST, VTK_RESLICE_CUBIC
#include "vtkRenderingVolumeOpenGL2Module.h" // For export macro
#include "vtkVolumeMapper.h"
 
VTK_ABI_NAMESPACE_BEGIN
class vtkFixedPointVolumeRayCastMapper;
class vtkGPUVolumeRayCastMapper;
class vtkImageResample;
class vtkMultiBlockVolumeMapper;
class vtkOSPRayVolumeInterface;
class vtkRenderWindow;
class vtkVolume;
class vtkVolumeProperty;
class vtkImageMagnitude;
 
class VTKRENDERINGVOLUMEOPENGL2_EXPORT vtkSmartVolumeMapper : public vtkVolumeMapper
{
public:
  static vtkSmartVolumeMapper* New();
  vtkTypeMacro(vtkSmartVolumeMapper, vtkVolumeMapper);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  vtkSetMacro(FinalColorWindow, float);
 
 
  vtkGetMacro(FinalColorWindow, float);
 
 
  vtkSetMacro(FinalColorLevel, float);
 
 
  vtkGetMacro(FinalColorLevel, float);
 
  // The possible values for the default and current render mode ivars
  enum
  {
    DefaultRenderMode = 0,
    RayCastRenderMode = 1,
    GPURenderMode = 2,
    OSPRayRenderMode = 3,
    UndefinedRenderMode = 4,
    InvalidRenderMode = 5
  };
 
  void SetRequestedRenderMode(int mode);
 
  void SetRequestedRenderModeToDefault();
 
  void SetRequestedRenderModeToRayCast();
 
  void SetRequestedRenderModeToGPU();
 
  void SetRequestedRenderModeToOSPRay();
 
 
  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(UseJittering, vtkTypeBool, 0, 1);
  vtkGetMacro(UseJittering, vtkTypeBool);
  vtkBooleanMacro(UseJittering, vtkTypeBool);
 
 
  vtkSetClampMacro(InteractiveUpdateRate, double, 1.0e-10, 1.0e10);
 
 
  vtkGetMacro(InteractiveUpdateRate, double);
 
 
  vtkSetClampMacro(InteractiveAdjustSampleDistances, vtkTypeBool, 0, 1);
  vtkGetMacro(InteractiveAdjustSampleDistances, vtkTypeBool);
  vtkBooleanMacro(InteractiveAdjustSampleDistances, vtkTypeBool);
 
 
  vtkSetClampMacro(AutoAdjustSampleDistances, vtkTypeBool, 0, 1);
  vtkGetMacro(AutoAdjustSampleDistances, vtkTypeBool);
  vtkBooleanMacro(AutoAdjustSampleDistances, vtkTypeBool);
 
 
  vtkSetMacro(SampleDistance, float);
  vtkGetMacro(SampleDistance, float);
 
 
  vtkSetClampMacro(GlobalIlluminationReach, float, 0.0f, 1.0f);
  vtkGetMacro(GlobalIlluminationReach, float);
 
 
  vtkSetClampMacro(VolumetricScatteringBlending, float, 0.0f, 2.0f);
  vtkGetMacro(VolumetricScatteringBlending, float);
 
  void Render(vtkRenderer*, vtkVolume*) override;
 
  void ReleaseGraphicsResources(vtkWindow*) override;
 
 
  enum VectorModeType
  {
    DISABLED = -1,
    MAGNITUDE = 0,
    COMPONENT = 1,
  };
 
  void SetVectorMode(int mode);
  vtkGetMacro(VectorMode, int);
 
  vtkSetClampMacro(VectorComponent, int, 0, 3);
  vtkGetMacro(VectorComponent, int);
 
 
  vtkSetStringMacro(Transfer2DYAxisArray);
  vtkGetStringMacro(Transfer2DYAxisArray);
 
 
  enum LowResModeType
  {
    LowResModeDisabled = 0,
    LowResModeResample = 1,
  };
 
  vtkSetMacro(LowResMode, int);
  vtkGetMacro(LowResMode, int)
 
    protected : vtkSmartVolumeMapper();
  ~vtkSmartVolumeMapper() override;
 
  void ConnectMapperInput(vtkVolumeMapper* m);
 
  void ConnectFilterInput(vtkImageResample* f);
 
 
  float FinalColorWindow;
  float FinalColorLevel;
 
 
  vtkIdType MaxMemoryInBytes;
  float MaxMemoryFraction;
 
  int InterpolationMode;
 
 
  int RequestedRenderMode;
  int CurrentRenderMode;
 
 
  int Initialized;
  vtkTimeStamp SupportStatusCheckTime;
  int GPUSupported;
  int RayCastSupported;
  int LowResGPUNecessary;
 
  vtkImageResample* GPUResampleFilter;
 
 
  vtkImageMagnitude* ImageMagnitude;
  vtkImageData* InputDataMagnitude;
 
  void Initialize(vtkRenderer* ren, vtkVolume* vol);
 
  void ComputeRenderMode(vtkRenderer* ren, vtkVolume* vol);
 
  friend class vtkMultiBlockVolumeMapper;
  vtkGetObjectMacro(GPUMapper, vtkGPUVolumeRayCastMapper);
 
 
  vtkGPUVolumeRayCastMapper* GPULowResMapper;
  vtkGPUVolumeRayCastMapper* GPUMapper;
  vtkFixedPointVolumeRayCastMapper* RayCastMapper;
 
  int InitializedBlendMode;
 
  vtkTypeBool UseJittering;
 
  float SampleDistance;
 
  float GlobalIlluminationReach = 0.0;
 
  float VolumetricScatteringBlending = 0.0;
 
  vtkTypeBool AutoAdjustSampleDistances;
 
  double InteractiveUpdateRate;
 
  vtkTypeBool InteractiveAdjustSampleDistances;
 
 
  int VectorMode;
  int VectorComponent;
  vtkTimeStamp MagnitudeUploadTime;
 
 
  vtkDataSet* LastInput;
  vtkDataSet* LastFilterInput;
 
  char* Transfer2DYAxisArray;
 
  int LowResMode = LowResModeDisabled;
 
private:
 
  void SetupVectorMode(vtkVolume* vol);
  void ComputeMagnitudeCellData(vtkDataSet* input, vtkDataArray* arr);
  void ComputeMagnitudePointData(vtkDataSet* input, vtkDataArray* arr);
 
  vtkSmartVolumeMapper(const vtkSmartVolumeMapper&) = delete;
  void operator=(const vtkSmartVolumeMapper&) = delete;
 
  vtkOSPRayVolumeInterface* OSPRayMapper;
};
 
VTK_ABI_NAMESPACE_END
#endif