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;

// STD includes
#include <string>

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

  // Start the place mode for annotations
  void StartPlaceMode(bool persistent=false);

  // Exit the place mode for annotations
  void StopPlaceMode(bool persistent=false);

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

  // Cancel the current annotation placement or remove last annotation node
  void CancelCurrentOrRemoveLastAddedAnnotationNode();

  void RemoveAnnotationNode(vtkMRMLAnnotationNode* annotationNode);

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

  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=0);

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

  
protected:

  vtkSlicerAnnotationModuleLogic();

  virtual ~vtkSlicerAnnotationModuleLogic();

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

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

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=0);


};

#endif