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"
#include "vtkWrappingHints.h" // For VTK_MARSHALAUTO

VTK_ABI_NAMESPACE_BEGIN
class vtkFixedPointVolumeRayCastMapper;
class vtkGPUVolumeRayCastMapper;
class vtkImageResample;
class vtkMultiBlockVolumeMapper;
class vtkOSPRayVolumeInterface;
class vtkAnariVolumeInterface;
class vtkRenderWindow;
class vtkVolume;
class vtkVolumeProperty;
class vtkImageMagnitude;

class VTKRENDERINGVOLUMEOPENGL2_EXPORT VTK_MARSHALAUTO 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,
    AnariRenderMode = 4,
    UndefinedRenderMode = 5,
    InvalidRenderMode = 6
  };

  void SetRequestedRenderMode(int mode);

  void SetRequestedRenderModeToDefault();

  void SetRequestedRenderModeToRayCast();

  void SetRequestedRenderModeToGPU();

  void SetRequestedRenderModeToOSPRay();

  void SetRequestedRenderModeToAnari();


  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;
  vtkAnariVolumeInterface* AnariMapper;
};

VTK_ABI_NAMESPACE_END
#endif