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);
 
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);
 
  // Getter and setter functions for the storable attributes
  // (protected because only the XML read/write methods need to use these)
  int GetInterpolationType();
  void SetInterpolationType(int);
  int GetShade();
  void SetShade(int);
  double GetDiffuse();
  void SetDiffuse(double);
  double GetAmbient();
  void SetAmbient(double);
  double GetSpecular();
  void SetSpecular(double);
  double GetSpecularPower();
  void SetSpecularPower(double);
  std::string GetScalarOpacityAsString();
  void SetScalarOpacityAsString(std::string);
  std::string GetGradientOpacityAsString();
  void SetGradientOpacityAsString(std::string);
  std::string GetRGBTransferFunctionAsString();
  void SetRGBTransferFunctionAsString(std::string);
 
protected:
  vtkSmartPointer<vtkIntArray> ObservedEvents;
 
  bool IgnoreVolumePropertyChanges{false};
 
  vtkVolumeProperty* VolumeProperty{nullptr};
 
  double EffectiveRange[2]{0.0,-1.0};
 
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