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

  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------
  virtual vtkMRMLNode* CreateNodeInstance() VTK_OVERRIDE;

  virtual void ReadXMLAttributes( const char** atts) VTK_OVERRIDE;

  virtual void WriteXML(ostream& of, int indent) VTK_OVERRIDE;

  virtual void Copy(vtkMRMLNode *node) VTK_OVERRIDE;

  void CopyParameterSet(vtkMRMLNode *node);

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

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

  virtual vtkMRMLStorageNode* CreateDefaultStorageNode() VTK_OVERRIDE;

  virtual bool GetModifiedSinceRead() VTK_OVERRIDE;

protected:
  vtkMRMLVolumePropertyNode(void);
  ~vtkMRMLVolumePropertyNode(void);

  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;

  double EffectiveRange[2];

  int DisabledModify;

private:
  vtkMRMLVolumePropertyNode(const vtkMRMLVolumePropertyNode&);//Not implemented
  void operator=(const vtkMRMLVolumePropertyNode&);// Not implemented

};

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