vtkMRMLMarkupsPlaneNode.h

Go to the documentation of this file.

/*==============================================================================
 
  Copyright (c) Laboratory for Percutaneous Surgery (PerkLab)
  Queen's University, Kingston, ON, Canada. 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.
 
  This file was originally developed by Kyle Sunderland, PerkLab, Queen's University
  and was supported through CANARIE's Research Software Program, Cancer
  Care Ontario, OpenAnatomy, and Brigham and Women's Hospital through NIH grant R01MH112748.
 
==============================================================================*/
 
#ifndef __vtkMRMLMarkupsPlaneNode_h
#define __vtkMRMLMarkupsPlaneNode_h
 
// MRML includes
#include "vtkMRMLDisplayableNode.h"
 
// Markups includes
#include "vtkMRMLMarkupsDisplayNode.h"
#include "vtkMRMLMarkupsNode.h"
#include "vtkMRMLExport.h"
 
// VTK includes
#include <vtkMatrix4x4.h>
#include <vtkPlane.h>

class VTK_MRML_EXPORT vtkMRMLMarkupsPlaneNode : public vtkMRMLMarkupsNode
{
public:
  static vtkMRMLMarkupsPlaneNode* New();
  vtkTypeMacro(vtkMRMLMarkupsPlaneNode, vtkMRMLMarkupsNode);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  const char* GetIcon() override { return ":/Icons/MarkupsPlane.png"; }
  const char* GetAddIcon() override { return ":/Icons/MarkupsPlaneMouseModePlace.png"; }
  const char* GetPlaceAddIcon() override { return ":/Icons/MarkupsPlaneMouseModePlaceAdd.png"; }
 
  //--------------------------------------------------------------------------
  // MRMLNode methods
  //--------------------------------------------------------------------------
 
  enum
  {
    SizeModeAuto,
    SizeModeAbsolute,
    SizeMode_Last,
  };

  enum
  {
    PlaneType3Points,
    PlaneTypePointNormal,
    PlaneTypePlaneFit,
    PlaneType_Last
  };
 
  vtkMRMLNode* CreateNodeInstance() override;
  const char* GetNodeTagName() override { return "MarkupsPlane"; }

  const char* GetMarkupType() override { return "Plane"; };

  void ReadXMLAttributes(const char** atts) override;

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

  vtkMRMLCopyContentMacro(vtkMRMLMarkupsPlaneNode);

  using Superclass::ApplyTransform;
  void ApplyTransform(vtkAbstractTransform* transform, bool applyToLockedControlPoints) override;


  void SetSizeMode(int sizeMode);
  vtkGetMacro(SizeMode, int);
  static const char* GetSizeModeAsString(int sizeMode);
  static int GetSizeModeFromString(const char* sizeMode);

  vtkGetMacro(AutoSizeScalingFactor, double);
  vtkSetMacro(AutoSizeScalingFactor, double);


  void GetSize(double size[2]);
  double* GetSize() VTK_SIZEHINT(2);
  virtual void SetSize(double x, double y);
  virtual void SetSize(double size[2]) { this->SetSize(size[0], size[1]); }


  void GetSizeWorld(double size[2]);
  double* GetSizeWorld() VTK_SIZEHINT(2);
  void SetSizeWorld(const double normal[2]);
  void SetSizeWorld(double x, double y);


  vtkGetVector4Macro(PlaneBounds, double);
  virtual void SetPlaneBounds(double x0, double x1, double y0, double y1);
  virtual void SetPlaneBounds(double bounds[4]) { this->SetPlaneBounds(bounds[0], bounds[1], bounds[2], bounds[3]); };


  void GetNormal(double normal[3]);
  double* GetNormal() VTK_SIZEHINT(3);
  void GetNormalWorld(double normal[3]);
  double* GetNormalWorld() VTK_SIZEHINT(3);
  void SetNormal(const double normal[3]);
  void SetNormal(double x, double y, double z);
  void SetNormalWorld(const double normal[3]);
  void SetNormalWorld(double x, double y, double z);

  void FlipNormal();


  void GetOrigin(double origin[3]);
  double* GetOrigin() VTK_SIZEHINT(3);
  void GetOriginWorld(double origin[3]);
  double* GetOriginWorld() VTK_SIZEHINT(3);
  void SetOrigin(const double origin[3]);
  void SetOrigin(double x, double y, double z);
  void SetOriginWorld(const double origin[3]);
  void SetOriginWorld(double x, double y, double z);


  void GetCenter(double origin[3]) { this->GetOrigin(origin); };
  double* GetCenter() VTK_SIZEHINT(3) { return this->GetOrigin(); };
  void GetCenterWorld(double origin[3]) { this->GetOriginWorld(origin); };
  double* GetCenterWorld() VTK_SIZEHINT(3) { return this->GetOriginWorld(); };
  void SetCenter(const double origin[3]) { this->SetOrigin(origin); };
  void SetCenter(double x, double y, double z) { this->SetOrigin(x, y, z); };
  void SetCenterWorld(const double origin[3]) { this->SetOriginWorld(origin); };
  void SetCenterWorld(double x, double y, double z) { this->SetOriginWorld(x, y, z); };


  void GetAxes(double x[3], double y[3], double z[3]);
  void SetAxes(const double x[3], const double y[3], const double z[3]);
  void GetAxesWorld(double x[3], double y[3], double z[3]);
  void SetAxesWorld(const double x[3], const double y[3], const double z[3]);

  virtual void GetObjectToNodeMatrix(vtkMatrix4x4* objectToNodeMatrix);
  virtual void GetObjectToWorldMatrix(vtkMatrix4x4* objectToWorldMatrix);
  virtual void GetBaseToWorldMatrix(vtkMatrix4x4* baseToWorldMatrix);

  virtual void GetBaseToNodeMatrix(vtkMatrix4x4* matrix);
  virtual vtkMatrix4x4* GetBaseToNodeMatrix();

  virtual vtkMatrix4x4* GetObjectToBaseMatrix();

  double GetClosestPointOnPlaneWorld(const double posWorld[3], double closestPosWorld[3], bool infinitePlane = true);

  vtkMRMLStorageNode* CreateDefaultStorageNode() override;

  void CreateDefaultDisplayNodes() override;


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


  vtkGetMacro(PlaneType, int);
  void SetPlaneType(int planeType);
  static const char* GetPlaneTypeAsString(int planeType);
  static int GetPlaneTypeFromString(const char* planeType);

  vtkGetMacro(IsPlaneValid, bool);


  static void GenerateOrthogonalMatrix(vtkMatrix4x4* inputMatrix, vtkMatrix4x4* outputMatrix, vtkAbstractTransform* transform = nullptr, bool applyScaling = true);
  static void GenerateOrthogonalMatrix(double xAxis[3],
                                       double yAxis[3],
                                       double zAxis[3],
                                       double origin[3],
                                       vtkMatrix4x4* outputMatrix,
                                       vtkAbstractTransform* transform = nullptr,
                                       bool applyScaling = true);

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


  void GetPlaneCornerPoints(vtkPoints* points_Node);
  void GetPlaneCornerPointsWorld(vtkPoints* points_World);
 
protected:
  vtkSetMacro(MaximumNumberOfControlPoints, int);
  vtkSetMacro(RequiredNumberOfControlPoints, int);
 
  // Set plane validity flag. True if the plane is fully defined.
  vtkSetMacro(IsPlaneValid, bool);

  void OnTransformNodeReferenceChanged(vtkMRMLTransformNode* transformNode) override;

  void CalculateAxesFromPoints(const double point0[3], const double point1[3], const double point2[3], double x[3], double y[3], double z[3]);

  void CalculatePlaneBounds(vtkPoints* cornerPoints, double bounds[6]);

  void CalculatePlaneCornerPoints(vtkPoints* points, double xAxis[3], double yAxis[3], double center[3], double size[2]);

  virtual void UpdatePlaneFromControlPoints();
  virtual void UpdatePlaneFromPointNormal();
  virtual void UpdatePlaneFrom3Points();
  virtual void UpdatePlaneFromPlaneFit();
  virtual void UpdatePlaneSize();

  virtual void UpdateControlPointsFromPlane();
  virtual void UpdateControlPointsFromPointNormal();
  virtual void UpdateControlPointsFrom3Points();
  virtual void UpdateControlPointsFromPlaneFit();
  bool GetClosestFitPlaneFromControlPoints(vtkMatrix4x4* closestFitPlane);
 
  vtkMRMLMarkupsPlaneNode();
  ~vtkMRMLMarkupsPlaneNode() override;
  vtkMRMLMarkupsPlaneNode(const vtkMRMLMarkupsPlaneNode&);
  void operator=(const vtkMRMLMarkupsPlaneNode&);
 
  virtual void SetNormalPointRequired(bool);
  vtkGetMacro(NormalPointRequired, bool);
 
  void UpdateImplicitFunction();
  vtkImplicitFunction* GetImplicitFunctionWorld() override;
 
protected:
  bool IsUpdatingControlPointsFromPlane{ false };
  bool IsUpdatingPlaneFromControlPoints{ false };
 
  int SizeMode{ SizeModeAuto };
  double AutoSizeScalingFactor{ 1.0 };
 
  vtkSmartPointer<vtkMatrix4x4> ObjectToBaseMatrix;
  vtkSmartPointer<vtkMatrix4x4> BaseToNodeMatrix;
 
  double Size[2] = { 100.0, 100.0 };
  double PlaneBounds[4] = { -50.0, 50.0, -50.0, 50.0 };
 
  // Arrays used to return pointers from GetNormal/GetOrigin functions.
  double Normal[3] = { 0.0, 0.0, 0.0 };
  double NormalWorld[3] = { 0.0, 0.0, 0.0 };
  double Origin[3] = { 0.0, 0.0, 0.0 };
  double OriginWorld[3] = { 0.0, 0.0, 0.0 };
  double SizeWorld[2] = { 0.0, 0.0 };
 
  int PlaneType{ PlaneTypePointNormal };
  bool IsPlaneValid{ false };
  bool NormalPointRequired{ false };

  void UpdateInteractionHandleToWorldMatrix() override;
 
  friend class vtkSlicerPlaneWidget;           // To directly access plane update functions
  friend class vtkSlicerPlaneRepresentation3D; // To directly access plane update functions
  friend class vtkSlicerPlaneRepresentation2D; // To directly access plane update functions
 
  vtkSmartPointer<vtkPlane> ImplicitPlaneWorld;
};
 
#endif