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 vtkMRMLMarkupsNode;
class vtkMRMLMarkupsDisplayNode;

class VTK_SLICER_MARKUPS_MODULE_LOGIC_EXPORT vtkSlicerMarkupsLogic :
  public vtkSlicerModuleLogic
{
public:

  static vtkSlicerMarkupsLogic *New();
  vtkTypeMacro(vtkSlicerMarkupsLogic,vtkSlicerModuleLogic);
  void PrintSelf(ostream& os, vtkIndent indent) VTK_OVERRIDE;

  virtual void ProcessMRMLNodesEvents(vtkObject *caller,
                                      unsigned long event,
                                      void *callData ) VTK_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 = NULL);

  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);
  void JumpSlicesToNthPointInMarkup(const char *id, int n, bool centered = false, int viewGroup = -1);
  void FocusCamerasOnNthPointInMarkup(const char *id, int n);
  void FocusCameraOnNthPointInMarkup(const char *cameraNodeID, const char *markupNodeID, int n);

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

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

  int GetDefaultMarkupsDisplayNodeGlyphType();
  void SetDefaultMarkupsDisplayNodeGlyphType(int glyphType);
  void SetDefaultMarkupsDisplayNodeGlyphTypeFromString(const char *glyphType);
  std::string GetDefaultMarkupsDisplayNodeGlyphTypeAsString();

  double GetDefaultMarkupsDisplayNodeGlyphScale();
  void SetDefaultMarkupsDisplayNodeGlyphScale(double scale);

  double GetDefaultMarkupsDisplayNodeTextScale();
  void SetDefaultMarkupsDisplayNodeTextScale(double scale);

  double GetDefaultMarkupsDisplayNodeOpacity();
  void SetDefaultMarkupsDisplayNodeOpacity(double opacity);

  double *GetDefaultMarkupsDisplayNodeColor();
  void SetDefaultMarkupsDisplayNodeColor(double *color);
  void SetDefaultMarkupsDisplayNodeColor(double r, double g, double b);

  double *GetDefaultMarkupsDisplayNodeSelectedColor();
  void SetDefaultMarkupsDisplayNodeSelectedColor(double *color);
  void SetDefaultMarkupsDisplayNodeSelectedColor(double r, double g, double b);

  int GetDefaultMarkupsDisplayNodeSliceProjection();
  void SetDefaultMarkupsDisplayNodeSliceProjection(int projection);

  double *GetDefaultMarkupsDisplayNodeSliceProjectionColor();
  void SetDefaultMarkupsDisplayNodeSliceProjectionColor(double *color);
  void SetDefaultMarkupsDisplayNodeSliceProjectionColor(double r, double g, double b);

  double GetDefaultMarkupsDisplayNodeSliceProjectionOpacity();
  void SetDefaultMarkupsDisplayNodeSliceProjectionOpacity(double opacity);

  void SetDisplayNodeToDefaults(vtkMRMLMarkupsDisplayNode *displayNode);

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

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

  void ConvertAnnotationFiducialsToMarkups();

  void RenameAllMarkupsFromCurrentFormat(vtkMRMLMarkupsNode *markupsNode);

  bool StartPlaceMode(bool persistent);

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

protected:
  vtkSlicerMarkupsLogic();
  virtual ~vtkSlicerMarkupsLogic();

  virtual void SetMRMLSceneInternal(vtkMRMLScene * newScene) VTK_OVERRIDE;
  virtual void ObserveMRMLScene() VTK_OVERRIDE;

  virtual void RegisterNodes() VTK_OVERRIDE;
  virtual void UpdateFromMRMLScene() VTK_OVERRIDE;
  virtual void OnMRMLSceneNodeAdded(vtkMRMLNode* node) VTK_OVERRIDE;
  virtual void OnMRMLSceneNodeRemoved(vtkMRMLNode* node) VTK_OVERRIDE;

private:

  vtkSlicerMarkupsLogic(const vtkSlicerMarkupsLogic&); // Not implemented
  void operator=(const vtkSlicerMarkupsLogic&);               // Not implemented

  vtkMRMLMarkupsDisplayNode *DefaultMarkupsDisplayNode;
};

#endif