vtkMRMLAnnotationDisplayNode.h

Go to the documentation of this file.

// .NAME vtkMRMLAnnotationDisplayNode - MRML node to represent display properties for tractography.
// .SECTION Description
// vtkMRMLAnnotationDisplayNode nodes store display properties of trajectories
// from tractography in diffusion MRI data, including color type (by bundle, by fiber,
// or by scalar invariants), display on/off for tensor glyphs and display of
// trajectory as a line or tube.
//

#ifndef __vtkMRMLAnnotationDisplayNode_h
#define __vtkMRMLAnnotationDisplayNode_h

#include "vtkMRML.h"
#include "vtkMRMLModelDisplayNode.h"
#include "vtkMRMLDisplayableNode.h"
#include "vtkMRMLDisplayNode.h"
#include "vtkSlicerAnnotationsModuleMRMLExport.h"

#define vtkSetAndPropagateVector3Macro(name,type) \
virtual void SetAndPropagateSuper##name (type _arg1, type _arg2, type _arg3) \
  { \
  vtkDebugMacro(<< this->GetClassName() << " (" << this << "): setting Super" << #name " to (" << _arg1 << "," << _arg2 << "," << _arg3 << ")"); \
  if ((this->Super##name[0] != _arg1)||(this->Super##name[1] != _arg2)||(this->Super##name[2] != _arg3)) \
    { \
    this->name[0] = _arg1; \
    this->name[1] = _arg2; \
    this->name[2] = _arg3; \
    this->Super##name[0] = _arg1; \
    this->Super##name[1] = _arg2; \
    this->Super##name[2] = _arg3; \
    vtkMRMLDisplayableNode *displayableNode = this->GetDisplayableNode(); \
    if (!displayableNode) \
      { \
      return; \
      } \
    for (int i=0; i<displayableNode->GetNumberOfDisplayNodes(); i++) \
      { \
      vtkMRMLDisplayNode *displayNode = displayableNode->GetNthDisplayNode(i); \
      if (!displayNode || displayNode==this) \
        { \
        continue; \
        } \
      displayNode->Set##name(this->Super##name); \
      } \
    this->Modified(); \
    } \
  }; \
virtual void SetAndPropagateSuper##name (type _arg[3]) \
  { \
  this->SetAndPropagateSuper##name (_arg[0], _arg[1], _arg[2]);\
  }

#define vtkSetAndPropagateMacro(name,type) \
virtual void SetAndPropagateSuper##name (type _arg) \
  { \
  vtkDebugMacro(<< this->GetClassName() << " (" << this << "): setting Super" << #name " to (" << _arg << ")"); \
  if (this->Super##name != _arg) \
    { \
    this->name = _arg; \
    this->Super##name = _arg; \
    vtkMRMLDisplayableNode *displayableNode = this->GetDisplayableNode(); \
    if (!displayableNode) \
      { \
      return; \
      } \
    for (int i=0; i<displayableNode->GetNumberOfDisplayNodes(); i++) \
      { \
      vtkMRMLDisplayNode *displayNode = displayableNode->GetNthDisplayNode(i); \
      if (!displayNode || displayNode==this) \
        { \
        continue; \
        } \
      displayNode->Set##name(this->Super##name); \
      } \
    this->Modified(); \
    } \
  }; \


class  VTK_SLICER_ANNOTATIONS_MODULE_MRML_EXPORT vtkMRMLAnnotationDisplayNode : public vtkMRMLModelDisplayNode
{
 public:
  static vtkMRMLAnnotationDisplayNode *New (  );
  vtkTypeMacro ( vtkMRMLAnnotationDisplayNode,vtkMRMLModelDisplayNode );
  void PrintSelf ( ostream& os, vtkIndent indent ) override;

  //--------------------------------------------------------------------------
  // MRMLNode methods
  //--------------------------------------------------------------------------

  vtkMRMLNode* CreateNodeInstance () override;

  // Description:
  // Read node attributes from XML (MRML) file
  void ReadXMLAttributes ( const char** atts ) override;

  // Description:
  // Write this node's information to a MRML file in XML format.
  void WriteXML ( ostream& of, int indent ) override;


  // Description:
  // Copy the node's attributes to this object
  void Copy ( vtkMRMLNode *node ) override;

  // Description:
  // Get node XML tag name (like Volume, Annotation)
  const char* GetNodeTagName() override {return "AnnotationDisplay";}

  // Description:
  // Finds the storage node and read the data
  void UpdateScene(vtkMRMLScene *scene) override;

  // Description:
  // alternative method to propagate events generated in Display nodes
  void ProcessMRMLEvents ( vtkObject * /*caller*/,
                                   unsigned long /*event*/,
                                   void * /*callData*/ ) override;

  // Functionality for backups of this node
  virtual void CreateBackup(){};
  virtual void RestoreBackup(){};
  void ClearBackup();
  vtkMRMLAnnotationDisplayNode * GetBackup();

  //
  // Set and propagate attributes to all other displayNodes
  //

  vtkSetAndPropagateVector3Macro(Color, double);
  vtkGetVector3Macro(SuperColor, double);

  vtkSetAndPropagateVector3Macro(SelectedColor, double);
  vtkGetVector3Macro(SuperSelectedColor, double);

  vtkSetAndPropagateMacro(Opacity, double);
  vtkGetMacro(SuperOpacity, double);

  vtkSetAndPropagateMacro(Ambient, double);
  vtkGetMacro(SuperAmbient, double);

  vtkSetAndPropagateMacro(Diffuse, double);
  vtkGetMacro(SuperDiffuse, double);

  vtkSetAndPropagateMacro(Specular, double);
  vtkGetMacro(SuperSpecular, double);

  vtkSetAndPropagateMacro(Power, double);
  vtkGetMacro(SuperPower, double);

  vtkSetAndPropagateMacro(SelectedAmbient, double);
  vtkGetMacro(SuperSelectedAmbient, double);

  vtkSetAndPropagateMacro(SelectedSpecular, double);
  vtkGetMacro(SuperSelectedSpecular, double);

  vtkSetMacro(SliceProjection, int);
  vtkGetMacro(SliceProjection, int);

  enum ProjectionFlag
  {
  ProjectionOff = 0x00,
  ProjectionOn = 0x01
  };

  inline void SliceProjectionOn();

  inline void SliceProjectionOff();

  vtkSetVector3Macro(ProjectedColor, double);
  vtkGetVector3Macro(ProjectedColor, double);

  vtkSetMacro(ProjectedOpacity, double);
  vtkGetMacro(ProjectedOpacity, double);

 protected:
  vtkMRMLAnnotationDisplayNode();
  ~vtkMRMLAnnotationDisplayNode() override;
  vtkMRMLAnnotationDisplayNode( const vtkMRMLAnnotationDisplayNode& );
  void operator= ( const vtkMRMLAnnotationDisplayNode& );

  vtkMRMLAnnotationDisplayNode* m_Backup;

  double SuperColor[3];
  double SuperSelectedColor[3];

  double SuperOpacity;
  double SuperAmbient;
  double SuperDiffuse;
  double SuperSpecular;
  double SuperPower;
  double SuperSelectedAmbient;
  double SuperSelectedSpecular;


  int SliceProjection;
  double ProjectedColor[3];
  double ProjectedOpacity;
};

//----------------------------------------------------------------------------
void vtkMRMLAnnotationDisplayNode
::SliceProjectionOn()
{
  this->SetSliceProjection( this->GetSliceProjection() |
                            vtkMRMLAnnotationDisplayNode::ProjectionOn);
}

//----------------------------------------------------------------------------
void vtkMRMLAnnotationDisplayNode
::SliceProjectionOff()
{
  this->SetSliceProjection( this->GetSliceProjection() &
                            ~vtkMRMLAnnotationDisplayNode::ProjectionOn);
}

#endif