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 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
  };
  enum RequestEvents {…};

  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 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;
};
class VTK_SLICER_BASE_LOGIC_EXPORT vtkSlicerApplicationLogic {…};
 
#endif