vtkVolumeProperty.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 vtkVolumeProperty_h
#define vtkVolumeProperty_h

#include "vtkImplicitFunction.h" // For vtkImplicitFunction
#include "vtkNew.h"              // Needed for vtkNew
#include "vtkObject.h"
#include "vtkRenderingCoreModule.h" // For export macro
#include "vtkSmartPointer.h"        // Needed for vtkSmartPointer
#include "vtkWrappingHints.h"       // For VTK_MARSHALAUTO

// STL includes
#include <set>           // For labelmap labels set
#include <unordered_map> // For labelmap transfer function maps

VTK_ABI_NAMESPACE_BEGIN
class vtkColorTransferFunction;
class vtkContourValues;
class vtkImageData;
class vtkPiecewiseFunction;
class vtkTimeStamp;

class VTKRENDERINGCORE_EXPORT VTK_MARSHALAUTO vtkVolumeProperty : public vtkObject
{
public:
  static vtkVolumeProperty* New();
  vtkTypeMacro(vtkVolumeProperty, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
  void DeepCopy(vtkVolumeProperty* p);

  vtkMTimeType GetMTime() override;


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


  vtkSetClampMacro(InterpolationType, int, VTK_NEAREST_INTERPOLATION, VTK_LINEAR_INTERPOLATION);
  vtkGetMacro(InterpolationType, int);
  void SetInterpolationTypeToNearest() { this->SetInterpolationType(VTK_NEAREST_INTERPOLATION); }
  void SetInterpolationTypeToLinear() { this->SetInterpolationType(VTK_LINEAR_INTERPOLATION); }
  const char* GetInterpolationTypeAsString();


  virtual void SetComponentWeight(int index, double value);
  virtual double GetComponentWeight(int index);

  void SetColor(int index, vtkPiecewiseFunction* function);
  void SetColor(vtkPiecewiseFunction* function) { this->SetColor(0, function); }

  void SetColor(int index, vtkColorTransferFunction* function);
  void SetColor(vtkColorTransferFunction* function) { this->SetColor(0, function); }

  int GetColorChannels(int index);
  int GetColorChannels() { return this->GetColorChannels(0); }

  vtkPiecewiseFunction* GetGrayTransferFunction(int index);
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_REDUNDANT)
  vtkPiecewiseFunction* GetGrayTransferFunction() { return this->GetGrayTransferFunction(0); }
  void SetGrayTransferFunction(int index, vtkPiecewiseFunction* function)
  {
    SetColor(index, function);
  }
  int GetNumberOfGrayTransferFunctions() { return VTK_MAX_VRCOMP; }

  vtkColorTransferFunction* GetRGBTransferFunction(int index);
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_REDUNDANT)
  vtkColorTransferFunction* GetRGBTransferFunction() { return this->GetRGBTransferFunction(0); }
  void SetRGBTransferFunction(int index, vtkColorTransferFunction* function)
  {
    SetColor(index, function);
  }
  int GetNumberOfRGBTransferFunctions() { return VTK_MAX_VRCOMP; }

  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_REDUNDANT)
  void SetScalarOpacity(int index, vtkPiecewiseFunction* function);
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_REDUNDANT)
  void SetScalarOpacity(vtkPiecewiseFunction* function) { this->SetScalarOpacity(0, function); }

  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_REDUNDANT)
  vtkPiecewiseFunction* GetScalarOpacity(int index);
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_REDUNDANT)
  vtkPiecewiseFunction* GetScalarOpacity() { return this->GetScalarOpacity(0); }


  void SetScalarOpacityFunction(int index, vtkPiecewiseFunction* function)
  {
    SetScalarOpacity(index, function);
  };
  vtkPiecewiseFunction* GetScalarOpacityFunction(int index) { return this->ScalarOpacity[index]; }
  int GetNumberOfScalarOpacityFunctions() { return VTK_MAX_VRCOMP; }


  void SetScalarOpacityUnitDistance(int index, double distance);
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_REDUNDANT)
  void SetScalarOpacityUnitDistance(double distance)
  {
    this->SetScalarOpacityUnitDistance(0, distance);
  }
  double GetScalarOpacityUnitDistance(int index);
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_REDUNDANT)
  double GetScalarOpacityUnitDistance() { return this->GetScalarOpacityUnitDistance(0); }

  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_REDUNDANT)
  void SetGradientOpacity(int index, vtkPiecewiseFunction* function);
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_REDUNDANT)
  void SetGradientOpacity(vtkPiecewiseFunction* function) { this->SetGradientOpacity(0, function); }


  void SetGradientOpacityFunction(int index, vtkPiecewiseFunction* function)
  {
    this->SetGradientOpacity(index, function);
  }
  vtkPiecewiseFunction* GetGradientOpacityFunction(int index) { return GradientOpacity[index]; }
  int GetNumberOfGradientOpacityFunctions() { return VTK_MAX_VRCOMP; }


  void SetTransferFunction2D(int index, vtkImageData* function);
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_REDUNDANT)
  void SetTransferFunction2D(vtkImageData* function) { this->SetTransferFunction2D(0, function); }

  vtkImageData* GetTransferFunction2D(int index);
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_REDUNDANT)
  vtkImageData* GetTransferFunction2D() { return this->GetTransferFunction2D(0); }
  int GetNumberOfTransferFunction2Ds() { return VTK_MAX_VRCOMP; }

  enum TransferMode
  {
    TF_1D = 0,
    TF_2D
  };

  vtkSetClampMacro(TransferFunctionMode, int, 0, 1);
  vtkGetMacro(TransferFunctionMode, int);
  void SetTransferFunctionModeTo1D() { this->SetTransferFunctionMode(TF_1D); }
  void SetTransferFunctionModeTo2D() { this->SetTransferFunctionMode(TF_2D); }

  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_REDUNDANT)
  vtkPiecewiseFunction* GetGradientOpacity(int index);
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_REDUNDANT)
  vtkPiecewiseFunction* GetGradientOpacity() { return this->GetGradientOpacity(0); }


  virtual void SetDisableGradientOpacity(int index, int value);
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_REDUNDANT)
  virtual void SetDisableGradientOpacity(int value) { this->SetDisableGradientOpacity(0, value); }
  virtual void DisableGradientOpacityOn(int index) { this->SetDisableGradientOpacity(index, 1); }
  virtual void DisableGradientOpacityOn() { this->DisableGradientOpacityOn(0); }
  virtual void DisableGradientOpacityOff(int index) { this->SetDisableGradientOpacity(index, 0); }
  virtual void DisableGradientOpacityOff() { this->DisableGradientOpacityOff(0); }
  virtual int GetDisableGradientOpacity(int index);
  VTK_MARSHALEXCLUDE(VTK_MARSHAL_EXCLUDE_REASON_IS_REDUNDANT)
  virtual int GetDisableGradientOpacity() { return this->GetDisableGradientOpacity(0); }
  vtkPiecewiseFunction* GetStoredGradientOpacity(int index);
  vtkPiecewiseFunction* GetStoredGradientOpacity() { return this->GetStoredGradientOpacity(0); }

  bool HasGradientOpacity(int index = 0)
  {
    switch (this->TransferFunctionMode)
    {
      case TF_1D:
        return (this->GradientOpacity[index] != nullptr);
      case TF_2D:
        return true;
    }
    return false;
  }

  /*
   * Check whether or not we have label map gradient opacity functions.
   */
  bool HasLabelGradientOpacity() { return !this->LabelGradientOpacity.empty(); }


  void SetShade(int index, int value);
  void SetShade(int value) { this->SetShade(0, value); }
  int GetShade(int index);
  int GetShade() { return this->GetShade(0); }
  void ShadeOn(int index);
  void ShadeOn() { this->ShadeOn(0); }
  void ShadeOff(int index);
  void ShadeOff() { this->ShadeOff(0); }


  void SetAmbient(int index, double value);
  void SetAmbient(double value) { this->SetAmbient(0, value); }
  double GetAmbient(int index);
  double GetAmbient() { return this->GetAmbient(0); }


  void SetDiffuse(int index, double value);
  void SetDiffuse(double value) { this->SetDiffuse(0, value); }
  double GetDiffuse(int index);
  double GetDiffuse() { return this->GetDiffuse(0); }


  void SetSpecular(int index, double value);
  void SetSpecular(double value) { this->SetSpecular(0, value); }
  double GetSpecular(int index);
  double GetSpecular() { return this->GetSpecular(0); }


  void SetSpecularPower(int index, double value);
  void SetSpecularPower(double value) { this->SetSpecularPower(0, value); }
  double GetSpecularPower(int index);
  double GetSpecularPower() { return this->GetSpecularPower(0); }

  vtkContourValues* GetIsoSurfaceValues();


  vtkSetSmartPointerMacro(SliceFunction, vtkImplicitFunction);
  vtkGetSmartPointerMacro(SliceFunction, vtkImplicitFunction);


  vtkSetClampMacro(ScatteringAnisotropy, float, -1.0, 1.0);
  vtkGetMacro(ScatteringAnisotropy, float);

  void UpdateMTimes();

  vtkTimeStamp GetGradientOpacityMTime(int index);
  vtkTimeStamp GetGradientOpacityMTime() { return this->GetGradientOpacityMTime(0); }

  vtkTimeStamp GetScalarOpacityMTime(int index);
  vtkTimeStamp GetScalarOpacityMTime() { return this->GetScalarOpacityMTime(0); }

  vtkTimeStamp GetRGBTransferFunctionMTime(int index);
  vtkTimeStamp GetRGBTransferFunctionMTime() { return this->GetRGBTransferFunctionMTime(0); }

  vtkTimeStamp GetGrayTransferFunctionMTime(int index);
  vtkTimeStamp GetGrayTransferFunctionMTime() { return this->GetGrayTransferFunctionMTime(0); }


  vtkSetMacro(UseClippedVoxelIntensity, int);
  vtkGetMacro(UseClippedVoxelIntensity, int);
  vtkBooleanMacro(UseClippedVoxelIntensity, int);


  vtkSetMacro(ClippedVoxelIntensity, double);
  vtkGetMacro(ClippedVoxelIntensity, double);


  void SetLabelColor(int label, vtkColorTransferFunction* function);
  vtkColorTransferFunction* GetLabelColor(int label);


  void SetLabelScalarOpacity(int label, vtkPiecewiseFunction* function);
  vtkPiecewiseFunction* GetLabelScalarOpacity(int label);


  void SetLabelGradientOpacity(int label, vtkPiecewiseFunction* function);
  vtkPiecewiseFunction* GetLabelGradientOpacity(int label);

  vtkGetMacro(LabelColorMTime, vtkTimeStamp);

  vtkGetMacro(LabelScalarOpacityMTime, vtkTimeStamp);

  vtkGetMacro(LabelGradientOpacityMTime, vtkTimeStamp);

  std::size_t GetNumberOfLabels();

  std::set<int> GetLabelMapLabels();

protected:
  vtkVolumeProperty();
  ~vtkVolumeProperty() override;

  vtkTimeStamp GetTransferFunction2DMTime(int index);
  vtkTimeStamp GetTransferFunction2DMTime() { return this->GetTransferFunction2DMTime(0); }

  virtual void CreateDefaultGradientOpacity(int index);

  vtkTypeBool IndependentComponents;
  double ComponentWeight[VTK_MAX_VRCOMP];

  int InterpolationType;

  float ScatteringAnisotropy = 0.0;

  int ColorChannels[VTK_MAX_VRCOMP];

  vtkPiecewiseFunction* GrayTransferFunction[VTK_MAX_VRCOMP];
  vtkTimeStamp GrayTransferFunctionMTime[VTK_MAX_VRCOMP];

  vtkColorTransferFunction* RGBTransferFunction[VTK_MAX_VRCOMP];
  vtkTimeStamp RGBTransferFunctionMTime[VTK_MAX_VRCOMP];

  vtkPiecewiseFunction* ScalarOpacity[VTK_MAX_VRCOMP];
  vtkTimeStamp ScalarOpacityMTime[VTK_MAX_VRCOMP];
  double ScalarOpacityUnitDistance[VTK_MAX_VRCOMP];

  vtkPiecewiseFunction* GradientOpacity[VTK_MAX_VRCOMP];
  vtkTimeStamp GradientOpacityMTime[VTK_MAX_VRCOMP];

  vtkPiecewiseFunction* DefaultGradientOpacity[VTK_MAX_VRCOMP];
  int DisableGradientOpacity[VTK_MAX_VRCOMP];

  int TransferFunctionMode;
  vtkImageData* TransferFunction2D[VTK_MAX_VRCOMP];
  vtkTimeStamp TransferFunction2DMTime[VTK_MAX_VRCOMP];

  vtkTimeStamp LabelColorMTime;
  vtkTimeStamp LabelScalarOpacityMTime;
  vtkTimeStamp LabelGradientOpacityMTime;

  int Shade[VTK_MAX_VRCOMP];
  double Ambient[VTK_MAX_VRCOMP];
  double Diffuse[VTK_MAX_VRCOMP];
  double Specular[VTK_MAX_VRCOMP];
  double SpecularPower[VTK_MAX_VRCOMP];

  double ClippedVoxelIntensity;
  int UseClippedVoxelIntensity;

  vtkNew<vtkContourValues> IsoSurfaceValues;

  vtkSmartPointer<vtkImplicitFunction> SliceFunction;

  std::unordered_map<int, vtkColorTransferFunction*> LabelColor;
  std::unordered_map<int, vtkPiecewiseFunction*> LabelScalarOpacity;
  std::unordered_map<int, vtkPiecewiseFunction*> LabelGradientOpacity;
  std::set<int> LabelMapLabels;

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

inline const char* vtkVolumeProperty::GetInterpolationTypeAsString()
{
  if (this->InterpolationType == VTK_NEAREST_INTERPOLATION)
  {
    return "Nearest Neighbor";
  }
  if (this->InterpolationType == VTK_LINEAR_INTERPOLATION)
  {
    return "Linear";
  }
  return "Unknown";
}

VTK_ABI_NAMESPACE_END
#endif