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"

// MRML includes

// STD includes
#include <cstdlib>

#include "vtkSlicerMarkupsModuleLogicExport.h"

class vtkMatrix4x4;
class vtkMRMLMarkupsNode;
class vtkMRMLMarkupsClosedCurveNode;
class vtkMRMLMarkupsDisplayNode;
class vtkMRMLMarkupsJsonStorageNode;
class vtkMRMLSelectionNode;
class vtkPlane;
class vtkPoints;
class vtkPolyData;

class VTK_SLICER_MARKUPS_MODULE_LOGIC_EXPORT vtkSlicerMarkupsLogic :
  public vtkSlicerModuleLogic
{
public:

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

  std::string AddNewDisplayNodeForMarkupsNode(vtkMRMLNode *mrmlNode);

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

  int AddFiducial(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);

  char* LoadMarkupsFiducials(const char* fileName, const char* fidsName = nullptr);

  char* LoadMarkupsFromFcsv(const char* fileName, const char* nodeName/*=nullptr*/);
  char* LoadMarkupsFromJson(const char* fileName, const char* nodeName/*=nullptr*/);

  void SetAllMarkupsVisibility(vtkMRMLMarkupsNode *node, bool flag);
  void ToggleAllMarkupsVisibility(vtkMRMLMarkupsNode *node);
  void SetAllMarkupsLocked(vtkMRMLMarkupsNode *node, bool flag);
  void ToggleAllMarkupsLocked(vtkMRMLMarkupsNode *node);
  void SetAllMarkupsSelected(vtkMRMLMarkupsNode *node, bool flag);
  void ToggleAllMarkupsSelected(vtkMRMLMarkupsNode *node);

  void SetDisplayNodeToDefaults(vtkMRMLMarkupsDisplayNode *displayNode);

  void SetDisplayDefaultsFromNode(vtkMRMLMarkupsDisplayNode *displayNode);

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

  bool CopyNthMarkupToNewList(int n, vtkMRMLMarkupsNode *markupsNode,
                              vtkMRMLMarkupsNode *newMarkupsNode)
    {
    return this->CopyNthControlPointToNewList(n, markupsNode, newMarkupsNode);
    }

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

  bool MoveNthMarkupToNewList(int n, vtkMRMLMarkupsNode *markupsNode,
                              vtkMRMLMarkupsNode *newMarkupsNode, int newIndex)
    {
    return this->MoveNthControlPointToNewListAtIndex(n, markupsNode, newMarkupsNode, newIndex);
    }

  void ConvertAnnotationFiducialsToMarkups();

  void RenameAllMarkupsFromCurrentFormat(vtkMRMLMarkupsNode *markupsNode);

  bool StartPlaceMode(bool persistent, vtkMRMLInteractionNode* interactionNode = nullptr);

  int GetSliceIntersectionsVisibility();
  void SetSliceIntersectionsVisibility(bool flag);

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

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

  static bool IsPolygonClockwise(vtkPoints* points);

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

protected:
  vtkSlicerMarkupsLogic();
  ~vtkSlicerMarkupsLogic() override;

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

  void RegisterNodes() override;
  void UpdateFromMRMLScene() override;
  void OnMRMLSceneNodeAdded(vtkMRMLNode* node) override;
  void OnMRMLSceneNodeRemoved(vtkMRMLNode* node) override;

  std::map<std::string, std::string> MarkupsTypeStorageNodes;
  vtkMRMLSelectionNode* SelectionNode{nullptr};

private:

  vtkSlicerMarkupsLogic(const vtkSlicerMarkupsLogic&) = delete;
  void operator=(const vtkSlicerMarkupsLogic&) = delete;

  bool AutoCreateDisplayNodes;
};

#endif