diff --git a/Modules/IGT/TrackingDevices/mitkOpenIGTLinkTrackingDevice.cpp b/Modules/IGT/TrackingDevices/mitkOpenIGTLinkTrackingDevice.cpp
index f151611af5..58a17d315a 100644
--- a/Modules/IGT/TrackingDevices/mitkOpenIGTLinkTrackingDevice.cpp
+++ b/Modules/IGT/TrackingDevices/mitkOpenIGTLinkTrackingDevice.cpp
@@ -1,575 +1,575 @@
/*===================================================================
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.
===================================================================*/
#include "mitkOpenIGTLinkTrackingDevice.h"
#include "mitkOpenIGTLinkTrackingTool.h"
#include "mitkIGTConfig.h"
#include "mitkIGTTimeStamp.h"
#include "mitkIGTHardwareException.h"
#include "mitkTrackingTypes.h"
#include <itksys/SystemTools.hxx>
#include <iostream>
#include <itkMutexLockHolder.h>
#include <itkCommand.h>
#include <mitkOpenIGTLinkTypeInformation.h>
#include <vtkConeSource.h>
//sleep headers
#include <chrono>
#include <thread>
typedef itk::MutexLockHolder<itk::FastMutexLock> MutexLockHolder;
mitk::OpenIGTLinkTrackingDevice::OpenIGTLinkTrackingDevice() : mitk::TrackingDevice(), m_UpdateRate(60)
{
//set the type of this tracking device
this->m_Data = mitk::OpenIGTLinkTypeInformation::GetDeviceDataOpenIGTLinkTrackingDeviceConnection();
m_OpenIGTLinkClient = mitk::IGTLClient::New(true);
m_OpenIGTLinkClient->SetName("OpenIGTLink Tracking Device");
m_OpenIGTLinkClient->EnableInfiniteBufferingMode(false);
m_IGTLDeviceSource = mitk::IGTLTransformDeviceSource::New();
m_IGTLDeviceSource->SetIGTLDevice(m_OpenIGTLinkClient);
}
mitk::OpenIGTLinkTrackingDevice::~OpenIGTLinkTrackingDevice()
{
}
int mitk::OpenIGTLinkTrackingDevice::GetPortNumber()
{
return m_OpenIGTLinkClient->GetPortNumber();
}
bool mitk::OpenIGTLinkTrackingDevice::AutoDetectToolsAvailable()
{
return true;
}
mitk::NavigationToolStorage::Pointer mitk::OpenIGTLinkTrackingDevice::AutoDetectTools()
{
mitk::NavigationToolStorage::Pointer returnValue = mitk::NavigationToolStorage::New();
if (m_OpenIGTLinkClient->GetPortNumber() == -1)
{
MITK_WARN << "Connection not initialized, aborting (invalid port number).";
return mitk::NavigationToolStorage::New();
}
//open connection
try
{
m_IGTLDeviceSource->Connect();
m_IGTLDeviceSource->StartCommunication();
}
catch (std::runtime_error &e)
{
MITK_WARN << "AutoDetection: Open IGT Link device retruned an error while trying to connect: " << e.what();
return mitk::NavigationToolStorage::New();
}
//get a message to find out type
mitk::IGTLMessage::Pointer receivedMessage = ReceiveMessage(100);
const char* msgType = receivedMessage->GetIGTLMessageType();
mitk::OpenIGTLinkTrackingDevice::TrackingMessageType type = GetMessageTypeFromString(msgType);
switch (type)
{
case TDATA:
returnValue = DiscoverToolsFromTData(dynamic_cast<igtl::TrackingDataMessage*>(receivedMessage->GetMessage().GetPointer()));
break;
case QTDATA:
returnValue = DiscoverToolsFromQTData(dynamic_cast<igtl::QuaternionTrackingDataMessage*>(receivedMessage->GetMessage().GetPointer()));
break;
case TRANSFORM:
returnValue = DiscoverToolsFromTransform();
break;
default:
MITK_INFO << "Server does not send tracking data. Received data is not of a compatible type. Received type: " << msgType;
}
//close connection
try
{
m_IGTLDeviceSource->StopCommunication();
m_IGTLDeviceSource->Disconnect();
}
catch (std::runtime_error &e)
{
MITK_WARN << "AutoDetection: Open IGT Link device retruned an error while trying to disconnect: " << e.what();
return mitk::NavigationToolStorage::New();
}
return returnValue;
}
std::string mitk::OpenIGTLinkTrackingDevice::GetHostname()
{
return m_OpenIGTLinkClient->GetHostname();
}
void mitk::OpenIGTLinkTrackingDevice::SetPortNumber(int portNumber)
{
m_OpenIGTLinkClient->SetPortNumber(portNumber);
}
void mitk::OpenIGTLinkTrackingDevice::SetHostname(std::string hostname)
{
m_OpenIGTLinkClient->SetHostname(hostname);
}
bool mitk::OpenIGTLinkTrackingDevice::IsDeviceInstalled()
{
return true;
}
mitk::TrackingTool* mitk::OpenIGTLinkTrackingDevice::AddTool(const char* toolName, const char* fileName)
{
mitk::OpenIGTLinkTrackingTool::Pointer t;// = mitk::OpenIGTLinkTrackingTool::New();
//TODO: Implement
if (this->InternalAddTool(t) == false)
return NULL;
return t.GetPointer();
}
bool mitk::OpenIGTLinkTrackingDevice::InternalAddTool(OpenIGTLinkTrackingTool::Pointer tool)
{
m_AllTools.push_back(tool);
return true;
}
bool mitk::OpenIGTLinkTrackingDevice::DiscoverTools(int waitingTime)
{
if (m_OpenIGTLinkClient->GetPortNumber() == -1)
{
MITK_WARN << "Connection not initialized, aborting (invalid port number).";
return false;
}
try
{
m_IGTLDeviceSource->Connect();
m_IGTLDeviceSource->StartCommunication();
}
catch (std::runtime_error &e)
{
MITK_WARN << "Open IGT Link device retruned an error while trying to connect: " << e.what();
return false;
}
mitk::IGTLMessage::Pointer receivedMessage = ReceiveMessage(waitingTime);
//check the tracking stream for the number and type of tools
//igtl::MessageBase::Pointer receivedMessage = m_OpenIGTLinkClient->GetNextMessage();
if (receivedMessage.IsNull())
{
MITK_WARN << "No message was received. Is there really a server?";
return false;
}
else if (!receivedMessage->IsDataValid())
{
MITK_WARN << "Received invalid message.";
return false;
}
const char* msgType = receivedMessage->GetIGTLMessageType();
mitk::OpenIGTLinkTrackingDevice::TrackingMessageType type = GetMessageTypeFromString(msgType);
mitk::NavigationToolStorage::Pointer foundTools;
switch (type)
{
case TDATA:
foundTools = DiscoverToolsFromTData(dynamic_cast<igtl::TrackingDataMessage*>(receivedMessage->GetMessage().GetPointer()));
break;
case QTDATA:
foundTools = DiscoverToolsFromQTData(dynamic_cast<igtl::QuaternionTrackingDataMessage*>(receivedMessage->GetMessage().GetPointer()));
break;
case TRANSFORM:
foundTools = DiscoverToolsFromTransform();
break;
default:
MITK_INFO << "Server does not send tracking data. Received data is not of a compatible type. Received type: " << msgType;
return false;
}
if (foundTools.IsNull() || (foundTools->GetToolCount() == 0)) { return false; }
for (int i = 0; i < foundTools->GetToolCount(); i++) { AddNewToolForName(foundTools->GetTool(i)->GetToolName(), i); }
MITK_INFO << "Found tools: " << foundTools->GetToolCount();
return true;
}
mitk::IGTLMessage::Pointer mitk::OpenIGTLinkTrackingDevice::ReceiveMessage(int waitingTime)
{
mitk::IGTLMessage::Pointer receivedMessage;
//send a message to the server: start tracking stream
mitk::IGTLMessageFactory::Pointer msgFactory = m_OpenIGTLinkClient->GetMessageFactory();
std::string message = "STT_TDATA";
igtl::MessageBase::Pointer sttMsg = msgFactory->CreateInstance(message);
//TODO: Fix this to dynamically get this from GUI
((igtl::StartTrackingDataMessage*)sttMsg.GetPointer())->SetResolution(m_UpdateRate);
m_OpenIGTLinkClient->SendMessage(sttMsg);
std::chrono::high_resolution_clock::time_point time = std::chrono::high_resolution_clock::now();
std::chrono::milliseconds d = std::chrono::milliseconds(waitingTime);
while (!(receivedMessage.IsNotNull() && receivedMessage->IsDataValid()))
{
m_IGTLDeviceSource->Update();
receivedMessage = m_IGTLDeviceSource->GetOutput();
if ((time + d) < std::chrono::high_resolution_clock::now())
break;
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
return receivedMessage;
}
mitk::NavigationToolStorage::Pointer mitk::OpenIGTLinkTrackingDevice::DiscoverToolsFromTData(igtl::TrackingDataMessage::Pointer tdMsg)
{
mitk::NavigationToolStorage::Pointer returnValue = mitk::NavigationToolStorage::New();
MITK_INFO << "Start discovering tools by TDATA messages";
if (tdMsg == nullptr)
{
MITK_WARN << "Message was not a TrackingDataMessage, aborting!";
return returnValue;
}
int numberOfTools = tdMsg->GetNumberOfTrackingDataElements();
MITK_INFO << "Found " << numberOfTools << " tools";
for (int i = 0; i < numberOfTools; i++)
{
igtl::TrackingDataElement::Pointer currentTrackingData;
tdMsg->GetTrackingDataElement(i, currentTrackingData);
std::string name = currentTrackingData->GetName();
std::stringstream identifier;
identifier << "AutoDetectedTool-" << i;
i++;
mitk::NavigationTool::Pointer newTool = ConstructDefaultOpenIGTLinkTool(name, identifier.str());
returnValue->AddTool(newTool);
}
m_IGTLDeviceSource->StopCommunication();
SetState(Ready);
return returnValue;
}
mitk::NavigationToolStorage::Pointer mitk::OpenIGTLinkTrackingDevice::DiscoverToolsFromQTData(igtl::QuaternionTrackingDataMessage::Pointer msg)
{
mitk::NavigationToolStorage::Pointer returnValue = mitk::NavigationToolStorage::New();
MITK_INFO << "Start discovering tools by QTDATA messages";
if (msg == nullptr)
{
MITK_WARN << "Message was not a QuaternionTrackingDataMessage, aborting!";
return returnValue;
}
int numberOfTools = msg->GetNumberOfQuaternionTrackingDataElements();
MITK_INFO << "Found " << numberOfTools << " tools";
for (int i = 0; i < numberOfTools; i++)
{
igtl::QuaternionTrackingDataElement::Pointer currentTrackingData;
msg->GetQuaternionTrackingDataElement(i, currentTrackingData);
std::string name = currentTrackingData->GetName();
std::stringstream identifier;
identifier << "AutoDetectedTool-" << i;
i++;
mitk::NavigationTool::Pointer newTool = ConstructDefaultOpenIGTLinkTool(name, identifier.str());
returnValue->AddTool(newTool);
}
m_IGTLDeviceSource->StopCommunication();
SetState(Ready);
return returnValue;
}
void mitk::OpenIGTLinkTrackingDevice::AddNewToolForName(std::string name, int i)
{
mitk::OpenIGTLinkTrackingTool::Pointer newTool = mitk::OpenIGTLinkTrackingTool::New();
if (name == "") //if no name was given create a default name
{
std::stringstream defaultName;
defaultName << "OpenIGTLinkTool#" << i;
name = defaultName.str();
}
MITK_INFO << "Added tool " << name << " to tracking device.";
newTool->SetToolName(name);
InternalAddTool(newTool);
}
mitk::NavigationToolStorage::Pointer mitk::OpenIGTLinkTrackingDevice::DiscoverToolsFromTransform(int NumberOfMessagesToWait)
{
MITK_INFO << "Start discovering tools by TRANSFORM messages";
mitk::NavigationToolStorage::Pointer returnValue = mitk::NavigationToolStorage::New();
std::map<std::string, int> toolNameMap;
for (int j=0; j<NumberOfMessagesToWait; j++)
{
std::this_thread::sleep_for(std::chrono::milliseconds(20));
m_IGTLDeviceSource->Update();
igtl::TransformMessage::Pointer msg = dynamic_cast<igtl::TransformMessage*>(m_IGTLDeviceSource->GetOutput()->GetMessage().GetPointer());
if (msg == nullptr || msg.IsNull())
{
MITK_INFO << "Received message could not be casted to TransformMessage. Skipping..";
continue;
}
int count = toolNameMap[msg->GetDeviceName()];
if (count == 0)
{
//MITK_WARN << "ADDED NEW TOOL TO TOOLCHAIN: " << msg->GetDeviceName() << " - 1";
toolNameMap[msg->GetDeviceName()] = 1;
}
else
{
toolNameMap[msg->GetDeviceName()]++;
//MITK_WARN << "INCREMENTED TOOL COUNT IN TOOLCHAIN: " << msg->GetDeviceName() << " - " << toolNameMap[msg->GetDeviceName()];
}
}
int i = 0;
for (std::map<std::string, int>::iterator it = toolNameMap.begin(); it != toolNameMap.end(); ++it)
{
MITK_INFO << "Found tool: " << it->first;
std::stringstream name;
name << it->first;
std::stringstream identifier;
identifier << "AutoDetectedTool-" << i;
i++;
mitk::NavigationTool::Pointer newTool = ConstructDefaultOpenIGTLinkTool(name.str(), identifier.str());
returnValue->AddTool(newTool);
}
return returnValue;
}
mitk::NavigationTool::Pointer mitk::OpenIGTLinkTrackingDevice::ConstructDefaultOpenIGTLinkTool(std::string name, std::string identifier)
{
mitk::DataNode::Pointer newNode = mitk::DataNode::New();
newNode->SetName(name);
mitk::Surface::Pointer myCone = mitk::Surface::New();
vtkConeSource *vtkData = vtkConeSource::New();
vtkData->SetAngle(5.0);
vtkData->SetResolution(50);
vtkData->SetHeight(6.0f);
vtkData->SetRadius(2.0f);
vtkData->SetCenter(0.0, 0.0, 0.0);
vtkData->Update();
myCone->SetVtkPolyData(vtkData->GetOutput());
vtkData->Delete();
newNode->SetData(myCone);
mitk::NavigationTool::Pointer newTool = mitk::NavigationTool::New();
newTool->SetDataNode(newNode);
newTool->SetIdentifier(identifier);
newTool->SetTrackingDeviceType(mitk::OpenIGTLinkTypeInformation::GetDeviceDataOpenIGTLinkTrackingDeviceConnection().Line);
return newTool;
}
void mitk::OpenIGTLinkTrackingDevice::UpdateTools()
{
if (this->GetState() != Tracking)
{
MITK_ERROR << "Method was called in the wrong state, something went wrong!";
return;
}
m_IGTLMsgToNavDataFilter->Update();
mitk::NavigationData::Pointer currentNavData = m_IGTLMsgToNavDataFilter->GetOutput();
const char* name = currentNavData->GetName();
//MITK_WARN << name;
for (int i = 0; i < m_AllTools.size(); i++)
{
if (strcmp(m_AllTools.at(i)->GetToolName(), name) == 0)
{
m_AllTools.at(i)->SetDataValid(currentNavData->IsDataValid());
m_AllTools.at(i)->SetPosition(currentNavData->GetPosition());
m_AllTools.at(i)->SetOrientation(currentNavData->GetOrientation());
m_AllTools.at(i)->SetIGTTimeStamp(currentNavData->GetIGTTimeStamp());
}
}
}
bool mitk::OpenIGTLinkTrackingDevice::StartTracking()
{
//check tracking state
if (this->GetState() != Ready)
{
MITK_WARN << "Cannot start tracking, device is not ready!";
return false;
}
try
{
m_IGTLDeviceSource->StartCommunication();
//send a message to the server: start tracking stream
mitk::IGTLMessageFactory::Pointer msgFactory = m_OpenIGTLinkClient->GetMessageFactory();
std::string message = "STT_TDATA";
//m_OpenIGTLinkClient->SendMessage(msgFactory->CreateInstance(message));
}
catch (std::runtime_error &e)
{
MITK_WARN << "Open IGT Link device retruned an error while starting communication: " << e.what();
return false;
}
//create internal igtl pipeline
m_IGTLMsgToNavDataFilter = mitk::IGTLMessageToNavigationDataFilter::New();
m_IGTLMsgToNavDataFilter->SetNumberOfExpectedOutputs(this->GetToolCount());
m_IGTLMsgToNavDataFilter->ConnectTo(m_IGTLDeviceSource);
//connect itk events
typedef itk::SimpleMemberCommand< mitk::OpenIGTLinkTrackingDevice > CurCommandType;
CurCommandType::Pointer messageReceivedCommand = CurCommandType::New();
messageReceivedCommand->SetCallbackFunction(this, &mitk::OpenIGTLinkTrackingDevice::UpdateTools);
m_MessageReceivedObserverTag = m_OpenIGTLinkClient->AddObserver(mitk::MessageReceivedEvent(), messageReceivedCommand);
this->SetState(Tracking);
return true;
}
bool mitk::OpenIGTLinkTrackingDevice::StopTracking()
{
//check tracking state
if (this->GetState() != Tracking)
{
MITK_WARN << "Cannot open connection, device is already connected!";
return false;
}
m_OpenIGTLinkClient->RemoveObserver(m_MessageReceivedObserverTag); //disconnect itk events
try
{
m_IGTLDeviceSource->StopCommunication();
}
catch (std::runtime_error &e)
{
MITK_WARN << "Open IGT Link device retruned an error while stopping communication: " << e.what();
return false;
}
this->SetState(Ready);
return true;
}
unsigned int mitk::OpenIGTLinkTrackingDevice::GetToolCount() const
{
return (unsigned int)this->m_AllTools.size();
}
mitk::TrackingTool* mitk::OpenIGTLinkTrackingDevice::GetTool(unsigned int toolNumber) const
{
if (toolNumber >= this->GetToolCount())
return NULL;
else
return this->m_AllTools[toolNumber];
}
bool mitk::OpenIGTLinkTrackingDevice::OpenConnection()
{
//check tracking state
if (this->GetState() != Setup)
{
MITK_WARN << "Cannot open connection, device is already connected!";
return false;
}
try
{
m_IGTLDeviceSource->Connect();
}
catch (std::runtime_error &e)
{
MITK_WARN << "Open IGT Link device retruned an error while trying to connect: " << e.what();
return false;
}
this->SetState(Ready);
return true;
}
bool mitk::OpenIGTLinkTrackingDevice::CloseConnection()
{
//check tracking state
if (this->GetState() != Ready)
{
MITK_WARN << "Cannot close connection, device is in the wrong state!";
return false;
}
try
{
m_IGTLDeviceSource->Disconnect();
}
catch (std::runtime_error &e)
{
MITK_WARN << "Open IGT Link device retruned an error while trying to disconnect: " << e.what();
return false;
}
this->SetState(Setup);
return true;
}
std::vector<mitk::OpenIGTLinkTrackingTool::Pointer> mitk::OpenIGTLinkTrackingDevice::GetAllTools()
{
return this->m_AllTools;
}
mitk::OpenIGTLinkTrackingDevice::TrackingMessageType mitk::OpenIGTLinkTrackingDevice::GetMessageTypeFromString(const char* messageTypeString)
{
if (strcmp(messageTypeString, "TDATA") == 0)
{
return mitk::OpenIGTLinkTrackingDevice::TrackingMessageType::TDATA;
}
else if (strcmp(messageTypeString, "QTDATA") == 0)
{
return mitk::OpenIGTLinkTrackingDevice::TrackingMessageType::QTDATA;
}
else if (strcmp(messageTypeString, "TRANSFORM") == 0)
{
return mitk::OpenIGTLinkTrackingDevice::TrackingMessageType::TRANSFORM;
}
else
{
return mitk::OpenIGTLinkTrackingDevice::TrackingMessageType::UNKNOWN;
}
-}
\ No newline at end of file
+}
diff --git a/Modules/OpenIGTLink/DeviceSources/mitkIGTL2DImageDeviceSource.cpp b/Modules/OpenIGTLink/DeviceSources/mitkIGTL2DImageDeviceSource.cpp
index 509992e296..2883114c31 100644
--- a/Modules/OpenIGTLink/DeviceSources/mitkIGTL2DImageDeviceSource.cpp
+++ b/Modules/OpenIGTLink/DeviceSources/mitkIGTL2DImageDeviceSource.cpp
@@ -1,58 +1,55 @@
/*===================================================================
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.
===================================================================*/
#include "mitkIGTL2DImageDeviceSource.h"
#include "mitkIGTLMessage.h"
//Microservices
#include <usGetModuleContext.h>
#include <usModule.h>
#include <usServiceProperties.h>
#include <usModuleContext.h>
//itk
#include <itkCommand.h>
mitk::IGTL2DImageDeviceSource::IGTL2DImageDeviceSource()
: mitk::IGTLDeviceSource()
{
this->SetName("IGTLDeviceSource (2D Images)");
}
mitk::IGTL2DImageDeviceSource::~IGTL2DImageDeviceSource()
{
}
void mitk::IGTL2DImageDeviceSource::GenerateData()
{
if (m_IGTLDevice.IsNull())
return;
/* update output with message from the device */
IGTLMessage* msgOut = this->GetOutput();
assert(msgOut);
igtl::MessageBase::Pointer msgIn = dynamic_cast<igtl::MessageBase*>(m_IGTLDevice->GetNextImage2dMessage().GetPointer());
if (msgIn.IsNotNull())
{
assert(msgIn);
-
- MITK_INFO << "Received valid image";
-
msgOut->SetMessage(msgIn);
msgOut->SetName(msgIn->GetDeviceName());
}
}
diff --git a/Modules/OpenIGTLink/DeviceSources/mitkIGTLTransformDeviceSource.cpp b/Modules/OpenIGTLink/DeviceSources/mitkIGTLTransformDeviceSource.cpp
index 25e4699a6d..26483d2f4c 100644
--- a/Modules/OpenIGTLink/DeviceSources/mitkIGTLTransformDeviceSource.cpp
+++ b/Modules/OpenIGTLink/DeviceSources/mitkIGTLTransformDeviceSource.cpp
@@ -1,58 +1,55 @@
/*===================================================================
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.
===================================================================*/
#include "mitkIGTLTransformDeviceSource.h"
#include "mitkIGTLMessage.h"
//Microservices
#include <usGetModuleContext.h>
#include <usModule.h>
#include <usServiceProperties.h>
#include <usModuleContext.h>
//itk
#include <itkCommand.h>
mitk::IGTLTransformDeviceSource::IGTLTransformDeviceSource()
: mitk::IGTLDeviceSource()
{
this->SetName("IGTLDeviceSource (Transforms)");
}
mitk::IGTLTransformDeviceSource::~IGTLTransformDeviceSource()
{
}
void mitk::IGTLTransformDeviceSource::GenerateData()
{
if (m_IGTLDevice.IsNull())
return;
/* update output with message from the device */
IGTLMessage* msgOut = this->GetOutput();
assert(msgOut);
igtl::MessageBase::Pointer msgIn = dynamic_cast<igtl::MessageBase*>(m_IGTLDevice->GetNextTransformMessage().GetPointer());
if (msgIn.IsNotNull())
{
assert(msgIn);
-
- //MITK_INFO << "Received valid image";
-
msgOut->SetMessage(msgIn);
msgOut->SetName(msgIn->GetDeviceName());
}
}
diff --git a/Modules/OpenIGTLink/Filters/mitkImageToIGTLMessageFilter.cpp b/Modules/OpenIGTLink/Filters/mitkImageToIGTLMessageFilter.cpp
index 0e88cf7d2a..81042c43ff 100644
--- a/Modules/OpenIGTLink/Filters/mitkImageToIGTLMessageFilter.cpp
+++ b/Modules/OpenIGTLink/Filters/mitkImageToIGTLMessageFilter.cpp
@@ -1,259 +1,257 @@
/*===================================================================
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.
===================================================================*/
#include "mitkImageToIGTLMessageFilter.h"
#include "mitkImageReadAccessor.h"
#include "itkByteSwapper.h"
#include "igtlImageMessage.h"
mitk::ImageToIGTLMessageFilter::ImageToIGTLMessageFilter()
{
mitk::IGTLMessage::Pointer output = mitk::IGTLMessage::New();
this->SetNumberOfRequiredOutputs(1);
this->SetNthOutput(0, output.GetPointer());
this->SetNumberOfRequiredInputs(1);
}
void mitk::ImageToIGTLMessageFilter::GenerateData()
{
// MITK_INFO << "ImageToIGTLMessageFilter.GenerateData()";
for (unsigned int i = 0; i < this->GetNumberOfIndexedOutputs(); ++i)
{
mitk::IGTLMessage* output = this->GetOutput(i);
assert(output);
const mitk::Image* img = this->GetInput(i);
int dims = img->GetDimension();
int chn = img->GetNumberOfChannels();
- MITK_INFO << "Sending image. Dimensions: " << dims << " Channels: " << chn << "\n";
-
if (dims < 1)
{
MITK_ERROR << "Can not handle dimensionless images";
}
if (dims > 3)
{
MITK_ERROR << "Can not handle more than three dimensions";
continue;
}
if (chn != 1)
{
MITK_ERROR << "Can not handle anything but one channel. Image contained " << chn;
continue;
}
igtl::ImageMessage::Pointer imgMsg = igtl::ImageMessage::New();
// TODO: Which kind of coordinate system does MITK really use?
imgMsg->SetCoordinateSystem(igtl::ImageMessage::COORDINATE_RAS);
// We could do this based on the host endiannes, but that's weird.
// We instead use little endian, as most modern systems are little endian,
// so there will probably not be an endian swap involved.
imgMsg->SetEndian(igtl::ImageMessage::ENDIAN_LITTLE);
// Set number of components.
mitk::PixelType type = img->GetPixelType();
imgMsg->SetNumComponents(type.GetNumberOfComponents());
// Set scalar type.
switch (type.GetComponentType())
{
case itk::ImageIOBase::CHAR:
imgMsg->SetScalarTypeToInt8();
break;
case itk::ImageIOBase::UCHAR:
imgMsg->SetScalarTypeToUint8();
break;
case itk::ImageIOBase::SHORT:
imgMsg->SetScalarTypeToInt16();
break;
case itk::ImageIOBase::USHORT:
imgMsg->SetScalarTypeToUint16();
break;
case itk::ImageIOBase::INT:
imgMsg->SetScalarTypeToInt32();
break;
case itk::ImageIOBase::UINT:
imgMsg->SetScalarTypeToUint32();
break;
case itk::ImageIOBase::LONG:
// OIGTL doesn't formally support 64bit int scalars, but if they are
// ever added,
// they will have the identifier 8 assigned.
imgMsg->SetScalarType(8);
break;
case itk::ImageIOBase::ULONG:
// OIGTL doesn't formally support 64bit uint scalars, but if they are
// ever added,
// they will have the identifier 9 assigned.
imgMsg->SetScalarType(9);
break;
case itk::ImageIOBase::FLOAT:
// The igtl library has no method for this. Correct type is 10.
imgMsg->SetScalarType(10);
break;
case itk::ImageIOBase::DOUBLE:
// The igtl library has no method for this. Correct type is 11.
imgMsg->SetScalarType(11);
break;
default:
MITK_ERROR << "Can not handle pixel component type "
<< type.GetComponentType();
return;
}
// Set transformation matrix.
vtkMatrix4x4* matrix = img->GetGeometry()->GetVtkMatrix();
float matF[4][4];
for (size_t i = 0; i < 4; ++i)
{
for (size_t j = 0; j < 4; ++j)
{
matF[i][j] = matrix->GetElement(i, j);
}
}
imgMsg->SetMatrix(matF);
float spacing[3];
auto spacingImg = img->GetGeometry()->GetSpacing();
for (int i = 0; i < 3; ++i)
spacing[i] = spacingImg[i];
imgMsg->SetSpacing(spacing);
// Set dimensions.
int sizes[3];
for (size_t j = 0; j < 3; ++j)
{
sizes[j] = img->GetDimension(j);
}
imgMsg->SetDimensions(sizes);
// Allocate and copy data.
imgMsg->AllocatePack();
imgMsg->AllocateScalars();
size_t num_pixel = sizes[0] * sizes[1] * sizes[2];
void* out = imgMsg->GetScalarPointer();
{
// Scoped, so that readAccess will be released ASAP.
mitk::ImageReadAccessor readAccess(img, img->GetChannelData(0));
const void* in = readAccess.GetData();
memcpy(out, in, num_pixel * type.GetSize());
}
// We want to byte swap to little endian. We would like to just
// swap by number of bytes for each component, but itk::ByteSwapper
// is templated over element type, not over element size. So we need to
// switch on the size and use types of the same size.
size_t num_scalars = num_pixel * type.GetNumberOfComponents();
switch (type.GetComponentType())
{
case itk::ImageIOBase::CHAR:
case itk::ImageIOBase::UCHAR:
// No endian conversion necessary, because a char is exactly one byte!
break;
case itk::ImageIOBase::SHORT:
case itk::ImageIOBase::USHORT:
itk::ByteSwapper<short>::SwapRangeFromSystemToLittleEndian((short*)out,
num_scalars);
break;
case itk::ImageIOBase::INT:
case itk::ImageIOBase::UINT:
itk::ByteSwapper<int>::SwapRangeFromSystemToLittleEndian((int*)out,
num_scalars);
break;
case itk::ImageIOBase::LONG:
case itk::ImageIOBase::ULONG:
itk::ByteSwapper<long>::SwapRangeFromSystemToLittleEndian((long*)out,
num_scalars);
break;
case itk::ImageIOBase::FLOAT:
itk::ByteSwapper<float>::SwapRangeFromSystemToLittleEndian((float*)out,
num_scalars);
break;
case itk::ImageIOBase::DOUBLE:
itk::ByteSwapper<double>::SwapRangeFromSystemToLittleEndian(
(double*)out, num_scalars);
break;
}
imgMsg->Pack();
output->SetMessage(imgMsg.GetPointer());
}
}
void mitk::ImageToIGTLMessageFilter::SetInput(const mitk::Image* img)
{
this->ProcessObject::SetNthInput(0, const_cast<mitk::Image*>(img));
this->CreateOutputsForAllInputs();
}
void mitk::ImageToIGTLMessageFilter::SetInput(unsigned int idx,
const Image* img)
{
this->ProcessObject::SetNthInput(idx, const_cast<mitk::Image*>(img));
this->CreateOutputsForAllInputs();
}
const mitk::Image* mitk::ImageToIGTLMessageFilter::GetInput(void)
{
if (this->GetNumberOfInputs() < 1)
return NULL;
return static_cast<const mitk::Image*>(this->ProcessObject::GetInput(0));
}
const mitk::Image* mitk::ImageToIGTLMessageFilter::GetInput(unsigned int idx)
{
if (this->GetNumberOfInputs() < idx + 1)
{
return NULL;
}
return static_cast<const mitk::Image*>(this->ProcessObject::GetInput(idx));
}
void mitk::ImageToIGTLMessageFilter::ConnectTo(mitk::ImageSource* upstream)
{
MITK_INFO << "Image source for this (" << this << ") mitkImageToIGTLMessageFilter is " << upstream;
for (DataObjectPointerArraySizeType i = 0; i < upstream->GetNumberOfOutputs();
i++)
{
this->SetInput(i, upstream->GetOutput(i));
}
}
void mitk::ImageToIGTLMessageFilter::CreateOutputsForAllInputs()
{
// create one message output for all image inputs
this->SetNumberOfIndexedOutputs(this->GetNumberOfIndexedInputs());
for (size_t idx = 0; idx < this->GetNumberOfIndexedOutputs(); ++idx)
{
if (this->GetOutput(idx) == NULL)
{
this->SetNthOutput(idx, this->MakeOutput(idx));
}
this->Modified();
}
-}
\ No newline at end of file
+}
diff --git a/Modules/OpenIGTLink/Testing/mitkOpenIGTLinkClientServerTest.cpp b/Modules/OpenIGTLink/Testing/mitkOpenIGTLinkClientServerTest.cpp
index 75c190525c..49d5f89f47 100644
--- a/Modules/OpenIGTLink/Testing/mitkOpenIGTLinkClientServerTest.cpp
+++ b/Modules/OpenIGTLink/Testing/mitkOpenIGTLinkClientServerTest.cpp
@@ -1,260 +1,260 @@
/*===================================================================
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.
===================================================================*/
//TEST
#include <mitkTestingMacros.h>
#include <mitkTestFixture.h>
//STD
#include <thread>
#include <chrono>
//MITK
#include "mitkIGTLServer.h"
#include "mitkIGTLClient.h"
#include "mitkIGTLMessageFactory.h"
//IGTL
#include "igtlStatusMessage.h"
#include "igtlClientSocket.h"
#include "igtlServerSocket.h"
static int PORT = 35352;
static const std::string HOSTNAME = "localhost";
static const std::string SERVER_DEVICE_NAME = "Test Server";
static const std::string CLIENT_ONE_DEVICE_NAME = "Test Client 1";
static const std::string CLIENT_TWO_DEVICE_NAME = "Test Client 2";
class mitkOpenIGTLinkClientServerTestSuite : public mitk::TestFixture
{
CPPUNIT_TEST_SUITE(mitkOpenIGTLinkClientServerTestSuite);
//MITK_TEST(Test_JustIGTLImpl_OpenAndCloseAndThenReopenAndCloseServer_Successful);
//MITK_TEST(Test_ConnectingOneClientAndOneServer_Successful);
//MITK_TEST(Test_ConnectingMultipleClientsToOneServer_Successful);
#ifdef _WIN32 //does only work under windows, see bug 19633
MITK_TEST(Test_DisconnectionServerFirst_Successful);
#endif
//MITK_TEST(Test_SendingMessageFromServerToOneClient_Successful);
//MITK_TEST(Test_SendingMessageFromServerToMultipleClients_Successful);
CPPUNIT_TEST_SUITE_END();
private:
std::string m_Message;
mitk::IGTLServer::Pointer m_Server;
mitk::IGTLClient::Pointer m_Client_One;
mitk::IGTLClient::Pointer m_Client_Two;
mitk::IGTLMessageFactory::Pointer m_MessageFactory;
public:
void setUp() override
{
std::this_thread::sleep_for(std::chrono::milliseconds(20));
m_Message = "This is a test status message";
m_MessageFactory = mitk::IGTLMessageFactory::New();
m_Server = mitk::IGTLServer::New(true);
m_Client_One = mitk::IGTLClient::New(true);
m_Client_Two = mitk::IGTLClient::New(true);
m_Server->SetObjectName(SERVER_DEVICE_NAME);
m_Server->SetHostname(HOSTNAME);
m_Server->SetName(SERVER_DEVICE_NAME);
m_Server->SetPortNumber(PORT);
m_Client_One->SetObjectName(CLIENT_ONE_DEVICE_NAME);
m_Client_One->SetHostname(HOSTNAME);
m_Client_One->SetName(CLIENT_ONE_DEVICE_NAME);
m_Client_One->SetPortNumber(PORT);
m_Client_Two->SetObjectName(CLIENT_TWO_DEVICE_NAME);
m_Client_Two->SetHostname(HOSTNAME);
m_Client_Two->SetName(CLIENT_TWO_DEVICE_NAME);
m_Client_Two->SetPortNumber(PORT);
}
void tearDown() override
{
std::this_thread::sleep_for(std::chrono::milliseconds(20));
m_Message.clear();
m_Server = nullptr;
m_Client_One = nullptr;
m_Client_Two = nullptr;
m_MessageFactory = nullptr;
}
void testMessagesEqual(igtl::MessageBase::Pointer sentMessage, igtl::MessageBase::Pointer receivedMessage)
{
std::string lhs(sentMessage->GetDeviceName());
std::string rhs(receivedMessage->GetDeviceName());
CPPUNIT_ASSERT_MESSAGE("The device names were not the same", lhs == rhs);
igtl::StatusMessage::Pointer receivedStatusMessage = dynamic_cast<igtl::StatusMessage*>(receivedMessage.GetPointer());
igtl::StatusMessage::Pointer sentStatusMessage = dynamic_cast<igtl::StatusMessage*>(sentMessage.GetPointer());
CPPUNIT_ASSERT_MESSAGE("The received message was not of the appropriate type.", receivedStatusMessage != nullptr);
CPPUNIT_ASSERT_MESSAGE("The sent message was not of the appropriate type.", sentStatusMessage != nullptr);
lhs = receivedStatusMessage->GetStatusString();
rhs = sentStatusMessage->GetStatusString();
CPPUNIT_ASSERT_MESSAGE("The sent and received message did not contain the same status message.", lhs == rhs);
CPPUNIT_ASSERT_MESSAGE("The sent message did not contain the correct status message.", lhs == m_Message);
CPPUNIT_ASSERT_MESSAGE("The received message did not contain the correct status message.", m_Message == rhs);
};
void Test_JustIGTLImpl_OpenAndCloseAndThenReopenAndCloseServer_Successful()
{
igtl::ServerSocket::Pointer server = igtl::ServerSocket::New();
igtl::ClientSocket::Pointer client = igtl::ClientSocket::New();
CPPUNIT_ASSERT(server->CreateServer(PORT) == 0);
CPPUNIT_ASSERT(client->ConnectToServer("localhost", PORT) == 0);
client->CloseSocket();
server->CloseSocket();
CPPUNIT_ASSERT(server->CreateServer(PORT) == 0);
CPPUNIT_ASSERT(client->ConnectToServer("localhost", PORT) == 0);
client->CloseSocket();
server->CloseSocket();
server = nullptr;
client = nullptr;
}
void Test_ConnectingOneClientAndOneServer_Successful()
{
CPPUNIT_ASSERT_MESSAGE("Could not open Connection with Server", m_Server->OpenConnection());
CPPUNIT_ASSERT_MESSAGE("Could not connect to Server with first client", m_Client_One->OpenConnection());
CPPUNIT_ASSERT(m_Client_One->CloseConnection());
CPPUNIT_ASSERT(m_Server->CloseConnection());
}
void Test_ConnectingMultipleClientsToOneServer_Successful()
{
CPPUNIT_ASSERT_MESSAGE("Could not open Connection with Server", m_Server->OpenConnection());
m_Server->StartCommunication();
CPPUNIT_ASSERT_MESSAGE("Could not connect to Server with first client", m_Client_One->OpenConnection());
CPPUNIT_ASSERT_MESSAGE("Could not start communication with first client", m_Client_One->StartCommunication());
CPPUNIT_ASSERT_MESSAGE("Could not connect to Server with second client", m_Client_Two->OpenConnection());
CPPUNIT_ASSERT_MESSAGE("Could not start communication with second client", m_Client_Two->StartCommunication());
CPPUNIT_ASSERT(m_Client_One->CloseConnection());
CPPUNIT_ASSERT(m_Client_Two->CloseConnection());
CPPUNIT_ASSERT(m_Server->CloseConnection());
}
void Test_DisconnectionServerFirst_Successful()
{
CPPUNIT_ASSERT_MESSAGE("Could not open Connection with Server", m_Server->OpenConnection());
m_Server->StartCommunication();
CPPUNIT_ASSERT_MESSAGE("Could not connect to Server with first client", m_Client_One->OpenConnection());
CPPUNIT_ASSERT_MESSAGE("Could not start communication with first client", m_Client_One->StartCommunication());
CPPUNIT_ASSERT_MESSAGE("Could not connect to Server with second client", m_Client_Two->OpenConnection());
CPPUNIT_ASSERT_MESSAGE("Could not start communication with second client", m_Client_Two->StartCommunication());
std::this_thread::sleep_for(std::chrono::milliseconds(200));
CPPUNIT_ASSERT(m_Server->CloseConnection());
CPPUNIT_ASSERT(m_Client_One->CloseConnection());
CPPUNIT_ASSERT(m_Client_Two->CloseConnection());
}
void Test_SendingMessageFromServerToOneClient_Successful()
{
CPPUNIT_ASSERT_MESSAGE("Server not connected to Client.", m_Server->OpenConnection());
CPPUNIT_ASSERT_MESSAGE("Client 1 not connected to Server.", m_Client_One->OpenConnection());
m_Server->StartCommunication();
m_Client_One->StartCommunication();
igtl::MessageBase::Pointer sentMessage = m_MessageFactory->CreateInstance("STATUS");
dynamic_cast<igtl::StatusMessage*>(sentMessage.GetPointer())->SetStatusString(m_Message.c_str());
- m_Server->SendMessage(sentMessage);
+ m_Server->SendMessage(mitk::IGTLMessage::New(sentMessage, m_Message));
igtl::MessageBase::Pointer receivedMessage;
int steps = 0;
while ((receivedMessage = m_Client_One->GetMessageQueue()->PullMiscMessage()) == nullptr)
{
std::this_thread::sleep_for(std::chrono::milliseconds(5));
if (++steps > 20)
break;
}
CPPUNIT_ASSERT(receivedMessage != nullptr);
CPPUNIT_ASSERT(m_Client_One->StopCommunication());
CPPUNIT_ASSERT(m_Server->StopCommunication());
CPPUNIT_ASSERT(m_Client_One->CloseConnection());
CPPUNIT_ASSERT(m_Server->CloseConnection());
testMessagesEqual(sentMessage, receivedMessage);
}
void Test_SendingMessageFromServerToMultipleClients_Successful()
{
CPPUNIT_ASSERT_MESSAGE("Server not connected to Client.", m_Server->OpenConnection());
m_Server->StartCommunication();
CPPUNIT_ASSERT_MESSAGE("Client 1 not connected to Server.", m_Client_One->OpenConnection());
m_Client_One->StartCommunication();
CPPUNIT_ASSERT_MESSAGE("Client 2 not connected to Server.", m_Client_Two->OpenConnection());
m_Client_Two->StartCommunication();
std::this_thread::sleep_for(std::chrono::milliseconds(100));
igtl::MessageBase::Pointer sentMessage = m_MessageFactory->CreateInstance("STATUS");
dynamic_cast<igtl::StatusMessage*>(sentMessage.GetPointer())->SetStatusString(m_Message.c_str());
- m_Server->SendMessage(sentMessage);
+ m_Server->SendMessage(mitk::IGTLMessage::New(sentMessage, m_Message));
MITK_INFO << "SENT MESSAGE";
igtl::MessageBase::Pointer receivedMessage1;
igtl::MessageBase::Pointer receivedMessage2;
int steps = 0;
while (receivedMessage1 == nullptr || receivedMessage2 == nullptr)
{
std::this_thread::sleep_for(std::chrono::milliseconds(20));
igtl::MessageBase::Pointer tmpMessage1 = m_Client_One->GetMessageQueue()->PullMiscMessage();
if (tmpMessage1.IsNotNull())
receivedMessage1 = tmpMessage1;
igtl::MessageBase::Pointer tmpMessage2 = m_Client_Two->GetMessageQueue()->PullMiscMessage();
if (tmpMessage2.IsNotNull())
receivedMessage2 = tmpMessage2;
if (++steps > 50)
break;
}
CPPUNIT_ASSERT(m_Client_Two->StopCommunication());
CPPUNIT_ASSERT(m_Client_One->StopCommunication());
CPPUNIT_ASSERT(m_Server->StopCommunication());
CPPUNIT_ASSERT(m_Client_Two->CloseConnection());
CPPUNIT_ASSERT(m_Client_One->CloseConnection());
CPPUNIT_ASSERT(m_Server->CloseConnection());
CPPUNIT_ASSERT_MESSAGE("Message from first client was null..", receivedMessage1 != nullptr);
CPPUNIT_ASSERT_MESSAGE("Message from first client was null..", receivedMessage1.IsNotNull());
CPPUNIT_ASSERT_MESSAGE("Message from second client was null..", receivedMessage2 != nullptr);
CPPUNIT_ASSERT_MESSAGE("Message from second client was null..", receivedMessage2.IsNotNull());
testMessagesEqual(sentMessage, receivedMessage1);
testMessagesEqual(sentMessage, receivedMessage2);
testMessagesEqual(receivedMessage2, receivedMessage1);
}
};
MITK_TEST_SUITE_REGISTRATION(mitkOpenIGTLinkClientServer)
diff --git a/Modules/OpenIGTLink/mitkIGTLClient.cpp b/Modules/OpenIGTLink/mitkIGTLClient.cpp
index 953c8a4ad2..e480a92f8c 100644
--- a/Modules/OpenIGTLink/mitkIGTLClient.cpp
+++ b/Modules/OpenIGTLink/mitkIGTLClient.cpp
@@ -1,124 +1,124 @@
/*===================================================================
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.
===================================================================*/
#include "mitkIGTLClient.h"
//#include "mitkIGTTimeStamp.h"
//#include "mitkIGTHardwareException.h"
#include "igtlTrackingDataMessage.h"
#include <stdio.h>
#include <itksys/SystemTools.hxx>
#include <itkMutexLockHolder.h>
#include <igtlClientSocket.h>
#include <igtl_status.h>
typedef itk::MutexLockHolder<itk::FastMutexLock> MutexLockHolder;
mitk::IGTLClient::IGTLClient(bool ReadFully) :
IGTLDevice(ReadFully)
{
}
mitk::IGTLClient::~IGTLClient()
{
}
bool mitk::IGTLClient::OpenConnection()
{
if (this->GetState() != Setup)
{
mitkThrowException(mitk::Exception) <<
"Can only try to open the connection if in setup mode. State was " << this->GetState();
return false;
}
std::string hostname = this->GetHostname();
int portNumber = this->GetPortNumber();
if (portNumber == -1 || hostname.size() <= 0)
{
//port number or hostname was not correct
MITK_WARN << "Port number or hostname was not correct";
return false;
}
//create a new client socket
m_Socket = igtl::ClientSocket::New();
//try to connect to the igtl server
int response = dynamic_cast<igtl::ClientSocket*>(m_Socket.GetPointer())->
ConnectToServer(hostname.c_str(), portNumber);
//check the response
if (response != 0)
{
MITK_ERROR << "The client could not connect to " << hostname << " port: " << portNumber;
return false;
}
// everything is initialized and connected so the communication can be started
this->SetState(Ready);
//inform observers about this new client
this->InvokeEvent(NewClientConnectionEvent());
return true;
}
void mitk::IGTLClient::Receive()
{
//MITK_INFO << "Trying to receive message";
//try to receive a message, if the socket is not present anymore stop the
//communication
unsigned int status = this->ReceivePrivate(this->m_Socket);
if (status == IGTL_STATUS_NOT_PRESENT)
{
this->StopCommunicationWithSocket(this->m_Socket);
//inform observers about loosing the connection to this socket
this->InvokeEvent(LostConnectionEvent());
MITK_WARN("IGTLClient") << "Lost connection to server socket.";
}
}
void mitk::IGTLClient::Send()
{
- igtl::MessageBase::Pointer curMessage;
+ mitk::IGTLMessage::Pointer mitkMessage;
//get the latest message from the queue
- curMessage = this->m_MessageQueue->PullSendMessage();
+ mitkMessage = this->m_MessageQueue->PullSendMessage();
// there is no message => return
- if (curMessage.IsNull())
+ if (mitkMessage.IsNull())
return;
- if (!this->SendMessagePrivate(curMessage.GetPointer(), this->m_Socket))
+ if (!this->SendMessagePrivate(mitkMessage, this->m_Socket))
{
MITK_WARN("IGTLDevice") << "Could not send the message.";
}
}
void mitk::IGTLClient::StopCommunicationWithSocket(igtl::Socket* /*socket*/)
{
m_StopCommunicationMutex->Lock();
m_StopCommunication = true;
m_StopCommunicationMutex->Unlock();
}
unsigned int mitk::IGTLClient::GetNumberOfConnections()
{
return this->m_Socket->GetConnected();
}
diff --git a/Modules/OpenIGTLink/mitkIGTLDevice.cpp b/Modules/OpenIGTLink/mitkIGTLDevice.cpp
index 823b809c72..0a3c9ac77a 100644
--- a/Modules/OpenIGTLink/mitkIGTLDevice.cpp
+++ b/Modules/OpenIGTLink/mitkIGTLDevice.cpp
@@ -1,566 +1,567 @@
/*===================================================================
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.
===================================================================*/
#include "mitkIGTLDevice.h"
//#include "mitkIGTException.h"
//#include "mitkIGTTimeStamp.h"
#include <itkMutexLockHolder.h>
#include <itksys/SystemTools.hxx>
#include <cstring>
#include <igtlTransformMessage.h>
#include <mitkIGTLMessageCommon.h>
#include <igtl_status.h>
//remove later
#include <igtlTrackingDataMessage.h>
//TODO: Which timeout is acceptable and also needed to transmit image data? Is there a maximum data limit?
static const int SOCKET_SEND_RECEIVE_TIMEOUT_MSEC = 100;
typedef itk::MutexLockHolder<itk::FastMutexLock> MutexLockHolder;
mitk::IGTLDevice::IGTLDevice(bool ReadFully) :
// m_Data(mitk::DeviceDataUnspecified),
m_State(mitk::IGTLDevice::Setup),
m_Name("Unspecified Device"),
m_StopCommunication(false),
m_Hostname("127.0.0.1"),
m_PortNumber(-1),
m_MultiThreader(nullptr), m_SendThreadID(0), m_ReceiveThreadID(0), m_ConnectThreadID(0)
{
m_ReadFully = ReadFully;
m_StopCommunicationMutex = itk::FastMutexLock::New();
m_StateMutex = itk::FastMutexLock::New();
// m_LatestMessageMutex = itk::FastMutexLock::New();
m_SendingFinishedMutex = itk::FastMutexLock::New();
m_ReceivingFinishedMutex = itk::FastMutexLock::New();
m_ConnectingFinishedMutex = itk::FastMutexLock::New();
// execution rights are owned by the application thread at the beginning
m_SendingFinishedMutex->Lock();
m_ReceivingFinishedMutex->Lock();
m_ConnectingFinishedMutex->Lock();
m_MultiThreader = itk::MultiThreader::New();
// m_Data = mitk::DeviceDataUnspecified;
// m_LatestMessage = igtl::MessageBase::New();
m_MessageFactory = mitk::IGTLMessageFactory::New();
m_MessageQueue = mitk::IGTLMessageQueue::New();
}
mitk::IGTLDevice::~IGTLDevice()
{
/* stop communication and disconnect from igtl device */
if (GetState() == Running)
{
this->StopCommunication();
this->CloseConnection();
}
else if (GetState() == Ready)
{
this->CloseConnection();
}
/* cleanup tracking thread */
if (m_MultiThreader.IsNotNull())
{
if ((m_SendThreadID != 0))
{
m_MultiThreader->TerminateThread(m_SendThreadID);
}
if ((m_ReceiveThreadID != 0))
{
m_MultiThreader->TerminateThread(m_ReceiveThreadID);
}
if ((m_ConnectThreadID != 0))
{
m_MultiThreader->TerminateThread(m_ConnectThreadID);
}
}
m_MultiThreader = nullptr;
}
mitk::IGTLDevice::IGTLDeviceState mitk::IGTLDevice::GetState() const
{
MutexLockHolder lock(*m_StateMutex);
return m_State;
}
void mitk::IGTLDevice::SetState(IGTLDeviceState state)
{
itkDebugMacro("setting m_State to " << state);
m_StateMutex->Lock();
// MutexLockHolder lock(*m_StateMutex); // lock and unlock the mutex
if (m_State == state)
{
m_StateMutex->Unlock();
return;
}
m_State = state;
m_StateMutex->Unlock();
this->Modified();
}
bool mitk::IGTLDevice::TestConnection()
{
return true;
}
unsigned int mitk::IGTLDevice::ReceivePrivate(igtl::Socket* socket)
{
// Create a message buffer to receive header
igtl::MessageHeader::Pointer headerMsg;
headerMsg = igtl::MessageHeader::New();
// Initialize receive buffer
headerMsg->InitPack();
// Receive generic header from the socket
int r =
socket->Receive(headerMsg->GetPackPointer(), headerMsg->GetPackSize(), 0);
//MITK_INFO << "Server received r = " << r;
//MITK_INFO << "Received r = " << r;
if (r == 0) //connection error
{
// an error was received, therefore the communication with this socket
// must be stoppedy
return IGTL_STATUS_NOT_PRESENT;
}
else if (r == -1) //timeout
{
// a timeout was received, this is no error state, thus, do nothing
return IGTL_STATUS_TIME_OUT;
}
else if (r == headerMsg->GetPackSize())
{
// Deserialize the header and check the CRC
// ERROR HERE: This probably means the header data is corrupted...
int crcCheck = headerMsg->Unpack(1);
if (crcCheck & igtl::MessageHeader::UNPACK_HEADER)
{
// Allocate a time stamp
igtl::TimeStamp::Pointer ts;
ts = igtl::TimeStamp::New();
// Get time stamp
igtlUint32 sec;
igtlUint32 nanosec;
headerMsg->GetTimeStamp(ts);
ts->GetTimeStamp(&sec, &nanosec);
// std::cerr << "Time stamp: "
// << sec << "."
// << nanosec << std::endl;
// std::cerr << "Dev type and name: " << headerMsg->GetDeviceType() << " "
// << headerMsg->GetDeviceName() << std::endl;
// headerMsg->Print(std::cout);
//check the type of the received message
//if it is a GET_, STP_ or RTS_ command push it into the command queue
//otherwise continue reading the whole message from the socket
const char* curDevType = headerMsg->GetDeviceType();
if (std::strstr(curDevType, "GET_") != nullptr ||
std::strstr(curDevType, "STP_") != nullptr ||
std::strstr(curDevType, "RTS_") != nullptr)
{
this->m_MessageQueue->PushCommandMessage(headerMsg);
this->InvokeEvent(CommandReceivedEvent());
return IGTL_STATUS_OK;
}
//Create a message according to the header message
igtl::MessageBase::Pointer curMessage;
curMessage = m_MessageFactory->CreateInstance(headerMsg);
//check if the curMessage is created properly, if not the message type is
//not supported and the message has to be skipped
if (curMessage.IsNull())
{
socket->Skip(headerMsg->GetBodySizeToRead(), 0);
// MITK_ERROR("IGTLDevice") << "The received type is not supported. Please "
// "add it to the message factory.";
return IGTL_STATUS_NOT_FOUND;
}
//insert the header to the message and allocate the pack
curMessage->SetMessageHeader(headerMsg);
curMessage->AllocatePack();
// Receive transform data from the socket
int receiveCheck = 0;
receiveCheck = socket->Receive(curMessage->GetPackBodyPointer(),
curMessage->GetPackBodySize(), m_ReadFully);
if (receiveCheck > 0)
{
int c = curMessage->Unpack(1);
if (!(c & igtl::MessageHeader::UNPACK_BODY))
{
return IGTL_STATUS_CHECKSUM_ERROR;
}
//check the type of the received message
//if it is a command push it into the command queue
//otherwise into the normal receive queue
//STP_ commands are handled here because they implemented additional
//member variables that are not stored in the header message
if (std::strstr(curDevType, "STT_") != nullptr)
{
this->m_MessageQueue->PushCommandMessage(curMessage);
this->InvokeEvent(CommandReceivedEvent());
}
else
{
+ if(m_LogMessages)
+ MITK_INFO << "Received Message: " << mitk::IGTLMessage::New(curMessage, "")->ToString();
this->m_MessageQueue->PushMessage(curMessage);
this->InvokeEvent(MessageReceivedEvent());
}
return IGTL_STATUS_OK;
}
else
{
MITK_ERROR("IGTLDevice") << "Received a valid header but could not "
<< "read the whole message.";
return IGTL_STATUS_UNKNOWN_ERROR;
}
}
else
{
//CRC check failed
MITK_ERROR << "CRC Check failed";
return IGTL_STATUS_CHECKSUM_ERROR;
}
}
else
{
//Message size information and actual data size don't match.
//this state is not suppossed to be reached, return unknown error
MITK_ERROR << "IGTL status unknown";
return IGTL_STATUS_UNKNOWN_ERROR;
}
}
-void mitk::IGTLDevice::SendMessage(const mitk::IGTLMessage* msg)
+void mitk::IGTLDevice::SendMessage(mitk::IGTLMessage::Pointer msg)
{
- this->SendMessage(msg->GetMessage());
-}
-
-void mitk::IGTLDevice::SendMessage(igtl::MessageBase::Pointer msg)
-{
- //add the message to the queue
m_MessageQueue->PushSendMessage(msg);
}
-unsigned int mitk::IGTLDevice::SendMessagePrivate(igtl::MessageBase::Pointer msg,
+unsigned int mitk::IGTLDevice::SendMessagePrivate(mitk::IGTLMessage::Pointer msg,
igtl::Socket::Pointer socket)
{
//check the input message
if (msg.IsNull())
{
MITK_ERROR("IGTLDevice") << "Could not send message because message is not "
"valid. Please check.";
return false;
}
+ igtl::MessageBase* sendMessage = msg->GetMessage();
+
// add the name of this device to the message
- msg->SetDeviceName(this->GetName().c_str());
+ sendMessage->SetDeviceName(this->GetName().c_str());
// Pack (serialize) and send
- msg->Pack();
+ sendMessage->Pack();
- int sendSuccess = socket->Send(msg->GetPackPointer(), msg->GetPackSize());
+ int sendSuccess = socket->Send(sendMessage->GetPackPointer(), sendMessage->GetPackSize());
if (sendSuccess)
{
+ if(m_LogMessages)
+ MITK_INFO << "Send IGTL message: " << msg->ToString();
+
this->InvokeEvent(MessageSentEvent());
return IGTL_STATUS_OK;
}
else
{
return IGTL_STATUS_UNKNOWN_ERROR;
}
}
void mitk::IGTLDevice::RunCommunication(void (IGTLDevice::*ComFunction)(void), itk::FastMutexLock* mutex)
{
if (this->GetState() != Running)
return;
try
{
// keep lock until end of scope
MutexLockHolder communicationFinishedLockHolder(*mutex);
// Because m_StopCommunication is used by two threads, access has to be guarded
// by a mutex. To minimize thread locking, a local copy is used here
bool localStopCommunication;
// update the local copy of m_StopCommunication
this->m_StopCommunicationMutex->Lock();
localStopCommunication = this->m_StopCommunication;
this->m_StopCommunicationMutex->Unlock();
while ((this->GetState() == Running) && (localStopCommunication == false))
{
(this->*ComFunction)();
/* Update the local copy of m_StopCommunication */
this->m_StopCommunicationMutex->Lock();
localStopCommunication = m_StopCommunication;
this->m_StopCommunicationMutex->Unlock();
// time to relax, this sets the maximum ever possible framerate to 1000 Hz
itksys::SystemTools::Delay(1);
}
}
catch (...)
{
mutex->Unlock();
this->StopCommunication();
MITK_ERROR("IGTLDevice::RunCommunication") << "Error while communicating. Thread stopped.";
//mitkThrowException(mitk::IGTException) << "Error while communicating. Thread stopped.";
}
// StopCommunication was called, thus the mode should be changed back to Ready now
// that the tracking loop has ended.
//this->SetState(Ready); //this is done elsewhere
MITK_DEBUG("IGTLDevice::RunCommunication") << "Reached end of communication.";
// returning from this function (and ThreadStartCommunication())
// this will end the thread
return;
}
bool mitk::IGTLDevice::StartCommunication()
{
if (this->GetState() != Ready)
return false;
// go to mode Running
this->SetState(Running);
// set a timeout for the sending and receiving
this->m_Socket->SetTimeout(SOCKET_SEND_RECEIVE_TIMEOUT_MSEC);
// update the local copy of m_StopCommunication
this->m_StopCommunicationMutex->Lock();
this->m_StopCommunication = false;
this->m_StopCommunicationMutex->Unlock();
// transfer the execution rights to tracking thread
m_SendingFinishedMutex->Unlock();
m_ReceivingFinishedMutex->Unlock();
m_ConnectingFinishedMutex->Unlock();
// start new threads that execute the communication
m_SendThreadID =
m_MultiThreader->SpawnThread(this->ThreadStartSending, this);
m_ReceiveThreadID =
m_MultiThreader->SpawnThread(this->ThreadStartReceiving, this);
m_ConnectThreadID =
m_MultiThreader->SpawnThread(this->ThreadStartConnecting, this);
// mitk::IGTTimeStamp::GetInstance()->Start(this);
return true;
}
bool mitk::IGTLDevice::StopCommunication()
{
if (this->GetState() == Running) // Only if the object is in the correct state
{
// m_StopCommunication is used by two threads, so we have to ensure correct
// thread handling
m_StopCommunicationMutex->Lock();
m_StopCommunication = true;
m_StopCommunicationMutex->Unlock();
// we have to wait here that the other thread recognizes the STOP-command
// and executes it
m_SendingFinishedMutex->Lock();
m_ReceivingFinishedMutex->Lock();
m_ConnectingFinishedMutex->Lock();
// mitk::IGTTimeStamp::GetInstance()->Stop(this); // notify realtime clock
// StopCommunication was called, thus the mode should be changed back
// to Ready now that the tracking loop has ended.
this->SetState(Ready);
}
return true;
}
bool mitk::IGTLDevice::CloseConnection()
{
if (this->GetState() == Setup)
{
return true;
}
else if (this->GetState() == Running)
{
this->StopCommunication();
}
m_Socket->CloseSocket();
/* return to setup mode */
this->SetState(Setup);
// this->InvokeEvent(mitk::LostConnectionEvent());
return true;
}
bool mitk::IGTLDevice::SendRTSMessage(const char* type)
{
//construct the device type for the return message, it starts with RTS_ and
//continues with the requested type
std::string returnType("RTS_");
returnType.append(type);
//create a return message
igtl::MessageBase::Pointer rtsMsg =
this->m_MessageFactory->CreateInstance(returnType);
//if retMsg is NULL there is no return message defined and thus it is not
//necessary to send one back
if (rtsMsg.IsNotNull())
{
- this->SendMessage(rtsMsg);
+ this->SendMessage(mitk::IGTLMessage::New(rtsMsg, returnType));
return true;
}
else
{
return false;
}
}
void mitk::IGTLDevice::Connect()
{
MITK_DEBUG << "mitk::IGTLDevice::Connect();";
}
igtl::ImageMessage::Pointer mitk::IGTLDevice::GetNextImage2dMessage()
{
return this->m_MessageQueue->PullImage2dMessage();
}
igtl::ImageMessage::Pointer mitk::IGTLDevice::GetNextImage3dMessage()
{
return this->m_MessageQueue->PullImage3dMessage();
}
igtl::TransformMessage::Pointer mitk::IGTLDevice::GetNextTransformMessage()
{
return this->m_MessageQueue->PullTransformMessage();
}
igtl::TrackingDataMessage::Pointer mitk::IGTLDevice::GetNextTrackingDataMessage()
{
igtl::TrackingDataMessage::Pointer msg = this->m_MessageQueue->PullTrackingMessage();
return msg;
}
igtl::StringMessage::Pointer mitk::IGTLDevice::GetNextStringMessage()
{
return this->m_MessageQueue->PullStringMessage();
}
igtl::MessageBase::Pointer mitk::IGTLDevice::GetNextMiscMessage()
{
return this->m_MessageQueue->PullMiscMessage();
}
igtl::MessageBase::Pointer mitk::IGTLDevice::GetNextCommand()
{
return m_MessageQueue->PullCommandMessage();
}
void mitk::IGTLDevice::EnableInfiniteBufferingMode(bool enable)
{
m_MessageQueue->EnableInfiniteBuffering(enable);
}
void mitk::IGTLDevice::EnableInfiniteBufferingMode(
mitk::IGTLMessageQueue::Pointer queue,
bool enable)
{
queue->EnableInfiniteBuffering(enable);
}
ITK_THREAD_RETURN_TYPE mitk::IGTLDevice::ThreadStartSending(void* pInfoStruct)
{
/* extract this pointer from Thread Info structure */
struct itk::MultiThreader::ThreadInfoStruct * pInfo =
(struct itk::MultiThreader::ThreadInfoStruct*)pInfoStruct;
if (pInfo == nullptr)
{
return ITK_THREAD_RETURN_VALUE;
}
if (pInfo->UserData == nullptr)
{
return ITK_THREAD_RETURN_VALUE;
}
IGTLDevice *igtlDevice = (IGTLDevice*)pInfo->UserData;
if (igtlDevice != nullptr)
{
igtlDevice->RunCommunication(&mitk::IGTLDevice::Send, igtlDevice->m_SendingFinishedMutex);
}
igtlDevice->m_SendThreadID = 0; // erase thread id because thread will end.
return ITK_THREAD_RETURN_VALUE;
}
ITK_THREAD_RETURN_TYPE mitk::IGTLDevice::ThreadStartReceiving(void* pInfoStruct)
{
/* extract this pointer from Thread Info structure */
struct itk::MultiThreader::ThreadInfoStruct * pInfo =
(struct itk::MultiThreader::ThreadInfoStruct*)pInfoStruct;
if (pInfo == nullptr)
{
return ITK_THREAD_RETURN_VALUE;
}
if (pInfo->UserData == nullptr)
{
return ITK_THREAD_RETURN_VALUE;
}
IGTLDevice *igtlDevice = (IGTLDevice*)pInfo->UserData;
if (igtlDevice != nullptr)
{
igtlDevice->RunCommunication(&mitk::IGTLDevice::Receive,
igtlDevice->m_ReceivingFinishedMutex);
}
igtlDevice->m_ReceiveThreadID = 0; // erase thread id because thread will end.
return ITK_THREAD_RETURN_VALUE;
}
ITK_THREAD_RETURN_TYPE mitk::IGTLDevice::ThreadStartConnecting(void* pInfoStruct)
{
/* extract this pointer from Thread Info structure */
struct itk::MultiThreader::ThreadInfoStruct * pInfo =
(struct itk::MultiThreader::ThreadInfoStruct*)pInfoStruct;
if (pInfo == nullptr)
{
return ITK_THREAD_RETURN_VALUE;
}
if (pInfo->UserData == nullptr)
{
return ITK_THREAD_RETURN_VALUE;
}
IGTLDevice *igtlDevice = (IGTLDevice*)pInfo->UserData;
if (igtlDevice != nullptr)
{
igtlDevice->RunCommunication(&mitk::IGTLDevice::Connect,
igtlDevice->m_ConnectingFinishedMutex);
}
igtlDevice->m_ConnectThreadID = 0; // erase thread id because thread will end.
return ITK_THREAD_RETURN_VALUE;
}
diff --git a/Modules/OpenIGTLink/mitkIGTLDevice.h b/Modules/OpenIGTLink/mitkIGTLDevice.h
index 30f34abb37..576d51e7a2 100644
--- a/Modules/OpenIGTLink/mitkIGTLDevice.h
+++ b/Modules/OpenIGTLink/mitkIGTLDevice.h
@@ -1,419 +1,417 @@
/*===================================================================
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 {
/**
* \brief Interface for all OpenIGTLink Devices
*
* Defines the methods that are common for all devices using OpenIGTLink. It
* can open/close a connection, start/stop a communication and send/receive
* messages.
*
* It uses message queues to store the incoming and outgoing mails. They are
* configurable, you can set buffering on and off.
*
* The device is in one of three different states: Setup, Ready or Running.
* Setup is the initial state. From this state on you can call
* OpenConnection() and arrive in the Ready state. From the Ready state you
* call StartCommunication() to arrive in the Running state. Now the device
* is continuosly checking for new connections, receiving messages and
* sending messages. This runs in a seperate thread. To stop the communication
* call StopCommunication() (to arrive in Ready state) or CloseConnection()
* (to arrive in the Setup state).
*
* \ingroup OpenIGTLink
*
*/
class MITKOPENIGTLINK_EXPORT IGTLDevice : public itk::Object
{
public:
mitkClassMacroItkParent(IGTLDevice, itk::Object)
IGTLDevice(bool ReadFully);
/**
* \brief Type for state variable.
* The IGTLDevice is always in one of these states.
*
*/
enum IGTLDeviceState { Setup, Ready, Running };
/**
* \brief Opens a connection to the device
*
* This may only be called if there is currently no connection to the
* device. If OpenConnection() is successful, the object will change from
* Setup state to Ready state.
*/
virtual bool OpenConnection() = 0;
/**
* \brief Closes the connection to the device
*
* This may only be called if there is currently a connection to the
* device, but device is not running (e.g. object is in Ready state)
*/
virtual bool CloseConnection();
/**
* \brief Stops the communication between the two devices
*
* This may only be called if the device is in Running state.
*/
virtual bool StopCommunication();
/**
* \brief Starts the communication between the two devices
*
* This may only be called if the device is in Ready state.
*/
bool StartCommunication();
/**
* \brief Continuously calls the given function
*
* This may only be called if the device is in Running state and only from
* a seperate thread.
*
* \param ComFunction function pointer that specifies the method to be executed
* \param mutex the mutex that corresponds to the function pointer
*/
void RunCommunication(void (IGTLDevice::*ComFunction)(void), itk::FastMutexLock* mutex);
+
/**
* \brief Adds the given message to the sending queue
*
* This may only be called after the connection to the device has been
* established with a call to OpenConnection(). Note that the message
* is not send directly. This method just adds it to the send queue.
* \param msg The message to be added to the sending queue
*/
- void SendMessage(igtl::MessageBase::Pointer msg);
-
- /**
- * \brief Adds the given message to the sending queue
- *
- * Convenience function to work with mitk::IGTLMessage directly.
- * \param msg The message to be added to the sending queue
- */
- void SendMessage(const IGTLMessage* msg);
+ void SendMessage(mitk::IGTLMessage::Pointer msg);
/**
* \brief Returns current object state (Setup, Ready or Running)
*/
IGTLDeviceState GetState() const;
/**
* \brief Returns the oldest message in the command queue
* \return The oldest message from the command queue.
*/
igtl::MessageBase::Pointer GetNextCommand();
/**
* \brief Returns the oldest message in the receive queue
* \return The oldest message from the receive queue
*/
igtl::ImageMessage::Pointer GetNextImage2dMessage();
igtl::ImageMessage::Pointer GetNextImage3dMessage();
igtl::TransformMessage::Pointer GetNextTransformMessage();
igtl::TrackingDataMessage::Pointer GetNextTrackingDataMessage();
igtl::StringMessage::Pointer GetNextStringMessage();
igtl::MessageBase::Pointer GetNextMiscMessage();
/**
* \brief Sets the port number of the device
*/
itkSetMacro(PortNumber, int);
/**
* \brief Returns the port number of the device
*/
itkGetMacro(PortNumber, int);
/**
* \brief Sets the ip/hostname of the device
*/
itkSetMacro(Hostname, std::string);
/**
* \brief Returns the ip/hostname of the device
*/
itkGetMacro(Hostname, std::string);
/**
* \brief Returns the name of this device
*/
itkGetConstMacro(Name, std::string);
/**
* \brief Sets the name of this device
*/
itkSetMacro(Name, std::string);
/**
* \brief Advises this IGTL Device to always block until the whole message is read.
*/
itkSetMacro(ReadFully, bool);
/**
* \brief Returns a const reference to the receive queue
*/
itkGetConstMacro(MessageQueue, mitk::IGTLMessageQueue::Pointer);
/**
* \brief Returns the message factory
*/
itkGetMacro(MessageFactory, mitk::IGTLMessageFactory::Pointer);
/**
* \brief static start method for the sending thread.
* \param data a void pointer to the IGTLDevice object.
*/
static ITK_THREAD_RETURN_TYPE ThreadStartSending(void* data);
/**
* \brief static start method for the receiving thread.
* \param data a void pointer to the IGTLDevice object.
*/
static ITK_THREAD_RETURN_TYPE ThreadStartReceiving(void* data);
/**
* \brief static start method for the connection thread.
* \param data a void pointer to the IGTLDevice object.
*/
static ITK_THREAD_RETURN_TYPE ThreadStartConnecting(void* data);
/**
* \brief TestConnection() tries to connect to a IGTL device on the current
* ip and port
*
* \todo Implement this method. Send a status message and check the answer.
*
* TestConnection() tries to connect to a IGTL server on the current
* ip and port and returns which device it has found.
* \return It returns the type of the device that answers. Throws an
* exception
* if no device is available on that ip/port.
* @throw mitk::Exception Throws an exception if there are errors
* while connecting to the device.
*/
virtual bool TestConnection();
/**
* \brief Send RTS message of given type
*/
bool SendRTSMessage(const char* type);
/**
* \brief Sets the buffering mode of the given queue
*/
void EnableInfiniteBufferingMode(mitk::IGTLMessageQueue::Pointer queue,
bool enable = true);
void EnableInfiniteBufferingMode(bool enable = true);
/**
* \brief Returns the number of connections of this device
*/
virtual unsigned int GetNumberOfConnections() = 0;
+ itkGetMacro(LogMessages, bool);
+ itkSetMacro(LogMessages, bool);
+
protected:
/**
* \brief Sends a message.
*
* This may only be called after the connection to the device has been
* established with a call to OpenConnection(). This method uses the given
* socket to send the given MessageReceivedEvent
*
* \param msg the message to be sent
* \param socket the socket used to communicate with the other device
*
* \retval IGTL_STATUS_OK the message was sent
* \retval IGTL_STATUS_UNKONWN_ERROR the message was not sent because an
* unknown error occurred
*/
- unsigned int SendMessagePrivate(igtl::MessageBase::Pointer msg,
+ unsigned int SendMessagePrivate(mitk::IGTLMessage::Pointer msg,
igtl::Socket::Pointer socket);
/**
* \brief Call this method to receive a message.
*
* The message will be saved in the receive queue.
*/
virtual void Receive() = 0;
/**
* \brief Call this method to receive a message from the given device.
*
* The message will be saved in the receive queue.
*
* \param device the socket that connects this device with the other one.
*
* \retval IGTL_STATUS_OK a message or a command was received
* \retval IGTL_STATUS_NOT_PRESENT the socket is not connected anymore
* \retval IGTL_STATUS_TIME_OUT the socket timed out
* \retval IGTL_STATUS_CHECKSUM_ERROR the checksum of the received msg was
* incorrect
* \retval IGTL_STATUS_UNKNOWN_ERROR an unknown error occurred
*/
unsigned int ReceivePrivate(igtl::Socket* device);
/**
* \brief Call this method to send a message. The message will be read from
* the queue.
*/
virtual void Send() = 0;
/**
* \brief Call this method to check for other devices that want to connect
* to this one.
*
* In case of a client this method is doing nothing. In case of a server it
* is checking for other devices and if there is one it establishes a
* connection.
*/
virtual void Connect();
/**
* \brief Stops the communication with the given socket
*
*/
virtual void StopCommunicationWithSocket(igtl::Socket* socket) = 0;
/**
* \brief change object state
*/
void SetState(IGTLDeviceState state);
IGTLDevice();
virtual ~IGTLDevice();
/** current object state (Setup, Ready or Running) */
IGTLDeviceState m_State;
/** the name of this device */
std::string m_Name;
/** signal used to stop the thread*/
bool m_StopCommunication;
/** mutex to control access to m_StopCommunication */
itk::FastMutexLock::Pointer m_StopCommunicationMutex;
/** mutex used to make sure that the send thread is just started once */
itk::FastMutexLock::Pointer m_SendingFinishedMutex;
/** mutex used to make sure that the receive thread is just started once */
itk::FastMutexLock::Pointer m_ReceivingFinishedMutex;
/** mutex used to make sure that the connect thread is just started once */
itk::FastMutexLock::Pointer m_ConnectingFinishedMutex;
/** mutex to control access to m_State */
itk::FastMutexLock::Pointer m_StateMutex;
/** the hostname or ip of the device */
std::string m_Hostname;
/** the port number of the device */
int m_PortNumber;
/** the socket used to communicate with other IGTL devices */
igtl::Socket::Pointer m_Socket;
/** The message receive queue */
mitk::IGTLMessageQueue::Pointer m_MessageQueue;
/** A message factory that provides the New() method for all msg types */
mitk::IGTLMessageFactory::Pointer m_MessageFactory;
+ bool m_LogMessages;
+
private:
/** creates worker thread that continuously polls interface for new
messages */
itk::MultiThreader::Pointer m_MultiThreader;
/** ID of sending thread */
int m_SendThreadID;
/** ID of receiving thread */
int m_ReceiveThreadID;
/** ID of connecting thread */
int m_ConnectThreadID;
/** Always try to read the full message. */
bool m_ReadFully;
};
/**
* \brief connect to this Event to get notified when a message was successfully sent
*
* \note This event is invoked in the communication thread, therefore do not use it to make
* changes in the GUI!!! Use the QT signal slot system to decouple this call from the com thread
* */
itkEventMacro(MessageSentEvent, itk::AnyEvent);
/**
* \brief connect to this Event to get notified when a message was received
*
* \note Check if you can invoke this events like this or if you have to make
* it thread-safe. They are not invoked in the main thread!!!
* */
itkEventMacro(MessageReceivedEvent, itk::AnyEvent);
/**
* \brief connect to this Event to get notified when a command was received
*
* \note Check if you can invoke this events like this or if you have to make
* it thread-safe. They are not invoked in the main thread!!!
* */
itkEventMacro(CommandReceivedEvent, itk::AnyEvent);
/**
* \brief connect to this Event to get notified when another igtl device
* connects with this device.
*
* \note Check if you can invoke this events like this or if you have to make
* it thread-safe. They are not invoked in the main thread!!!
* */
itkEventMacro(NewClientConnectionEvent, itk::AnyEvent);
/**
* \brief connect to this Event to get notified when this device looses the
* connection to a socket.
*
* \note Check if you can invoke this events like this or if you have to make
* it thread-safe. They are not invoked in the main thread!!!
* */
itkEventMacro(LostConnectionEvent, itk::AnyEvent);
} // namespace mitk
#endif /* MITKIGTLDEVICE_H */
diff --git a/Modules/OpenIGTLink/mitkIGTLMessage.cpp b/Modules/OpenIGTLink/mitkIGTLMessage.cpp
index d0958d2553..703f0d8ae1 100644
--- a/Modules/OpenIGTLink/mitkIGTLMessage.cpp
+++ b/Modules/OpenIGTLink/mitkIGTLMessage.cpp
@@ -1,170 +1,180 @@
/*===================================================================
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.
===================================================================*/
#include "mitkIGTLMessage.h"
#include "mitkException.h"
#include "mitkIGTLMessageCommon.h"
mitk::IGTLMessage::IGTLMessage() : itk::DataObject(),
-m_DataValid(false), m_IGTTimeStamp(0.0), m_Name()
+ m_DataValid(false), m_IGTTimeStamp(0.0), m_Name()
{
m_Message = igtl::MessageBase::New();
}
mitk::IGTLMessage::IGTLMessage(const mitk::IGTLMessage& toCopy) :
itk::DataObject()
{
// TODO SW: Graft does the same, remove code duplications, set Graft to
// deprecated, remove duplication in tescode
this->Graft(&toCopy);
}
mitk::IGTLMessage::~IGTLMessage()
{
}
mitk::IGTLMessage::IGTLMessage(igtl::MessageBase::Pointer message,
std::string name)
{
this->SetMessage(message);
this->SetName(name);
}
void mitk::IGTLMessage::Graft( const DataObject *data )
{
// Attempt to cast data to an IGTLMessage
const Self* msg;
try
{
msg = dynamic_cast<const Self *>(data);
}
catch( ... )
{
itkExceptionMacro( << "mitk::IGTLMessage::Graft cannot cast "
- << typeid(data).name() << " to "
- << typeid(const Self *).name() );
+ << typeid(data).name() << " to "
+ << typeid(const Self *).name() );
return;
}
if (!msg)
{
// pointer could not be cast back down
itkExceptionMacro( << "mitk::IGTLMessage::Graft cannot cast "
- << typeid(data).name() << " to "
- << typeid(const Self *).name() );
+ << typeid(data).name() << " to "
+ << typeid(const Self *).name() );
return;
}
// Now copy anything that is needed
this->SetMessage(msg->GetMessage());
this->SetDataValid(msg->IsDataValid());
this->SetIGTTimeStamp(msg->GetIGTTimeStamp());
this->SetName(msg->GetName());
}
void mitk::IGTLMessage::SetMessage(igtl::MessageBase::Pointer msg)
{
m_Message = msg;
unsigned int ts = 0;
unsigned int frac = 0;
m_Message->GetTimeStamp(&ts, &frac);
this->SetIGTTimeStamp((double)ts + (double)frac/1000.0);
this->SetDataValid(true);
}
bool mitk::IGTLMessage::IsDataValid() const
{
return m_DataValid;
}
void mitk::IGTLMessage::PrintSelf(std::ostream& os, itk::Indent indent) const
{
this->Superclass::PrintSelf(os, indent);
os << indent << "name: " << this->GetName() << std::endl;
os << indent << "data valid: " << this->IsDataValid() << std::endl;
os << indent << "TimeStamp: " << this->GetIGTTimeStamp() << std::endl;
os << indent << "OpenIGTLinkMessage: " << std::endl;
m_Message->Print(os);
}
+std::string mitk::IGTLMessage::ToString() const
+{
+ std::stringstream output;
+ output << "name: " << this->GetName() << std::endl <<
+ "MessageType: " << this->GetIGTLMessageType() << std::endl <<
+ "TimeStamp: " << this->GetIGTTimeStamp() << std::endl <<
+ "OpenIGTLinkMessage: " << std::endl;
+ return output.str();
+}
+
void mitk::IGTLMessage::CopyInformation( const DataObject* data )
{
this->Superclass::CopyInformation( data );
const Self * nd = nullptr;
try
{
nd = dynamic_cast<const Self*>(data);
}
catch( ... )
{
// data could not be cast back down
itkExceptionMacro(<< "mitk::IGTLMessage::CopyInformation() cannot cast "
- << typeid(data).name() << " to "
- << typeid(Self*).name() );
+ << typeid(data).name() << " to "
+ << typeid(Self*).name() );
}
if ( !nd )
{
// pointer could not be cast back down
itkExceptionMacro(<< "mitk::IGTLMessage::CopyInformation() cannot cast "
- << typeid(data).name() << " to "
- << typeid(Self*).name() );
+ << typeid(data).name() << " to "
+ << typeid(Self*).name() );
}
/* copy all meta data */
}
bool mitk::Equal(const mitk::IGTLMessage& leftHandSide,
const mitk::IGTLMessage& rightHandSide,
ScalarType /*eps*/, bool verbose)
{
bool returnValue = true;
if( std::string(rightHandSide.GetName()) != std::string(leftHandSide.GetName()) )
{
if(verbose)
{
MITK_INFO << "[( IGTLMessage )] Name differs.";
MITK_INFO << "leftHandSide is " << leftHandSide.GetName()
- << "rightHandSide is " << rightHandSide.GetName();
+ << "rightHandSide is " << rightHandSide.GetName();
}
returnValue = false;
}
if( rightHandSide.GetIGTTimeStamp() != leftHandSide.GetIGTTimeStamp() )
{
if(verbose)
{
MITK_INFO << "[( IGTLMessage )] IGTTimeStamp differs.";
MITK_INFO << "leftHandSide is " << leftHandSide.GetIGTTimeStamp()
- << "rightHandSide is " << rightHandSide.GetIGTTimeStamp();
+ << "rightHandSide is " << rightHandSide.GetIGTTimeStamp();
}
returnValue = false;
}
return returnValue;
}
const char* mitk::IGTLMessage::GetIGTLMessageType() const
{
return this->m_Message->GetDeviceType();
}
template < typename IGTLMessageType >
IGTLMessageType* mitk::IGTLMessage::GetMessage() const
{
return dynamic_cast<IGTLMessageType*>(this->m_Message);
}
diff --git a/Modules/OpenIGTLink/mitkIGTLMessage.h b/Modules/OpenIGTLink/mitkIGTLMessage.h
index ff66f82e14..d3e0d9ddcd 100644
--- a/Modules/OpenIGTLink/mitkIGTLMessage.h
+++ b/Modules/OpenIGTLink/mitkIGTLMessage.h
@@ -1,197 +1,199 @@
/*===================================================================
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 MITKIGTLMESSAGEH_HEADER_INCLUDED_
#define MITKIGTLMESSAGEH_HEADER_INCLUDED_
#include <itkDataObject.h>
#include "MitkOpenIGTLinkExports.h"
#include <mitkNumericTypes.h>
#include <mitkCommon.h>
#include "igtlMessageBase.h"
namespace mitk {
/**Documentation
* \brief A wrapper for the OpenIGTLink message type
*
* This class represents the data object that is passed through the
* MITK-OpenIGTLink filter pipeline. It wraps the OpenIGTLink message type.
* Additionally, it contains a data structure that contains error/plausibility
* information.
*
*/
class MITKOPENIGTLINK_EXPORT IGTLMessage : public itk::DataObject
{
public:
mitkClassMacroItkParent(IGTLMessage, itk::DataObject);
itkFactorylessNewMacro(Self);
itkCloneMacro(Self);
mitkNewMacro2Param(Self, igtl::MessageBase::Pointer,std::string);
/**
* \brief type that holds the time at which the data was recorded
*/
typedef double TimeStampType;
/**
* \brief Sets the OpenIGTLink message
*/
void SetMessage(igtl::MessageBase::Pointer msg);
/**
* \brief returns the OpenIGTLink message
*/
itkGetConstMacro(Message, igtl::MessageBase::Pointer);
/**
* \brief returns true if the object contains valid data
*/
virtual bool IsDataValid() const;
/**
* \brief sets the dataValid flag of the IGTLMessage object indicating if
* the object contains valid data
*/
itkSetMacro(DataValid, bool);
/**
* \brief gets the IGT timestamp of the IGTLMessage object
*/
itkGetConstMacro(IGTTimeStamp, TimeStampType);
/**
* \brief set the name of the IGTLMessage object
*/
itkSetStringMacro(Name);
/**
* \brief returns the name of the IGTLMessage object
*/
itkGetStringMacro(Name);
/**
* \brief Graft the data and information from one IGTLMessage to another.
*
* Copies the content of data into this object.
* This is a convenience method to setup a second IGTLMessage object with
* all the meta information of another IGTLMessage object.
* Note that this method is different than just using two
* SmartPointers to the same IGTLMessage object since separate DataObjects
* are still maintained.
*/
virtual void Graft(const DataObject *data) override;
/**
* \brief copy meta data of a IGTLMessage object
*
* copies all meta data from IGTLMessage data to this object
*/
virtual void CopyInformation(const DataObject* data) override;
/**
* \brief Prints the object information to the given stream os.
* \param os The stream which is used to print the output.
* \param indent Defines the indentation of the output.
*/
void PrintSelf(std::ostream& os, itk::Indent indent) const override;
+ std::string ToString() const;
+
/** Compose with another IGTLMessage
*
* This method composes self with another IGTLMessage of the
* same dimension, modifying self to be the composition of self
* and other. If the argument pre is true, then other is
* precomposed with self; that is, the resulting transformation
* consists of first applying other to the source, followed by
* self. If pre is false or omitted, then other is post-composed
* with self; that is the resulting transformation consists of
* first applying self to the source, followed by other. */
void Compose(const mitk::IGTLMessage::Pointer n, const bool pre = false);
/** Returns the OpenIGTL Message type
**/
const char* GetIGTLMessageType() const;
template < typename IGTLMessageType > IGTLMessageType* GetMessage() const;
protected:
mitkCloneMacro(Self);
IGTLMessage();
/**
* Copy constructor internally used.
*/
IGTLMessage(const mitk::IGTLMessage& toCopy);
/**
* Creates a IGTLMessage object from an igtl::MessageBase and a given name.
*/
IGTLMessage(igtl::MessageBase::Pointer message, std::string name = "");
virtual ~IGTLMessage();
/**
* \brief holds the actual OpenIGTLink message
*/
igtl::MessageBase::Pointer m_Message;
/**
* \brief defines if the object contains valid values
*/
bool m_DataValid;
/**
* \brief contains the time at which the tracking data was recorded
*/
TimeStampType m_IGTTimeStamp;
/**
* \brief name of the navigation data
*/
std::string m_Name;
private:
// pre = false
static mitk::IGTLMessage::Pointer getComposition(
const mitk::IGTLMessage::Pointer nd1,
const mitk::IGTLMessage::Pointer nd2);
/**
* \brief sets the IGT timestamp of the IGTLMessage object
*/
itkSetMacro(IGTTimeStamp, TimeStampType);
};
/**
* @brief Equal A function comparing two OpenIGTLink message objects for
* being equal in meta- and imagedata
*
* @ingroup MITKTestingAPI
*
* Following aspects are tested for equality:
* - TBD
*
* @param rightHandSide An IGTLMessage to be compared
* @param leftHandSide An IGTLMessage to be compared
* @param eps Tolarence for comparison. You can use mitk::eps in most cases.
* @param verbose Flag indicating if the user wants detailed console output
* or not.
* @return true, if all subsequent comparisons are true, false otherwise
*/
MITKOPENIGTLINK_EXPORT bool Equal( const mitk::IGTLMessage& leftHandSide,
const mitk::IGTLMessage& rightHandSide,
ScalarType eps = mitk::eps,
bool verbose = false );
} // namespace mitk
#endif /* MITKIGTLMESSAGEH_HEADER_INCLUDED_ */
diff --git a/Modules/OpenIGTLink/mitkIGTLMessageProvider.cpp b/Modules/OpenIGTLink/mitkIGTLMessageProvider.cpp
index b508a3d875..fe7f8049e0 100644
--- a/Modules/OpenIGTLink/mitkIGTLMessageProvider.cpp
+++ b/Modules/OpenIGTLink/mitkIGTLMessageProvider.cpp
@@ -1,436 +1,432 @@
/*===================================================================
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.
===================================================================*/
#include "mitkIGTLMessageProvider.h"
#include "mitkIGTLDevice.h"
#include "mitkIGTLMessage.h"
#include "mitkIGTLMessageFactory.h"
#include "mitkCallbackFromGUIThread.h"
//Microservices
#include "usServiceReference.h"
#include "usModuleContext.h"
#include "usServiceEvent.h"
#include "mitkServiceInterface.h"
#include "usGetModuleContext.h"
//igt (remove this later)
#include "igtlBindMessage.h"
#include "igtlQuaternionTrackingDataMessage.h"
#include "igtlTrackingDataMessage.h"
#ifndef WIN32
#include <unistd.h>
#endif
mitk::IGTLMessageProvider::IGTLMessageProvider()
: mitk::IGTLDeviceSource()
{
this->SetName("IGTLMessageProvider");
//m_MultiThreader = itk::MultiThreader::New();
m_StreamingTimeMutex = itk::FastMutexLock::New();
//m_StopStreamingThreadMutex = itk::FastMutexLock::New();
//m_ThreadId = 0;
m_IsStreaming = false;
// Create a command object. The function will be called later from the main thread
this->m_StopStreamingCommand = ProviderCommand::New();
m_StopStreamingCommand->SetCallbackFunction(this,
&mitk::IGTLMessageProvider::InvokeStopStreamingEvent);
this->m_StreamingCommand = ProviderCommand::New();
m_StreamingCommand->SetCallbackFunction(this,
&mitk::IGTLMessageProvider::InvokeStartStreamingEvent);
}
mitk::IGTLMessageProvider::~IGTLMessageProvider()
{
//// terminate worker thread on destruction
//this->m_StopStreamingThreadMutex->Lock();
//this->m_StopStreamingThread = true;
//this->m_StopStreamingThreadMutex->Unlock();
//if ( m_ThreadId >= 0)
//{
// this->m_MultiThreader->TerminateThread(m_ThreadId);
//}
this->InvokeEvent(StreamingStartRequiredEvent());
}
void mitk::IGTLMessageProvider::Update()
{
Superclass::Update();
if (this->GetInput() != nullptr)
{
igtl::MessageBase::Pointer curMessage = this->GetInput()->GetMessage();
if (dynamic_cast<igtl::TrackingDataMessage*>(curMessage.GetPointer()) != nullptr)
{
igtl::TrackingDataMessage* tdMsg =
(igtl::TrackingDataMessage*)(curMessage.GetPointer());
igtl::TrackingDataElement::Pointer trackingData = igtl::TrackingDataElement::New();
tdMsg->GetTrackingDataElement(0, trackingData);
float x_pos, y_pos, z_pos;
trackingData->GetPosition(&x_pos, &y_pos, &z_pos);
}
}
}
void mitk::IGTLMessageProvider::GenerateData()
{
if (this->m_IGTLDevice.IsNull())
return;
for (unsigned int index = 0; index < this->GetNumberOfIndexedInputs(); index++)
{
- const IGTLMessage* msg = this->GetInput(index);
+ mitk::IGTLMessage::Pointer msg = const_cast<mitk::IGTLMessage*>(this->GetInput(index));
if (msg == nullptr)
{
continue;
}
if ( !msg->IsDataValid() )
{
continue;
}
- igtl::MessageBase::Pointer igtlMsg = msg->GetMessage();
-
- if ( igtlMsg.IsNotNull() )
- {
- //send the message
- this->m_IGTLDevice->SendMessage(igtlMsg);
- }
+ this->m_IGTLDevice->SendMessage(msg);
}
}
void mitk::IGTLMessageProvider::CreateOutputs()
{
//if outputs are set then delete them
if (this->GetNumberOfOutputs() > 0)
{
for (int numOP = this->GetNumberOfOutputs() - 1; numOP >= 0; numOP--)
this->RemoveOutput(numOP);
this->Modified();
}
//fill the outputs if a valid OpenIGTLink device is set
if (m_IGTLDevice.IsNull())
return;
this->SetNumberOfIndexedOutputs(1);
if (this->GetOutput(0) == NULL)
{
DataObjectPointer newOutput = this->MakeOutput(0);
this->SetNthOutput(0, newOutput);
this->Modified();
}
}
//void mitk::IGTLMessageProvider::UpdateOutputInformation()
//{
// this->Modified(); // make sure that we need to be updated
// Superclass::UpdateOutputInformation();
//}
void mitk::IGTLMessageProvider::OnIncomingMessage()
{
}
void mitk::IGTLMessageProvider::OnLostConnection()
{
//in case the provider is streaming at the moment we have to stop it
if (m_IsStreaming)
{
MITK_DEBUG("IGTLMessageProvider") << "lost connection, stop streaming";
this->StopStreamingOfAllSources();
}
}
std::string RemoveRequestPrefixes(std::string requestType)
{
return requestType.substr(4);
}
void mitk::IGTLMessageProvider::OnIncomingCommand()
{
//get the next command
igtl::MessageBase::Pointer curCommand = this->m_IGTLDevice->GetNextCommand();
//extract the type
const char * requestType = curCommand->GetDeviceType();
//check the type
std::string reqType(requestType);
bool isGetMsg = !reqType.find("GET_");
bool isSTTMsg = !reqType.find("STT_");
bool isSTPMsg = !reqType.find("STP_");
bool isRTSMsg = !reqType.find("RTS_");
//get the type from the request type (remove STT_, STP_, GET_, RTS_)
std::string type = RemoveRequestPrefixes(requestType);
//check all microservices if there is a fitting source for the requested type
mitk::IGTLMessageSource::Pointer source = this->GetFittingSource(type.c_str());
//if there is no fitting source return a RTS message, if there is a RTS
//type defined in the message factory send it
if ( source.IsNull() )
{
if ( !this->GetIGTLDevice()->SendRTSMessage(type.c_str()) )
{
//sending RTS message failed, probably because the type is not in the
//message factory
MITK_WARN("IGTLMessageProvider") << "Tried to send a RTS message but did "
"not succeed. Check if this type ( "
<< type << " ) was added to the message "
"factory. ";
}
}
else
{
if ( isGetMsg ) //if it is a single value push it into sending queue
{
//first it is necessary to update the source. This needs additional time
//but is necessary. But are we really allowed to call this here? In which
//thread are we? Is the source thread safe?
source->Update();
mitk::IGTLMessage::Pointer sourceOutput = source->GetOutput();
if (sourceOutput.IsNotNull() && sourceOutput->IsDataValid())
{
- igtl::MessageBase::Pointer sourceMsg = sourceOutput->GetMessage();
if ( source.IsNotNull() )
{
- this->GetIGTLDevice()->SendMessage(sourceMsg);
+ this->GetIGTLDevice()->SendMessage(sourceOutput);
}
}
}
else if ( isSTTMsg )
{
//read the requested frames per second
int fps = 10;
//read the fps from the command
igtl::MessageBase* curCommandPt = curCommand.GetPointer();
if ( std::strcmp( curCommand->GetDeviceType(), "STT_BIND" ) == 0 )
{
fps = ((igtl::StartBindMessage*)curCommandPt)->GetResolution();
}
else if ( std::strcmp( curCommand->GetDeviceType(), "STT_QTDATA" ) == 0 )
{
fps = ((igtl::StartQuaternionTrackingDataMessage*)curCommandPt)->GetResolution();
}
else if ( std::strcmp( curCommand->GetDeviceType(), "STT_TDATA" ) == 0 )
{
fps = ((igtl::StartTrackingDataMessage*)curCommandPt)->GetResolution();
}
this->StartStreamingOfSource(source, fps);
}
else if ( isSTPMsg )
{
this->StopStreamingOfSource(source);
}
else
{
//do nothing
}
}
}
bool mitk::IGTLMessageProvider::IsStreaming()
{
return m_IsStreaming;
}
void mitk::IGTLMessageProvider::StartStreamingOfSource(IGTLMessageSource* src,
unsigned int fps)
{
if ( src == NULL )
return;
//so far the provider allows the streaming of a single source only
//if the streaming thread is already running return a RTS message
if ( !m_IsStreaming )
{
//if it is a stream establish a connection between the provider and the
//source
this->ConnectTo(src);
// calculate the streaming time
this->m_StreamingTimeMutex->Lock();
this->m_StreamingTime = 1.0 / (double) fps * 1000.0;
this->m_StreamingTimeMutex->Unlock();
//// For streaming we need a continues time signal, since there is no timer
//// available we start a thread that generates a timing signal
//// This signal is invoked from the other thread the update of the pipeline
//// has to be executed from the main thread. Thus, we use the
//// callbackfromGUIThread class to pass the execution to the main thread
//this->m_ThreadId = m_MultiThreader->SpawnThread(this->TimerThread, this);
mitk::CallbackFromGUIThread::GetInstance()->CallThisFromGUIThread(
this->m_StreamingCommand);
this->m_IsStreaming = true;
}
else
{
MITK_WARN("IGTLMessageProvider") << "This provider just supports the "
"streaming of one source.";
}
}
void mitk::IGTLMessageProvider::InvokeStartStreamingEvent()
{
this->InvokeEvent(StreamingStartRequiredEvent());
}
void mitk::IGTLMessageProvider::InvokeStopStreamingEvent()
{
this->InvokeEvent(StreamingStopRequiredEvent());
}
void mitk::IGTLMessageProvider::StopStreamingOfSource(IGTLMessageSource* src)
{
//this is something bad!!! The streaming thread has to be stopped before the
//source is disconnected otherwise it can cause a crash. This has to be added!!
this->DisconnectFrom(src);
//this->m_StopStreamingThreadMutex->Lock();
//this->m_StopStreamingThread = true;
//this->m_StopStreamingThreadMutex->Unlock();
mitk::CallbackFromGUIThread::GetInstance()->CallThisFromGUIThread(
this->m_StopStreamingCommand);
//does this flag needs a mutex???
this->m_IsStreaming = false;
}
void mitk::IGTLMessageProvider::StopStreamingOfAllSources()
{
// \todo remove all inputs
mitk::CallbackFromGUIThread::GetInstance()->CallThisFromGUIThread(
this->m_StopStreamingCommand);
//does this flag needs a mutex???
this->m_IsStreaming = false;
}
mitk::IGTLMessageSource::Pointer mitk::IGTLMessageProvider::GetFittingSource(const char* requestedType)
{
//get the context
us::ModuleContext* context = us::GetModuleContext();
//define the interface name
std::string interface = mitk::IGTLMessageSource::US_INTERFACE_NAME;
//specify a filter that defines the requested type
std::string filter = "(" + mitk::IGTLMessageSource::US_PROPKEY_DEVICETYPE +
"=" + requestedType + ")";
//find the fitting service
std::vector<us::ServiceReferenceU> serviceReferences =
context->GetServiceReferences(interface, filter);
//check if a service reference was found. It is also possible that several
//services were found. This is not checked here, just the first one is taken.
if ( serviceReferences.size() )
{
mitk::IGTLMessageSource::Pointer curSource =
context->GetService<mitk::IGTLMessageSource>(serviceReferences.front());
if ( curSource.IsNotNull() )
return curSource;
}
//no service reference was found or found service reference has no valid source
return NULL;
}
-void mitk::IGTLMessageProvider::Send(const mitk::IGTLMessage* msg)
+void mitk::IGTLMessageProvider::Send(mitk::IGTLMessage::Pointer msg)
{
- if (msg != NULL)
+ if (msg != nullptr)
+ {
+ MITK_INFO << "Sending OpenIGTLink Message: " << msg->ToString();
this->m_IGTLDevice->SendMessage(msg);
+ }
}
void
mitk::IGTLMessageProvider::ConnectTo( mitk::IGTLMessageSource* UpstreamFilter )
{
for (DataObjectPointerArraySizeType i = 0;
i < UpstreamFilter->GetNumberOfOutputs(); i++)
{
this->SetInput(i, UpstreamFilter->GetOutput(i));
}
}
void
mitk::IGTLMessageProvider::DisconnectFrom( mitk::IGTLMessageSource* UpstreamFilter )
{
for (DataObjectPointerArraySizeType i = 0;
i < UpstreamFilter->GetNumberOfOutputs(); i++)
{
this->RemoveInput(UpstreamFilter->GetOutput(i));
}
}
//ITK_THREAD_RETURN_TYPE mitk::IGTLMessageProvider::TimerThread(void* pInfoStruct)
//{
// // extract this pointer from thread info structure
// struct itk::MultiThreader::ThreadInfoStruct * pInfo =
// (struct itk::MultiThreader::ThreadInfoStruct*)pInfoStruct;
// mitk::IGTLMessageProvider* thisObject =
// static_cast<mitk::IGTLMessageProvider*>(pInfo->UserData);
//
// itk::SimpleMutexLock mutex;
// mutex.Lock();
//
// thisObject->m_StopStreamingThreadMutex->Lock();
// thisObject->m_StopStreamingThread = false;
// thisObject->m_StopStreamingThreadMutex->Unlock();
//
// thisObject->m_StreamingTimeMutex->Lock();
// unsigned int waitingTime = thisObject->m_StreamingTime;
// thisObject->m_StreamingTimeMutex->Unlock();
//
// while (true)
// {
// thisObject->m_StopStreamingThreadMutex->Lock();
// bool stopThread = thisObject->m_StopStreamingThread;
// thisObject->m_StopStreamingThreadMutex->Unlock();
//
// if (stopThread)
// {
// break;
// }
//
// //wait for the time given
// //I know it is not the nicest solution but we just need an approximate time
// //sleeps for 20 ms
// #if defined (WIN32) || defined (_WIN32)
// Sleep(waitingTime);
// #else
// usleep(waitingTime * 1000);
// #endif
//
// // Ask to execute that command from the GUI thread
// mitk::CallbackFromGUIThread::GetInstance()->CallThisFromGUIThread(
// thisObject->m_StreamingCommand);
// }
//
// thisObject->m_ThreadId = 0;
//
// mutex.Unlock();
//
// return ITK_THREAD_RETURN_VALUE;
//}
diff --git a/Modules/OpenIGTLink/mitkIGTLMessageProvider.h b/Modules/OpenIGTLink/mitkIGTLMessageProvider.h
index 77f2a43cb6..720513c774 100644
--- a/Modules/OpenIGTLink/mitkIGTLMessageProvider.h
+++ b/Modules/OpenIGTLink/mitkIGTLMessageProvider.h
@@ -1,226 +1,228 @@
/*===================================================================
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 IGTLMESSAGEPROVIDER_H_HEADER_INCLUDED_
#define IGTLMESSAGEPROVIDER_H_HEADER_INCLUDED_
#include "mitkIGTLDevice.h"
#include "mitkIGTLDeviceSource.h"
//itk
#include "itkCommand.h"
namespace mitk {
/**
* \brief Provides information/objects from a MITK-Pipeline to other OpenIGTLink
* devices
*
* This class is intended as the drain of the pipeline. Other OpenIGTLink
* devices connect with the IGTLDevice hold by this provider. The other device
* asks for a certain data type. The provider checks if there are other
* IGTLMessageSources available that provide this data type. If yes the provider
* connects with this source and sends the message to the requesting device.
*
* If a STT message was received the provider looks for fitting messageSources.
* Once found it connects with it, starts a timing thread (which updates the
* pipeline) and sends the result to the requesting device.
*
* If a GET message was received the provider just calls an update of the
* found source and sends the result without connecting to the source.
*
* If a STP message was received it stops the thread and disconnects from the
* previous source.
*
* So far the provider can just connect with one source.
*
* \ingroup OpenIGTLink
*/
class MITKOPENIGTLINK_EXPORT IGTLMessageProvider : public IGTLDeviceSource
{
public:
mitkClassMacro(IGTLMessageProvider, IGTLDeviceSource);
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
typedef itk::SimpleMemberCommand<mitk::IGTLMessageProvider> ProviderCommand;
/**
* \brief sends the msg to the requesting client
*
* Note: so far it broadcasts the message to all registered clients
*/
- void Send(const IGTLMessage* msg);
+ void Send(mitk::IGTLMessage::Pointer msg);
/**
* \brief Starts the streaming of the given message source with the given fps.
*/
void StartStreamingOfSource(mitk::IGTLMessageSource* src,
unsigned int fps);
/**
* \brief Stops the streaming of the given message source.
*/
void StopStreamingOfSource(mitk::IGTLMessageSource* src);
/**
* \brief Stops the streaming of all message source.
*/
void StopStreamingOfAllSources();
/**
* \brief Returns the streaming state.
*/
bool IsStreaming();
/**
* \brief Get method for the streaming time
*/
itkGetMacro(StreamingTime, unsigned int);
virtual void Update() override;
protected:
IGTLMessageProvider();
virtual ~IGTLMessageProvider();
/**
* \brief filter execute method
*
* queries the OpenIGTLink device for new messages and updates its output
* igtl::MessageBase objects with it.
* \warning Will raise a std::out_of_range exception, if tools were added to
* the OpenIGTLink device after it was set as input for this filter
*/
virtual void GenerateData() override;
/**
* \brief Create the necessary outputs for the m_IGTLDevice
*
* This Method is called internally whenever outputs need to be reset. Old
* Outputs are deleted when called.
**/
void CreateOutputs();
/**
* \brief This method is called when the IGTL device hold by this class
* receives a new message
**/
virtual void OnIncomingMessage() override;
/**
* \brief This method is called when the IGTL device hold by this class
* receives a new command
**/
virtual void OnIncomingCommand() override;
/**
* \brief This method is called when the IGTL device lost the connection to the other side
**/
virtual void OnLostConnection() override;
/**
*\brief Connects the input of this filter to the outputs of the given
* IGTLMessageSource
*
* This method does not support smartpointer. use FilterX.GetPointer() to
* retrieve a dumbpointer.
*/
void ConnectTo( mitk::IGTLMessageSource* UpstreamFilter );
/**
*\brief Disconnects this filter from the outputs of the given
* IGTLMessageSource
*
* This method does not support smartpointer. use FilterX.GetPointer() to
* retrieve a dumbpointer.
*/
void DisconnectFrom( mitk::IGTLMessageSource* UpstreamFilter );
/**
* \brief Looks for microservices that provide messages with the requested
* type.
**/
mitk::IGTLMessageSource::Pointer GetFittingSource(const char* requestedType);
/** Invokes the start streaming event. This separate method is required, because it
* has to be started from the main thread. (It is used as callback function)
*/
void InvokeStartStreamingEvent();
/** Invokes the stop streaming event. This separate method is required, because it
* has to be started from the main thread. (It is used as callback function)
*/
void InvokeStopStreamingEvent();
private:
/**
* \brief a command that has to be executed in the main thread
*/
ProviderCommand::Pointer m_StreamingCommand;
ProviderCommand::Pointer m_StopStreamingCommand;
///**
// * \brief Timer thread for generating a continuous time signal for the stream
// *
// * Everyt time the time is passed a time signal is invoked.
// *
// * \param pInfoStruct pointer to the mitkIGTLMessageProvider object
// * \return
// */
//static ITK_THREAD_RETURN_TYPE TimerThread(void* pInfoStruct);
//int m_ThreadId;
///** \brief timer thread will terminate after the next wakeup if set to true */
//bool m_StopStreamingThread;
//itk::SmartPointer<itk::MultiThreader> m_MultiThreader;
/** \brief the time used for streaming */
unsigned int m_StreamingTime;
/** \brief mutex for guarding m_Time */
itk::SmartPointer<itk::FastMutexLock> m_StreamingTimeMutex;
///** \brief mutex for guarding m_StopStreamingThread */
//itk::SmartPointer<itk::FastMutexLock> m_StopStreamingThreadMutex;
/** \brief flag to indicate if the provider is streaming */
bool m_IsStreaming;
unsigned long m_LostConnectionObserverTag;
+
+ bool m_LogMessages;
};
/**
* \brief connect to this Event to get notified when a stream is requested
*
* \note It is necessary to do the following things to have streaming support: 1. listen to this
* event. 2. When emitted start a timer with the given interval. 3. In the timeout method of
* this timer call IGTLMessageProvider::Update. 4. Also listen to the StreamingStopRequiredEvent
* and stop the timer imdediately.
* */
itkEventMacro(StreamingStartRequiredEvent, itk::AnyEvent);
/**
* \brief connect to this Event to get notified when a stream shall be stopped
*
* \note It is necessary to connect to this event and stop the streaming timer when called.
* */
itkEventMacro(StreamingStopRequiredEvent, itk::AnyEvent);
} // namespace mitk
#endif /* MITKIGTLMESSAGEPROVIDER_H_HEADER_INCLUDED_ */
diff --git a/Modules/OpenIGTLink/mitkIGTLMessageQueue.cpp b/Modules/OpenIGTLink/mitkIGTLMessageQueue.cpp
index 4d2244067b..d572e1f2bd 100644
--- a/Modules/OpenIGTLink/mitkIGTLMessageQueue.cpp
+++ b/Modules/OpenIGTLink/mitkIGTLMessageQueue.cpp
@@ -1,312 +1,312 @@
/*===================================================================
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.
===================================================================*/
#include "mitkIGTLMessageQueue.h"
#include <string>
#include "igtlMessageBase.h"
-void mitk::IGTLMessageQueue::PushSendMessage(igtl::MessageBase::Pointer message)
+void mitk::IGTLMessageQueue::PushSendMessage(mitk::IGTLMessage::Pointer message)
{
this->m_Mutex->Lock();
if (this->m_BufferingType == IGTLMessageQueue::Infinit)
m_SendQueue.clear();
m_SendQueue.push_back(message);
this->m_Mutex->Unlock();
}
void mitk::IGTLMessageQueue::PushCommandMessage(igtl::MessageBase::Pointer message)
{
this->m_Mutex->Lock();
if (this->m_BufferingType == IGTLMessageQueue::Infinit)
m_CommandQueue.clear();
m_CommandQueue.push_back(message);
this->m_Mutex->Unlock();
}
void mitk::IGTLMessageQueue::PushMessage(igtl::MessageBase::Pointer msg)
{
this->m_Mutex->Lock();
std::stringstream infolog;
infolog << "Received message of type ";
if (dynamic_cast<igtl::TrackingDataMessage*>(msg.GetPointer()) != nullptr)
{
if (this->m_BufferingType == IGTLMessageQueue::Infinit)
m_TrackingDataQueue.clear();
this->m_TrackingDataQueue.push_back(dynamic_cast<igtl::TrackingDataMessage*>(msg.GetPointer()));
infolog << "TDATA";
}
else if (dynamic_cast<igtl::TransformMessage*>(msg.GetPointer()) != nullptr)
{
if (this->m_BufferingType == IGTLMessageQueue::Infinit)
m_TransformQueue.clear();
this->m_TransformQueue.push_back(dynamic_cast<igtl::TransformMessage*>(msg.GetPointer()));
infolog << "TRANSFORM";
}
else if (dynamic_cast<igtl::StringMessage*>(msg.GetPointer()) != nullptr)
{
if (this->m_BufferingType == IGTLMessageQueue::Infinit)
m_StringQueue.clear();
this->m_StringQueue.push_back(dynamic_cast<igtl::StringMessage*>(msg.GetPointer()));
infolog << "STRING";
}
else if (dynamic_cast<igtl::ImageMessage*>(msg.GetPointer()) != nullptr)
{
igtl::ImageMessage::Pointer imageMsg = dynamic_cast<igtl::ImageMessage*>(msg.GetPointer());
int* dim = new int[3];
imageMsg->GetDimensions(dim);
if (dim[2] > 1)
{
if (this->m_BufferingType == IGTLMessageQueue::Infinit)
m_Image3dQueue.clear();
this->m_Image3dQueue.push_back(dynamic_cast<igtl::ImageMessage*>(msg.GetPointer()));
infolog << "IMAGE3D";
}
else
{
if (this->m_BufferingType == IGTLMessageQueue::Infinit)
m_Image2dQueue.clear();
this->m_Image2dQueue.push_back(dynamic_cast<igtl::ImageMessage*>(msg.GetPointer()));
infolog << "IMAGE2D";
}
}
else
{
if (this->m_BufferingType == IGTLMessageQueue::Infinit)
m_MiscQueue.clear();
this->m_MiscQueue.push_back(msg);
infolog << "OTHER";
}
m_Latest_Message = msg;
//MITK_INFO << infolog.str();
this->m_Mutex->Unlock();
}
-igtl::MessageBase::Pointer mitk::IGTLMessageQueue::PullSendMessage()
+mitk::IGTLMessage::Pointer mitk::IGTLMessageQueue::PullSendMessage()
{
- igtl::MessageBase::Pointer ret = nullptr;
+ mitk::IGTLMessage::Pointer ret = nullptr;
this->m_Mutex->Lock();
if (this->m_SendQueue.size() > 0)
{
ret = this->m_SendQueue.front();
this->m_SendQueue.pop_front();
}
this->m_Mutex->Unlock();
return ret;
}
igtl::MessageBase::Pointer mitk::IGTLMessageQueue::PullMiscMessage()
{
igtl::MessageBase::Pointer ret = nullptr;
this->m_Mutex->Lock();
if (this->m_MiscQueue.size() > 0)
{
ret = this->m_MiscQueue.front();
this->m_MiscQueue.pop_front();
}
this->m_Mutex->Unlock();
return ret;
}
igtl::ImageMessage::Pointer mitk::IGTLMessageQueue::PullImage2dMessage()
{
igtl::ImageMessage::Pointer ret = nullptr;
this->m_Mutex->Lock();
if (this->m_Image2dQueue.size() > 0)
{
ret = this->m_Image2dQueue.front();
this->m_Image2dQueue.pop_front();
}
this->m_Mutex->Unlock();
return ret;
}
igtl::ImageMessage::Pointer mitk::IGTLMessageQueue::PullImage3dMessage()
{
igtl::ImageMessage::Pointer ret = nullptr;
this->m_Mutex->Lock();
if (this->m_Image3dQueue.size() > 0)
{
ret = this->m_Image3dQueue.front();
this->m_Image3dQueue.pop_front();
}
this->m_Mutex->Unlock();
return ret;
}
igtl::TrackingDataMessage::Pointer mitk::IGTLMessageQueue::PullTrackingMessage()
{
igtl::TrackingDataMessage::Pointer ret = nullptr;
this->m_Mutex->Lock();
if (this->m_TrackingDataQueue.size() > 0)
{
ret = this->m_TrackingDataQueue.front();
this->m_TrackingDataQueue.pop_front();
}
this->m_Mutex->Unlock();
return ret;
}
igtl::MessageBase::Pointer mitk::IGTLMessageQueue::PullCommandMessage()
{
igtl::MessageBase::Pointer ret = nullptr;
this->m_Mutex->Lock();
if (this->m_CommandQueue.size() > 0)
{
ret = this->m_CommandQueue.front();
this->m_CommandQueue.pop_front();
}
this->m_Mutex->Unlock();
return ret;
}
igtl::StringMessage::Pointer mitk::IGTLMessageQueue::PullStringMessage()
{
igtl::StringMessage::Pointer ret = nullptr;
this->m_Mutex->Lock();
if (this->m_StringQueue.size() > 0)
{
ret = this->m_StringQueue.front();
this->m_StringQueue.pop_front();
}
this->m_Mutex->Unlock();
return ret;
}
igtl::TransformMessage::Pointer mitk::IGTLMessageQueue::PullTransformMessage()
{
igtl::TransformMessage::Pointer ret = nullptr;
this->m_Mutex->Lock();
if (this->m_TransformQueue.size() > 0)
{
ret = this->m_TransformQueue.front();
this->m_TransformQueue.pop_front();
}
this->m_Mutex->Unlock();
return ret;
}
std::string mitk::IGTLMessageQueue::GetNextMsgInformationString()
{
this->m_Mutex->Lock();
std::stringstream s;
if (this->m_Latest_Message != nullptr)
{
s << "Device Type: " << this->m_Latest_Message->GetDeviceType() << std::endl;
s << "Device Name: " << this->m_Latest_Message->GetDeviceName() << std::endl;
}
else
{
s << "No Msg";
}
this->m_Mutex->Unlock();
return s.str();
}
std::string mitk::IGTLMessageQueue::GetNextMsgDeviceType()
{
this->m_Mutex->Lock();
std::stringstream s;
if (m_Latest_Message != nullptr)
{
s << this->m_Latest_Message->GetDeviceType();
}
else
{
s << "";
}
this->m_Mutex->Unlock();
return s.str();
}
std::string mitk::IGTLMessageQueue::GetLatestMsgInformationString()
{
this->m_Mutex->Lock();
std::stringstream s;
if (m_Latest_Message != nullptr)
{
s << "Device Type: " << this->m_Latest_Message->GetDeviceType() << std::endl;
s << "Device Name: " << this->m_Latest_Message->GetDeviceName() << std::endl;
}
else
{
s << "No Msg";
}
this->m_Mutex->Unlock();
return s.str();
}
std::string mitk::IGTLMessageQueue::GetLatestMsgDeviceType()
{
this->m_Mutex->Lock();
std::stringstream s;
if (m_Latest_Message != nullptr)
{
s << this->m_Latest_Message->GetDeviceType();
}
else
{
s << "";
}
this->m_Mutex->Unlock();
return s.str();
}
int mitk::IGTLMessageQueue::GetSize()
{
return (this->m_CommandQueue.size() + this->m_Image2dQueue.size() + this->m_Image3dQueue.size() + this->m_MiscQueue.size()
+ this->m_StringQueue.size() + this->m_TrackingDataQueue.size() + this->m_TransformQueue.size());
}
void mitk::IGTLMessageQueue::EnableInfiniteBuffering(bool enable)
{
this->m_Mutex->Lock();
if (enable)
this->m_BufferingType = IGTLMessageQueue::BufferingType::Infinit;
else
this->m_BufferingType = IGTLMessageQueue::BufferingType::NoBuffering;
this->m_Mutex->Unlock();
}
mitk::IGTLMessageQueue::IGTLMessageQueue()
{
this->m_Mutex = itk::FastMutexLock::New();
this->m_BufferingType = IGTLMessageQueue::Infinit;
}
mitk::IGTLMessageQueue::~IGTLMessageQueue()
{
this->m_Mutex->Unlock();
-}
\ No newline at end of file
+}
diff --git a/Modules/OpenIGTLink/mitkIGTLMessageQueue.h b/Modules/OpenIGTLink/mitkIGTLMessageQueue.h
index 367d46c865..2a9c22921d 100644
--- a/Modules/OpenIGTLink/mitkIGTLMessageQueue.h
+++ b/Modules/OpenIGTLink/mitkIGTLMessageQueue.h
@@ -1,144 +1,145 @@
/*===================================================================
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 IGTLMessageQueue_H
#define IGTLMessageQueue_H
#include "MitkOpenIGTLinkExports.h"
#include "itkObject.h"
#include "itkFastMutexLock.h"
#include "mitkCommon.h"
#include <deque>
+#include <mitkIGTLMessage.h>
//OpenIGTLink
#include "igtlMessageBase.h"
#include "igtlImageMessage.h"
#include "igtlStringMessage.h"
#include "igtlTrackingDataMessage.h"
#include "igtlTransformMessage.h"
namespace mitk {
/**
* \class IGTLMessageQueue
* \brief Thread safe message queue to store OpenIGTLink messages.
*
* \ingroup OpenIGTLink
*/
class MITKOPENIGTLINK_EXPORT IGTLMessageQueue : public itk::Object
{
public:
mitkClassMacroItkParent(mitk::IGTLMessageQueue, itk::Object)
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
/**
* \brief Different buffering types
* Infinit buffering means that you can push as many messages as you want
* NoBuffering means that the queue just stores a single message
*/
enum BufferingType { Infinit, NoBuffering };
- void PushSendMessage(igtl::MessageBase::Pointer message);
+ void PushSendMessage(mitk::IGTLMessage::Pointer message);
/**
* \brief Adds the message to the queue
*/
void PushMessage(igtl::MessageBase::Pointer message);
/**
* \brief Adds the message to the queue
*/
void PushCommandMessage(igtl::MessageBase::Pointer message);
/**
* \brief Returns and removes the oldest message from the queue
*/
igtl::MessageBase::Pointer PullMiscMessage();
igtl::ImageMessage::Pointer PullImage2dMessage();
igtl::ImageMessage::Pointer PullImage3dMessage();
igtl::TrackingDataMessage::Pointer PullTrackingMessage();
igtl::MessageBase::Pointer PullCommandMessage();
igtl::StringMessage::Pointer PullStringMessage();
igtl::TransformMessage::Pointer PullTransformMessage();
- igtl::MessageBase::Pointer PullSendMessage();
+ mitk::IGTLMessage::Pointer PullSendMessage();
/**
* \brief Get the number of messages in the queue
*/
int GetSize();
/**
* \brief Returns a string with information about the oldest message in the
* queue
*/
std::string GetNextMsgInformationString();
/**
* \brief Returns the device type of the oldest message in the queue
*/
std::string GetNextMsgDeviceType();
/**
* \brief Returns a string with information about the oldest message in the
* queue
*/
std::string GetLatestMsgInformationString();
/**
* \brief Returns the device type of the oldest message in the queue
*/
std::string GetLatestMsgDeviceType();
/**
* \brief Sets infinite buffering on/off.
* Initiale value is enabled.
*/
void EnableInfiniteBuffering(bool enable);
protected:
IGTLMessageQueue();
virtual ~IGTLMessageQueue();
protected:
/**
* \brief Mutex to take car of the queue
*/
itk::FastMutexLock::Pointer m_Mutex;
/**
* \brief the queue that stores pointer to the inserted messages
*/
std::deque< igtl::MessageBase::Pointer > m_CommandQueue;
std::deque< igtl::ImageMessage::Pointer > m_Image2dQueue;
std::deque< igtl::ImageMessage::Pointer > m_Image3dQueue;
std::deque< igtl::TransformMessage::Pointer > m_TransformQueue;
std::deque< igtl::TrackingDataMessage::Pointer > m_TrackingDataQueue;
std::deque< igtl::StringMessage::Pointer > m_StringQueue;
std::deque< igtl::MessageBase::Pointer > m_MiscQueue;
- std::deque< igtl::MessageBase::Pointer> m_SendQueue;
+ std::deque< mitk::IGTLMessage::Pointer > m_SendQueue;
igtl::MessageBase::Pointer m_Latest_Message;
/**
* \brief defines the kind of buffering
*/
BufferingType m_BufferingType;
};
}
#endif
diff --git a/Modules/OpenIGTLink/mitkIGTLServer.cpp b/Modules/OpenIGTLink/mitkIGTLServer.cpp
index bafb56e16b..610bcbb1c0 100644
--- a/Modules/OpenIGTLink/mitkIGTLServer.cpp
+++ b/Modules/OpenIGTLink/mitkIGTLServer.cpp
@@ -1,218 +1,216 @@
/*===================================================================
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.
===================================================================*/
#include "mitkIGTLServer.h"
#include <stdio.h>
#include <itksys/SystemTools.hxx>
#include <itkMutexLockHolder.h>
#include <igtlServerSocket.h>
#include <igtlTrackingDataMessage.h>
#include <igtlImageMessage.h>
#include <igtl_status.h>
mitk::IGTLServer::IGTLServer(bool ReadFully) :
IGTLDevice(ReadFully)
{
m_ReceiveListMutex = itk::FastMutexLock::New();
m_SentListMutex = itk::FastMutexLock::New();
}
mitk::IGTLServer::~IGTLServer()
{
m_ReceiveListMutex = nullptr;
m_SentListMutex = nullptr;
}
bool mitk::IGTLServer::OpenConnection()
{
if (this->GetState() != Setup)
{
mitkThrowException(mitk::Exception) <<
"Can only try to create a server if in setup mode";
return false;
}
int portNumber = this->GetPortNumber();
if (portNumber == -1)
{
//port number was not correct
return false;
}
//create a new server socket
m_Socket = igtl::ServerSocket::New();
//try to create the igtl server
int response = dynamic_cast<igtl::ServerSocket*>(m_Socket.GetPointer())->
CreateServer(portNumber);
//check the response
if (response != 0)
{
mitkThrowException(mitk::Exception) <<
"The server could not be created. Port: " << portNumber;
return false;
}
// everything is initialized and connected so the communication can be started
this->SetState(Ready);
return true;
}
bool mitk::IGTLServer::CloseConnection()
{
//remove all registered clients
m_SentListMutex->Lock();
m_ReceiveListMutex->Lock();
SocketListType allRegisteredSockets(m_RegisteredClients);
m_SentListMutex->Unlock();
m_ReceiveListMutex->Unlock();
this->StopCommunicationWithSocket(allRegisteredSockets);
return mitk::IGTLDevice::CloseConnection();
}
void mitk::IGTLServer::Connect()
{
igtl::Socket::Pointer socket;
//check if another igtl device wants to connect to this socket
socket =
((igtl::ServerSocket*)(this->m_Socket.GetPointer()))->WaitForConnection(1);
//if there is a new connection the socket is not null
if (socket.IsNotNull())
{
//add the new client socket to the list of registered clients
m_SentListMutex->Lock();
m_ReceiveListMutex->Lock();
this->m_RegisteredClients.push_back(socket);
m_SentListMutex->Unlock();
m_ReceiveListMutex->Unlock();
//inform observers about this new client
this->InvokeEvent(NewClientConnectionEvent());
MITK_INFO("IGTLServer") << "Connected to a new client: " << socket;
}
}
void mitk::IGTLServer::Receive()
{
unsigned int status = IGTL_STATUS_OK;
SocketListType socketsToBeRemoved;
//the server can be connected with several clients, therefore it has to check
//all registered clients
SocketListIteratorType it;
m_ReceiveListMutex->Lock();
auto it_end = this->m_RegisteredClients.end();
for (it = this->m_RegisteredClients.begin(); it != it_end; ++it)
{
//it is possible that ReceivePrivate detects that the current socket is
//already disconnected. Therefore, it is necessary to remove this socket
//from the registered clients list
status = this->ReceivePrivate(*it);
if (status == IGTL_STATUS_NOT_PRESENT)
{
//remember this socket for later, it is not a good idea to remove it
//from the list directly because we iterate over the list at this point
socketsToBeRemoved.push_back(*it);
MITK_WARN("IGTLServer") << "Lost connection to a client socket. ";
}
else if (status != 1)
{
- MITK_WARN("IGTLServer") << "IGTL Message with status: " << status;
+ MITK_DEBUG("IGTLServer") << "IGTL Message with status: " << status;
}
}
m_ReceiveListMutex->Unlock();
if (socketsToBeRemoved.size() > 0)
{
//remove the sockets that are not connected anymore
this->StopCommunicationWithSocket(socketsToBeRemoved);
//inform observers about loosing the connection to these sockets
this->InvokeEvent(LostConnectionEvent());
}
}
void mitk::IGTLServer::Send()
{
- igtl::MessageBase::Pointer curMessage;
-
//get the latest message from the queue
- curMessage = this->m_MessageQueue->PullSendMessage();
+ mitk::IGTLMessage::Pointer curMessage = this->m_MessageQueue->PullSendMessage();
// there is no message => return
if (curMessage.IsNull())
return;
//the server can be connected with several clients, therefore it has to check
//all registered clients
//sending a message to all registered clients might not be the best solution,
//it could be better to store the client together with the requested type. Then
//the data would be send to the appropriate client and to noone else.
//(I know it is no excuse but PLUS is doing exactly the same, they broadcast
//everything)
m_SentListMutex->Lock();
SocketListIteratorType it;
auto it_end =
this->m_RegisteredClients.end();
for (it = this->m_RegisteredClients.begin(); it != it_end; ++it)
{
//maybe there should be a check here if the current socket is still active
- this->SendMessagePrivate(curMessage.GetPointer(), *it);
+ this->SendMessagePrivate(curMessage, *it);
MITK_DEBUG("IGTLServer") << "Sent IGTL Message";
}
m_SentListMutex->Unlock();
}
void mitk::IGTLServer::StopCommunicationWithSocket(
SocketListType& toBeRemovedSockets)
{
for (auto i = toBeRemovedSockets.begin(); i != toBeRemovedSockets.end(); i++)
this->StopCommunicationWithSocket(*i);
}
void mitk::IGTLServer::StopCommunicationWithSocket(igtl::Socket* client)
{
m_SentListMutex->Lock();
m_ReceiveListMutex->Lock();
auto i = m_RegisteredClients.begin();
auto end = m_RegisteredClients.end();
while (i != end)
{
if ((*i) == client)
{
// //close the socket
(*i)->CloseSocket();
//and remove it from the list
i = this->m_RegisteredClients.erase(i);
MITK_INFO("IGTLServer") << "Removed client socket from server client list.";
break;
}
else
{
++i;
}
}
m_SentListMutex->Unlock();
m_ReceiveListMutex->Unlock();
}
unsigned int mitk::IGTLServer::GetNumberOfConnections()
{
return this->m_RegisteredClients.size();
}
diff --git a/Modules/OpenIGTLinkUI/Qmitk/QmitkIGTLDeviceCommandWidget.cpp b/Modules/OpenIGTLinkUI/Qmitk/QmitkIGTLDeviceCommandWidget.cpp
index 1f99fadace..075e100236 100644
--- a/Modules/OpenIGTLinkUI/Qmitk/QmitkIGTLDeviceCommandWidget.cpp
+++ b/Modules/OpenIGTLinkUI/Qmitk/QmitkIGTLDeviceCommandWidget.cpp
@@ -1,293 +1,293 @@
/*===================================================================
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.
===================================================================*/
#include "QmitkIGTLDeviceCommandWidget.h"
//mitk headers
#include <mitkSurface.h>
#include <mitkIGTLDeviceSource.h>
#include <mitkDataStorage.h>
#include <mitkIGTLMessageFactory.h>
//qt headers
#include <qfiledialog.h>
#include <qinputdialog.h>
#include <qmessagebox.h>
#include <qscrollbar.h>
//igtl
#include <igtlStringMessage.h>
#include <igtlBindMessage.h>
#include <igtlQuaternionTrackingDataMessage.h>
#include <igtlTrackingDataMessage.h>
//poco headers
#include <Poco/Path.h>
const std::string QmitkIGTLDeviceCommandWidget::VIEW_ID =
"org.mitk.views.igtldevicesourcemanagementwidget";
QmitkIGTLDeviceCommandWidget::QmitkIGTLDeviceCommandWidget(
QWidget* parent, Qt::WindowFlags f)
: QWidget(parent, f), m_IsClient(false), m_MessageReceivedObserverTag(0), m_CommandReceivedObserverTag(0), m_LostConnectionObserverTag(0), m_NewConnectionObserverTag(0), m_StateModifiedObserverTag(0)
{
m_Controls = NULL;
this->m_IGTLDevice = NULL;
CreateQtPartControl(this);
}
QmitkIGTLDeviceCommandWidget::~QmitkIGTLDeviceCommandWidget()
{
if (m_MessageReceivedObserverTag) this->m_IGTLDevice->RemoveObserver(m_MessageReceivedObserverTag);
if (m_CommandReceivedObserverTag) this->m_IGTLDevice->RemoveObserver(m_CommandReceivedObserverTag);
if (m_LostConnectionObserverTag) this->m_IGTLDevice->RemoveObserver(m_LostConnectionObserverTag);
if (m_NewConnectionObserverTag) this->m_IGTLDevice->RemoveObserver(m_NewConnectionObserverTag);
if (m_StateModifiedObserverTag) this->m_IGTLDevice->RemoveObserver(m_StateModifiedObserverTag);
}
void QmitkIGTLDeviceCommandWidget::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkIGTLDeviceCommandWidgetControls;
// setup GUI widgets
m_Controls->setupUi(parent);
}
//connect slots with signals
CreateConnections();
}
void QmitkIGTLDeviceCommandWidget::CreateConnections()
{
if (m_Controls)
{
// connect the widget items with the methods
connect( m_Controls->butSendCommand, SIGNAL(clicked()),
this, SLOT(OnSendCommand()));
connect( m_Controls->commandsComboBox,
SIGNAL(currentIndexChanged(const QString &)),
this, SLOT(OnCommandChanged(const QString &)));
}
//this is used for thread seperation, otherwise the worker thread would change the ui elements
//which would cause an exception
connect(this, SIGNAL(AdaptGUIToStateSignal()), this, SLOT(AdaptGUIToState()));
}
void QmitkIGTLDeviceCommandWidget::OnDeviceStateChanged()
{
//this->AdaptGUIToState();
emit AdaptGUIToStateSignal();
}
void QmitkIGTLDeviceCommandWidget::AdaptGUIToState()
{
if (this->m_IGTLDevice.IsNotNull())
{
//check the state of the device
mitk::IGTLDevice::IGTLDeviceState state = this->m_IGTLDevice->GetState();
switch (state) {
case mitk::IGTLDevice::Setup:
this->m_Controls->commandsComboBox->setEnabled(false);
this->m_Controls->butSendCommand->setEnabled(false);
this->m_Controls->fpsSpinBox->setEnabled(false);
break;
case mitk::IGTLDevice::Ready:
this->m_Controls->commandsComboBox->setEnabled(true);
this->m_Controls->butSendCommand->setEnabled(true);
this->m_Controls->fpsSpinBox->setEnabled(false);
break;
case mitk::IGTLDevice::Running:
if ( this->m_IGTLDevice->GetNumberOfConnections() == 0 )
{
//just a server can run and have 0 connections
this->m_Controls->butSendCommand->setEnabled(false);
this->m_Controls->fpsSpinBox->setEnabled(false);
this->m_Controls->commandsComboBox->setEnabled(false);
}
else
{
this->m_Controls->commandsComboBox->setEnabled(true);
this->m_Controls->butSendCommand->setEnabled(true);
// this->m_Controls->fpsSpinBox->setEnabled(true);
}
break;
default:
mitkThrow() << "Invalid Device State";
break;
}
}
else
{
this->DisableSourceControls();
}
}
void QmitkIGTLDeviceCommandWidget::Initialize(mitk::IGTLDevice::Pointer device)
{
//reset the GUI
DisableSourceControls();
//reset the observers
if ( this->m_IGTLDevice.IsNotNull() )
{
this->m_IGTLDevice->RemoveObserver(m_MessageReceivedObserverTag);
this->m_IGTLDevice->RemoveObserver(m_CommandReceivedObserverTag);
this->m_IGTLDevice->RemoveObserver(m_LostConnectionObserverTag);
this->m_IGTLDevice->RemoveObserver(m_NewConnectionObserverTag);
this->m_IGTLDevice->RemoveObserver(m_StateModifiedObserverTag);
}
if(device.IsNotNull())
{
//get the device
this->m_IGTLDevice = device;
//check if the device is a server or a client
if ( dynamic_cast<mitk::IGTLClient*>(
this->m_IGTLDevice.GetPointer()) == NULL )
{
m_IsClient = false;
}
else
{
m_IsClient = true;
}
typedef itk::SimpleMemberCommand< QmitkIGTLDeviceCommandWidget > CurCommandType;
// CurCommandType::Pointer messageReceivedCommand = CurCommandType::New();
// messageReceivedCommand->SetCallbackFunction(
// this, &QmitkIGTLDeviceCommandWidget::OnMessageReceived );
// this->m_MessageReceivedObserverTag =
// this->m_IGTLDevice->AddObserver(mitk::MessageReceivedEvent(), messageReceivedCommand);
// CurCommandType::Pointer commandReceivedCommand = CurCommandType::New();
// commandReceivedCommand->SetCallbackFunction(
// this, &QmitkIGTLDeviceCommandWidget::OnCommandReceived );
// this->m_CommandReceivedObserverTag =
// this->m_IGTLDevice->AddObserver(mitk::CommandReceivedEvent(), commandReceivedCommand);
CurCommandType::Pointer connectionLostCommand = CurCommandType::New();
connectionLostCommand->SetCallbackFunction(
this, &QmitkIGTLDeviceCommandWidget::OnLostConnection );
this->m_LostConnectionObserverTag = this->m_IGTLDevice->AddObserver(
mitk::LostConnectionEvent(), connectionLostCommand);
CurCommandType::Pointer newConnectionCommand = CurCommandType::New();
newConnectionCommand->SetCallbackFunction(
this, &QmitkIGTLDeviceCommandWidget::OnNewConnection );
this->m_NewConnectionObserverTag = this->m_IGTLDevice->AddObserver(
mitk::NewClientConnectionEvent(), newConnectionCommand);
CurCommandType::Pointer stateModifiedCommand = CurCommandType::New();
stateModifiedCommand->SetCallbackFunction(
this, &QmitkIGTLDeviceCommandWidget::OnDeviceStateChanged );
this->m_StateModifiedObserverTag = this->m_IGTLDevice->AddObserver(
itk::ModifiedEvent(), stateModifiedCommand);
//Fill the commands combo box with all available commands
FillCommandsComboBox();
}
else
{
m_IGTLDevice = NULL;
}
this->AdaptGUIToState();
}
void QmitkIGTLDeviceCommandWidget::DisableSourceControls()
{
this->m_Controls->commandsComboBox->setEnabled(false);
this->m_Controls->butSendCommand->setEnabled(false);
this->m_Controls->fpsSpinBox->setEnabled(false);
}
void QmitkIGTLDeviceCommandWidget::OnSendCommand()
{
//Set the frames per second of the current command in case of a STT_ command
if ( std::strcmp( m_CurrentCommand->GetDeviceType(), "STT_BIND" ) == 0 )
{
((igtl::StartBindMessage*)this->m_CurrentCommand.GetPointer())->
SetResolution(this->m_Controls->fpsSpinBox->value());
}
else if ( std::strcmp( m_CurrentCommand->GetDeviceType(), "STT_QTDATA" ) == 0 )
{
((igtl::StartQuaternionTrackingDataMessage*)m_CurrentCommand.GetPointer())->
SetResolution(this->m_Controls->fpsSpinBox->value());
}
else if ( std::strcmp( m_CurrentCommand->GetDeviceType(), "STT_TDATA" ) == 0 )
{
((igtl::StartTrackingDataMessage*)this->m_CurrentCommand.GetPointer())->
SetResolution(this->m_Controls->fpsSpinBox->value());
}
- m_IGTLDevice->SendMessage(m_CurrentCommand.GetPointer());
+ m_IGTLDevice->SendMessage(mitk::IGTLMessage::New(m_CurrentCommand, ""));
}
void QmitkIGTLDeviceCommandWidget::OnCommandChanged(
const QString & curCommand)
{
if ( curCommand.isEmpty() )
return;
mitk::IGTLMessageFactory::Pointer msgFactory =
this->m_IGTLDevice->GetMessageFactory();
//create a new message that fits to the selected get message type command
this->m_CurrentCommand = msgFactory->CreateInstance( curCommand.toStdString());
//enable/disable the FPS spinbox
this->m_Controls->fpsSpinBox->setEnabled(curCommand.contains("STT_"));
}
void QmitkIGTLDeviceCommandWidget::OnLostConnection()
{
//get the IGTL device that invoked this event
// mitk::IGTLDevice* dev = (mitk::IGTLDevice*)caller;
//this->AdaptGUIToState();
emit AdaptGUIToStateSignal();
}
void QmitkIGTLDeviceCommandWidget::OnNewConnection()
{
//this->AdaptGUIToState();
emit AdaptGUIToStateSignal();
}
void QmitkIGTLDeviceCommandWidget::FillCommandsComboBox()
{
//load the msg factory from the client (maybe this will be moved later on)
mitk::IGTLMessageFactory::Pointer msgFactory =
this->m_IGTLDevice->GetMessageFactory();
//get the available commands as std::list<std::string>
std::list<std::string> commandsList_ =
msgFactory->GetAvailableMessageRequestTypes();
//create a string list to convert the std::list
this->m_Controls->commandsComboBox->clear();
while ( commandsList_.size() )
{
//fill the combo box with life
this->m_Controls->commandsComboBox->addItem(
QString::fromStdString(commandsList_.front()));
commandsList_.pop_front();
}
}
diff --git a/Modules/OpenIGTLinkUI/Qmitk/QmitkIGTLDeviceSourceManagementWidget.cpp b/Modules/OpenIGTLinkUI/Qmitk/QmitkIGTLDeviceSourceManagementWidget.cpp
index 4cacacd062..5b9e328186 100644
--- a/Modules/OpenIGTLinkUI/Qmitk/QmitkIGTLDeviceSourceManagementWidget.cpp
+++ b/Modules/OpenIGTLinkUI/Qmitk/QmitkIGTLDeviceSourceManagementWidget.cpp
@@ -1,246 +1,246 @@
/*===================================================================
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.
===================================================================*/
#include "QmitkIGTLDeviceSourceManagementWidget.h"
//mitk headers
#include <mitkSurface.h>
#include <mitkIGTLDeviceSource.h>
#include <mitkDataStorage.h>
#include <mitkIGTLMessageFactory.h>
//qt headers
#include <qfiledialog.h>
#include <qinputdialog.h>
#include <qmessagebox.h>
#include <qscrollbar.h>
//igtl
#include <igtlStringMessage.h>
#include <igtlBindMessage.h>
#include <igtlQuaternionTrackingDataMessage.h>
#include <igtlTrackingDataMessage.h>
//poco headers
#include <Poco/Path.h>
const std::string QmitkIGTLDeviceSourceManagementWidget::VIEW_ID =
"org.mitk.views.igtldevicesourcemanagementwidget";
QmitkIGTLDeviceSourceManagementWidget::QmitkIGTLDeviceSourceManagementWidget(
QWidget* parent, Qt::WindowFlags f)
: QWidget(parent, f), m_IsClient(false), m_MessageReceivedObserverTag(0), m_CommandReceivedObserverTag(0), m_LostConnectionObserverTag(0), m_NewConnectionObserverTag(0), m_StateModifiedObserverTag(0)
{
m_Controls = NULL;
this->m_IGTLDevice = NULL;
CreateQtPartControl(this);
}
QmitkIGTLDeviceSourceManagementWidget::~QmitkIGTLDeviceSourceManagementWidget()
{
if (m_MessageReceivedObserverTag) this->m_IGTLDevice->RemoveObserver(m_MessageReceivedObserverTag);
if (m_CommandReceivedObserverTag) this->m_IGTLDevice->RemoveObserver(m_CommandReceivedObserverTag);
if (m_LostConnectionObserverTag) this->m_IGTLDevice->RemoveObserver(m_LostConnectionObserverTag);
if (m_NewConnectionObserverTag) this->m_IGTLDevice->RemoveObserver(m_NewConnectionObserverTag);
if (m_StateModifiedObserverTag) this->m_IGTLDevice->RemoveObserver(m_StateModifiedObserverTag);
}
void QmitkIGTLDeviceSourceManagementWidget::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkIGTLDeviceSourceManagementWidgetControls;
// setup GUI widgets
m_Controls->setupUi(parent);
}
//connect slots with signals
CreateConnections();
}
void QmitkIGTLDeviceSourceManagementWidget::CreateConnections()
{
if (m_Controls)
{
connect( m_Controls->butSend, SIGNAL(clicked()),
this, SLOT(OnSendMessage()));
}
//this is used for thread seperation, otherwise the worker thread would change the ui elements
//which would cause an exception
connect(this, SIGNAL(AdaptGUIToStateSignal()), this, SLOT(AdaptGUIToState()));
}
void QmitkIGTLDeviceSourceManagementWidget::OnDeviceStateChanged()
{
emit AdaptGUIToStateSignal();
}
void QmitkIGTLDeviceSourceManagementWidget::AdaptGUIToState()
{
if (this->m_IGTLDeviceSource.IsNotNull())
{
//check the state of the device
mitk::IGTLDevice::IGTLDeviceState state =
this->m_IGTLDeviceSource->GetIGTLDevice()->GetState();
switch (state) {
case mitk::IGTLDevice::Setup:
this->m_Controls->editSend->setEnabled(false);
this->m_Controls->butSend->setEnabled(false);
break;
case mitk::IGTLDevice::Ready:
this->m_Controls->editSend->setEnabled(false);
this->m_Controls->butSend->setEnabled(false);
break;
case mitk::IGTLDevice::Running:
if ( this->m_IGTLDevice->GetNumberOfConnections() == 0 )
{
//just a server can run and have 0 connections
this->m_Controls->editSend->setEnabled(false);
this->m_Controls->butSend->setEnabled(false);
}
else
{
this->m_Controls->editSend->setEnabled(true);
this->m_Controls->butSend->setEnabled(true);
}
break;
default:
mitkThrow() << "Invalid Device State";
break;
}
m_Controls->selectedSourceLabel->setText(
m_IGTLDeviceSource->GetName().c_str());
}
else
{
this->DisableSourceControls();
}
}
void QmitkIGTLDeviceSourceManagementWidget::LoadSource(
mitk::IGTLDeviceSource::Pointer sourceToLoad)
{
//reset the GUI
DisableSourceControls();
//reset the observers
if ( this->m_IGTLDevice.IsNotNull() )
{
if (m_MessageReceivedObserverTag) this->m_IGTLDevice->RemoveObserver(m_MessageReceivedObserverTag);
if (m_CommandReceivedObserverTag) this->m_IGTLDevice->RemoveObserver(m_CommandReceivedObserverTag);
if (m_LostConnectionObserverTag) this->m_IGTLDevice->RemoveObserver(m_LostConnectionObserverTag);
if (m_NewConnectionObserverTag) this->m_IGTLDevice->RemoveObserver(m_NewConnectionObserverTag);
if (m_StateModifiedObserverTag) this->m_IGTLDevice->RemoveObserver(m_StateModifiedObserverTag);
}
if(sourceToLoad.IsNotNull())
{
this->m_IGTLDeviceSource = sourceToLoad;
//get the device
this->m_IGTLDevice = this->m_IGTLDeviceSource->GetIGTLDevice();
//initialize the other GUI elements
this->m_Controls->connectionSetupWidget->Initialize(this->m_IGTLDevice);
this->m_Controls->commandWidget->Initialize(this->m_IGTLDevice);
//check if the device is a server or a client
if ( dynamic_cast<mitk::IGTLClient*>(
this->m_IGTLDeviceSource->GetIGTLDevice()) == NULL )
{
m_IsClient = false;
}
else
{
m_IsClient = true;
}
typedef itk::SimpleMemberCommand< QmitkIGTLDeviceSourceManagementWidget > CurCommandType;
CurCommandType::Pointer messageReceivedCommand = CurCommandType::New();
messageReceivedCommand->SetCallbackFunction(
this, &QmitkIGTLDeviceSourceManagementWidget::OnMessageReceived );
this->m_MessageReceivedObserverTag =
this->m_IGTLDevice->AddObserver(mitk::MessageReceivedEvent(), messageReceivedCommand);
CurCommandType::Pointer commandReceivedCommand = CurCommandType::New();
commandReceivedCommand->SetCallbackFunction(
this, &QmitkIGTLDeviceSourceManagementWidget::OnCommandReceived );
this->m_CommandReceivedObserverTag =
this->m_IGTLDevice->AddObserver(mitk::CommandReceivedEvent(), commandReceivedCommand);
CurCommandType::Pointer connectionLostCommand = CurCommandType::New();
connectionLostCommand->SetCallbackFunction(
this, &QmitkIGTLDeviceSourceManagementWidget::OnLostConnection );
this->m_LostConnectionObserverTag = this->m_IGTLDevice->AddObserver(
mitk::LostConnectionEvent(), connectionLostCommand);
CurCommandType::Pointer newConnectionCommand = CurCommandType::New();
newConnectionCommand->SetCallbackFunction(
this, &QmitkIGTLDeviceSourceManagementWidget::OnNewConnection );
this->m_NewConnectionObserverTag = this->m_IGTLDevice->AddObserver(
mitk::NewClientConnectionEvent(), newConnectionCommand);
CurCommandType::Pointer stateModifiedCommand = CurCommandType::New();
stateModifiedCommand->SetCallbackFunction(
this, &QmitkIGTLDeviceSourceManagementWidget::OnDeviceStateChanged );
this->m_StateModifiedObserverTag = this->m_IGTLDevice->AddObserver(
itk::ModifiedEvent(), stateModifiedCommand);
}
else
{
m_IGTLDeviceSource = NULL;
}
this->AdaptGUIToState();
}
void QmitkIGTLDeviceSourceManagementWidget::DisableSourceControls()
{
m_Controls->selectedSourceLabel->setText("<none>");
m_Controls->editSend->setEnabled(false);
m_Controls->butSend->setEnabled(false);
}
void QmitkIGTLDeviceSourceManagementWidget::OnSendMessage()
{
std::string toBeSend = m_Controls->editSend->text().toStdString();
igtl::StringMessage::Pointer msg = igtl::StringMessage::New();
msg->SetString(toBeSend);
- this->m_IGTLDevice->SendMessage(msg.GetPointer());
+ this->m_IGTLDevice->SendMessage(mitk::IGTLMessage::New((igtl::MessageBase::Pointer)msg, toBeSend));
}
void QmitkIGTLDeviceSourceManagementWidget::OnMessageReceived()
{
}
void QmitkIGTLDeviceSourceManagementWidget::OnCommandReceived()
{
}
void QmitkIGTLDeviceSourceManagementWidget::OnLostConnection()
{
emit AdaptGUIToStateSignal();
}
void QmitkIGTLDeviceSourceManagementWidget::OnNewConnection()
{
emit AdaptGUIToStateSignal();
}
diff --git a/Plugins/org.mitk.gui.qt.igtexamples/src/internal/OpenIGTLinkExample.cpp b/Plugins/org.mitk.gui.qt.igtexamples/src/internal/OpenIGTLinkExample.cpp
index 9803942ff4..8e7adf35a2 100644
--- a/Plugins/org.mitk.gui.qt.igtexamples/src/internal/OpenIGTLinkExample.cpp
+++ b/Plugins/org.mitk.gui.qt.igtexamples/src/internal/OpenIGTLinkExample.cpp
@@ -1,242 +1,242 @@
/*===================================================================
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.
===================================================================*/
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Qmitk
#include "QmitkRenderWindow.h"
// Qt
#include <QMessageBox>
// mitk
#include <mitkImage.h>
#include <mitkSurface.h>
#include <mitkIGTLMessageToNavigationDataFilter.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateProperty.h>
// vtk
#include <vtkSphereSource.h>
//
#include "OpenIGTLinkExample.h"
//igtl
#include "igtlStringMessage.h"
#include "igtlTrackingDataMessage.h"
const std::string OpenIGTLinkExample::VIEW_ID = "org.mitk.views.OpenIGTLinkExample";
void OpenIGTLinkExample::SetFocus()
{
}
OpenIGTLinkExample::~OpenIGTLinkExample()
{
this->DestroyPipeline();
if (m_IGTLDeviceSource.IsNotNull())
{
m_IGTLDeviceSource->UnRegisterMicroservice();
}
}
void OpenIGTLinkExample::CreateQtPartControl( QWidget *parent )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls.setupUi( parent );
// connect the widget items with the methods
connect( m_Controls.butStart, SIGNAL(clicked()),
this, SLOT(Start()) );
connect( &m_Timer, SIGNAL(timeout()), this, SLOT(UpdatePipeline()));
//create a new OpenIGTLinkExample Client
m_IGTLClient = mitk::IGTLClient::New(false);
m_IGTLClient->SetName("OIGTL Example Client Device");
//create a new OpenIGTLinkExample Device source
m_IGTLDeviceSource = mitk::IGTLDeviceSource::New();
//set the client as the source for the device source
m_IGTLDeviceSource->SetIGTLDevice(m_IGTLClient);
m_IGTLDeviceSource->RegisterAsMicroservice();
}
void OpenIGTLinkExample::CreatePipeline()
{
//create a filter that converts OpenIGTLinkExample messages into navigation data
m_IGTLMsgToNavDataFilter = mitk::IGTLMessageToNavigationDataFilter::New();
//create a visualization filter
m_VisFilter = mitk::NavigationDataObjectVisualizationFilter::New();
//we expect a tracking data message with three tools. Since we cannot change
//the outputs at runtime we have to set it manually.
m_IGTLMsgToNavDataFilter->SetNumberOfExpectedOutputs(m_Controls.channelSpinBox->value());
//connect the filters with each other
//the OpenIGTLinkExample messages will be passed to the first filter that converts
//it to navigation data, then it is passed to the visualization filter that
//will visualize the transformation
m_IGTLMsgToNavDataFilter->ConnectTo(m_IGTLDeviceSource);
m_VisFilter->ConnectTo(m_IGTLMsgToNavDataFilter);
//create an object that will be moved respectively to the navigation data
for (size_t i = 0; i < m_IGTLMsgToNavDataFilter->GetNumberOfIndexedOutputs(); i++)
{
mitk::DataNode::Pointer newNode = mitk::DataNode::New();
QString name("DemoNode IGTLProviderExmpl T");
name.append(QString::number(i));
newNode->SetName(name.toStdString());
//create small sphere and use it as surface
mitk::Surface::Pointer mySphere = mitk::Surface::New();
vtkSphereSource *vtkData = vtkSphereSource::New();
vtkData->SetRadius(2.0f);
vtkData->SetCenter(0.0, 0.0, 0.0);
vtkData->Update();
mySphere->SetVtkPolyData(vtkData->GetOutput());
vtkData->Delete();
newNode->SetData(mySphere);
m_VisFilter->SetRepresentationObject(i, mySphere);
m_DemoNodes.append(newNode);
}
this->ResizeBoundingBox();
}
void OpenIGTLinkExample::DestroyPipeline()
{
m_VisFilter = nullptr;
foreach(mitk::DataNode::Pointer node, m_DemoNodes)
{
this->GetDataStorage()->Remove(node);
}
this->m_DemoNodes.clear();
}
void OpenIGTLinkExample::Start()
{
if (this->m_Controls.butStart->text().contains("Start Pipeline"))
{
static bool isFirstTime = true;
if (isFirstTime)
{
//Setup the pipeline
this->CreatePipeline();
isFirstTime = false;
}
m_Timer.setInterval(this->m_Controls.visualizationUpdateRateSpinBox->value());
m_Timer.start();
//this->m_Controls.visualizationUpdateRateSpinBox->setEnabled(true);
this->m_Controls.butStart->setText("Stop Pipeline");
}
else
{
m_Timer.stop();
igtl::StopTrackingDataMessage::Pointer stopStreaming =
igtl::StopTrackingDataMessage::New();
- this->m_IGTLClient->SendMessage(stopStreaming.GetPointer());
+ this->m_IGTLClient->SendMessage(mitk::IGTLMessage::New((igtl::MessageBase::Pointer) stopStreaming, ""));
this->m_Controls.butStart->setText("Start Pipeline");
//this->m_Controls.visualizationUpdateRateSpinBox->setEnabled(false);
}
}
void OpenIGTLinkExample::UpdatePipeline()
{
if (this->m_Controls.visualizeCheckBox->isChecked())
{
//update the pipeline
m_VisFilter->Update();
////update the boundings
//mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(this->GetDataStorage());
//Update rendering
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
else
{
//no visualization so we just update this filter
m_IGTLMsgToNavDataFilter->Update();
//record a timestamp if the output is new
//static double previousTimestamp;
//double curTimestamp = m_IGTLMsgToNavDataFilter->GetOutput()->GetIGTTimeStamp();
//if (previousTimestamp != curTimestamp)
static mitk::NavigationData::Pointer previousND = mitk::NavigationData::New();
mitk::NavigationData* curND = m_IGTLMsgToNavDataFilter->GetOutput();
//std::cout << "9: igt timestamp: " << curND->GetIGTTimeStamp() << std::endl;
//std::cout << "9: timestamp: " << curND->GetTimeStamp() << std::endl;
if ( !mitk::Equal( *(previousND.GetPointer()), *curND ) )
{
//previousTimestamp = curTimestamp;
previousND->Graft(curND);
}
}
//check if the timer interval changed
static int previousValue = 0;
int currentValue = this->m_Controls.visualizationUpdateRateSpinBox->value();
if (previousValue != currentValue)
{
m_Timer.setInterval(currentValue);
previousValue = currentValue;
}
}
/**
* \brief To initialize the scene to the bounding box of all visible objects
*/
void OpenIGTLinkExample::ResizeBoundingBox()
{
// get all nodes
mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDataStorage()->GetAll();
mitk::TimeGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs);
if (bounds.IsNull())
{
return;
}
//expand the bounding box in case the instruments are all at one position
mitk::Point3D center = bounds->GetCenterInWorld();
mitk::Geometry3D::BoundsArrayType extended_bounds = bounds->GetGeometryForTimeStep(0)->GetBounds();
for (unsigned int i = 0; i < 3; ++i)
{
if (bounds->GetExtentInWorld(i) < 500)
{
// extend the bounding box
extended_bounds[i * 2] = center[i] - 500 / 2.0;
extended_bounds[i * 2 + 1] = center[i] + 500 / 2.0;
}
}
//set the extended bounds
bounds->GetGeometryForTimeStep(0)->SetBounds(extended_bounds);
// initialize the views to the bounding geometry
mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
}
diff --git a/Plugins/org.mitk.gui.qt.openigtlink/src/internal/OpenIGTLinkManager.cpp b/Plugins/org.mitk.gui.qt.openigtlink/src/internal/OpenIGTLinkManager.cpp
index 72397c9036..29dc0c5b06 100644
--- a/Plugins/org.mitk.gui.qt.openigtlink/src/internal/OpenIGTLinkManager.cpp
+++ b/Plugins/org.mitk.gui.qt.openigtlink/src/internal/OpenIGTLinkManager.cpp
@@ -1,84 +1,100 @@
/*===================================================================
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.
===================================================================*/
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
//
#include "OpenIGTLinkManager.h"
const std::string OpenIGTLinkManager::VIEW_ID =
"org.mitk.views.openigtlinkmanager";
OpenIGTLinkManager::OpenIGTLinkManager()
: QmitkAbstractView()
{
}
OpenIGTLinkManager::~OpenIGTLinkManager()
{
for(unsigned int i=0; i < m_AllSourcesHandledByThisWidget.size(); i++)
m_AllSourcesHandledByThisWidget.at(i)->UnRegisterMicroservice();
}
void OpenIGTLinkManager::SetFocus()
{
}
void OpenIGTLinkManager::CreateQtPartControl( QWidget *parent )
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls.setupUi( parent );
// create GUI widgets from the Qt Designer's .ui file
// connect( (QObject*)(m_Controls.m_SourceManagerWidget),
// SIGNAL(NewSourceAdded(mitk::IGTLDeviceSource::Pointer, std::string)),
// this,
// SLOT(NewSourceByWidget(mitk::IGTLDeviceSource::Pointer,std::string)) );
connect( (QObject*)(m_Controls.m_SourceListWidget),
SIGNAL(IGTLDeviceSourceSelected(mitk::IGTLDeviceSource::Pointer)),
this,
SLOT(SourceSelected(mitk::IGTLDeviceSource::Pointer)) );
+ connect(m_Controls.checkBoxLogMessages, SIGNAL(clicked()), this, SLOT(LogMessagesClicked()));
+
+ logMessages = m_Controls.checkBoxLogMessages->isChecked();
}
void OpenIGTLinkManager::NewSourceByWidget(
mitk::IGTLDeviceSource::Pointer source,std::string /*sourceName*/)
{
source->RegisterAsMicroservice(/*sourceName*/);
m_AllSourcesHandledByThisWidget.push_back(source);
}
+void OpenIGTLinkManager::LogMessagesClicked()
+{
+ logMessages = m_Controls.checkBoxLogMessages->isChecked();
+ if(m_CurrentIGTLDevice.IsNotNull())
+ m_CurrentIGTLDevice->SetLogMessages(logMessages);
+ else
+ MITK_WARN << "Logging information not passed down to Message Provider.";
+}
+
void OpenIGTLinkManager::SourceSelected(
mitk::IGTLDeviceSource::Pointer source)
{
if (source.IsNull()) //no source selected
{
//reset everything
return;
}
+ m_CurrentIGTLDevice = source->GetIGTLDevice();
+ m_CurrentIGTLDevice->SetLogMessages(logMessages);
this->m_Controls.m_SourceManagerWidget->LoadSource(source);
//check if the current selected source is also a message provider
- mitk::IGTLMessageProvider::Pointer msgProvider =
+ mitk::IGTLMessageProvider::Pointer currentMsgProvider =
mitk::IGTLMessageProvider::New();
- msgProvider = dynamic_cast<mitk::IGTLMessageProvider*>(source.GetPointer());
- this->m_Controls.m_StreamManagerWidget->LoadSource(msgProvider);
+ currentMsgProvider = dynamic_cast<mitk::IGTLMessageProvider*>(source.GetPointer());
+ if(currentMsgProvider.IsNull())
+ return;
+ this->m_Controls.m_StreamManagerWidget->LoadSource(currentMsgProvider);
}
diff --git a/Plugins/org.mitk.gui.qt.openigtlink/src/internal/OpenIGTLinkManager.h b/Plugins/org.mitk.gui.qt.openigtlink/src/internal/OpenIGTLinkManager.h
index 0c418b5150..6e5765f4a4 100644
--- a/Plugins/org.mitk.gui.qt.openigtlink/src/internal/OpenIGTLinkManager.h
+++ b/Plugins/org.mitk.gui.qt.openigtlink/src/internal/OpenIGTLinkManager.h
@@ -1,71 +1,76 @@
/*===================================================================
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 OpenIGTLinkManager_h
#define OpenIGTLinkManager_h
#include <berryISelectionListener.h>
#include <QmitkAbstractView.h>
#include "ui_OpenIGTLinkManagerControls.h"
#include "mitkIGTLClient.h"
#include "mitkIGTLDeviceSource.h"
/**
\brief OpenIGTLinkManager
\warning This class is not yet documented. Use "git blame" and ask the author to provide basic documentation.
\sa QmitkAbstractView
\ingroup ${plugin_target}_internal
*/
class OpenIGTLinkManager : public QmitkAbstractView
{
// this is needed for all Qt objects that should have a Qt meta-object
// (everything that derives from QObject and wants to have signal/slots)
Q_OBJECT
public:
static const std::string VIEW_ID;
OpenIGTLinkManager();
virtual ~OpenIGTLinkManager();
public slots:
void NewSourceByWidget(mitk::IGTLDeviceSource::Pointer source, std::string);
void SourceSelected(mitk::IGTLDeviceSource::Pointer source);
+ void LogMessagesClicked();
protected:
virtual void CreateQtPartControl(QWidget *parent) override;
virtual void SetFocus() override;
void CreatePipeline();
void DestroyPipeline();
Ui::OpenIGTLinkManagerControls m_Controls;
/** Someone needs to hold the smart pointers of new sources, otherwise the
* objects will be lost although they are listed as microservice.
*/
std::vector<mitk::IGTLDeviceSource::Pointer> m_AllSourcesHandledByThisWidget;
+
+ bool logMessages;
+
+ mitk::IGTLDevice::Pointer m_CurrentIGTLDevice;
};
#endif // OpenIGTLinkManager_h
diff --git a/Plugins/org.mitk.gui.qt.openigtlink/src/internal/OpenIGTLinkManagerControls.ui b/Plugins/org.mitk.gui.qt.openigtlink/src/internal/OpenIGTLinkManagerControls.ui
index c112355b49..e83ddbb914 100644
--- a/Plugins/org.mitk.gui.qt.openigtlink/src/internal/OpenIGTLinkManagerControls.ui
+++ b/Plugins/org.mitk.gui.qt.openigtlink/src/internal/OpenIGTLinkManagerControls.ui
@@ -1,98 +1,105 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>OpenIGTLinkManagerControls</class>
<widget class="QWidget" name="OpenIGTLinkManagerControls">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>668</width>
<height>392</height>
</rect>
</property>
<property name="minimumSize">
<size>
<width>0</width>
<height>0</height>
</size>
</property>
<property name="windowTitle">
<string>QmitkTemplate</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_2">
<item>
<widget class="QLabel" name="label_2">
<property name="font">
<font>
<pointsize>12</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>Select OpenIGTLink device source:</string>
</property>
</widget>
</item>
<item>
<widget class="QmitkIGTLDeviceSourceSelectionWidget" name="m_SourceListWidget"/>
</item>
<item>
<widget class="QLabel" name="label">
<property name="font">
<font>
<pointsize>12</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>Manage device:</string>
</property>
</widget>
</item>
+ <item>
+ <widget class="QCheckBox" name="checkBoxLogMessages">
+ <property name="text">
+ <string>Log incoming / outgoing messages</string>
+ </property>
+ </widget>
+ </item>
<item>
<widget class="QmitkIGTLDeviceSourceManagementWidget" name="m_SourceManagerWidget" native="true"/>
</item>
<item>
<widget class="QLabel" name="label_3">
<property name="font">
<font>
<pointsize>12</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>Manage streams of selected device source:</string>
</property>
</widget>
</item>
<item>
<widget class="QmitkIGTLStreamingManagementWidget" name="m_StreamManagerWidget" native="true"/>
</item>
</layout>
</widget>
<layoutdefault spacing="6" margin="11"/>
<customwidgets>
<customwidget>
<class>QmitkIGTLDeviceSourceSelectionWidget</class>
<extends>QTextEdit</extends>
<header>QmitkIGTLDeviceSourceSelectionWidget.h</header>
</customwidget>
<customwidget>
<class>QmitkIGTLDeviceSourceManagementWidget</class>
<extends>QWidget</extends>
<header>QmitkIGTLDeviceSourceManagementWidget.h</header>
<container>1</container>
</customwidget>
<customwidget>
<class>QmitkIGTLStreamingManagementWidget</class>
<extends>QWidget</extends>
<header>QmitkIGTLStreamingManagementWidget.h</header>
<container>1</container>
</customwidget>
</customwidgets>
<resources/>
<connections/>
</ui>