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