vtkMRMLMarkupsROINode.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 __vtkMRMLMarkupsROINode_h
#define __vtkMRMLMarkupsROINode_h
 
// MRML includes
#include "vtkMRMLDisplayableNode.h"
#include "vtkMRMLModelNode.h"
 
// Markups includes
#include "vtkMRMLExport.h"
#include "vtkMRMLMarkupsDisplayNode.h"
#include "vtkMRMLMarkupsNode.h"
 
// VTK includes
#include <vtkImplicitBoolean.h>
#include <vtkImplicitFunction.h>
#include <vtkMatrix4x4.h>
#include <vtkSmartPointer.h>
#include <vtkStringArray.h>
#include <vtkTransform.h>
 
// std includes
#include <vector>
 
class vtkPlanes;

class VTK_MRML_EXPORT vtkMRMLMarkupsROINode : public vtkMRMLMarkupsNode
{
public:
  static vtkMRMLMarkupsROINode* New();
  vtkTypeMacro(vtkMRMLMarkupsROINode, vtkMRMLMarkupsNode);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  const char* GetIcon() override { return ":/Icons/MarkupsROI.png"; }
  const char* GetAddIcon() override { return ":/Icons/MarkupsROIMouseModePlace.png"; }
  const char* GetPlaceAddIcon() override { return ":/Icons/MarkupsROIMouseModePlaceAdd.png"; }
 
  //--------------------------------------------------------------------------
  // MRMLNode methods
  //--------------------------------------------------------------------------
 
  vtkMRMLNode* CreateNodeInstance() override;

  const char* GetNodeTagName() override { return "MarkupsROI"; }

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

  vtkMRMLCopyContentMacro(vtkMRMLMarkupsROINode);

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


  vtkGetVector3Macro(Size, double);
  void SetSize(const double size[3]);
  void SetSize(double x, double y, double z);
  void GetSizeWorld(double size_World[3]);
  void SetSizeWorld(const double size_World[3]);
  void SetSizeWorld(double x_World, double y_World, double z_World);


  void GetCenter(double center[3]);
  void GetCenterWorld(double center[3]);
  vtkVector3d GetCenter();
  vtkVector3d GetCenterWorld();
  void SetCenterWorld(const double center[3]);
  void SetCenterWorld(double x, double y, double z);
  void SetCenter(const double center[3]);
  void SetCenter(double x, double y, double z);


  void GetXAxisWorld(double axis_World[3]);
  void GetYAxisWorld(double axis_World[3]);
  void GetZAxisWorld(double axis_World[3]);
  void GetAxisWorld(int axisIndex, double axis_World[3]);
  void GetXAxis(double axis_Node[3]);
  void GetYAxis(double axis_Node[3]);
  void GetZAxis(double axis_Node[3]);
  void GetAxis(int axisIndex, double axis_Node[3]);


  vtkMatrix4x4* GetObjectToNodeMatrix() { return this->ObjectToNodeMatrix; };
  void SetAndObserveObjectToNodeMatrix(vtkMatrix4x4* objectToNodeMatrix);

  vtkMatrix4x4* GetObjectToWorldMatrix() { return this->ObjectToWorldMatrix; };


  vtkGetMacro(ROIType, int);
  void SetROIType(int roiType);
  static const char* GetROITypeAsString(int roiType);
  static int GetROITypeFromString(const char* roiType);


  virtual void UpdateROIFromControlPoints();
  virtual void UpdateBoxROIFromControlPoints();
  virtual void UpdateBoundingBoxROIFromControlPoints();


  virtual void UpdateControlPointsFromROI();
  virtual void UpdateControlPointsFromBoundingBoxROI();
  virtual void UpdateControlPointsFromBoxROI();
 
  // ROI type enum defines the calculation method that should be used to convert to and from control points.
  enum
  {
    ROITypeBox,         
    ROITypeBoundingBox, 
    ROIType_Last
  };

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

  void UpdateInteractionHandleToWorldMatrix() override;

  vtkMRMLStorageNode* CreateDefaultStorageNode() override;

  void CreateDefaultDisplayNodes() override;


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

  void GetObjectBounds(double bounds[6]);


  void GetPlanes(vtkPlanes* planes) { this->GetPlanes(planes, this->GetInsideOut()); }
  void GetPlanesWorld(vtkPlanes* planes) { this->GetPlanesWorld(planes, this->GetInsideOut()); }


  void GetPlanes(vtkPlanes* planes, bool insideOut);
  void GetPlanesWorld(vtkPlanes* planes, bool insideOut);


  bool IsPointInROI(double point_Node[3]);
  bool IsPointInROIWorld(double point_World[3]);


  void SetInsideOut(bool insideOut);
  vtkGetMacro(InsideOut, bool);
  vtkBooleanMacro(InsideOut, bool);

  vtkGetObjectMacro(ImplicitFunction, vtkImplicitFunction);
  vtkImplicitFunction* GetImplicitFunctionWorld() override { return this->ImplicitFunctionWorld; }

  VTK_NEWINSTANCE vtkPolyData* CreateROIBoxPolyDataWorld();



  int SetXYZ(double center[3]);
  int SetXYZ(double x, double y, double z);
  bool GetXYZ(double center[3]);


  void SetRadiusXYZ(double radiusXYZ[3]);
  void SetRadiusXYZ(double x, double y, double z);
  void GetRadiusXYZ(double radiusXYZ[3]);

  void GetTransformedPlanes(vtkPlanes* planes, bool insideOut = false);


  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 WriteCLI(std::vector<std::string>& commandLine, std::string prefix, int coordinateSystem = vtkMRMLStorageNode::CoordinateSystemRAS, int multipleFlag = 1) override;
 
protected:
  int ROIType{ vtkMRMLMarkupsROINode::ROITypeBox };
 
  double Size[3]{ 0.0, 0.0, 0.0 };
 
  bool IsUpdatingControlPointsFromROI{ false };
  bool IsUpdatingROIFromControlPoints{ false };
  bool IsUpdatingInteractionHandleToWorldMatrix{ false };
  bool InsideOut{ false };
  bool GetObjectToNodeMatrixRotated();
 
  vtkSmartPointer<vtkMatrix4x4> ObjectToNodeMatrix{ nullptr };
  vtkSmartPointer<vtkMatrix4x4> ObjectToWorldMatrix{ nullptr };
 
  vtkSmartPointer<vtkImplicitFunction> ImplicitFunction{ nullptr };
  vtkSmartPointer<vtkImplicitFunction> ImplicitFunctionWorld{ nullptr };

  void GenerateBoxBounds(double bounds[6], double xAxis[3], double yAxis[3], double zAxis[3], double center[3], double size[3]);

  void UpdateObjectToWorldMatrix();

  void UpdateImplicitFunction();
 
  vtkMRMLMarkupsROINode();
  ~vtkMRMLMarkupsROINode() override;
  vtkMRMLMarkupsROINode(const vtkMRMLMarkupsROINode&);
  void operator=(const vtkMRMLMarkupsROINode&);
};
 
#endif