vtkSlicerAnnotationModuleLogic.h

Go to the documentation of this file.

#ifndef __vtkSlicerAnnotationModuleLogic_h
#define __vtkSlicerAnnotationModuleLogic_h

// Slicer Logic includes
#include "vtkSlicerAnnotationsModuleLogicExport.h"
#include "vtkSlicerModuleLogic.h"

// MRML includes
class vtkMRMLAnnotationHierarchyNode;
class vtkMRMLAnnotationLineDisplayNode;
class vtkMRMLAnnotationNode;
class vtkMRMLAnnotationPointDisplayNode;
class vtkMRMLAnnotationTextDisplayNode;

// VTK includes
#include <vtkStdString.h>

// STD includes
#include <string>

class VTK_SLICER_ANNOTATIONS_MODULE_LOGIC_EXPORT vtkSlicerAnnotationModuleLogic
  :public vtkSlicerModuleLogic
{
public:
  enum Events{
    RefreshRequestEvent = vtkCommand::UserEvent,
    HierarchyNodeAddedEvent
  };
  static vtkSlicerAnnotationModuleLogic *New();
  vtkTypeMacro(vtkSlicerAnnotationModuleLogic,vtkSlicerModuleLogic);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  void StartPlaceMode(bool persistent=false, vtkMRMLInteractionNode* interactionNode = nullptr);

  void StopPlaceMode(bool persistent=false, vtkMRMLInteractionNode* interactionNode = nullptr);

  // Start adding a new annotation Node
  void AddAnnotationNode(const char * nodeDescriptor, bool persistent=false);

  // After a node was added, propagate to widget
  void AddNodeCompleted(vtkMRMLAnnotationNode* annotationNode);

  void CancelCurrentOrRemoveLastAddedAnnotationNode(vtkMRMLInteractionNode* interactionNode = nullptr);

  void RemoveAnnotationNode(vtkMRMLAnnotationNode* annotationNode);

  //
  // Annotation Properties (interface to MRML)
  //
  void RegisterNodes() override;

  bool IsAnnotationNode(const char* id);

  bool IsAnnotationHierarchyNode(const char* id);

  vtkMRMLAnnotationTextDisplayNode *GetTextDisplayNode(const char *id);
  vtkMRMLAnnotationPointDisplayNode *GetPointDisplayNode(const char *id);
  vtkMRMLAnnotationLineDisplayNode *GetLineDisplayNode(const char *id);

  const char * GetAnnotationName(const char * id);

  vtkStdString GetAnnotationText(const char* id);
  void SetAnnotationText(const char* id, const char * newtext);

  double GetAnnotationTextScale(const char* id);
  void SetAnnotationTextScale(const char* id, double textScale);

  double * GetAnnotationTextSelectedColor(const char* id);
  void SetAnnotationTextSelectedColor(const char* id, double * color);

  double * GetAnnotationTextUnselectedColor(const char* id);
  void SetAnnotationTextUnselectedColor(const char* id, double * color);

  double * GetAnnotationColor(const char *id);
  void SetAnnotationColor(const char *id, double *color);

  double * GetAnnotationUnselectedColor(const char *id);
  void SetAnnotationUnselectedColor(const char *id, double *color);

  double * GetAnnotationPointColor(const char *id);
  void SetAnnotationPointColor(const char *id, double *color);

  double * GetAnnotationPointUnselectedColor(const char *id);
  void SetAnnotationPointUnselectedColor(const char *id, double *color);

  const char * GetAnnotationPointGlyphTypeAsString(const char *id);
  int GetAnnotationPointGlyphType(const char *id);
  void SetAnnotationPointGlyphTypeFromString(const char *id, const char *glyphType);
  void SetAnnotationPointGlyphType(const char *id, int glyphType);

  double * GetAnnotationLineColor(const char *id);
  void SetAnnotationLineColor(const char *id, double *color);

  double * GetAnnotationLineUnselectedColor(const char *id);
  void SetAnnotationLineUnselectedColor(const char *id, double *color);


  const char * GetAnnotationMeasurement(const char * id, bool showUnits);

  const char * GetAnnotationIcon(const char * id);
  const char * GetAnnotationIcon(vtkMRMLNode* mrmlNode);

  int GetAnnotationLockedUnlocked(const char * id);
  void SetAnnotationLockedUnlocked(const char * id);

  int GetAnnotationVisibility(const char * id);
  void SetAnnotationVisibility(const char * id);

  void SetAnnotationSelected(const char * id, bool selected);
  void SetAllAnnotationsSelected(bool selected);

  void BackupAnnotationNode(const char * id);
  void RestoreAnnotationNode(const char * id);
  void DeleteBackupNodes(const char * id);

  void JumpSlicesToAnnotationCoordinate(const char* id);

  const char * MoveAnnotationUp(const char* id);
  const char * MoveAnnotationDown(const char* id);

  //
  // SnapShot functionality
  //
  void CreateSnapShot(const char* name, const char* description, int screenshotType, double scaleFactor, vtkImageData* screenshot);

  void ModifySnapShot(vtkStdString id, const char* name, const char* description, int screenshotType, double scaleFactor, vtkImageData* screenshot);

  vtkStdString GetSnapShotName(const char* id);

  vtkStdString GetSnapShotDescription(const char* id);

  int GetSnapShotScreenshotType(const char* id);

  double GetSnapShotScaleFactor(const char* id);

  vtkImageData* GetSnapShotScreenshot(const char* id);

  bool IsSnapshotNode(const char* id);

  //
  // Hierarchy functionality
  //
  bool AddHierarchy();

  char * GetTopLevelHierarchyNodeID(vtkMRMLNode* node=nullptr);

  char * GetTopLevelHierarchyNodeIDForNodeClass(vtkMRMLAnnotationNode *annotationNode);

  vtkMRMLAnnotationHierarchyNode *GetActiveHierarchyNode();

  vtkGetStringMacro(ActiveHierarchyNodeID);
  vtkSetStringMacro(ActiveHierarchyNodeID);

  void SetHierarchyAnnotationsVisibleFlag(vtkMRMLAnnotationHierarchyNode* hierarchyNode, bool flag);
  void SetHierarchyAnnotationsLockFlag(vtkMRMLAnnotationHierarchyNode* hierarchyNode, bool flag);

  //
  // Place Annotations programmatically
  //

  //
  // Report functionality
  //
  const char* GetHTMLRepresentation(vtkMRMLAnnotationNode* annotationNode, int level);
  const char* GetHTMLRepresentation(vtkMRMLAnnotationHierarchyNode* hierarchyNode, int level);


  const char* AddDisplayNodeForHierarchyNode(vtkMRMLAnnotationHierarchyNode *hnode);

  char *LoadFiducialList(const char *filename);

  char *LoadAnnotation(const char *filename, const char *name, int fileType);
  enum
  {
    None = 0,
    Fiducial,
    Ruler,
    ROI,
  };

  char *AddFiducial(double r=0.0, double a=0.0, double s=0.0, const char *label=nullptr);

protected:

  vtkSlicerAnnotationModuleLogic();

  ~vtkSlicerAnnotationModuleLogic() override;

  // Initialize listening to MRML events
  void SetMRMLSceneInternal(vtkMRMLScene * newScene) override;
  void ObserveMRMLScene() override;

  // MRML events
  void OnMRMLSceneNodeAdded(vtkMRMLNode* node) override;
  void OnMRMLSceneEndClose() override;
  void ProcessMRMLNodesEvents(vtkObject *caller,
                                      unsigned long event,
                                      void *callData ) override;
  virtual void OnMRMLAnnotationNodeModifiedEvent(vtkMRMLNode* node);

private:

  vtkMRMLAnnotationNode* m_LastAddedAnnotationNode;

  std::string m_StringHolder;

  char* m_MeasurementFormat;
  char* m_CoordinateFormat;

  // id of the currently active hierarchy node
  char *ActiveHierarchyNodeID;

  //
  // Private hierarchy functionality.
  //
  bool AddHierarchyNodeForAnnotation(vtkMRMLAnnotationNode* annotationNode=nullptr);

private:
  vtkSlicerAnnotationModuleLogic(const vtkSlicerAnnotationModuleLogic&) = delete;
  void operator=(const vtkSlicerAnnotationModuleLogic&) = delete;
};

#endif