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"
#include "vtkMRMLSelectionNode.h"
 
// Markups includes
#include "vtkMRMLExport.h"
 
// VTK includes
#include <vtkParallelTransportFrame.h>
#include <vtkPointLocator.h>
#include <vtkSmartPointer.h>
#include <vtkVector.h>
 
// VTK 9.3 does not have VTK_PROPEXCLUDE
#ifndef VTK_PROPEXCLUDE
# define VTK_PROPEXCLUDE
#endif
 
class vtkMatrix3x3;
class vtkMRMLUnitNode;

 
class vtkAlgorithmOutput;
class vtkCollection;
class vtkDataArray;
class vtkGeneralTransform;
class vtkMatrix4x4;
class vtkMRMLMarkupsDisplayNode;
class vtkPolyData;
class vtkStringArray;
class vtkTransformPolyDataFilter;
 
class VTK_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;
      AutoCreated = false;
    }
 
    // 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 control point in 3x3  matrix.
    // x axis (0, 3, 6), y axis (1, 4, 7), and z axis (2, 5, 8).
    double OrientationMatrix[9];
 
    std::string ID;
    std::string Label;
    std::string Description;
    std::string AssociatedNodeID;
 
    bool Selected;
    bool Locked;
    bool Visibility;
    int PositionStatus;
    bool AutoCreated;
  };
 
  typedef std::vector<ControlPoint*> ControlPointsListType;
 
  vtkTypeMacro(vtkMRMLMarkupsNode, vtkMRMLDisplayableNode);
 
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  virtual const char* GetIcon() { return ":/Icons/MarkupsGeneric.png"; }
  virtual const char* GetAddIcon() { return ":/Icons/MarkupsGenericMouseModePlace.png"; }
  virtual const char* GetPlaceAddIcon() { return ":/Icons/MarkupsGenericMouseModePlaceAdd.png"; }
 
  //--------------------------------------------------------------------------
  // MRMLNode methods
  //--------------------------------------------------------------------------

  virtual const char* GetMarkupType() { return "Markup"; };

  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 = vtkMRMLStorageNode::CoordinateSystemRAS, int multipleFlag = 1) override;

  vtkMRMLCopyContentMacro(vtkMRMLMarkupsNode);

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

  int EndModify(int previousDisableModifiedEventState) 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,               
    PointPositionUndefinedEvent,             
    PointPositionMissingEvent,               
    PointPositionNonMissingEvent,            
    PointModifiedEvent,                      
    PointStartInteractionEvent,              
    PointEndInteractionEvent,                
    CenterOfRotationModifiedEvent,           
    FixedNumberOfControlPointsModifiedEvent, 
    PointAboutToBeRemovedEvent,              
  };

  enum
  {
    PositionUndefined,  
    PositionPreview,    
    PositionDefined,    
    PositionMissing,    
    PositionStatus_Last 
  };
 
  static const char* GetPositionStatusAsString(int id);
  static int GetPositionStatusFromString(const char* name);

  virtual void RemoveAllControlPoints();
  virtual void UnsetAllControlPoints();

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

  vtkMRMLMarkupsDisplayNode* GetMarkupsDisplayNode();

  bool ControlPointExists(int n);

  int GetNumberOfControlPoints();
  int GetNumberOfMovableControlPoints();
  int GetNumberOfDefinedControlPoints(bool includePreview = false);
  int GetNumberOfUndefinedControlPoints(bool includePreview = false);

  ControlPoint* GetNthControlPoint(int n);
  std::vector<ControlPoint*>* GetControlPoints();

  int AddNControlPoints(int n, std::string label = std::string(), vtkVector3d* point = nullptr);
  int AddNControlPoints(int n, std::string label, double point[3]);

  void SetControlPointPositionsWorld(vtkPoints* points, bool setUndefinedPoints = true);

  void GetControlPointPositionsWorld(vtkPoints* points);

  int AddControlPoint(vtkVector3d point, std::string label = std::string());
  int AddControlPoint(double point[3], std::string label = std::string());
  int AddControlPoint(double x, double y, double z, std::string label = std::string());

  int AddControlPoint(ControlPoint* controlPoint, bool autoLabel = true);

  int AddControlPointWorld(vtkVector3d point, std::string label = std::string());
  int AddControlPointWorld(double point[3], std::string label = std::string());
  int AddControlPointWorld(double x, double y, double z, std::string label = std::string());

  bool InsertControlPoint(ControlPoint* controlPoint, int targetIndex);
  bool InsertControlPoint(int n, vtkVector3d point, std::string label = std::string());
  bool InsertControlPoint(int n, double point[3], std::string label = std::string());

  // 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());
  bool InsertControlPointWorld(int n, double pointWorld[3], std::string label = std::string());

  void RemoveNthControlPoint(int pointIndex);

  void SwapControlPoints(int m1, int m2);

  bool GetNthControlPointAutoCreated(int n);
  void SetNthControlPointAutoCreated(int n, bool flag);

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

  // Note: this method is not redundant because GetNthControlPointPosition returns a double*
  // (as it is safe to do so) and so the method that returns a vtkVector3d cannot have the same name.
  vtkVector3d GetNthControlPointPositionVector(int pointIndex);

  int GetNthControlPointPositionWorld(int pointIndex, double worldxyz[3]);
  vtkVector3d GetNthControlPointPositionWorld(int pointIndex);

  void SetNthControlPointPosition(const int pointIndex, const double x, const double y, const double z, int positionStatus = PositionDefined);
  void SetNthControlPointPosition(const int pointIndex, const double position[3], int positionStatus = PositionDefined);

  void SetNthControlPointPositionWorld(const int pointIndex, const double x, const double y, const double z, int positionStatus = PositionDefined);
  void SetNthControlPointPositionWorld(const int pointIndex, const double position[3], int positionStatus = PositionDefined);

  void SetNthControlPointPositionOrientationWorld(const int pointIndex,
                                                  const double pos[3],
                                                  const double orientationMatrix[9],
                                                  const char* associatedNodeID,
                                                  int positionStatus = PositionDefined);

  void SetNthControlPointOrientation(int n, double w, double x, double y, double z);
  void SetNthControlPointOrientation(int n, const double wxyz[4]);

  void GetNthControlPointOrientation(int n, double orientationWXYZ[4]);

  double* GetNthControlPointOrientationMatrix(int n) VTK_SIZEHINT(9);
  void SetNthControlPointOrientationMatrix(int n, double orientationMatrix[9]);

  void GetNthControlPointOrientationMatrix(int n, vtkMatrix3x3* matrix);
  void SetNthControlPointOrientationMatrix(int n, vtkMatrix3x3* matrix);

  void GetNthControlPointOrientationMatrixWorld(int n, double orientationMatrix[9]);
  vtkVector<double, 9> GetNthControlPointOrientationMatrixWorld(int n);
  void SetNthControlPointOrientationMatrixWorld(int n, const double orientationMatrix[9]);

  void GetNthControlPointOrientationMatrixWorld(int n, vtkMatrix3x3* matrix);
  void SetNthControlPointOrientationMatrixWorld(int n, vtkMatrix3x3* matrix);

  int GetNthControlPointPositionStatus(int pointIndex);

  int GetNthControlPointIndexByPositionStatus(int pointIndex, int positionStatus);

  void UnsetNthControlPointPosition(int pointIndex);

  VTK_PROPEXCLUDE void SetNthControlPointPositionMissing(int pointIndex);

  void ResetNthControlPointPosition(int n);

  void RestoreNthControlPointPosition(int n);

  vtkVector3d GetCenterOfRotation();

  bool GetCenterOfRotation(double point[3]);

  // \sa GetCenterOfRotation
  bool GetCenterOfRotationWorld(double worldxyz[3]);

  void SetCenterOfRotation(const double x, const double y, const double z);
  void SetCenterOfRotation(const double position[3]);

  void SetCenterOfRotationWorld(const double x, const double y, const double z);
  void SetCenterOfRotationWorld(const double positionWorld[3]);

  void GetNthControlPointNormal(int n, double normal[3]);
  vtkVector3d GetNthControlPointNormal(int n);

  void GetNthControlPointNormalWorld(int n, double normalWorld[3]);
  vtkVector3d GetNthControlPointNormalWorld(int n);

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

  std::string GetNthControlPointID(int n);

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

  int GetControlPointIndexByID(const char* id);
  int GetControlPointIndexByLabel(const char* label);
  int GetControlPointIndexByDescription(const char* description);

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

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

  bool GetNthControlPointVisibility(int n = 0);

  bool GetNthControlPointPositionVisibility(int n = 0);

  void SetNthControlPointVisibility(int n, bool flag);

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

  void GetControlPointLabels(vtkStringArray* labels);

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

  bool CanApplyNonLinearTransforms() const override;

  void ApplyTransform(vtkAbstractTransform* transform) override;
  virtual void ApplyTransform(vtkAbstractTransform* transform, bool applyToLockedControlPoints);

  std::string GetControlPointLabelFormat();
  void SetControlPointLabelFormat(std::string format);

  std::string ReplaceListNameInControlPointLabelFormat();

  bool GetModifiedSinceRead() override;

  bool ResetNthControlPointID(int n);

  bool GetFixedNumberOfControlPoints();
  void SetFixedNumberOfControlPoints(bool fixed);

  vtkGetMacro(RequiredNumberOfControlPoints, int);

  vtkGetMacro(MaximumNumberOfControlPoints, int);

  static void ConvertOrientationMatrixToWXYZ(const double orientationMatrix[9], double orientationWXYZ[4]);
  static void ConvertOrientationWXYZToMatrix(const double orientationWXYZ[4], double orientationMatrix[9]);

  virtual vtkPoints* GetCurvePoints();
  virtual vtkPoints* GetCurvePointsWorld();
  virtual vtkPolyData* GetCurve();
  virtual vtkPolyData* GetCurveWorld();
  virtual vtkAlgorithmOutput* GetCurveWorldConnection();

  int GetControlPointIndexFromInterpolatedPointIndex(vtkIdType interpolatedPointIndex);

  static bool BuildLineDirectionMarkers(vtkPoints* curvePoints,
                                        bool closedCurve,
                                        double spacing,
                                        vtkPoints* outPositions,
                                        vtkDoubleArray* outTangents,
                                        bool directionFirstToLastControlPoint = true);

  vtkGetMacro(CurveClosed, bool);

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

  vtkParallelTransportFrame* GetCurveCoordinateSystemGeneratorWorld() { return this->CurveCoordinateSystemGeneratorWorld.GetPointer(); };
 
  void GetRASBounds(double bounds[6]) override;
  void GetBounds(double bounds[6]) override;

  int GetClosestControlPointIndexToPositionWorld(double pos[3], bool visibleOnly = false);

  virtual vtkMatrix4x4* GetInteractionHandleToWorldMatrix();

  virtual std::string GetPropertiesLabelText();

  vtkMRMLUnitNode* GetUnitNode(const char* quantity);

  virtual void UpdateAssignedAttribute() {};

  virtual bool GetControlPointPlacementComplete();

  int GetControlPointPlacementStartIndex();
  void SetControlPointPlacementStartIndex(int);

  vtkGetMacro(LastUsedControlPointNumber, int);
  vtkSetMacro(LastUsedControlPointNumber, int);
 
  //-----------------------------------------------------------
  // All public methods below are deprecated
  //
  // These methods are either deprecated because they use old terms (markup instead of control point),
  // or include "array", "vector", "pointer" in the name (it is redundant, as input arguments can be
  // deduced from the type; and return type for vectors is always vtkVectorNd).
  //

  void RemoveAllMarkups()
  {
    vtkWarningMacro("vtkMRMLMarkupsNode::RemoveAllMarkups method is deprecated, please use RemoveAllControlPoints instead");
    this->RemoveAllControlPoints();
  };

  bool MarkupExists(int n)
  {
    vtkWarningMacro("vtkMRMLMarkupsNode::MarkupExists method is deprecated, please use ControlPointExists instead");
    return this->ControlPointExists(n);
  };

  int GetNumberOfMarkups()
  {
    vtkWarningMacro("vtkMRMLMarkupsNode::GetNumberOfMarkups method is deprecated, please use GetNumberOfControlPoints instead");
    return this->GetNumberOfControlPoints();
  };

  int GetNumberOfPointsInNthMarkup(int)
  {
    vtkWarningMacro("vtkMRMLMarkupsNode::GetNumberOfPointsInNthMarkup method is deprecated, please use GetNumberOfControlPoints instead");
    return this->GetNumberOfControlPoints();
  };

  vtkVector3d GetMarkupPointVector(int markupIndex, int)
  {
    vtkWarningMacro("vtkMRMLMarkupsNode::GetMarkupPointVector method is deprecated, please use GetNthControlPointPositionVector instead");
    return this->GetNthControlPointPositionVector(markupIndex);
  };

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

  void RemoveMarkup(int pointIndex)
  {
    vtkWarningMacro("vtkMRMLMarkupsNode::RemoveMarkup method is deprecated, please use RemoveNthControlPoint instead");
    this->RemoveNthControlPoint(pointIndex);
  };

  void SetNthControlPointPositionFromPointer(const int pointIndex, const double* pos);

  void SetNthControlPointPositionFromArray(const int pointIndex, const double pos[3], int positionStatus = PositionDefined)
  {
    vtkWarningMacro("vtkMRMLMarkupsNode::SetNthControlPointPositionFromArray method is deprecated, please use SetNthControlPointPosition instead");
    this->SetNthControlPointPosition(pointIndex, pos[0], pos[1], pos[2], positionStatus);
  }

  void SetNthControlPointPositionWorldFromArray(const int pointIndex, const double pos[3], int positionStatus = PositionDefined);

  void SetNthControlPointPositionOrientationWorldFromArray(const int pointIndex,
                                                           const double positionWorld[3],
                                                           const double orientationMatrix_World[9],
                                                           const char* associatedNodeID,
                                                           int positionStatus = PositionDefined)
  {
    vtkWarningMacro("vtkMRMLMarkupsNode::SetNthControlPointPositionOrientationWorldFromArray method is deprecated,"
                    << " please use SetNthControlPointPositionOrientationWorld instead");
    this->SetNthControlPointPositionOrientationWorld(pointIndex, positionWorld, orientationMatrix_World, associatedNodeID, positionStatus);
  }

  vtkVector4d GetNthControlPointOrientationVector(int pointIndex);

  vtkVector3d GetCenterOfRotationVector()
  {
    vtkWarningMacro("vtkMRMLMarkupsNode::GetCenterOfRotationVector method is deprecated, please use GetCenterOfRotation instead");
    return this->GetCenterOfRotation();
  }

  void SetCenterOfRotationFromPointer(const double* pos);
  void SetCenterOfRotationFromArray(const double pos[3])
  {
    vtkWarningMacro("vtkMRMLMarkupsNode::SetCenterOfRotationFromArray method is deprecated, please use SetCenterOfRotation instead");
    this->SetCenterOfRotation(pos[0], pos[1], pos[2]);
  }

  void SetNthControlPointOrientationFromPointer(int n, const double* orientationWXYZ);
  void SetNthControlPointOrientationFromArray(int n, const double orientationWXYZ[4])
  {
    vtkWarningMacro("vtkMRMLMarkupsNode::SetNthControlPointOrientationFromArray method is deprecated, please use SetNthControlPointOrientation instead");
    this->SetNthControlPointOrientation(n, orientationWXYZ[0], orientationWXYZ[1], orientationWXYZ[2], orientationWXYZ[3]);
  }


  std::string GetNthMarkupAssociatedNodeID(int n = 0)
  {
    vtkWarningMacro("vtkMRMLMarkupsNode::GetNthMarkupAssociatedNodeID method is deprecated, please use GetNthControlPointAssociatedNodeID instead");
    return this->GetNthControlPointAssociatedNodeID(n);
  };

  void SetNthMarkupAssociatedNodeID(int n, std::string id)
  {
    vtkWarningMacro("vtkMRMLMarkupsNode::SetNthMarkupAssociatedNodeID method is deprecated, please use SetNthControlPointAssociatedNodeID instead");
    this->SetNthControlPointAssociatedNodeID(n, id);
  };

  std::string GetNthMarkupID(int n = 0)
  {
    vtkWarningMacro("vtkMRMLMarkupsNode::GetNthMarkupID method is deprecated, please use GetNthControlPointID instead");
    return this->GetNthControlPointID(n);
  };

  bool GetNthMarkupLocked(int n = 0)
  {
    vtkWarningMacro("vtkMRMLMarkupsNode::GetNthMarkupLocked method is deprecated, please use GetNthControlPointLocked instead");
    return this->GetNthControlPointLocked(n);
  };

  void SetNthMarkupLocked(int n, bool flag)
  {
    vtkWarningMacro("vtkMRMLMarkupsNode::SetNthMarkupLocked method is deprecated, please use SetNthControlPointLocked instead");
    this->SetNthControlPointLocked(n, flag);
  };

  std::string GetNthMarkupLabel(int n = 0)
  {
    vtkWarningMacro("vtkMRMLMarkupsNode::GetNthMarkupLabel method is deprecated, please use GetNthControlPointLabel instead");
    return this->GetNthControlPointLabel(n);
  };

  void SetNthMarkupLabel(int n, std::string label)
  {
    vtkWarningMacro("vtkMRMLMarkupsNode::SetNthMarkupLabel method is deprecated, please use SetNthControlPointLabel instead");
    this->SetNthControlPointLabel(n, label);
  };

  std::string GetMarkupLabelFormat()
  {
    vtkWarningMacro("vtkMRMLMarkupsNode::GetMarkupLabelFormat method is deprecated, please use GetControlPointLabelFormat instead");
    return this->GetControlPointLabelFormat();
  };

  void SetMarkupLabelFormat(std::string format)
  {
    // Not warning this at the moment as existing scene files will contain the markupLabelFormat attribute name and would warn on load
    // vtkWarningMacro("vtkMRMLMarkupsNode::SetMarkupLabelFormat method is deprecated, please use SetControlPointLabelFormat instead");
    return this->SetControlPointLabelFormat(format);
  };

  std::string ReplaceListNameInMarkupLabelFormat()
  {
    vtkWarningMacro("vtkMRMLMarkupsNode::ReplaceListNameInMarkupLabelFormat method is deprecated, please use ReplaceListNameInControlPointLabelFormat instead");
    return this->ReplaceListNameInControlPointLabelFormat();
  };
 
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();

  virtual void TransformOrientationMatrixFromNodeToWorld(const double position_Node[3], const double orientationMatrix_Node[9], double orientationMatrix_World[9]);

  virtual void TransformOrientationMatrixFromWorldToNode(const double position_World[3], const double orientationMatrix_World[9], double orientationMatrix_Node[9]);

  int RequiredNumberOfControlPoints{ 0 };
  int MaximumNumberOfControlPoints{ -1 };
 
  bool CurveClosed{ false };

  ControlPointsListType ControlPoints;

  vtkSmartPointer<vtkCurveGenerator> CurveGenerator;

  vtkSmartPointer<vtkParallelTransportFrame> CurveCoordinateSystemGeneratorWorld;

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

  vtkSmartPointer<vtkPointLocator> TransformedCurvePolyLocator;

  int Locked{ 0 };

  bool FixedNumberOfControlPoints{ false };
 
  std::string ControlPointLabelFormat{ "%N-%d" };

  int LastUsedControlPointNumber{ 0 };

  int ControlPointPlacementStartIndex{ -1 };

  vtkVector3d CenterOfRotation;

  vtkCollection* Measurements;
 
  std::string PropertiesLabelText;

  vtkSmartPointer<vtkMatrix4x4> InteractionHandleToWorldMatrix;

  bool IsUpdatingPoints{ false };
 
  friend class qSlicerMarkupsModuleWidget; // To directly access measurements
};
 
#endif