mitkIGTLDevice.h

Go to the documentation of this file.

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

The Medical Imaging Interaction Toolkit (MITK)

Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.

This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.

See LICENSE.txt or http://www.mitk.org for details.

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

#ifndef MITKIGTLDEVICE_H
#define MITKIGTLDEVICE_H

#include "mitkCommon.h"

//itk
#include "itkObject.h"
#include "itkFastMutexLock.h"
#include "itkMultiThreader.h"

//igtl
#include "igtlSocket.h"
#include "igtlMessageBase.h"
#include "igtlTransformMessage.h"

//mitkIGTL
#include "MitkOpenIGTLinkExports.h"
#include "mitkIGTLMessageFactory.h"
#include "mitkIGTLMessageQueue.h"
#include "mitkIGTLMessage.h"

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), itk::FastMutexLock* mutex);

    void SendMessage(igtl::MessageBase::Pointer msg);

    void SendMessage(const IGTLMessage* 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);

    static ITK_THREAD_RETURN_TYPE ThreadStartSending(void* data);

    static ITK_THREAD_RETURN_TYPE ThreadStartReceiving(void* data);

    static ITK_THREAD_RETURN_TYPE ThreadStartConnecting(void* data);

    virtual bool TestConnection();

    bool SendRTSMessage(const char* type);

    void EnableInfiniteBufferingMode(mitk::IGTLMessageQueue::Pointer queue,
      bool enable = true);

    virtual unsigned int GetNumberOfConnections() = 0;

  protected:
    unsigned int SendMessagePrivate(igtl::MessageBase::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();
    virtual ~IGTLDevice();

    IGTLDeviceState m_State;
    std::string m_Name;

    bool m_StopCommunication;
    itk::FastMutexLock::Pointer m_StopCommunicationMutex;
    itk::FastMutexLock::Pointer m_SendingFinishedMutex;
    itk::FastMutexLock::Pointer m_ReceivingFinishedMutex;
    itk::FastMutexLock::Pointer m_ConnectingFinishedMutex;
    itk::FastMutexLock::Pointer m_StateMutex;

    std::string m_Hostname;
    int m_PortNumber;
    igtl::Socket::Pointer m_Socket;

    mitk::IGTLMessageQueue::Pointer m_MessageQueue;

    mitk::IGTLMessageFactory::Pointer m_MessageFactory;

  private:

    itk::MultiThreader::Pointer m_MultiThreader;
    int m_SendThreadID;
    int m_ReceiveThreadID;
    int m_ConnectThreadID;
    bool m_ReadFully;
  };

  itkEventMacro(MessageSentEvent, itk::AnyEvent);

  itkEventMacro(MessageReceivedEvent, itk::AnyEvent);

  itkEventMacro(CommandReceivedEvent, itk::AnyEvent);

  itkEventMacro(NewClientConnectionEvent, itk::AnyEvent);

  itkEventMacro(LostConnectionEvent, itk::AnyEvent);
} // namespace mitk

#endif /* MITKIGTLDEVICE_H */