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"
#include "vtkCurveGenerator.h"
#include "vtkMRMLMeasurement.h"

// Markups includes
#include "vtkSlicerMarkupsModuleMRMLExport.h"

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

class vtkFrenetSerretFrame;
class vtkMRMLUnitNode;


class vtkAlgorithmOutput;
class vtkCollection;
class vtkDataArray;
class vtkGeneralTransform;
class vtkMatrix4x4;
class vtkMRMLMarkupsDisplayNode;
class vtkPolyData;
class vtkStringArray;
class vtkTransformPolyDataFilter;

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

public:

  struct ControlPoint
    {
    ControlPoint()
      {
      // position is 0
      this->Position[0] = 0.0;
      this->Position[1] = 0.0;
      this->Position[2] = 0.0;

      this->OrientationMatrix[0] = 1.0;
      this->OrientationMatrix[1] = 0.0;
      this->OrientationMatrix[2] = 0.0;

      this->OrientationMatrix[3] = 0.0;
      this->OrientationMatrix[4] = 1.0;
      this->OrientationMatrix[5] = 0.0;

      this->OrientationMatrix[6] = 0.0;
      this->OrientationMatrix[7] = 0.0;
      this->OrientationMatrix[8] = 1.0;

      Selected = true;
      Locked = false;
      Visibility = true;
      PositionStatus = PositionUndefined;
      }

    // Positions and orientation in local coordinates.
    // If transform is applied to the markup node then world
    // coordinates may be obtained by applying "to world" transform.
    double Position[3];
    // Orientation of x axis (0, 1, 2), y axis (3, 4, 5), and z axis (6, 7, 8).
    // This memory layout is chosen so that the normal (z axis) can be retrieved quickly.
    double OrientationMatrix[9];

    std::string ID;
    std::string Label;
    std::string Description;
    std::string AssociatedNodeID;

    bool Selected;
    bool Locked;
    bool Visibility;
    int PositionStatus;
    };

  typedef std::vector<ControlPoint*> ControlPointsListType;

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

  void PrintSelf(ostream& os, vtkIndent indent) override;

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

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

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

  void ReadXMLAttributes( const char** atts) override;

  void WriteXML(ostream& of, int indent) override;

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

  vtkMRMLCopyContentMacro(vtkMRMLMarkupsNode);

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


  vtkMRMLStorageNode* CreateDefaultStorageNode() override;

  void CreateDefaultDisplayNodes() override;


  int GetNumberOfMeasurements();
  int GetNumberOfEnabledMeasurements();
  vtkMRMLMeasurement* GetNthMeasurement(int id);
  vtkMRMLMeasurement* GetMeasurement(const char* name);
  void AddMeasurement(vtkMRMLMeasurement* measurement);
  void RemoveNthMeasurement(int id);
  void ClearValueForAllMeasurements();

  void UpdateAllMeasurements();


  void SetNthMeasurement(int id, vtkMRMLMeasurement* measurement);
  void SetNthMeasurement(int id, const std::string& name, double value, const std::string &units,
    std::string printFormat = "", const std::string description = "",
    vtkCodedEntry* quantityCode = nullptr, vtkCodedEntry* derivationCode = nullptr,
    vtkCodedEntry* unitsCode = nullptr, vtkCodedEntry* methodCode = nullptr);
  void RemoveAllMeasurements();

  enum
  {
    LockModifiedEvent = 19000,
    LabelFormatModifiedEvent,
    PointAddedEvent,
    PointRemovedEvent,
    PointPositionDefinedEvent, // point was not defined (undefined, preview position status, or non-existent point) before but now it is defined
    PointPositionUndefinedEvent, // point position was defined and now it is not defined anymore (point deleted or position is not defined)
    PointModifiedEvent,
    PointStartInteractionEvent,
    PointEndInteractionEvent,
    CenterPointModifiedEvent,
  };

  enum
  {
    PositionUndefined,
    PositionPreview,
    PositionDefined,
    PositionStatus_Last
  };

  static const char* GetPositionStatusAsString(int id);
  static int GetPositionStatusFromString(const char* name);

  virtual void RemoveAllControlPoints();

  void RemoveAllMarkups() { this->RemoveAllControlPoints(); };

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

  vtkMRMLMarkupsDisplayNode *GetMarkupsDisplayNode();

  bool ControlPointExists(int n);

  bool MarkupExists(int n) { return this->ControlPointExists(n); }
  int GetNumberOfControlPoints();
  int GetNumberOfDefinedControlPoints(bool includePreview=false);
  int GetNumberOfMarkups() { return this->GetNumberOfControlPoints(); };
  int GetNumberOfPointsInNthMarkup(int) { return this->GetNumberOfControlPoints(); };
  ControlPoint* GetNthControlPoint(int n);
  std::vector<ControlPoint*>* GetControlPoints();
  int AddNControlPoints(int n, std::string label = std::string(), vtkVector3d* point = nullptr);
  int AddControlPointWorld(vtkVector3d point, std::string label = std::string());
  int AddControlPoint(vtkVector3d point, std::string label = std::string());
  int AddControlPoint(ControlPoint *controlPoint, bool autoLabel=true);

  vtkVector3d GetNthControlPointPositionVector(int pointIndex);

  vtkVector3d GetMarkupPointVector(int markupIndex, int) { return this->GetNthControlPointPositionVector(markupIndex); };

  void GetMarkupPoint(int markupIndex, int pointIndex, double point[3]);

  void GetNthControlPointPosition(int pointIndex, double point[3]);
  double* GetNthControlPointPosition(int pointIndex);
  int GetNthControlPointPositionWorld(int pointIndex, double worldxyz[3]);

  int GetNthControlPointPositionStatus(int pointIndex);

  int GetNthControlPointIndexByPositionStatus(int pointIndex, int positionStatus);

  void UnsetNthControlPointPosition(int pointIndex);

  void RemoveNthControlPoint(int pointIndex);

  void RemoveMarkup(int pointIndex) { this->RemoveNthControlPoint(pointIndex); };

  bool InsertControlPoint(ControlPoint* controlPoint, int targetIndex);

  //Add and insert control point at index, defined in the world coordinate system.
  //\sa InsertControlPoint
  bool InsertControlPointWorld(int n, vtkVector3d pointWorld, std::string label = std::string());

  //Add and insert control point at index
  //\sa InsertControlPoint
  bool InsertControlPoint(int n, vtkVector3d point, std::string label = std::string());

  void SwapControlPoints(int m1, int m2);

  void SetNthControlPointPositionFromPointer(const int pointIndex, const double *pos);
  void SetNthControlPointPositionFromArray(const int pointIndex, const double pos[3], int positionStatus = PositionDefined);
  void SetNthControlPointPosition(const int pointIndex, const double x, const double y, const double z, int positionStatus = PositionDefined);
  void SetNthControlPointPositionWorld(const int pointIndex, const double x, const double y, const double z);
  void SetNthControlPointPositionWorldFromArray(const int pointIndex, const double pos[3], int positionStatus = PositionDefined);
  void SetNthControlPointPositionOrientationWorldFromArray(const int pointIndex,
    const double pos[3], const double orientationMatrix[9], const char* associatedNodeID, int positionStatus = PositionDefined);

  vtkVector3d GetCenterPositionVector();
  void GetCenterPosition(double point[3]);
  int GetCenterPositionWorld(double worldxyz[3]);
  void SetCenterPositionFromPointer(const double *pos);
  void SetCenterPositionFromArray(const double pos[3]);
  void SetCenterPosition(const double x, const double y, const double z);
  void SetCenterPositionWorld(const double x, const double y, const double z);

  void SetNthControlPointOrientationFromPointer(int n, const double *orientationWXYZ);
  void SetNthControlPointOrientationFromArray(int n, const double orientationWXYZ[4]);
  void SetNthControlPointOrientation(int n, double w, double x, double y, double z);
  void GetNthControlPointOrientation(int n, double orientationWXYZ[4]);
  double* GetNthControlPointOrientationMatrix(int n);
  void SetNthControlPointOrientationMatrix(int n, double orientationMatrix[9]);
  void SetNthControlPointOrientationMatrixWorld(int n, double orientationMatrix[9]);
  double* GetNthControlPointNormal(int n);
  void GetNthControlPointNormalWorld(int n, double normalWorld[3]);
  vtkVector4d GetNthControlPointOrientationVector(int pointIndex);

  std::string GetNthControlPointAssociatedNodeID(int n = 0);
  void SetNthControlPointAssociatedNodeID(int n, std::string id);

  std::string GetNthMarkupAssociatedNodeID(int n = 0) { return this->GetNthControlPointAssociatedNodeID(n); }
  void SetNthMarkupAssociatedNodeID(int n, std::string id) { this->SetNthControlPointAssociatedNodeID(n,id); }

  std::string GetNthControlPointID(int n);

  std::string GetNthMarkupID(int n = 0) { return this->GetNthControlPointID(n); }

  int GetNthControlPointIndexByID(const char* controlPointID);
  ControlPoint* GetNthControlPointByID(const char* controlPointID);

  bool GetNthControlPointSelected(int n = 0);
  void SetNthControlPointSelected(int n, bool flag);

  bool GetNthControlPointLocked(int n = 0);
  void SetNthControlPointLocked(int n, bool flag);

  bool GetNthMarkupLocked(int n = 0) { return this->GetNthControlPointLocked(n); };
  void SetNthMarkupLocked(int n, bool flag) { this->SetNthControlPointLocked(n, flag);  }

  bool GetNthControlPointVisibility(int n = 0);
  void SetNthControlPointVisibility(int n, bool flag);

  std::string GetNthControlPointLabel(int n = 0);
  void SetNthControlPointLabel(int n, std::string label);

  std::string GetNthMarkupLabel(int n = 0) { return this->GetNthControlPointLabel(n); }
  void SetNthMarkupLabel(int n, std::string label) { this->SetNthControlPointLabel(n, label); }

  std::string GetNthControlPointDescription(int n = 0);
  void SetNthControlPointDescription(int n, std::string description);

  bool CanApplyNonLinearTransforms()const override;
  void ApplyTransform(vtkAbstractTransform* transform) override;

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

  std::string ReplaceListNameInMarkupLabelFormat();

  bool GetModifiedSinceRead() override;

  bool ResetNthControlPointID(int n);

  vtkGetMacro(RequiredNumberOfControlPoints, int);

  vtkGetMacro(MaximumNumberOfControlPoints, int);

  // WXYZ: W rotation angle in degrees, XYZ is rotation axis.
  static void ConvertOrientationMatrixToWXYZ(const double orientationMatrix[9], double orientationWXYZ[4]);
  static void ConvertOrientationWXYZToMatrix(double orientationWXYZ[4], double orientationMatrix[9]);

  void GetControlPointLabels(vtkStringArray* labels);

  vtkPoints* GetCurvePoints();
  vtkPoints* GetCurvePointsWorld();

  vtkPolyData* GetCurve();
  vtkPolyData* GetCurveWorld();

  vtkAlgorithmOutput* GetCurveWorldConnection();

  vtkGetMacro(CurveClosed, bool);

  int GetControlPointIndexFromInterpolatedPointIndex(vtkIdType interpolatedPointIndex);

  vtkCurveGenerator* GetCurveGenerator() { return this->CurveGenerator.GetPointer(); };

  void GetRASBounds(double bounds[6]) override;
  void GetBounds(double bounds[6]) override;

  int GetClosestControlPointIndexToPositionWorld(double pos[3]);

  void SetControlPointPositionsWorld(vtkPoints* points);

  void GetControlPointPositionsWorld(vtkPoints* points);

  virtual vtkMatrix4x4* GetInteractionHandleToWorldMatrix();

  virtual std::string GetPropertiesLabelText();

  vtkMRMLUnitNode* GetUnitNode(const char* quantity);

  virtual void UpdateAssignedAttribute() {};

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

  vtkSmartPointer<vtkStringArray> TextList;

  bool SetControlPointLabelsWorld(vtkStringArray* labels, vtkPoints* points, std::string separator = "");

  ControlPoint* GetNthControlPointCustomLog(int n, const char* failedMethodName);

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

  std::string GenerateUniqueControlPointID();

  std::string GenerateControlPointLabel(int controlPointIndex);

  virtual void UpdateCurvePolyFromControlPoints();

  void OnTransformNodeReferenceChanged(vtkMRMLTransformNode* transformNode) override;

  virtual void UpdateMeasurementsInternal();

  virtual void WriteMeasurementsToDescription();

  virtual void UpdateInteractionHandleToWorldMatrix();

  int RequiredNumberOfControlPoints{0};
  int MaximumNumberOfControlPoints{0};

  bool CurveClosed{false};

  ControlPointsListType ControlPoints;

  vtkSmartPointer<vtkCurveGenerator> CurveGenerator;

  vtkSmartPointer<vtkFrenetSerretFrame> CurveCoordinateSystemGeneratorWorld;

  vtkSmartPointer<vtkPolyData> CurveInputPoly;

  vtkSmartPointer<vtkTransformPolyDataFilter> CurvePolyToWorldTransformer;
  vtkSmartPointer<vtkGeneralTransform> CurvePolyToWorldTransform;

  vtkSmartPointer<vtkPointLocator> TransformedCurvePolyLocator;

  int Locked{0};

  std::string MarkupLabelFormat{"%N-%d"};

  int LastUsedControlPointNumber{0};

  vtkVector3d CenterPos;

  vtkCollection* Measurements;

  std::string PropertiesLabelText;

  vtkSmartPointer<vtkMatrix4x4> InteractionHandleToWorldMatrix;

  bool IsUpdatingPoints{false};

  friend class qSlicerMarkupsModuleWidget; // To directly access measurements
};

#endif