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 <itkMultiThreader.h>
#include <itkMutexLock.h>

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) VTK_OVERRIDE;

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


  void PropagateFiducialListSelection();

  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);

  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);

  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();

protected:

  vtkSlicerApplicationLogic();
  ~vtkSlicerApplicationLogic();

  static ITK_THREAD_RETURN_TYPE ProcessingThreaderCallback( void * );

  static ITK_THREAD_RETURN_TYPE NetworkingThreaderCallback( void * );

  void ProcessProcessingTasks();

  void ProcessNetworkingTasks();

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

private:
  vtkSlicerApplicationLogic(const vtkSlicerApplicationLogic&);
  void operator=(const vtkSlicerApplicationLogic&);

  itk::MultiThreader::Pointer ProcessingThreader;
  itk::MutexLock::Pointer ProcessingThreadActiveLock;
  itk::MutexLock::Pointer ProcessingTaskQueueLock;
  itk::MutexLock::Pointer ModifiedQueueActiveLock;
  itk::MutexLock::Pointer ModifiedQueueLock;
  itk::MutexLock::Pointer ReadDataQueueActiveLock;
  itk::MutexLock::Pointer ReadDataQueueLock;
  itk::MutexLock::Pointer WriteDataQueueActiveLock;
  itk::MutexLock::Pointer 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