Slicer  5.0
Slicer is a multi-platform, free and open source software package for visualization and medical image computing
vtkMRMLMarkupsPlaneNode.h
Go to the documentation of this file.
1 /*==============================================================================
2 
3  Copyright (c) Laboratory for Percutaneous Surgery (PerkLab)
4  Queen's University, Kingston, ON, Canada. All Rights Reserved.
5 
6  See COPYRIGHT.txt
7  or http://www.slicer.org/copyright/copyright.txt for details.
8 
9  Unless required by applicable law or agreed to in writing, software
10  distributed under the License is distributed on an "AS IS" BASIS,
11  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  See the License for the specific language governing permissions and
13  limitations under the License.
14 
15  This file was originally developed by Kyle Sunderland, PerkLab, Queen's University
16  and was supported through CANARIE's Research Software Program, Cancer
17  Care Ontario, OpenAnatomy, and Brigham and Women's Hospital through NIH grant R01MH112748.
18 
19 ==============================================================================*/
20 
21 #ifndef __vtkMRMLMarkupsPlaneNode_h
22 #define __vtkMRMLMarkupsPlaneNode_h
23 
24 // MRML includes
25 #include "vtkMRMLDisplayableNode.h"
26 
27 // Markups includes
29 #include "vtkMRMLMarkupsNode.h"
30 #include "vtkSlicerMarkupsModuleMRMLExport.h"
31 
32 // VTK includes
33 #include <vtkMatrix4x4.h>
34 
55 class VTK_SLICER_MARKUPS_MODULE_MRML_EXPORT vtkMRMLMarkupsPlaneNode : public vtkMRMLMarkupsNode
56 {
57 public:
58  static vtkMRMLMarkupsPlaneNode *New();
61  void PrintSelf(ostream& os, vtkIndent indent) override;
62 
63  const char* GetIcon() override {return ":/Icons/MarkupsPlane.png";}
64  const char* GetAddIcon() override {return ":/Icons/MarkupsPlaneMouseModePlace.png";}
65  const char* GetPlaceAddIcon() override {return ":/Icons/MarkupsPlaneMouseModePlaceAdd.png";}
66 
67  //--------------------------------------------------------------------------
68  // MRMLNode methods
69  //--------------------------------------------------------------------------
70 
71  enum
72  {
76  };
77 
79  enum
80  {
84  PlaneType_Last
85  };
86 
87  vtkMRMLNode* CreateNodeInstance() override;
89  const char* GetNodeTagName() override {return "MarkupsPlane";}
90 
92  const char* GetMarkupType() override {return "Plane";};
93 
94  // Get markup type GUI display name
95  const char* GetTypeDisplayName() override {return "Plane";};
96 
98  const char* GetDefaultNodeNamePrefix() override {return "P";};
99 
101  void ReadXMLAttributes( const char** atts) override;
102 
104  void WriteXML(ostream& of, int indent) override;
105 
109 
111  void ApplyTransform(vtkAbstractTransform* transform) override;
112 
114  void SetSizeMode(int sizeMode);
119  vtkGetMacro(SizeMode, int);
120  static const char* GetSizeModeAsString(int sizeMode);
121  static int GetSizeModeFromString(const char* sizeMode);
123 
127  vtkGetMacro(AutoSizeScalingFactor, double);
128  vtkSetMacro(AutoSizeScalingFactor, double);
130 
132  void GetSize(double size[2]);
137  double* GetSize() VTK_SIZEHINT(2);
138  virtual void SetSize(double x, double y);
139  virtual void SetSize(double size[2]) { this->SetSize(size[0], size[1]); }
141 
143  void GetSizeWorld(double size[2]);
148  double* GetSizeWorld() VTK_SIZEHINT(2);
149  void SetSizeWorld(const double normal[2]);
150  void SetSizeWorld(double x, double y);
152 
154  vtkGetVector4Macro(PlaneBounds, double);
156  virtual void SetPlaneBounds(double x0, double x1, double y0, double y1);
157  virtual void SetPlaneBounds(double bounds[4]) { this->SetPlaneBounds(bounds[0], bounds[1], bounds[2], bounds[3]); };
159 
161  void GetNormal(double normal[3]);
163  double* GetNormal() VTK_SIZEHINT(3);
164  void GetNormalWorld(double normal[3]);
165  double* GetNormalWorld() VTK_SIZEHINT(3);
166  void SetNormal(const double normal[3]);
167  void SetNormal(double x, double y, double z);
168  void SetNormalWorld(const double normal[3]);
169  void SetNormalWorld(double x, double y, double z);
171 
173  void GetOrigin(double origin[3]);
175  double* GetOrigin() VTK_SIZEHINT(3);
176  void GetOriginWorld(double origin[3]);
177  double* GetOriginWorld() VTK_SIZEHINT(3);
178  void SetOrigin(const double origin[3]);
179  void SetOrigin(double x, double y, double z);
180  void SetOriginWorld(const double origin[3]);
181  void SetOriginWorld(double x, double y, double z);
183 
185  void GetCenter(double origin[3]) { this->GetOrigin(origin); };
187  double* GetCenter() VTK_SIZEHINT(3) { return this->GetOrigin(); };
188  void GetCenterWorld(double origin[3]) { this->GetOriginWorld(origin); };
189  double* GetCenterWorld() VTK_SIZEHINT(3) { return this->GetOriginWorld(); };
190  void SetCenter(const double origin[3]) { this->SetOrigin(origin); };
191  void SetCenter(double x, double y, double z) { this->SetOrigin(x, y, z); };
192  void SetCenterWorld(const double origin[3]) { this->SetOriginWorld(origin); };
193  void SetCenterWorld(double x, double y, double z) { this->SetOriginWorld(x, y, z); };
195 
197  void GetAxes(double x[3], double y[3], double z[3]);
203  void SetAxes(const double x[3], const double y[3], const double z[3]);
204  void GetAxesWorld(double x[3], double y[3], double z[3]);
205  void SetAxesWorld(const double x[3], const double y[3], const double z[3]);
207 
209  virtual void GetObjectToNodeMatrix(vtkMatrix4x4* objectToNodeMatrix);
211  virtual void GetObjectToWorldMatrix(vtkMatrix4x4* objectToWorldMatrix);
213  virtual void GetBaseToWorldMatrix(vtkMatrix4x4* baseToWorldMatrix);
215  virtual void GetBaseToNodeMatrix(vtkMatrix4x4* matrix);
217  virtual vtkMatrix4x4* GetBaseToNodeMatrix();
219 
222  virtual vtkMatrix4x4* GetObjectToBaseMatrix();
223 
231  double GetClosestPointOnPlaneWorld(const double posWorld[3], double closestPosWorld[3], bool infinitePlane = true);
232 
235 
237  void CreateDefaultDisplayNodes() override;
238 
240  void GetRASBounds(double bounds[6]) override;
243  void GetBounds(double bounds[6]) override;
245 
247  vtkGetMacro(PlaneType, int);
253  void SetPlaneType(int planeType);
254  static const char* GetPlaneTypeAsString(int planeType);
255  static int GetPlaneTypeFromString(const char* planeType);
257 
259  vtkGetMacro(IsPlaneValid, bool);
260 
262  static void GenerateOrthogonalMatrix(vtkMatrix4x4* inputMatrix,
265  vtkMatrix4x4* outputMatrix, vtkAbstractTransform* transform = nullptr, bool applyScaling = true);
266  static void GenerateOrthogonalMatrix(double xAxis[3], double yAxis[3], double zAxis[3], double origin[3],
267  vtkMatrix4x4* outputMatrix, vtkAbstractTransform* transform = nullptr, bool applyScaling = true);
269 
271  void ProcessMRMLEvents(vtkObject* caller, unsigned long event, void* callData) override;
272 
274  void GetPlaneCornerPoints(vtkPoints* points_Node);
276  void GetPlaneCornerPointsWorld(vtkPoints* points_World);
278 
279 protected:
280 
281  vtkSetMacro(MaximumNumberOfControlPoints, int);
282  vtkSetMacro(RequiredNumberOfControlPoints, int);
283 
284  // Set plane validity flag. True if the plane is fully defined.
285  vtkSetMacro(IsPlaneValid, bool);
286 
288  void OnTransformNodeReferenceChanged(vtkMRMLTransformNode* transformNode) override;
289 
291  void CalculateAxesFromPoints(const double point0[3], const double point1[3], const double point2[3], double x[3], double y[3], double z[3]);
292 
294  void CalculatePlaneBounds(vtkPoints* cornerPoints, double bounds[6]);
295 
297  void CalculatePlaneCornerPoints(vtkPoints* points, double xAxis[3], double yAxis[3], double center[3], double size[2]);
298 
300  virtual void UpdatePlaneFromControlPoints();
301  virtual void UpdatePlaneFromPointNormal();
302  virtual void UpdatePlaneFrom3Points();
303  virtual void UpdatePlaneFromPlaneFit();
304  virtual void UpdatePlaneSize();
305 
307  virtual void UpdateControlPointsFromPlane();
308  virtual void UpdateControlPointsFromPointNormal();
309  virtual void UpdateControlPointsFrom3Points();
310  virtual void UpdateControlPointsFromPlaneFit();
311  bool GetClosestFitPlaneFromControlPoints(vtkMatrix4x4* closestFitPlane);
312 
314  ~vtkMRMLMarkupsPlaneNode() override;
316  void operator=(const vtkMRMLMarkupsPlaneNode&);
317 
318  virtual void SetNormalPointRequired(bool);
319  vtkGetMacro(NormalPointRequired, bool);
320 
321 protected:
322  bool IsUpdatingControlPointsFromPlane{ false };
323  bool IsUpdatingPlaneFromControlPoints{ false };
324 
325  int SizeMode{ SizeModeAuto };
326  double AutoSizeScalingFactor{ 1.0 };
327 
328  vtkSmartPointer<vtkMatrix4x4> ObjectToBaseMatrix;
329  vtkSmartPointer<vtkMatrix4x4> BaseToNodeMatrix;
330 
331  double Size[2] = { 100.0, 100.0 };
332  double PlaneBounds[4] = { -50.0, 50.0, -50.0, 50.0 };
333 
334  // Arrays used to return pointers from GetNormal/GetOrigin functions.
335  double Normal[3] = { 0.0, 0.0, 0.0 };
336  double NormalWorld[3] = { 0.0, 0.0, 0.0 };
337  double Origin[3] = { 0.0, 0.0, 0.0 };
338  double OriginWorld[3] = { 0.0, 0.0, 0.0 };
339  double SizeWorld[2] = { 0.0, 0.0 };
340 
341  int PlaneType{ PlaneTypePointNormal };
342  bool IsPlaneValid{ false };
343  bool NormalPointRequired{ false };
344 
346  void UpdateInteractionHandleToWorldMatrix() override;
347 
348  friend class vtkSlicerPlaneWidget; // To directly access plane update functions
349  friend class vtkSlicerPlaneRepresentation3D; // To directly access plane update functions
350  friend class vtkSlicerPlaneRepresentation2D; // To directly access plane update functions
351 };
352 
353 #endif
void ApplyTransform(vtkAbstractTransform *transform) override
vtkSmartPointer< vtkMatrix4x4 > BaseToNodeMatrix
const char * GetIcon() override
double * GetCenter() VTK_SIZEHINT(3)
void SetCenter(const double origin[3])
const char * GetTypeDisplayName() override
MRML node for representing a transformation between this node space and a parent node space...
virtual void SetPlaneBounds(double bounds[4])
void operator=(const vtkMRMLMarkupsNode &)
void CreateDefaultDisplayNodes() override
Create and observe default display node(s)
void GetBounds(double bounds[6]) override
void GetRASBounds(double bounds[6]) override
void OnTransformNodeReferenceChanged(vtkMRMLTransformNode *transformNode) override
Called when transform node reference added/modified/removed.
void SetCenter(double x, double y, double z)
void GetCenterWorld(double origin[3])
const char * GetNodeTagName() override
Get node XML tag name (like Volume, Model)
virtual void UpdateInteractionHandleToWorldMatrix()
Calculates the handle to world matrix based on the current control points.
void SetCenterWorld(double x, double y, double z)
const char * GetMarkupType() override
Get markup type internal name.
const char * GetDefaultNodeNamePrefix() override
Get markup short name.
MRML node to represent a plane markup Plane Markups nodes contain three control points. Visualization parameters are set in the vtkMRMLMarkupsDisplayNode class.
Default representation for the plane widget.
vtkMRMLCopyContentMacro(vtkMRMLMarkupsNode)
vtkMRMLStorageNode * CreateDefaultStorageNode() override
Create default storage node or nullptr if does not have one.
A superclass for other storage nodes.
vtkSmartPointer< vtkMatrix4x4 > ObjectToBaseMatrix
vtkMRMLNode * CreateNodeInstance() override=0
MRMLNode methods.
create a plane with a set of 3 points
const char * GetAddIcon() override
double * GetCenterWorld() VTK_SIZEHINT(3)
void ReadXMLAttributes(const char **atts) override
Read node attributes from XML file.
virtual void SetSize(double size[2])
Abstract Superclass for all specific types of MRML nodes.
Definition: vtkMRMLNode.h:167
void SetCenterWorld(const double origin[3])
const char * GetPlaceAddIcon() override
void WriteXML(ostream &of, int indent) override
Write this node&#39;s information to a MRML file in XML format.
Default representation for the plane widget.
void ProcessMRMLEvents(vtkObject *, unsigned long, void *) override
Alternative method to propagate events generated in Display nodes.
void PrintSelf(ostream &os, vtkIndent indent) override