vtkSlicerApplicationLogic.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Slicer3 Application Logic
  Module:    $HeadURL: http://svn.slicer.org/Slicer3/trunk/Base/Logic/vtkSlicerApplicationLogic.h $
  Language:  C++
  Date:      $Date: 2011-01-30 12:51:01 -0500 (Sun, 30 Jan 2011) $
  Version:   $Revision: 15856 $

  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

#include "vtkMRMLSelectionNode.h"
#include "vtkMRMLInteractionNode.h"

#include "vtkSlicerBaseLogic.h"
#include "vtkSlicerLogic.h"
#include "vtkSlicerSliceLogic.h"

#include "vtkCollection.h"

#include "itkMultiThreader.h"
#include "itkMutexLock.h"

//BTX
class ProcessingTaskQueue;
class ModifiedQueue;
class ReadDataQueue;
class ReadDataRequest;
class WriteDataQueue;
class WriteDataRequest;
class vtkSlicerTask;
//ETX

//BTX
class SliceLogicMap;
//ETX

class VTK_SLICER_BASE_LOGIC_EXPORT vtkSlicerApplicationLogic : public vtkSlicerLogic 
{
  public:
  
  static vtkSlicerApplicationLogic *New();
  vtkTypeRevisionMacro(vtkSlicerApplicationLogic,vtkSlicerLogic);
  void PrintSelf(ostream& os, vtkIndent indent);
    

  void Connect (const char *URL) {
    if (this->MRMLScene)
     {
      this->MRMLScene->SetURL(URL);
      this->MRMLScene->Connect();
      }
  };

  int Commit () {
    if (this->MRMLScene)
      {
      return (this->MRMLScene->Commit());
      }
    return (0);
  };
  int Commit (const char *URL) {
    if (this->MRMLScene)
      {
      return (this->MRMLScene->Commit(URL));
      }
    return (0);
  };


 


  //
  //

  //vtkSetObjectMacro (Views,vtkCollection);
  vtkGetObjectMacro (Views,vtkCollection);

  //vtkSetObjectMacro (ActiveView,vtkSlicerViewLogic);
  //vtkGetObjectMacro (ActiveView,vtkSlicerViewLogic);

  //vtkSetObjectMacro (Slices,vtkCollection);
  //vtkGetObjectMacro (Slices,vtkCollection);

  vtkSetObjectMacro (ActiveSlice,vtkSlicerSliceLogic);
  vtkGetObjectMacro (ActiveSlice,vtkSlicerSliceLogic);

  vtkSetObjectMacro (SelectionNode,vtkMRMLSelectionNode);
  vtkGetObjectMacro (SelectionNode,vtkMRMLSelectionNode);

  vtkSetObjectMacro (InteractionNode,vtkMRMLInteractionNode);
  vtkGetObjectMacro (InteractionNode,vtkMRMLInteractionNode);

  void PropagateVolumeSelection(int fit);
  void PropagateVolumeSelection() {this->PropagateVolumeSelection(1);}; 

  void PropagateVolumeLayerSelection(int layer);

  void PropagateFiducialListSelection();
  
  //vtkSetObjectMacro (Modules,vtkCollection);
  vtkGetObjectMacro (Modules,vtkCollection);

  //vtkSetObjectMacro (ActiveModule,vtkSlicerModule);
  //vtkGetObjectMacro (ActiveModule,vtkSlicerModule);

  virtual void ProcessMRMLEvents ( vtkObject * /*caller*/, 
                                  unsigned long /*event*/, 
                                  void * /*callData*/ );
  virtual void ProcessMRMLEvents () { this->ProcessMRMLEvents( NULL, vtkCommand::NoEvent, NULL ); };

  void CreateProcessingThread();

  void CreateSliceLogics();
  void DeleteSliceLogics();

  void TerminateProcessingThread();
  
  int ScheduleTask( vtkSlicerTask* );

  int RequestModified( vtkObject * );

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

  unsigned int GetReadDataQueueSize();


  int RequestWriteData(const char *refNode, const char *filename,
                       int displayData = false,
                       int deleteFile=false);
  //
  //BTX
  int RequestReadScene(const std::string& filename,
                       std::vector<std::string> &targetIDs,
                       std::vector<std::string> &sourceIDs,
                       int displayData = false,
                       int deleteFile = false);
  //ETX
  
  void ProcessModified();

  void ProcessReadData();
  void ProcessWriteData();

  void AddSliceLogic(const char *layoutName, vtkSlicerSliceLogic *sliceLogic);

  void AddSliceLogic(vtkSlicerSliceLogic *sliceLogic);

  vtkSlicerSliceLogic* GetSliceLogic(const char *layoutName);

  void RemoveSliceLogic(vtkSlicerSliceLogic *sliceLogic);
  void RemoveSliceLogic(char *layoutName);
  
  //
  //

  void ClearCollections ( );


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

protected:

  vtkSlicerApplicationLogic();
  ~vtkSlicerApplicationLogic();
  vtkSlicerApplicationLogic(const vtkSlicerApplicationLogic&);
  void operator=(const vtkSlicerApplicationLogic&);

  static ITK_THREAD_RETURN_TYPE ProcessingThreaderCallback( void * );

  static ITK_THREAD_RETURN_TYPE NetworkingThreaderCallback( void * );
  
  void ProcessProcessingTasks();

  void ProcessNetworkingTasks();

  //BTX
  void ProcessReadNodeData( ReadDataRequest &req );
  void ProcessWriteNodeData( WriteDataRequest &req );
  //EXT
  

  //BTX
  void ProcessReadSceneData( ReadDataRequest &req );
  void ProcessWriteSceneData( WriteDataRequest &req );
  //EXT
  
private:
  //BTX
  SliceLogicMap *InternalSliceLogicMap;
  //ETX
  
  vtkCollection *Views;
  //vtkCollection *Slices;
  vtkCollection *Modules;

  //vtkSlicerViewLogic *ActiveView;
  vtkSlicerSliceLogic *ActiveSlice;
  vtkMRMLSelectionNode *SelectionNode;
  vtkMRMLInteractionNode *InteractionNode;
  //vtkSlicerModuleLogic *ActiveModule;

  //BTX
  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;
  //ETX
  int ProcessingThreadId;
  //BTX
  std::vector<int> NetworkingThreadIDs;
  //ETX
  int ProcessingThreadActive;
  int ModifiedQueueActive;
  int ReadDataQueueActive;
  int WriteDataQueueActive;

  ProcessingTaskQueue* InternalTaskQueue;
  ModifiedQueue* InternalModifiedQueue;
  ReadDataQueue* InternalReadDataQueue;
  WriteDataQueue* InternalWriteDataQueue;
  
  
  int Tracing;
};

#endif