vtkSlicerSceneViewsModuleLogic.h

Go to the documentation of this file.

/*==============================================================================
 
  Program: 3D Slicer
 
  Copyright (c) Kitware Inc.
 
  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 Daniel Haehn, UPenn
  and was partially funded by NIH grant 3P41RR013218-12S1
 
==============================================================================*/
 
#ifndef vtkSlicerSceneViewsModuleLogic_h
#define vtkSlicerSceneViewsModuleLogic_h
 
// SlicerLogic includes
#include "vtkSlicerBaseLogic.h"
 
// MRMLLogic includes
#include "vtkMRMLAbstractLogic.h"
 
#include "vtkSlicerSceneViewsModuleLogicExport.h"
// #include "qSlicerSceneViewsModuleExport.h"
 
#include "vtkSlicerModuleLogic.h"
 
// MRML includes
class vtkMRMLSequenceBrowserNode;
class vtkMRMLSequenceNode;
class vtkMRMLSceneViewNode;
class vtkMRMLTextNode;
class vtkMRMLVolumeNode;
 
// VTK includes
class vtkImageData;
 
// STD includes
#include <string>
 
class VTK_SLICER_SCENEVIEWS_MODULE_LOGIC_EXPORT vtkSlicerSceneViewsModuleLogic : public vtkSlicerModuleLogic
{
public:
  static vtkSlicerSceneViewsModuleLogic* New();
  vtkTypeMacro(vtkSlicerSceneViewsModuleLogic, vtkSlicerModuleLogic);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  void SetMRMLSceneInternal(vtkMRMLScene* newScene) override;

  void RegisterNodes() override;

  void CreateSceneView(std::string name,
                       std::string description = "",
                       int screenshotType = ScreenShotType3D,
                       vtkImageData* screenshot = nullptr,
                       bool saveDisplayNodes = true,
                       bool saveViewNodes = true,
                       vtkMRMLSequenceBrowserNode* sequenceBrowser = nullptr);
  void CreateSceneView(vtkCollection* savedNodes,
                       std::string name,
                       std::string description = "",
                       int screenshotType = ScreenShotType3D,
                       vtkImageData* screenshot = nullptr,
                       vtkMRMLSequenceBrowserNode* sequenceBrowser = nullptr);
  void CreateSceneView(std::vector<vtkMRMLNode*> savedNodes,
                       std::string name,
                       std::string description = "",
                       int screenshotType = ScreenShotType3D,
                       vtkImageData* screenshot = nullptr,
                       vtkMRMLSequenceBrowserNode* sequenceBrowser = nullptr);

  int GetSceneViewIndexByName(std::string name);

  void ModifyNthSceneView(int sceneViewIndex, std::string name, std::string, int screenshotType, vtkImageData* screenshot);


  void UpdateNthSceneView(int sceneViewIndex, bool updateExistingNodes = true, bool saveDisplayNodes = true, bool saveViewNodes = true);
  void UpdateNthSceneView(int sceneViewIndex, vtkCollection* savedNodes, bool updateExistingNodes = true);
  void UpdateNthSceneView(int sceneViewIndex, std::vector<vtkMRMLNode*> savedNodes, bool updateExistingNodes = true);

  int SceneViewIndexToSequenceBrowserIndex(int sceneViewIndex);


  void SetNthSceneViewName(int index, std::string name);
  std::string GetNthSceneViewName(int index);

  int GetNumberOfSceneViews();


  void SetNthSceneViewDescription(int index, std::string description);
  std::string GetNthSceneViewDescription(int index);


  void SetNthSceneViewScreenshotType(int index, int type);
  int GetNthSceneViewScreenshotType(int index);


  void SetNthSceneViewScreenshot(int index, vtkImageData* screenshot);
  vtkImageData* GetNthSceneViewScreenshot(int index);


  bool RestoreSceneView(int sceneViewIndex);
  bool RestoreSceneView(std::string sceneViewName);

  std::string MoveSceneViewUp(std::string id);

  std::string MoveSceneViewDown(std::string id);

  bool RemoveSceneView(int index);

  // Attributes and values for marking sequence browsers as scene views.
  static const char* GetSceneViewNodeAttributeName();
  static const char* GetSceneViewNodeAttributeValue();

  // Attributes on the screenshot node which contain scene view names, descriptions and screenshot types.
  static const char* GetSceneViewNameAttributeName();
  static const char* GetSceneViewDescriptionAttributeName();
  static const char* GetSceneViewScreenshotTypeAttributeName();
 
  // Reference role for screenshot volume node.
  static const char* GetSceneViewScreenshotReferenceRole();
 
  // Returns the sequence browser used to record the scene views. If not found and addMissingNode is true,
  // then it will be created.
  vtkMRMLSequenceBrowserNode* GetSceneViewSequenceBrowserNode(bool addMissingNode);
 
  // Returns the sequence browser for the Nth scene view.
  vtkMRMLSequenceBrowserNode* GetNthSceneViewSequenceBrowserNode(int index);
 
  // Initialize a new scene view sequence browser node.
  vtkMRMLSequenceBrowserNode* AddNewSceneViewSequenceBrowserNode();

  enum
  {
    ScreenShotType3D = 0,
    ScreenShotTypeRed = 1,
    ScreenShotTypeYellow = 2,
    ScreenShotTypeGreen = 3,
    ScreenShotTypeFullLayout = 4
  };
 
  enum
  {
    SceneViewsModifiedEvent = 22001,
  };


  std::string GetScreenShotTypeAsString(int type);
  int GetScreenShotTypeFromString(const std::string& type);


  bool IsSceneViewNode(vtkMRMLNode* node);

  void GetDisplayNodes(std::vector<vtkMRMLNode*>& displayNodes);

  void GetViewNodes(std::vector<vtkMRMLNode*>& viewNodes);
 
  void GetDisplayNodeClasses(std::vector<std::string>& displayNodeTypes);
  std::vector<std::string> GetDisplayNodeClasses();
 
  void GetViewNodeClasses(std::vector<std::string>& viewNodeTypes);
  std::vector<std::string> GetViewNodeClasses();
 
protected:
  vtkSlicerSceneViewsModuleLogic();
 
  ~vtkSlicerSceneViewsModuleLogic() override;

  void OnMRMLSceneNodeAdded(vtkMRMLNode* node) override;
  void OnMRMLSceneEndImport() override;
  void OnMRMLSceneEndRestore() override;
  void OnMRMLSceneEndClose() override;

  void OnMRMLNodeModified(vtkMRMLNode* node) override;

  vtkMRMLVolumeNode* GetSceneViewScreenshotProxyNode(vtkMRMLSequenceBrowserNode* sequenceBrowser = nullptr);

  vtkMRMLNode* GetNthSceneViewDataNode(int index, vtkMRMLNode* proxyNode);

  vtkMRMLVolumeNode* GetNthSceneViewScreenshotDataNode(int index);

  vtkMRMLVolumeNode* GetNthSceneViewScreenshotProxyNode(int index);

  // Set/Get an attribute on the data node for the Nth scene view.
  void SetNthNodeAttribute(vtkMRMLNode* proxyTextNode, int index, std::string attributeName, std::string text);
  std::string GetNthNodeAttribute(vtkMRMLNode* proxyTextNode, int index, std::string attributeName);
 
protected:
  void ConvertSceneViewNodesToSequenceBrowserNodes(vtkMRMLScene* scene);

  vtkMRMLSequenceBrowserNode* ConvertSceneViewNodeToSequenceBrowserNode(vtkMRMLSceneViewNode* sceneView, vtkMRMLSequenceBrowserNode* sequenceBrowserNode);

  vtkMRMLSequenceNode* GetOrAddSceneViewSequenceNode(vtkMRMLSequenceBrowserNode* sequenceBrowser, vtkMRMLNode* proxyNode);
 
private:
  std::string m_StringHolder;
 
private:
  vtkSlicerSceneViewsModuleLogic(const vtkSlicerSceneViewsModuleLogic&) = delete;
  void operator=(const vtkSlicerSceneViewsModuleLogic&) = delete;
};
 
#endif