vtkSlicerApplicationLogic.h

Go to the documentation of this file.

/*=========================================================================
 
  Copyright (c) Brigham and Women's Hospital (BWH) All Rights Reserved.
 
  See License.txt or http://www.slicer.org/copyright/copyright.txt for details.
 
==========================================================================*/
//
 
#ifndef __vtkSlicerApplicationLogic_h
#define __vtkSlicerApplicationLogic_h
 
// Slicer includes
#include "vtkSlicerBaseLogic.h"
 
// MRMLLogic includes
#include <vtkMRMLApplicationLogic.h>
 
// VTK includes
#include <vtkCollection.h>
 
// STL includes
#include <mutex>
#include <thread>
 
class vtkMRMLAbstractDisplayableManager;
class vtkMRMLAbstractViewNode;
class vtkMRMLSelectionNode;
class vtkMRMLInteractionNode;
class vtkMRMLRemoteIOLogic;
class vtkDataIOManagerLogic;
class vtkPersonInformation;
class vtkSlicerTask;
class ModifiedQueue;
class ProcessingTaskQueue;
class ReadDataQueue;
class ReadDataRequest;
class WriteDataQueue;
class WriteDataRequest;
 
class VTK_SLICER_BASE_LOGIC_EXPORT vtkSlicerApplicationLogic : public vtkMRMLApplicationLogic
{
public:
  static vtkSlicerApplicationLogic* New();
  vtkTypeMacro(vtkSlicerApplicationLogic, vtkMRMLApplicationLogic);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  void SetMRMLSceneDataIO(vtkMRMLScene* scene, vtkMRMLRemoteIOLogic* remoteIOLogic, vtkDataIOManagerLogic* dataIOManagerLogic);

  void CreateProcessingThread();

  void TerminateProcessingThread();
  enum RequestEvents
  {
    RequestModifiedEvent = vtkMRMLApplicationLogic::RequestInvokeEvent + 1,
    RequestReadDataEvent,
    RequestWriteDataEvent,
    RequestProcessedEvent
  };

  int ScheduleTask(vtkSlicerTask*);

  vtkMTimeType RequestModified(vtkObject*);

  vtkMTimeType RequestReadFile(const char* refNode, const char* filename, int displayData = false, int deleteFile = false);

  vtkMTimeType RequestUpdateParentTransform(const std::string& updatedNode, const std::string& parentTransformNode);

  vtkMTimeType RequestUpdateSubjectHierarchyLocation(const std::string& updatedNode, const std::string& siblingNode);

  vtkMTimeType RequestAddNodeReference(const std::string& referencingNode, const std::string& referencedNode, const std::string& role);

  unsigned int GetReadDataQueueSize();

  vtkMTimeType RequestWriteData(const char* refNode, const char* filename);

  vtkMTimeType RequestReadScene(const std::string& filename,
                                std::vector<std::string>& targetIDs,
                                std::vector<std::string>& sourceIDs,
                                int displayData = false,
                                int deleteFile = false);

  void ProcessModified();

  void ProcessReadData();

  void ProcessWriteData();

  void SetTracingOn() { this->Tracing = 1; }
  void SetTracingOff() { this->Tracing = 0; }

  static bool IsEmbeddedModule(const std::string& filePath, const std::string& applicationHomeDir, const std::string& slicerRevision);

  static bool IsPluginInstalled(const std::string& filePath, const std::string& applicationHomeDir);

  static bool IsPluginBuiltIn(const std::string& filePath, const std::string& applicationHomeDir, const std::string& slicerRevision);

  static std::string GetModuleShareDirectory(const std::string& moduleName, const std::string& filePath);

  static std::string GetModuleSlicerXYShareDirectory(const std::string& filePath);

  static std::string GetModuleSlicerXYLibDirectory(const std::string& filePath);

  vtkPersonInformation* GetUserInformation();

  static void RequestModifiedCallback(vtkObject* caller, unsigned long eid, void* clientData, void* callData);

  vtkMRMLAbstractDisplayableManager* GetViewDisplayableManagerByClassName(vtkMRMLAbstractViewNode* viewNode, const char* className) const;
 
protected:
  vtkSlicerApplicationLogic();
  ~vtkSlicerApplicationLogic() override;

  static void ProcessingThreaderCallback(vtkSlicerApplicationLogic* appLogic);

  static void NetworkingThreaderCallback(vtkSlicerApplicationLogic* appLogic);

  void ProcessProcessingTasks();

  void ProcessNetworkingTasks();

  void ProcessReadSceneData(ReadDataRequest& req);
  void ProcessWriteSceneData(WriteDataRequest& req);

  virtual void SetCurrentThreadPriorityToBackground();
 
private:
  vtkSlicerApplicationLogic(const vtkSlicerApplicationLogic&);
  void operator=(const vtkSlicerApplicationLogic&);
 
  std::mutex ProcessingThreadActiveLock;
  std::mutex ProcessingTaskQueueLock;
  std::mutex ModifiedQueueActiveLock;
  std::mutex ModifiedQueueLock;
  std::mutex ReadDataQueueActiveLock;
  std::mutex ReadDataQueueLock;
  std::mutex WriteDataQueueActiveLock;
  std::mutex WriteDataQueueLock;
  vtkTimeStamp RequestTimeStamp;
  std::thread ProcessingThread;
  std::vector<std::thread> NetworkingThreads;
  int ProcessingThreadActive;
  int ModifiedQueueActive;
  int ReadDataQueueActive;
  int WriteDataQueueActive;
 
  ProcessingTaskQueue* InternalTaskQueue;
  ModifiedQueue* InternalModifiedQueue;
  ReadDataQueue* InternalReadDataQueue;
  WriteDataQueue* InternalWriteDataQueue;
 
  vtkPersonInformation* UserInformation;

  int Tracing;
};
 
#endif