igstkVideoImager.h

Go to the documentation of this file.

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

  Program:   Image Guided Surgery Software Toolkit
  Module:    $RCSfile: igstkVideoImager.h,v $
  Language:  C++
  Date:      $Date: 2009-06-18 18:40:55 $
  Version:   $Revision: 1.1 $

  Copyright (c) ISC  Insight Software Consortium.  All rights reserved.
  See IGSTKCopyright.txt or http://www.igstk.org/copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notices for more information.

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

#ifndef __igstkVideoImager_h
#define __igstkVideoImager_h

#include <vector>
#include <map>

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

#include "igstkObject.h"
#include "igstkStateMachine.h"
#include "igstkTransform.h"
#include "igstkFrame.h"
#include "igstkPulseGenerator.h"
#include "igstkVideoImagerTool.h"

#include "igstkCoordinateSystemInterfaceMacros.h"

namespace igstk
{

igstkEventMacro( VideoImagerEvent,                   StringEvent);
igstkEventMacro( VideoImagerErrorEvent,              IGSTKErrorWithStringEvent);

igstkEventMacro( VideoImagerOpenEvent,               VideoImagerEvent);
igstkEventMacro( VideoImagerOpenErrorEvent,          VideoImagerErrorEvent);

igstkEventMacro( VideoImagerCloseEvent,              VideoImagerEvent);
igstkEventMacro( VideoImagerCloseErrorEvent,         VideoImagerErrorEvent);

igstkEventMacro( VideoImagerInitializeEvent,         VideoImagerEvent);
igstkEventMacro( VideoImagerInitializeErrorEvent,    VideoImagerErrorEvent);

igstkEventMacro( VideoImagerStartImagingEvent,       VideoImagerEvent);
igstkEventMacro( VideoImagerStartImagingErrorEvent,  VideoImagerErrorEvent);

igstkEventMacro( VideoImagerStopImagingEvent,        VideoImagerEvent);
igstkEventMacro( VideoImagerStopImagingErrorEvent,   VideoImagerErrorEvent);

igstkEventMacro( VideoImagerUpdateStatusEvent,       VideoImagerEvent);
igstkEventMacro( VideoImagerUpdateStatusErrorEvent,  VideoImagerErrorEvent);

class VideoImager : public Object
{

public:
  igstkStandardAbstractClassTraitsMacro( VideoImager, Object )

public:

  igstkFriendClassMacro( VideoImagerTool );

  typedef VideoImagerTool       VideoImagerToolType;

  void RequestOpen( void );

  void RequestClose( void );

  void RequestReset( void );

  void RequestStartImaging( void );

  void RequestStopImaging( void );

  void RequestSetFrequency( double frequencyInHz );

protected:

  VideoImager(void);
  virtual ~VideoImager(void);

  igstkSetMacro( ThreadingEnabled, bool );

  igstkGetMacro( ThreadingEnabled, bool );

  typedef Transform::TimePeriodType         TimePeriodType;

  igstkGetMacro( ValidityTime, TimePeriodType );

  typedef enum
    {
    FAILURE=0,
    SUCCESS
    } ResultType;

  typedef Transform                      TransformType;

  typedef Frame                          FrameType;

  virtual ResultType InternalOpen( void ) = 0;

  virtual ResultType InternalClose( void ) = 0;

  virtual ResultType InternalReset( void ) = 0;

  virtual ResultType InternalStartImaging( void ) = 0;

  virtual ResultType InternalStopImaging( void ) = 0;


  virtual ResultType InternalUpdateStatus( void ) = 0;

  virtual ResultType InternalThreadedUpdateStatus( void ) = 0;

  virtual void PrintSelf( std::ostream& os, itk::Indent indent ) const;

  virtual ResultType
        VerifyVideoImagerToolInformation( const VideoImagerToolType * ) = 0;

  virtual ResultType ValidateSpecifiedFrequency( double frequencyInHz );

  virtual ResultType RemoveVideoImagerToolFromInternalDataContainers(
                              const VideoImagerToolType * videoImagerTool ) = 0;

  virtual ResultType AddVideoImagerToolToInternalDataContainers(
                              const VideoImagerToolType * videoImagerTool ) = 0;

  typedef std::map< std::string, VideoImagerToolType *>
                                                  VideoImagerToolsContainerType;

  const VideoImagerToolsContainerType & GetVideoImagerToolContainer() const;

  void ReportImagingToolNotAvailable(
                                  VideoImagerToolType * VideoImagerTool ) const;

  void ReportImagingToolStreaming(
                                  VideoImagerToolType * videoImagerTool ) const;

  void SetVideoImagerToolFrame( VideoImagerToolType * videoImagerTool,
                                   FrameType* frame );

  FrameType* GetVideoImagerToolFrame( VideoImagerToolType * videoImagerTool);

  void SetVideoImagerToolUpdate( VideoImagerToolType * videoImagerTool,
                                      bool flag ) const;

  void ExitImagingStateProcessing( void );

  void ExitImagingWithoutTerminatingImagingThread();

  void ExitImagingTerminatingImagingThread();

private:
  VideoImager(const Self&);           //purposely not implemented
  void operator=(const Self&);    //purposely not implemented

  PulseGenerator::Pointer   m_PulseGenerator;

  typedef itk::SimpleMemberCommand< Self >   ObserverType;
  ObserverType::Pointer     m_PulseObserver;

  VideoImagerToolsContainerType           m_VideoImagerTools;

  typedef VideoImagerToolType::Pointer                   VideoImagerToolPointer;

  TimePeriodType                      m_ValidityTime;

  bool                                m_ThreadingEnabled;

  bool                                m_ImagingThreadStarted;

  itk::MultiThreader::Pointer     m_Threader;

  int                             m_ThreadID;

  itk::ConditionVariable::Pointer m_ConditionNextFrameReceived;

  itk::SimpleMutexLock            m_LockForConditionNextFrameReceived;

  igstkDeclareStateMacro( Idle );
  igstkDeclareStateMacro( AttemptingToEstablishCommunication );
  igstkDeclareStateMacro( AttemptingToCloseCommunication );
  igstkDeclareStateMacro( CommunicationEstablished );
  igstkDeclareStateMacro( AttemptingToAttachVideoImagerTool );
  igstkDeclareStateMacro( VideoImagerToolAttached );
  igstkDeclareStateMacro( AttemptingToImaging );
  igstkDeclareStateMacro( Imaging );
  igstkDeclareStateMacro( AttemptingToUpdate );
  igstkDeclareStateMacro( AttemptingToStopImaging );

  igstkDeclareInputMacro( EstablishCommunication );
  igstkDeclareInputMacro( StartImaging );
  igstkDeclareInputMacro( AttachVideoImagerTool );
  igstkDeclareInputMacro( UpdateStatus );
  igstkDeclareInputMacro( StopImaging );
  igstkDeclareInputMacro( Reset );
  igstkDeclareInputMacro( CloseCommunication );
  igstkDeclareInputMacro( ValidFrequency );

  igstkDeclareInputMacro( Success );
  igstkDeclareInputMacro( Failure );

  void RequestAttachTool( VideoImagerToolType * videoImagerTool );

  ResultType RequestRemoveTool( VideoImagerToolType * videoImagerTool );

  static ITK_THREAD_RETURN_TYPE ImagingThreadFunction(void* pInfoStruct);

  void UpdateStatus( void );

  void AttemptToOpenProcessing( void );

  void AttemptToStartImagingProcessing( void );

  void AttemptToStopImagingProcessing( void );

  void AttemptToAttachVideoImagerToolProcessing( void );

  void AttemptToUpdateStatusProcessing( void );

  void UpdateStatusSuccessProcessing( void );

  void UpdateStatusFailureProcessing( void );

  void CloseFromImagingStateProcessing( void );

  void CloseFromCommunicatingStateProcessing( void );

  void ResetFromImagingStateProcessing( void );

  void ResetFromToolsActiveStateProcessing( void);

  void ResetFromCommunicatingStateProcessing( void );

  void CommunicationEstablishmentSuccessProcessing( void );

  void CommunicationEstablishmentFailureProcessing( void );

  void ToolsActivationSuccessProcessing( void );

  void ToolsActivationFailureProcessing( void );

  void StartImagingSuccessProcessing( void );

  void StartImagingFailureProcessing( void );

  void AttachingVideoImagerToolSuccessProcessing( void );

  void AttachingVideoImagerToolFailureProcessing( void );

  void StopImagingSuccessProcessing( void );

  void StopImagingFailureProcessing( void );

  void CloseCommunicationSuccessProcessing( void );

  void CloseCommunicationFailureProcessing( void );

  void EnterImagingStateProcessing( void );

  void DetachAllVideoImagerToolsFromVideoImager();

  void ReportInvalidRequestProcessing( void );

  void SetFrequencyProcessing( void );

  igstkCoordinateSystemClassInterfaceMacro();

  VideoImagerToolType   * m_VideoImagerToolToBeAttached;

  double                  m_FrequencyToBeSet;
};

}

#endif //__igstk_VideoImager_h_