mitkIGTLDevice.h

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
 
============================================================================*/
 
#ifndef mitkIGTLDevice_h
#define mitkIGTLDevice_h
 
#include <mutex>
#include <thread>
 
#include "mitkCommon.h"
 
//itk
#include "itkObject.h"
 
//igtl
#include "igtlSocket.h"
#include "igtlMessageBase.h"
#include "igtlTransformMessage.h"
 
//mitkIGTL
#include "MitkOpenIGTLinkExports.h"
#include "mitkIGTLMessageFactory.h"
#include "mitkIGTLMessageQueue.h"
#include "mitkIGTLMessage.h"
 
#if !defined(MITK_WINDOWS_NO_UNDEF) && defined(SendMessage)
  #undef SendMessage
#endif
 
namespace mitk {
  class MITKOPENIGTLINK_EXPORT IGTLDevice : public itk::Object
  {
  public:
    mitkClassMacroItkParent(IGTLDevice, itk::Object);
 
      IGTLDevice(bool ReadFully);
 
    enum IGTLDeviceState { Setup, Ready, Running };
 
    virtual bool OpenConnection() = 0;
 
    virtual bool CloseConnection();
 
    virtual bool StopCommunication();
 
    bool StartCommunication();
 
    void RunCommunication(void (IGTLDevice::*ComFunction)(void), std::mutex& mutex);
 
 
    void SendMessage(mitk::IGTLMessage::Pointer msg);
 
    IGTLDeviceState GetState() const;
 
    igtl::MessageBase::Pointer GetNextCommand();
 
    igtl::ImageMessage::Pointer GetNextImage2dMessage();
 
    igtl::ImageMessage::Pointer GetNextImage3dMessage();
 
    igtl::TransformMessage::Pointer GetNextTransformMessage();
 
    igtl::TrackingDataMessage::Pointer GetNextTrackingDataMessage();
 
    igtl::StringMessage::Pointer GetNextStringMessage();
 
    igtl::MessageBase::Pointer GetNextMiscMessage();
 
    itkSetMacro(PortNumber, int);
 
    itkGetMacro(PortNumber, int);
 
    itkSetMacro(Hostname, std::string);
 
    itkGetMacro(Hostname, std::string);
 
    itkGetConstMacro(Name, std::string);
 
    itkSetMacro(Name, std::string);
 
    itkSetMacro(ReadFully, bool);
 
    itkGetConstMacro(MessageQueue, mitk::IGTLMessageQueue::Pointer);
 
    itkGetMacro(MessageFactory, mitk::IGTLMessageFactory::Pointer);
 
    void ThreadStartSending();
 
    void ThreadStartReceiving();
 
    void ThreadStartConnecting();
 
    virtual bool TestConnection();
 
    bool SendRTSMessage(const char* type);
 
    void EnableNoBufferingMode(mitk::IGTLMessageQueue::Pointer queue,
      bool enable = true);
 
    void EnableNoBufferingMode(bool enable = true);
 
    virtual unsigned int GetNumberOfConnections() = 0;
 
    itkGetMacro(LogMessages, bool);
    itkSetMacro(LogMessages, bool);
 
  protected:
    unsigned int SendMessagePrivate(mitk::IGTLMessage::Pointer msg,
      igtl::Socket::Pointer socket);
 
    virtual void Receive() = 0;
 
    unsigned int ReceivePrivate(igtl::Socket* device);
 
    virtual void Send() = 0;
 
    virtual void Connect();
 
    virtual void StopCommunicationWithSocket(igtl::Socket* socket) = 0;
 
    void SetState(IGTLDeviceState state);
 
    IGTLDevice();
    ~IGTLDevice() override;
 
    IGTLDeviceState m_State;
    std::string m_Name;
 
    bool m_StopCommunication;
    std::mutex m_StopCommunicationMutex;
    std::mutex m_SendingFinishedMutex;
    std::mutex m_ReceivingFinishedMutex;
    std::mutex m_ConnectingFinishedMutex;
    mutable std::mutex m_StateMutex;
 
    std::string m_Hostname;
    int m_PortNumber;
    igtl::Socket::Pointer m_Socket;
 
    mitk::IGTLMessageQueue::Pointer m_MessageQueue;
 
    mitk::IGTLMessageFactory::Pointer m_MessageFactory;
 
    bool m_LogMessages;
 
  private:
 
    std::thread m_SendThread;
    std::thread m_ReceiveThread;
    std::thread m_ConnectThread;
    bool m_ReadFully;
  };
 
  itkEventMacroDeclaration(MessageSentEvent, itk::AnyEvent);
 
  itkEventMacroDeclaration(MessageReceivedEvent, itk::AnyEvent);
 
  itkEventMacroDeclaration(CommandReceivedEvent, itk::AnyEvent);
 
  itkEventMacroDeclaration(NewClientConnectionEvent, itk::AnyEvent);
 
  itkEventMacroDeclaration(LostConnectionEvent, itk::AnyEvent);
} // namespace mitk
 
#endif