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