vtkSmartVolumeMapper.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkSmartVolumeMapper.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 vtkSmartVolumeMapper_h
#define vtkSmartVolumeMapper_h

#include "vtkRenderingVolumeOpenGL2Module.h" // For export macro
#include "vtkVolumeMapper.h"
#include "vtkImageReslice.h" // for VTK_RESLICE_NEAREST, VTK_RESLICE_CUBIC

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

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

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;

  float  SampleDistance;

  vtkTypeBool    AutoAdjustSampleDistances;

  double InteractiveUpdateRate;

  vtkTypeBool InteractiveAdjustSampleDistances;


  int VectorMode;
  int VectorComponent;
  vtkTimeStamp MagnitudeUploadTime;

private:

  void SetupVectorMode(vtkVolume* vol);
  void ComputeMagnitudeCellData(vtkImageData* input, vtkDataArray* arr);
  void ComputeMagnitudePointData(vtkImageData* input, vtkDataArray* arr);

  vtkSmartVolumeMapper(const vtkSmartVolumeMapper&) = delete;
  void operator=(const vtkSmartVolumeMapper&) = delete;

  vtkOSPRayVolumeInterface *OSPRayMapper;
};

#endif