Slicer 5.9
Slicer is a multi-platform, free and open source software package for visualization and medical image computing
Loading...
Searching...
No Matches
vtkMRMLMarkupsNode.h
Go to the documentation of this file.
1/*==============================================================================
2
3 Program: 3D Slicer
4
5 Portions (c) Copyright Brigham and Women's Hospital (BWH) All Rights Reserved.
6
7 See COPYRIGHT.txt
8 or http://www.slicer.org/copyright/copyright.txt for details.
9
10 Unless required by applicable law or agreed to in writing, software
11 distributed under the License is distributed on an "AS IS" BASIS,
12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 See the License for the specific language governing permissions and
14 limitations under the License.
15
16==============================================================================*/
17
18#ifndef __vtkMRMLMarkupsNode_h
19#define __vtkMRMLMarkupsNode_h
20
21// MRML includes
23#include "vtkCurveGenerator.h"
24#include "vtkMRMLMeasurement.h"
26
27// Markups includes
28#include "vtkMRMLExport.h"
29
30// VTK includes
31#include <vtkParallelTransportFrame.h>
32#include <vtkPointLocator.h>
33#include <vtkSmartPointer.h>
34#include <vtkVector.h>
35
36// VTK 9.3 does not have VTK_PROPEXCLUDE
37#ifndef VTK_PROPEXCLUDE
38# define VTK_PROPEXCLUDE
39#endif
40
41class vtkMatrix3x3;
42class vtkMRMLUnitNode;
43
70
71class vtkAlgorithmOutput;
72class vtkCollection;
73class vtkDataArray;
74class vtkGeneralTransform;
75class vtkMatrix4x4;
77class vtkPolyData;
78class vtkStringArray;
79class vtkTransformPolyDataFilter;
80
81class VTK_MRML_EXPORT vtkMRMLMarkupsNode : public vtkMRMLDisplayableNode
82{
87
88public:
90 {
92 {
93 // position is 0
94 this->Position[0] = 0.0;
95 this->Position[1] = 0.0;
96 this->Position[2] = 0.0;
97
98 this->OrientationMatrix[0] = 1.0;
99 this->OrientationMatrix[1] = 0.0;
100 this->OrientationMatrix[2] = 0.0;
101
102 this->OrientationMatrix[3] = 0.0;
103 this->OrientationMatrix[4] = 1.0;
104 this->OrientationMatrix[5] = 0.0;
105
106 this->OrientationMatrix[6] = 0.0;
107 this->OrientationMatrix[7] = 0.0;
108 this->OrientationMatrix[8] = 1.0;
109
110 Selected = true;
111 Locked = false;
112 Visibility = true;
114 AutoCreated = false;
115 }
116
117 // Positions and orientation in local coordinates.
118 // If transform is applied to the markup node then world
119 // coordinates may be obtained by applying "to world" transform.
120 double Position[3];
121 // Orientation of control point in 3x3 matrix.
122 // x axis (0, 3, 6), y axis (1, 4, 7), and z axis (2, 5, 8).
124
125 std::string ID;
126 std::string Label;
127 std::string Description;
128 std::string AssociatedNodeID;
129
131 bool Locked;
135 };
136
137 typedef std::vector<ControlPoint*> ControlPointsListType;
138
140
141 void PrintSelf(ostream& os, vtkIndent indent) override;
142
143 virtual const char* GetIcon() { return ":/Icons/MarkupsGeneric.png"; }
144 virtual const char* GetAddIcon() { return ":/Icons/MarkupsGenericMouseModePlace.png"; }
145 virtual const char* GetPlaceAddIcon() { return ":/Icons/MarkupsGenericMouseModePlaceAdd.png"; }
146
147 //--------------------------------------------------------------------------
148 // MRMLNode methods
149 //--------------------------------------------------------------------------
150
153 virtual const char* GetMarkupType() { return "Markup"; };
154
156 void ReadXMLAttributes(const char** atts) override;
157
159 void WriteXML(ostream& of, int indent) override;
160
165 void WriteCLI(std::vector<std::string>& commandLine, std::string prefix, int coordinateSystem = vtkMRMLStorageNode::CoordinateSystemRAS, int multipleFlag = 1) override;
166
170
172 void ProcessMRMLEvents(vtkObject* /*caller*/, unsigned long /*event*/, void* /*callData*/) override;
173
177 int EndModify(int previousDisableModifiedEventState) override;
178
181
184
186
198
202
204
213 void SetNthMeasurement(int id, vtkMRMLMeasurement* measurement);
214 void SetNthMeasurement(int id,
215 const std::string& name,
216 double value,
217 const std::string& units,
218 std::string printFormat = "",
219 const std::string description = "",
220 vtkCodedEntry* quantityCode = nullptr,
221 vtkCodedEntry* derivationCode = nullptr,
222 vtkCodedEntry* unitsCode = nullptr,
223 vtkCodedEntry* methodCode = nullptr);
226
234 enum
235 {
251 };
252
254 enum
255 {
261 };
262
263 static const char* GetPositionStatusAsString(int id);
264 static int GetPositionStatusFromString(const char* name);
265
268 virtual void UnsetAllControlPoints();
269
278 vtkGetMacro(Locked, int);
279 void SetLocked(int locked);
280 vtkBooleanMacro(Locked, int);
282
285
288
294 int GetNumberOfDefinedControlPoints(bool includePreview = false);
296 int GetNumberOfUndefinedControlPoints(bool includePreview = false);
297
301 std::vector<ControlPoint*>* GetControlPoints();
302
310 int AddNControlPoints(int n, std::string label = std::string(), vtkVector3d* point = nullptr);
311 int AddNControlPoints(int n, std::string label, double point[3]);
313
319 void SetControlPointPositionsWorld(vtkPoints* points, bool setUndefinedPoints = true);
320
322 void GetControlPointPositionsWorld(vtkPoints* points);
323
326 int AddControlPoint(vtkVector3d point, std::string label = std::string());
327 int AddControlPoint(double point[3], std::string label = std::string());
328 int AddControlPoint(double x, double y, double z, std::string label = std::string());
330
336 int AddControlPoint(ControlPoint* controlPoint, bool autoLabel = true);
337
341 int AddControlPointWorld(vtkVector3d point, std::string label = std::string());
342 int AddControlPointWorld(double point[3], std::string label = std::string());
343 int AddControlPointWorld(double x, double y, double z, std::string label = std::string());
345
353 bool InsertControlPoint(ControlPoint* controlPoint, int targetIndex);
354 bool InsertControlPoint(int n, vtkVector3d point, std::string label = std::string());
355 bool InsertControlPoint(int n, double point[3], std::string label = std::string());
357
359 // Add and insert control point at index, defined in the world coordinate system.
360 //\sa InsertControlPoint
361 bool InsertControlPointWorld(int n, vtkVector3d pointWorld, std::string label = std::string());
362 bool InsertControlPointWorld(int n, double pointWorld[3], std::string label = std::string());
364
366 void RemoveNthControlPoint(int pointIndex);
367
369 void SwapControlPoints(int m1, int m2);
370
374 void SetNthControlPointAutoCreated(int n, bool flag);
376
380 void GetNthControlPointPosition(int pointIndex, double point[3]);
381 double* GetNthControlPointPosition(int pointIndex) VTK_SIZEHINT(3);
383
386 // Note: this method is not redundant because GetNthControlPointPosition returns a double*
387 // (as it is safe to do so) and so the method that returns a vtkVector3d cannot have the same name.
388 vtkVector3d GetNthControlPointPositionVector(int pointIndex);
389
393 int GetNthControlPointPositionWorld(int pointIndex, double worldxyz[3]);
394 vtkVector3d GetNthControlPointPositionWorld(int pointIndex);
396
399 void SetNthControlPointPosition(const int pointIndex, const double x, const double y, const double z, int positionStatus = PositionDefined);
400 void SetNthControlPointPosition(const int pointIndex, const double position[3], int positionStatus = PositionDefined);
402
407 void SetNthControlPointPositionWorld(const int pointIndex, const double x, const double y, const double z, int positionStatus = PositionDefined);
408 void SetNthControlPointPositionWorld(const int pointIndex, const double position[3], int positionStatus = PositionDefined);
410
415 const double pos[3],
416 const double orientationMatrix[9],
417 const char* associatedNodeID,
418 int positionStatus = PositionDefined);
419
423 void SetNthControlPointOrientation(int n, double w, double x, double y, double z);
424 void SetNthControlPointOrientation(int n, const double wxyz[4]);
426
429 void GetNthControlPointOrientation(int n, double orientationWXYZ[4]);
430
434 double* GetNthControlPointOrientationMatrix(int n) VTK_SIZEHINT(9);
435 void SetNthControlPointOrientationMatrix(int n, double orientationMatrix[9]);
437
440 void GetNthControlPointOrientationMatrix(int n, vtkMatrix3x3* matrix);
441 void SetNthControlPointOrientationMatrix(int n, vtkMatrix3x3* matrix);
443
447 void GetNthControlPointOrientationMatrixWorld(int n, double orientationMatrix[9]);
448 vtkVector<double, 9> GetNthControlPointOrientationMatrixWorld(int n);
449 void SetNthControlPointOrientationMatrixWorld(int n, const double orientationMatrix[9]);
451
454 void GetNthControlPointOrientationMatrixWorld(int n, vtkMatrix3x3* matrix);
455 void SetNthControlPointOrientationMatrixWorld(int n, vtkMatrix3x3* matrix);
457
460
465 int GetNthControlPointIndexByPositionStatus(int pointIndex, int positionStatus);
466
468 void UnsetNthControlPointPosition(int pointIndex);
469
472
475
478
482 vtkVector3d GetCenterOfRotation();
483
487 bool GetCenterOfRotation(double point[3]);
488
492 // \sa GetCenterOfRotation
493 bool GetCenterOfRotationWorld(double worldxyz[3]);
494
498 void SetCenterOfRotation(const double x, const double y, const double z);
499 void SetCenterOfRotation(const double position[3]);
501
505 void SetCenterOfRotationWorld(const double x, const double y, const double z);
506 void SetCenterOfRotationWorld(const double positionWorld[3]);
508
511 void GetNthControlPointNormal(int n, double normal[3]);
512 vtkVector3d GetNthControlPointNormal(int n);
514
517 void GetNthControlPointNormalWorld(int n, double normalWorld[3]);
520
524 void SetNthControlPointAssociatedNodeID(int n, std::string id);
526
528 std::string GetNthControlPointID(int n);
529
532 int GetNthControlPointIndexByID(const char* controlPointID);
534 ControlPoint* GetNthControlPointByID(const char* controlPointID);
535
539 int GetControlPointIndexByID(const char* id);
540 int GetControlPointIndexByLabel(const char* label);
541 int GetControlPointIndexByDescription(const char* description);
543
549 void SetNthControlPointSelected(int n, bool flag);
550
560 void SetNthControlPointLocked(int n, bool flag);
561
565
570
578 void SetNthControlPointVisibility(int n, bool flag);
579
582 std::string GetNthControlPointLabel(int n = 0);
583 void SetNthControlPointLabel(int n, std::string label);
585
587 void GetControlPointLabels(vtkStringArray* labels);
588
592 std::string GetNthControlPointDescription(int n = 0);
593 void SetNthControlPointDescription(int n, std::string description);
595
598 bool CanApplyNonLinearTransforms() const override;
599
602 void ApplyTransform(vtkAbstractTransform* transform) override;
603 virtual void ApplyTransform(vtkAbstractTransform* transform, bool applyToLockedControlPoints);
604
614 void SetControlPointLabelFormat(std::string format);
616
622
630 bool GetModifiedSinceRead() override;
631
636
644
649
659
663 static void ConvertOrientationMatrixToWXYZ(const double orientationMatrix[9], double orientationWXYZ[4]);
664 static void ConvertOrientationWXYZToMatrix(const double orientationWXYZ[4], double orientationMatrix[9]);
666
669 virtual vtkPoints* GetCurvePoints();
670 virtual vtkPoints* GetCurvePointsWorld();
671 virtual vtkPolyData* GetCurve();
672 virtual vtkPolyData* GetCurveWorld();
673 virtual vtkAlgorithmOutput* GetCurveWorldConnection();
675
677 int GetControlPointIndexFromInterpolatedPointIndex(vtkIdType interpolatedPointIndex);
678
680 vtkGetMacro(CurveClosed, bool);
681
685 vtkCurveGenerator* GetCurveGenerator() { return this->CurveGenerator.GetPointer(); };
686
689 vtkParallelTransportFrame* GetCurveCoordinateSystemGeneratorWorld() { return this->CurveCoordinateSystemGeneratorWorld.GetPointer(); };
690
691 void GetRASBounds(double bounds[6]) override;
692 void GetBounds(double bounds[6]) override;
693
696 int GetClosestControlPointIndexToPositionWorld(double pos[3], bool visibleOnly = false);
697
699 virtual vtkMatrix4x4* GetInteractionHandleToWorldMatrix();
700
703 virtual std::string GetPropertiesLabelText();
704
706 vtkMRMLUnitNode* GetUnitNode(const char* quantity);
707
710 virtual void UpdateAssignedAttribute() {};
711
714
725
730 vtkGetMacro(LastUsedControlPointNumber, int);
731 vtkSetMacro(LastUsedControlPointNumber, int);
733
734 //-----------------------------------------------------------
735 // All public methods below are deprecated
736 //
737 // These methods are either deprecated because they use old terms (markup instead of control point),
738 // or include "array", "vector", "pointer" in the name (it is redundant, as input arguments can be
739 // deduced from the type; and return type for vectors is always vtkVectorNd).
740 //
741
744 {
745 vtkWarningMacro("vtkMRMLMarkupsNode::RemoveAllMarkups method is deprecated, please use RemoveAllControlPoints instead");
747 };
748
750 bool MarkupExists(int n)
751 {
752 vtkWarningMacro("vtkMRMLMarkupsNode::MarkupExists method is deprecated, please use ControlPointExists instead");
753 return this->ControlPointExists(n);
754 };
755
758 {
759 vtkWarningMacro("vtkMRMLMarkupsNode::GetNumberOfMarkups method is deprecated, please use GetNumberOfControlPoints instead");
760 return this->GetNumberOfControlPoints();
761 };
762
764 {
765 vtkWarningMacro("vtkMRMLMarkupsNode::GetNumberOfPointsInNthMarkup method is deprecated, please use GetNumberOfControlPoints instead");
766 return this->GetNumberOfControlPoints();
767 };
768
770 vtkVector3d GetMarkupPointVector(int markupIndex, int)
771 {
772 vtkWarningMacro("vtkMRMLMarkupsNode::GetMarkupPointVector method is deprecated, please use GetNthControlPointPositionVector instead");
773 return this->GetNthControlPointPositionVector(markupIndex);
774 };
775
777 void GetMarkupPoint(int markupIndex, int pointIndex, double point[3]);
778
780 void RemoveMarkup(int pointIndex)
781 {
782 vtkWarningMacro("vtkMRMLMarkupsNode::RemoveMarkup method is deprecated, please use RemoveNthControlPoint instead");
783 this->RemoveNthControlPoint(pointIndex);
784 };
785
789 void SetNthControlPointPositionFromPointer(const int pointIndex, const double* pos);
790
793 void SetNthControlPointPositionFromArray(const int pointIndex, const double pos[3], int positionStatus = PositionDefined)
794 {
795 vtkWarningMacro("vtkMRMLMarkupsNode::SetNthControlPointPositionFromArray method is deprecated, please use SetNthControlPointPosition instead");
796 this->SetNthControlPointPosition(pointIndex, pos[0], pos[1], pos[2], positionStatus);
797 }
798
802 void SetNthControlPointPositionWorldFromArray(const int pointIndex, const double pos[3], int positionStatus = PositionDefined);
803
809 const double positionWorld[3],
810 const double orientationMatrix_World[9],
811 const char* associatedNodeID,
812 int positionStatus = PositionDefined)
813 {
814 vtkWarningMacro("vtkMRMLMarkupsNode::SetNthControlPointPositionOrientationWorldFromArray method is deprecated,"
815 << " please use SetNthControlPointPositionOrientationWorld instead");
816 this->SetNthControlPointPositionOrientationWorld(pointIndex, positionWorld, orientationMatrix_World, associatedNodeID, positionStatus);
817 }
818
824 vtkVector4d GetNthControlPointOrientationVector(int pointIndex);
825
830 {
831 vtkWarningMacro("vtkMRMLMarkupsNode::GetCenterOfRotationVector method is deprecated, please use GetCenterOfRotation instead");
832 return this->GetCenterOfRotation();
833 }
834
838 void SetCenterOfRotationFromPointer(const double* pos);
842 void SetCenterOfRotationFromArray(const double pos[3])
843 {
844 vtkWarningMacro("vtkMRMLMarkupsNode::SetCenterOfRotationFromArray method is deprecated, please use SetCenterOfRotation instead");
845 this->SetCenterOfRotation(pos[0], pos[1], pos[2]);
846 }
847
852 void SetNthControlPointOrientationFromPointer(int n, const double* orientationWXYZ);
853 void SetNthControlPointOrientationFromArray(int n, const double orientationWXYZ[4])
854 {
855 vtkWarningMacro("vtkMRMLMarkupsNode::SetNthControlPointOrientationFromArray method is deprecated, please use SetNthControlPointOrientation instead");
856 this->SetNthControlPointOrientation(n, orientationWXYZ[0], orientationWXYZ[1], orientationWXYZ[2], orientationWXYZ[3]);
857 }
858
859
861 std::string GetNthMarkupAssociatedNodeID(int n = 0)
862 {
863 vtkWarningMacro("vtkMRMLMarkupsNode::GetNthMarkupAssociatedNodeID method is deprecated, please use GetNthControlPointAssociatedNodeID instead");
865 };
866
867 void SetNthMarkupAssociatedNodeID(int n, std::string id)
868 {
869 vtkWarningMacro("vtkMRMLMarkupsNode::SetNthMarkupAssociatedNodeID method is deprecated, please use SetNthControlPointAssociatedNodeID instead");
871 };
872
874 std::string GetNthMarkupID(int n = 0)
875 {
876 vtkWarningMacro("vtkMRMLMarkupsNode::GetNthMarkupID method is deprecated, please use GetNthControlPointID instead");
877 return this->GetNthControlPointID(n);
878 };
879
881 bool GetNthMarkupLocked(int n = 0)
882 {
883 vtkWarningMacro("vtkMRMLMarkupsNode::GetNthMarkupLocked method is deprecated, please use GetNthControlPointLocked instead");
884 return this->GetNthControlPointLocked(n);
885 };
886
887 void SetNthMarkupLocked(int n, bool flag)
888 {
889 vtkWarningMacro("vtkMRMLMarkupsNode::SetNthMarkupLocked method is deprecated, please use SetNthControlPointLocked instead");
890 this->SetNthControlPointLocked(n, flag);
891 };
892
894 std::string GetNthMarkupLabel(int n = 0)
895 {
896 vtkWarningMacro("vtkMRMLMarkupsNode::GetNthMarkupLabel method is deprecated, please use GetNthControlPointLabel instead");
897 return this->GetNthControlPointLabel(n);
898 };
899
900 void SetNthMarkupLabel(int n, std::string label)
901 {
902 vtkWarningMacro("vtkMRMLMarkupsNode::SetNthMarkupLabel method is deprecated, please use SetNthControlPointLabel instead");
903 this->SetNthControlPointLabel(n, label);
904 };
905
907 {
908 vtkWarningMacro("vtkMRMLMarkupsNode::GetMarkupLabelFormat method is deprecated, please use GetControlPointLabelFormat instead");
909 return this->GetControlPointLabelFormat();
910 };
911
912 void SetMarkupLabelFormat(std::string format)
913 {
914 // Not warning this at the moment as existing scene files will contain the markupLabelFormat attribute name and would warn on load
915 // vtkWarningMacro("vtkMRMLMarkupsNode::SetMarkupLabelFormat method is deprecated, please use SetControlPointLabelFormat instead");
916 return this->SetControlPointLabelFormat(format);
917 };
918
920 {
921 vtkWarningMacro("vtkMRMLMarkupsNode::ReplaceListNameInMarkupLabelFormat method is deprecated, please use ReplaceListNameInControlPointLabelFormat instead");
923 };
924
925protected:
930
931 vtkSmartPointer<vtkStringArray> TextList;
932
938 bool SetControlPointLabelsWorld(vtkStringArray* labels, vtkPoints* points, std::string separator = "");
939
943 ControlPoint* GetNthControlPointCustomLog(int n, const char* failedMethodName);
944
948 void SetNthControlPointID(int n, std::string id);
949
954
955 std::string GenerateControlPointLabel(int controlPointIndex);
956
958
960
964
968
971
973 virtual void TransformOrientationMatrixFromNodeToWorld(const double position_Node[3], const double orientationMatrix_Node[9], double orientationMatrix_World[9]);
974
976 virtual void TransformOrientationMatrixFromWorldToNode(const double position_World[3], const double orientationMatrix_World[9], double orientationMatrix_Node[9]);
977
984
985 bool CurveClosed{ false };
986
989
991 vtkSmartPointer<vtkCurveGenerator> CurveGenerator;
992
997 vtkSmartPointer<vtkParallelTransportFrame> CurveCoordinateSystemGeneratorWorld;
998
1001 vtkSmartPointer<vtkPolyData> CurveInputPoly;
1002
1003 vtkSmartPointer<vtkTransformPolyDataFilter> CurvePolyToWorldTransformer;
1004 vtkSmartPointer<vtkGeneralTransform> CurvePolyToWorldTransform;
1005
1008 vtkSmartPointer<vtkPointLocator> TransformedCurvePolyLocator;
1009
1011 int Locked{ 0 };
1012
1016
1017 std::string ControlPointLabelFormat{ "%N-%d" };
1018
1023
1026
1029 vtkVector3d CenterOfRotation;
1030
1032 vtkCollection* Measurements;
1033
1035
1037 vtkSmartPointer<vtkMatrix4x4> InteractionHandleToWorldMatrix;
1038
1040 bool IsUpdatingPoints{ false };
1041
1042 friend class qSlicerMarkupsModuleWidget; // To directly access measurements
1043};
1044
1045#endif
Simple class for storing standard coded entries (coding scheme, value, meaning triplets)
friend class vtkMRMLMarkupsFiducialStorageNode
vtkParallelTransportFrame * GetCurveCoordinateSystemGeneratorWorld()
void SetNthControlPointOrientationFromArray(int n, const double orientationWXYZ[4])
void GetNthControlPointNormalWorld(int n, double normalWorld[3])
void GetControlPointPositionsWorld(vtkPoints *points)
Get a copy of all control point positions in world coordinate system.
void ClearValueForAllMeasurements()
void SetCenterOfRotationWorld(const double x, const double y, const double z)
int GetNthControlPointPositionWorld(int pointIndex, double worldxyz[3])
bool GetNthControlPointSelected(int n=0)
friend class qSlicerMarkupsModuleWidget
void ProcessMRMLEvents(vtkObject *, unsigned long, void *) override
Alternative method to propagate events generated in Display nodes.
virtual bool GetControlPointPlacementComplete()
Returns true if no additional control points can be added to this node.
vtkMRMLUnitNode * GetUnitNode(const char *quantity)
Utility function to get unit node from scene.
vtkMRMLMarkupsNode(const vtkMRMLMarkupsNode &)
vtkMRMLStorageNode * CreateDefaultStorageNode() override
Create default storage node or nullptr if does not have one.
void ApplyTransform(vtkAbstractTransform *transform) override
bool GetNthMarkupLocked(int n=0)
int AddControlPointWorld(double point[3], std::string label=std::string())
void SetNthControlPointOrientationMatrix(int n, double orientationMatrix[9])
bool GetNthControlPointAutoCreated(int n)
void GetNthControlPointOrientationMatrixWorld(int n, vtkMatrix3x3 *matrix)
std::vector< ControlPoint * > ControlPointsListType
VTK_PROPEXCLUDE void SetNthControlPointPositionMissing(int pointIndex)
Set control point status to ignored.
void GetNthControlPointOrientationMatrix(int n, vtkMatrix3x3 *matrix)
int GetNthControlPointIndexByPositionStatus(int pointIndex, int positionStatus)
vtkSmartPointer< vtkParallelTransportFrame > CurveCoordinateSystemGeneratorWorld
vtkMRMLMeasurement * GetMeasurement(const char *name)
std::string GetNthMarkupLabel(int n=0)
void UpdateAllMeasurements()
int AddNControlPoints(int n, std::string label=std::string(), vtkVector3d *point=nullptr)
void GetControlPointLabels(vtkStringArray *labels)
Get all control point labels at once.
int GetControlPointIndexByID(const char *id)
void SetNthControlPointPositionOrientationWorldFromArray(const int pointIndex, const double positionWorld[3], const double orientationMatrix_World[9], const char *associatedNodeID, int positionStatus=PositionDefined)
virtual vtkPolyData * GetCurveWorld()
virtual vtkPoints * GetCurvePoints()
bool InsertControlPointWorld(int n, double pointWorld[3], std::string label=std::string())
bool InsertControlPoint(int n, vtkVector3d point, std::string label=std::string())
void SetNthControlPointOrientation(int n, double w, double x, double y, double z)
friend class vtkMRMLMarkupsJsonStorageNode
ControlPoint * GetNthControlPointCustomLog(int n, const char *failedMethodName)
int ControlPointPlacementStartIndex
Index of the control point index that placement is started from (if no other point is requested speci...
std::string GetControlPointLabelFormat()
virtual void TransformOrientationMatrixFromWorldToNode(const double position_World[3], const double orientationMatrix_World[9], double orientationMatrix_Node[9])
Transform the orientation matrix from world to node coordinates.
virtual const char * GetPlaceAddIcon()
void SetFixedNumberOfControlPoints(bool fixed)
int Locked
Locks all the points and GUI.
void UnsetNthControlPointPosition(int pointIndex)
Set control point status to undefined.
void SetControlPointPlacementStartIndex(int)
void SetNthControlPointID(int n, std::string id)
bool ResetNthControlPointID(int n)
void WriteXML(ostream &of, int indent) override
Write this node's information to a MRML file in XML format.
int GetNthControlPointPositionStatus(int pointIndex)
Get control point position status (PositionUndefined, PositionPreview, PositionDefined)
virtual void UpdateCurvePolyFromControlPoints()
void AddMeasurement(vtkMRMLMeasurement *measurement)
vtkSmartPointer< vtkTransformPolyDataFilter > CurvePolyToWorldTransformer
int AddControlPoint(ControlPoint *controlPoint, bool autoLabel=true)
void SetNthControlPointAssociatedNodeID(int n, std::string id)
void SetNthControlPointVisibility(int n, bool flag)
int GetNumberOfMovableControlPoints()
Return the number of unlocked control points with defined position in this node.
virtual void UpdateAssignedAttribute()
virtual vtkPoints * GetCurvePointsWorld()
double * GetNthControlPointPosition(int pointIndex) VTK_SIZEHINT(3)
bool GetNthControlPointLocked(int n=0)
static int GetPositionStatusFromString(const char *name)
void SetNthControlPointPosition(const int pointIndex, const double x, const double y, const double z, int positionStatus=PositionDefined)
void GetNthControlPointOrientationMatrixWorld(int n, double orientationMatrix[9])
void SetNthControlPointOrientationFromPointer(int n, const double *orientationWXYZ)
void GetNthControlPointPosition(int pointIndex, double point[3])
void SetNthMarkupLabel(int n, std::string label)
static void ConvertOrientationWXYZToMatrix(const double orientationWXYZ[4], double orientationMatrix[9])
bool IsUpdatingPoints
Flag set from SetControlPointPositionsWorld that pauses update of measurements until the update is co...
virtual void TransformOrientationMatrixFromNodeToWorld(const double position_Node[3], const double orientationMatrix_Node[9], double orientationMatrix_World[9])
Transform the orientation matrix from node to world coordinates.
vtkSmartPointer< vtkPolyData > CurveInputPoly
bool SetControlPointLabelsWorld(vtkStringArray *labels, vtkPoints *points, std::string separator="")
vtkMRMLCopyContentMacro(vtkMRMLMarkupsNode)
int GetNthControlPointIndexByID(const char *controlPointID)
vtkVector3d GetCenterOfRotationVector()
std::string GetMarkupLabelFormat()
double * GetNthControlPointOrientationMatrix(int n) VTK_SIZEHINT(9)
int GetNumberOfUndefinedControlPoints(bool includePreview=false)
Return the number of control points that have not been placed (not being previewed or skipped).
~vtkMRMLMarkupsNode() override
void SetNthMarkupAssociatedNodeID(int n, std::string id)
vtkSmartPointer< vtkMatrix4x4 > InteractionHandleToWorldMatrix
Transform that moves the xyz unit vectors and origin of the interaction handles to local coordinates.
int GetClosestControlPointIndexToPositionWorld(double pos[3], bool visibleOnly=false)
bool InsertControlPoint(ControlPoint *controlPoint, int targetIndex)
void SetControlPointLabelFormat(std::string format)
void SetNthControlPointPositionFromPointer(const int pointIndex, const double *pos)
virtual void UpdateMeasurementsInternal()
bool GetModifiedSinceRead() override
void CreateDefaultDisplayNodes() override
Create and observe default display node(s)
void SetNthControlPointPositionOrientationWorld(const int pointIndex, const double pos[3], const double orientationMatrix[9], const char *associatedNodeID, int positionStatus=PositionDefined)
std::string GenerateControlPointLabel(int controlPointIndex)
@ PointRemovedEvent
Control point(s) deleted. Modified event is NOT invoked.
@ PointPositionNonMissingEvent
Point missing before and now it is not missing.
@ LockModifiedEvent
Markups node lock status is changed. Modified event is invoked, too.
@ PointAboutToBeRemovedEvent
Point is about to be deleted. Thus it is alive when event is called.
@ CenterOfRotationModifiedEvent
When position of the center of rotation is changed (used for example for rotating closed curves).
@ PointModifiedEvent
Existing control point(s) modified, added, or removed. Modified event is NOT invoked.
@ FixedNumberOfControlPointsModifiedEvent
When fixed number of points set/unset.
@ PointAddedEvent
New control point(s) added. Modified event is NOT invoked.
@ PointPositionUndefinedEvent
Point position was defined and now it is not defined anymore (point deleted or position is not define...
@ LabelFormatModifiedEvent
Markups node label format changed. Modified event is invoked, too.
@ PointEndInteractionEvent
When an interaction with a control point process finishes.
@ PointPositionMissingEvent
Point was not not missing before and now it is missing.
@ PointStartInteractionEvent
When starting interacting with a control point.
static const char * GetPositionStatusAsString(int id)
vtkVector4d GetNthControlPointOrientationVector(int pointIndex)
std::string ReplaceListNameInControlPointLabelFormat()
bool InsertControlPoint(int n, double point[3], std::string label=std::string())
void ResetNthControlPointPosition(int n)
Set control point status to preview.
void SetNthControlPointPositionFromArray(const int pointIndex, const double pos[3], int positionStatus=PositionDefined)
int AddNControlPoints(int n, std::string label, double point[3])
vtkVector< double, 9 > GetNthControlPointOrientationMatrixWorld(int n)
@ PositionStatus_Last
PositionStatus_Last: indicates the end of the enum (int first = 0, int last = PositionStatus_Last)
@ PositionMissing
PositionMissing: point is undefined and placement should not be attempted.
@ PositionUndefined
PositionUndefined: position is undefined (coordinate values must not be used).
@ PositionPreview
PositionPreview: new point is being placed, position is tentative.
@ PositionDefined
PositionDefined: position is specified.
int GetControlPointIndexByDescription(const char *description)
vtkVector3d GetNthControlPointNormal(int n)
bool CanApplyNonLinearTransforms() const override
bool InsertControlPointWorld(int n, vtkVector3d pointWorld, std::string label=std::string())
std::string GetNthControlPointID(int n)
Get the id for the Nth control point.
vtkVector3d GetMarkupPointVector(int markupIndex, int)
vtkCurveGenerator * GetCurveGenerator()
vtkMRMLMarkupsDisplayNode * GetMarkupsDisplayNode()
Return a cast display node, returns null if none.
void GetMarkupPoint(int markupIndex, int pointIndex, double point[3])
void SetNthMarkupLocked(int n, bool flag)
vtkSmartPointer< vtkCurveGenerator > CurveGenerator
Converts curve control points to curve points.
void SetCenterOfRotation(const double position[3])
int GetNumberOfPointsInNthMarkup(int)
vtkVector3d GetNthControlPointNormalWorld(int n)
bool GetNthControlPointVisibility(int n=0)
void OnTransformNodeReferenceChanged(vtkMRMLTransformNode *transformNode) override
Called when transform node reference added/modified/removed.
int GetControlPointPlacementStartIndex()
void SetNthControlPointOrientationMatrixWorld(int n, const double orientationMatrix[9])
int GetControlPointIndexByLabel(const char *label)
void SetCenterOfRotationFromArray(const double pos[3])
virtual vtkPolyData * GetCurve()
void PrintSelf(ostream &os, vtkIndent indent) override
bool GetFixedNumberOfControlPoints()
virtual const char * GetMarkupType()
std::string GetNthControlPointLabel(int n=0)
int AddControlPoint(double point[3], std::string label=std::string())
virtual const char * GetAddIcon()
void SetNthMeasurement(int id, vtkMRMLMeasurement *measurement)
void SetNthControlPointSelected(int n, bool flag)
vtkSmartPointer< vtkStringArray > TextList
virtual std::string GetPropertiesLabelText()
void SetControlPointPositionsWorld(vtkPoints *points, bool setUndefinedPoints=true)
void SwapControlPoints(int m1, int m2)
Swap two control points (position data and all other properties).
void GetBounds(double bounds[6]) override
void SetNthControlPointDescription(int n, std::string description)
vtkSmartPointer< vtkPointLocator > TransformedCurvePolyLocator
int GetNumberOfDefinedControlPoints(bool includePreview=false)
Return the number of control points that are already placed (not being previewed or undefined).
std::string ControlPointLabelFormat
vtkSmartPointer< vtkGeneralTransform > CurvePolyToWorldTransform
vtkVector3d GetNthControlPointPositionVector(int pointIndex)
std::string GetNthControlPointAssociatedNodeID(int n=0)
void SetCenterOfRotationWorld(const double positionWorld[3])
void SetNthControlPointOrientation(int n, const double wxyz[4])
void SetNthControlPointPositionWorld(const int pointIndex, const double x, const double y, const double z, int positionStatus=PositionDefined)
std::string ReplaceListNameInMarkupLabelFormat()
void SetNthControlPointLabel(int n, std::string label)
void RemoveMarkup(int pointIndex)
void SetCenterOfRotationFromPointer(const double *pos)
void GetNthControlPointNormal(int n, double normal[3])
void SetMarkupLabelFormat(std::string format)
std::string GetNthMarkupAssociatedNodeID(int n=0)
virtual void ApplyTransform(vtkAbstractTransform *transform, bool applyToLockedControlPoints)
std::vector< ControlPoint * > * GetControlPoints()
Return a pointer to the std::vector of control points stored in this node.
void SetNthControlPointOrientationMatrixWorld(int n, vtkMatrix3x3 *matrix)
bool ControlPointExists(int n)
Return true if n is a valid control point, false otherwise.
void SetNthControlPointPositionWorld(const int pointIndex, const double position[3], int positionStatus=PositionDefined)
vtkMRMLMeasurement * GetNthMeasurement(int id)
bool GetCenterOfRotationWorld(double worldxyz[3])
void SetNthControlPointPosition(const int pointIndex, const double position[3], int positionStatus=PositionDefined)
int AddControlPointWorld(double x, double y, double z, std::string label=std::string())
bool GetCenterOfRotation(double point[3])
friend class vtkMRMLMarkupsStorageNode
Make the storage node a friend so that ReadDataInternal can set the ControlPoint ids.
virtual vtkAlgorithmOutput * GetCurveWorldConnection()
void ReadXMLAttributes(const char **atts) override
Read node attributes from XML file.
int GetNumberOfControlPoints()
Return the number of control points that are stored in this node.
std::string GenerateUniqueControlPointID()
virtual void RemoveAllControlPoints()
Clear out the node of all control points.
ControlPoint * GetNthControlPointByID(const char *controlPointID)
Get the Nth control point based on it's ID.
std::string GetNthControlPointDescription(int n=0)
void SetLocked(int locked)
int AddControlPointWorld(vtkVector3d point, std::string label=std::string())
virtual vtkMatrix4x4 * GetInteractionHandleToWorldMatrix()
4x4 matrix detailing the orientation and position in world coordinates of the interaction handles.
virtual void UpdateInteractionHandleToWorldMatrix()
Calculates the handle to world matrix based on the current control points.
int GetControlPointIndexFromInterpolatedPointIndex(vtkIdType interpolatedPointIndex)
Converts curve point index to control point index.
virtual const char * GetIcon()
ControlPointsListType ControlPoints
Vector of control points.
void SetCenterOfRotation(const double x, const double y, const double z)
void RemoveNthMeasurement(int id)
void operator=(const vtkMRMLMarkupsNode &)
void WriteCLI(std::vector< std::string > &commandLine, std::string prefix, int coordinateSystem=vtkMRMLStorageNode::CoordinateSystemRAS, int multipleFlag=1) override
virtual void UnsetAllControlPoints()
int GetNumberOfEnabledMeasurements()
static void ConvertOrientationMatrixToWXYZ(const double orientationMatrix[9], double orientationWXYZ[4])
int AddControlPoint(vtkVector3d point, std::string label=std::string())
void GetRASBounds(double bounds[6]) override
vtkVector3d GetCenterOfRotation()
int GetNumberOfMeasurements()
void RemoveAllMeasurements()
std::string GetNthMarkupID(int n=0)
virtual void WriteMeasurementsToDescription()
void RestoreNthControlPointPosition(int n)
Set control point status to defined and return to the previous position.
bool GetNthControlPointPositionVisibility(int n=0)
vtkCollection * Measurements
List of measurements stored for the markup.
void SetNthControlPointLocked(int n, bool flag)
void GetNthControlPointOrientation(int n, double orientationWXYZ[4])
void SetNthControlPointPositionWorldFromArray(const int pointIndex, const double pos[3], int positionStatus=PositionDefined)
void RemoveNthControlPoint(int pointIndex)
Remove Nth Control Point.
int AddControlPoint(double x, double y, double z, std::string label=std::string())
vtkVector3d GetNthControlPointPositionWorld(int pointIndex)
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 SetNthControlPointAutoCreated(int n, bool flag)
ControlPoint * GetNthControlPoint(int n)
Return a pointer to the Nth control point stored in this node, null if n is out of bounds.
void SetNthControlPointOrientationMatrix(int n, vtkMatrix3x3 *matrix)
int EndModify(int previousDisableModifiedEventState) override
End modifying the node. Updates pending measurements and other updates.
Class for storing well-defined measurement results, using coded entries.
A superclass for other storage nodes.
MRML node for representing a transformation between this node space and a parent node space.
Node that holds the information about a unit.
#define VTK_PROPEXCLUDE