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>
 
// ITK includes
#include <itkPlatformMultiThreader.h>
 
// STL includes
#include <mutex>
 
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);
 
protected:
 
  vtkSlicerApplicationLogic();
  ~vtkSlicerApplicationLogic() override;
 
  static itk::ITK_THREAD_RETURN_TYPE ProcessingThreaderCallback( void * );
 
  static itk::ITK_THREAD_RETURN_TYPE NetworkingThreaderCallback( void * );
 
  void ProcessProcessingTasks();
 
  void ProcessNetworkingTasks();
 
  void ProcessReadSceneData( ReadDataRequest &req );
  void ProcessWriteSceneData( WriteDataRequest &req );
 
  virtual void SetCurrentThreadPriorityToBackground();
 
private:
  vtkSlicerApplicationLogic(const vtkSlicerApplicationLogic&);
  void operator=(const vtkSlicerApplicationLogic&);
 
  itk::PlatformMultiThreader::Pointer ProcessingThreader;
  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;
  int ProcessingThreadId;
  std::vector<int> NetworkingThreadIDs;
  int ProcessingThreadActive;
  int ModifiedQueueActive;
  int ReadDataQueueActive;
  int WriteDataQueueActive;
 
  ProcessingTaskQueue* InternalTaskQueue;
  ModifiedQueue*       InternalModifiedQueue;
  ReadDataQueue*       InternalReadDataQueue;
  WriteDataQueue*      InternalWriteDataQueue;
 
  vtkPersonInformation* UserInformation;
 
  int Tracing;
};
 
#endif