vtkMRMLApplicationLogic.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 Jean-Christophe Fillion-Robin, Kitware Inc.
  and was partially funded by NIH grant 3P41RR013218-12S1

==============================================================================*/

#ifndef __vtkMRMLApplicationLogic_h
#define __vtkMRMLApplicationLogic_h

// MRMLLogic includes
#include "vtkMRMLAbstractLogic.h"

#include "vtkMRMLLogicExport.h"
#include "vtkMRMLSliceCompositeNode.h"

class vtkMRMLColorLogic;
class vtkMRMLModelDisplayNode;
class vtkMRMLSliceNode;
class vtkMRMLSliceLogic;
class vtkMRMLSelectionNode;
class vtkMRMLStorableNode;
class vtkMRMLStorageNode;
class vtkMRMLInteractionNode;
class vtkMRMLViewLogic;
class vtkMRMLViewNode;

// VTK includes
class vtkCollection;
class vtkImageData;

// STD includes
#include <vector>

class VTK_MRML_LOGIC_EXPORT vtkMRMLApplicationLogic
  : public vtkMRMLAbstractLogic
{
public:

  static vtkMRMLApplicationLogic *New();
  void PrintSelf(ostream& os, vtkIndent indent) override;
  vtkTypeMacro(vtkMRMLApplicationLogic, vtkMRMLAbstractLogic);

  vtkMRMLSelectionNode* GetSelectionNode()const;

  vtkMRMLInteractionNode* GetInteractionNode()const;

  void SetSliceLogics(vtkCollection* sliceLogics);
  vtkCollection* GetSliceLogics()const;
  vtkMRMLSliceLogic* GetSliceLogic(vtkMRMLSliceNode* sliceNode) const;
  vtkMRMLSliceLogic* GetSliceLogicByLayoutName(const char* layoutName) const;
  vtkMRMLSliceLogic* GetSliceLogicByModelDisplayNode(vtkMRMLModelDisplayNode* displayNode) const;

  void SetViewLogics(vtkCollection* viewLogics);
  vtkCollection* GetViewLogics()const;
  vtkMRMLViewLogic* GetViewLogic(vtkMRMLViewNode* viewNode) const;
  vtkMRMLViewLogic* GetViewLogicByLayoutName(const char* layoutName) const;

  void SetColorLogic(vtkMRMLColorLogic* newColorLogic);
  vtkMRMLColorLogic* GetColorLogic()const;

  void PropagateVolumeSelection(int fit = 1);

  void PropagateBackgroundVolumeSelection(int fit = 1);

  void PropagateForegroundVolumeSelection(int fit = 1);

  void PropagateLabelVolumeSelection(int fit = 1);

  enum Layers
  {
    LabelLayer = 0x1,
    ForegroundLayer = 0x2,
    BackgroundLayer = 0x4,
    AllLayers = LabelLayer | ForegroundLayer | BackgroundLayer
  };

  void PropagateVolumeSelection(int layer, int fit);

  void FitSliceToAll(bool onlyIfPropagateVolumeSelectionAllowed=false, bool resetOrientation=true);

  void PropagateTableSelection();

  void PropagatePlotChartSelection();

  bool Zip(const char* zipFileName, const char* directoryToZip);

  bool Unzip(const char* zipFileName, const char* destinationDirectory);

  static std::string PercentEncode(std::string s);

  bool SaveSceneToSlicerDataBundleDirectory(const char* sdbDir, vtkImageData* screenShot = nullptr);

  bool OpenSlicerDataBundle(const char* sdbFilePath, const char* temporaryDirectory);

  std::string UnpackSlicerDataBundle(const char* sdbFilePath, const char* temporaryDirectory);

  static int LoadDefaultParameterSets(vtkMRMLScene* scene,
                                      const std::vector<std::string>& directories);

  static std::string CreateUniqueFileName(const std::string &filename, const std::string& knownExtension="");

  enum Events{
    RequestInvokeEvent = vtkCommand::UserEvent + 1,
    PauseRenderEvent = vtkCommand::UserEvent + 101,
    ResumeRenderEvent,
    EditNodeEvent,
    ShowViewContextMenuEvent,
  };
  struct InvokeRequest{
    InvokeRequest();
    unsigned int Delay{100};
    vtkObject* Caller{nullptr};
    unsigned long EventID{vtkCommand::ModifiedEvent};
    void* CallData{nullptr};
  };
  void InvokeEventWithDelay(unsigned int delayInMs,
                            vtkObject* caller,
                            unsigned long eventID = vtkCommand::ModifiedEvent,
                            void* callData = nullptr);

  const char* GetTemporaryPath();

  void SetTemporaryPath(const char* path);

  void SaveSceneScreenshot(vtkImageData* screenshot);

  virtual void PauseRender();

  virtual void ResumeRender();

  virtual void EditNode(vtkMRMLNode* node);

  void SetModuleLogic(const char* moduleName, vtkMRMLAbstractLogic* moduleLogic);

  vtkMRMLAbstractLogic* GetModuleLogic(const char* moduleName) const;

  enum IntersectingSlicesOperation
  {
    IntersectingSlicesVisibility,
    IntersectingSlicesInteractive,
    IntersectingSlicesTranslation,
    IntersectingSlicesRotation,
  };

  void SetIntersectingSlicesEnabled(IntersectingSlicesOperation operation, bool enabled);
  bool GetIntersectingSlicesEnabled(IntersectingSlicesOperation operation);

  void SetIntersectingSlicesIntersectionMode(int mode);
  int GetIntersectingSlicesIntersectionMode();

  void SetIntersectingSlicesLineThicknessMode(int mode);
  int GetIntersectingSlicesLineThicknessMode();

protected:

  vtkMRMLApplicationLogic();
  ~vtkMRMLApplicationLogic() override;

  void SetMRMLSceneInternal(vtkMRMLScene *newScene) override;

  void SetSelectionNode(vtkMRMLSelectionNode* );
  void SetInteractionNode(vtkMRMLInteractionNode* );

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

  void OnMRMLSceneStartBatchProcess() override;
  void OnMRMLSceneEndBatchProcess() override;
  void OnMRMLSceneStartImport() override;
  void OnMRMLSceneEndImport() override;
  void OnMRMLSceneStartRestore() override;
  void OnMRMLSceneEndRestore() override;

private:

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

  class vtkInternal;
  vtkInternal* Internal;

};


#endif