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

  bool GetModifiedSinceRead() override;

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:
  vtkIntArray* ObservedEvents;

  vtkVolumeProperty* VolumeProperty{nullptr};

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

  int DisabledModify{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