vtkMRMLMarkupsNode.h

Go to the documentation of this file.

/*==============================================================================

  Program: 3D Slicer

  Portions (c) Copyright Brigham and Women's Hospital (BWH) All Rights Reserved.

  See COPYRIGHT.txt
  or http://www.slicer.org/copyright/copyright.txt for details.

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.

==============================================================================*/

#ifndef __vtkMRMLMarkupsNode_h
#define __vtkMRMLMarkupsNode_h

// MRML includes
#include "vtkMRMLDisplayableNode.h"

// Markups includes
#include "vtkSlicerMarkupsModuleMRMLExport.h"

// VTK includes
#include <vtkSmartPointer.h>
#include <vtkVector.h>

class vtkStringArray;
class vtkMatrix4x4;

typedef struct
{
  std::string ID;
  std::string Label;
  std::string Description;
  std::string AssociatedNodeID;
  std::vector < vtkVector3d> points;
  double OrientationWXYZ[4];
  bool Selected;
  bool Locked;
  bool Visibility;
} Markup;

class  VTK_SLICER_MARKUPS_MODULE_MRML_EXPORT vtkMRMLMarkupsNode : public vtkMRMLDisplayableNode
{
  friend class vtkMRMLMarkupsStorageNode;
  friend class vtkMRMLMarkupsFiducialStorageNode;

public:
  static vtkMRMLMarkupsNode *New();
  vtkTypeMacro(vtkMRMLMarkupsNode,vtkMRMLDisplayableNode);

  void PrintMarkup(ostream&  os, vtkIndent indent, Markup *markup);
  void PrintSelf(ostream& os, vtkIndent indent) VTK_OVERRIDE;

  virtual const char* GetIcon() {return "";};

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

  virtual vtkMRMLNode* CreateNodeInstance() VTK_OVERRIDE;
  virtual const char* GetNodeTagName() VTK_OVERRIDE {return "Markups";};

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

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

  virtual void WriteCLI(std::vector<std::string>& commandLine,
                        std::string prefix, int coordinateSystem = 0,
                        int multipleFlag = 1) VTK_OVERRIDE;

  virtual void Copy(vtkMRMLNode *node) VTK_OVERRIDE;

  void UpdateScene(vtkMRMLScene *scene) VTK_OVERRIDE;

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


  virtual vtkMRMLStorageNode* CreateDefaultStorageNode() VTK_OVERRIDE;

  int AddText(const char *newText);
  void SetText(int id, const char *newText);
  vtkStdString GetText(int id);
  int DeleteText(int id);
  int GetNumberOfTexts();
  void RemoveAllTexts();

  enum
  {
    LockModifiedEvent = 19000,
    LabelFormatModifiedEvent,
    PointModifiedEvent,
    PointStartInteractionEvent,
    PointEndInteractionEvent,
    PointClickedEvent,
    NthMarkupModifiedEvent,
    MarkupAddedEvent,
    MarkupRemovedEvent,
  };

  virtual void RemoveAllMarkups();

  vtkGetMacro(Locked, int);
  void SetLocked(int locked);
  vtkBooleanMacro(Locked, int);

  bool MarkupExists(int n);
  int GetNumberOfMarkups();
  bool PointExistsInMarkup(int p, int n);
  int GetNumberOfPointsInNthMarkup(int n);
  Markup * GetNthMarkup(int n);
  void InitMarkup(Markup *markup);
  int AddMarkup(Markup markup);
  int AddMarkupWithNPoints(int n, std::string label = std::string(), vtkVector3d* point = NULL);
  int AddPointToNewMarkup(vtkVector3d point, std::string label = std::string());
  int AddPointWorldToNewMarkup(vtkVector3d point, std::string label = std::string());
  int AddPointToNthMarkup(vtkVector3d point, int n);

  vtkVector3d GetMarkupPointVector(int markupIndex, int pointIndex);
  void GetMarkupPoint(int markupIndex, int pointIndex, double point[3]);
  void GetMarkupPointLPS(int markupIndex, int pointIndex, double point[3]);
  int GetMarkupPointWorld(int markupIndex, int pointIndex, double worldxyz[4]);

  void RemoveMarkup(int m);

  bool InsertMarkup(Markup m, int targetIndex);

  void CopyMarkup(Markup *source, Markup *target);

  void SwapMarkups(int m1, int m2);

  void SetMarkupPointFromPointer(const int markupIndex, const int pointIndex, const double * pos);
  void SetMarkupPointFromArray(const int markupIndex, const int pointIndex, const double pos[3]);
  void SetMarkupPoint(const int markupIndex, const int pointIndex, const double x, const double y, const double z);
  void SetMarkupPointLPS(const int markupIndex, const int pointIndex, const double x, const double y, const double z);
  void SetMarkupPointWorld(const int markupIndex, const int pointIndex, const double x, const double y, const double z);

  void SetNthMarkupOrientationFromPointer(int n, const double *orientation);
  void SetNthMarkupOrientationFromArray(int n, const double orientation[4]);
  void SetNthMarkupOrientation(int n, double w, double x, double y, double z);
  void GetNthMarkupOrientation(int n, double orientation[4]);

  std::string GetNthMarkupAssociatedNodeID(int n = 0);
  void SetNthMarkupAssociatedNodeID(int n, std::string id);

  std::string GetNthMarkupID(int n = 0);
  int GetMarkupIndexByID(const char* markupID);
  Markup* GetMarkupByID(const char* markupID);

  bool GetNthMarkupSelected(int n = 0);
  void SetNthMarkupSelected(int n, bool flag);
  bool GetNthMarkupLocked(int n = 0);
  void SetNthMarkupLocked(int n, bool flag);
  bool GetNthMarkupVisibility(int n = 0);
  void SetNthMarkupVisibility(int n, bool flag);
  std::string GetNthMarkupLabel(int n = 0);
  void SetNthMarkupLabel(int n, std::string label);
  std::string GetNthMarkupDescription(int n = 0);
  void SetNthMarkupDescription(int n, std::string description);

  // Transform utility functions

  virtual bool CanApplyNonLinearTransforms()const VTK_OVERRIDE;
  virtual void ApplyTransform(vtkAbstractTransform* transform) VTK_OVERRIDE;

  std::string GetMarkupLabelFormat();
  void SetMarkupLabelFormat(std::string format);

  std::string ReplaceListNameInMarkupLabelFormat();

  virtual bool GetModifiedSinceRead() VTK_OVERRIDE;

  bool ResetNthMarkupID(int n);

protected:
  vtkMRMLMarkupsNode();
  ~vtkMRMLMarkupsNode();
  vtkMRMLMarkupsNode(const vtkMRMLMarkupsNode&);
  void operator=(const vtkMRMLMarkupsNode&);

  vtkStringArray *TextList;

  void SetNthMarkupID(int n, std::string id);

  std::string GenerateUniqueMarkupID();;

private:
  std::vector < Markup > Markups;

  int Locked;

  std::string MarkupLabelFormat;

  // Keep track of the number of markups that were added to the list, always
  // incrementing, not decreasing when they're removed. Used to help create
  // unique names and ids. Reset to 0 when \sa RemoveAllMarkups called
  int MaximumNumberOfMarkups;
};

#endif