vtkMRMLVolumePropertyNode.h

Go to the documentation of this file.

 
#ifndef __vtkMRMLVolumePropertyNode_h
#define __vtkMRMLVolumePropertyNode_h
 
// VolumeRendering includes
#include "vtkSlicerVolumeRenderingModuleMRMLExport.h"
 
// MRML includes
#include "vtkMRMLStorableNode.h"
 
// VTK includes
class vtkColorTransferFunction;
class vtkIntArray;
class vtkPiecewiseFunction;
class vtkVolume;
class vtkVolumeProperty;
 
// STD includes
#include <string>
#include <vector>

class VTK_SLICER_VOLUMERENDERING_MODULE_MRML_EXPORT vtkMRMLVolumePropertyNode : public vtkMRMLStorableNode
{
public:
  enum
  {
    EffectiveRangeModified = 62300
  };

  static vtkMRMLVolumePropertyNode* New();
  vtkTypeMacro(vtkMRMLVolumePropertyNode, vtkMRMLStorableNode);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  vtkGetObjectMacro(VolumeProperty, vtkVolumeProperty);

  void SetScalarOpacity(vtkPiecewiseFunction* newScalarOpacity, int component = 0);
  vtkPiecewiseFunction* GetScalarOpacity(int component = 0);

  void SetGradientOpacity(vtkPiecewiseFunction* newGradientOpacity, int component = 0);
  vtkPiecewiseFunction* GetGradientOpacity(int component = 0);

  void SetColor(vtkColorTransferFunction* newColorFunction, int component = 0);
  vtkColorTransferFunction* GetColor(int component = 0);

  static std::string GetPiecewiseFunctionString(vtkPiecewiseFunction* function);

  static std::string GetColorTransferFunctionString(vtkColorTransferFunction* function);

  static void GetPiecewiseFunctionFromString(const std::string& str, vtkPiecewiseFunction* result);

  static void GetColorTransferFunctionFromString(const std::string& str, vtkColorTransferFunction* result);

  static inline void GetPiecewiseFunctionFromString(const char* str, vtkPiecewiseFunction* result);

  static inline void GetColorTransferFunctionFromString(const char* str, vtkColorTransferFunction* result);

  static double NextHigher(double value);
  static double HigherAndUnique(double value, double& previousValue);

  void SetEffectiveRange(double min, double max);
  void SetEffectiveRange(double range[2]);
  vtkGetVector2Macro(EffectiveRange, double);

  bool CalculateEffectiveRange();
 
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------
  vtkMRMLNode* CreateNodeInstance() override;

  void ReadXMLAttributes(const char** atts) override;

  void WriteXML(ostream& of, int indent) override;

  vtkMRMLCopyContentMacro(vtkMRMLVolumePropertyNode);

  void CopyParameterSet(vtkMRMLNode* node);

  const char* GetNodeTagName() override { return "VolumeProperty"; }

  void ProcessMRMLEvents(vtkObject* caller, unsigned long event, void* callData) override;

  vtkMRMLStorageNode* CreateDefaultStorageNode() override;

  void SetPropertyInVolumeNode(vtkVolume* volume);

  vtkSetClampMacro(NumberOfIndependentComponents, int, 1, VTK_MAX_VRCOMP);
  vtkGetMacro(NumberOfIndependentComponents, int);
 
protected:
  vtkMRMLVolumePropertyNode();
  ~vtkMRMLVolumePropertyNode() override;
 
  static int NodesFromString(const std::string& dataString, double*& data, int nodeSize);
  static int DataFromString(const std::string& dataString, double*& data);
  static std::string DataToString(double* data, int size);
 
  // Setter functions for the storable attributes
  // (protected because only the XML read method needs to use these)
  void SetInterpolationType(int);
  void SetShade(int);
  void SetDiffuse(double);
  void SetAmbient(double);
  void SetSpecular(double);
  void SetSpecularPower(double);
  void SetScalarOpacityAsString(std::string);
  void SetGradientOpacityAsString(std::string);
  void SetRGBTransferFunctionAsString(std::string);
 
protected:
  vtkSmartPointer<vtkIntArray> ObservedEvents;

  bool IgnoreVolumePropertyChanges{ false };

  vtkVolumeProperty* VolumeProperty{ nullptr };

  double EffectiveRange[2]{ 0.0, -1.0 };

  int NumberOfIndependentComponents{ 1 };
 
private:
  vtkMRMLVolumePropertyNode(const vtkMRMLVolumePropertyNode&) = delete;
  void operator=(const vtkMRMLVolumePropertyNode&) = delete;
};
 
//---------------------------------------------------------------------------
void vtkMRMLVolumePropertyNode::GetPiecewiseFunctionFromString(const char* str, vtkPiecewiseFunction* result)
{
  vtkMRMLVolumePropertyNode::GetPiecewiseFunctionFromString(std::string(str), result);
}
 
//---------------------------------------------------------------------------
void vtkMRMLVolumePropertyNode::GetColorTransferFunctionFromString(const char* str, vtkColorTransferFunction* result)
{
  vtkMRMLVolumePropertyNode::GetColorTransferFunctionFromString(std::string(str), result);
}
 
#endif