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 centerally 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 "vtkSlicerMarkupsModuleMRMLExport.h"
#include "vtkMRMLMarkupsDisplayNode.h"
#include "vtkMRMLMarkupsNode.h"

// VTK includes
#include <vtkMatrix4x4.h>
#include <vtkSmartPointer.h>
#include <vtkStringArray.h>
#include <vtkTransform.h>

// std includes
#include <vector>

class vtkImplicitFunction;
class vtkPlanes;

class  VTK_SLICER_MARKUPS_MODULE_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/MarkupsCurveMouseModePlace.png";}

  //--------------------------------------------------------------------------
  // MRMLNode methods
  //--------------------------------------------------------------------------

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

  vtkMRMLCopyContentMacro(vtkMRMLMarkupsROINode);

  vtkGetVector3Macro(Size, double);
  void SetSize(const double size[3]);
  void SetSize(double x, double y, double z);

  void GetCenter(double center[3]);
  void GetCenterWorld(double center[3]);
  void SetCenterWorld(const double center[3]);
  void SetCenter(const double center[3]);

  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 GetXAxisLocal(double axis_Local[3]);
  void GetYAxisLocal(double axis_Local[3]);
  void GetZAxisLocal(double axis_Local[3]);
  void GetAxisLocal(int axisIndex, double axis_Local[3]);

  vtkMatrix4x4* GetROIToLocalMatrix()
  {
    return this->ROIToLocalMatrix;
  };

  void GetBoundsROI(double bounds[6]);

  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, // Requires two Control points that are removed after they have been placed.
    ROITypeBoundingBox, // ROI forms a bounding box around the control points.
    ROIType_Last
    };

  // Scale handle indexes
  enum
  {
    HandleLFace,
    HandleRFace,
    HandlePFace,
    HandleAFace,
    HandleIFace,
    HandleSFace,

    HandleLPICorner,
    HandleRPICorner,
    HandleLAICorner,
    HandleRAICorner,
    HandleLPSCorner,
    HandleRPSCorner,
    HandleLASCorner,
    HandleRASCorner,
    };

  void OnTransformNodeReferenceChanged(vtkMRMLTransformNode* transformNode) override;


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

  void UpdateInteractionHandleToWorldMatrix() override;

  vtkMRMLStorageNode* CreateDefaultStorageNode() override;

  void CreateDefaultDisplayNodes() override;


  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);

  vtkSetMacro(InsideOut, bool);
  vtkGetMacro(InsideOut, bool);
  vtkBooleanMacro(InsideOut, bool);

protected:
  bool InsideOut{false};
  int ROIType{vtkMRMLMarkupsROINode::ROITypeBox};

  double Size[3]{ 0.0, 0.0, 0.0 };

  bool IsUpdatingControlPointsFromROI{false};
  bool IsUpdatingROIFromControlPoints{false};

  vtkSmartPointer<vtkMatrix4x4> ROIToLocalMatrix;

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

#endif