vtkPlusOpenIGTLinkServer.h

Go to the documentation of this file.

/*=Plus=header=begin======================================================
  Program: Plus
  Copyright (c) Laboratory for Percutaneous Surgery. All rights reserved.
  See License.txt for details.
=========================================================Plus=header=end*/

#ifndef __VTKPLUSOPENIGTLINKSERVER_H
#define __VTKPLUSOPENIGTLINKSERVER_H

// Local includes
#include "vtkPlusServerExport.h"
#include "PlusIgtlClientInfo.h"
#include "vtkPlusDataCollector.h"
#include "vtkPlusIgtlMessageFactory.h"
#include "vtkIGSIOTransformRepository.h"

// VTK includes
#include <vtkMultiThreader.h>
#include <vtkObject.h>
#include <vtkSmartPointer.h>

// STL includes
#include <deque>

// OS includes
#if (_MSC_VER == 1500)
  #include <stdint.h>
#endif

// IGTL includes
#include <igtlMessageBase.h>
#include <igtlServerSocket.h>

//class igsioTrackedFrame; 
class vtkPlusDataCollector;
class vtkPlusOpenIGTLinkServer;
class vtkPlusChannel;
class vtkPlusCommandProcessor;
class vtkPlusCommandResponse;
class vtkIGSIORecursiveCriticalSection;
//class vtkIGSIOTransformRepository;

struct ClientData
{
  ClientData()
    : ClientId(-1)
    , ClientSocket(NULL)
    , DataReceiverActive(std::make_pair(false, false))
    , DataReceiverThreadId(-1)
    , Server(NULL)
  {
  }

  int ClientId;

  igtl::ClientSocket::Pointer ClientSocket;

  uint32_t ClientSocketSendTimeout;
  uint32_t ClientSocketReceiveTimeout;

  std::pair<bool, bool> DataReceiverActive;
  int DataReceiverThreadId;

  PlusIgtlClientInfo ClientInfo;

  vtkPlusOpenIGTLinkServer* Server;
};

class vtkPlusServerExport vtkPlusOpenIGTLinkServer: public vtkObject
{
  typedef std::map<int, std::vector<igtl::MessageBase::Pointer> > ClientIdToMessageListMap;

public:
  static vtkPlusOpenIGTLinkServer* New();
  vtkTypeMacro(vtkPlusOpenIGTLinkServer, vtkObject);
  virtual void PrintSelf(ostream& os, vtkIndent indent) VTK_OVERRIDE;

  PlusStatus Start(vtkPlusDataCollector* dataCollector, vtkIGSIOTransformRepository* transformRepository, vtkXMLDataElement* serverElement, const std::string& configFilePath);

  PlusStatus Stop();


  virtual PlusStatus ReadConfiguration(vtkXMLDataElement* serverElement, const std::string& aFilename);

  vtkSetMacro(ListeningPort, int);
  vtkGetMacroConst(ListeningPort, int);

  vtkGetStdStringMacro(OutputChannelId);

  vtkSetMacro(MissingInputGracePeriodSec, double);
  vtkGetMacroConst(MissingInputGracePeriodSec, double);

  vtkSetMacro(MaxTimeSpentWithProcessingMs, double);
  vtkGetMacroConst(MaxTimeSpentWithProcessingMs, double);

  vtkSetMacro(SendValidTransformsOnly, bool);
  vtkGetMacroConst(SendValidTransformsOnly, bool);

  vtkSetMacro(DefaultClientSendTimeoutSec, float);
  vtkGetMacroConst(DefaultClientSendTimeoutSec, float);

  vtkSetMacro(DefaultClientReceiveTimeoutSec, float);
  vtkGetMacroConst(DefaultClientReceiveTimeoutSec, float);

  vtkSetMacro(DataCollector, vtkPlusDataCollector*);
  vtkGetMacroConst(DataCollector, vtkPlusDataCollector*);

  vtkSetMacro(TransformRepository, vtkIGSIOTransformRepository*);
  vtkGetMacroConst(TransformRepository, vtkIGSIOTransformRepository*);

  virtual unsigned int GetNumberOfConnectedClients() const;

  virtual PlusStatus GetClientInfo(unsigned int clientId, PlusIgtlClientInfo& outClientInfo) const;

  PlusStatus StartOpenIGTLinkService();

  PlusStatus StopOpenIGTLinkService();

  vtkGetStdStringMacro(ConfigFilename);

  vtkGetMacro(IGTLProtocolVersion, int);
  vtkGetMacro(IGTLHeaderVersion, int);

  int ProcessPendingCommands();

protected:
  vtkPlusOpenIGTLinkServer();
  virtual ~vtkPlusOpenIGTLinkServer();

  PlusStatus QueueMessageResponseForClient(int clientId, igtl::MessageBase::Pointer message);

  static void* ConnectionReceiverThread(vtkMultiThreader::ThreadInfo* data);

  static void* DataSenderThread(vtkMultiThreader::ThreadInfo* data);

  static PlusStatus SendLatestFramesToClients(vtkPlusOpenIGTLinkServer& self, double& elapsedTimeSinceLastPacketSentSec);

  static PlusStatus SendMessageResponses(vtkPlusOpenIGTLinkServer& self);

  static PlusStatus SendCommandResponses(vtkPlusOpenIGTLinkServer& self);

  static void* DataReceiverThread(vtkMultiThreader::ThreadInfo* data);

  virtual PlusStatus SendTrackedFrame(igsioTrackedFrame& trackedFrame);

  igtl::MessageBase::Pointer CreateIgtlMessageFromCommandResponse(vtkPlusCommandResponse* response);

  virtual void KeepAlive();

  void DisconnectClient(int clientId);

  vtkSetMacro(IgtlMessageCrcCheckEnabled, bool);
  vtkGetMacroConst(IgtlMessageCrcCheckEnabled, bool);

  vtkSetMacro(LogWarningOnNoDataAvailable, bool);
  vtkGetMacroConst(LogWarningOnNoDataAvailable, bool);

  vtkSetMacro(MaxNumberOfIgtlMessagesToSend, int);
  vtkGetMacroConst(MaxNumberOfIgtlMessagesToSend, int);

  vtkSetMacro(NumberOfRetryAttempts, int);
  vtkGetMacroConst(NumberOfRetryAttempts, int);

  vtkSetMacro(DelayBetweenRetryAttemptsSec, double);
  vtkGetMacroConst(DelayBetweenRetryAttemptsSec, double);

  vtkSetMacro(KeepAliveIntervalSec, double);
  vtkGetMacroConst(KeepAliveIntervalSec, double);

  vtkSetStdStringMacro(OutputChannelId);
  vtkSetStdStringMacro(ConfigFilename);

  bool HasGracePeriodExpired();

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

  igtl::ServerSocket::Pointer ServerSocket;

  vtkSmartPointer<vtkIGSIOTransformRepository> TransformRepository;

  vtkSmartPointer<vtkPlusDataCollector> DataCollector;

  vtkSmartPointer<vtkMultiThreader> Threader;

  int IGTLProtocolVersion;
  int IGTLHeaderVersion;

  int ListeningPort;

  int NumberOfRetryAttempts;

  double DelayBetweenRetryAttemptsSec;

  int MaxNumberOfIgtlMessagesToSend;

  // Active flag for threads (request, respond )
  struct ThreadFlags
  {
    bool Request;
    bool Respond;
    ThreadFlags()
      : Request(false)
      , Respond(false)
    {}
  };
  ThreadFlags ConnectionActive;
  ThreadFlags DataSenderActive;

  // Thread IDs
  int ConnectionReceiverThreadId;
  int DataSenderThreadId;

  std::list<ClientData> IgtlClients;

  vtkSmartPointer<vtkPlusIgtlMessageFactory> IgtlMessageFactory;

  vtkSmartPointer<vtkIGSIORecursiveCriticalSection> IgtlClientsMutex;

  double LastSentTrackedFrameTimestamp;

  int MaxTimeSpentWithProcessingMs;

  int LastProcessingTimePerFrameMs;

  bool SendValidTransformsOnly;

  PlusIgtlClientInfo DefaultClientInfo;
  float DefaultClientSendTimeoutSec;
  float DefaultClientReceiveTimeoutSec;

  bool IgtlMessageCrcCheckEnabled;

  vtkSmartPointer<vtkPlusCommandProcessor> PlusCommandProcessor;

  ClientIdToMessageListMap MessageResponseQueue;

  vtkSmartPointer<vtkIGSIORecursiveCriticalSection> MessageResponseQueueMutex;

  std::string OutputChannelId;

  vtkPlusChannel* BroadcastChannel;

  bool LogWarningOnNoDataAvailable;

  double KeepAliveIntervalSec;

  std::string ConfigFilename;

  vtkPlusLogger::LogLevelType GracePeriodLogLevel;
  double MissingInputGracePeriodSec;
  double BroadcastStartTime;

  static int ClientIdCounter;

  static const float CLIENT_SOCKET_TIMEOUT_SEC;

  bool NewClientConnected;
};

#endif