vtkSlicerMarkupsLogic.h

Go to the documentation of this file.

/*==============================================================================
 
  Program: 3D Slicer
 
  Portions (c) Copyright Brigham and Women's Hospital (BWH) 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.
 
==============================================================================*/
 
// .NAME vtkSlicerMarkupsLogic - slicer logic class for volumes manipulation
// .SECTION Description
// This class manages the logic associated with reading, saving,
// and changing propertied of the volumes
 
#ifndef __vtkSlicerMarkupsLogic_h
#define __vtkSlicerMarkupsLogic_h
 
// Slicer includes
#include "vtkSlicerModuleLogic.h"
 
// Markups module includes
class vtkSlicerMarkupsInteractionWidget;
class vtkSlicerMarkupsWidget;
 
// MRML includes
#include "vtkMRMLStorageNode.h"
class vtkMRMLMarkupsClosedCurveNode;
class vtkMRMLMarkupsDisplayNode;
class vtkMRMLMarkupsJsonStorageNode;
class vtkMRMLMarkupsNode;
class vtkMRMLMessageCollection;
class vtkMRMLSelectionNode;
class vtkMRMLTableNode;
 
// VTK includes
#include <vtkVector.h>
class vtkIdList;
class vtkMatrix4x4;
class vtkPlane;
class vtkPoints;
class vtkPolyData;
 
// STD includes
#include <cstdlib>
#include <list>
#include <string>
 
#include "vtkSlicerMarkupsModuleLogicExport.h"
 
class VTK_SLICER_MARKUPS_MODULE_LOGIC_EXPORT vtkSlicerMarkupsLogic : public vtkSlicerModuleLogic
{
public:
  enum Events
  {
    MarkupRegistered = vtkCommand::UserEvent + 1,
    MarkupUnregistered
  };
 
  static vtkSlicerMarkupsLogic* New();
  vtkTypeMacro(vtkSlicerMarkupsLogic, vtkSlicerModuleLogic);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  void ProcessMRMLNodesEvents(vtkObject* caller, unsigned long event, void* callData) override;

  std::string GetSelectionNodeID();

  std::string GetActiveListID();

  void SetActiveListID(vtkMRMLMarkupsNode* markupsNode);

  void SetActiveList(vtkMRMLMarkupsNode* markupsNode);

  std::string AddNewDisplayNodeForMarkupsNode(vtkMRMLNode* mrmlNode);

  std::string AddNewFiducialNode(const char* name = "F", vtkMRMLScene* scene = nullptr);

  vtkMRMLMarkupsNode* AddNewMarkupsNode(std::string className, std::string nodeName = std::string(), vtkMRMLScene* scene = nullptr);

  int AddControlPoint(double r = 0.0, double a = 0.0, double s = 0.0);

  void JumpSlicesToLocation(double x, double y, double z, bool centered, int viewGroup = -1, vtkMRMLSliceNode* exclude = nullptr);
  void JumpSlicesToNthPointInMarkup(const char* id, int n, bool centered = false, int viewGroup = -1, vtkMRMLSliceNode* exclude = nullptr);
  void FocusCamerasOnNthPointInMarkup(const char* id, int n);
  void FocusCameraOnNthPointInMarkup(const char* cameraNodeID, const char* markupNodeID, int n);

  char* LoadMarkups(const char* fileName, const char* fidsName = nullptr, vtkMRMLMessageCollection* userMessages = nullptr);

  char* LoadMarkupsFiducials(const char* fileName, const char* fidsName = nullptr, vtkMRMLMessageCollection* userMessages = nullptr);
 
  char* LoadMarkupsFromFcsv(const char* fileName, const char* nodeName = nullptr, vtkMRMLMessageCollection* userMessages = nullptr);
  char* LoadMarkupsFromJson(const char* fileName, const char* nodeName = nullptr, vtkMRMLMessageCollection* userMessages = nullptr);

  char* LoadAnnotation(const char* filename, const char* name, int annotationFileType);

  enum
  {
    AnnotationNone = 0,
    AnnotationFiducial,
    AnnotationRuler,
    AnnotationROI,
  };

  void SetAllControlPointsVisibility(vtkMRMLMarkupsNode* node, bool flag);
  void ToggleAllControlPointsVisibility(vtkMRMLMarkupsNode* node);
  void SetAllControlPointsLocked(vtkMRMLMarkupsNode* node, bool flag);
  void ToggleAllControlPointsLocked(vtkMRMLMarkupsNode* node);
  void SetAllControlPointsSelected(vtkMRMLMarkupsNode* node, bool flag);
  void ToggleAllControlPointsSelected(vtkMRMLMarkupsNode* node);

  void SetDisplayNodeToDefaults(vtkMRMLMarkupsDisplayNode* displayNode);

  void SetDisplayDefaultsFromNode(vtkMRMLMarkupsDisplayNode* displayNode);

  bool CopyNthControlPointToNewList(int n, vtkMRMLMarkupsNode* markupsNode, vtkMRMLMarkupsNode* newMarkupsNode);

  bool MoveNthControlPointToNewListAtIndex(int n, vtkMRMLMarkupsNode* markupsNode, vtkMRMLMarkupsNode* newMarkupsNode, int newIndex);

  void ConvertAnnotationFiducialsToMarkups(vtkStringArray* addedNodeIds = nullptr, vtkStringArray* removedNodeIds = nullptr);

  void ConvertAnnotationLinesROIsToMarkups(vtkStringArray* addedNodeIds = nullptr, vtkStringArray* removedNodeIds = nullptr);
 
  void ConvertAnnotationHierarchyToSubjectHierarchy(vtkMRMLScene* scene);

  void RemoveUnusedAnnotationNodes(vtkStringArray* removedNodeIds = nullptr);

  void RenameAllControlPointsFromCurrentFormat(vtkMRMLMarkupsNode* markupsNode);

  bool StartPlaceMode(bool persistent, vtkMRMLInteractionNode* interactionNode = nullptr);
 
  vtkSetMacro(AutoCreateDisplayNodes, bool);
  vtkGetMacro(AutoCreateDisplayNodes, bool);
  vtkBooleanMacro(AutoCreateDisplayNodes, bool);
 
  vtkMRMLMarkupsDisplayNode* GetDefaultMarkupsDisplayNode();

  void CopyBasicDisplayProperties(vtkMRMLMarkupsDisplayNode* sourceDisplayNode, vtkMRMLMarkupsDisplayNode* targetDisplayNode);

  static double GetClosedCurveSurfaceArea(vtkMRMLMarkupsClosedCurveNode* curveNode, vtkPolyData* surface = nullptr, bool projectWarp = true);

  static bool FitSurfaceProjectWarp(vtkPoints* curvePoints, vtkPolyData* surface, double radiusScalingFactor = 1.0, vtkIdType numberOfInternalGridPoints = 225);

  static bool FitSurfaceDiskWarp(vtkPoints* curvePoints, vtkPolyData* surface, double radiusScalingFactor = 1.0);

  static bool IsPolygonClockwise(vtkPoints* points, vtkIdList* pointIds = nullptr);

  static bool GetBestFitPlane(vtkMRMLMarkupsNode* curveNode, vtkPlane* plane);
 
  std::string GetJsonStorageNodeClassNameForMarkupsType(std::string markupsType);
  void RegisterJsonStorageNodeForMarkupsType(std::string markupsType, std::string storageNodeClassName);
  vtkMRMLMarkupsJsonStorageNode* AddNewJsonStorageNodeForMarkupsType(std::string markupsType);

  void RegisterMarkupsNode(vtkMRMLMarkupsNode* markupsNode,
                           vtkSlicerMarkupsWidget* markupsWidget,
                           bool createPushButton = true,
                           vtkSlicerMarkupsInteractionWidget* interactionWidget = nullptr);

  void UnregisterMarkupsNode(vtkMRMLMarkupsNode* markupsNode);

  bool IsMarkupsNodeRegistered(const char* nodeType) const;

  vtkSlicerMarkupsWidget* GetWidgetByMarkupsType(const char* markupsType) const;

  vtkSlicerMarkupsInteractionWidget* GetInteractionWidgetByMarkupsType(const char* markupsType) const;

  vtkMRMLMarkupsNode* GetNodeByMarkupsType(const char* markupsType) const;

  const std::list<std::string>& GetRegisteredMarkupsTypes() const;

  bool GetCreateMarkupsPushButton(const char* markupName) const;

  static bool ImportControlPointsFromTable(vtkMRMLMarkupsNode* markupsNode, vtkMRMLTableNode* tableNode, int startRow = 0, int numberOfRows = -1);
 
  static bool ExportControlPointsToTable(vtkMRMLMarkupsNode* markupsNode, vtkMRMLTableNode* tableNode, int coordinateSystem = vtkMRMLStorageNode::CoordinateSystemRAS);

  static bool ExportControlPointsToCSV(vtkMRMLMarkupsNode* markupsNode, const std::string filename, bool lps = true);

  static bool ImportControlPointsFromCSV(vtkMRMLMarkupsNode* markupsNode, const std::string filename);
 
  //-----------------------------------------------------------
  // All public methods below are deprecated
  //
  // These methods are deprecated because they use old terms (markup instead of control point),

  bool CopyNthMarkupToNewList(int n, vtkMRMLMarkupsNode* markupsNode, vtkMRMLMarkupsNode* newMarkupsNode)
  {
    vtkWarningMacro("vtkSlicerMarkupsLogic::CopyNthMarkupToNewList method is deprecated, please use CopyNthControlPointToNewList instead");
    return this->CopyNthControlPointToNewList(n, markupsNode, newMarkupsNode);
  }

  bool MoveNthMarkupToNewList(int n, vtkMRMLMarkupsNode* markupsNode, vtkMRMLMarkupsNode* newMarkupsNode, int newIndex)
  {
    vtkWarningMacro("vtkSlicerMarkupsLogic::MoveNthMarkupToNewList method is deprecated, please use MoveNthControlPointToNewListAtIndex instead");
    return this->MoveNthControlPointToNewListAtIndex(n, markupsNode, newMarkupsNode, newIndex);
  }

  int AddFiducial(double r = 0.0, double a = 0.0, double s = 0.0)
  {
    vtkWarningMacro("vtkSlicerMarkupsLogic::AddFiducial method is deprecated, please use AddControlPoint instead");
    return this->AddControlPoint(r, a, s);
  };

  void SetAllMarkupsVisibility(vtkMRMLMarkupsNode* node, bool flag)
  {
    vtkWarningMacro("vtkSlicerMarkupsLogic::SetAllMarkupsVisibility method is deprecated, please use SetAllControlPointsVisibility instead");
    this->SetAllControlPointsVisibility(node, flag);
  };

  void ToggleAllMarkupsVisibility(vtkMRMLMarkupsNode* node)
  {
    vtkWarningMacro("vtkSlicerMarkupsLogic::ToggleAllMarkupsVisibility method is deprecated, please use ToggleAllControlPointsVisibility instead");
    this->ToggleAllControlPointsVisibility(node);
  };

  void SetAllMarkupsLocked(vtkMRMLMarkupsNode* node, bool flag)
  {
    vtkWarningMacro("vtkSlicerMarkupsLogic::SetAllMarkupsLocked method is deprecated, please use SetAllControlPointsLocked instead");
    this->SetAllControlPointsLocked(node, flag);
  };

  void ToggleAllMarkupsLocked(vtkMRMLMarkupsNode* node)
  {
    vtkWarningMacro("vtkSlicerMarkupsLogic::ToggleAllMarkupsLocked method is deprecated, please use ToggleAllControlPointsLocked instead");
    this->ToggleAllControlPointsLocked(node);
  };

  void SetAllMarkupsSelected(vtkMRMLMarkupsNode* node, bool flag)
  {
    vtkWarningMacro("vtkSlicerMarkupsLogic::SetAllMarkupsSelected method is deprecated, please use SetAllControlPointsSelected instead");
    this->SetAllControlPointsSelected(node, flag);
  };

  void ToggleAllMarkupsSelected(vtkMRMLMarkupsNode* node)
  {
    vtkWarningMacro("vtkSlicerMarkupsLogic::ToggleAllMarkupsSelected method is deprecated, please use ToggleAllControlPointsSelected instead");
    this->ToggleAllControlPointsSelected(node);
  };

  void RenameAllMarkupsFromCurrentFormat(vtkMRMLMarkupsNode* markupsNode)
  {
    vtkWarningMacro("vtkSlicerMarkupsLogic::RenameAllMarkupsFromCurrentFormat method is deprecated, please use RenameAllControlPointsFromCurrentFormat instead");
    this->RenameAllControlPointsFromCurrentFormat(markupsNode);
  };


  vtkVector3d GenerateUniqueColor();
  void GenerateUniqueColor(double color[3]);
 
protected:
  vtkSlicerMarkupsLogic();
  ~vtkSlicerMarkupsLogic() override;

  void SetMRMLSceneInternal(vtkMRMLScene* newScene) override;
  void ObserveMRMLScene() override;
  void SetAndObserveSelectionNode(vtkMRMLSelectionNode* selectionNode);

  void UpdatePlaceNodeClassNamesInSelectionNode();

  void RegisterNodes() override;
  void UpdateFromMRMLScene() override;
  void OnMRMLSceneNodeAdded(vtkMRMLNode* node) override;
  void OnMRMLSceneNodeRemoved(vtkMRMLNode* node) override;
  void OnMRMLSceneEndImport() override;
 
private:
  vtkSlicerMarkupsLogic(const vtkSlicerMarkupsLogic&) = delete;
  void operator=(const vtkSlicerMarkupsLogic&) = delete;
 
  bool AutoCreateDisplayNodes;
 
  class vtkInternal;
  vtkInternal* Internal;
};
 
#endif