diff --git a/Modules/IGT/Algorithms/mitkIGTLMessageToNavigationDataFilter.cpp b/Modules/IGT/Algorithms/mitkIGTLMessageToNavigationDataFilter.cpp
index 4b2422cc23..5cc584f098 100644
--- a/Modules/IGT/Algorithms/mitkIGTLMessageToNavigationDataFilter.cpp
+++ b/Modules/IGT/Algorithms/mitkIGTLMessageToNavigationDataFilter.cpp
@@ -1,439 +1,439 @@
/*===================================================================
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 "mitkIGTLMessageToNavigationDataFilter.h"
#include "igtlTrackingDataMessage.h"
#include "igtlQuaternionTrackingDataMessage.h"
#include "igtlTransformMessage.h"
#include "mitkQuaternion.h"
#include <vnl/vnl_det.h>
mitk::IGTLMessageToNavigationDataFilter::IGTLMessageToNavigationDataFilter()
: mitk::NavigationDataSource()
{
mitk::NavigationData::Pointer output = mitk::NavigationData::New();
this->SetNumberOfRequiredOutputs(1);
this->SetNthOutput(0, output.GetPointer());
}
mitk::IGTLMessageToNavigationDataFilter::~IGTLMessageToNavigationDataFilter()
{
}
void mitk::IGTLMessageToNavigationDataFilter::SetInput(const IGTLMessage* msg)
{
this->SetInput(0, msg);
}
void mitk::IGTLMessageToNavigationDataFilter::SetInput(unsigned int idx, const IGTLMessage* msg)
{
if (msg == nullptr) // if an input is set to nullptr, remove it
{
this->RemoveInput(idx);
}
else
{
// ProcessObject is not const-correct so a const_cast is required here
this->ProcessObject::SetNthInput(idx, const_cast<IGTLMessage*>(msg));
}
this->CreateOutputsForAllInputs();
}
const mitk::IGTLMessage*
mitk::IGTLMessageToNavigationDataFilter::GetInput(void) const
{
if (this->GetNumberOfInputs() < 1)
return nullptr;
return static_cast<const IGTLMessage*>(this->ProcessObject::GetInput(0));
}
const mitk::IGTLMessage*
mitk::IGTLMessageToNavigationDataFilter::GetInput(unsigned int idx) const
{
if (this->GetNumberOfInputs() < 1)
return nullptr;
return static_cast<const IGTLMessage*>(this->ProcessObject::GetInput(idx));
}
const mitk::IGTLMessage*
mitk::IGTLMessageToNavigationDataFilter::GetInput(std::string messageName) const
{
const DataObjectPointerArray& inputs = const_cast<Self*>(this)->GetInputs();
for (DataObjectPointerArray::const_iterator it = inputs.begin();
it != inputs.end(); ++it)
{
if (std::string(messageName) ==
(static_cast<IGTLMessage*>(it->GetPointer()))->GetName())
{
return static_cast<IGTLMessage*>(it->GetPointer());
}
}
return nullptr;
}
itk::ProcessObject::DataObjectPointerArraySizeType
mitk::IGTLMessageToNavigationDataFilter::GetInputIndex(std::string messageName)
{
DataObjectPointerArray outputs = this->GetInputs();
for (DataObjectPointerArray::size_type i = 0; i < outputs.size(); ++i)
{
if (messageName ==
(static_cast<IGTLMessage*>(outputs.at(i).GetPointer()))->GetName())
{
return i;
}
}
throw std::invalid_argument("output name does not exist");
}
void mitk::IGTLMessageToNavigationDataFilter::ConnectTo(
mitk::IGTLMessageSource* UpstreamFilter)
{
for (DataObjectPointerArraySizeType i = 0;
i < UpstreamFilter->GetNumberOfOutputs(); i++)
{
this->SetInput(i, UpstreamFilter->GetOutput(i));
}
}
void mitk::IGTLMessageToNavigationDataFilter::SetNumberOfExpectedOutputs(
unsigned int numOutputs)
{
this->SetNumberOfIndexedOutputs(numOutputs);
this->CreateOutputsForAllInputs();
}
void mitk::IGTLMessageToNavigationDataFilter::CreateOutputsForAllInputs()
{
// create outputs for all inputs
// this->SetNumberOfIndexedOutputs(this->GetNumberOfIndexedInputs());
bool isModified = false;
for (unsigned int idx = 0; idx < this->GetNumberOfIndexedOutputs(); ++idx)
{
if (this->GetOutput(idx) == nullptr)
{
mitk::NavigationData::Pointer newOutput = mitk::NavigationData::New();
this->SetNthOutput(idx, newOutput);
isModified = true;
}
}
if (isModified)
this->Modified();
}
void mitk::IGTLMessageToNavigationDataFilter::GenerateTransformData()
{
const mitk::IGTLMessage* input = this->GetInput(0);
assert(input);
//cast the input message into the proper type
igtl::TransformMessage* tMsg =
(igtl::TransformMessage*)(input->GetMessage().GetPointer());
//check if cast was successful
if (!tMsg)
{
mitkThrow() << "Cast from igtl::MessageBase to igtl::TransformMessage "
<< "failed! Please check the message.";
}
/* update outputs with tracking data from tools */
for (unsigned int i = 0; i < this->GetNumberOfOutputs(); ++i)
{
mitk::NavigationData* output = this->GetOutput(i);
assert(output);
if (input->IsDataValid() == false)
{
output->SetDataValid(false);
continue;
}
//get the transformation matrix and convert it into an affinetransformation
igtl::Matrix4x4 transformation_;
tMsg->GetMatrix(transformation_);
mitk::AffineTransform3D::Pointer affineTransformation =
mitk::AffineTransform3D::New();
mitk::Matrix3D transformation;
mitk::Vector3D offset;
for (unsigned int r = 0; r < 3; r++)
{
for (unsigned int c = 0; c < 3; c++)
{
transformation.GetVnlMatrix().set(r, c, transformation_[r][c]);
}
offset.SetElement(r, transformation_[r][3]);
}
//convert the igtl matrix here and set it in the affine transformation
affineTransformation->SetMatrix(transformation);
affineTransformation->SetOffset(offset);
//create a new navigation data here, there is a neat constructor for
//affine transformations that sets the orientation, position according to
//the affine transformation. The other values are initialized with standard
//values
mitk::NavigationData::Pointer nd =
mitk::NavigationData::New(affineTransformation, true);
//set the time stamp
nd->SetIGTTimeStamp(input->GetTimeStamp());
//set the name
nd->SetName(input->GetName());
output->Graft(nd);
}
}
void mitk::IGTLMessageToNavigationDataFilter::GenerateTrackingDataData()
{
const mitk::IGTLMessage* input = this->GetInput(0);
assert(input);
//cast the input message into the proper type
igtl::TrackingDataMessage* tdMsg =
(igtl::TrackingDataMessage*)(input->GetMessage().GetPointer());
//check if cast was successful
if (!tdMsg)
{
mitkThrow() << "Cast from igtl::MessageBase to igtl::TrackingDataMessage "
<< "failed! Please check the message.";
}
//get the number of tracking data elements
unsigned int numTrackingDataElements =
tdMsg->GetNumberOfTrackingDataElements();
if (!numTrackingDataElements)
{
MITK_ERROR("IGTLMsgToNavDataFilter") << "There are no tracking data "
"elements in this message";
}
/* update outputs with tracking data from tools */
for (unsigned int i = 0; i < this->GetNumberOfOutputs(); ++i)
{
mitk::NavigationData* output = this->GetOutput(i);
assert(output);
//invalidate the output
output->SetDataValid(false);
//check if the current index, all outputs that have no corresponding input
//tracking element stay invalidated, the others are validated according to
//the tracking element
if (input->IsDataValid() == false || i >= numTrackingDataElements)
{
continue;
}
output->SetDataValid(true);
//get the tracking data element which holds all the data
igtl::TrackingDataElement::Pointer td;
tdMsg->GetTrackingDataElement(i, td);
//get the transformation matrix and convert it into an affinetransformation
igtl::Matrix4x4 transformation_;
td->GetMatrix(transformation_);
mitk::AffineTransform3D::Pointer affineTransformation =
mitk::AffineTransform3D::New();
mitk::Matrix3D transformation;
mitk::Vector3D offset;
for (unsigned int r = 0; r < 3; r++)
{
for (unsigned int c = 0; c < 3; c++)
{
transformation.GetVnlMatrix().set(r, c, transformation_[r][c]);
}
offset.SetElement(r, transformation_[r][3]);
}
//convert the igtl matrix here and set it in the affine transformation
affineTransformation->SetMatrix(transformation);
affineTransformation->SetOffset(offset);
mitk::NavigationData::Pointer nd;
//check the rotation matrix
vnl_matrix_fixed<ScalarType, 3, 3> rotationMatrix =
affineTransformation->GetMatrix().GetVnlMatrix();
vnl_matrix_fixed<ScalarType, 3, 3> rotationMatrixTransposed =
rotationMatrix.transpose();
// a quadratic matrix is a rotation matrix exactly when determinant is 1
// and transposed is inverse
if (!Equal(1.0, vnl_det(rotationMatrix), 0.1)
|| !((rotationMatrix*rotationMatrixTransposed).is_identity(0.1)))
{
MITK_ERROR("IGTLMsgToNavDataFilter") << "tried to initialize NavData "
<< "with non-rotation matrix :" << rotationMatrix << " (Does your "
"AffineTransform3D object include spacing? This is not "
"supported by NavigationData objects!)";
nd = mitk::NavigationData::New();
}
else
{
//create a new navigation data here, there is a neat constructor for
//affine transformations that sets the orientation, position according to
//the affine transformation. The other values are initialized with standard
//values
nd = mitk::NavigationData::New(affineTransformation, true);
}
//set the time stamp
nd->SetIGTTimeStamp(input->GetIGTTimeStamp());
//set the name
- nd->SetName(td->GetName());
+ nd->SetName(input->GetName());
output->Graft(nd);
}
}
void
mitk::IGTLMessageToNavigationDataFilter::GenerateQuaternionTrackingDataData()
{
const mitk::IGTLMessage* input = this->GetInput(0);
assert(input);
//cast the input message into the proper type
igtl::QuaternionTrackingDataMessage* tdMsg =
(igtl::QuaternionTrackingDataMessage*)(input->GetMessage().GetPointer());
//check if cast was successful
if (!tdMsg)
{
mitkThrow() << "Cast from igtl::MessageBase to igtl::TrackingDataMessage "
<< "failed! Please check the message.";
}
//get the number of tracking data elements
unsigned int numTrackingDataElements =
tdMsg->GetNumberOfQuaternionTrackingDataElements();
if (!numTrackingDataElements)
{
MITK_ERROR("IGTLMsgToNavDataFilter") << "There are no tracking data "
"elements in this message";
}
/* update outputs with tracking data from tools */
for (unsigned int i = 0; i < this->GetNumberOfOutputs(); ++i)
{
mitk::NavigationData* output = this->GetOutput(i);
assert(output);
//invalidate the output
output->SetDataValid(false);
//check if the current index, all outputs that have no corresponding input
//tracking element stay invalidated, the others are validated according to
//the tracking element
if (input->IsDataValid() == false || i >= numTrackingDataElements)
{
continue;
}
output->SetDataValid(true);
//get the tracking data element which holds all the data
igtl::QuaternionTrackingDataElement::Pointer td;
tdMsg->GetQuaternionTrackingDataElement(i, td);
//get the quaternion and set it
float quaternion_[4]; //igtl quat type
td->GetQuaternion(quaternion_);
mitk::Quaternion quaternion;
quaternion.put(0, quaternion_[0]);
quaternion.put(1, quaternion_[1]);
quaternion.put(2, quaternion_[2]);
quaternion.put(3, quaternion_[3]);
output->SetOrientation(quaternion);
output->SetHasOrientation(true);
//get the position and set it
float position_[3]; //igtl position type
td->GetPosition(position_);
mitk::NavigationData::PositionType position; //mitk position type
position.SetElement(0, position_[0]);
position.SetElement(1, position_[1]);
position.SetElement(2, position_[2]);
output->SetPosition(position);
output->SetHasPosition(true);
//set the time stamp
output->SetIGTTimeStamp(input->GetTimeStamp());
//set the name
output->SetName(td->GetName());
//there is no explicit covarience matrix
output->SetCovErrorMatrix(mitk::NavigationData::CovarianceMatrixType());
}
}
void mitk::IGTLMessageToNavigationDataFilter::GenerateData()
{
//get the IGTLMessage from the previous filter
const mitk::IGTLMessage* input = this->GetInput(0);
assert(input);
//check if the message is valid, if it is not valid we do not generate new
//outputs
if (!input->IsDataValid())
{
MITK_DEBUG("IGTLMessageToNavigationDataFilter") << "Input data is invalid.";
return;
}
//get the message type
const char* msgType = input->GetIGTLMessageType();
//check if the IGTL message has the proper type
if (strcmp(msgType, "TRANSFORM") == 0)
{
this->GenerateTransformData();
}
else if (strcmp(msgType, "TDATA") == 0)
{
this->GenerateTrackingDataData();
}
else if (strcmp(msgType, "QTDATA") == 0)
{
this->GenerateQuaternionTrackingDataData();
}
else
{
//the message has another type
//ignore
MITK_INFO("IGTLMessageToNavigationDataFilter") << "The input has a unknown "
<< "message type: "
<< msgType;
}
}
void mitk::IGTLMessageToNavigationDataFilter::GenerateOutputInformation()
{
// Superclass::GenerateOutputInformation();
// mitk::NavigationData* output = this->GetOutput(0);
// assert(output);
// const mitk::IGTLMessage* input = this->GetInput(0);
// assert(input);
itkDebugMacro(<< "GenerateOutputInformation()");
// output->Initialize(input->GetPixelType(), input->GetDimension(), input->GetDimensions());
// // initialize geometry
// output->SetPropertyList(input->GetPropertyList()->Clone());
// mitk::TimeGeometry::Pointer clonGeometry = input->GetTimeGeometry()->Clone();
// output->SetTimeGeometry(clonGeometry.GetPointer());
}
diff --git a/Modules/IGT/Algorithms/mitkNavigationDataToIGTLMessageFilter.cpp b/Modules/IGT/Algorithms/mitkNavigationDataToIGTLMessageFilter.cpp
index 0e8f7cb849..c940bf8a72 100644
--- a/Modules/IGT/Algorithms/mitkNavigationDataToIGTLMessageFilter.cpp
+++ b/Modules/IGT/Algorithms/mitkNavigationDataToIGTLMessageFilter.cpp
@@ -1,360 +1,348 @@
/*===================================================================
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 "mitkNavigationDataToIGTLMessageFilter.h"
#include "igtlQuaternionTrackingDataMessage.h"
#include "igtlTrackingDataMessage.h"
#include "igtlTransformMessage.h"
#include "igtlPositionMessage.h"
#include <mitkInteractionConst.h>
#include <itksys/SystemTools.hxx>
mitk::NavigationDataToIGTLMessageFilter::NavigationDataToIGTLMessageFilter()
{
mitk::IGTLMessage::Pointer output = mitk::IGTLMessage::New();
this->SetNumberOfRequiredOutputs(1);
this->SetNthOutput(0, output.GetPointer());
-
this->SetNumberOfRequiredInputs(1);
// m_OperationMode = Mode3D;
m_CurrentTimeStep = 0;
// m_RingBufferSize = 50; //the default ring buffer size
// m_NumberForMean = 100;
}
mitk::NavigationDataToIGTLMessageFilter::~NavigationDataToIGTLMessageFilter()
{
}
void mitk::NavigationDataToIGTLMessageFilter::GenerateData()
{
switch (m_OperationMode)
{
case ModeSendQTDataMsg:
this->GenerateDataModeSendQTDataMsg();
break;
case ModeSendTDataMsg:
this->GenerateDataModeSendTDataMsg();
break;
case ModeSendQTransMsg:
this->GenerateDataModeSendQTransMsg();
break;
case ModeSendTransMsg:
this->GenerateDataModeSendTransMsg();
break;
default:
break;
}
- igtl::MessageBase::Pointer curMessage = this->GetOutput()->GetMessage();
- if (dynamic_cast<igtl::TrackingDataMessage*>(curMessage.GetPointer()) != nullptr)
- {
- igtl::TrackingDataMessage* tdMsg =
- (igtl::TrackingDataMessage*)(curMessage.GetPointer());
- }
-
}
void mitk::NavigationDataToIGTLMessageFilter::SetInput(const NavigationData* nd)
{
// Process object is not const-correct so the const_cast is required here
this->ProcessObject::SetNthInput(0, const_cast<NavigationData*>(nd));
this->CreateOutputsForAllInputs();
}
void mitk::NavigationDataToIGTLMessageFilter::SetInput(unsigned int idx, const NavigationData* nd)
{
// Process object is not const-correct so the const_cast is required here
this->ProcessObject::SetNthInput(idx, const_cast<NavigationData*>(nd));
this->CreateOutputsForAllInputs();
}
const mitk::NavigationData* mitk::NavigationDataToIGTLMessageFilter::GetInput(void)
{
if (this->GetNumberOfInputs() < 1)
return nullptr;
return static_cast<const NavigationData*>(this->ProcessObject::GetInput(0));
}
const mitk::NavigationData* mitk::NavigationDataToIGTLMessageFilter::GetInput(unsigned int idx)
{
if (this->GetNumberOfInputs() < 1)
return nullptr;
return static_cast<const NavigationData*>(this->ProcessObject::GetInput(idx));
}
void mitk::NavigationDataToIGTLMessageFilter::CreateOutputsForAllInputs()
{
switch (m_OperationMode)
{
case ModeSendQTDataMsg:
// create one message output for all navigation data inputs
this->SetNumberOfIndexedOutputs(this->GetNumberOfIndexedInputs());
// set the type for this filter
this->SetType("QTDATA");
break;
case ModeSendTDataMsg:
// create one message output for all navigation data inputs
this->SetNumberOfIndexedOutputs(this->GetNumberOfIndexedInputs());
// set the type for this filter
this->SetType("TDATA");
break;
case ModeSendQTransMsg:
// create one message output for all navigation data input together
this->SetNumberOfIndexedOutputs(this->GetNumberOfIndexedInputs());
// set the type for this filter
this->SetType("POSITION");
break;
case ModeSendTransMsg:
// create one message output for all navigation data input together
this->SetNumberOfIndexedOutputs(this->GetNumberOfIndexedInputs());
// set the type for this filter
this->SetType("TRANS");
break;
default:
break;
}
for (unsigned int idx = 0; idx < this->GetNumberOfIndexedOutputs(); ++idx)
{
if (this->GetOutput(idx) == nullptr)
{
DataObjectPointer newOutput = this->MakeOutput(idx);
this->SetNthOutput(idx, newOutput);
}
this->Modified();
}
}
void ConvertAffineTransformationIntoIGTLMatrix(mitk::AffineTransform3D* trans,
igtl::Matrix4x4 igtlTransform)
{
const mitk::AffineTransform3D::MatrixType& matrix = trans->GetMatrix();
mitk::Vector3D position = trans->GetOffset();
//copy the data into a matrix type that igtl understands
for (unsigned int r = 0; r < 3; r++)
{
for (unsigned int c = 0; c < 3; c++)
{
igtlTransform[r][c] = matrix(r, c);
}
igtlTransform[r][3] = position[r];
}
for (unsigned int c = 0; c < 3; c++)
{
igtlTransform[3][c] = 0.0;
}
igtlTransform[3][3] = 1.0;
}
void mitk::NavigationDataToIGTLMessageFilter::GenerateDataModeSendQTransMsg()
{
// for each output message
- for (unsigned int i = 0; i < this->GetNumberOfIndexedOutputs(); ++i)
+ for (unsigned int i = 0; i < this->GetNumberOfIndexedInputs(); ++i)
{
mitk::IGTLMessage* output = this->GetOutput(i);
assert(output);
const mitk::NavigationData* input = this->GetInput(i);
assert(input);
// do not add navigation data to message if input is invalid
if (input->IsDataValid() == false)
continue;
//get the navigation data components
mitk::NavigationData::PositionType pos = input->GetPosition();
mitk::NavigationData::OrientationType ori = input->GetOrientation();
//insert this information into the message
igtl::PositionMessage::Pointer posMsg = igtl::PositionMessage::New();
posMsg->SetPosition(pos[0], pos[1], pos[2]);
posMsg->SetQuaternion(ori[0], ori[1], ori[2], ori[3]);
- igtl::TimeStamp::Pointer timestamp = igtl::TimeStamp::New();
- timestamp->SetTime(input->GetTimeStamp().GetMTime() / 1000, input->GetTimeStamp().GetMTime() % 1000);
+ igtl::TimeStamp::Pointer timestamp = ConvertToIGTLTimeStamp(input->GetIGTTimeStamp());
posMsg->SetTimeStamp(timestamp);
posMsg->SetDeviceName(input->GetName());
posMsg->Pack();
//add the igtl message to the mitk::IGTLMessage
output->SetMessage(posMsg.GetPointer());
}
}
void mitk::NavigationDataToIGTLMessageFilter::GenerateDataModeSendTransMsg()
{
// for each output message
- for (unsigned int i = 0; i < this->GetNumberOfIndexedOutputs(); ++i)
+ for (unsigned int i = 0; i < this->GetNumberOfIndexedInputs(); ++i)
{
mitk::IGTLMessage* output = this->GetOutput(i);
assert(output);
const mitk::NavigationData* input = this->GetInput(i);
assert(input);
// do not add navigation data to message if input is invalid
if (input->IsDataValid() == false)
continue;
//get the navigation data components
mitk::AffineTransform3D::Pointer transform = input->GetAffineTransform3D();
mitk::NavigationData::PositionType position = transform->GetOffset();
//convert the transform into a igtl type
igtl::Matrix4x4 igtlTransform;
ConvertAffineTransformationIntoIGTLMatrix(transform, igtlTransform);
//insert this information into the message
igtl::TransformMessage::Pointer transMsg = igtl::TransformMessage::New();
transMsg->SetMatrix(igtlTransform);
transMsg->SetPosition(position[0], position[1], position[2]);
- igtl::TimeStamp::Pointer timestamp = igtl::TimeStamp::New();
- timestamp->SetTime(input->GetTimeStamp().GetMTime() / 1000, input->GetTimeStamp().GetMTime() % 1000);
+ igtl::TimeStamp::Pointer timestamp = ConvertToIGTLTimeStamp(input->GetIGTTimeStamp());
transMsg->SetTimeStamp(timestamp);
transMsg->SetDeviceName(input->GetName());
transMsg->Pack();
//add the igtl message to the mitk::IGTLMessage
output->SetMessage(transMsg.GetPointer());
}
}
+igtl::TimeStamp::Pointer mitk::NavigationDataToIGTLMessageFilter::ConvertToIGTLTimeStamp(double IGTTimeStamp)
+{
+ igtl::TimeStamp::Pointer timestamp = igtl::TimeStamp::New();
+ timestamp->SetTime(IGTTimeStamp / 1000, (int)(IGTTimeStamp) % 1000);
+ return timestamp;
+}
void mitk::NavigationDataToIGTLMessageFilter::GenerateDataModeSendQTDataMsg()
{
mitk::IGTLMessage* output = this->GetOutput();
assert(output);
//create a output igtl message
igtl::QuaternionTrackingDataMessage::Pointer qtdMsg =
igtl::QuaternionTrackingDataMessage::New();
mitk::NavigationData::PositionType pos;
mitk::NavigationData::OrientationType ori;
for (unsigned int index = 0; index < this->GetNumberOfIndexedInputs(); index++)
{
const mitk::NavigationData* nd = GetInput(index);
assert(nd);
//get the navigation data components
pos = nd->GetPosition();
ori = nd->GetOrientation();
//insert the information into the tracking element
igtl::QuaternionTrackingDataElement::Pointer tde =
igtl::QuaternionTrackingDataElement::New();
tde->SetPosition(pos[0], pos[1], pos[2]);
tde->SetQuaternion(ori[0], ori[1], ori[2], ori[3]);
tde->SetName(nd->GetName());
//insert this element into the tracking data message
qtdMsg->AddQuaternionTrackingDataElement(tde);
- //copy the time stamp
- //todo find a better way to do that
- igtl::TimeStamp::Pointer timestamp = igtl::TimeStamp::New();
- timestamp->SetTime(nd->GetTimeStamp().GetMTime() / 1000, nd->GetTimeStamp().GetMTime() % 1000);
- MITK_INFO << timestamp;
+ MITK_INFO << ConvertToIGTLTimeStamp(nd->GetIGTTimeStamp());
}
qtdMsg->Pack();
//add the igtl message to the mitk::IGTLMessage
output->SetMessage(qtdMsg.GetPointer());
}
void mitk::NavigationDataToIGTLMessageFilter::GenerateDataModeSendTDataMsg()
{
bool isValidData = true;
mitk::IGTLMessage* output = this->GetOutput();
assert(output);
//create a output igtl message
igtl::TrackingDataMessage::Pointer tdMsg = igtl::TrackingDataMessage::New();
mitk::AffineTransform3D::Pointer transform;
Vector3D position;
igtl::Matrix4x4 igtlTransform;
vnl_matrix_fixed<ScalarType, 3, 3> rotationMatrix;
vnl_matrix_fixed<ScalarType, 3, 3> rotationMatrixTransposed;
for (unsigned int index = 0; index < this->GetNumberOfIndexedInputs(); index++)
{
const mitk::NavigationData* nd = GetInput(index);
assert(nd);
//create a new tracking element
igtl::TrackingDataElement::Pointer tde = igtl::TrackingDataElement::New();
//get the navigation data components
transform = nd->GetAffineTransform3D();
position = transform->GetOffset();
//check the rotation matrix
rotationMatrix = transform->GetMatrix().GetVnlMatrix();
rotationMatrixTransposed = rotationMatrix.transpose();
// a quadratic matrix is a rotation matrix exactly when determinant is 1
// and transposed is inverse
if (!Equal(1.0, vnl_det(rotationMatrix), 0.1)
|| !((rotationMatrix*rotationMatrixTransposed).is_identity(0.1)))
{
//the rotation matrix is not valid! => invalidate the current element
isValidData = false;
}
//convert the transform into a igtl type
ConvertAffineTransformationIntoIGTLMatrix(transform, igtlTransform);
//fill the tracking element with life
tde->SetMatrix(igtlTransform);
tde->SetPosition(position[0], position[1], position[2]);
std::stringstream name;
name << nd->GetName();
if (name.rdbuf()->in_avail() == 0)
{
name << "TrackingTool" << index;
}
tde->SetName(name.str().c_str());
//insert this element into the tracking data message
tdMsg->AddTrackingDataElement(tde);
//copy the time stamp
- //todo find a better way to do that
- igtl::TimeStamp::Pointer timestamp = igtl::TimeStamp::New();
- timestamp->SetTime(nd->GetTimeStamp().GetMTime() / 1000, nd->GetTimeStamp().GetMTime() % 1000);
+ igtl::TimeStamp::Pointer timestamp = ConvertToIGTLTimeStamp(nd->GetIGTTimeStamp());
tdMsg->SetTimeStamp(timestamp);
-
}
tdMsg->Pack();
//add the igtl message to the mitk::IGTLMessage
output->SetMessage(tdMsg.GetPointer());
output->SetDataValid(isValidData);
}
void mitk::NavigationDataToIGTLMessageFilter::SetOperationMode(OperationMode mode)
{
m_OperationMode = mode;
this->Modified();
- this->CreateOutputsForAllInputs();
}
void mitk::NavigationDataToIGTLMessageFilter::ConnectTo(
mitk::NavigationDataSource* UpstreamFilter)
{
for (DataObjectPointerArraySizeType i = 0;
i < UpstreamFilter->GetNumberOfOutputs(); i++)
{
this->SetInput(i, UpstreamFilter->GetOutput(i));
}
}
diff --git a/Modules/IGT/Algorithms/mitkNavigationDataToIGTLMessageFilter.h b/Modules/IGT/Algorithms/mitkNavigationDataToIGTLMessageFilter.h
index 799900d30d..a92dd036b5 100644
--- a/Modules/IGT/Algorithms/mitkNavigationDataToIGTLMessageFilter.h
+++ b/Modules/IGT/Algorithms/mitkNavigationDataToIGTLMessageFilter.h
@@ -1,170 +1,173 @@
/*===================================================================
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 _MITKNAVIGATIONDATATOIGTLMessageFILTER_H__
#define _MITKNAVIGATIONDATATOIGTLMessageFILTER_H__
#include "mitkCommon.h"
#include "mitkPointSet.h"
#include "mitkIGTLMessageSource.h"
#include "mitkNavigationData.h"
#include "mitkNavigationDataSource.h"
namespace mitk {
/**Documentation
*
* \brief This filter creates IGTL messages from mitk::NavigaitionData objects
*
*
* \ingroup IGT
*
*/
class MITKIGT_EXPORT NavigationDataToIGTLMessageFilter : public IGTLMessageSource
{
public:
mitkClassMacro(NavigationDataToIGTLMessageFilter, IGTLMessageSource);
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
/**Documentation
* \brief There are four different operation modes.
*
* - ModeSendQTransMsg: every input NavigationData is processed into one
* output message that contains a position and a orientation (quaternion).
* - ModeSendTransMsg: every input NavigationData is processed into one
* output message that contains a 4x4 transformation.
* - ModeSendQTDataMsg:all input NavigationData is processed into one single
* output message that contains a position and orientation (quaternion) for
* each navigation data.
* - ModeSendTDataMsg:all input NavigationData is processed into one single
* output message that contains a 4x4 transformation for
* each navigation data.
*/
enum OperationMode
{
ModeSendQTransMsg,
ModeSendTransMsg,
ModeSendQTDataMsg,
ModeSendTDataMsg
};
/**
* \brief filter execute method
*/
virtual void GenerateData() override;
using Superclass::SetInput;
/**
* \brief Sets one input NavigationData
*/
virtual void SetInput(const mitk::NavigationData *NavigationData);
/**
* \brief Sets the input NavigationData at a specific index
*/
virtual void SetInput(unsigned int idx, const NavigationData* nd);
/**
* \brief Returns the input of this filter
*/
const mitk::NavigationData* GetInput();
/**
* \brief Returns the input number idx of this filter
*/
const mitk::NavigationData* GetInput(unsigned int idx);
/**
* \brief Sets the mode of this filter.
*
* See OperationMode for the behavior in the different modes
* \warn A call to this method will change the number of outputs of the filter.
* After calling this method, all previously acquired pointers to outputs are invalid
* Always set the operation mode first, then get the outputs with GetOutput()
*/
virtual void SetOperationMode(OperationMode mode);
/**
* \brief returns the mode of this filter.
*
* See OperationMode for the behavior in the different modes
*/
itkGetConstMacro(OperationMode, OperationMode);
/**
* empty implementation to prevent calling of the superclass method that
* would try to copy information from the input NavigationData to the output
* PointSet, which makes no sense!
*/
void GenerateOutputInformation() override {};
/**
*\brief Connects the input of this filter to the outputs of the given
* NavigationDataSource
*
* This method does not support smartpointer. use FilterX.GetPointer() to
* retrieve a dumbpointer.
*/
virtual void ConnectTo(mitk::NavigationDataSource * UpstreamFilter);
protected:
NavigationDataToIGTLMessageFilter();
virtual ~NavigationDataToIGTLMessageFilter();
/**
* \brief Generates the output
*
*/
// virtual void GenerateData();
/**
* \brief Generates the output for ModeSendQTDataMsg
*
*/
virtual void GenerateDataModeSendQTDataMsg();
/**
* \brief Generates the output for ModeSendTDataMsg
*/
virtual void GenerateDataModeSendTDataMsg();
/**
* \brief Generates the output for ModeSendQTransMsg
*
*/
virtual void GenerateDataModeSendQTransMsg();
/**
* \brief Generates the output for ModeSendTransMsg
*/
virtual void GenerateDataModeSendTransMsg();
/**
* \brief create output objects according to OperationMode for all inputs
*/
virtual void CreateOutputsForAllInputs();
OperationMode m_OperationMode; ///< Stores the mode. See enum OperationMode
// unsigned int m_RingBufferSize; ///< Stores the ringbuffer size
unsigned int m_CurrentTimeStep; ///< Indicates the current timestamp
// unsigned int m_NumberForMean; ///< Number of Navigation Data, which should be averaged
+ /** Converts a mitk::IGTTimestamp (double, milliseconds) to an OpenIGTLink timestamp */
+ igtl::TimeStamp::Pointer ConvertToIGTLTimeStamp(double IGTTimeStamp);
+
/** Measurement class to calculate latency and frame count */
};
} // namespace mitk
#endif // _MITKNAVIGATIONDATATOIGTLMessageFILTER_H__
diff --git a/Modules/IGT/DataManagement/mitkNavigationTool.cpp b/Modules/IGT/DataManagement/mitkNavigationTool.cpp
index ffa6c92c34..02e48810a0 100644
--- a/Modules/IGT/DataManagement/mitkNavigationTool.cpp
+++ b/Modules/IGT/DataManagement/mitkNavigationTool.cpp
@@ -1,129 +1,134 @@
/*===================================================================
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 "mitkNavigationTool.h"
#include "mitkIGTException.h"
#include "mitkNavigationData.h"
#include "Poco/File.h"
#include "mitkUnspecifiedTrackingTypeInformation.h"
mitk::NavigationTool::NavigationTool() : m_Identifier("None"),
m_Type(mitk::NavigationTool::Unknown),
m_CalibrationFile("none"),
m_SerialNumber(""),
m_TrackingDeviceType(mitk::UnspecifiedTrackingTypeInformation::GetTrackingDeviceName()),
m_ToolRegistrationLandmarks(mitk::PointSet::New()),
m_ToolCalibrationLandmarks(mitk::PointSet::New()),
m_ToolTipOrientation(mitk::Quaternion(0,0,0,1))
{
m_ToolTipPosition[0] = 0;
m_ToolTipPosition[1] = 0;
m_ToolTipPosition[2] = 0;
+
+ m_ToolAxis[0] = 1;
+ m_ToolAxis[1] = 0;
+ m_ToolAxis[2] = 0;
}
mitk::NavigationTool::~NavigationTool()
{
}
mitk::AffineTransform3D::Pointer mitk::NavigationTool::GetToolTipTransform()
{
mitk::NavigationData::Pointer returnValue = mitk::NavigationData::New();
returnValue->SetPosition(this->m_ToolTipPosition);
returnValue->SetOrientation(this->m_ToolTipOrientation);
return returnValue->GetAffineTransform3D();
}
void mitk::NavigationTool::Graft( const DataObject *data )
{
// Attempt to cast data to an NavigationData
const Self* nd;
try
{
nd = dynamic_cast<const Self *>( data );
}
catch( ... )
{
mitkThrowException(mitk::IGTException) << "mitk::NavigationData::Graft cannot cast "
<< typeid(data).name() << " to "
<< typeid(const Self *).name() ;
}
if (!nd)
{
// pointer could not be cast back down
mitkThrowException(mitk::IGTException) << "mitk::NavigationData::Graft cannot cast "
<< typeid(data).name() << " to "
<< typeid(const Self *).name() ;
}
// Now copy anything that is needed
m_Identifier = nd->GetIdentifier();
m_Type = nd->GetType();
m_DataNode->SetName(nd->GetDataNode()->GetName());
m_DataNode->SetData(nd->GetDataNode()->GetData());
m_SpatialObject = nd->GetSpatialObject();
m_TrackingTool = nd->GetTrackingTool();
m_CalibrationFile = nd->GetCalibrationFile();
m_SerialNumber = nd->GetSerialNumber();
m_TrackingDeviceType = nd->GetTrackingDeviceType();
m_ToolRegistrationLandmarks = nd->GetToolRegistrationLandmarks();
m_ToolCalibrationLandmarks = nd->GetToolCalibrationLandmarks();
m_ToolTipPosition = nd->GetToolTipPosition();
m_ToolTipOrientation = nd->GetToolTipOrientation();
+ m_ToolAxis = nd->GetToolAxis();
}
bool mitk::NavigationTool::IsToolTipSet()
{
if( (m_ToolTipPosition[0] == 0) &&
(m_ToolTipPosition[1] == 0) &&
(m_ToolTipPosition[2] == 0) &&
(m_ToolTipOrientation.x() == 0) &&
(m_ToolTipOrientation.y() == 0) &&
(m_ToolTipOrientation.z() == 0) &&
(m_ToolTipOrientation.r() == 1))
return false;
else return true;
}
void mitk::NavigationTool::SetCalibrationFile(const std::string filename)
{
//check if file does exist:
if (filename=="")
{
m_CalibrationFile = "none";
}
else
{
Poco::File myFile(filename);
if (myFile.exists())
m_CalibrationFile = filename;
else
m_CalibrationFile = "none";
}
}
std::string mitk::NavigationTool::GetToolName()
{
if (this->m_DataNode.IsNull()) {return "";}
else {return m_DataNode->GetName();}
}
mitk::Surface::Pointer mitk::NavigationTool::GetToolSurface()
{
if (this->m_DataNode.IsNull()) {return nullptr;}
else if (this->m_DataNode->GetData() == nullptr) {return nullptr;}
else {return dynamic_cast<mitk::Surface*>(m_DataNode->GetData());}
}
diff --git a/Modules/IGT/DataManagement/mitkNavigationTool.h b/Modules/IGT/DataManagement/mitkNavigationTool.h
index b5cbad784a..04ce577314 100644
--- a/Modules/IGT/DataManagement/mitkNavigationTool.h
+++ b/Modules/IGT/DataManagement/mitkNavigationTool.h
@@ -1,197 +1,206 @@
/*===================================================================
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 NAVIGATIONTOOL_H_INCLUDED
#define NAVIGATIONTOOL_H_INCLUDED
//itk headers
#include <itkObjectFactory.h>
#include <itkSpatialObject.h>
#include <itkDataObject.h>
//mitk headers
#include <mitkCommon.h>
#include <mitkDataNode.h>
#include <mitkPointSet.h>
#include <mitkTrackingTool.h>
#include <mitkTrackingTypes.h>
#include <mitkSurface.h>
#include <MitkIGTExports.h>
namespace mitk {
/**Documentation
* \brief An object of this class represents a navigation tool in the view of the software.
* A few informations like an identifier, a toolname, a surface and a itk spatial
* object are stored in such an object. The classes NavigationToolReader and
* are availiable to write/read tools to/from the harddisc. If you need a collection
* of navigation tools the class NavigationToolStorage could be used.
*
* \ingroup IGT
*/
class MITKIGT_EXPORT NavigationTool : public itk::DataObject
{
public:
mitkClassMacroItkParent(NavigationTool,itk::DataObject);
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
enum NavigationToolType {Instrument, Fiducial, Skinmarker, Unknown};
//## getter and setter ##
//NavigationToolType:
itkGetConstMacro(Type,NavigationToolType);
itkSetMacro(Type,NavigationToolType);
//Identifier:
itkGetConstMacro(Identifier,std::string);
itkSetMacro(Identifier,std::string);
//Datatreenode:
itkGetConstMacro(DataNode,mitk::DataNode::Pointer);
itkSetMacro(DataNode,mitk::DataNode::Pointer);
//SpatialObject:
itkGetConstMacro(SpatialObject,itk::SpatialObject<3>::Pointer);
itkSetMacro(SpatialObject,itk::SpatialObject<3>::Pointer);
//TrackingTool:
itkGetConstMacro(TrackingTool,mitk::TrackingTool::Pointer);
itkSetMacro(TrackingTool,mitk::TrackingTool::Pointer);
//CalibrationFile:
itkGetConstMacro(CalibrationFile,std::string);
void SetCalibrationFile(const std::string filename);
//Tool tip definition:
itkGetConstMacro(ToolTipPosition,mitk::Point3D);
itkSetMacro(ToolTipPosition,mitk::Point3D);
itkGetConstMacro(ToolTipOrientation,mitk::Quaternion);
itkSetMacro(ToolTipOrientation,mitk::Quaternion);
+ //Tool Axis definition:
+ //default tool axis is along x axis, the tool axis must be normalized
+ itkGetConstMacro(ToolAxis, mitk::Point3D);
+ itkSetMacro(ToolAxis, mitk::Point3D);
+
+
/** @return Returns the tooltip as transform object. */
mitk::AffineTransform3D::Pointer GetToolTipTransform();
/** @return Returns true if a tooltip is set, false if not. */
bool IsToolTipSet();
//Tool Landmarks:
/** For overview, here are descriptons of the two types of tool landmarks:
*
* tool calibration landmarks: These landmarks may be used clearly define the tools pose only by
* using landmarks in the tool coordinate system. E.g., two landmarks for a 5DoF tool and three
* landmarks for a 6DoF tool. These landmarks may be used, e.g., for a point based registration
* of a tool from image space to tracking space.
*
* tool registration landmarks: These landmarks are designed for representing defined landmarks
* on a tools surface. The number of these landmarks might exeed the number of tool calibration
* landmarks for reasons of redundancy and averaging. They are used for, e.g., manually registering
* the pose of a tool by visual markers in a CT scan. If you would use these landmarks to do a
* point based registration from image space to tracking space later, you might overweight the
* tool because of two many landmarks compared to other markers.
*
* @return Returns the tool registration landmarks which represent markers / special points on a
* tool that can be used for registration. The landmarks should be given in tool coordinates.
* If there are no landmarks defined for this tool the method returns an empty point set.
*/
itkGetConstMacro(ToolRegistrationLandmarks,mitk::PointSet::Pointer);
/** @brief Sets the tool registration landmarks which represent markers / special points on a
* tool that can be used for registration. The landmarks should be given in tool coordinates.
*/
itkSetMacro(ToolRegistrationLandmarks,mitk::PointSet::Pointer);
/** @return Returns the tool calibration landmarks for calibration of the defined points in the
* tool coordinate system, e.g. 2 landmarks for a 5DoF tool and 3 landmarks for a 6DoF tool.
*/
itkGetConstMacro(ToolCalibrationLandmarks,mitk::PointSet::Pointer);
/** @brief Sets the tool calibration landmarks for calibration of defined points in the
* tool coordinate system, e.g. 2 landmarks for a 5DoF tool and 3 landmarks for a 6DoF tool.
*/
itkSetMacro(ToolCalibrationLandmarks,mitk::PointSet::Pointer);
//SerialNumber:
itkGetConstMacro(SerialNumber,std::string);
itkSetMacro(SerialNumber,std::string);
//TrackingDeviceType:
itkGetConstMacro(TrackingDeviceType,mitk::TrackingDeviceType);
itkSetMacro(TrackingDeviceType,mitk::TrackingDeviceType);
//ToolName (only getter):
/** @return Returns the name of this navigation tool. Returns an empty string if there is
* no name (for example because the data node has not been set yet).
*
* Note: There is no setter for the name,
* because the name of the corresponding data node is used as tool name. So if you
* want to modify the name of this navigation tool only get the data node and modify
* its name.
*/
std::string GetToolName();
//ToolSurface (only getter):
/** @return Returns the surface of this navigation tool. Returns nullptr if there is
* no surface (for example because the data node has not been set yet).
*
* Note: There is no setter for the surface,
* because the surface is the data of the corresponding data node. So if you
* want to set a new surface only get the data node and modify its data.
*/
mitk::Surface::Pointer GetToolSurface();
/**
* \brief Graft the data and information from one NavigationTool to another.
*
* Copies the content of data into this object.
* This is a convenience method to setup a second NavigationTool object with all the meta
* information of another NavigationTool object.
* Note that this method is different than just using two
* SmartPointers to the same NavigationTool object since separate DataObjects are
* still maintained.
*/
virtual void Graft(const DataObject *data) override;
//#######################
protected:
NavigationTool();
~NavigationTool();
//## data structure of a navigation tool object ##
std::string m_Identifier;
NavigationToolType m_Type;
/** @brief This DataNode holds a toolname and a tool surface */
mitk::DataNode::Pointer m_DataNode;
/** @brief This member variable holds a mathamatical description of the tool */
itk::SpatialObject<3>::Pointer m_SpatialObject;
/** @brief This member variable holds a pointer to the corresponding tracking tool in the hardware. */
mitk::TrackingTool::Pointer m_TrackingTool;
/** @brief The path to the calibration file of the tool. */
std::string m_CalibrationFile;
/** @brief A unique serial number of the tool which is needed to identify the tool correctly. This is very important
* in case of the NDI Aurora System. */
std::string m_SerialNumber;
/** @brief This member holds the tracking device type of the tool. */
mitk::TrackingDeviceType m_TrackingDeviceType;
/** @brief Holds landmarks for tool registration. */
mitk::PointSet::Pointer m_ToolRegistrationLandmarks;
/** @brief Holds landmarks for calibration of the defined points in the tool coordinate system,
* e.g. 2 landmarks for a 5DoF tool and 3 landmarks for a 6DoF tool.
*/
mitk::PointSet::Pointer m_ToolCalibrationLandmarks;
/** @brief Holds the position of the tool tip. */
mitk::Point3D m_ToolTipPosition;
/** @brief Holds the orientation of the tool tip. */
mitk::Quaternion m_ToolTipOrientation;
+
+ /** @brief Holds the axis of the tool. */
+ mitk::Point3D m_ToolAxis;
//#################################################
};
} // namespace mitk
#endif //NAVIGATIONTOOL
diff --git a/Modules/IGT/IO/mitkNavigationDataRecorder.cpp b/Modules/IGT/IO/mitkNavigationDataRecorder.cpp
index fa2a457668..96c27d6db2 100644
--- a/Modules/IGT/IO/mitkNavigationDataRecorder.cpp
+++ b/Modules/IGT/IO/mitkNavigationDataRecorder.cpp
@@ -1,116 +1,125 @@
/*===================================================================
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 "mitkNavigationDataRecorder.h"
#include <mitkIGTTimeStamp.h>
mitk::NavigationDataRecorder::NavigationDataRecorder()
{
//set default values
m_NumberOfInputs = 0;
m_Recording = false;
m_StandardizedTimeInitialized = false;
m_RecordCountLimit = -1;
+ m_RecordOnlyValidData = false;
}
mitk::NavigationDataRecorder::~NavigationDataRecorder()
{
//mitk::IGTTimeStamp::GetInstance()->Stop(this); //commented out because of bug 18952
}
void mitk::NavigationDataRecorder::GenerateData()
{
// get each input, lookup the associated BaseData and transfer the data
DataObjectPointerArray inputs = this->GetIndexedInputs(); //get all inputs
//This vector will hold the NavigationDatas that are copied from the inputs
std::vector< mitk::NavigationData::Pointer > clonedDatas;
+ bool atLeastOneInputIsInvalid = false;
+
// For each input
for (unsigned int index=0; index < inputs.size(); index++)
{
// First copy input to output
this->GetOutput(index)->Graft(this->GetInput(index));
// if we are not recording, that's all there is to do
if (! m_Recording) continue;
+ if (atLeastOneInputIsInvalid || !this->GetInput(index)->IsDataValid())
+ {
+ atLeastOneInputIsInvalid = true;
+ }
+
// Clone a Navigation Data
mitk::NavigationData::Pointer clone = mitk::NavigationData::New();
clone->Graft(this->GetInput(index));
clonedDatas.push_back(clone);
if (m_StandardizeTime)
{
mitk::NavigationData::TimeStampType igtTimestamp = mitk::IGTTimeStamp::GetInstance()->GetElapsed(this);
clonedDatas[index]->SetIGTTimeStamp(igtTimestamp);
}
}
// if limitation is set and has been reached, stop recording
if ((m_RecordCountLimit > 0) && (m_NavigationDataSet->Size() >= static_cast<unsigned int>(m_RecordCountLimit)))
m_Recording = false;
// We can skip the rest of the method, if recording is deactivated
- if (!m_Recording)
- return;
-
+ if (!m_Recording) return;
+ // We can skip the rest of the method, if we read only valid data
+ if (m_RecordOnlyValidData && atLeastOneInputIsInvalid) return;
+
// Add data to set
m_NavigationDataSet->AddNavigationDatas(clonedDatas);
}
void mitk::NavigationDataRecorder::StartRecording()
{
if (m_Recording)
{
MITK_WARN << "Already recording please stop before start new recording session";
return;
}
m_Recording = true;
// The first time this StartRecording is called, we initialize the standardized time.
// Afterwards, it can be reset via ResetNavigationDataSet();
if (! m_StandardizedTimeInitialized)
mitk::IGTTimeStamp::GetInstance()->Start(this);
if (m_NavigationDataSet.IsNull())
m_NavigationDataSet = mitk::NavigationDataSet::New(GetNumberOfIndexedInputs());
}
void mitk::NavigationDataRecorder::StopRecording()
{
if (!m_Recording)
{
std::cout << "You have to start a recording first" << std::endl;
return;
}
m_Recording = false;
}
void mitk::NavigationDataRecorder::ResetRecording()
{
m_NavigationDataSet = mitk::NavigationDataSet::New(GetNumberOfIndexedInputs());
if (m_Recording)
{
mitk::IGTTimeStamp::GetInstance()->Stop(this);
mitk::IGTTimeStamp::GetInstance()->Start(this);
}
}
int mitk::NavigationDataRecorder::GetNumberOfRecordedSteps()
{
return m_NavigationDataSet->Size();
}
\ No newline at end of file
diff --git a/Modules/IGT/IO/mitkNavigationDataRecorder.h b/Modules/IGT/IO/mitkNavigationDataRecorder.h
index 4353d493d3..3ab694c634 100644
--- a/Modules/IGT/IO/mitkNavigationDataRecorder.h
+++ b/Modules/IGT/IO/mitkNavigationDataRecorder.h
@@ -1,120 +1,133 @@
/*===================================================================
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 _MITK_NavigationDataRecorder_H
#define _MITK_NavigationDataRecorder_H
#include "mitkNavigationDataToNavigationDataFilter.h"
#include "mitkNavigationData.h"
#include "mitkNavigationDataSet.h"
namespace mitk
{
/**Documentation
* \brief This class records NavigationData objects into NavigationDataSets.
*
* The recording is started with the call of the method StartRecording(). Now
* every Update() stores the current state of the added NavigationDatas into the NavigationDataSet.
* With StopRecording() the stream is stopped, but can be resumed anytime.
* To start recording to a new NavigationDataSet, call ResetRecording();
*
* \warning Do not add inputs while the recorder ist recording. The recorder can't handle that and will cause a nullpointer exception.
* \ingroup IGT
*/
class MITKIGT_EXPORT NavigationDataRecorder : public NavigationDataToNavigationDataFilter
{
public:
mitkClassMacro( NavigationDataRecorder, NavigationDataToNavigationDataFilter );
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
/**
* \brief Returns whether the NavigationDataRecorder is currently recording or not
*/
itkGetMacro(Recording, bool);
/**
* \brief Returns the set that contains all of the recorded data.
*/
itkGetMacro(NavigationDataSet, mitk::NavigationDataSet::Pointer);
/**
* \brief Sets a limit of recorded data sets / frames. Recording will be stopped if the number is reached. values < 1 disable this behaviour. Default is -1.
*/
itkSetMacro(RecordCountLimit, int);
/**
* \brief Returns whether to use the navigationdata's time stamp or to create a new one upon recording.
*/
itkGetMacro(StandardizeTime, bool);
/**
* \brief If set to false, the navigationDatas Timestamp will be used. If set to false, the recorder
* will generate a timestamp when it copies the data to the navigationdataset.
*/
itkSetMacro(StandardizeTime, bool);
+ /**
+ * \brief If set to false, invalid navigationDatas will also be used. If set to true, the recorder
+ * will record only valid data. Standard is false.
+ */
+ itkSetMacro(RecordOnlyValidData, bool);
+
+ /**
+ * \brief Returns whether to use valid data only.
+ */
+ itkGetMacro(RecordOnlyValidData, bool);
+
/**
* \brief Starts recording NavigationData into the NAvigationDataSet
*/
virtual void StartRecording();
/**
* \brief Stops StopsRecording to the NavigationDataSet.
*
* Recording can be resumed to the same Dataset by just calling StartRecording() again.
* Call ResetRecording() to start recording to a new Dataset;
*/
virtual void StopRecording();
/**
* \brief Resets the Datasets and the timestamp, so a new recording can happen.
*
* Do not forget to save the old Dataset, it will be lost after calling this function.
*/
virtual void ResetRecording();
/**
* \brief Returns the number of time steps that were recorded in the current set.
* Warning: This Method does NOT Stop Recording!
*/
virtual int GetNumberOfRecordedSteps();
protected:
virtual void GenerateData() override;
NavigationDataRecorder();
virtual ~NavigationDataRecorder();
unsigned int m_NumberOfInputs; ///< counts the numbers of added input NavigationDatas
mitk::NavigationDataSet::Pointer m_NavigationDataSet;
bool m_Recording; ///< indicates whether the recording is started or not
bool m_StandardizeTime; //< indicates whether one should use the timestamps in NavigationData or create new timestamps upon recording
bool m_StandardizedTimeInitialized; //< set to true the first time start recording is called.
int m_RecordCountLimit; ///< limits the number of frames, recording will be stopped if the limit is reached. -1 disables the limit
+
+ bool m_RecordOnlyValidData; //< indicates whether only valid data is recorded
};
}
#endif // #define _MITK_POINT_SET_SOURCE_H
diff --git a/Modules/IGT/IO/mitkNavigationToolReader.cpp b/Modules/IGT/IO/mitkNavigationToolReader.cpp
index 347a436428..2d35a82652 100644
--- a/Modules/IGT/IO/mitkNavigationToolReader.cpp
+++ b/Modules/IGT/IO/mitkNavigationToolReader.cpp
@@ -1,267 +1,272 @@
/*===================================================================
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.
===================================================================*/
//Poco headers
#include <Poco/Zip/Decompress.h>
#include <Poco/Path.h>
//mitk headers
#include "mitkNavigationToolReader.h"
#include "mitkTrackingTypes.h"
#include <mitkIOUtil.h>
#include <mitkSceneIO.h>
//All Tracking devices, which should be available by default
#include "mitkNDIAuroraTypeInformation.h"
#include "mitkNDIPolarisTypeInformation.h"
#include "mitkVirtualTrackerTypeInformation.h"
#include "mitkMicronTrackerTypeInformation.h"
#include "mitkNPOptitrackTrackingTypeInformation.h"
#include "mitkOpenIGTLinkTypeInformation.h"
#include "mitkUnspecifiedTrackingTypeInformation.h"
mitk::NavigationToolReader::NavigationToolReader()
{
m_ToolfilePath = mitk::IOUtil::GetTempPath() + Poco::Path::separator() + "IGT_Toolfiles" + Poco::Path::separator();
}
mitk::NavigationToolReader::~NavigationToolReader()
{
}
mitk::NavigationTool::Pointer mitk::NavigationToolReader::DoRead(std::string filename)
{
//decompress all files into a temporary directory
std::ifstream file(filename.c_str(), std::ios::binary);
if (!file.good())
{
m_ErrorMessage = "Cannot open '" + filename + "' for reading";
return nullptr;
}
std::string tempDirectory = m_ToolfilePath + GetFileWithoutPath(filename);
Poco::Zip::Decompress unzipper(file, Poco::Path(tempDirectory));
unzipper.decompressAllFiles();
//use SceneSerialization to load the DataStorage
mitk::SceneIO::Pointer mySceneIO = mitk::SceneIO::New();
mitk::DataStorage::Pointer loadedStorage = mySceneIO->LoadScene(tempDirectory + Poco::Path::separator() + GetFileWithoutPath(filename) + ".storage");
if (loadedStorage->GetAll()->size() == 0 || loadedStorage.IsNull())
{
m_ErrorMessage = "Invalid file: cannot parse tool data.";
return nullptr;
}
//convert the DataStorage back to a NavigationTool-Object
mitk::DataNode::Pointer myNode = loadedStorage->GetAll()->ElementAt(0);
mitk::NavigationTool::Pointer returnValue = ConvertDataNodeToNavigationTool(myNode, tempDirectory);
//delete the data-storage file which is not needed any more. The toolfile must be left in the temporary directory becauses it is linked in the datatreenode of the tool
std::remove((std::string(tempDirectory + Poco::Path::separator() + GetFileWithoutPath(filename) + ".storage")).c_str());
return returnValue;
}
mitk::NavigationTool::Pointer mitk::NavigationToolReader::ConvertDataNodeToNavigationTool(mitk::DataNode::Pointer node, std::string toolPath)
{
mitk::NavigationTool::Pointer returnValue = mitk::NavigationTool::New();
//DateTreeNode with Name and Surface
mitk::DataNode::Pointer newNode = mitk::DataNode::New();
newNode->SetName(node->GetName());
newNode->SetData(node->GetData());
bool visible = true;
node->GetVisibility(visible, NULL);
newNode->SetVisibility(visible);
returnValue->SetDataNode(newNode);
//Identifier
std::string identifier;
node->GetStringProperty("identifier", identifier);
returnValue->SetIdentifier(identifier);
//Serial Number
std::string serial;
node->GetStringProperty("serial number", serial);
returnValue->SetSerialNumber(serial);
//Tracking Device
mitk::TrackingDeviceType device_type;
node->GetStringProperty("tracking device type", device_type);
//For backward compability with old tool stroages (before 12/2015 device_type was an int value, now it is string)
if (device_type.size() == 0)
{
/*
This was the old enum. Numbers inserted for better readibility. Don't delete this if-case to allow loading of ols storages...
enum TrackingDeviceType
{
0 NDIPolaris, ///< Polaris: optical Tracker from NDI
1 NDIAurora, ///< Aurora: electromagnetic Tracker from NDI
2 ClaronMicron, ///< Micron Tracker: optical Tracker from Claron
3 IntuitiveDaVinci, ///< Intuitive Surgical: DaVinci Telemanipulator API Interface
4 AscensionMicroBird, ///< Ascension microBird / PCIBird family
5 VirtualTracker, ///< Virtual Tracking device class that produces random tracking coordinates
6 TrackingSystemNotSpecified, ///< entry for not specified or initialized tracking system
7 TrackingSystemInvalid, ///< entry for invalid state (mainly for testing)
8 NPOptitrack, ///< NaturalPoint: Optitrack optical Tracking System
9 OpenIGTLinkTrackingDeviceConnection ///< Device which is connected via open igt link
};
*/
int device_type_old;
node->GetIntProperty("tracking device type", device_type_old);
switch (device_type_old)
{
case 0:device_type = mitk::NDIPolarisTypeInformation::GetTrackingDeviceName(); break;
case 1:device_type = mitk::NDIAuroraTypeInformation::GetTrackingDeviceName(); break;
case 2:device_type = mitk::MicronTrackerTypeInformation::GetTrackingDeviceName(); break;
case 3:device_type = "IntuitiveDaVinci"; break;
case 4:device_type = "AscensionMicroBird"; break;
case 5:device_type = mitk::VirtualTrackerTypeInformation::GetTrackingDeviceName(); break;
case 6:device_type = mitk::UnspecifiedTrackingTypeInformation::GetTrackingDeviceName(); break;
case 7:device_type = "TrackingSystemInvalid"; break;
case 8:device_type = mitk::NPOptitrackTrackingTypeInformation::GetTrackingDeviceName(); break;
case 9:device_type = mitk::OpenIGTLinkTypeInformation::GetTrackingDeviceName(); break;
default: device_type = mitk::UnspecifiedTrackingTypeInformation::GetTrackingDeviceName(); break; //default... unknown...
}
}
returnValue->SetTrackingDeviceType(static_cast<mitk::TrackingDeviceType>(device_type));
//Tool Type
int type;
node->GetIntProperty("tracking tool type", type);
returnValue->SetType(static_cast<mitk::NavigationTool::NavigationToolType>(type));
//Calibration File Name
std::string calibration_filename;
node->GetStringProperty("toolfileName", calibration_filename);
if (calibration_filename == "none")
{
returnValue->SetCalibrationFile("none");
}
else
{
std::string calibration_filename_with_path = toolPath + Poco::Path::separator() + calibration_filename;
returnValue->SetCalibrationFile(calibration_filename_with_path);
}
//Tool Landmarks
mitk::PointSet::Pointer ToolRegLandmarks = mitk::PointSet::New();
mitk::PointSet::Pointer ToolCalLandmarks = mitk::PointSet::New();
std::string RegLandmarksString;
std::string CalLandmarksString;
node->GetStringProperty("ToolRegistrationLandmarks", RegLandmarksString);
node->GetStringProperty("ToolCalibrationLandmarks", CalLandmarksString);
ToolRegLandmarks = ConvertStringToPointSet(RegLandmarksString);
ToolCalLandmarks = ConvertStringToPointSet(CalLandmarksString);
returnValue->SetToolRegistrationLandmarks(ToolRegLandmarks);
returnValue->SetToolCalibrationLandmarks(ToolCalLandmarks);
//Tool Tip
std::string toolTipPositionString;
std::string toolTipOrientationString;
bool positionSet = node->GetStringProperty("ToolTipPosition", toolTipPositionString);
bool orientationSet = node->GetStringProperty("ToolTipOrientation", toolTipOrientationString);
if (positionSet && orientationSet) //only define tooltip if it is set
{
returnValue->SetToolTipPosition(ConvertStringToPoint(toolTipPositionString));
returnValue->SetToolTipOrientation(ConvertStringToQuaternion(toolTipOrientationString));
}
else if (positionSet != orientationSet)
{
MITK_WARN << "Tooltip definition incomplete: position and orientation have to be set! Skipping tooltip definition.";
}
+ //Tool Axis
+ std::string ToolAxisString;
+ node->GetStringProperty("ToolAxis", ToolAxisString);
+ returnValue->SetToolAxis(ConvertStringToPoint(ToolAxisString));
+
return returnValue;
}
std::string mitk::NavigationToolReader::GetFileWithoutPath(std::string FileWithPath)
{
Poco::Path myFile(FileWithPath.c_str());
return myFile.getFileName();
}
mitk::PointSet::Pointer mitk::NavigationToolReader::ConvertStringToPointSet(std::string string)
{
mitk::PointSet::Pointer returnValue = mitk::PointSet::New();
std::string pointSeperator = "|";
std::string valueSeperator = ";";
std::vector<std::string> points;
split(string, pointSeperator, points);
for (unsigned int i = 0; i < points.size(); i++)
{
std::vector<std::string> values;
split(points.at(i), valueSeperator, values);
if (values.size() == 4)
{
double index = atof(values.at(0).c_str());
mitk::Point3D point;
point[0] = atof(values.at(1).c_str());
point[1] = atof(values.at(2).c_str());
point[2] = atof(values.at(3).c_str());
returnValue->SetPoint(index, point);
}
}
return returnValue;
}
mitk::Point3D mitk::NavigationToolReader::ConvertStringToPoint(std::string string)
{
std::string valueSeperator = ";";
std::vector<std::string> values;
split(string, valueSeperator, values);
mitk::Point3D point;
if (values.size() == 3)
{
point[0] = atof(values.at(0).c_str());
point[1] = atof(values.at(1).c_str());
point[2] = atof(values.at(2).c_str());
}
return point;
}
mitk::Quaternion mitk::NavigationToolReader::ConvertStringToQuaternion(std::string string)
{
std::string valueSeperator = ";";
std::vector<std::string> values;
split(string, valueSeperator, values);
mitk::Quaternion quat = mitk::Quaternion(0, 0, 0, 1);
if (values.size() == 4)
{
quat = mitk::Quaternion(atof(values.at(0).c_str()),
atof(values.at(1).c_str()),
atof(values.at(2).c_str()),
atof(values.at(3).c_str()));
}
return quat;
}
void mitk::NavigationToolReader::split(std::string& text, std::string& separators, std::vector<std::string>& words)
{
int n = text.length();
int start, stop;
start = text.find_first_not_of(separators);
while ((start >= 0) && (start < n))
{
stop = text.find_first_of(separators, start);
if ((stop < 0) || (stop > n)) stop = n;
words.push_back(text.substr(start, stop - start));
start = text.find_first_not_of(separators, stop + 1);
}
}
diff --git a/Modules/IGT/IO/mitkNavigationToolWriter.cpp b/Modules/IGT/IO/mitkNavigationToolWriter.cpp
index 25819c8262..b07b333155 100644
--- a/Modules/IGT/IO/mitkNavigationToolWriter.cpp
+++ b/Modules/IGT/IO/mitkNavigationToolWriter.cpp
@@ -1,176 +1,179 @@
/*===================================================================
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.
===================================================================*/
//Poco headers
#include <Poco/Zip/Compress.h>
#include <Poco/Path.h>
//mitk headers
#include "mitkNavigationToolWriter.h"
#include <mitkStandaloneDataStorage.h>
#include <mitkProperties.h>
#include <mitkSceneIO.h>
#include <mitkPointSet.h>
#include <mitkIOUtil.h>
//std headers
#include <stdio.h>
mitk::NavigationToolWriter::NavigationToolWriter()
{
}
mitk::NavigationToolWriter::~NavigationToolWriter()
{
}
bool mitk::NavigationToolWriter::DoWrite(std::string FileName,mitk::NavigationTool::Pointer Tool)
{
//some initial validation checks...
if ( Tool.IsNull())
{
m_ErrorMessage = "Cannot write a navigation tool containing invalid tool data, aborting!";
MITK_ERROR << m_ErrorMessage;
return false;
}
// Workaround for a problem: the geometry might be modified if the tool is tracked. If this
// modified geometry is saved the surface representation is moved by this offset. To avoid
// this bug, the geometry is set to identity for the saving progress and restored later.
mitk::BaseGeometry::Pointer geometryBackup;
if ( Tool->GetDataNode().IsNotNull()
&& (Tool->GetDataNode()->GetData()!=nullptr)
&& (Tool->GetDataNode()->GetData()->GetGeometry()!=nullptr)
)
{
geometryBackup = Tool->GetDataNode()->GetData()->GetGeometry()->Clone();
Tool->GetDataNode()->GetData()->GetGeometry()->SetIdentity();
}
else {MITK_WARN << "Saving a tool with invalid data node, proceeding but errors might occure!";}
//convert whole data to a mitk::DataStorage
mitk::StandaloneDataStorage::Pointer saveStorage = mitk::StandaloneDataStorage::New();
mitk::DataNode::Pointer thisTool = ConvertToDataNode(Tool);
saveStorage->Add(thisTool);
//use SceneSerialization to save the DataStorage
std::string DataStorageFileName = mitk::IOUtil::CreateTemporaryDirectory() + Poco::Path::separator() + GetFileWithoutPath(FileName) + ".storage";
mitk::SceneIO::Pointer mySceneIO = mitk::SceneIO::New();
mySceneIO->SaveScene(saveStorage->GetAll(),saveStorage,DataStorageFileName);
//now put the DataStorage and the Toolfile in a ZIP-file
std::ofstream file( FileName.c_str(), std::ios::binary | std::ios::out);
if (!file.good())
{
m_ErrorMessage = "Could not open a zip file for writing: '" + FileName + "'";
MITK_ERROR << m_ErrorMessage;
return false;
}
else
{
Poco::Zip::Compress zipper( file, true );
zipper.addFile(DataStorageFileName,GetFileWithoutPath(DataStorageFileName));
if (Tool->GetCalibrationFile()!="none") zipper.addFile(Tool->GetCalibrationFile(),GetFileWithoutPath(Tool->GetCalibrationFile()));
zipper.close();
}
//delete the data storage
std::remove(DataStorageFileName.c_str());
//restore original geometry
if (geometryBackup.IsNotNull()) {Tool->GetDataNode()->GetData()->SetGeometry(geometryBackup);}
return true;
}
mitk::DataNode::Pointer mitk::NavigationToolWriter::ConvertToDataNode(mitk::NavigationTool::Pointer Tool)
{
mitk::DataNode::Pointer thisTool = mitk::DataNode::New();
//Name
if (Tool->GetDataNode().IsNull()) thisTool->SetName("none");
else thisTool->SetName(Tool->GetDataNode()->GetName().c_str());
//Identifier
thisTool->AddProperty("identifier",mitk::StringProperty::New(Tool->GetIdentifier().c_str()));
//Serial Number
thisTool->AddProperty("serial number",mitk::StringProperty::New(Tool->GetSerialNumber().c_str()));
//Tracking Device
thisTool->AddProperty("tracking device type",mitk::StringProperty::New(Tool->GetTrackingDeviceType()));
//Tool Type
thisTool->AddProperty("tracking tool type",mitk::IntProperty::New(Tool->GetType()));
//Calibration File Name
thisTool->AddProperty("toolfileName",mitk::StringProperty::New(GetFileWithoutPath(Tool->GetCalibrationFile())));
//Surface
if (Tool->GetDataNode().IsNotNull()) if (Tool->GetDataNode()->GetData() != NULL)
{
thisTool->SetData(Tool->GetDataNode()->GetData());
//Visibility
bool visible = true;
Tool->GetDataNode()->GetVisibility(visible, NULL);
thisTool->SetVisibility(visible);
}
//Tool Landmarks
thisTool->AddProperty("ToolRegistrationLandmarks",mitk::StringProperty::New(ConvertPointSetToString(Tool->GetToolRegistrationLandmarks())));
thisTool->AddProperty("ToolCalibrationLandmarks",mitk::StringProperty::New(ConvertPointSetToString(Tool->GetToolCalibrationLandmarks())));
//Tool Tip
if (Tool->IsToolTipSet())
{
thisTool->AddProperty("ToolTipPosition",mitk::StringProperty::New(ConvertPointToString(Tool->GetToolTipPosition())));
thisTool->AddProperty("ToolTipOrientation",mitk::StringProperty::New(ConvertQuaternionToString(Tool->GetToolTipOrientation())));
}
+ //Tool Axis
+ thisTool->AddProperty("ToolAxis", mitk::StringProperty::New(ConvertPointToString(Tool->GetToolAxis())));
+
//Material is not needed, to avoid errors in scene serialization we have to do this:
thisTool->ReplaceProperty("material",nullptr);
return thisTool;
}
std::string mitk::NavigationToolWriter::GetFileWithoutPath(std::string FileWithPath)
{
Poco::Path myFile(FileWithPath.c_str());
return myFile.getFileName();
}
std::string mitk::NavigationToolWriter::ConvertPointSetToString(mitk::PointSet::Pointer pointSet)
{
std::stringstream returnValue;
mitk::PointSet::PointDataIterator it;
for ( it = pointSet->GetPointSet()->GetPointData()->Begin();it != pointSet->GetPointSet()->GetPointData()->End();it++ )
{
mitk::Point3D thisPoint = pointSet->GetPoint(it->Index());
returnValue << it->Index() << ";" << ConvertPointToString(thisPoint) << "|";
}
return returnValue.str();
}
std::string mitk::NavigationToolWriter::ConvertPointToString(mitk::Point3D point)
{
std::stringstream returnValue;
returnValue << point[0] << ";" << point[1] << ";" << point[2];
return returnValue.str();
}
std::string mitk::NavigationToolWriter::ConvertQuaternionToString(mitk::Quaternion quat)
{
std::stringstream returnValue;
returnValue << quat.x() << ";" << quat.y() << ";" << quat.z() << ";" << quat.r();
return returnValue.str();
}
diff --git a/Modules/IGT/MITKIGTHardware.cmake b/Modules/IGT/MITKIGTHardware.cmake
index 21c9309de8..b18e590db4 100644
--- a/Modules/IGT/MITKIGTHardware.cmake
+++ b/Modules/IGT/MITKIGTHardware.cmake
@@ -1,49 +1,48 @@
#Begin MicronTracker Hardware
option(MITK_USE_MICRON_TRACKER "Enable support for micron tracker hardware" OFF)
#Begin Optitrack Hardware
option(MITK_USE_OPTITRACK_TRACKER "Enable support for Optitrack tracker hardware" OFF)
option(MITK_USE_POLHEMUS_TRACKER "Enable support for Polhemus tracker hardware" OFF)
# only if MicronTracker is enabled
if(MITK_USE_MICRON_TRACKER)
find_library(MITK_MICRON_TRACKER_LIB MTC DOC "Path which contains the MT2 library.")
get_filename_component(MICRON_TRACKER_SDK_DIR ${MITK_MICRON_TRACKER_LIB} PATH)
find_path(MITK_MICRON_TRACKER_INCLUDE_DIR MTC.h ${MICRON_TRACKER_SDK_DIR} DOC "Include directory of the MT2.")
- find_path(MITK_MICRON_TRACKER_TEMP_DIR . DOC "Any temporary directory which can be used by the MicronTracker2.")
MITK_INSTALL(FILES ${MICRON_TRACKER_SDK_DIR}/MTC.dll CONFIGURATIONS Release)
MITK_INSTALL(FILES ${MICRON_TRACKER_SDK_DIR}/MTInterfaceDotNet.dll CONFIGURATIONS Release)
MITK_INSTALL(FILES ${MICRON_TRACKER_SDK_DIR}/PGRFlyCapture.dll CONFIGURATIONS Release)
ENDIF(MITK_USE_MICRON_TRACKER)
#End MicronTracker Hardware
#only if Optitrack is enabled
if(MITK_USE_OPTITRACK_TRACKER)
find_library(MITK_OPTITRACK_TRACKER_LIB NPTrackingTools DOC "Path which contains the Optitrack library. Please choose 32/64 bit version depending on your build.")
find_path(MITK_OPTITRACK_TRACKER_INCLUDE_DIR NPTrackinTools.h DOC "Include directory of the Optitrack library.")
find_path(MITK_OPTITRACK_TRACKER_LIB_DIR NPTrackingTools.dll)
MITK_INSTALL(FILES ${MITK_OPTITRACK_TRACKER_LIB_DIR}/NPTrackingTools.dll CONFIGURATIONS Release)
MITK_INSTALL(FILES ${MITK_OPTITRACK_TRACKER_LIB_DIR}/NPTrackingToolsx64.dll CONFIGURATIONS Release)
ENDIF(MITK_USE_OPTITRACK_TRACKER)
#End Optitrack Hardware
if(MITK_USE_POLHEMUS_TRACKER)
find_library(MITK_POLHEMUS_TRACKER_LIB PDI DOC "Path which contains the Polhemus library.")
find_path(MITK_POLHEMUS_TRACKER_INCLUDE_DIR PDI.h DOC "Include directory of the Polhemus library.")
ENDIF(MITK_USE_POLHEMUS_TRACKER)
# only on Win32
if(WIN32)
#Begin Ascension MicroBird Hardware
option(MITK_USE_MICROBIRD_TRACKER "Enable support for Ascension MicroBird tracker hardware" OFF)
if(MITK_USE_MICROBIRD_TRACKER)
add_definitions(-DMITK_USE_MICROBIRD_TRACKER)
find_library(MITK_USE_MICROBIRD_TRACKER_LIB PCIBird3)
get_filename_component(MICROBIRD_TRACKER_API_DIR ${MITK_USE_MICROBIRD_TRACKER_LIB} PATH)
find_path(MITK_USE_MICROBIRD_TRACKER_INCLUDE_DIR PCIBird3.h ${MICROBIRD_TRACKER_API_DIR})
endif(MITK_USE_MICROBIRD_TRACKER)
#End MicroBird Hardware
endif(WIN32)
diff --git a/Modules/IGT/TrackingDevices/mitkClaronTrackingDevice.cpp b/Modules/IGT/TrackingDevices/mitkClaronTrackingDevice.cpp
index dce85d5488..1ded0e39b1 100644
--- a/Modules/IGT/TrackingDevices/mitkClaronTrackingDevice.cpp
+++ b/Modules/IGT/TrackingDevices/mitkClaronTrackingDevice.cpp
@@ -1,333 +1,331 @@
/*===================================================================
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 "mitkClaronTrackingDevice.h"
#include "mitkClaronTool.h"
#include "mitkIGTConfig.h"
#include "mitkIGTTimeStamp.h"
#include "mitkIGTHardwareException.h"
#include <itksys/SystemTools.hxx>
#include <iostream>
#include <itkMutexLockHolder.h>
+#include <mitkIOUtil.h>
#include <mitkMicronTrackerTypeInformation.h>
typedef itk::MutexLockHolder<itk::FastMutexLock> MutexLockHolder;
mitk::ClaronTrackingDevice::ClaronTrackingDevice(): mitk::TrackingDevice()
{
//set the type of this tracking device
this->m_Data = mitk::MicronTrackerTypeInformation::GetDeviceDataMicronTrackerH40();
this->m_MultiThreader = itk::MultiThreader::New();
m_ThreadID = 0;
m_Device = mitk::ClaronInterface::New();
- //############################# standard directories (from cmake) ##################################
+ //############################# standard directories ##################################
if (m_Device->IsMicronTrackerInstalled())
{
-#ifdef MITK_MICRON_TRACKER_TEMP_DIR
- m_ToolfilesDir = std::string(MITK_MICRON_TRACKER_TEMP_DIR);
- m_ToolfilesDir.append("/MT-tools");
-#endif
+ m_ToolfilesDir = mitk::IOUtil::CreateTemporaryDirectory();
#ifdef MITK_MICRON_TRACKER_CALIBRATION_DIR
m_CalibrationDir = std::string(MITK_MICRON_TRACKER_CALIBRATION_DIR);
#endif
}
else
{
m_ToolfilesDir = "Error - No Microntracker installed";
m_CalibrationDir = "Error - No Microntracker installed";
}
//##################################################################################################
m_Device->Initialize(m_CalibrationDir, m_ToolfilesDir);
}
bool mitk::ClaronTrackingDevice::IsDeviceInstalled()
{
mitk::ClaronInterface::Pointer tempInterface = mitk::ClaronInterface::New();
return tempInterface->IsMicronTrackerInstalled();
}
mitk::ClaronTrackingDevice::~ClaronTrackingDevice()
{
}
mitk::TrackingTool* mitk::ClaronTrackingDevice::AddTool( const char* toolName, const char* fileName )
{
mitk::ClaronTool::Pointer t = mitk::ClaronTool::New();
if (t->LoadFile(fileName) == false)
{
return nullptr;
}
t->SetToolName(toolName);
if (this->InternalAddTool(t) == false)
return nullptr;
return t.GetPointer();
}
bool mitk::ClaronTrackingDevice::InternalAddTool(ClaronTool::Pointer tool)
{
m_AllTools.push_back(tool);
return true;
}
std::vector<mitk::ClaronTool::Pointer> mitk::ClaronTrackingDevice::DetectTools()
{
std::vector<mitk::ClaronTool::Pointer> returnValue;
std::vector<claronToolHandle> allHandles = m_Device->GetAllActiveTools();
for (auto iter = allHandles.begin(); iter != allHandles.end(); ++iter)
{
ClaronTool::Pointer newTool = ClaronTool::New();
newTool->SetToolName(m_Device->GetName(*iter));
newTool->SetCalibrationName(m_Device->GetName(*iter));
newTool->SetToolHandle(*iter);
returnValue.push_back(newTool);
}
return returnValue;
}
bool mitk::ClaronTrackingDevice::StartTracking()
{
//By Alfred: next line because no temp directory is set if MicronTracker is not installed
if (!m_Device->IsMicronTrackerInstalled())
return false;
//##################################################################################
//be sure that the temp-directory is empty at start: delete all files in the tool files directory
itksys::SystemTools::RemoveADirectory(m_ToolfilesDir.c_str());
itksys::SystemTools::MakeDirectory(m_ToolfilesDir.c_str());
//copy all toolfiles into the temp directory
for (unsigned int i=0; i<m_AllTools.size(); i++)
{
itksys::SystemTools::CopyAFile(m_AllTools[i]->GetFile().c_str(), m_ToolfilesDir.c_str());
}
this->SetState(Tracking); // go to mode Tracking
this->m_StopTrackingMutex->Lock(); // update the local copy of m_StopTracking
this->m_StopTracking = false;
this->m_StopTrackingMutex->Unlock();
//restart the Microntracker, so it will load the new tool files
m_Device->StopTracking();
m_Device->Initialize(m_CalibrationDir,m_ToolfilesDir);
if (m_Device->StartTracking())
{
mitk::IGTTimeStamp::GetInstance()->Start(this);
m_ThreadID = m_MultiThreader->SpawnThread(this->ThreadStartTracking, this); // start a new thread that executes the TrackTools() method
return true;
}
else
{mitkThrowException(mitk::IGTHardwareException) << "Error while trying to start the device!";}
}
bool mitk::ClaronTrackingDevice::StopTracking()
{
Superclass::StopTracking();
//delete all files in the tool files directory
itksys::SystemTools::RemoveADirectory(m_ToolfilesDir.c_str());
return true;
}
unsigned int mitk::ClaronTrackingDevice::GetToolCount() const
{
return (unsigned int)this->m_AllTools.size();
}
mitk::TrackingTool* mitk::ClaronTrackingDevice::GetTool(unsigned int toolNumber) const
{
if ( toolNumber >= this->GetToolCount())
return nullptr;
else
return this->m_AllTools[toolNumber];
}
bool mitk::ClaronTrackingDevice::OpenConnection()
{
bool returnValue;
//Create the temp directory
itksys::SystemTools::MakeDirectory(m_ToolfilesDir.c_str());
m_Device->Initialize(m_CalibrationDir,m_ToolfilesDir);
returnValue = m_Device->StartTracking();
if (returnValue)
{
this->SetState(Ready);
}
else
{
//reset everything
if (m_Device.IsNull())
{
m_Device = mitk::ClaronInterface::New();
m_Device->Initialize(m_CalibrationDir, m_ToolfilesDir);
}
m_Device->StopTracking();
this->SetState(Setup);
mitkThrowException(mitk::IGTHardwareException) << "Error while trying to open connection to the MicronTracker.";
}
return returnValue;
}
bool mitk::ClaronTrackingDevice::CloseConnection()
{
bool returnValue = true;
if (this->GetState() == Setup)
return true;
returnValue = m_Device->StopTracking();
//delete the temporary directory
itksys::SystemTools::RemoveADirectory(m_ToolfilesDir.c_str());
this->SetState(Setup);
return returnValue;
}
mitk::ClaronInterface* mitk::ClaronTrackingDevice::GetDevice()
{
return m_Device;
}
std::vector<mitk::ClaronTool::Pointer> mitk::ClaronTrackingDevice::GetAllTools()
{
return this->m_AllTools;
}
void mitk::ClaronTrackingDevice::TrackTools()
{
try
{
/* lock the TrackingFinishedMutex to signal that the execution rights are now transfered to the tracking thread */
MutexLockHolder trackingFinishedLockHolder(*m_TrackingFinishedMutex); // keep lock until end of scope
bool localStopTracking; // Because m_StopTracking is used by two threads, access has to be guarded by a mutex. To minimize thread locking, a local copy is used here
this->m_StopTrackingMutex->Lock(); // update the local copy of m_StopTracking
localStopTracking = this->m_StopTracking;
this->m_StopTrackingMutex->Unlock();
while ((this->GetState() == Tracking) && (localStopTracking == false))
{
this->GetDevice()->GrabFrame();
std::vector<mitk::ClaronTool::Pointer> detectedTools = this->DetectTools();
std::vector<mitk::ClaronTool::Pointer> allTools = this->GetAllTools();
std::vector<mitk::ClaronTool::Pointer>::iterator itAllTools;
for(itAllTools = allTools.begin(); itAllTools != allTools.end(); itAllTools++)
{
mitk::ClaronTool::Pointer currentTool = *itAllTools;
//test if current tool was detected
std::vector<mitk::ClaronTool::Pointer>::iterator itDetectedTools;
bool foundTool = false;
for(itDetectedTools = detectedTools.begin(); itDetectedTools != detectedTools.end(); itDetectedTools++)
{
mitk::ClaronTool::Pointer aktuDet = *itDetectedTools;
std::string tempString(currentTool->GetCalibrationName());
if (tempString.compare(aktuDet->GetCalibrationName())==0)
{
currentTool->SetToolHandle(aktuDet->GetToolHandle());
foundTool = true;
}
}
if (!foundTool)
{
currentTool->SetToolHandle(0);
}
if (currentTool->GetToolHandle() != 0)
{
currentTool->SetDataValid(true);
//get tip position of tool:
std::vector<double> pos_vector = this->GetDevice()->GetTipPosition(currentTool->GetToolHandle());
//write tip position into tool:
mitk::Point3D pos;
pos[0] = pos_vector[0];
pos[1] = pos_vector[1];
pos[2] = pos_vector[2];
currentTool->SetPosition(pos);
//get tip quaternion of tool
std::vector<double> quat = this->GetDevice()->GetTipQuaternions(currentTool->GetToolHandle());
//write tip quaternion into tool
mitk::Quaternion orientation(quat[1], quat[2], quat[3], quat[0]);
currentTool->SetOrientation(orientation);
//TODO: read the timestamp data from the tracking device interface
currentTool->SetIGTTimeStamp(mitk::IGTTimeStamp::GetInstance()->GetElapsed());
}
else
{
mitk::Point3D origin;
origin.Fill(0);
currentTool->SetPosition(origin);
currentTool->SetOrientation(mitk::Quaternion(0,0,0,0));
currentTool->SetDataValid(false);
}
}
/* Update the local copy of m_StopTracking */
this->m_StopTrackingMutex->Lock();
localStopTracking = m_StopTracking;
this->m_StopTrackingMutex->Unlock();
}
}
catch(...)
{
this->StopTracking();
mitkThrowException(mitk::IGTHardwareException) << "Error while trying to track tools. Thread stopped.";
}
}
bool mitk::ClaronTrackingDevice::IsMicronTrackerInstalled()
{
return this->m_Device->IsMicronTrackerInstalled();
}
ITK_THREAD_RETURN_TYPE mitk::ClaronTrackingDevice::ThreadStartTracking(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;
}
ClaronTrackingDevice *trackingDevice = (ClaronTrackingDevice*)pInfo->UserData;
if (trackingDevice != nullptr)
trackingDevice->TrackTools();
return ITK_THREAD_RETURN_VALUE;
}
diff --git a/Modules/IGT/TrackingDevices/mitkOpenIGTLinkTrackingDevice.cpp b/Modules/IGT/TrackingDevices/mitkOpenIGTLinkTrackingDevice.cpp
index ab3f6a8190..3c26e8fcbf 100644
--- a/Modules/IGT/TrackingDevices/mitkOpenIGTLinkTrackingDevice.cpp
+++ b/Modules/IGT/TrackingDevices/mitkOpenIGTLinkTrackingDevice.cpp
@@ -1,446 +1,638 @@
/*===================================================================
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->EnableNoBufferingMode(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();
+
+ if (std::string(msgType).empty())
+ {
+ MITK_INFO << "Did not receive a message. Do you have to start the stream manually at the server?";
+ MITK_INFO << "Waiting for 10 seconds ...";
+ receivedMessage = ReceiveMessage(10000);
+ msgType = receivedMessage->GetIGTLMessageType();
+ }
+
+ mitk::OpenIGTLinkTrackingDevice::TrackingMessageType type = GetMessageTypeFromString(msgType);
+
+ returnValue = DiscoverToolsAndConvertToNavigationTools(type);
+ /*
+ 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 or 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;
+}
+
+mitk::NavigationToolStorage::Pointer mitk::OpenIGTLinkTrackingDevice::DiscoverToolsAndConvertToNavigationTools(mitk::OpenIGTLinkTrackingDevice::TrackingMessageType type, int NumberOfMessagesToWait)
+{
+ MITK_INFO << "Start discovering tools by " << type << " 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;
+}
+
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 nullptr;
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;
}
- //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);
-
- mitk::IGTLMessage::Pointer receivedMessage;
-
- 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));
- }
+ 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:
- return DiscoverToolsFromTData(dynamic_cast<igtl::TrackingDataMessage*>(receivedMessage->GetMessage().GetPointer()));
+ foundTools = DiscoverToolsFromTData(dynamic_cast<igtl::TrackingDataMessage*>(receivedMessage->GetMessage().GetPointer()));
+ break;
case QTDATA:
- return DiscoverToolsFromQTData(dynamic_cast<igtl::QuaternionTrackingDataMessage*>(receivedMessage->GetMessage().GetPointer()));
+ foundTools = DiscoverToolsFromQTData(dynamic_cast<igtl::QuaternionTrackingDataMessage*>(receivedMessage->GetMessage().GetPointer()));
+ break;
case TRANSFORM:
- return DiscoverToolsFromTransform();
+ 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;
}
-bool mitk::OpenIGTLinkTrackingDevice::DiscoverToolsFromTData(igtl::TrackingDataMessage::Pointer tdMsg)
+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[2] = {"STT_QTDATA","STT_TDATA"};
+
+ for (int i = 0; i < 2; i++)
+ {
+ igtl::MessageBase::Pointer sttMsg = msgFactory->CreateInstance(message[i]);
+ //TODO: Fix this to dynamically get this from GUI
+ ((igtl::StartTrackingDataMessage*)sttMsg.GetPointer())->SetResolution(m_UpdateRate);
+ m_OpenIGTLinkClient->SendMessage(mitk::IGTLMessage::New(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 false;
+ 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();
- AddNewToolForName(name, i);
+
+ std::stringstream identifier;
+ identifier << "AutoDetectedTool-" << i;
+ i++;
+
+ mitk::NavigationTool::Pointer newTool = ConstructDefaultOpenIGTLinkTool(name, identifier.str());
+
+ returnValue->AddTool(newTool);
}
m_IGTLDeviceSource->StopCommunication();
SetState(Ready);
- return true;
+ return returnValue;
}
-bool mitk::OpenIGTLinkTrackingDevice::DiscoverToolsFromQTData(igtl::QuaternionTrackingDataMessage::Pointer msg)
+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 false;
+ 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();
- AddNewToolForName(name, i);
+
+ std::stringstream identifier;
+ identifier << "AutoDetectedTool-" << i;
+ i++;
+
+ mitk::NavigationTool::Pointer newTool = ConstructDefaultOpenIGTLinkTool(name, identifier.str());
+
+ returnValue->AddTool(newTool);
}
m_IGTLDeviceSource->StopCommunication();
SetState(Ready);
- return true;
+ 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);
}
-bool mitk::OpenIGTLinkTrackingDevice::DiscoverToolsFromTransform()
+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;
- bool condition = false;
- while (!condition)
+
+ for (int j=0; j<NumberOfMessagesToWait; j++)
{
- //TODO: Fix this.. :/
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;
}
- condition = true;
int count = toolNameMap[msg->GetDeviceName()];
if (count == 0)
{
- MITK_WARN << "ADDED NEW TOOL TO TOOLCHAIN: " << msg->GetDeviceName() << " - 1";
+ //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()];
- }
-
- for (std::map<std::string, int>::iterator it = toolNameMap.begin(); it != toolNameMap.end(); ++it)
- {
- if (it->second < 5)
- {
- condition = false;
- break;
- }
+ //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)
{
- AddNewToolForName(it->first, i++);
+ 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);
}
- //TODO InternalAddTool for all tools
- return true;
+ 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);
+ m_OpenIGTLinkClient->EnableNoBufferingMode(true);
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;
}
+ m_OpenIGTLinkClient->EnableNoBufferingMode(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 nullptr;
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;
}
}
diff --git a/Modules/IGT/TrackingDevices/mitkOpenIGTLinkTrackingDevice.h b/Modules/IGT/TrackingDevices/mitkOpenIGTLinkTrackingDevice.h
index a2263a7043..e040ce5ee5 100644
--- a/Modules/IGT/TrackingDevices/mitkOpenIGTLinkTrackingDevice.h
+++ b/Modules/IGT/TrackingDevices/mitkOpenIGTLinkTrackingDevice.h
@@ -1,166 +1,188 @@
/*===================================================================
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 MITKOPENIGTLINKTRACKINGDEVICE_H_HEADER_INCLUDED_
#define MITKOPENIGTLINKTRACKINGDEVICE_H_HEADER_INCLUDED_
#include <mitkIGTConfig.h>
#include <mitkTrackingDevice.h>
#include <mitkOpenIGTLinkTrackingTool.h>
#include <mitkIGTLClient.h>
#include <mitkIGTLDeviceSource.h>
#include <mitkIGTLMessageToNavigationDataFilter.h>
#include <itkMultiThreader.h>
#include <igtlQuaternionTrackingDataMessage.h>
#include <igtlTrackingDataMessage.h>
#include <igtlTransformMessage.h>
#include "mitkIGTLTransformDeviceSource.h"
namespace mitk
{
/** Documentation:
* \brief An object of this class represents the MicronTracker device. You can add tools to this
* device, then open the connection and start tracking. The tracking device will then
* continuously update the tool coordinates.
* \ingroup IGT
*/
class MITKIGT_EXPORT OpenIGTLinkTrackingDevice : public TrackingDevice
{
public:
mitkClassMacro(OpenIGTLinkTrackingDevice, TrackingDevice);
itkFactorylessNewMacro(Self)
itkCloneMacro(Self)
/** Sets the port number for the Open IGT Link connection. Default value is -1 (invalid). */
void SetPortNumber(int portNumber);
/** Sets the hostname for the Open IGT Link connection. Default value is 127.0.0.1 (localhost). */
void SetHostname(std::string hostname);
int GetPortNumber();
std::string GetHostname();
/**
* \brief Starts the tracking.
* \return Returns true if the tracking is started. Throws an exception if an error occures.
* @throw mitk::IGTHardwareException Throws an exception if there is an error during start tracking.
*/
virtual bool StartTracking();
/**
* \brief Stops the tracking.
* \return Returns true if the tracking is stopped.
*/
virtual bool StopTracking();
/**
* \brief Opens the connection to the device. This have to be done before the tracking is started.
* @throw mitk::IGTHardwareException Throws an exception if there is an error during open connection.
*/
virtual bool OpenConnection();
/**
* \brief Closes the connection and clears all resources.
*/
virtual bool CloseConnection();
/**
* \return Returns the number of tools which have been added to the device.
*/
virtual unsigned int GetToolCount() const;
/**
* \param toolNumber The number of the tool which should be given back.
* \return Returns the tool which the number "toolNumber". Returns nullptr, if there is
* no tool with this number.
*/
TrackingTool* GetTool(unsigned int toolNumber) const;
/**
* \brief Discover the tools available from the connected OpenIGTLink device and adds these tools to this tracking device. Therefore, a connection
* is opened, the tools are discovered and added.
* \param WaitingTime Defines how long the method waits for an answer from the server (in milliseconds). Default value is 10000 (10 seconds).
* \return Returns true if the connection was established and the tools were discovered successfully and - if at least one tool was found - were added to this device.
* Retruns false if no valid connection is available.
*/
bool DiscoverTools(int WaitingTime = 10000);
/**
* \brief Create a new OpenIGTLink tool with toolName and fileName and add it to the list of tools
*
* Note that tools are usually provided by the OpenIGTLink connection. In most cases, the method DiscoverTools() should be used
* instead which automatically finds the provided tools. If you use this method to manually add tools be sure that you add the
* same number and type of tools that are provided by the connected device. Otherwise problems might occur when you try to start
* tracking.
*/
mitk::TrackingTool* AddTool(const char* toolName, const char* fileName);
+ /** @return Returns true if this device can autodetects its tools. */
+ virtual bool AutoDetectToolsAvailable();
+
+ /** Autodetects tools from the current OpenIGTLink connection and returns them as a navigation tool storage.
+ * @return Returns the detected tools. Returns an empty storage if no tools are present
+ * or if OpenIGTLink Connection is not possible
+ */
+ virtual mitk::NavigationToolStorage::Pointer AutoDetectTools();
+
bool IsDeviceInstalled();
itkSetMacro(UpdateRate, int); ///< Sets the update rate of the device in fps. Default value is 60 fps.
itkGetConstMacro(UpdateRate, int); ///< Returns the update rate of the device in fps
protected:
OpenIGTLinkTrackingDevice();
~OpenIGTLinkTrackingDevice();
/**
* \brief Adds a tool to the tracking device.
*
* \param tool The tool which will be added.
* \return Returns true if the tool has been added, false otherwise.
*/
bool InternalAddTool(OpenIGTLinkTrackingTool::Pointer tool);
/** Updates the tools from the open IGT link connection. Is called every time a message received event is invoked.*/
void UpdateTools();
unsigned long m_MessageReceivedObserverTag;
+ /** Receives one message from the OpenIGTLink connection. Starts the tracking stream if required.
+ */
+ mitk::IGTLMessage::Pointer ReceiveMessage(int waitingTime);
+
/**
* \return Returns all tools of the tracking device.
*/
std::vector<OpenIGTLinkTrackingTool::Pointer> GetAllTools();
//OpenIGTLink connection class
mitk::IGTLClient::Pointer m_OpenIGTLinkClient;
//OpenIGTLink pipeline
mitk::IGTLTransformDeviceSource::Pointer m_IGTLDeviceSource;
mitk::IGTLMessageToNavigationDataFilter::Pointer m_IGTLMsgToNavDataFilter;
std::vector<OpenIGTLinkTrackingTool::Pointer> m_AllTools; ///< vector holding all tools
int m_UpdateRate; ///< holds the update rate in FPS (will be set automatically when the OpenIGTLink connection is established)
private:
enum TrackingMessageType
{
TDATA, TRANSFORM, QTDATA, UNKNOWN
};
mitk::OpenIGTLinkTrackingDevice::TrackingMessageType GetMessageTypeFromString(const char* messageTypeString);
- bool DiscoverToolsFromTData(igtl::TrackingDataMessage::Pointer msg);
+ /** Discovers tools from the OpenIGTLink connection and converts them to MITK navigation tool objects.
+ @return Returns a navigation tool storage holding all found tools. Returns an empty storage if no tools were found or if there was an error.*/
+ mitk::NavigationToolStorage::Pointer DiscoverToolsAndConvertToNavigationTools(mitk::OpenIGTLinkTrackingDevice::TrackingMessageType type, int NumberOfMessagesToWait = 50);
+
+ /** Discovers tools from the input (type TDATA) */
+ mitk::NavigationToolStorage::Pointer DiscoverToolsFromTData(igtl::TrackingDataMessage::Pointer msg);
- bool DiscoverToolsFromQTData(igtl::QuaternionTrackingDataMessage::Pointer msg);
+ /** Discovers tools from the input (type QTDATA) */
+ mitk::NavigationToolStorage::Pointer DiscoverToolsFromQTData(igtl::QuaternionTrackingDataMessage::Pointer msg);
- bool DiscoverToolsFromTransform();
+ /** Discovers tools from the input (type TRANSFORM) and waits for the given number of messages */
+ mitk::NavigationToolStorage::Pointer DiscoverToolsFromTransform(int NumberOfMessagesToWait = 50);
void AddNewToolForName(std::string name, int i);
+
+ mitk::NavigationTool::Pointer ConstructDefaultOpenIGTLinkTool(std::string name, std::string identifier);
};
}//mitk
#endif /* MITKOpenIGTLinkTRACKINGDEVICE_H_HEADER_INCLUDED_ */
diff --git a/Modules/IGT/TrackingDevices/mitkPolhemusInterface.cpp b/Modules/IGT/TrackingDevices/mitkPolhemusInterface.cpp
index 26f1b570b8..7e4af215c8 100644
--- a/Modules/IGT/TrackingDevices/mitkPolhemusInterface.cpp
+++ b/Modules/IGT/TrackingDevices/mitkPolhemusInterface.cpp
@@ -1,200 +1,207 @@
/*===================================================================
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 <mitkPolhemusInterface.h>
#define _USE_MATH_DEFINES
#include <math.h>
#include <PDI.h>
BYTE MotionBuf[0x1FA400];
-mitk::PolhemusInterface::PolhemusInterface()
+mitk::PolhemusInterface::PolhemusInterface() : m_continousTracking(false)
{
m_pdiDev = new CPDIdev();
}
mitk::PolhemusInterface::~PolhemusInterface()
{
delete m_pdiDev;
}
bool mitk::PolhemusInterface::InitializeDevice()
{
m_pdiDev->ResetTracker();
m_pdiDev->ResetSAlignment(-1);
m_pdiDev->Trace(TRUE, 7);
+ m_continousTracking = false;
return true;
}
bool mitk::PolhemusInterface::SetupDevice()
{
m_pdiDev->SetPnoBuffer(MotionBuf, 0x1FA400);
m_pdiDev->SetMetric(true); //use cm instead of inches
m_pdiDev->StartPipeExport();
CPDImdat pdiMDat;
pdiMDat.Empty();
pdiMDat.Append(PDI_MODATA_FRAMECOUNT);
pdiMDat.Append(PDI_MODATA_POS);
pdiMDat.Append(PDI_MODATA_ORI);
m_pdiDev->SetSDataList(-1, pdiMDat);
CPDIbiterr cBE;
m_pdiDev->GetBITErrs(cBE);
if (!(cBE.IsClear())) {m_pdiDev->ClearBITErrs();}
if (this->m_HemisphereTrackingEnabled) { m_pdiDev->SetSHemiTrack(-1); }
else { m_pdiDev->SetSHemisphere(-1, { (float)2.54,0,0 }); }
return true;
}
bool mitk::PolhemusInterface::StartTracking()
{
LPCTSTR szWindowClass = _T("PDIconsoleWinClass");
HINSTANCE hInst = GetModuleHandle(0);
HWND hwnd = CreateWindowEx(
WS_EX_NOACTIVATE,//WS_EX_STATICEDGE, //
szWindowClass,
_T("MyWindowName"),
WS_POPUP,
0, 0, 1, 1,
HWND_MESSAGE,
0,
hInst,
0);
m_continousTracking = true;
return m_pdiDev->StartContPno(hwnd);
}
bool mitk::PolhemusInterface::StopTracking()
{
m_continousTracking = false;
return true;
}
bool mitk::PolhemusInterface::Connect()
{
if (!InitializeDevice()) { return false; }
if (m_pdiDev->CnxReady()) { return true; }
CPDIser pdiSer;
m_pdiDev->SetSerialIF(&pdiSer);
ePiCommType eType = m_pdiDev->DiscoverCnx();
switch (eType)
{
case PI_CNX_USB:
MITK_INFO << "USB Connection: " << m_pdiDev->GetLastResultStr();
break;
case PI_CNX_SERIAL:
MITK_INFO << "Serial Connection: " << m_pdiDev->GetLastResultStr();
break;
default:
MITK_INFO << "DiscoverCnx result: " << m_pdiDev->GetLastResultStr();
break;
}
if (!SetupDevice()) { return false; }
return m_pdiDev->CnxReady();
}
bool mitk::PolhemusInterface::Disconnect()
{
if (m_continousTracking)
{
m_continousTracking = false;
if (!m_pdiDev->Disconnect()) return false;
}
return true;
}
std::vector<mitk::PolhemusInterface::trackingData> mitk::PolhemusInterface::GetLastFrame()
{
PBYTE pBuf;
DWORD dwSize;
//read one frame
if (!m_pdiDev->LastPnoPtr(pBuf, dwSize)) {MITK_WARN << m_pdiDev->GetLastResultStr();}
std::vector<mitk::PolhemusInterface::trackingData> returnValue = ParsePolhemusRawData(pBuf, dwSize);
if (returnValue.empty()) { MITK_WARN << "Cannot parse data / no tools present"; }
return returnValue;
}
unsigned int mitk::PolhemusInterface::GetNumberOfTools()
{
if (m_continousTracking) return GetLastFrame().size();
else return GetSingleFrame().size();
}
std::vector<mitk::PolhemusInterface::trackingData> mitk::PolhemusInterface::GetSingleFrame()
{
- if (m_continousTracking) return std::vector<mitk::PolhemusInterface::trackingData>();
-
+ if (m_continousTracking)
+ {
+ MITK_WARN << "Cannot get tool count when continously tracking";
+ return std::vector<mitk::PolhemusInterface::trackingData>();
+ }
PBYTE pBuf;
DWORD dwSize;
//read one frame
- if (!m_pdiDev->ReadSinglePnoBuf(pBuf, dwSize)) { MITK_WARN << m_pdiDev->GetLastResultStr(); }
+ if (!m_pdiDev->ReadSinglePnoBuf(pBuf, dwSize)) {
+ MITK_WARN << m_pdiDev->GetLastResultStr();
+ return std::vector<mitk::PolhemusInterface::trackingData>();
+ }
return ParsePolhemusRawData(pBuf, dwSize);
}
std::vector<mitk::PolhemusInterface::trackingData> mitk::PolhemusInterface::ParsePolhemusRawData(PBYTE pBuf, DWORD dwSize)
{
std::vector<mitk::PolhemusInterface::trackingData> returnValue;
DWORD i = 0;
while (i<dwSize)
{
BYTE ucSensor = pBuf[i + 2];
SHORT shSize = pBuf[i + 6];
// skip rest of header
i += 8;
PDWORD pFC = (PDWORD)(&pBuf[i]);
PFLOAT pPno = (PFLOAT)(&pBuf[i + 4]);
mitk::PolhemusInterface::trackingData currentTrackingData;
currentTrackingData.id = ucSensor;
currentTrackingData.pos[0] = pPno[0] * 10; //from cm to mm
currentTrackingData.pos[1] = pPno[1] * 10;
currentTrackingData.pos[2] = pPno[2] * 10;
double azimuthAngle = pPno[3] / 180 * M_PI; //from degree to rad
double elevationAngle = pPno[4] / 180 * M_PI;
double rollAngle = pPno[5] / 180 * M_PI;
vnl_quaternion<double> eulerQuat(rollAngle, elevationAngle, azimuthAngle);
currentTrackingData.rot = eulerQuat;
returnValue.push_back(currentTrackingData);
i += shSize;
}
return returnValue;
}
diff --git a/Modules/IGT/TrackingDevices/mitkTrackingVolumeGenerator.cpp b/Modules/IGT/TrackingDevices/mitkTrackingVolumeGenerator.cpp
index 5f044a9fbf..caed56dd1e 100644
--- a/Modules/IGT/TrackingDevices/mitkTrackingVolumeGenerator.cpp
+++ b/Modules/IGT/TrackingDevices/mitkTrackingVolumeGenerator.cpp
@@ -1,131 +1,195 @@
/*===================================================================
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 "mitkTrackingVolumeGenerator.h"
#include "mitkStandardFileLocations.h"
#include "mitkConfig.h"
#include <vtkCubeSource.h>
#include <mitkTrackingTypes.h>
#include <mitkTrackingDevice.h>
#include <mitkVirtualTrackingDevice.h>
#include <vtkSmartPointer.h>
#include <mitkSurface.h>
#include <mitkIOMimeTypes.h>
#include <mitkFileReaderRegistry.h>
#include <usModuleContext.h>
#include <usGetModuleContext.h>
#include <usModule.h>
#include <usModuleResource.h>
#include <usModuleResourceStream.h>
+#include <mitkCoreServices.h>
+#include <mitkIFileReader.h>
#include <mitkIOUtil.h>
+#include <mitkIOMimeTypes.h>
+#include <mitkMimeType.h>
+#include <mitkIMimeTypeProvider.h>
#include "mitkUnspecifiedTrackingTypeInformation.h"
#include "mitkTrackingDeviceTypeCollection.h"
+#include <algorithm>
+
+namespace {
+
+//! Workaround until IOUtil::LoadSurface will guarantee to load mitk::Surface
+//! even in presence of reader services that load STL as another type of
+//! BaseData (T19825).
+mitk::Surface::Pointer LoadCoreSurface(const us::ModuleResource& usResource)
+{
+ us::ModuleResourceStream resStream(usResource, std::ios_base::in);
+
+ mitk::CoreServicePointer<mitk::IMimeTypeProvider> mimeTypeProvider(mitk::CoreServices::GetMimeTypeProvider());
+ // get mime types for file (extension) and for surfaces
+ std::vector<mitk::MimeType> mimetypesForFile = mimeTypeProvider->GetMimeTypesForFile(usResource.GetResourcePath());
+ std::vector<mitk::MimeType> mimetypesForSurface = mimeTypeProvider->GetMimeTypesForCategory(mitk::IOMimeTypes::CATEGORY_SURFACES());
+
+ // construct our candidates as the intersection of both sets because we need something that
+ // handles the type type _and_ produces a surface out of it
+ std::vector<mitk::MimeType> mimetypes;
+
+ std::sort(mimetypesForFile.begin(), mimetypesForFile.end());
+ std::sort(mimetypesForSurface.begin(), mimetypesForSurface.end());
+ std::set_intersection(mimetypesForFile.begin(), mimetypesForFile.end(),
+ mimetypesForSurface.begin(), mimetypesForSurface.end(),
+ std::back_inserter(mimetypes));
+
+ mitk::Surface::Pointer surface;
+ if (mimetypes.empty())
+ {
+ mitkThrow() << "No mimetype for resource stream: " << usResource.GetResourcePath();
+ return surface;
+ }
+
+ mitk::FileReaderRegistry fileReaderRegistry;
+ std::vector<us::ServiceReference<mitk::IFileReader>> refs = fileReaderRegistry.GetReferences(mimetypes[0]);
+ if (refs.empty())
+ {
+ mitkThrow() << "No reader available for resource stream: " << usResource.GetResourcePath();
+ return surface;
+ }
+
+ mitk::IFileReader *reader = fileReaderRegistry.GetReader(refs[0]);
+ reader->SetInput(usResource.GetResourcePath(), &resStream);
+ auto basedatas = reader->Read();
+ if (!basedatas.empty())
+ {
+ surface = dynamic_cast<mitk::Surface*>(basedatas.front().GetPointer());
+ }
+
+ return surface;
+}
+
+} // unnamed namespace
+
mitk::TrackingVolumeGenerator::TrackingVolumeGenerator()
{
m_Data = mitk::UnspecifiedTrackingTypeInformation::GetDeviceDataUnspecified();
}
void mitk::TrackingVolumeGenerator::SetTrackingDevice (mitk::TrackingDevice::Pointer tracker)
{
std::vector<us::ServiceReference<mitk::TrackingDeviceTypeCollection> > refs = us::GetModuleContext()->GetServiceReferences<mitk::TrackingDeviceTypeCollection>();
if (refs.empty())
{
MITK_ERROR << "No tracking device service found!";
}
mitk::TrackingDeviceTypeCollection* deviceTypeCollection = us::GetModuleContext()->GetService<mitk::TrackingDeviceTypeCollection>(refs.front());
this->m_Data = deviceTypeCollection->GetFirstCompatibleDeviceDataForLine(tracker->GetType());
}
void mitk::TrackingVolumeGenerator::GenerateData()
{
mitk::Surface::Pointer output = this->GetOutput(); //the surface wich represents the tracking volume
- std::string filepath = ""; // Full path to file (wil be resolved later)
std::string filename = this->m_Data.VolumeModelLocation; // Name of the file or possibly a magic String, e.g. "cube"
MITK_INFO << "volume: " << filename;
// See if filename matches a magic string.
if (filename.compare("cube") == 0){
vtkSmartPointer<vtkCubeSource> cubeSource = vtkSmartPointer<vtkCubeSource>::New();
double bounds[6];
bounds[0] = bounds[2] = bounds[4] = -400.0; // initialize bounds to -400 ... +400 cube. This is the default value of the
bounds[1] = bounds[3] = bounds[5] = 400.0; // virtual tracking device, but it can be changed. In that case,
// the tracking volume polydata has to be updated manually
cubeSource->SetBounds(bounds);
cubeSource->Update();
output->SetVtkPolyData(cubeSource->GetOutput()); //set the vtkCubeSource as polyData of the surface
return;
}
if (filename.compare("") == 0) // empty String means no model, return empty output
{
// initialize with empty poly data (otherwise old surfaces may be returned) => so an empty surface is returned
vtkPolyData *emptyPolyData = vtkPolyData::New();
output->SetVtkPolyData(emptyPolyData);
emptyPolyData->Delete();
return;
}
// from here on, we assume that filename contains an actual filename and not a magic string
us::Module* module = us::GetModuleContext()->GetModule();
-
us::ModuleResource moduleResource = module->GetResource(filename);
- std::vector<mitk::BaseData::Pointer> data = mitk::IOUtil::Load(moduleResource);
-
- if(data.empty())
- MITK_ERROR << "Exception while reading file:";
-
- mitk::Surface::Pointer fileoutput = dynamic_cast<mitk::Surface*>(data[0].GetPointer());
-
- output->SetVtkPolyData(fileoutput->GetVtkPolyData());
+ // TODO one would want to call mitk::IOUtils::LoadSurface(moduleResource) here.
+ // However this function is not guaranteed to find a reader that loads
+ // named resource as a Surface (given the presence of alternative readers
+ // that produce another data type but has a higher ranking than the core
+ // surface reader) - see bug T22608.
+ mitk::Surface::Pointer fileoutput = LoadCoreSurface(moduleResource);
+ if (fileoutput == nullptr)
+ {
+ MITK_ERROR << "Exception while casting data loaded from file: " << moduleResource.GetResourcePath();
+ output->SetVtkPolyData(vtkSmartPointer<vtkPolyData>(vtkPolyData::New()));
+ }
+ else
+ {
+ output->SetVtkPolyData(fileoutput->GetVtkPolyData());
+ }
}
void mitk::TrackingVolumeGenerator::SetTrackingDeviceType(mitk::TrackingDeviceType deviceType)
{
std::vector<us::ServiceReference<mitk::TrackingDeviceTypeCollection> > refs = us::GetModuleContext()->GetServiceReferences<mitk::TrackingDeviceTypeCollection>();
if (refs.empty())
{
MITK_ERROR << "No tracking device service found!";
}
mitk::TrackingDeviceTypeCollection* deviceTypeCollection = us::GetModuleContext()->GetService<mitk::TrackingDeviceTypeCollection>(refs.front());
m_Data = deviceTypeCollection->GetFirstCompatibleDeviceDataForLine(deviceType);
}
mitk::TrackingDeviceType mitk::TrackingVolumeGenerator::GetTrackingDeviceType() const
{
return m_Data.Line;
}
void mitk::TrackingVolumeGenerator::SetTrackingDeviceData(mitk::TrackingDeviceData deviceData)
{
m_Data= deviceData;
}
mitk::TrackingDeviceData mitk::TrackingVolumeGenerator::GetTrackingDeviceData() const
{
return m_Data;
}
diff --git a/Modules/IGT/autoload/DeviceRegistry/src/mitkIGTActivator.cpp b/Modules/IGT/autoload/DeviceRegistry/src/mitkIGTActivator.cpp
index 8e34c40cd4..9965796486 100644
--- a/Modules/IGT/autoload/DeviceRegistry/src/mitkIGTActivator.cpp
+++ b/Modules/IGT/autoload/DeviceRegistry/src/mitkIGTActivator.cpp
@@ -1,70 +1,78 @@
/*===================================================================
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 "mitkIGTConfig.h"
#include "mitkIGTActivator.h"
//All Tracking devices, which should be available by default
#include "mitkNDIAuroraTypeInformation.h"
#include "mitkNDIPolarisTypeInformation.h"
#include "mitkVirtualTrackerTypeInformation.h"
+#ifdef MITK_USE_MICRON_TRACKER
#include "mitkMicronTrackerTypeInformation.h"
+#endif
+#ifdef MITK_USE_OPTITRACK_TRACKER
#include "mitkNPOptitrackTrackingTypeInformation.h"
+#endif
#include "mitkOpenIGTLinkTypeInformation.h"
#ifdef MITK_USE_POLHEMUS_TRACKER
#include "mitkPolhemusTrackerTypeInformation.h"
#endif
namespace mitk
{
IGTActivator::IGTActivator()
{
}
IGTActivator::~IGTActivator()
{
}
void IGTActivator::Load(us::ModuleContext*)
{
m_DeviceTypeCollection.RegisterTrackingDeviceType(new mitk::NDIAuroraTypeInformation());
m_DeviceTypeCollection.RegisterTrackingDeviceType(new mitk::NDIPolarisTypeInformation());
- m_DeviceTypeCollection.RegisterTrackingDeviceType(new mitk::MicronTrackerTypeInformation());
- m_DeviceTypeCollection.RegisterTrackingDeviceType(new mitk::NPOptitrackTrackingTypeInformation());
m_DeviceTypeCollection.RegisterTrackingDeviceType(new mitk::VirtualTrackerTypeInformation());
m_DeviceTypeCollection.RegisterTrackingDeviceType(new mitk::OpenIGTLinkTypeInformation());
+#ifdef MITK_USE_OPTITRACK_TRACKER
+ m_DeviceTypeCollection.RegisterTrackingDeviceType(new mitk::NPOptitrackTrackingTypeInformation());
+#endif
+#ifdef MITK_USE_MICRON_TRACKER
+ m_DeviceTypeCollection.RegisterTrackingDeviceType(new mitk::MicronTrackerTypeInformation());
+#endif
#ifdef MITK_USE_POLHEMUS_TRACKER
m_DeviceTypeCollection.RegisterTrackingDeviceType(new mitk::PolhemusTrackerTypeInformation());
#endif
m_DeviceTypeCollection.RegisterAsMicroservice();
}
void IGTActivator::Unload(us::ModuleContext*)
{
try
{
m_DeviceTypeCollection.UnRegisterMicroservice();
}
catch (std::exception& e)
{
MITK_WARN << "Unable to unregister IGT DeviceTypeCollection Microservice: "<<e.what();
}
}
}
US_EXPORT_MODULE_ACTIVATOR(mitk::IGTActivator)
diff --git a/Modules/IGT/mitkIGTConfig.h.in b/Modules/IGT/mitkIGTConfig.h.in
index 5680c76a27..c76df88a23 100644
--- a/Modules/IGT/mitkIGTConfig.h.in
+++ b/Modules/IGT/mitkIGTConfig.h.in
@@ -1,10 +1,9 @@
/*
mitkIGTConfig.h
this file is generated. Do not change!
*/
#cmakedefine MITK_USE_MICRON_TRACKER
-#cmakedefine MITK_MICRON_TRACKER_TEMP_DIR "@MITK_MICRON_TRACKER_TEMP_DIR@"
#cmakedefine MITK_MICRON_TRACKER_CALIBRATION_DIR "@MITK_MICRON_TRACKER_CALIBRATION_DIR@"
#cmakedefine MITK_USE_POLHEMUS_TRACKER
#define MITK_IGT_DATA_DIR "@MITK_DATA_DIR@/IGT-Data"
diff --git a/Modules/IGTBase/include/mitkNavigationData.h b/Modules/IGTBase/include/mitkNavigationData.h
index bcecdd9d72..fc393a6727 100644
--- a/Modules/IGTBase/include/mitkNavigationData.h
+++ b/Modules/IGTBase/include/mitkNavigationData.h
@@ -1,298 +1,298 @@
/*===================================================================
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 MITKNAVIGATIONDATA_H_HEADER_INCLUDED_
#define MITKNAVIGATIONDATA_H_HEADER_INCLUDED_
#include <itkDataObject.h>
#include <MitkIGTBaseExports.h>
#include <mitkCommon.h>
#include <mitkNumericTypes.h>
namespace mitk {
/**Documentation
* \brief Navigation Data
*
* This class represents the data object that is passed through the MITK-IGT navigation filter
* pipeline. It encapsulates position and orientation of a tracked tool/sensor. Additionally,
* it contains a data structure that contains error/plausibility information
*
* It provides methods to work with the affine transformation represented by its orientation and position.
* Additionally, it provides a constructor to construct a NavigationData object from an AffineTransform3D and
* a getter to create an AffineTransform3D from a NavigationData object.
*
* \ingroup IGT
*/
class MITKIGTBASE_EXPORT NavigationData : public itk::DataObject
{
public:
mitkClassMacroItkParent(NavigationData, itk::DataObject);
itkFactorylessNewMacro(Self);
itkCloneMacro(Self);
mitkNewMacro2Param(Self, mitk::AffineTransform3D::Pointer, const bool);
mitkNewMacro1Param(Self, mitk::AffineTransform3D::Pointer);
/**
* \brief Type that holds the position part of the tracking data
*/
typedef mitk::Point3D PositionType;
/**
* \brief Type that holds the orientation part of the tracking data
*/
typedef mitk::Quaternion OrientationType;
/**
* \brief type that holds the error characterization of the position and orientation measurements
*/
typedef itk::Matrix<mitk::ScalarType,6,6> CovarianceMatrixType;
/**
- * \brief type that holds the time at which the data was recorded
+ * \brief type that holds the time at which the data was recorded in milliseconds
*/
typedef double TimeStampType;
/**
* \brief sets the position of the NavigationData object
*/
itkSetMacro(Position, PositionType);
/**
* \brief returns position of the NavigationData object
*/
itkGetConstMacro(Position, PositionType);
/**
* \brief sets the orientation of the NavigationData object
*/
itkSetMacro(Orientation, OrientationType);
/**
* \brief returns the orientation of the NavigationData object
*/
itkGetConstMacro(Orientation, OrientationType);
/**
* \brief returns true if the object contains valid data
*/
virtual bool IsDataValid() const;
/**
* \brief sets the dataValid flag of the NavigationData object indicating if the object contains valid data
*/
itkSetMacro(DataValid, bool);
/**
- * \brief sets the IGT timestamp of the NavigationData object
+ * \brief sets the IGT timestamp of the NavigationData object in milliseconds
*/
itkSetMacro(IGTTimeStamp, TimeStampType);
/**
- * \brief gets the IGT timestamp of the NavigationData object
+ * \brief gets the IGT timestamp of the NavigationData object in milliseconds
* Please note, that there is also the GetTimeStamp method provided by the ITK object. Within IGT you should always use GetIGTTimeStamp !
*/
itkGetConstMacro(IGTTimeStamp, TimeStampType);
/**
* \brief sets the HasPosition flag of the NavigationData object
*/
itkSetMacro(HasPosition, bool);
/**
* \brief gets the HasPosition flag of the NavigationData object
*/
itkGetConstMacro(HasPosition, bool);
/**
* \brief sets the HasOrientation flag of the NavigationData object
*/
itkSetMacro(HasOrientation, bool);
/**
* \brief gets the HasOrientation flag of the NavigationData object
*/
itkGetConstMacro(HasOrientation, bool);
/**
* \brief sets the 6x6 Error Covariance Matrix of the NavigationData object
*/
itkSetMacro(CovErrorMatrix, CovarianceMatrixType);
/**
* \brief gets the 6x6 Error Covariance Matrix of the NavigationData object
*/
itkGetConstMacro(CovErrorMatrix, CovarianceMatrixType);
/**
* \brief set the name of the NavigationData object
*/
itkSetStringMacro(Name);
/**
* \brief returns the name of the NavigationData object
*/
itkGetStringMacro(Name);
/**
* \brief Graft the data and information from one NavigationData to another.
*
* Copies the content of data into this object.
* This is a convenience method to setup a second NavigationData object with all the meta
* information of another NavigationData object.
* Note that this method is different than just using two
* SmartPointers to the same NavigationData object since separate DataObjects are
* still maintained.
*/
virtual void Graft(const DataObject *data) override;
/**
* \brief copy meta data of a NavigationData object
*
* copies all meta data from NavigationData 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;
/**
* Set the position part of m_CovErrorMatrix to I*error^2
* This means that all position variables are assumed to be independent
*/
void SetPositionAccuracy(mitk::ScalarType error);
/**
* Set the orientation part of m_CovErrorMatrix to I*error^2
* This means that all orientation variables are assumed to be independent
*/
void SetOrientationAccuracy(mitk::ScalarType error);
/**
* \brief Calculate AffineTransform3D from the transformation held by this NavigationData.
* TODO: should throw an error if transformation is invalid.
*/
mitk::AffineTransform3D::Pointer GetAffineTransform3D() const;
/**
* \brief Calculate the RotationMatrix of this transformation.
*/
mitk::Matrix3D GetRotationMatrix() const;
/**
* \brief Transform by an affine transformation
*
* This method applies the affine transform given by self to a
* given point, returning the transformed point.
*/
mitk::Point3D TransformPoint(const mitk::Point3D point) const;
/**
* Get inverse of the Transformation represented by this NavigationData.
* @throws mitk::Exception in case the transformation is invalid (only case: quaternion is zero)
*/
mitk::NavigationData::Pointer GetInverse() const;
/** Compose with another NavigationData
*
* This method composes self with another NavigationData 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::NavigationData::Pointer n, const bool pre = false);
protected:
mitkCloneMacro(Self);
NavigationData();
/*
* Copy constructor internally used.
*/
NavigationData(const mitk::NavigationData& toCopy);
/**
* Creates a NavigationData object from an affineTransform3D.
* Caution: NavigationData doesn't support spacing, only translation and rotation. If the affine
* transform includes spacing it cannot be converted to a NavigationData and an exception is thrown.
* @param checkForRotationMatrix if this is true, the rotation matrix coming from the affineTransform is checked
* for being a rotation matrix. If it isn't, an exception is thrown. Disable this check by
* setting checkForRotationMatrix to false.
*
* @throws mitkException if checkForRotationMatrix is true and a non rotation matrix was introduced by
* AffineTransform.
*/
NavigationData(mitk::AffineTransform3D::Pointer affineTransform3D, const bool checkForRotationMatrix = true);
virtual ~NavigationData();
/**
* \brief holds the position part of the tracking data
*/
PositionType m_Position;
/**
* \brief holds the orientation part of the tracking data
*/
OrientationType m_Orientation;
/**
* \brief A 6x6 covariance matrix parameterizing the Gaussian error
* distribution of the measured position and orientation.
*
* The hasPosition/hasOrientation fields define which entries
* are valid.
*/
CovarianceMatrixType m_CovErrorMatrix; ///< holds the error characterization of the position and orientation
/**
* \brief defines if position part of m_CovErrorMatrix is valid
*/
bool m_HasPosition;
/**
* \brief defines if orientation part of m_CovErrorMatrix is valid
*/
bool m_HasOrientation;
/**
* \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:
void ResetCovarianceValidity();
// pre = false
static mitk::NavigationData::Pointer getComposition(const mitk::NavigationData::Pointer nd1, const mitk::NavigationData::Pointer nd2);
};
/**
* @brief Equal A function comparing two navigation data objects for beeing equal in meta- and imagedata
*
* @ingroup MITKTestingAPI
*
* Following aspects are tested for equality:
* - position
* - orientation
* - other members and flags of the class
*
* @param rightHandSide An NavigationData to be compared
* @param leftHandSide An NavigationData 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
*/
MITKIGTBASE_EXPORT bool Equal( const mitk::NavigationData& leftHandSide, const mitk::NavigationData& rightHandSide, ScalarType eps = mitk::eps, bool verbose = false );
} // namespace mitk
#endif /* MITKNAVIGATIONDATA_H_HEADER_INCLUDED_ */
diff --git a/Modules/IGTBase/src/mitkNavigationData.cpp b/Modules/IGTBase/src/mitkNavigationData.cpp
index d9050923b3..629cbcc928 100644
--- a/Modules/IGTBase/src/mitkNavigationData.cpp
+++ b/Modules/IGTBase/src/mitkNavigationData.cpp
@@ -1,385 +1,392 @@
/*===================================================================
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 "mitkNavigationData.h"
#include "vnl/vnl_det.h"
#include "mitkException.h"
mitk::NavigationData::NavigationData() : itk::DataObject(),
m_Position(), m_Orientation(0.0, 0.0, 0.0, 1.0), m_CovErrorMatrix(),
m_HasPosition(true), m_HasOrientation(true), m_DataValid(false), m_IGTTimeStamp(0.0),
m_Name()
{
m_Position.Fill(0.0);
m_CovErrorMatrix.SetIdentity();
}
mitk::NavigationData::NavigationData(const mitk::NavigationData& toCopy) : itk::DataObject(),
m_Position(toCopy.GetPosition()), m_Orientation(toCopy.GetOrientation()), m_CovErrorMatrix(toCopy.GetCovErrorMatrix()),
m_HasPosition(toCopy.GetHasPosition()), m_HasOrientation(toCopy.GetHasOrientation()), m_DataValid(toCopy.IsDataValid()), m_IGTTimeStamp(toCopy.GetIGTTimeStamp()),
m_Name(toCopy.GetName())
{/* TODO SW: Graft does the same, remove code duplications, set Graft to deprecated, remove duplication in tescode */}
mitk::NavigationData::~NavigationData()
{
}
void mitk::NavigationData::Graft( const DataObject *data )
{
// Attempt to cast data to an NavigationData
const Self* nd;
try
{
nd = dynamic_cast<const Self *>( data );
}
catch( ... )
{
itkExceptionMacro( << "mitk::NavigationData::Graft cannot cast "
<< typeid(data).name() << " to "
<< typeid(const Self *).name() );
return;
}
if (!nd)
{
// pointer could not be cast back down
itkExceptionMacro( << "mitk::NavigationData::Graft cannot cast "
<< typeid(data).name() << " to "
<< typeid(const Self *).name() );
return;
}
// Now copy anything that is needed
this->SetPosition(nd->GetPosition());
this->SetOrientation(nd->GetOrientation());
this->SetDataValid(nd->IsDataValid());
this->SetIGTTimeStamp(nd->GetIGTTimeStamp());
this->SetHasPosition(nd->GetHasPosition());
this->SetHasOrientation(nd->GetHasOrientation());
this->SetCovErrorMatrix(nd->GetCovErrorMatrix());
this->SetName(nd->GetName());
}
bool mitk::NavigationData::IsDataValid() const
{
- return m_DataValid;
+ if (m_Position[0] == 0.0 && m_Position[1] == 0.0 && m_Position[2] == 0.0)
+ {
+ return false;
+ }
+ else
+ {
+ return m_DataValid;
+ }
}
void mitk::NavigationData::PrintSelf(std::ostream& os, itk::Indent indent) const
{
this->Superclass::PrintSelf(os, indent);
os << indent << "data valid: " << this->IsDataValid() << std::endl;
os << indent << "Position: " << this->GetPosition() << std::endl;
os << indent << "Orientation: " << this->GetOrientation() << std::endl;
os << indent << "TimeStamp: " << this->GetIGTTimeStamp() << std::endl;
os << indent << "HasPosition: " << this->GetHasPosition() << std::endl;
os << indent << "HasOrientation: " << this->GetHasOrientation() << std::endl;
os << indent << "CovErrorMatrix: " << this->GetCovErrorMatrix() << std::endl;
}
void mitk::NavigationData::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::NavigationData::CopyInformation() cannot cast "
<< typeid(data).name() << " to "
<< typeid(Self*).name() );
}
if ( !nd )
{
// pointer could not be cast back down
itkExceptionMacro(<< "mitk::NavigationData::CopyInformation() cannot cast "
<< typeid(data).name() << " to "
<< typeid(Self*).name() );
}
/* copy all meta data */
}
void mitk::NavigationData::SetPositionAccuracy(mitk::ScalarType error)
{
for ( int i = 0; i < 3; i++ )
for ( int j = 0; j < 3; j++ )
{
m_CovErrorMatrix[ i ][ j ] = 0;
// assume independence of position and orientation
m_CovErrorMatrix[ i + 3 ][ j ] = 0;
m_CovErrorMatrix[ i ][ j + 3 ] = 0;
}
m_CovErrorMatrix[0][0] = m_CovErrorMatrix[1][1] = m_CovErrorMatrix[2][2] = error * error;
}
void mitk::NavigationData::SetOrientationAccuracy(mitk::ScalarType error)
{
for ( int i = 0; i < 3; i++ )
for ( int j = 0; j < 3; j++ ) {
m_CovErrorMatrix[ i + 3 ][ j + 3 ] = 0;
// assume independence of position and orientation
m_CovErrorMatrix[ i + 3 ][ j ] = 0;
m_CovErrorMatrix[ i ][ j + 3 ] = 0;
}
m_CovErrorMatrix[3][3] = m_CovErrorMatrix[4][4] = m_CovErrorMatrix[5][5] = error * error;
}
void
mitk::NavigationData::Compose(const mitk::NavigationData::Pointer n, const bool pre)
{
NavigationData::Pointer nd3;
if (!pre)
nd3 = getComposition(this, n);
else
nd3 = getComposition(n, this);
this->Graft(nd3);
}
mitk::NavigationData::NavigationData(
mitk::AffineTransform3D::Pointer affineTransform3D,
const bool checkForRotationMatrix) : itk::DataObject(),
m_Position(),
m_CovErrorMatrix(), m_HasPosition(true), m_HasOrientation(true), m_DataValid(true), m_IGTTimeStamp(0.0),
m_Name()
{
mitk::Vector3D offset = affineTransform3D->GetOffset();
m_Position[0] = offset[0];
m_Position[1] = offset[1];
m_Position[2] = offset[2];
vnl_matrix_fixed<ScalarType, 3, 3> rotationMatrix = affineTransform3D->GetMatrix().GetVnlMatrix();
vnl_matrix_fixed<ScalarType, 3, 3> rotationMatrixTransposed = rotationMatrix.transpose();
if (checkForRotationMatrix)
{
// a quadratic matrix is a rotation matrix exactly when determinant is 1 and transposed is inverse
if (!Equal(1.0, vnl_det(rotationMatrix), 0.1)
|| !((rotationMatrix*rotationMatrixTransposed).is_identity(0.1)))
{
mitkThrow() << "tried to initialize NavigationData with non-rotation matrix :" << rotationMatrix << " (Does your AffineTransform3D object include spacing? This is not supported by NavigationData objects!)";
}
}
// the transpose is because vnl_quaterion expects a transposed rotation matrix
m_Orientation = Quaternion(rotationMatrixTransposed);
}
mitk::AffineTransform3D::Pointer
mitk::NavigationData::GetAffineTransform3D() const
{
AffineTransform3D::Pointer affineTransform3D = AffineTransform3D::New();
// first set rotation
affineTransform3D->SetMatrix(this->GetRotationMatrix());
// now set offset
Vector3D vector3D;
for (int i = 0; i < 3; ++i) {
vector3D[i] = m_Position[i];
}
affineTransform3D->SetOffset(vector3D);
return affineTransform3D;
}
mitk::Matrix3D
mitk::NavigationData::GetRotationMatrix() const
{
vnl_matrix_fixed<ScalarType,3,3> vnl_rotation = m_Orientation.rotation_matrix_transpose().transpose(); // :-)
Matrix3D mitkRotation;
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
mitkRotation[i][j] = vnl_rotation[i][j];
}
}
return mitkRotation;
}
mitk::Point3D
mitk::NavigationData::TransformPoint(const mitk::Point3D point) const
{
vnl_vector_fixed<ScalarType, 3> vnlPoint;
for (int i = 0; i < 3; ++i) {
vnlPoint[i] = point[i];
}
Quaternion normalizedQuaternion = this->GetOrientation().normalize();
// first get rotated point
vnlPoint = normalizedQuaternion.rotate(vnlPoint);
Point3D resultingPoint;
for (int i = 0; i < 3; ++i) {
// now copy it to our format + offset
resultingPoint[i] = vnlPoint[i] + this->GetPosition()[i];
}
return resultingPoint;
}
mitk::NavigationData::Pointer
mitk::NavigationData::GetInverse() const
{
// non-zero quaternion does not have inverse: throw exception in this case.
Quaternion zeroQuaternion;
zeroQuaternion.fill(0);
if (Equal(zeroQuaternion, this->GetOrientation()))
mitkThrow() << "tried to invert zero quaternion in NavigationData";
mitk::NavigationData::Pointer navigationDataInverse = this->Clone();
navigationDataInverse->SetOrientation(this->GetOrientation().inverse());
// To vnl_vector
vnl_vector_fixed<ScalarType, 3> vnlPoint;
for (int i = 0; i < 3; ++i) {
vnlPoint[i] = this->GetPosition()[i];
}
// invert position
vnlPoint = -(navigationDataInverse->GetOrientation().rotate(vnlPoint));
// back to Point3D
Point3D invertedPosition = this->GetPosition();
for (int i = 0; i < 3; ++i) {
invertedPosition[i] = vnlPoint[i];
}
navigationDataInverse->SetPosition(invertedPosition);
// Inversion does not care for covariances for now
navigationDataInverse->ResetCovarianceValidity();
return navigationDataInverse;
}
void
mitk::NavigationData::ResetCovarianceValidity()
{
this->SetHasPosition(false);
this->SetHasOrientation(false);
}
mitk::NavigationData::Pointer
mitk::NavigationData::getComposition(const mitk::NavigationData::Pointer nd1,
const mitk::NavigationData::Pointer nd2)
{
NavigationData::Pointer nd3 = nd1->Clone();
// A2 * A1
nd3->SetOrientation(nd2->GetOrientation() * nd1->GetOrientation());
// first: b1, b2 vnl vector
vnl_vector_fixed<ScalarType,3> b1, b2, b3;
for (int i = 0; i < 3; ++i) {
b1[i] = nd1->GetPosition()[i];
b2[i] = nd2->GetPosition()[i];
}
// b3 = A2b1 + b2
b3 = nd2->GetOrientation().rotate(b1) + b2;
// back to mitk::Point3D
Point3D point;
for (int i = 0; i < 3; ++i) {
point[i] = b3[i];
}
nd3->SetPosition(point);
nd3->ResetCovarianceValidity();
return nd3;
}
bool mitk::Equal(const mitk::NavigationData& leftHandSide, const mitk::NavigationData& rightHandSide, ScalarType eps, bool verbose)
{
bool returnValue = true;
// Dimensionality
if( !mitk::Equal(rightHandSide.GetPosition(), leftHandSide.GetPosition(), eps) )
{
if(verbose)
{
MITK_INFO << "[( NavigationData )] Position differs.";
MITK_INFO << "leftHandSide is " << leftHandSide.GetPosition()
<< "rightHandSide is " << rightHandSide.GetPosition();
}
returnValue = false;
}
// Dimensionality
if( !mitk::Equal(rightHandSide.GetOrientation(), leftHandSide.GetOrientation(), eps) )
{
if(verbose)
{
MITK_INFO << "[( NavigationData )] Orientation differs.";
MITK_INFO << "leftHandSide is " << leftHandSide.GetOrientation()
<< "rightHandSide is " << rightHandSide.GetOrientation();
}
returnValue = false;
}
if( rightHandSide.GetCovErrorMatrix() != leftHandSide.GetCovErrorMatrix() )
{
if(verbose)
{
MITK_INFO << "[( NavigationData )] CovErrorMatrix differs.";
MITK_INFO << "leftHandSide is " << leftHandSide.GetCovErrorMatrix()
<< "rightHandSide is " << rightHandSide.GetCovErrorMatrix();
}
returnValue = false;
}
if( std::string(rightHandSide.GetName()) != std::string(leftHandSide.GetName()) )
{
if(verbose)
{
MITK_INFO << "[( NavigationData )] Name differs.";
MITK_INFO << "leftHandSide is " << leftHandSide.GetName()
<< "rightHandSide is " << rightHandSide.GetName();
}
returnValue = false;
}
if( rightHandSide.GetIGTTimeStamp() != leftHandSide.GetIGTTimeStamp() )
{
if(verbose)
{
MITK_INFO << "[( NavigationData )] IGTTimeStamp differs.";
MITK_INFO << "leftHandSide is " << leftHandSide.GetIGTTimeStamp()
<< "rightHandSide is " << rightHandSide.GetIGTTimeStamp();
}
returnValue = false;
}
return returnValue;
}
diff --git a/Modules/IGTUI/Qmitk/QmitkIGTCommonHelper.cpp b/Modules/IGTUI/Qmitk/QmitkIGTCommonHelper.cpp
new file mode 100644
index 0000000000..b5ca3695ea
--- /dev/null
+++ b/Modules/IGTUI/Qmitk/QmitkIGTCommonHelper.cpp
@@ -0,0 +1,70 @@
+/*===================================================================
+
+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 <QmitkIGTCommonHelper.h>
+#include <QSettings>
+#include <QFileInfo>
+
+const std::string QmitkIGTCommonHelper::VIEW_ID = "org.mitk.views.igtcommonhelper";
+
+void QmitkIGTCommonHelper::SetLastFileSavePath(const QString &str)
+{
+ QSettings settings;
+ settings.beginGroup(QString::fromStdString(QmitkIGTCommonHelper::VIEW_ID));
+ settings.setValue("LastFileSavePath",QVariant(str));
+ settings.endGroup();
+}
+
+void QmitkIGTCommonHelper::SetLastFileSavePathByFileName(const QString &str)
+{
+ QFileInfo file(str);
+ SetLastFileSavePath(file.absolutePath());
+}
+
+const QString QmitkIGTCommonHelper::GetLastFileSavePath()
+{
+ QString path = "";
+ QSettings settings;
+ settings.beginGroup(QString::fromStdString(QmitkIGTCommonHelper::VIEW_ID));
+ path = settings.value("LastFileSavePath",QString("")).toString();
+ settings.endGroup();
+
+ return path;
+}
+
+void QmitkIGTCommonHelper::SetLastFileLoadPath(const QString &str)
+{
+ QSettings settings;
+ settings.beginGroup(QString::fromStdString(QmitkIGTCommonHelper::VIEW_ID));
+ settings.setValue("LastFileLoadPath",QVariant(str));
+ settings.endGroup();
+}
+
+void QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(const QString &str)
+{
+ QFileInfo file(str);
+ SetLastFileLoadPath(file.absolutePath());
+}
+
+const QString QmitkIGTCommonHelper::GetLastFileLoadPath()
+{
+ QString path = "";
+ QSettings settings;
+ settings.beginGroup(QString::fromStdString(QmitkIGTCommonHelper::VIEW_ID));
+ path = settings.value("LastFileLoadPath",QString("")).toString();
+ settings.endGroup();
+
+ return path;
+}
diff --git a/Modules/IGTUI/Qmitk/QmitkIGTCommonHelper.h b/Modules/IGTUI/Qmitk/QmitkIGTCommonHelper.h
new file mode 100644
index 0000000000..2b72ea7290
--- /dev/null
+++ b/Modules/IGTUI/Qmitk/QmitkIGTCommonHelper.h
@@ -0,0 +1,46 @@
+/*===================================================================
+
+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 QmitkIGTCommonHelper_H
+#define QmitkIGTCommonHelper_H
+
+#include "MitkIGTUIExports.h"
+#include <QString>
+
+ /** Documentation:
+ * \brief Simple and fast access to a pre-configured TrackingDeviceSource.
+ *
+ * \ingroup IGTUI
+ */
+class MITKIGTUI_EXPORT QmitkIGTCommonHelper
+{
+
+public:
+
+ static const std::string VIEW_ID;
+
+ static void SetLastFileSavePath(const QString& str);
+
+ static void SetLastFileSavePathByFileName(const QString& str);
+
+ static const QString GetLastFileSavePath();
+
+ static void SetLastFileLoadPath(const QString& str);
+
+ static void SetLastFileLoadPathByFileName(const QString& str);
+
+ static const QString GetLastFileLoadPath();
+};
+#endif
diff --git a/Modules/IGTUI/Qmitk/QmitkIGTConnectionWidget.cpp b/Modules/IGTUI/Qmitk/QmitkIGTConnectionWidget.cpp
index b50b126985..d86c9516d2 100644
--- a/Modules/IGTUI/Qmitk/QmitkIGTConnectionWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkIGTConnectionWidget.cpp
@@ -1,213 +1,215 @@
/*===================================================================
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 "QmitkIGTConnectionWidget.h"
#include "QmitkTrackingDeviceConfigurationWidget.h"
#include "mitkClaronTrackingDevice.h"
#include "mitkNDITrackingDevice.h"
#include "mitkOptitrackTrackingDevice.h"
#include "mitkNavigationToolStorageDeserializer.h"
#include "mitkTrackingDeviceSourceConfigurator.h"
+#include "QmitkIGTCommonHelper.h"
#include <QFileDialog>
#include <QMessageBox>
const std::string QmitkIGTConnectionWidget::VIEW_ID = "org.mitk.views.igtconnectionwidget";
QmitkIGTConnectionWidget::QmitkIGTConnectionWidget(QWidget* parent, Qt::WindowFlags f)
: QWidget(parent, f)
{
m_Controls = nullptr;
CreateQtPartControl(this);
CreateConnections();
m_TrackingDevice = nullptr;
m_TrackingDeviceSource = nullptr;
m_NavigationToolStorage = nullptr;
m_DataStorage = nullptr;
m_ErrorMessage = "";
}
QmitkIGTConnectionWidget::~QmitkIGTConnectionWidget()
{
}
void QmitkIGTConnectionWidget::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkIGTConnectionWidgetControls;
m_Controls->setupUi(parent);
}
}
void QmitkIGTConnectionWidget::CreateConnections()
{
if ( m_Controls )
{
connect( (QObject*)(m_Controls->connectButton), SIGNAL(clicked()), this, SLOT(OnConnect()) );
}
}
void QmitkIGTConnectionWidget::OnConnect()
{
if (m_Controls->connectButton->isChecked()) // Load tools and connect tracking device
{
m_Controls->connectButton->setChecked(false);
// create TrackingDevice
m_TrackingDevice = m_Controls->trackingDeviceConfigurationWidget->GetTrackingDevice();
if (m_TrackingDevice.IsNotNull())
{
- QString fileName = QFileDialog::getOpenFileName(nullptr,tr("Open Navigation tool storage"), "/", tr("Toolfile (*.tfl)"));
+ QString fileName = QFileDialog::getOpenFileName(nullptr,tr("Open Navigation tool storage"), QmitkIGTCommonHelper::GetLastFileLoadPath(), tr("Toolfile (*.tfl)"));
+ QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(fileName);
if (LoadToolfile(fileName))
{
// Create TrackingDeviceSource and add tools
mitk::TrackingDeviceSourceConfigurator::Pointer myTrackingDeviceSourceFactory =
mitk::TrackingDeviceSourceConfigurator::New(this->m_NavigationToolStorage,m_TrackingDevice);
m_TrackingDeviceSource = myTrackingDeviceSourceFactory->CreateTrackingDeviceSource();
m_TrackingDeviceSource->Connect();
m_TrackingDeviceSource->StartTracking();
// change button text
m_Controls->connectButton->setText("Disconnect");
m_Controls->connectButton->setChecked(true);
// disable configuration widget
m_Controls->trackingDeviceConfigurationWidget->setEnabled(false);
// emit connected signal
emit TrackingDeviceConnected();
}
else
{
QString error(m_ErrorMessage.c_str());
QMessageBox::warning(nullptr,"Warning",error);
// reset button to unchecked
m_Controls->connectButton->setChecked(false);
// remove tool nodes from DataStorage
this->RemoveToolNodes();
// reset NavigationToolStorage
m_NavigationToolStorage = nullptr;
}
}
else
{
// reset button to unchecked
m_Controls->connectButton->setChecked(false);
MITK_ERROR<<"Could not create TrackingDevice";
}
}
else // Disconnect tracking device
{
// disconnect TrackingDeviceSource
if (m_TrackingDeviceSource.IsNotNull())
{
m_TrackingDeviceSource->StopTracking();
m_TrackingDeviceSource->Disconnect();
}
// remove tool nodes from DataStorage
this->RemoveToolNodes();
// reset members
m_NavigationToolStorage = nullptr;
m_TrackingDevice = nullptr;
m_TrackingDeviceSource = nullptr;
// change button text
m_Controls->connectButton->setText("Connect");
// enable configuration widget
m_Controls->trackingDeviceConfigurationWidget->setEnabled(true);
// emit disconnected signal
emit TrackingDeviceDisconnected();
}
}
bool QmitkIGTConnectionWidget::LoadToolfile(QString qFilename)
{
if (m_DataStorage.IsNotNull())
{
std::string filename = qFilename.toStdString();
mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(this->m_DataStorage);
mitk::NavigationToolStorage::Pointer tempStorage = myDeserializer->Deserialize(filename);
m_NavigationToolStorage = tempStorage;
if (tempStorage.IsNull())
{
m_ErrorMessage = myDeserializer->GetErrorMessage();
return false;
}
// check if there are tools in the storage
mitk::TrackingDeviceType lastDevice;
if (tempStorage->GetToolCount()>0)
{
lastDevice = tempStorage->GetTool(0)->GetTrackingDeviceType();
}
else
{
m_ErrorMessage = "Error: Didn't find a tool in the storage. Do you want to navigate without even an instrument?";
return false;
}
//check if all tools are from the same device
for (int i=1; i<tempStorage->GetToolCount(); i++)
{
if (lastDevice!=tempStorage->GetTool(i)->GetTrackingDeviceType())
{
m_ErrorMessage = "Error: Toolfile contains tools of different tracking devices which is not acceptable for this application.";
return false;
}
else lastDevice = tempStorage->GetTool(i)->GetTrackingDeviceType();
}
// check if tracking device typ of tools corresponds with chosen tracking device
if (m_TrackingDevice->GetType()!=tempStorage->GetTool(0)->GetTrackingDeviceType())
{
m_ErrorMessage = "Tools are not compliant with this tracking device. Please use correct toolfile for specified device.";
return false;
}
m_NavigationToolStorage = tempStorage;
return true;
}
else
{
m_ErrorMessage = "Error: No DataStorage available! Make sure the widget is initialized with a DataStorage";
return false;
}
}
void QmitkIGTConnectionWidget::RemoveToolNodes()
{
for (int i=0; i<m_NavigationToolStorage->GetToolCount(); i++)
{
mitk::DataNode::Pointer currentNode = m_NavigationToolStorage->GetTool(i)->GetDataNode();
if (currentNode.IsNotNull())
{
m_DataStorage->Remove(currentNode);
}
}
}
mitk::TrackingDeviceSource::Pointer QmitkIGTConnectionWidget::GetTrackingDeviceSource()
{
return m_TrackingDeviceSource;
}
void QmitkIGTConnectionWidget::SetDataStorage( mitk::DataStorage::Pointer dataStorage )
{
m_DataStorage = dataStorage;
}
mitk::NavigationToolStorage::Pointer QmitkIGTConnectionWidget::GetNavigationToolStorage()
{
return m_NavigationToolStorage;
}
diff --git a/Modules/IGTUI/Qmitk/QmitkIGTPlayerWidget.cpp b/Modules/IGTUI/Qmitk/QmitkIGTPlayerWidget.cpp
index d607dbf839..6d751ce80f 100644
--- a/Modules/IGTUI/Qmitk/QmitkIGTPlayerWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkIGTPlayerWidget.cpp
@@ -1,573 +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 "QmitkIGTPlayerWidget.h"
//mitk headers
#include "mitkTrackingTypes.h"
#include <mitkSurface.h>
#include <mitkNavigationToolReader.h>
#include <mitkNavigationToolWriter.h>
#include <mitkNavigationToolStorage.h>
#include <mitkNavigationToolStorageDeserializer.h>
#include <mitkNavigationToolStorageSerializer.h>
#include <mitkIGTException.h>
#include <mitkIOUtil.h>
+#include <QmitkIGTCommonHelper.h>
//qt headers
#include <qfiledialog.h>
#include <qmessagebox.h>
#include <qtimer.h>
QmitkIGTPlayerWidget::QmitkIGTPlayerWidget(QWidget* parent, Qt::WindowFlags f)
: QWidget(parent, f),
m_RealTimePlayer(mitk::NavigationDataPlayer::New()),
m_SequentialPlayer(mitk::NavigationDataSequentialPlayer::New()),
m_StartTime(-1.0),
m_CurrentSequentialPointNumber(0),
m_Controls(new Ui::QmitkIGTPlayerWidgetControls)
{
m_Controls->setupUi(this);
m_PlayingTimer = new QTimer(this); // initialize update timer
CreateConnections();
m_Controls->samplePositionHorizontalSlider->setVisible(false);
this->ResetLCDNumbers(); // reset lcd numbers at start
}
QmitkIGTPlayerWidget::~QmitkIGTPlayerWidget()
{
m_PlayingTimer->stop();
delete m_Controls;
}
void QmitkIGTPlayerWidget::CreateConnections()
{
connect( (QObject*)(m_Controls->playPushButton), SIGNAL(clicked(bool)), this, SLOT(OnPlayButtonClicked(bool)) ); // play button
connect( (QObject*)(m_PlayingTimer), SIGNAL(timeout()), this, SLOT(OnPlaying()) ); // update timer
connect( (QObject*) (m_Controls->beginPushButton), SIGNAL(clicked()), this, SLOT(OnGoToBegin()) ); // reset player and go to begin
connect( (QObject*) (m_Controls->stopPushButton), SIGNAL(clicked()), this, SLOT(OnGoToEnd()) ); // reset player
// pass this widgets protected combobox signal to public signal
connect( (QObject*) (m_Controls->trajectorySelectComboBox), SIGNAL(currentIndexChanged(int)), this, SIGNAL(SignalCurrentTrajectoryChanged(int)) );
// pass this widgets protected checkbox signal to public signal
connect( m_Controls->splineModeCheckBox, SIGNAL(toggled(bool)), this, SIGNAL(SignalSplineModeToggled(bool)) );
//connect( m_Controls->sequencialModeCheckBox, SIGNAL(toggled(bool)), this, SLOT(OnSequencialModeToggled(bool)) );
connect( m_Controls->samplePositionHorizontalSlider, SIGNAL(sliderPressed()), this, SLOT(OnSliderPressed()) );
connect( m_Controls->samplePositionHorizontalSlider, SIGNAL(sliderReleased()), this, SLOT(OnSliderReleased()) );
connect( m_Controls->m_OpenFileButton, SIGNAL(clicked()), this, SLOT(OnOpenFileButtonPressed()) );
}
bool QmitkIGTPlayerWidget::IsTrajectoryInSplineMode()
{
return m_Controls->splineModeCheckBox->isChecked();
}
bool QmitkIGTPlayerWidget::CheckInputFileValid()
{
QFile file(m_CmpFilename);
// check if file exists
if(!file.exists())
{
QMessageBox::warning(nullptr, "IGTPlayer: Error", "No valid input file was loaded. Please load input file first!");
return false;
}
return true;
}
unsigned int QmitkIGTPlayerWidget::GetNumberOfTools()
{
unsigned int result = 0;
if(this->GetCurrentPlaybackMode() == RealTimeMode)
{
if(m_RealTimePlayer.IsNotNull())
result = m_RealTimePlayer->GetNumberOfOutputs();
}
else if(this->GetCurrentPlaybackMode() == SequentialMode)
{
if(m_SequentialPlayer.IsNotNull())
result = m_SequentialPlayer->GetNumberOfOutputs();
}
// at the moment this works only if player is initialized
return result;
}
void QmitkIGTPlayerWidget::SetUpdateRate(unsigned int msecs)
{
m_PlayingTimer->setInterval((int) msecs); // set update timer update rate
}
void QmitkIGTPlayerWidget::OnPlayButtonClicked(bool checked)
{
if ( ! checked )
{
if ( this->GetCurrentPlaybackMode() == RealTimeMode )
{
m_RealTimePlayer->StopPlaying();
}
else if ( this->GetCurrentPlaybackMode() == SequentialMode )
{
// m_SequentialPlayer->
}
}
if(CheckInputFileValid()) // no playing possible without valid input file
{
switch ( this->GetCurrentPlaybackMode() )
{
case RealTimeMode:
{
break;
}
case SequentialMode:
{
break;
}
}
PlaybackMode currentMode = this->GetCurrentPlaybackMode();
bool isRealTimeMode = currentMode == RealTimeMode;
bool isSequentialMode = currentMode == SequentialMode;
if(checked) // play
{
if( (isRealTimeMode && m_RealTimePlayer.IsNull()) || (isSequentialMode && m_SequentialPlayer.IsNull())) // start play
{
mitk::NavigationDataSet::Pointer navigationDataSet;
try
{
navigationDataSet = dynamic_cast<mitk::NavigationDataSet*> (mitk::IOUtil::LoadBaseData(m_CmpFilename.toStdString()).GetPointer());
}
catch(mitk::IGTException)
{
std::string errormessage = "Error during start playing. Invalid or wrong file?";
QMessageBox::warning(nullptr, "IGTPlayer: Error", errormessage.c_str());
m_Controls->playPushButton->setChecked(false);
m_RealTimePlayer = nullptr;
return;
}
if(isRealTimeMode)
{
m_RealTimePlayer = mitk::NavigationDataPlayer::New();
m_RealTimePlayer->SetNavigationDataSet(navigationDataSet);
try
{
m_RealTimePlayer->StartPlaying();
}
catch(mitk::IGTException)
{
std::string errormessage = "Error during start playing. Invalid or wrong file?";
QMessageBox::warning(nullptr, "IGTPlayer: Error", errormessage.c_str());
m_Controls->playPushButton->setChecked(false);
m_RealTimePlayer = nullptr;
return;
}
}
else if(isSequentialMode)
{
m_SequentialPlayer = mitk::NavigationDataSequentialPlayer::New();
try
{
m_SequentialPlayer->SetNavigationDataSet(navigationDataSet);
}
catch(mitk::IGTException)
{
std::string errormessage = "Error during start playing. Invalid or wrong file type?";
QMessageBox::warning(nullptr, "IGTPlayer: Error", errormessage.c_str());
m_Controls->playPushButton->setChecked(false);
m_RealTimePlayer = nullptr;
return;
}
m_Controls->samplePositionHorizontalSlider->setMinimum(0);
m_Controls->samplePositionHorizontalSlider->setMaximum(m_SequentialPlayer->GetNumberOfSnapshots());
m_Controls->samplePositionHorizontalSlider->setEnabled(true);
}
m_PlayingTimer->start(100);
emit SignalPlayingStarted();
}
else // resume play
{
if(isRealTimeMode)
m_RealTimePlayer->Resume();
m_PlayingTimer->start(100);
emit SignalPlayingResumed();
}
}
else // pause
{
if(isRealTimeMode)
m_RealTimePlayer->Pause();
m_PlayingTimer->stop();
emit SignalPlayingPaused();
}
}
else
{
m_Controls->playPushButton->setChecked(false); // uncheck play button if file unvalid
}
}
QmitkIGTPlayerWidget::PlaybackMode QmitkIGTPlayerWidget::GetCurrentPlaybackMode()
{
/*if(m_Controls->sequencialModeCheckBox->isChecked())
return SequentialMode;
else*/
return RealTimeMode;
}
QTimer* QmitkIGTPlayerWidget::GetPlayingTimer()
{
return m_PlayingTimer;
}
void QmitkIGTPlayerWidget::OnStopPlaying()
{
this->StopPlaying();
}
void QmitkIGTPlayerWidget::StopPlaying()
{
m_PlayingTimer->stop();
emit SignalPlayingStopped();
if(m_RealTimePlayer.IsNotNull())
m_RealTimePlayer->StopPlaying();
m_StartTime = -1; // set starttime back
m_CurrentSequentialPointNumber = 0;
m_Controls->samplePositionHorizontalSlider->setSliderPosition(m_CurrentSequentialPointNumber);
m_Controls->sampleLCDNumber->display(static_cast<int>(m_CurrentSequentialPointNumber));
this->ResetLCDNumbers();
m_Controls->playPushButton->setChecked(false); // set play button unchecked
}
void QmitkIGTPlayerWidget::OnPlaying()
{
switch ( this->GetCurrentPlaybackMode() )
{
case RealTimeMode:
{
if ( m_RealTimePlayer.IsNull() ) { return; }
if ( m_StartTime < 0 )
{
// get playback start time
m_StartTime = m_RealTimePlayer->GetOutput()->GetTimeStamp();
}
if( ! m_RealTimePlayer->IsAtEnd() )
{
m_RealTimePlayer->Update(); // update player
int msc = (int) (m_RealTimePlayer->GetOutput()->GetTimeStamp() - m_StartTime);
// calculation for playing time display
int ms = msc % 1000;
msc = (msc - ms) / 1000;
int s = msc % 60;
int min = (msc-s) / 60;
// set lcd numbers
m_Controls->msecLCDNumber->display(ms);
m_Controls->secLCDNumber->display(s);
m_Controls->minLCDNumber->display(min);
emit SignalPlayerUpdated(); // player successfully updated
}
else
{
this->StopPlaying(); // if player is at EOF
}
break;
}
case SequentialMode:
{
if ( m_SequentialPlayer.IsNull() ) { return; }
if ( m_CurrentSequentialPointNumber < m_SequentialPlayer->GetNumberOfSnapshots() )
{
m_SequentialPlayer->Update(); // update sequential player
m_Controls->samplePositionHorizontalSlider->setSliderPosition(m_CurrentSequentialPointNumber++); // refresh slider position
m_Controls->sampleLCDNumber->display(static_cast<int>(m_CurrentSequentialPointNumber));
//for debugging purposes
//std::cout << "Sample: " << m_CurrentSequentialPointNumber << " X: " << m_SequentialPlayer->GetOutput()->GetPosition()[0] << " Y: " << m_SequentialPlayer->GetOutput()->GetPosition()[1] << " Y: " << m_SequentialPlayer->GetOutput()->GetPosition()[2] << std::endl;
emit SignalPlayerUpdated(); // player successfully updated
}
else
{
this->StopPlaying(); // if player is at EOF
}
break;
}
}
}
const std::vector<mitk::NavigationData::Pointer> QmitkIGTPlayerWidget::GetNavigationDatas()
{
std::vector<mitk::NavigationData::Pointer> navDatas;
if(this->GetCurrentPlaybackMode() == RealTimeMode && m_RealTimePlayer.IsNotNull())
{
for(unsigned int i=0; i < m_RealTimePlayer->GetNumberOfOutputs(); ++i)
{
navDatas.push_back(m_RealTimePlayer->GetOutput(i)); // push back current navigation data for each tool
}
}
else if(this->GetCurrentPlaybackMode() == SequentialMode && m_SequentialPlayer.IsNotNull())
{
for(unsigned int i=0; i < m_SequentialPlayer->GetNumberOfOutputs(); ++i)
{
navDatas.push_back(m_SequentialPlayer->GetOutput(i)); // push back current navigation data for each tool
}
}
return navDatas;
}
const mitk::PointSet::Pointer QmitkIGTPlayerWidget::GetNavigationDatasPointSet()
{
mitk::PointSet::Pointer result = mitk::PointSet::New();
mitk::PointSet::PointType pointType;
PlaybackMode currentMode = this->GetCurrentPlaybackMode();
bool isRealTimeMode = currentMode == RealTimeMode;
bool isSequentialMode = currentMode == SequentialMode;
if( (isRealTimeMode && m_RealTimePlayer.IsNotNull()) || (isSequentialMode && m_SequentialPlayer.IsNotNull()))
{
int numberOfOutputs = 0;
if(isRealTimeMode)
numberOfOutputs = m_RealTimePlayer->GetNumberOfOutputs();
else if(isSequentialMode)
numberOfOutputs = m_SequentialPlayer->GetNumberOfOutputs();
for(unsigned int i=0; i < m_RealTimePlayer->GetNumberOfOutputs(); ++i)
{
mitk::NavigationData::PositionType position;
if(isRealTimeMode)
position = m_RealTimePlayer->GetOutput(i)->GetPosition();
else if(isSequentialMode)
position = m_SequentialPlayer->GetOutput(i)->GetPosition();
pointType[0] = position[0];
pointType[1] = position[1];
pointType[2] = position[2];
result->InsertPoint(i,pointType); // insert current ND as Pointtype in PointSet for return
}
}
return result;
}
const mitk::PointSet::PointType QmitkIGTPlayerWidget::GetNavigationDataPoint(unsigned int index)
{
if( index > this->GetNumberOfTools() || index < 0 )
throw std::out_of_range("Tool Index out of range!");
PlaybackMode currentMode = this->GetCurrentPlaybackMode();
bool isRealTimeMode = currentMode == RealTimeMode;
bool isSequentialMode = currentMode == SequentialMode;
// create return PointType from current ND for tool index
mitk::PointSet::PointType result;
if( (isRealTimeMode && m_RealTimePlayer.IsNotNull()) || (isSequentialMode && m_SequentialPlayer.IsNotNull()))
{
mitk::NavigationData::PositionType position;
if(isRealTimeMode)
position = m_RealTimePlayer->GetOutput(index)->GetPosition();
else if(isSequentialMode)
position = m_SequentialPlayer->GetOutput(index)->GetPosition();
result[0] = position[0];
result[1] = position[1];
result[2] = position[2];
}
return result;
}
/*void QmitkIGTPlayerWidget::SetRealTimePlayer( mitk::NavigationDataPlayer::Pointer player )
{
if(player.IsNotNull())
m_RealTimePlayer = player;
}
void QmitkIGTPlayerWidget::SetSequentialPlayer( mitk::NavigationDataSequentialPlayer::Pointer player )
{
if(player.IsNotNull())
m_SequentialPlayer = player;
}*/
void QmitkIGTPlayerWidget::OnOpenFileButtonPressed()
{
- QString filename = QFileDialog::getOpenFileName(this, "Load tracking data", QDir::currentPath(),"XML files (*.xml)");
+ QString filename = QFileDialog::getOpenFileName(this, "Load tracking data", QmitkIGTCommonHelper::GetLastFileLoadPath(),"XML files (*.xml)");
QFile file(filename);
+ QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(filename);
// if something went wrong or user pressed cancel in the save dialog
if ( filename.isEmpty() || ! file.exists() )
{
QMessageBox::warning(nullptr, "Warning", QString("Please enter valid path. Using previous path again."));
return;
}
m_CmpFilename = filename;
this->OnGoToEnd(); /// stops playing and resets lcd numbers
m_Controls->m_ActiveFileLabel->setText(m_CmpFilename);
emit SignalInputFileChanged();
mitk::NavigationDataSet::Pointer navigationDataSet = dynamic_cast<mitk::NavigationDataSet*> (mitk::IOUtil::LoadBaseData(m_CmpFilename.toStdString()).GetPointer());
m_RealTimePlayer->SetNavigationDataSet(navigationDataSet);
m_SequentialPlayer->SetNavigationDataSet(navigationDataSet);
m_Controls->m_PlayerControlsGroupBox->setEnabled(true);
}
void QmitkIGTPlayerWidget::OnGoToEnd()
{
this->StopPlaying();
// reset lcd numbers
this->ResetLCDNumbers();
}
void QmitkIGTPlayerWidget::OnGoToBegin()
{
// stop player manual so no PlayingStopped()
m_PlayingTimer->stop();
if(this->GetCurrentPlaybackMode() == RealTimeMode && m_RealTimePlayer.IsNotNull())
{
m_RealTimePlayer->StopPlaying();
m_RealTimePlayer = nullptr; // set player to nullptr so it can be initialized again if playback is called afterwards
}
m_StartTime = -1; // set starttime back
//reset view elements
m_Controls->playPushButton->setChecked(false);
this->ResetLCDNumbers();
}
void QmitkIGTPlayerWidget::ResetLCDNumbers()
{
m_Controls->minLCDNumber->display(QString("00"));
m_Controls->secLCDNumber->display(QString("00"));
m_Controls->msecLCDNumber->display(QString("000"));
}
void QmitkIGTPlayerWidget::SetTrajectoryNames(const QStringList toolNames)
{
QComboBox* cBox = m_Controls->trajectorySelectComboBox;
if(cBox->count() > 0)
this->ClearTrajectorySelectCombobox();
// before making changed to QComboBox it is recommended to disconnet it's SIGNALS and SLOTS
disconnect( (QObject*) (m_Controls->trajectorySelectComboBox), SIGNAL(currentIndexChanged(int)), this, SIGNAL(SignalCurrentTrajectoryChanged(int)) );
if(!toolNames.isEmpty())
m_Controls->trajectorySelectComboBox->insertItems(0, toolNames); // adding current tool names to combobox
// reconnect after performed changes
connect( (QObject*) (m_Controls->trajectorySelectComboBox), SIGNAL(currentIndexChanged(int)), this, SIGNAL(SignalCurrentTrajectoryChanged(int)) );
}
int QmitkIGTPlayerWidget::GetResolution()
{
return m_Controls->resolutionSpinBox->value(); // return currently selected trajectory resolution
}
void QmitkIGTPlayerWidget::ClearTrajectorySelectCombobox()
{
// before making changed to QComboBox it is recommended to disconnet it's SIGNALS and SLOTS
disconnect( (QObject*) (m_Controls->trajectorySelectComboBox), SIGNAL(currentIndexChanged(int)), this, SIGNAL(SignalCurrentTrajectoryChanged(int)) );
m_Controls->trajectorySelectComboBox->clear();
// reconnect after performed changes
connect( (QObject*) (m_Controls->trajectorySelectComboBox), SIGNAL(currentIndexChanged(int)), this, SIGNAL(SignalCurrentTrajectoryChanged(int)) );
}
void QmitkIGTPlayerWidget::OnSequencialModeToggled(bool toggled)
{
this->StopPlaying(); // stop playing when mode is changed
if(toggled)
{
m_Controls->samplePositionHorizontalSlider->setEnabled(true); // enable slider if sequential mode
}
else if(!toggled)
{
m_Controls->samplePositionHorizontalSlider->setSliderPosition(0); // set back and disable slider
m_Controls->samplePositionHorizontalSlider->setDisabled(true);
}
}
void QmitkIGTPlayerWidget::OnSliderReleased()
{
int currentSliderValue = m_Controls->samplePositionHorizontalSlider->value(); // current slider value selected through user movement
if(currentSliderValue > static_cast<int>(m_CurrentSequentialPointNumber)) // at the moment only forward scrolling is possible
{
auto snapshotNumber = static_cast<unsigned int>(currentSliderValue);
m_SequentialPlayer->GoToSnapshot(snapshotNumber); // move player to selected snapshot
m_CurrentSequentialPointNumber = currentSliderValue;
m_Controls->sampleLCDNumber->display(currentSliderValue); // update lcdnumber in widget
}
else
m_Controls->samplePositionHorizontalSlider->setValue(m_CurrentSequentialPointNumber);
}
void QmitkIGTPlayerWidget::OnSliderPressed()
{
if(m_Controls->playPushButton->isChecked()) // check if widget is playing
m_Controls->playPushButton->click(); // perform click to pause the play
}
diff --git a/Modules/IGTUI/Qmitk/QmitkMicronTrackerWidget.cpp b/Modules/IGTUI/Qmitk/QmitkMicronTrackerWidget.cpp
index 3d0842916b..953b1c1ed0 100644
--- a/Modules/IGTUI/Qmitk/QmitkMicronTrackerWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkMicronTrackerWidget.cpp
@@ -1,168 +1,171 @@
/*===================================================================
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 "QmitkMicronTrackerWidget.h"
#include <QFileDialog>
#include <QScrollBar>
#include <mitkClaronTrackingDevice.h>
#include <itksys/SystemTools.hxx>
#include <Poco/Path.h>
#include <QSettings>
+#include <QmitkIGTCommonHelper.h>
+
const std::string QmitkMicronTrackerWidget::VIEW_ID = "org.mitk.views.NDIMicronTrackerWidget";
QmitkMicronTrackerWidget::QmitkMicronTrackerWidget(QWidget* parent, Qt::WindowFlags f)
: QmitkAbstractTrackingDeviceWidget(parent, f)
, m_Controls(nullptr)
{
}
void QmitkMicronTrackerWidget::Initialize()
{
InitializeSuperclassWidget();
CreateQtPartControl(this);
CreateConnections();
m_MTCalibrationFile = "";
}
QmitkMicronTrackerWidget::~QmitkMicronTrackerWidget()
{
delete m_Controls;
}
void QmitkMicronTrackerWidget::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkMicronTrackerWidget;
m_Controls->setupUi(parent);
}
}
void QmitkMicronTrackerWidget::CreateConnections()
{
if (m_Controls)
{
connect((QObject*)(m_Controls->m_testConnectionMicronTracker), SIGNAL(clicked()), this, SLOT(TestConnection()));
connect((QObject*)(m_Controls->m_SetMTCalibrationFile), SIGNAL(clicked()), this, SLOT(SetMTCalibrationFileClicked()));
}
}
void QmitkMicronTrackerWidget::ResetOutput()
{
m_Controls->m_outputTextMicronTracker->setHtml("<body style=\" font-family:\'MS Shell Dlg 2\'; font-size:7pt; font-weight:400; font-style:normal;\" bgcolor=black><span style=\"color:#ffffff;\"><u>output:</u>");
}
void QmitkMicronTrackerWidget::AddOutput(std::string s)
{
m_Controls->m_outputTextMicronTracker->setHtml(QString(s.c_str()));
m_Controls->m_outputTextMicronTracker->verticalScrollBar()->setValue(m_Controls->m_outputTextMicronTracker->verticalScrollBar()->maximum());
}
mitk::TrackingDevice::Pointer QmitkMicronTrackerWidget::ConstructTrackingDevice()
{
mitk::ClaronTrackingDevice::Pointer newDevice = mitk::ClaronTrackingDevice::New();
if (this->m_MTCalibrationFile.empty()) //if configuration file for MicronTracker is empty: load default
{
mitk::ClaronTrackingDevice::Pointer tempDevice = mitk::ClaronTrackingDevice::New();
m_MTCalibrationFile = tempDevice->GetCalibrationDir();
Poco::Path myPath = Poco::Path(m_MTCalibrationFile.c_str());
m_Controls->m_MTCalibrationFile->setText("Calibration File: " + QString(myPath.getFileName().c_str()));
}
if (!this->m_MTCalibrationFile.empty())
{
//extract path from calibration file and set the calibration dir of the device
std::string path = itksys::SystemTools::GetFilenamePath(m_MTCalibrationFile);
newDevice->SetCalibrationDir(path);
}
else
AddOutput("<br>Warning: Calibration file is not set!");
return static_cast<mitk::TrackingDevice::Pointer>(newDevice);
}
void QmitkMicronTrackerWidget::StoreUISettings()
{
std::string id = "org.mitk.modules.igt.ui.trackingdeviceconfigurationwidget";
if (this->GetPersistenceService()) // now save the settings using the persistence service
{
mitk::PropertyList::Pointer propList = this->GetPersistenceService()->GetPropertyList(id);
propList->Set("MTCalibrationFile", m_MTCalibrationFile);
}
else // QSettings as a fallback if the persistence service is not available
{
QSettings settings;
settings.beginGroup(QString::fromStdString(id));
settings.setValue("mTCalibrationFile", QVariant(QString::fromStdString(m_MTCalibrationFile)));
settings.endGroup();
}
}
void QmitkMicronTrackerWidget::LoadUISettings()
{
std::string id = "org.mitk.modules.igt.ui.trackingdeviceconfigurationwidget";
if (this->GetPersistenceService())
{
mitk::PropertyList::Pointer propList = this->GetPersistenceService()->GetPropertyList(id);
if (propList.IsNull())
{
MITK_ERROR << "Property list for this UI (" << id << ") is not available, could not load UI settings!"; return;
}
propList->Get("MTCalibrationFile", m_MTCalibrationFile);
}
else
{
// QSettings as a fallback if the persistence service is not available
QSettings settings;
settings.beginGroup(QString::fromStdString(id));
m_MTCalibrationFile = settings.value("mTCalibrationFile", "").toString().toStdString();
settings.endGroup();
}
m_Controls->m_MTCalibrationFile->setText("Calibration File: " + QString::fromStdString(m_MTCalibrationFile));
}
bool QmitkMicronTrackerWidget::IsDeviceInstalled()
{
return mitk::ClaronTrackingDevice::New()->IsDeviceInstalled();
}
void QmitkMicronTrackerWidget::SetMTCalibrationFileClicked()
{
- std::string filename = QFileDialog::getOpenFileName(nullptr, tr("Open Calibration File"), "/", "*.*").toLatin1().data();
+ std::string filename = QFileDialog::getOpenFileName(nullptr, tr("Open Calibration File"), QmitkIGTCommonHelper::GetLastFileLoadPath(), "*.*").toLatin1().data();
if (filename == "") { return; }
else
{
+ QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(QString::fromStdString(filename));
m_MTCalibrationFile = filename;
Poco::Path myPath = Poco::Path(m_MTCalibrationFile.c_str());
m_Controls->m_MTCalibrationFile->setText("Calibration File: " + QString(myPath.getFileName().c_str()));
}
}
QmitkMicronTrackerWidget* QmitkMicronTrackerWidget::Clone(QWidget* parent) const
{
QmitkMicronTrackerWidget* clonedWidget = new QmitkMicronTrackerWidget(parent);
clonedWidget->Initialize();
clonedWidget->m_MTCalibrationFile = m_MTCalibrationFile;
m_Controls->m_MTCalibrationFile->setText("Calibration File: " + QString::fromStdString(m_MTCalibrationFile));
return clonedWidget;
}
diff --git a/Modules/IGTUI/Qmitk/QmitkNDIConfigurationWidget.cpp b/Modules/IGTUI/Qmitk/QmitkNDIConfigurationWidget.cpp
index 3019ef64cf..d90e459440 100644
--- a/Modules/IGTUI/Qmitk/QmitkNDIConfigurationWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkNDIConfigurationWidget.cpp
@@ -1,886 +1,893 @@
/*===================================================================
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 "QmitkNDIConfigurationWidget.h"
#include <QTableWidget>
#include <QMessageBox>
#include <QFileDialog>
#include <QInputDialog>
#include <QDir>
#include <QFileInfo>
#include <mitkNavigationToolWriter.h>
#include <mitkNavigationToolReader.h>
#include <mitkIGTException.h>
#include <mitkIOUtil.h>
+#include <QmitkIGTCommonHelper.h>
#include "QmitkCustomVariants.h"
//#include <QtConcurrentMap>
#include "QmitkNDIToolDelegate.h"
#include "mitkNDIAuroraTypeInformation.h"
#include "mitkNDIPolarisTypeInformation.h"
/* VIEW MANAGEMENT */
QmitkNDIConfigurationWidget::QmitkNDIConfigurationWidget(QWidget* parent)
: QWidget(parent), m_Controls(nullptr), m_Tracker(nullptr), m_Source(nullptr),
m_Delegate(nullptr), m_SROMCellDefaultText("<click to load SROM file>"), m_RepresentatonCellDefaultText("<click to select representation>")
{
this->CreateQtPartControl(this);
}
QmitkNDIConfigurationWidget::~QmitkNDIConfigurationWidget()
{
m_Controls = nullptr;
m_Tracker = nullptr;
m_Source = nullptr;
}
void QmitkNDIConfigurationWidget::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkNDIConfigurationWidget;
m_Controls->setupUi(parent);
QStringList comPorts;
#ifdef WIN32
comPorts << "COM1" << "COM2" << "COM3" << "COM4" << "COM5" << "COM6" << "COM7" << "COM8" << "COM9";
#else
comPorts << "/dev/ttyS1" << "/dev/ttyS2" << "/dev/ttyS3" << "/dev/ttyS4" << "/dev/ttyS5" << "/dev/ttyUSB0" << "/dev/ttyUSB1" << "/dev/ttyUSB2" << "/dev/ttyUSB3";
#endif
m_Controls->m_ComPortSelector->addItems(comPorts);
m_Delegate = new QmitkNDIToolDelegate(m_Controls->m_ToolTable);
m_Delegate->SetDataStorage(nullptr); //needs to be set later using the setter methods
m_Delegate->SetPredicate(nullptr);
m_Delegate->SetTypes(QStringList());
m_Controls->m_ToolTable->setItemDelegate(m_Delegate);
this->CreateConnections();
this->HidePolarisOptionsGroupbox(true);
this->HideAuroraOptionsGroupbox(true);
}
}
void QmitkNDIConfigurationWidget::CreateConnections()
{
connect(m_Controls->m_Connect, SIGNAL(clicked()), this, SLOT(OnConnect()));
connect(m_Controls->m_DiscoverToolsBtn, SIGNAL(clicked()), this, SLOT(OnDiscoverTools()));
connect(m_Controls->m_AddToolBtn, SIGNAL(clicked()), this, SLOT(OnAddPassiveTool()));
connect(m_Controls->m_DisoverDevicesBtn, SIGNAL(clicked()), this, SLOT(OnDiscoverDevices()));
connect(m_Controls->m_ToolTable->model(), SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)), this, SLOT(UpdateTrackerFromToolTable(const QModelIndex &, const QModelIndex &)));
connect(m_Controls->m_DisoverDevicesBtnInfo, SIGNAL(clicked()), this, SLOT(OnDisoverDevicesBtnInfo()));
connect(m_Controls->m_SaveToolPushButton, SIGNAL(clicked()), this, SLOT(OnSaveTool()) );
connect(m_Controls->m_LoadToolPushButton, SIGNAL(clicked()), this, SLOT(OnLoadTool()) );
}
void QmitkNDIConfigurationWidget::OnConnect()
{
if (m_Tracker.IsNotNull())
{
m_Tracker->CloseConnection();
m_Tracker = nullptr;
}
this->CreateTracker();
this->SetupTracker();
bool okay = false;
try
{
okay = m_Tracker->OpenConnection();
}
catch(mitk::IGTException &e)
{
QMessageBox::warning(nullptr, "Error", QString("Connection failed, error message: ") + e.GetDescription());
m_Tracker->CloseConnection();
this->m_Tracker = nullptr;
}
if (okay)
{
// show/hide options according to connected device
if(m_Tracker->GetType() == mitk::NDIPolarisTypeInformation::GetTrackingDeviceName())
{
this->HideAuroraOptionsGroupbox(true);
this->HidePolarisOptionsGroupbox(false);
}
else if (m_Tracker->GetType() == mitk::NDIAuroraTypeInformation::GetTrackingDeviceName())
{
this->HidePolarisOptionsGroupbox(true);
this->HideAuroraOptionsGroupbox(false);
}
this->UpdateWidgets();
this->UpdateToolTable();
connect(m_Controls->m_ToolTable, SIGNAL(cellChanged(int,int)), this, SLOT(OnTableCellChanged(int,int)));
emit ToolsAdded(this->GetToolNamesList());
emit Connected();
}
else
{
QMessageBox::warning(nullptr, "Error", QString("Connection failed due to an unknown reason!"));
m_Tracker->CloseConnection();
this->m_Tracker = nullptr;
}
}
void QmitkNDIConfigurationWidget::OnDisconnect()
{
if (m_Tracker.IsNull())
return;
m_Tracker->CloseConnection();
m_Tracker = nullptr;
disconnect(m_Controls->m_ToolTable, SIGNAL(cellChanged(int,int)), this, SLOT(OnTableCellChanged(int,int)));
m_Controls->m_ToolSelectionComboBox->clear();
this->UpdateToolTable();
this->UpdateWidgets();
emit ToolsAdded(this->GetToolNamesList());
emit Disconnected();
this->HidePolarisOptionsGroupbox(true);
this->HideAuroraOptionsGroupbox(true);
}
void QmitkNDIConfigurationWidget::UpdateWidgets()
{
m_Controls->m_DeviceStatus->setText(this->GetStatusText());
if (m_Tracker.IsNull()) // not connected to tracker
{
m_Controls->m_Connect->setText("Connect");
m_Controls->m_lConnection->setText("III. Enable connection to device ");
disconnect(m_Controls->m_Connect, SIGNAL(clicked()), this, SLOT(OnDisconnect()));
connect(m_Controls->m_Connect, SIGNAL(clicked()), this, SLOT(OnConnect()));
m_Controls->m_DiscoverToolsBtn->setDisabled(true);
m_Controls->m_AddToolBtn->setDisabled(true);
return;
}
if (m_Tracker->GetState() == mitk::TrackingDevice::Setup)
{
m_Controls->m_Connect->setText("Connect");
m_Controls->m_lConnection->setText("III. Enable connection to device ");
disconnect(m_Controls->m_Connect, SIGNAL(clicked()), this, SLOT(OnDisconnect()));
connect(m_Controls->m_Connect, SIGNAL(clicked()), this, SLOT(OnConnect()));
m_Controls->m_DiscoverToolsBtn->setDisabled(true);
m_Controls->m_AddToolBtn->setDisabled(true);
return;
}
if ((m_Tracker->GetState() == mitk::TrackingDevice::Ready) || (m_Tracker->GetState() == mitk::TrackingDevice::Tracking))
{
m_Controls->m_Connect->setText("Disconnect");
m_Controls->m_lConnection->setText("III. Disable connection to device ");
disconnect(m_Controls->m_Connect, SIGNAL(clicked()), this, SLOT(OnConnect()));
connect(m_Controls->m_Connect, SIGNAL(clicked()), this, SLOT(OnDisconnect()));
m_Controls->m_DiscoverToolsBtn->setEnabled(true);
m_Controls->m_AddToolBtn->setEnabled(true);
}
}
QString QmitkNDIConfigurationWidget::GetStatusText()
{
if (m_Tracker.IsNull())
return QString("Not connected");
QString devName = QString::fromStdString(m_Tracker->GetType());
if (m_Tracker->GetState() == mitk::TrackingDevice::Ready)
return QString("Connected to %1 on %2. Device is ready.").arg(devName).arg(m_Tracker->GetDeviceName());
if (m_Tracker->GetState() == mitk::TrackingDevice::Tracking)
return QString("%1 is tracking.").arg(devName);
return QString("");
}
void QmitkNDIConfigurationWidget::OnDiscoverTools()
{
if (m_Tracker.IsNull())
{
QMessageBox::warning(nullptr, "Error", QString("Connection failed. No tracking device found."));
return;
}
m_Tracker->DiscoverWiredTools();
this->UpdateToolTable();
emit ToolsAdded(this->GetToolNamesList());
}
void QmitkNDIConfigurationWidget::OnAddPassiveTool()
{
if (m_Tracker.IsNull())
this->CreateTracker();
- QStringList filenames = QFileDialog::getOpenFileNames(this, "Select NDI SROM file", QDir::currentPath(),"NDI SROM files (*.rom)");
+ QStringList filenames = QFileDialog::getOpenFileNames(this, "Select NDI SROM file", QmitkIGTCommonHelper::GetLastFileLoadPath(),"NDI SROM files (*.rom)");
if (filenames.isEmpty())
{
this->m_Tracker = nullptr;
return;
}
+
+ QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(filenames.at(0));
+
foreach(QString fileName, filenames)
{
//QString toolName = QInputDialog::getText(this, "Enter a name for the tool", "Name of the tool: ", QLineEdit::Normal, QFileInfo(filename).baseName(), &ok);
//if (ok == false || toolName.isEmpty())
// return;
m_Tracker->AddTool(QFileInfo(fileName).baseName().toLatin1(), fileName.toLatin1());
m_Tracker->Modified();
}
emit ToolsAdded(this->GetToolNamesList());
this->UpdateToolTable();
}
void QmitkNDIConfigurationWidget::CreateTracker()
{
m_Tracker = mitk::NDITrackingDevice::New();
}
void QmitkNDIConfigurationWidget::SetupTracker()
{
if (m_Tracker.IsNull())
return;
m_Tracker->SetDeviceName(this->GetDeviceName());
m_Tracker->SetBaudRate(mitk::SerialCommunication::BaudRate115200);
}
std::string QmitkNDIConfigurationWidget::GetDeviceName() const
{
if (m_Controls == nullptr)
return nullptr;
QString deviceName = m_Controls->m_ComPortSelector->currentText();
#if WIN32
deviceName.prepend("\\\\.\\"); // always prepend "\\.\ to all COM ports, to be able to connect to ports > 9"
#endif
return deviceName.toStdString();
}
void QmitkNDIConfigurationWidget::SetDeviceName( const char* dev )
{
if (m_Controls == nullptr)
return;
m_Controls->m_ComPortSelector->setCurrentIndex(m_Controls->m_ComPortSelector->findText(dev));
}
void QmitkNDIConfigurationWidget::UpdateToolTable()
{
//disconnect(m_Controls->m_ToolTable, SIGNAL(itemChanged(QTableWidgetItem*)), this, SLOT(OnTableItemChanged(QTableWidgetItem*))); // stop listening to table changes
disconnect(m_Controls->m_ToolTable->model(), SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)), this, SLOT(UpdateTrackerFromToolTable(const QModelIndex &, const QModelIndex &)));
disconnect(m_Controls->m_ToolTable, SIGNAL( clicked ( const QModelIndex & )), this, SLOT ( OnTableItemClicked( const QModelIndex & )));
m_Controls->m_ToolTable->clearContents();
m_Controls->m_ToolTable->setRowCount(0);
if (m_Tracker.IsNull() || (m_Controls == nullptr))
return;
m_Controls->m_ToolSelectionComboBox->clear();
m_Controls->m_ToolTable->setRowCount(m_Tracker->GetToolCount());
for (unsigned int i = 0; i < m_Tracker->GetToolCount(); ++i)
{
mitk::TrackingTool* t = m_Tracker->GetTool(i);
if (t == nullptr)
{
m_Controls->m_ToolTable->setItem(i, QmitkNDIToolDelegate::IndexCol, new QTableWidgetItem("INVALID")); // Index
continue;
}
m_Controls->m_ToolSelectionComboBox->addItem(m_Tracker->GetTool(i)->GetToolName());
m_Controls->m_ToolTable->setItem(i, QmitkNDIToolDelegate::IndexCol, new QTableWidgetItem(QString::number(i))); // Index
m_Controls->m_ToolTable->setItem(i, QmitkNDIToolDelegate::NameCol, new QTableWidgetItem(t->GetToolName())); // Name
if (dynamic_cast<mitk::NDIPassiveTool*>(t)->GetSROMDataLength() > 0)
m_Controls->m_ToolTable->setItem(i, QmitkNDIToolDelegate::SROMCol, new QTableWidgetItem("SROM file loaded")); // SROM file
else
m_Controls->m_ToolTable->setItem(i, QmitkNDIToolDelegate::SROMCol, new QTableWidgetItem(m_SROMCellDefaultText)); // SROM file
m_Controls->m_ToolTable->setItem(i, QmitkNDIToolDelegate::TypeCol, new QTableWidgetItem("<click to set type>")); // Type
if (t->IsEnabled())
m_Controls->m_ToolTable->setItem(i, QmitkNDIToolDelegate::StatusCol, new QTableWidgetItem("Enabled")); // Status
else
m_Controls->m_ToolTable->setItem(i, QmitkNDIToolDelegate::StatusCol, new QTableWidgetItem("Disabled")); // Status
m_Controls->m_ToolTable->setItem(i, QmitkNDIToolDelegate::NodeCol, new QTableWidgetItem("<click to select node>")); // Node
m_Controls->m_ToolTable->setItem(i, QmitkNDIToolDelegate::RepCol, new QTableWidgetItem(m_RepresentatonCellDefaultText)); // Representation
/* set read-only/editable flags */
m_Controls->m_ToolTable->item(i, QmitkNDIToolDelegate::IndexCol)->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled); // Index
m_Controls->m_ToolTable->item(i, QmitkNDIToolDelegate::NodeCol)->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled); // Name
m_Controls->m_ToolTable->item(i, QmitkNDIToolDelegate::SROMCol)->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled); // SROM file
m_Controls->m_ToolTable->item(i, QmitkNDIToolDelegate::TypeCol)->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled); // Type
m_Controls->m_ToolTable->item(i, QmitkNDIToolDelegate::StatusCol)->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled); // Status
m_Controls->m_ToolTable->item(i, QmitkNDIToolDelegate::NodeCol)->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled); // Node
m_Controls->m_ToolTable->item(i, QmitkNDIToolDelegate::RepCol)->setFlags(Qt::NoItemFlags); // Representation surface file
}
m_Controls->m_ToolTable->resizeColumnsToContents();
//connect(m_Controls->m_ToolTable, SIGNAL(itemChanged(QTableWidgetItem*)), this, SLOT(OnTableItemChanged(QTableWidgetItem*))); // listen to table changes again
connect(m_Controls->m_ToolTable->model(), SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)), this, SLOT(UpdateTrackerFromToolTable(const QModelIndex &, const QModelIndex &)));
connect(m_Controls->m_ToolTable, SIGNAL( clicked ( const QModelIndex & )), this, SLOT ( OnTableItemClicked( const QModelIndex & )));
}
void QmitkNDIConfigurationWidget::OnDiscoverDevices()
{
PortDeviceMap portsAndDevices;
QString status = "Scanning ";
#ifdef WIN32
QString devName;
for (unsigned int i = 1; i < 40; ++i)
{
if (i<10)
devName = QString("COM%1").arg(i);
else
devName = QString("\\\\.\\COM%1").arg(i); // prepend "\\.\ to COM ports >9, to be able to allow connection"
portsAndDevices[devName];
status += QString("COM%1").arg(i) + ", ";
}
#else //linux/posix systems
for(unsigned int i = 1; i < 6; ++i)
{
QString devName = QString("/dev/ttyS%1").arg(i);
portsAndDevices[devName];
status += devName + ", ";
}
for(unsigned int i = 0; i <7; ++i)
{
QString devName = QString("/dev/ttyUSB%1").arg(i);
portsAndDevices[devName];
status += devName + ", ";
}
#endif
status.chop(2); // remove last ", "
status += " for NDI tracking devices...";
m_Controls->m_DeviceStatus->setText(status);
ScanPortsForNDITrackingDevices(portsAndDevices);
m_Controls->m_ComPortSelector->clear();
QString result = "The following tracking devices were found:<BR/>\n";
for (PortDeviceMap::const_iterator it = portsAndDevices.begin(); it != portsAndDevices.end(); ++it)
{
QString tmpComPort = it.key();
if (tmpComPort.startsWith("\\"))
{
tmpComPort.remove(0,4); // remove "\\.\" for nice ui visualisation
}
result += tmpComPort + ": ";
if (mitk::NDIPolarisTypeInformation::GetTrackingDeviceName() == it.value() || mitk::NDIAuroraTypeInformation::GetTrackingDeviceName() == it.value())
{
result += QString::fromStdString(it.value());
result += "<BR/>\n";
m_Controls->m_ComPortSelector->addItem(tmpComPort);
}
else
{
result += "No NDI tracking device found<BR/>\n";
}
}
//QMessageBox::information(nullptr, "Tracking Device Discovery", result);
m_Controls->m_DeviceStatus->setText(result);
}
mitk::TrackingDeviceType QmitkNDIConfigurationWidget::ScanPort(QString port)
{
mitk::NDITrackingDevice::Pointer tracker = mitk::NDITrackingDevice::New();
tracker->SetDeviceName(port.toStdString());
return tracker->TestConnection();
}
void QmitkNDIConfigurationWidget::ScanPortsForNDITrackingDevices( PortDeviceMap& portsAndDevices )
{
// Iterative scanning:
for (PortDeviceMap::iterator it = portsAndDevices.begin(); it != portsAndDevices.end(); ++it)
it.value() = this->ScanPort(it.key());
// \Todo: use parallel scanning
//QtConcurrent::blockingMap( portsAndDevices.begin(), portsAndDevices.end(), ScanPort );
//MITK_INFO << portsAndDevices;
}
QStringList QmitkNDIConfigurationWidget::GetToolNamesList()
{
QStringList toolNames;
if (m_Tracker.IsNull())
return toolNames;
for (unsigned int i = 0; i < m_Tracker->GetToolCount(); ++i)
{
mitk::TrackingTool* t = m_Tracker->GetTool(i);
if (t == nullptr)
continue;
toolNames << t->GetToolName();
}
return toolNames;
}
mitk::NDITrackingDevice* QmitkNDIConfigurationWidget::GetTracker() const
{
return m_Tracker.GetPointer();
}
void QmitkNDIConfigurationWidget::SetToolTypes(const QStringList& types)
{
m_Delegate->SetTypes(types);
}
void QmitkNDIConfigurationWidget::SetDataStorage(mitk::DataStorage* ds)
{
m_Delegate->SetDataStorage(ds);
}
void QmitkNDIConfigurationWidget::SetPredicate(mitk::NodePredicateBase::Pointer p)
{
m_Delegate->SetPredicate(p);
}
void QmitkNDIConfigurationWidget::SetTagPropertyName( const std::string& name )
{
m_Delegate->SetTagPropertyName(name);
}
void QmitkNDIConfigurationWidget::SetTagProperty( mitk::BaseProperty::Pointer prop )
{
m_Delegate->SetTagProperty(prop);
}
void QmitkNDIConfigurationWidget::OnTableItemClicked(const QModelIndex & topLeft )
{
QString filename;
QTableWidgetItem* filenameItem;
switch (topLeft.column())
{
case QmitkNDIToolDelegate::RepCol:
- filename = QFileDialog::getOpenFileName(this, "Select Surface File", QDir::currentPath(),"STL files (*.stl)");
+ filename = QFileDialog::getOpenFileName(this, "Select Surface File", QmitkIGTCommonHelper::GetLastFileLoadPath(),"STL files (*.stl)");
+ QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(filename);
filenameItem = new QTableWidgetItem(filename);
m_Controls->m_ToolTable->setItem( topLeft.row(), topLeft.column(), filenameItem );
if(QFileInfo(filename).exists())
{
mitk::Surface::Pointer surface = this->LoadSurfaceFromSTLFile(filename);
if(surface.IsNotNull())
emit RepresentationChanged( topLeft.row(), surface);
}
break;
default:
break;
}
}
void QmitkNDIConfigurationWidget::UpdateTrackerFromToolTable(const QModelIndex & topLeft, const QModelIndex & /*bottomRight*/)
{
//Colums ID doesn't have to be processed.
if (topLeft.column()<1)
return;
if (m_Tracker.IsNull())
return;
if (topLeft.row() >= (int) m_Tracker->GetToolCount())
return;
QAbstractItemModel* model = m_Controls->m_ToolTable->model();
//define topleft contains row and column; row 0 is tool 0; column is index =0, Name =1, SROMFileName = 2; Type = 3; Status = 4; Node (?) = 5
//only update the changed item
mitk::NDIPassiveTool* tool = dynamic_cast<mitk::NDIPassiveTool*> (m_Tracker->GetTool(topLeft.row()));
if (tool == nullptr)
return;
switch (topLeft.column())
{
case QmitkNDIToolDelegate::IndexCol: //index
break;
case QmitkNDIToolDelegate::NameCol: //name
tool->SetToolName(model->data(model->index(topLeft.row(), 1)).toString().toLatin1());
emit ToolsChanged();
break;
case QmitkNDIToolDelegate::SROMCol: //SROM File Name
{
QString romfile = model->data(model->index(topLeft.row(), QmitkNDIToolDelegate::SROMCol)).toString();
if (QFileInfo(romfile).exists())
tool->LoadSROMFile(romfile.toLatin1());
m_Tracker->UpdateTool(tool);
break;
}
//TODO: Add Node Status and Type here as well
default:
break;
}
}
const QString QmitkNDIConfigurationWidget::GetToolType( unsigned int index ) const
{
if (m_Controls == nullptr)
return QString("");
QAbstractItemModel* model = m_Controls->m_ToolTable->model();
QModelIndex modelIndex = model->index(index, QmitkNDIToolDelegate::TypeCol);
if (modelIndex.isValid() == false)
return QString("");
return model->data(modelIndex).toString();
}
const QString QmitkNDIConfigurationWidget::GetToolName( unsigned int index ) const
{
if (m_Controls == nullptr)
return QString("");
QAbstractItemModel* model = m_Controls->m_ToolTable->model();
QModelIndex modelIndex = model->index(index, QmitkNDIToolDelegate::NameCol);
if (modelIndex.isValid() == false)
return QString("");
return model->data(modelIndex).toString();
}
QMap<QString, unsigned int> QmitkNDIConfigurationWidget::GetToolAndTypes() const
{
QMap<QString, unsigned int> map;
if (m_Controls == nullptr)
return map;
QAbstractItemModel* model = m_Controls->m_ToolTable->model();
for (int i = 0; i < model->rowCount(); ++i)
{
QModelIndex indexIndex = model->index(i, QmitkNDIToolDelegate::IndexCol);
QModelIndex typeIndex = model->index(i, QmitkNDIToolDelegate::TypeCol);
if ((indexIndex.isValid() == false) || (typeIndex.isValid() == false))
continue;
map.insert(model->data(typeIndex).toString(), model->data(indexIndex).toUInt());
}
return map;
}
QList<unsigned int> QmitkNDIConfigurationWidget::GetToolsByToolType( QString toolType ) const
{
QList<unsigned int> list;
if (m_Controls == nullptr)
return list;
QAbstractItemModel* model = m_Controls->m_ToolTable->model();
for (int i = 0; i < model->rowCount(); ++i)
{
QModelIndex indexIndex = model->index(i, QmitkNDIToolDelegate::IndexCol);
QModelIndex typeIndex = model->index(i, QmitkNDIToolDelegate::TypeCol);
if ((indexIndex.isValid() == false) || (typeIndex.isValid() == false))
continue;
if (model->data(typeIndex).toString() == toolType)
list.append(model->data(indexIndex).toUInt());
}
return list;
}
mitk::DataNode* QmitkNDIConfigurationWidget::GetNode( unsigned int index ) const
{
if (m_Controls == nullptr)
return nullptr;
QAbstractItemModel* model = m_Controls->m_ToolTable->model();
QVariant data = model->data(model->index(index, QmitkNDIToolDelegate::NodeCol), QmitkNDIToolDelegate::OrganNodeRole);
return data.value<mitk::DataNode*>();
}
void QmitkNDIConfigurationWidget::HidePolarisOptionsGroupbox( bool on )
{
m_Controls->m_gbPolarisOptions->setHidden(on);
}
void QmitkNDIConfigurationWidget::HideAuroraOptionsGroupbox( bool on )
{
m_Controls->m_gbAuroraOptions->setHidden(on);
}
void QmitkNDIConfigurationWidget::ShowToolRepresentationColumn()
{
int cols = m_Controls->m_ToolTable->columnCount();
//checking if representation column is inserted at right index
if(cols != QmitkNDIToolDelegate::RepCol)
{
//throw std::exception("Representation Column is not inserted at it's designated index!");
return;
}
m_Controls->m_ToolTable->insertColumn(cols); // insert new column at end of table
m_Controls->m_ToolTable->setHorizontalHeaderItem(QmitkNDIToolDelegate::RepCol, new QTableWidgetItem(QString("Representation"))); // inser column header for new colum
//m_Controls->m_ToolTable->setEditTriggers(QAbstractItemView::EditTrigger::NoEditTriggers);
int rows = m_Controls->m_ToolTable->rowCount();
// make all representation colum items not editable
for(int i=0; i < rows; ++i)
{
m_Controls->m_ToolTable->setItem(i, QmitkNDIToolDelegate::RepCol, new QTableWidgetItem("<click to select representation>")); // Representation
m_Controls->m_ToolTable->item(i,QmitkNDIToolDelegate::RepCol)->setFlags(Qt::NoItemFlags);
}
//connect(m_Controls->m_ToolTable, SIGNAL( clicked ( const QModelIndex & )), this, SLOT ( OnTableItemClicked( const QModelIndex & )));
}
void QmitkNDIConfigurationWidget::OnDisoverDevicesBtnInfo()
{
QMessageBox *infoBox = new QMessageBox(this);
infoBox->setText("Click \"Scan Ports\" to get a list of all connected NDI tracking devices. This will clear the selection menu below and add the ports for discovered NDI tracking devices. Use this function, if a port is not listed.");
infoBox->exec();
delete infoBox;
}
void QmitkNDIConfigurationWidget::OnTableCellChanged(int row, int column)
{
if(m_Tracker.IsNull())
return;
QString toolName;
switch (column)
{
case QmitkNDIToolDelegate::NameCol:
toolName = m_Controls->m_ToolTable->item(row,column)->text();
m_Controls->m_ToolSelectionComboBox->setItemText(row, toolName);
emit SignalToolNameChanged(row, toolName);
break;
default:
break;
}
}
void QmitkNDIConfigurationWidget::OnSaveTool()
{
if(m_Tracker.IsNull() || m_Tracker->GetToolCount() <= 0)
return;
int currId = m_Controls->m_ToolSelectionComboBox->currentIndex();
QString filename = QFileDialog::getSaveFileName(nullptr, "Save NDI-Tool", QString(QString(m_Tracker->GetTool(currId)->GetToolName())),"NDI Tracking Tool file(*.ntf)");
mitk::TrackingTool* selectedTool = m_Tracker->GetTool(currId);
if(filename.isEmpty())
return;
mitk::NavigationTool::Pointer navTool = mitk::NavigationTool::New();
mitk::NavigationToolWriter::Pointer toolWriter = mitk::NavigationToolWriter::New();
try {
toolWriter->DoWrite(filename.toStdString(), this->GenerateNavigationTool(selectedTool));
}
catch( ... )
{
QMessageBox::warning(nullptr, "Saving Tool Error", QString("An error occured! Could not save tool!\n\n"));
MBI_ERROR<<"Could not save tool surface!";
MBI_ERROR<< toolWriter->GetErrorMessage();
QFile maybeCorruptFile(filename);
if(maybeCorruptFile.exists())
maybeCorruptFile.remove();
}
emit SignalSavedTool(currId, filename);
}
void QmitkNDIConfigurationWidget::OnLoadTool()
{
if(m_Tracker.IsNull() || m_Tracker->GetToolCount() <= 0)
return;
- QString filename = QFileDialog::getOpenFileName(nullptr, "Load NDI-Tools", QDir::currentPath(),"NDI Tracking Tool file(*.ntf)");
+ QString filename = QFileDialog::getOpenFileName(nullptr, "Load NDI-Tools", QmitkIGTCommonHelper::GetLastFileLoadPath(),"NDI Tracking Tool file(*.ntf)");
int currId = m_Controls->m_ToolSelectionComboBox->currentIndex();
if(filename.isEmpty())
return;
+ QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(filename);
+
mitk::DataNode::Pointer toolNode;
mitk::NavigationToolReader::Pointer toolReader = mitk::NavigationToolReader::New();
mitk::NavigationTool::Pointer navTool;
try {
navTool = toolReader->DoRead(filename.toStdString());
}
catch( ... )
{
QMessageBox::warning(nullptr, "Loading Tool Error", QString("An error occured! Could not load tool!\n\n"));
MBI_ERROR<<"Could not load tool surface!";
MBI_ERROR<< toolReader->GetErrorMessage();
}
int currSelectedToolID = m_Controls->m_ToolSelectionComboBox->currentIndex();
// name
m_Controls->m_ToolTable->item(currSelectedToolID,QmitkNDIToolDelegate::NameCol)->setText(navTool->GetToolName().c_str());
dynamic_cast<mitk::NDIPassiveTool*>(m_Tracker->GetTool(currSelectedToolID))->SetToolName(navTool->GetToolName().c_str()); // also setting name to tool directly
//calibration file (.srom) filename
m_Controls->m_ToolTable->item(currSelectedToolID,QmitkNDIToolDelegate::SROMCol)->setText(navTool->GetCalibrationFile().c_str());
//type
if(navTool->GetType() == mitk::NavigationTool::Instrument)
m_Controls->m_ToolTable->item(currSelectedToolID,QmitkNDIToolDelegate::TypeCol)->setText("Instrument");
else if(navTool->GetType() == mitk::NavigationTool::Fiducial)
m_Controls->m_ToolTable->item(currSelectedToolID,QmitkNDIToolDelegate::TypeCol)->setText("Fiducial");
else if(navTool->GetType() == mitk::NavigationTool::Skinmarker)
m_Controls->m_ToolTable->item(currSelectedToolID,QmitkNDIToolDelegate::TypeCol)->setText("Skinmarker");
else
m_Controls->m_ToolTable->item(currSelectedToolID,QmitkNDIToolDelegate::TypeCol)->setText("Unknown");
//representation
m_Controls->m_ToolTable->item(currSelectedToolID,QmitkNDIToolDelegate::SROMCol)->setText(m_RepresentatonCellDefaultText);
emit SignalLoadTool(currId, navTool->GetDataNode());
}
mitk::NavigationTool::Pointer QmitkNDIConfigurationWidget::GenerateNavigationTool(mitk::TrackingTool* tool)
{
mitk::NavigationTool::Pointer navTool = mitk::NavigationTool::New();
mitk::NDIPassiveTool::Pointer passiveTool = dynamic_cast<mitk::NDIPassiveTool*>(tool);
if(passiveTool.IsNull())
throw std::runtime_error("Could not cast TrackingTool to PassiveTool");
int currSelectedToolID = m_Controls->m_ToolSelectionComboBox->currentIndex();
QString sromFileName = m_Controls->m_ToolTable->item(currSelectedToolID, QmitkNDIToolDelegate::SROMCol)->text();
QString surfaceFileName = m_Controls->m_ToolTable->item(currSelectedToolID, QmitkNDIToolDelegate::RepCol)->text();
//calibration file (.srom) filename
QFile sromFile(sromFileName);
if(sromFile.exists())
navTool->SetCalibrationFile(sromFileName.toStdString());
//serial number
navTool->SetSerialNumber(passiveTool->GetSerialNumber());
// name and surface as dataNode
mitk::DataNode::Pointer node = mitk::DataNode::New();
mitk::Surface::Pointer toolSurface;
try{
toolSurface = this->LoadSurfaceFromSTLFile(surfaceFileName);
}
catch( ... )
{
QMessageBox::warning(nullptr, "Loading Surface Error", QString("An error occured! Could not load surface from .stl file!\n\n"));
MBI_ERROR<<"Could not load .stl tool surface!";
}
if(toolSurface.IsNotNull())
{
node->SetData(toolSurface);
node->SetName(tool->GetToolName());
}
navTool->SetDataNode(node);
// type
mitk::NavigationTool::NavigationToolType type;
QString currentToolType = m_Controls->m_ToolTable->item(currSelectedToolID,QmitkNDIToolDelegate::TypeCol)->text();
if(currentToolType.compare("Instrument") == 0)
type = mitk::NavigationTool::Instrument;
else if(currentToolType.compare("Fiducial") == 0)
type = mitk::NavigationTool::Fiducial;
else if(currentToolType.compare("Skinmarker") == 0)
type = mitk::NavigationTool::Skinmarker;
else
type = mitk::NavigationTool::Unknown;
navTool->SetType(type);
return navTool;
}
mitk::Surface::Pointer QmitkNDIConfigurationWidget::LoadSurfaceFromSTLFile(QString surfaceFilename)
{
mitk::Surface::Pointer toolSurface;
QFile surfaceFile(surfaceFilename);
if(surfaceFile.exists())
{
try{
toolSurface = mitk::IOUtil::LoadSurface(surfaceFilename.toStdString().c_str());
}
catch(std::exception& e )
{
MBI_ERROR<<"Could not load surface for tool!";
MBI_ERROR<< e.what();
throw e;
}
}
return toolSurface;
}
void QmitkNDIConfigurationWidget::EnableAddToolsButton(bool enable) {
m_Controls->m_AddToolBtn->setEnabled(enable);
}
void QmitkNDIConfigurationWidget::EnableDiscoverNewToolsButton(bool enable) {
m_Controls->m_DiscoverToolsBtn->setEnabled(enable);
}
diff --git a/Modules/IGTUI/Qmitk/QmitkNPOptitrackWidget.cpp b/Modules/IGTUI/Qmitk/QmitkNPOptitrackWidget.cpp
index ac0ca48415..47f43dbd0e 100644
--- a/Modules/IGTUI/Qmitk/QmitkNPOptitrackWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkNPOptitrackWidget.cpp
@@ -1,120 +1,122 @@
/*===================================================================
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 "QmitkNPOptitrackWidget.h"
#include "mitkOptitrackTrackingDevice.h"
#include "mitkNPOptitrackTrackingTypeInformation.h"
+#include "QmitkIGTCommonHelper.h"
#include <QFileDialog>
#include <QScrollBar>
#include <Poco/Path.h>
const std::string QmitkNPOptitrackWidget::VIEW_ID = "org.mitk.views.NPOptitrackWidget";
QmitkNPOptitrackWidget::QmitkNPOptitrackWidget(QWidget* parent, Qt::WindowFlags f)
: QmitkAbstractTrackingDeviceWidget(parent, f)
, m_Controls(nullptr)
{
}
void QmitkNPOptitrackWidget::Initialize()
{
InitializeSuperclassWidget();
CreateQtPartControl(this);
CreateConnections();
}
QmitkNPOptitrackWidget::~QmitkNPOptitrackWidget()
{
delete m_Controls;
}
void QmitkNPOptitrackWidget::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkNPOptitrackWidget;
m_Controls->setupUi(parent);
}
}
void QmitkNPOptitrackWidget::CreateConnections()
{
if (m_Controls)
{
connect((QObject*)(m_Controls->m_testConnectionOptitrack), SIGNAL(clicked()), this, SLOT(TestConnection()));
connect((QObject*)(m_Controls->m_SetOptitrackCalibrationFile), SIGNAL(clicked()), this, SLOT(SetOptitrackCalibrationFileClicked()));
}
}
void QmitkNPOptitrackWidget::ResetOutput()
{
m_Controls->m_outputTextOptitrack->setHtml("<body style=\" font-family:\'MS Shell Dlg 2\'; font-size:7pt; font-weight:400; font-style:normal;\" bgcolor=black><span style=\"color:#ffffff;\"><u>output:</u>");
}
void QmitkNPOptitrackWidget::AddOutput(std::string s)
{
m_Controls->m_outputTextOptitrack->setHtml(QString(s.c_str()));
m_Controls->m_outputTextOptitrack->verticalScrollBar()->setValue(m_Controls->m_outputTextOptitrack->verticalScrollBar()->maximum());
}
mitk::TrackingDevice::Pointer QmitkNPOptitrackWidget::ConstructTrackingDevice()
{
// Create the Tracking Device
mitk::OptitrackTrackingDevice::Pointer tempTrackingDevice = mitk::OptitrackTrackingDevice::New();
// Set the calibration File
tempTrackingDevice->SetCalibrationPath(m_OptitrackCalibrationFile);
//Set the camera parameters
tempTrackingDevice->SetExp(m_Controls->m_OptitrackExp->value());
tempTrackingDevice->SetLed(m_Controls->m_OptitrackLed->value());
tempTrackingDevice->SetThr(m_Controls->m_OptitrackThr->value());
tempTrackingDevice->SetType(mitk::NPOptitrackTrackingTypeInformation::GetTrackingDeviceName());
return static_cast<mitk::TrackingDevice::Pointer>(tempTrackingDevice);
}
bool QmitkNPOptitrackWidget::IsDeviceInstalled()
{
return mitk::OptitrackTrackingDevice::New()->IsDeviceInstalled();
}
void QmitkNPOptitrackWidget::SetOptitrackCalibrationFileClicked()
{
- std::string filename = QFileDialog::getOpenFileName(nullptr, tr("Open Calibration File"), "/", "*.*").toLatin1().data();
+ std::string filename = QFileDialog::getOpenFileName(nullptr, tr("Open Calibration File"), QmitkIGTCommonHelper::GetLastFileLoadPath(), "*.*").toLatin1().data();
if (filename == "") { return; }
else
{
+ QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(QString::fromStdString(filename));
m_OptitrackCalibrationFile = filename;
Poco::Path myPath = Poco::Path(m_OptitrackCalibrationFile.c_str());
m_Controls->m_OptitrackCalibrationFile->setText("Calibration File: " + QString(myPath.getFileName().c_str()));
}
}
QmitkNPOptitrackWidget* QmitkNPOptitrackWidget::Clone(QWidget* parent) const
{
QmitkNPOptitrackWidget* clonedWidget = new QmitkNPOptitrackWidget(parent);
clonedWidget->Initialize();
clonedWidget->m_OptitrackCalibrationFile = this->m_OptitrackCalibrationFile;
clonedWidget->m_Controls->m_OptitrackCalibrationFile->setText(m_Controls->m_OptitrackCalibrationFile->text());
clonedWidget->m_Controls->m_OptitrackExp->setValue(m_Controls->m_OptitrackExp->value());
clonedWidget->m_Controls->m_OptitrackLed->setValue(m_Controls->m_OptitrackLed->value());
clonedWidget->m_Controls->m_OptitrackThr->setValue(m_Controls->m_OptitrackThr->value());
return clonedWidget;
}
diff --git a/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.cpp b/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.cpp
index 4621ac9e63..bffcd3b5fd 100644
--- a/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.cpp
@@ -1,336 +1,347 @@
/*===================================================================
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 "QmitkNavigationToolCreationWidget.h"
//mitk headers
#include <mitkTrackingTypes.h>
#include <mitkSurface.h>
#include <mitkNavigationData.h>
#include <mitkRenderingManager.h>
#include "mitkTrackingDeviceTypeCollection.h"
//qt headers
#include <qfiledialog.h>
#include <qmessagebox.h>
#include <QDialog>
#include <mitkIOUtil.h>
+#include <QmitkIGTCommonHelper.h>
//poco headers
#include <Poco/Path.h>
// vtk
#include <vtkSphereSource.h>
#include <vtkConeSource.h>
const std::string QmitkNavigationToolCreationWidget::VIEW_ID = "org.mitk.views.navigationtoolcreationwizardwidget";
QmitkNavigationToolCreationWidget::QmitkNavigationToolCreationWidget(QWidget* parent, Qt::WindowFlags f)
: QWidget(parent, f)
{
m_Controls = nullptr;
m_AdvancedWidget = new QmitkNavigationToolCreationAdvancedWidget(this);
m_AdvancedWidget->setWindowFlags(Qt::Tool | Qt::WindowStaysOnTopHint);
m_AdvancedWidget->setWindowTitle("Tool Creation Advanced Options");
m_AdvancedWidget->setModal(false);
CreateQtPartControl(this);
CreateConnections();
RefreshTrackingDeviceCollection();
}
QmitkNavigationToolCreationWidget::~QmitkNavigationToolCreationWidget()
{
m_Controls->m_CalibrationLandmarksList->SetPointSetNode(nullptr);
m_Controls->m_RegistrationLandmarksList->SetPointSetNode(nullptr);
delete m_AdvancedWidget;
}
void QmitkNavigationToolCreationWidget::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkNavigationToolCreationWidgetControls;
m_Controls->setupUi(parent);
}
}
void QmitkNavigationToolCreationWidget::CreateConnections()
{
if ( m_Controls )
{
connect( (QObject*)(m_Controls->m_cancel), SIGNAL(clicked()), this, SLOT(OnCancel()) );
connect( (QObject*)(m_Controls->m_finished), SIGNAL(clicked()), this, SLOT(OnFinished()) );
connect( (QObject*)(m_Controls->m_LoadSurface), SIGNAL(clicked()), this, SLOT(OnLoadSurface()) );
connect( (QObject*)(m_Controls->m_LoadCalibrationFile), SIGNAL(clicked()), this, SLOT(OnLoadCalibrationFile()) );
connect( (QObject*)(m_Controls->m_ShowAdvancedOptionsPB), SIGNAL(toggled(bool)), this, SLOT(OnShowAdvancedOptions(bool)) );
connect( (QObject*)(m_AdvancedWidget), SIGNAL(DialogCloseRequested()), this, SLOT(OnProcessDialogCloseRequest()) );
connect( (QObject*)(m_AdvancedWidget), SIGNAL(RetrieveDataForManualToolTipManipulation()), this, SLOT(OnRetrieveDataForManualTooltipManipulation()) );
connect( m_Controls->m_Surface_Use_Other, SIGNAL(toggled(bool)), this, SLOT(OnSurfaceUseOtherToggled(bool)));
}
}
void QmitkNavigationToolCreationWidget::Initialize(mitk::DataStorage* dataStorage, const std::string& supposedIdentifier, const std::string& supposedName)
{
m_DataStorage = dataStorage;
//initialize UI components
m_Controls->m_SurfaceChooser->SetDataStorage(m_DataStorage);
m_Controls->m_SurfaceChooser->SetAutoSelectNewItems(true);
m_Controls->m_SurfaceChooser->SetPredicate(mitk::NodePredicateDataType::New("Surface"));
//set default data
m_Controls->m_ToolNameEdit->setText(supposedName.c_str());
m_Controls->m_CalibrationFileName->setText("none");
m_Controls->m_Surface_Use_Sphere->setChecked(true);
m_AdvancedWidget->SetDataStorage(m_DataStorage);
m_Controls->m_IdentifierEdit->setText(supposedIdentifier.c_str());
this->InitializeUIToolLandmarkLists();
m_Controls->m_CalibrationLandmarksList->EnableEditButton(false);
m_Controls->m_RegistrationLandmarksList->EnableEditButton(false);
}
void QmitkNavigationToolCreationWidget::SetTrackingDeviceType(mitk::TrackingDeviceType type, bool changeable)
{
int index = m_Controls->m_TrackingDeviceTypeChooser->findText(QString::fromStdString(type));
if (index >= 0)
{
m_Controls->m_TrackingDeviceTypeChooser->setCurrentIndex(index);
}
}
mitk::NavigationTool::Pointer QmitkNavigationToolCreationWidget::GetCreatedTool()
{
return m_CreatedTool;
}
//##################################################################################
//############################## slots ############################
//##################################################################################
void QmitkNavigationToolCreationWidget::OnFinished()
{
//here we create a new tool
m_CreatedTool = mitk::NavigationTool::New();
//create DataNode...
mitk::DataNode::Pointer newNode = mitk::DataNode::New();
if(m_Controls->m_Surface_Use_Sphere->isChecked())
{
//create small sphere and use it as surface
mitk::Surface::Pointer mySphere = 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();
mySphere->SetVtkPolyData(vtkData->GetOutput());
vtkData->Delete();
newNode->SetData(mySphere);
}
else
{
newNode->SetData(m_Controls->m_SurfaceChooser->GetSelectedNode()->GetData());
}
newNode->SetName(m_Controls->m_ToolNameEdit->text().toLatin1());
m_CreatedTool->SetDataNode(newNode);
//fill NavigationTool object
m_CreatedTool->SetCalibrationFile(m_Controls->m_CalibrationFileName->text().toLatin1().data());
m_CreatedTool->SetIdentifier(m_Controls->m_IdentifierEdit->text().toLatin1().data());
m_CreatedTool->SetSerialNumber(m_Controls->m_SerialNumberEdit->text().toLatin1().data());
//Tracking Device
m_CreatedTool->SetTrackingDeviceType(m_Controls->m_TrackingDeviceTypeChooser->currentText().toStdString());
//ToolType
if (m_Controls->m_ToolTypeChooser->currentText()=="Instrument") m_CreatedTool->SetType(mitk::NavigationTool::Instrument);
else if (m_Controls->m_ToolTypeChooser->currentText()=="Fiducial") m_CreatedTool->SetType(mitk::NavigationTool::Fiducial);
else if (m_Controls->m_ToolTypeChooser->currentText()=="Skinmarker") m_CreatedTool->SetType(mitk::NavigationTool::Skinmarker);
else m_CreatedTool->SetType(mitk::NavigationTool::Unknown);
//Tool Tip
mitk::NavigationData::Pointer tempND = mitk::NavigationData::New(m_AdvancedWidget->GetManipulatedToolTip());
m_CreatedTool->SetToolTipOrientation(tempND->GetOrientation());
m_CreatedTool->SetToolTipPosition(tempND->GetPosition());
//Tool Landmarks
mitk::PointSet::Pointer toolCalLandmarks, toolRegLandmarks;
GetUIToolLandmarksLists(toolCalLandmarks,toolRegLandmarks);
m_CreatedTool->SetToolCalibrationLandmarks(toolCalLandmarks);
m_CreatedTool->SetToolRegistrationLandmarks(toolRegLandmarks);
+ //Tool Axis
+ mitk::Point3D toolAxis;
+ toolAxis.SetElement(0, (m_Controls->m_ToolAxisX->value()));
+ toolAxis.SetElement(1, (m_Controls->m_ToolAxisY->value()));
+ toolAxis.SetElement(2, (m_Controls->m_ToolAxisZ->value()));
+ m_CreatedTool->SetToolAxis(toolAxis);
+
emit NavigationToolFinished();
}
void QmitkNavigationToolCreationWidget::OnCancel()
{
m_CreatedTool = nullptr;
emit Canceled();
}
void QmitkNavigationToolCreationWidget::OnLoadSurface()
{
- std::string filename = QFileDialog::getOpenFileName(nullptr,tr("Open Surface"), "/", tr("STL (*.stl)")).toLatin1().data();
+ std::string filename = QFileDialog::getOpenFileName(nullptr,tr("Open Surface"), QmitkIGTCommonHelper::GetLastFileLoadPath(), tr("STL (*.stl)")).toLatin1().data();
+ QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(QString::fromStdString(filename));
try
{
mitk::IOUtil::Load(filename.c_str(), *m_DataStorage);
}
catch (mitk::Exception &e)
{
MITK_ERROR << "Exception occured: " << e.what();
}
}
void QmitkNavigationToolCreationWidget::OnLoadCalibrationFile()
{
- m_Controls->m_CalibrationFileName->setText(QFileDialog::getOpenFileName(nullptr,tr("Open Calibration File"), "/", "*.*"));
+ QString fileName = QFileDialog::getOpenFileName(nullptr,tr("Open Calibration File"), QmitkIGTCommonHelper::GetLastFileLoadPath(), "*.*");
+ QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(fileName);
+ m_Controls->m_CalibrationFileName->setText(fileName);
}
void QmitkNavigationToolCreationWidget::SetDefaultData(mitk::NavigationTool::Pointer DefaultTool)
{
m_Controls->m_ToolNameEdit->setText(QString(DefaultTool->GetDataNode()->GetName().c_str()));
m_Controls->m_IdentifierEdit->setText(QString(DefaultTool->GetIdentifier().c_str()));
m_Controls->m_SerialNumberEdit->setText(QString(DefaultTool->GetSerialNumber().c_str()));
m_AdvancedWidget->SetDefaultTooltip( DefaultTool->GetToolTipTransform() );
int index = m_Controls->m_TrackingDeviceTypeChooser->findText(QString::fromStdString(DefaultTool->GetTrackingDeviceType()));
if (index >= 0)
{
m_Controls->m_TrackingDeviceTypeChooser->setCurrentIndex(index);
}
m_Controls->m_CalibrationFileName->setText(QString(DefaultTool->GetCalibrationFile().c_str()));
m_Controls->m_Surface_Use_Other->setChecked(true);
switch(DefaultTool->GetType())
{
case mitk::NavigationTool::Instrument:
m_Controls->m_ToolTypeChooser->setCurrentIndex(0); break;
case mitk::NavigationTool::Fiducial:
m_Controls->m_ToolTypeChooser->setCurrentIndex(1); break;
case mitk::NavigationTool::Skinmarker:
m_Controls->m_ToolTypeChooser->setCurrentIndex(2); break;
case mitk::NavigationTool::Unknown:
m_Controls->m_ToolTypeChooser->setCurrentIndex(3); break;
}
m_Controls->m_SurfaceChooser->SetSelectedNode(DefaultTool->GetDataNode());
FillUIToolLandmarkLists(DefaultTool->GetToolCalibrationLandmarks(),DefaultTool->GetToolRegistrationLandmarks());
}
//##################################################################################
//############################## internal help methods #############################
//##################################################################################
void QmitkNavigationToolCreationWidget::MessageBox(std::string s)
{
QMessageBox msgBox;
msgBox.setText(s.c_str());
msgBox.exec();
}
void QmitkNavigationToolCreationWidget::OnShowAdvancedOptions(bool state)
{
if(state)
{
m_AdvancedWidget->show();
m_AdvancedWidget->SetDefaultTooltip(m_AdvancedWidget->GetManipulatedToolTip()); //use the last one, if there is one
m_AdvancedWidget->ReInitialize();
// reinit the views with the new nodes
mitk::DataStorage::SetOfObjects::ConstPointer rs = m_DataStorage->GetAll();
mitk::TimeGeometry::Pointer bounds = m_DataStorage->ComputeBoundingGeometry3D(rs, "visible"); // initialize the views to the bounding geometry
mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
}
else
{
m_AdvancedWidget->hide();
}
}
void QmitkNavigationToolCreationWidget::OnProcessDialogCloseRequest()
{
m_AdvancedWidget->hide();
m_Controls->m_ShowAdvancedOptionsPB->setChecked(false);
}
void QmitkNavigationToolCreationWidget::OnRetrieveDataForManualTooltipManipulation()
{
if(m_Controls->m_Surface_Use_Sphere->isChecked())
{
m_AdvancedWidget->SetToolTipSurface(true);
}
else
{
m_AdvancedWidget->SetToolTipSurface(false,
dynamic_cast<mitk::DataNode*>(m_Controls->m_SurfaceChooser->GetSelectedNode().GetPointer()));
}
}
void QmitkNavigationToolCreationWidget::OnSurfaceUseOtherToggled(bool checked)
{
m_Controls->m_LoadSurface->setEnabled(checked);
}
void QmitkNavigationToolCreationWidget::FillUIToolLandmarkLists(mitk::PointSet::Pointer calLandmarks, mitk::PointSet::Pointer regLandmarks)
{
m_calLandmarkNode->SetData(calLandmarks);
m_regLandmarkNode->SetData(regLandmarks);
m_Controls->m_CalibrationLandmarksList->SetPointSetNode(m_calLandmarkNode);
m_Controls->m_RegistrationLandmarksList->SetPointSetNode(m_regLandmarkNode);
}
void QmitkNavigationToolCreationWidget::GetUIToolLandmarksLists(mitk::PointSet::Pointer& calLandmarks, mitk::PointSet::Pointer& regLandmarks)
{
calLandmarks = dynamic_cast<mitk::PointSet*>(m_calLandmarkNode->GetData());
regLandmarks = dynamic_cast<mitk::PointSet*>(m_regLandmarkNode->GetData());
}
void QmitkNavigationToolCreationWidget::InitializeUIToolLandmarkLists()
{
m_calLandmarkNode = mitk::DataNode::New();
m_regLandmarkNode = mitk::DataNode::New();
FillUIToolLandmarkLists(mitk::PointSet::New(),mitk::PointSet::New());
}
void QmitkNavigationToolCreationWidget::RefreshTrackingDeviceCollection()
{
us::ModuleContext* context = us::GetModuleContext();
std::vector<us::ServiceReference<mitk::TrackingDeviceTypeCollection> > refs = context->GetServiceReferences<mitk::TrackingDeviceTypeCollection>();
if (refs.empty())
{
MITK_WARN << "No tracking device service found!";
return;
}
mitk::TrackingDeviceTypeCollection* _DeviceTypeCollection = context->GetService<mitk::TrackingDeviceTypeCollection>(refs.front());
for (auto name : _DeviceTypeCollection->GetTrackingDeviceTypeNames())
{
//if the device is not included yet, add name to comboBox and widget to stackedWidget
if (m_Controls->m_TrackingDeviceTypeChooser->findText(QString::fromStdString(name)) == -1)
{
m_Controls->m_TrackingDeviceTypeChooser->addItem(QString::fromStdString(name));
}
}
}
diff --git a/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.ui b/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.ui
index 67abcf9f91..d65184df95 100644
--- a/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.ui
+++ b/Modules/IGTUI/Qmitk/QmitkNavigationToolCreationWidget.ui
@@ -1,511 +1,571 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>QmitkNavigationToolCreationWidgetControls</class>
<widget class="QWidget" name="QmitkNavigationToolCreationWidgetControls">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
- <width>254</width>
+ <width>255</width>
<height>309</height>
</rect>
</property>
<property name="windowTitle">
<string>Form</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
<widget class="QLabel" name="label">
<property name="text">
<string>Device Type:</string>
</property>
</widget>
</item>
<item>
<widget class="QComboBox" name="m_TrackingDeviceTypeChooser">
<property name="minimumSize">
<size>
<width>150</width>
<height>0</height>
</size>
</property>
<property name="maximumSize">
<size>
<width>150</width>
<height>16777215</height>
</size>
</property>
</widget>
</item>
</layout>
</item>
<item>
<widget class="QToolBox" name="toolBox">
<property name="currentIndex">
<number>0</number>
</property>
<widget class="QWidget" name="page">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>236</width>
- <height>115</height>
+ <height>90</height>
</rect>
</property>
<attribute name="label">
<string>Basic Information</string>
</attribute>
<layout class="QVBoxLayout" name="verticalLayout_2">
<item>
<layout class="QHBoxLayout" name="horizontalLayout_11">
<item>
<widget class="QLabel" name="label_3">
<property name="minimumSize">
<size>
<width>100</width>
<height>0</height>
</size>
</property>
<property name="text">
<string>Name:</string>
</property>
</widget>
</item>
<item>
<widget class="QLineEdit" name="m_ToolNameEdit">
<property name="text">
<string>NewTool</string>
</property>
</widget>
</item>
</layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_6">
<item>
<widget class="QLabel" name="label_8">
<property name="minimumSize">
<size>
<width>100</width>
<height>0</height>
</size>
</property>
<property name="text">
<string>Calibration File:</string>
</property>
</widget>
</item>
<item>
<widget class="QLineEdit" name="m_CalibrationFileName">
<property name="text">
<string>none</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="m_LoadCalibrationFile">
<property name="maximumSize">
<size>
<width>40</width>
<height>16777215</height>
</size>
</property>
<property name="text">
<string>Load</string>
</property>
</widget>
</item>
</layout>
</item>
<item>
<spacer name="verticalSpacer_3">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
<widget class="QWidget" name="page_2">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
- <width>303</width>
- <height>98</height>
+ <width>310</width>
+ <height>113</height>
</rect>
</property>
<attribute name="label">
<string>Tool Visualization</string>
</attribute>
<layout class="QVBoxLayout" name="verticalLayout_3">
<item>
<widget class="QRadioButton" name="m_Surface_Use_Sphere">
<property name="text">
<string>Use Simple Cone</string>
</property>
<property name="checked">
<bool>true</bool>
</property>
</widget>
</item>
<item>
<widget class="QRadioButton" name="m_Surface_Use_Other">
<property name="text">
<string>Use Surface:</string>
</property>
</widget>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_2">
<item>
<spacer name="horizontalSpacer_3">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeType">
<enum>QSizePolicy::Fixed</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>25</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QmitkDataStorageComboBox" name="m_SurfaceChooser">
<property name="minimumSize">
<size>
<width>200</width>
<height>0</height>
</size>
</property>
<property name="maximumSize">
<size>
<width>150</width>
<height>16777215</height>
</size>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="m_LoadSurface">
<property name="enabled">
<bool>false</bool>
</property>
<property name="maximumSize">
<size>
<width>40</width>
<height>16777215</height>
</size>
</property>
<property name="text">
<string>Load</string>
</property>
</widget>
</item>
<item>
<spacer name="horizontalSpacer_4">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
</layout>
</item>
<item>
<spacer name="verticalSpacer_2">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>8</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
<widget class="QWidget" name="page_4">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
- <width>236</width>
- <height>115</height>
+ <width>157</width>
+ <height>84</height>
</rect>
</property>
<attribute name="label">
<string>Tool Landmarks</string>
</attribute>
<layout class="QVBoxLayout" name="verticalLayout_6">
<item>
<widget class="QTabWidget" name="m_RegistrationLandmarksTab">
<property name="currentIndex">
<number>1</number>
</property>
<widget class="QWidget" name="tab">
<attribute name="title">
<string>Calibration Landmarks</string>
</attribute>
<layout class="QVBoxLayout" name="verticalLayout_7">
<item>
<widget class="QmitkPointListWidget" name="m_CalibrationLandmarksList" native="true"/>
</item>
</layout>
</widget>
<widget class="QWidget" name="tab_2">
<attribute name="title">
<string>Registration Landmarks</string>
</attribute>
<layout class="QVBoxLayout" name="verticalLayout_5">
<item>
<widget class="QmitkPointListWidget" name="m_RegistrationLandmarksList" native="true"/>
</item>
</layout>
</widget>
</widget>
</item>
</layout>
</widget>
<widget class="QWidget" name="page_3">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
- <width>276</width>
- <height>133</height>
+ <width>286</width>
+ <height>183</height>
</rect>
</property>
<attribute name="label">
<string>Advanced</string>
</attribute>
<layout class="QVBoxLayout" name="verticalLayout_4">
<item>
<layout class="QHBoxLayout" name="horizontalLayout_4">
<item>
<widget class="QLabel" name="label_7">
<property name="minimumSize">
<size>
<width>100</width>
<height>0</height>
</size>
</property>
<property name="text">
<string>Tool Type:</string>
</property>
</widget>
</item>
<item>
<widget class="QComboBox" name="m_ToolTypeChooser">
<property name="minimumSize">
<size>
<width>150</width>
<height>0</height>
</size>
</property>
<property name="maximumSize">
<size>
<width>150</width>
<height>16777215</height>
</size>
</property>
<item>
<property name="text">
<string>Instrument</string>
</property>
</item>
<item>
<property name="text">
<string>Fiducial</string>
</property>
</item>
<item>
<property name="text">
<string>Skinmarker</string>
</property>
</item>
<item>
<property name="text">
<string>Unkown</string>
</property>
</item>
</widget>
</item>
</layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_5">
<item>
<widget class="QLabel" name="label_4">
<property name="minimumSize">
<size>
<width>100</width>
<height>0</height>
</size>
</property>
<property name="text">
<string>Identifier:</string>
</property>
</widget>
</item>
<item>
<widget class="QLineEdit" name="m_IdentifierEdit">
<property name="text">
<string><not given></string>
</property>
</widget>
</item>
</layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_8">
<item>
<widget class="QLabel" name="label_5">
<property name="minimumSize">
<size>
<width>100</width>
<height>0</height>
</size>
</property>
<property name="text">
<string>Serial Number:</string>
</property>
</widget>
</item>
<item>
<widget class="QLineEdit" name="m_SerialNumberEdit">
<property name="text">
<string><not given></string>
</property>
</widget>
</item>
</layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_3">
<item>
<widget class="QLabel" name="label_2">
<property name="text">
<string>Tooltip:</string>
</property>
</widget>
</item>
<item>
<spacer name="horizontalSpacer_2">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QPushButton" name="m_ShowAdvancedOptionsPB">
<property name="text">
<string>Edit Tooltip</string>
</property>
<property name="checkable">
<bool>true</bool>
</property>
</widget>
</item>
</layout>
</item>
<item>
<spacer name="verticalSpacer">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
+ <item>
+ <layout class="QHBoxLayout" name="horizontalLayout_10">
+ <item>
+ <widget class="QLabel" name="label_6">
+ <property name="text">
+ <string>Tool Axis:</string>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <spacer name="horizontalSpacer_5">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>40</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ <item>
+ <widget class="QSpinBox" name="m_ToolAxisX">
+ <property name="correctionMode">
+ <enum>QAbstractSpinBox::CorrectToPreviousValue</enum>
+ </property>
+ <property name="minimum">
+ <number>-9999</number>
+ </property>
+ <property name="maximum">
+ <number>9999</number>
+ </property>
+ <property name="value">
+ <number>1</number>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QSpinBox" name="m_ToolAxisY">
+ <property name="minimum">
+ <number>-9999</number>
+ </property>
+ <property name="maximum">
+ <number>9999</number>
+ </property>
+ </widget>
+ </item>
+ <item>
+ <widget class="QSpinBox" name="m_ToolAxisZ">
+ <property name="minimum">
+ <number>-9999</number>
+ </property>
+ <property name="maximum">
+ <number>9999</number>
+ </property>
+ </widget>
+ </item>
+ </layout>
+ </item>
</layout>
</widget>
</widget>
</item>
<item>
<widget class="Line" name="line">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
</widget>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_7">
<item>
<spacer name="horizontalSpacer">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QPushButton" name="m_cancel">
<property name="text">
<string>Cancel</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="m_finished">
<property name="text">
<string>Finished</string>
</property>
</widget>
</item>
</layout>
</item>
</layout>
</widget>
<customwidgets>
<customwidget>
<class>QmitkDataStorageComboBox</class>
<extends>QComboBox</extends>
<header>QmitkDataStorageComboBox.h</header>
<container>1</container>
</customwidget>
<customwidget>
<class>QmitkPointListWidget</class>
<extends>QWidget</extends>
<header>QmitkPointListWidget.h</header>
<container>1</container>
</customwidget>
</customwidgets>
<resources/>
<connections/>
</ui>
diff --git a/Modules/IGTUI/Qmitk/QmitkNavigationToolManagementWidget.cpp b/Modules/IGTUI/Qmitk/QmitkNavigationToolManagementWidget.cpp
index 2f78379f4a..acdeae0ceb 100644
--- a/Modules/IGTUI/Qmitk/QmitkNavigationToolManagementWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkNavigationToolManagementWidget.cpp
@@ -1,396 +1,419 @@
/*===================================================================
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 "QmitkNavigationToolManagementWidget.h"
//mitk headers
#include "mitkTrackingTypes.h"
#include <mitkSurface.h>
#include <mitkNavigationToolReader.h>
#include <mitkNavigationToolWriter.h>
#include <mitkNavigationToolStorage.h>
#include <mitkNavigationToolStorageDeserializer.h>
#include <mitkNavigationToolStorageSerializer.h>
+#include <QmitkIGTCommonHelper.h>
//qt headers
#include <qfiledialog.h>
#include <qinputdialog.h>
#include <qmessagebox.h>
+#include <qsettings.h>
//poco headers
#include <Poco/Path.h>
const std::string QmitkNavigationToolManagementWidget::VIEW_ID = "org.mitk.views.navigationtoolmanagementwidget";
QmitkNavigationToolManagementWidget::QmitkNavigationToolManagementWidget(QWidget* parent, Qt::WindowFlags f)
: QWidget(parent, f)
{
m_Controls = nullptr;
CreateQtPartControl(this);
CreateConnections();
}
QmitkNavigationToolManagementWidget::~QmitkNavigationToolManagementWidget()
{
}
void QmitkNavigationToolManagementWidget::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkNavigationToolManagementWidgetControls;
m_Controls->setupUi(parent);
}
//Disable StorageControls in the beginning, because there is no storage to edit
DisableStorageControls();
}
void QmitkNavigationToolManagementWidget::OnLoadTool()
{
if (m_NavigationToolStorage->isLocked())
{
MessageBox("Storage is locked, cannot modify it. Maybe the tracking device which uses this storage is connected. If you want to modify the storage please disconnect the device first.");
return;
}
mitk::NavigationToolReader::Pointer myReader = mitk::NavigationToolReader::New();
- std::string filename = QFileDialog::getOpenFileName(nullptr, tr("Add Navigation Tool"), "/", "*.IGTTool").toLatin1().data();
+ std::string filename = QFileDialog::getOpenFileName(nullptr,tr("Add Navigation Tool"), QmitkIGTCommonHelper::GetLastFileLoadPath(), "*.IGTTool").toLatin1().data();
+ QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(QString::fromStdString(filename));
if (filename == "") return;
mitk::NavigationTool::Pointer readTool = myReader->DoRead(filename);
if (readTool.IsNull()) MessageBox("Error: " + myReader->GetErrorMessage());
else
{
if (!m_NavigationToolStorage->AddTool(readTool))
{
MessageBox("Error: Can't add tool!");
m_DataStorage->Remove(readTool->GetDataNode());
}
UpdateToolTable();
m_NavigationToolStorage->UpdateMicroservice();
}
}
void QmitkNavigationToolManagementWidget::OnSaveTool()
{
//if no item is selected, show error message:
if (m_Controls->m_ToolList->currentItem() == nullptr) { MessageBox("Error: Please select tool first!"); return; }
- mitk::NavigationToolWriter::Pointer myWriter = mitk::NavigationToolWriter::New();
- std::string filename = QFileDialog::getSaveFileName(nullptr, tr("Save Navigation Tool"), "/", "*.IGTTool").toLatin1().data();
- filename.append(".IGTTool");
- if (filename == "") return;
- if (!myWriter->DoWrite(filename, m_NavigationToolStorage->GetTool(m_Controls->m_ToolList->currentIndex().row())))
- MessageBox("Error: " + myWriter->GetErrorMessage());
+ mitk::NavigationToolWriter::Pointer myWriter = mitk::NavigationToolWriter::New();
+ std::string filename = QFileDialog::getSaveFileName(nullptr,tr("Save Navigation Tool"), QmitkIGTCommonHelper::GetLastFileSavePath(), "*.IGTTool").toLatin1().data();
+ QmitkIGTCommonHelper::SetLastFileSavePathByFileName(QString::fromStdString(filename));
+ if (filename == "") return;
+ std::string fileExt = Poco::Path(filename).getExtension();
+ if (fileExt == "") { filename.append(".IGTTool"); }
+ if (!myWriter->DoWrite(filename,m_NavigationToolStorage->GetTool(m_Controls->m_ToolList->currentIndex().row())))
+ MessageBox("Error: "+ myWriter->GetErrorMessage());
}
void QmitkNavigationToolManagementWidget::CreateConnections()
{
if (m_Controls)
{
//main widget page:
connect((QObject*)(m_Controls->m_AddTool), SIGNAL(clicked()), this, SLOT(OnAddTool()));
connect((QObject*)(m_Controls->m_DeleteTool), SIGNAL(clicked()), this, SLOT(OnDeleteTool()));
connect((QObject*)(m_Controls->m_EditTool), SIGNAL(clicked()), this, SLOT(OnEditTool()));
connect((QObject*)(m_Controls->m_MoveToolUp), SIGNAL(clicked()), this, SLOT(OnMoveToolUp()));
connect((QObject*)(m_Controls->m_MoveToolDown), SIGNAL(clicked()), this, SLOT(OnMoveToolDown()));
connect((QObject*)(m_Controls->m_LoadStorage), SIGNAL(clicked()), this, SLOT(OnLoadStorage()));
connect((QObject*)(m_Controls->m_SaveStorage), SIGNAL(clicked()), this, SLOT(OnSaveStorage()));
connect((QObject*)(m_Controls->m_LoadTool), SIGNAL(clicked()), this, SLOT(OnLoadTool()));
connect((QObject*)(m_Controls->m_SaveTool), SIGNAL(clicked()), this, SLOT(OnSaveTool()));
connect((QObject*)(m_Controls->m_CreateNewStorage), SIGNAL(clicked()), this, SLOT(OnCreateStorage()));
//widget page "add tool":
connect((QObject*)(m_Controls->m_ToolCreationWidget), SIGNAL(Canceled()), this, SLOT(OnAddToolCancel()));
connect((QObject*)(m_Controls->m_ToolCreationWidget), SIGNAL(NavigationToolFinished()), this, SLOT(OnAddToolSave()));
}
}
void QmitkNavigationToolManagementWidget::Initialize(mitk::DataStorage* dataStorage)
{
m_DataStorage = dataStorage;
m_Controls->m_ToolCreationWidget->Initialize(m_DataStorage, "Tool0");
}
void QmitkNavigationToolManagementWidget::LoadStorage(mitk::NavigationToolStorage::Pointer storageToLoad)
{
if (storageToLoad.IsNotNull())
{
m_NavigationToolStorage = storageToLoad;
m_Controls->m_StorageName->setText(m_NavigationToolStorage->GetName().c_str());
EnableStorageControls();
}
else
{
m_NavigationToolStorage = nullptr;
DisableStorageControls();
}
UpdateToolTable();
m_NavigationToolStorage->UpdateMicroservice();
}
//##################################################################################
//############################## slots: main widget ################################
//##################################################################################
void QmitkNavigationToolManagementWidget::OnMoveToolUp()
{
if (m_NavigationToolStorage.IsNotNull())
{
int toolIndex = m_Controls->m_ToolList->currentIndex().row();
if (toolIndex >= 0)
{
mitk::NavigationTool::Pointer currentNavigationTool = m_NavigationToolStorage->GetTool(toolIndex);
if (currentNavigationTool.IsNotNull())
{
std::string currentIdentifier = currentNavigationTool->GetIdentifier();
int NewNumber = m_Controls->m_ToolList->currentIndex().row() - 1;
if (NewNumber < 0) { MITK_WARN << "Cannot move tool up because it is on the top!"; }
else { m_NavigationToolStorage->AssignToolNumber(currentIdentifier, NewNumber); }
UpdateToolTable();
m_NavigationToolStorage->UpdateMicroservice();
}
}
}
}
void QmitkNavigationToolManagementWidget::OnMoveToolDown()
{
if (m_NavigationToolStorage.IsNotNull())
{
int toolIndex = m_Controls->m_ToolList->currentIndex().row();
if (toolIndex >= 0)
{
mitk::NavigationTool::Pointer currentNavigationTool = m_NavigationToolStorage->GetTool(toolIndex);
if (currentNavigationTool.IsNotNull())
{
std::string currentIdentifier = currentNavigationTool->GetIdentifier();
int NewNumber = m_Controls->m_ToolList->currentIndex().row() + 1;
if (NewNumber >= m_NavigationToolStorage->GetToolCount()) { MITK_WARN << "Cannot move tool down because it is the last tool in this storage!"; }
else { m_NavigationToolStorage->AssignToolNumber(currentIdentifier, NewNumber); }
UpdateToolTable();
m_NavigationToolStorage->UpdateMicroservice();
}
}
}
}
void QmitkNavigationToolManagementWidget::OnAddTool()
{
if (m_NavigationToolStorage->isLocked())
{
MessageBox("Storage is locked, cannot modify it. Maybe the tracking device which uses this storage is connected. If you want to modify the storage please disconnect the device first.");
return;
}
QString defaultIdentifier = "NavigationTool#" + QString::number(m_NavigationToolStorage->GetToolCount());
QString defaultName = "NavigationTool" + QString::number(m_NavigationToolStorage->GetToolCount());
m_Controls->m_ToolCreationWidget->Initialize(m_DataStorage, defaultIdentifier.toStdString(), defaultName.toStdString());
m_edit = false;
m_Controls->m_MainWidgets->setCurrentIndex(1);
m_NavigationToolStorage->UpdateMicroservice();
}
void QmitkNavigationToolManagementWidget::OnDeleteTool()
{
//first: some checks
if (m_NavigationToolStorage->isLocked())
{
MessageBox("Storage is locked, cannot modify it. Maybe the tracking device which uses this storage is connected. If you want to modify the storage please disconnect the device first.");
return;
}
else if (m_Controls->m_ToolList->currentItem() == nullptr) //if no item is selected, show error message:
{
MessageBox("Error: Please select tool first!");
return;
}
m_DataStorage->Remove(m_NavigationToolStorage->GetTool(m_Controls->m_ToolList->currentIndex().row())->GetDataNode());
m_NavigationToolStorage->DeleteTool(m_Controls->m_ToolList->currentIndex().row());
UpdateToolTable();
m_NavigationToolStorage->UpdateMicroservice();
}
void QmitkNavigationToolManagementWidget::OnEditTool()
{
if (m_NavigationToolStorage->isLocked())
{
MessageBox("Storage is locked, cannot modify it. Maybe the tracking device which uses this storage is connected. If you want to modify the storage please disconnect the device first.");
return;
}
else if (m_Controls->m_ToolList->currentItem() == nullptr) //if no item is selected, show error message:
{
MessageBox("Error: Please select tool first!");
return;
}
mitk::NavigationTool::Pointer selectedTool = m_NavigationToolStorage->GetTool(m_Controls->m_ToolList->currentIndex().row());
m_Controls->m_ToolCreationWidget->SetDefaultData(selectedTool);
m_NavigationToolStorage->SetName("test");
m_edit = true;
m_Controls->m_MainWidgets->setCurrentIndex(1);
m_NavigationToolStorage->UpdateMicroservice();
}
void QmitkNavigationToolManagementWidget::OnCreateStorage()
{
QString storageName = QInputDialog::getText(nullptr, "Storage Name", "Name of the new tool storage:");
if (storageName.isNull()) return;
m_NavigationToolStorage = mitk::NavigationToolStorage::New(this->m_DataStorage);
m_NavigationToolStorage->SetName(storageName.toStdString());
m_Controls->m_StorageName->setText(m_NavigationToolStorage->GetName().c_str());
EnableStorageControls();
emit NewStorageAdded(m_NavigationToolStorage, storageName.toStdString());
}
void QmitkNavigationToolManagementWidget::OnLoadStorage()
{
mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(m_DataStorage);
std::string filename = QFileDialog::getOpenFileName(nullptr, tr("Open Navigation Tool Storage"), "/", tr("IGT Tool Storage (*.IGTToolStorage)")).toStdString();
if (filename == "") return;
try
{
- mitk::NavigationToolStorage::Pointer tempStorage = myDeserializer->Deserialize(filename);
+ mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(m_DataStorage);
+ std::string filename = QFileDialog::getOpenFileName(NULL, tr("Open Navigation Tool Storage"), QmitkIGTCommonHelper::GetLastFileLoadPath(), tr("IGT Tool Storage (*.IGTToolStorage)")).toStdString();
+ if (filename == "") return;
+
+ QmitkIGTCommonHelper::SetLastFileLoadPathByFileName(QString::fromStdString(filename));
- if (tempStorage.IsNull()) MessageBox("Error" + myDeserializer->GetErrorMessage());
- else
+ try
+ {
+ mitk::NavigationToolStorage::Pointer tempStorage = myDeserializer->Deserialize(filename);
+
+ if (tempStorage.IsNull()) MessageBox("Error" + myDeserializer->GetErrorMessage());
+ else
+ {
+ Poco::Path myPath = Poco::Path(filename.c_str());
+ tempStorage->SetName(myPath.getFileName()); //set the filename as name for the storage, so the user can identify it
+ this->LoadStorage(tempStorage);
+ emit NewStorageAdded(m_NavigationToolStorage,myPath.getFileName());
+ m_NavigationToolStorage->UpdateMicroservice();
+ }
+ }
+ catch (const mitk::Exception& exception)
{
- Poco::Path myPath = Poco::Path(filename.c_str());
- tempStorage->SetName(myPath.getFileName()); //set the filename as name for the storage, so the user can identify it
- this->LoadStorage(tempStorage);
- emit NewStorageAdded(m_NavigationToolStorage, myPath.getFileName());
+ MessageBox(exception.GetDescription());
}
}
catch (const mitk::Exception& exception)
{
MessageBox(exception.GetDescription());
}
m_NavigationToolStorage->UpdateMicroservice();
}
void QmitkNavigationToolManagementWidget::OnSaveStorage()
-{
- //read in filename
- QString filename = QFileDialog::getSaveFileName(nullptr, tr("Save Navigation Tool Storage"), "/", tr("IGT Tool Storage (*.IGTToolStorage)"));
- if (filename.isEmpty()) return; //canceled by the user
+ {
+ QFileDialog *fileDialog = new QFileDialog;
+ fileDialog->setDefaultSuffix("IGTToolStorage");
+ QString suffix = "IGT Tool Storage (*.IGTToolStorage)";
+ QString filename = fileDialog->getSaveFileName(nullptr, tr("Save Navigation Tool Storage"), QmitkIGTCommonHelper::GetLastFileSavePath(), suffix, &suffix);
- // add file extension if it wasn't added by the file dialog
- if (filename.right(15) != ".IGTToolStorage") { filename += ".IGTToolStorage"; }
+ if (filename.isEmpty()) return; //canceled by the user
+ // check file suffix
+ QFileInfo file(filename);
+ if(file.suffix().isEmpty()) filename += ".IGTToolStorage";
//serialize tool storage
mitk::NavigationToolStorageSerializer::Pointer mySerializer = mitk::NavigationToolStorageSerializer::New();
if (!mySerializer->Serialize(filename.toStdString(), m_NavigationToolStorage))
{
MessageBox("Error: " + mySerializer->GetErrorMessage());
return;
+ QmitkIGTCommonHelper::SetLastFileSavePath(file.absolutePath());
}
Poco::Path myPath = Poco::Path(filename.toStdString());
m_Controls->m_StorageName->setText(QString::fromStdString(myPath.getFileName()));
}
//##################################################################################
//############################## slots: add tool widget ############################
//##################################################################################
void QmitkNavigationToolManagementWidget::OnAddToolSave()
{
mitk::NavigationTool::Pointer newTool = m_Controls->m_ToolCreationWidget->GetCreatedTool();
if (m_edit) //here we edit a existing tool
{
mitk::NavigationTool::Pointer editedTool = m_NavigationToolStorage->GetTool(m_Controls->m_ToolList->currentIndex().row());
editedTool->Graft(newTool);
}
else //here we create a new tool
{
m_NavigationToolStorage->AddTool(newTool);
}
UpdateToolTable();
m_Controls->m_MainWidgets->setCurrentIndex(0);
m_NavigationToolStorage->UpdateMicroservice();
}
void QmitkNavigationToolManagementWidget::OnAddToolCancel()
{
m_Controls->m_MainWidgets->setCurrentIndex(0);
}
//##################################################################################
//############################## private help methods ##############################
//##################################################################################
void QmitkNavigationToolManagementWidget::UpdateToolTable()
{
m_Controls->m_ToolList->clear();
if (m_NavigationToolStorage.IsNull()) return;
for (int i = 0; i < m_NavigationToolStorage->GetToolCount(); i++)
{
QString currentTool = "Tool" + QString::number(i) + ": " + QString(m_NavigationToolStorage->GetTool(i)->GetDataNode()->GetName().c_str()) + " ";
currentTool += "(" + QString::fromStdString(m_NavigationToolStorage->GetTool(i)->GetTrackingDeviceType()) + "/";
switch (m_NavigationToolStorage->GetTool(i)->GetType())
{
case mitk::NavigationTool::Instrument:
currentTool += "Instrument)"; break;
case mitk::NavigationTool::Fiducial:
currentTool += "Fiducial)"; break;
case mitk::NavigationTool::Skinmarker:
currentTool += "Skinmarker)"; break;
default:
currentTool += "Unknown)";
}
m_Controls->m_ToolList->addItem(currentTool);
}
}
void QmitkNavigationToolManagementWidget::MessageBox(std::string s)
{
QMessageBox msgBox;
msgBox.setText(s.c_str());
msgBox.exec();
}
void QmitkNavigationToolManagementWidget::DisableStorageControls()
{
m_Controls->m_StorageName->setText("<none>");
m_Controls->m_AddTool->setEnabled(false);
m_Controls->m_LoadTool->setEnabled(false);
m_Controls->m_MoveToolUp->setEnabled(false);
m_Controls->m_MoveToolDown->setEnabled(false);
m_Controls->m_selectedLabel->setEnabled(false);
m_Controls->m_DeleteTool->setEnabled(false);
m_Controls->m_EditTool->setEnabled(false);
m_Controls->m_SaveTool->setEnabled(false);
m_Controls->m_ToolList->setEnabled(false);
m_Controls->m_SaveStorage->setEnabled(false);
m_Controls->m_ToolLabel->setEnabled(false);
}
void QmitkNavigationToolManagementWidget::EnableStorageControls()
{
m_Controls->m_AddTool->setEnabled(true);
m_Controls->m_LoadTool->setEnabled(true);
m_Controls->m_MoveToolUp->setEnabled(true);
m_Controls->m_MoveToolDown->setEnabled(true);
m_Controls->m_selectedLabel->setEnabled(true);
m_Controls->m_DeleteTool->setEnabled(true);
m_Controls->m_EditTool->setEnabled(true);
m_Controls->m_SaveTool->setEnabled(true);
m_Controls->m_ToolList->setEnabled(true);
m_Controls->m_SaveStorage->setEnabled(true);
m_Controls->m_ToolLabel->setEnabled(true);
}
diff --git a/Modules/IGTUI/files.cmake b/Modules/IGTUI/files.cmake
index 9678e39cb4..df2e5e6088 100644
--- a/Modules/IGTUI/files.cmake
+++ b/Modules/IGTUI/files.cmake
@@ -1,114 +1,116 @@
set(CPP_FILES
Qmitk/QmitkTrackingDeviceWidget.cpp
Qmitk/QmitkTrackingDeviceConfigurationWidget.cpp
Qmitk/QmitkNDIConfigurationWidget.cpp
Qmitk/QmitkFiducialRegistrationWidget.cpp
Qmitk/QmitkNDIToolDelegate.cpp
Qmitk/QmitkNavigationToolManagementWidget.cpp
Qmitk/QmitkIGTLoggerWidget.cpp
Qmitk/QmitkUpdateTimerWidget.cpp
Qmitk/QmitkToolDistanceWidget.cpp
Qmitk/QmitkToolTrackingStatusWidget.cpp
Qmitk/QmitkTrackingSourcesCheckBoxPanelWidget.cpp
Qmitk/QmitkIGTPlayerWidget.cpp
Qmitk/QmitkIGTConnectionWidget.cpp
Qmitk/QmitkToolSelectionWidget.cpp
Qmitk/QmitkNavigationToolCreationWidget.cpp
Qmitk/QmitkNavigationToolCreationAdvancedWidget.cpp
Qmitk/QmitkNavigationDataSourceSelectionWidget.cpp
Qmitk/QmitkInteractiveTransformationWidget.cpp
Qmitk/QmitkNavigationToolStorageSelectionWidget.cpp
Qmitk/QmitkNavigationDataPlayerControlWidget.cpp
Qmitk/QmitkNavigationDataSequentialPlayerControlWidget.cpp
Qmitk/QmitkNDIAuroraWidget.cpp
Qmitk/QmitkNDIPolarisWidget.cpp
Qmitk/QmitkMicronTrackerWidget.cpp
Qmitk/QmitkNPOptitrackWidget.cpp
Qmitk/QmitkVirtualTrackerWidget.cpp
Qmitk/QmitkOpenIGTLinkWidget.cpp
Qmitk/mitkTrackingDeviceWidgetCollection.cpp
Qmitk/QmitkTrackingDeviceConfigurationWidgetScanPortsWorker.cpp
Qmitk/QmitkTrackingDeviceConfigurationWidgetConnectionWorker.cpp
Qmitk/QmitkNDIAbstractDeviceWidget.cpp
Qmitk/QmitkAbstractTrackingDeviceWidget.cpp
+ Qmitk/QmitkIGTCommonHelper.cpp
)
set(UI_FILES
Qmitk/QmitkNavigationToolManagementWidgetControls.ui
Qmitk/QmitkTrackingDeviceConfigurationWidgetControls.ui
Qmitk/QmitkNDIConfigurationWidget.ui
Qmitk/QmitkFiducialRegistrationWidget.ui
Qmitk/QmitkIGTLoggerWidgetControls.ui
Qmitk/QmitkUpdateTimerWidgetControls.ui
Qmitk/QmitkToolDistanceWidgetControls.ui
Qmitk/QmitkToolTrackingStatusWidgetControls.ui
Qmitk/QmitkTrackingSourcesCheckBoxPanelWidgetControls.ui
Qmitk/QmitkIGTPlayerWidgetControls.ui
Qmitk/QmitkIGTConnectionWidgetControls.ui
Qmitk/QmitkToolSelectionWidgetControls.ui
Qmitk/QmitkNavigationToolCreationWidget.ui
Qmitk/QmitkNavigationToolCreationAdvancedWidgetControls.ui
Qmitk/QmitkNavigationDataSourceSelectionWidgetControls.ui
Qmitk/QmitkInteractiveTransformationWidgetControls.ui
Qmitk/QmitkNavigationToolStorageSelectionWidgetControls.ui
Qmitk/QmitkNavigationDataPlayerControlWidget.ui
Qmitk/QmitkNavigationDataSequentialPlayerControlWidget.ui
Qmitk/QmitkNDIAuroraWidget.ui
Qmitk/QmitkNDIPolarisWidget.ui
Qmitk/QmitkMicronTrackerWidget.ui
Qmitk/QmitkNPOptitrackWidget.ui
Qmitk/QmitkVirtualTrackerWidget.ui
Qmitk/QmitkOpenIGTLinkWidget.ui
)
set(MOC_H_FILES
Qmitk/QmitkNavigationToolManagementWidget.h
Qmitk/QmitkTrackingDeviceWidget.h
Qmitk/QmitkTrackingDeviceConfigurationWidget.h
Qmitk/QmitkNDIConfigurationWidget.h
Qmitk/QmitkFiducialRegistrationWidget.h
Qmitk/QmitkNDIToolDelegate.h
Qmitk/QmitkIGTLoggerWidget.h
Qmitk/QmitkUpdateTimerWidget.h
Qmitk/QmitkToolDistanceWidget.h
Qmitk/QmitkToolTrackingStatusWidget.h
Qmitk/QmitkTrackingSourcesCheckBoxPanelWidget.h
Qmitk/QmitkIGTPlayerWidget.h
Qmitk/QmitkIGTConnectionWidget.h
Qmitk/QmitkToolSelectionWidget.h
Qmitk/QmitkNavigationToolCreationWidget.h
Qmitk/QmitkNavigationToolCreationAdvancedWidget.h
Qmitk/QmitkNavigationDataSourceSelectionWidget.h
Qmitk/QmitkInteractiveTransformationWidget.h
Qmitk/QmitkNavigationToolStorageSelectionWidget.h
Qmitk/QmitkNavigationDataPlayerControlWidget.h
Qmitk/QmitkNavigationDataSequentialPlayerControlWidget.h
Qmitk/QmitkNDIAuroraWidget.h
Qmitk/QmitkNDIPolarisWidget.h
Qmitk/QmitkMicronTrackerWidget.h
Qmitk/QmitkNPOptitrackWidget.h
Qmitk/QmitkVirtualTrackerWidget.h
Qmitk/QmitkOpenIGTLinkWidget.h
Qmitk/QmitkTrackingDeviceConfigurationWidgetScanPortsWorker.h
Qmitk/QmitkTrackingDeviceConfigurationWidgetConnectionWorker.h
Qmitk/QmitkNDIAbstractDeviceWidget.h
Qmitk/QmitkAbstractTrackingDeviceWidget.h
+ Qmitk/QmitkIGTCommonHelper.h
)
if(MITK_USE_POLHEMUS_TRACKER)
set(CPP_FILES ${CPP_FILES} Qmitk/QmitkPolhemusTrackerWidget.cpp)
set(UI_FILES ${UI_FILES} Qmitk/QmitkPolhemusTrackerWidget.ui)
set(MOC_H_FILES ${MOC_H_FILES} Qmitk/QmitkPolhemusTrackerWidget.h)
endif(MITK_USE_POLHEMUS_TRACKER)
set(QRC_FILES
resources/IGTUI.qrc
)
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 ef30992896..e9a7426e10 100644
--- a/Modules/OpenIGTLink/Filters/mitkImageToIGTLMessageFilter.cpp
+++ b/Modules/OpenIGTLink/Filters/mitkImageToIGTLMessageFilter.cpp
@@ -1,259 +1,262 @@
/*===================================================================
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;
}
+ //copy timestamp of mitk image
+ igtl::TimeStamp::Pointer timestamp = igtl::TimeStamp::New();
+ timestamp->SetTime(img->GetMTime() / 1000, (int)(img->GetMTime()) % 1000);
+ imgMsg->SetTimeStamp(timestamp);
+
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 nullptr;
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 nullptr;
}
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) == nullptr)
{
this->SetNthOutput(idx, this->MakeOutput(idx));
}
this->Modified();
}
}
diff --git a/Modules/OpenIGTLink/Testing/mitkOpenIGTLinkClientServerTest.cpp b/Modules/OpenIGTLink/Testing/mitkOpenIGTLinkClientServerTest.cpp
index 75c190525c..d2238e53fb 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));
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));
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 ce7c9cc0be..9b2ec6b70c 100644
--- a/Modules/OpenIGTLink/mitkIGTLDevice.cpp
+++ b/Modules/OpenIGTLink/mitkIGTLDevice.cpp
@@ -1,562 +1,564 @@
/*===================================================================
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;
}
- // add the name of this device to the message
- msg->SetDeviceName(this->GetName().c_str());
+ igtl::MessageBase* sendMessage = msg->GetMessage();
// 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 nullptr 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));
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::EnableNoBufferingMode(bool enable)
+{
+ m_MessageQueue->EnableNoBufferingMode(enable);
+}
-void mitk::IGTLDevice::EnableInfiniteBufferingMode(
+void mitk::IGTLDevice::EnableNoBufferingMode(
mitk::IGTLMessageQueue::Pointer queue,
bool enable)
{
- queue->EnableInfiniteBuffering(enable);
+ queue->EnableNoBufferingMode(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 f337a304f2..15a499f6af 100644
--- a/Modules/OpenIGTLink/mitkIGTLDevice.h
+++ b/Modules/OpenIGTLink/mitkIGTLDevice.h
@@ -1,417 +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,
+ void EnableNoBufferingMode(mitk::IGTLMessageQueue::Pointer queue,
bool enable = true);
+ void EnableNoBufferingMode(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..5dd4b976c0 100644
--- a/Modules/OpenIGTLink/mitkIGTLMessage.cpp
+++ b/Modules/OpenIGTLink/mitkIGTLMessage.cpp
@@ -1,170 +1,181 @@
/*===================================================================
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), 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)
+mitk::IGTLMessage::IGTLMessage(igtl::MessageBase::Pointer message)
{
this->SetMessage(message);
- this->SetName(name);
+ this->SetName(message->GetDeviceName());
}
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);
+ m_Message->GetTimeStamp(&ts, &frac); //ts = seconds / frac = nanoseconds
+ this->SetName(m_Message->GetDeviceName());
+ double timestamp = ts * 1000.0 + frac;
+ this->SetIGTTimeStamp(timestamp);
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..4ad923f8a7 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);
+ mitkNewMacro1Param(Self, igtl::MessageBase::Pointer);
/**
- * \brief type that holds the time at which the data was recorded
+ * \brief type that holds the time at which the data was recorded in milliseconds
*/
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 = "");
+ IGTLMessage(igtl::MessageBase::Pointer message);
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 f7a76bf6fe..19500d89c2 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) == nullptr)
{
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 == nullptr )
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 nullptr;
}
-void mitk::IGTLMessageProvider::Send(const mitk::IGTLMessage* msg)
+void mitk::IGTLMessageProvider::Send(mitk::IGTLMessage::Pointer msg)
{
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..9b8a1a1e15 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)
+ if (this->m_BufferingType == IGTLMessageQueue::NoBuffering)
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)
+ if (this->m_BufferingType == IGTLMessageQueue::NoBuffering)
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)
+ if (this->m_BufferingType == IGTLMessageQueue::NoBuffering)
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)
+ if (this->m_BufferingType == IGTLMessageQueue::NoBuffering)
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)
+ if (this->m_BufferingType == IGTLMessageQueue::NoBuffering)
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)
+ if (this->m_BufferingType == IGTLMessageQueue::NoBuffering)
m_Image3dQueue.clear();
this->m_Image3dQueue.push_back(dynamic_cast<igtl::ImageMessage*>(msg.GetPointer()));
infolog << "IMAGE3D";
}
else
{
- if (this->m_BufferingType == IGTLMessageQueue::Infinit)
+ if (this->m_BufferingType == IGTLMessageQueue::NoBuffering)
m_Image2dQueue.clear();
this->m_Image2dQueue.push_back(dynamic_cast<igtl::ImageMessage*>(msg.GetPointer()));
infolog << "IMAGE2D";
}
}
else
{
- if (this->m_BufferingType == IGTLMessageQueue::Infinit)
+ if (this->m_BufferingType == IGTLMessageQueue::NoBuffering)
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)
+void mitk::IGTLMessageQueue::EnableNoBufferingMode(bool enable)
{
this->m_Mutex->Lock();
if (enable)
- this->m_BufferingType = IGTLMessageQueue::BufferingType::Infinit;
- else
this->m_BufferingType = IGTLMessageQueue::BufferingType::NoBuffering;
+ else
+ this->m_BufferingType = IGTLMessageQueue::BufferingType::Infinit;
this->m_Mutex->Unlock();
}
mitk::IGTLMessageQueue::IGTLMessageQueue()
{
this->m_Mutex = itk::FastMutexLock::New();
- this->m_BufferingType = IGTLMessageQueue::Infinit;
+ this->m_BufferingType = IGTLMessageQueue::NoBuffering;
}
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..82626d4aa4 100644
--- a/Modules/OpenIGTLink/mitkIGTLMessageQueue.h
+++ b/Modules/OpenIGTLink/mitkIGTLMessageQueue.h
@@ -1,144 +1,143 @@
/*===================================================================
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);
+ */
+ void EnableNoBufferingMode(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 071fa8637f..7fac13dfed 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 = nullptr;
this->m_IGTLDevice = nullptr;
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()) == nullptr )
{
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 = nullptr;
}
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/QmitkIGTLDeviceSetupConnectionWidget.cpp b/Modules/OpenIGTLinkUI/Qmitk/QmitkIGTLDeviceSetupConnectionWidget.cpp
index 561433fb83..7e4801aebc 100644
--- a/Modules/OpenIGTLinkUI/Qmitk/QmitkIGTLDeviceSetupConnectionWidget.cpp
+++ b/Modules/OpenIGTLinkUI/Qmitk/QmitkIGTLDeviceSetupConnectionWidget.cpp
@@ -1,410 +1,410 @@
/*===================================================================
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 "QmitkIGTLDeviceSetupConnectionWidget.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 QmitkIGTLDeviceSetupConnectionWidget::VIEW_ID =
"org.mitk.views.igtldevicesetupconnectionwidget";
QmitkIGTLDeviceSetupConnectionWidget::QmitkIGTLDeviceSetupConnectionWidget(
QWidget* parent, Qt::WindowFlags f)
: QWidget(parent, f), m_IsClient(false)
{
m_Controls = nullptr;
this->m_IGTLDevice = nullptr;
CreateQtPartControl(this);
m_NumSentFramesSinceLastUpdate = 0;
m_NumReceivedFramesSinceLastUpdate = 0;
}
QmitkIGTLDeviceSetupConnectionWidget::~QmitkIGTLDeviceSetupConnectionWidget()
{
this->RemoveObserver();
}
void QmitkIGTLDeviceSetupConnectionWidget::RemoveObserver()
{
if (this->m_IGTLDevice.IsNotNull())
{
this->m_IGTLDevice->RemoveObserver(m_MessageReceivedObserverTag);
this->m_IGTLDevice->RemoveObserver(m_MessageSentObserverTag);
this->m_IGTLDevice->RemoveObserver(m_CommandReceivedObserverTag);
this->m_IGTLDevice->RemoveObserver(m_LostConnectionObserverTag);
this->m_IGTLDevice->RemoveObserver(m_NewConnectionObserverTag);
this->m_IGTLDevice->RemoveObserver(m_StateModifiedObserverTag);
}
}
void QmitkIGTLDeviceSetupConnectionWidget::CreateQtPartControl(QWidget *parent)
{
if (!m_Controls)
{
// create GUI widgets
m_Controls = new Ui::QmitkIGTLDeviceSetupConnectionWidgetControls;
// setup GUI widgets
m_Controls->setupUi(parent);
}
// set the validator for the ip edit box (values must be between 0 and 255 and
// there are four of them, seperated with a point
QRegExpValidator *v = new QRegExpValidator(this);
QRegExp rx("((1{0,1}[0-9]{0,2}|2[0-4]{1,1}[0-9]{1,1}|25[0-5]{1,1})\\.){3,3}(1{0,1}[0-9]{0,2}|2[0-4]{1,1}[0-9]{1,1}|25[0-5]{1,1})");
v->setRegExp(rx);
m_Controls->editIP->setValidator(v);
// set the validator for the port edit box (values must be between 1 and 65535)
m_Controls->editPort->setValidator(new QIntValidator(1, 65535, this));
m_FPSCalculationTimer.start(1000);
//connect slots with signals
CreateConnections();
}
void QmitkIGTLDeviceSetupConnectionWidget::CreateConnections()
{
if (m_Controls)
{
// connect the widget items with the methods
connect(m_Controls->butConnect, SIGNAL(clicked()),
this, SLOT(OnConnect()));
connect(m_Controls->editPort, SIGNAL(editingFinished()),
this, SLOT(OnPortChanged()));
connect(m_Controls->editIP, SIGNAL(editingFinished()),
this, SLOT(OnHostnameChanged()));
connect(m_Controls->bufferInMsgCheckBox, SIGNAL(stateChanged(int)),
this, SLOT(OnBufferIncomingMessages(int)));
connect(m_Controls->bufferOutMsgCheckBox, SIGNAL(stateChanged(int)),
this, SLOT(OnBufferOutgoingMessages(int)));
connect(&m_FPSCalculationTimer, SIGNAL(timeout()),
this, SLOT(OnUpdateFPSLabel()));
}
//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 QmitkIGTLDeviceSetupConnectionWidget::OnDeviceStateChanged()
{
emit AdaptGUIToStateSignal();
}
void QmitkIGTLDeviceSetupConnectionWidget::AdaptGUIToState()
{
//check the validity of the device
if (this->m_IGTLDevice.IsNull())
{
return;
}
//check the state of the device
mitk::IGTLDevice::IGTLDeviceState state = this->m_IGTLDevice->GetState();
switch (state) {
case mitk::IGTLDevice::Setup:
if (!m_IsClient)
{
m_Controls->butConnect->setText("Go Online");
this->m_Controls->editIP->setEnabled(false);
}
else
{
m_Controls->butConnect->setText("Connect");
this->m_Controls->editIP->setEnabled(true);
}
this->m_Controls->editPort->setEnabled(true);
this->m_Controls->logIncomingMsg->setEnabled(false);
this->m_Controls->logOutgoingMsg->setEnabled(false);
this->m_Controls->bufferInMsgCheckBox->setEnabled(false);
this->m_Controls->bufferOutMsgCheckBox->setEnabled(false);
this->m_Controls->butConnect->setEnabled(true);
this->m_Controls->fpsInLabel->setEnabled(false);
this->m_Controls->fpsOutLabel->setEnabled(false);
this->m_Controls->fpsInDescrLabel->setEnabled(false);
this->m_Controls->fpsOutDescrLabel->setEnabled(false);
break;
case mitk::IGTLDevice::Ready:
if (m_IsClient)
{
this->m_Controls->butConnect->setText("Disconnect");
}
else
{
this->m_Controls->butConnect->setText("Go Offline");
}
this->m_Controls->editIP->setEnabled(false);
this->m_Controls->editPort->setEnabled(false);
this->m_Controls->logIncomingMsg->setEnabled(true);
this->m_Controls->logOutgoingMsg->setEnabled(true);
this->m_Controls->bufferInMsgCheckBox->setEnabled(true);
this->m_Controls->bufferOutMsgCheckBox->setEnabled(true);
this->m_Controls->butConnect->setEnabled(true);
this->m_Controls->fpsInLabel->setEnabled(true);
this->m_Controls->fpsOutLabel->setEnabled(true);
this->m_Controls->fpsInDescrLabel->setEnabled(true);
this->m_Controls->fpsOutDescrLabel->setEnabled(true);
break;
case mitk::IGTLDevice::Running:
if (m_IsClient)
{
this->m_Controls->butConnect->setText("Disconnect");
}
else
{
this->m_Controls->butConnect->setText("Go Offline");
}
this->m_Controls->editIP->setEnabled(false);
this->m_Controls->editPort->setEnabled(false);
this->m_Controls->logIncomingMsg->setEnabled(true);
this->m_Controls->logOutgoingMsg->setEnabled(true);
this->m_Controls->bufferInMsgCheckBox->setEnabled(true);
this->m_Controls->bufferOutMsgCheckBox->setEnabled(true);
this->m_Controls->butConnect->setEnabled(true);
this->m_Controls->fpsInLabel->setEnabled(true);
this->m_Controls->fpsOutLabel->setEnabled(true);
this->m_Controls->fpsInDescrLabel->setEnabled(true);
this->m_Controls->fpsOutDescrLabel->setEnabled(true);
break;
default:
mitkThrow() << "Invalid Device State";
break;
}
}
void QmitkIGTLDeviceSetupConnectionWidget::Initialize(
mitk::IGTLDevice::Pointer device)
{
//reset the GUI
DisableSourceControls();
//reset the observers
this->RemoveObserver();
if (device.IsNotNull())
{
this->m_IGTLDevice = device;
//check if the device is a server or a client
if (dynamic_cast<mitk::IGTLClient*>(
this->m_IGTLDevice.GetPointer()) == nullptr)
{
m_IsClient = false;
}
else
{
m_IsClient = true;
}
this->AdaptGUIToState();
typedef itk::SimpleMemberCommand< QmitkIGTLDeviceSetupConnectionWidget > CurCommandType;
CurCommandType::Pointer messageSentCommand = CurCommandType::New();
messageSentCommand->SetCallbackFunction(
this, &QmitkIGTLDeviceSetupConnectionWidget::OnMessageSent);
this->m_MessageSentObserverTag = this->m_IGTLDevice->AddObserver(
mitk::MessageSentEvent(), messageSentCommand);
CurCommandType::Pointer messageReceivedCommand = CurCommandType::New();
messageReceivedCommand->SetCallbackFunction(
this, &QmitkIGTLDeviceSetupConnectionWidget::OnMessageReceived);
this->m_MessageReceivedObserverTag = this->m_IGTLDevice->AddObserver(
mitk::MessageReceivedEvent(), messageReceivedCommand);
CurCommandType::Pointer commandReceivedCommand = CurCommandType::New();
commandReceivedCommand->SetCallbackFunction(
this, &QmitkIGTLDeviceSetupConnectionWidget::OnCommandReceived);
this->m_CommandReceivedObserverTag = this->m_IGTLDevice->AddObserver(
mitk::CommandReceivedEvent(), commandReceivedCommand);
CurCommandType::Pointer connectionLostCommand = CurCommandType::New();
connectionLostCommand->SetCallbackFunction(
this, &QmitkIGTLDeviceSetupConnectionWidget::OnLostConnection);
this->m_LostConnectionObserverTag = this->m_IGTLDevice->AddObserver(
mitk::LostConnectionEvent(), connectionLostCommand);
CurCommandType::Pointer newConnectionCommand = CurCommandType::New();
newConnectionCommand->SetCallbackFunction(
this, &QmitkIGTLDeviceSetupConnectionWidget::OnNewConnection);
this->m_NewConnectionObserverTag = this->m_IGTLDevice->AddObserver(
mitk::NewClientConnectionEvent(), newConnectionCommand);
CurCommandType::Pointer stateModifiedCommand = CurCommandType::New();
stateModifiedCommand->SetCallbackFunction(
this, &QmitkIGTLDeviceSetupConnectionWidget::OnDeviceStateChanged);
this->m_StateModifiedObserverTag = this->m_IGTLDevice->AddObserver(
itk::ModifiedEvent(), stateModifiedCommand);
OnBufferIncomingMessages(m_Controls->bufferInMsgCheckBox->isChecked());
OnBufferOutgoingMessages(m_Controls->bufferOutMsgCheckBox->isChecked());
}
else
{
m_IGTLDevice = nullptr;
}
}
void QmitkIGTLDeviceSetupConnectionWidget::DisableSourceControls()
{
m_Controls->editIP->setEnabled(false);
m_Controls->editPort->setEnabled(false);
m_Controls->butConnect->setEnabled(false);
m_Controls->bufferInMsgCheckBox->setEnabled(false);
m_Controls->bufferOutMsgCheckBox->setEnabled(false);
m_Controls->logIncomingMsg->setEnabled(false);
m_Controls->logOutgoingMsg->setEnabled(false);
}
void QmitkIGTLDeviceSetupConnectionWidget::OnConnect()
{
if (m_IGTLDevice->GetState() == mitk::IGTLDevice::Setup)
{
QString port = m_Controls->editPort->text();
m_IGTLDevice->SetPortNumber(port.toInt());
std::string hostname = m_Controls->editIP->text().toStdString();
m_IGTLDevice->SetHostname(hostname);
//connect with the other OpenIGTLink device => changes the state from Setup
//to Ready
if (m_IGTLDevice->OpenConnection())
{
//starts the communication thread => changes the state from Ready to
//Running
if (m_IGTLDevice->StartCommunication())
{
if (this->m_IsClient)
{
MITK_INFO("IGTLDeviceSourceManagementWidget")
<< "Successfully connected to " << hostname
<< " on port " << port.toStdString();
}
}
else
{
MITK_ERROR("QmitkIGTLDeviceSetupConnectionWidget") <<
"Could not start a communication with the"
"server because the client is in the wrong state";
}
}
else
{
MITK_ERROR("QmitkIGTLDeviceSetupConnectionWidget") <<
"Could not connect to the server. "
"Please check the hostname and port.";
}
}
else if (m_IGTLDevice->GetState() == mitk::IGTLDevice::Ready || m_IGTLDevice->GetState() == mitk::IGTLDevice::Running)
{
m_IGTLDevice->CloseConnection();
MITK_INFO("QmitkIGTLDeviceSetupConnectionWidget") << "Closed connection";
}
else
{
mitkThrow() << "Invalid state of IGTLDevice";
}
this->AdaptGUIToState();
}
void QmitkIGTLDeviceSetupConnectionWidget::OnPortChanged()
{
}
void QmitkIGTLDeviceSetupConnectionWidget::OnHostnameChanged()
{
}
void QmitkIGTLDeviceSetupConnectionWidget::OnLostConnection()
{
emit AdaptGUIToStateSignal();
}
void QmitkIGTLDeviceSetupConnectionWidget::OnNewConnection()
{
emit AdaptGUIToStateSignal();
}
void QmitkIGTLDeviceSetupConnectionWidget::OnMessageReceived()
{
if (this->m_Controls->logIncomingMsg->isChecked())
{
MITK_INFO("IGTLDeviceSetupConnectionWidget") << "Received a message: "
<< this->m_IGTLDevice->GetMessageQueue()->GetLatestMsgInformationString();
}
m_NumReceivedFramesSinceLastUpdate++;
}
void QmitkIGTLDeviceSetupConnectionWidget::OnMessageSent()
{
if (this->m_Controls->logOutgoingMsg->isChecked())
{
MITK_INFO("IGTLDeviceSetupConnectionWidget") << "Sent a message.";
}
m_NumSentFramesSinceLastUpdate++;
}
void QmitkIGTLDeviceSetupConnectionWidget::OnCommandReceived()
{
if (this->m_Controls->logIncomingMsg->isChecked())
{
MITK_INFO("IGTLDeviceSetupConnectionWidget") << "Received a command: "
<< this->m_IGTLDevice->GetMessageQueue()->GetLatestMsgInformationString();
}
}
void QmitkIGTLDeviceSetupConnectionWidget::OnBufferIncomingMessages(int state)
{
if (this->m_IGTLDevice.IsNotNull())
{
- this->m_IGTLDevice->EnableInfiniteBufferingMode(
+ this->m_IGTLDevice->EnableNoBufferingMode(
this->m_IGTLDevice->GetMessageQueue(), (bool)state);
}
}
void QmitkIGTLDeviceSetupConnectionWidget::OnBufferOutgoingMessages(int state)
{
if (this->m_IGTLDevice.IsNotNull())
{
- this->m_IGTLDevice->EnableInfiniteBufferingMode(
+ this->m_IGTLDevice->EnableNoBufferingMode(
this->m_IGTLDevice->GetMessageQueue(), (bool)state);
}
}
void QmitkIGTLDeviceSetupConnectionWidget::OnUpdateFPSLabel()
{
double fpsIn = m_NumReceivedFramesSinceLastUpdate / 1.0;
double fpsOut = m_NumSentFramesSinceLastUpdate / 1.0;
this->m_Controls->fpsInLabel->setText(QString::number(fpsIn));
this->m_Controls->fpsOutLabel->setText(QString::number(fpsOut));
m_NumReceivedFramesSinceLastUpdate = 0;
m_NumSentFramesSinceLastUpdate = 0;
}
diff --git a/Modules/OpenIGTLinkUI/Qmitk/QmitkIGTLDeviceSourceManagementWidget.cpp b/Modules/OpenIGTLinkUI/Qmitk/QmitkIGTLDeviceSourceManagementWidget.cpp
index 3f835d9fda..9979b38a2e 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 = nullptr;
this->m_IGTLDevice = nullptr;
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()) == nullptr )
{
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 = nullptr;
}
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));
}
void QmitkIGTLDeviceSourceManagementWidget::OnMessageReceived()
{
}
void QmitkIGTLDeviceSourceManagementWidget::OnCommandReceived()
{
}
void QmitkIGTLDeviceSourceManagementWidget::OnLostConnection()
{
emit AdaptGUIToStateSignal();
}
void QmitkIGTLDeviceSourceManagementWidget::OnNewConnection()
{
emit AdaptGUIToStateSignal();
}
diff --git a/Modules/US/USNavigation/Filter/mitkNeedleProjectionFilter.cpp b/Modules/US/USNavigation/Filter/mitkNeedleProjectionFilter.cpp
index a186f8e255..4b4065d024 100644
--- a/Modules/US/USNavigation/Filter/mitkNeedleProjectionFilter.cpp
+++ b/Modules/US/USNavigation/Filter/mitkNeedleProjectionFilter.cpp
@@ -1,150 +1,169 @@
/*===================================================================
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.
===================================================================*/
// MITK
#include "mitkNeedleProjectionFilter.h"
#include <mitkPlaneGeometry.h>
+#include "mitkUSCombinedModality.h"
// VTK
#include <vtkPlane.h>
+
mitk::NeedleProjectionFilter::NeedleProjectionFilter()
: m_Projection(mitk::PointSet::New()),
- m_OriginalPoints(mitk::PointSet::New()),
- m_SelectedInput(-1)
+ m_OriginalPoints(mitk::PointSet::New()),
+ m_SelectedInput(-1)
{
- // Tool Coordinates: First point - Tip of Needle, Second Point - 40 cm distance from needle
+ // Tool Coordinates:x axis is chosen as default axis when no axis is specified
for (int i = 0; i < 2; i++)
{
mitk::Point3D point;
- point.SetElement(0,0);
- point.SetElement(1,0);
- point.SetElement(2, i * 400);
+ point.SetElement(0, i * 400);
+ point.SetElement(1, 0);
+ point.SetElement(2, 0);
m_OriginalPoints->InsertPoint(i, point);
}
}
-mitk::NeedleProjectionFilter::~NeedleProjectionFilter()
+void mitk::NeedleProjectionFilter::SetToolAxisForFilter(mitk::Point3D point)
{
+ // Tool Coordinates: First point - Tip of Needle, Second Point - 40 cm distance from needle
+ mitk::Point3D originPoint;
+ originPoint.SetElement(0, 0);
+ originPoint.SetElement(1, 0);
+ originPoint.SetElement(2, 0);
+ m_OriginalPoints->SetPoint(0, originPoint);
+
+ mitk::Point3D endPoint;
+ endPoint.SetElement(0, point.GetElement(0) * 400);
+ endPoint.SetElement(1, point.GetElement(1) * 400);
+ endPoint.SetElement(2, point.GetElement(2) * 400);
+ MITK_INFO << "Tool axis in project filter:";
+ MITK_INFO << endPoint;
+ m_OriginalPoints->SetPoint(1, endPoint);
}
+mitk::NeedleProjectionFilter::~NeedleProjectionFilter()
+{
+}
void mitk::NeedleProjectionFilter::SelectInput(int i)
{
if (i < 0) mitkThrow() << "Negative Input selected in NeedleProjectionFilter";
if (! (static_cast<unsigned int>(i) < this->GetInputs().size())) mitkThrow() << "Selected input index is larger than actual number of inputs in NeedleProjectionFilter";
m_SelectedInput = i;
}
void mitk::NeedleProjectionFilter::GenerateData()
{
// copy the navigation data from the inputs to the outputs
mitk::NavigationDataPassThroughFilter::GenerateData();
// If no reference has been set yet, warn and abort
if (m_SelectedInput == -1)
{
MITK_INFO << "No input has been selected in NeedleProjection Filter. Only forwarding NavigationData...";
return;
}
// Cancel, if selected tool is currently not being tracked
if (! GetInput(m_SelectedInput)->IsDataValid()) return;
// Outputs have been updated, now to calculate the Projection
// 1) Generate Pseudo-Geometry for Input
mitk::AffineTransform3D::Pointer refTrans = this->NavigationDataToTransform(this->GetInput(m_SelectedInput));
mitk::Geometry3D::Pointer refGeom = this->TransformToGeometry(refTrans);
// 2) Transform Original Pointset
m_OriginalPoints->SetGeometry(refGeom);
// Update Projection (We do not clone, since we want to keep properties alive)
m_Projection->SetPoint(0, m_OriginalPoints->GetPoint(0));
m_Projection->SetPoint(1, m_OriginalPoints->GetPoint(1));
// 3a) If no target Plane has been set, then leave it at that
if (this->m_TargetPlane.IsNull())
return;
// 3b) else, calculate intersection with plane
mitk::PlaneGeometry::Pointer plane = mitk::PlaneGeometry::New();
plane->SetIndexToWorldTransform(m_TargetPlane);
//plane->TransferItkToVtkTransform(); //included in SetIndexToWorldTransform
double t;
double x[3];
// Points that define the needle vector
double p1[3] = {m_OriginalPoints->GetPoint(0)[0], m_OriginalPoints->GetPoint(0)[1], m_OriginalPoints->GetPoint(0)[2]};
double p2[3] = {m_OriginalPoints->GetPoint(1)[0], m_OriginalPoints->GetPoint(1)[1], m_OriginalPoints->GetPoint(1)[2]};
// Center of image plane and it's normal
double center[3] = {plane->GetCenter()[0], plane->GetCenter()[1], plane->GetCenter()[2]};
double normal[3] = {plane->GetNormal()[0], plane->GetNormal()[1], plane->GetNormal()[2]};
vtkPlane::IntersectWithLine(p1, p2, normal, center, t, x);
// change (cut) needle path only if the needle points to the image plane;
// otherwise the needle path direction would be changed pointing to the image plane
if ( t >= 0 )
{
// Convert vtk to itk
mitk::Point3D intersection;
intersection[0] = x[0];
intersection[1] = x[1];
intersection[2] = x[2];
// Replace distant point with image intersection
m_Projection->SetPoint(1, intersection);
}
}
mitk::AffineTransform3D::Pointer mitk::NeedleProjectionFilter::NavigationDataToTransform(const mitk::NavigationData * nd)
{
mitk::AffineTransform3D::Pointer affineTransform = mitk::AffineTransform3D::New();
affineTransform->SetIdentity();
//calculate the transform from the quaternions
static itk::QuaternionRigidTransform<double>::Pointer quatTransform = itk::QuaternionRigidTransform<double>::New();
mitk::NavigationData::OrientationType orientation = nd->GetOrientation();
// convert mitk::ScalarType quaternion to double quaternion because of itk bug
vnl_quaternion<double> doubleQuaternion(orientation.x(), orientation.y(), orientation.z(), orientation.r());
quatTransform->SetIdentity();
quatTransform->SetRotation(doubleQuaternion);
quatTransform->Modified();
/* because of an itk bug, the transform can not be calculated with float data type.
To use it in the mitk geometry classes, it has to be transfered to mitk::ScalarType which is float */
static AffineTransform3D::MatrixType m;
mitk::TransferMatrix(quatTransform->GetMatrix(), m);
affineTransform->SetMatrix(m);
/*set the offset by convert from itkPoint to itkVector and setting offset of transform*/
mitk::Vector3D pos;
pos.SetVnlVector(nd->GetPosition().GetVnlVector());
affineTransform->SetOffset(pos);
affineTransform->Modified();
return affineTransform;
}
mitk::Geometry3D::Pointer mitk::NeedleProjectionFilter::TransformToGeometry(mitk::AffineTransform3D::Pointer transform){
mitk::Geometry3D::Pointer g3d = mitk::Geometry3D::New();
mitk::ScalarType scale[] = {1.0, 1.0, 1.0};
g3d->SetSpacing(scale);
g3d->SetIndexToWorldTransform(transform);
//g3d->TransferItkToVtkTransform(); // update VTK Transform for rendering too //included in SetIndexToWorldTransform
g3d->Modified();
return g3d;
}
diff --git a/Modules/US/USNavigation/Filter/mitkNeedleProjectionFilter.h b/Modules/US/USNavigation/Filter/mitkNeedleProjectionFilter.h
index aa6be02285..1b03ffd6ea 100644
--- a/Modules/US/USNavigation/Filter/mitkNeedleProjectionFilter.h
+++ b/Modules/US/USNavigation/Filter/mitkNeedleProjectionFilter.h
@@ -1,85 +1,86 @@
/*===================================================================
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 NEEDLEPROJECTIONFILTER_H_INCLUDED
#define NEEDLEPROJECTIONFILTER_H_INCLUDED
#include <MitkUSNavigationExports.h>
// MITK
#include <mitkNavigationDataPassThroughFilter.h>
#include <mitkNavigationData.h>
#include <mitkPointSet.h>
#include <mitkGeometry3D.h>
namespace mitk {
/**
* \brief This filter projects a needle's path onto a plane.
*
* To use it, hook it up to a NavigationDataStream,
* select an input and set an AffineTransform 3D that represents the target plane.
* You can then call GetProjection to retrieve a pointset that represents the projected path.
* You may change the PointSet's properties, these changes will not be overwritten.
* If no Input is selected, the target Pointset will not update
* If no Target Plane is selected, The projection line will always be 40 cm long
* Any points you add to the pointSet will be overwritten during the next Update.
* The point with index zero is the Tip of the Needle.
* The Point with index one is the projection onto the plane.
*
* Projection will happen onto an extension of the plane as well - the filter does not regard boundaries
* This Filter currently only supports projection of one needle. Extension to multiple needles / planes should be easy.
*
* \ingroup US
*/
class MITKUSNAVIGATION_EXPORT NeedleProjectionFilter : public NavigationDataPassThroughFilter
{
public:
mitkClassMacro(NeedleProjectionFilter, NavigationDataPassThroughFilter);
itkNewMacro(Self);
virtual void SelectInput(int i);
itkGetMacro(TargetPlane, mitk::AffineTransform3D::Pointer);
itkSetMacro(TargetPlane, mitk::AffineTransform3D::Pointer);
itkGetMacro(Projection, mitk::PointSet::Pointer);
+ void SetToolAxisForFilter(mitk::Point3D point);
protected:
NeedleProjectionFilter();
virtual ~NeedleProjectionFilter();
virtual void GenerateData() override;
mitk::AffineTransform3D::Pointer m_TargetPlane;
mitk::PointSet::Pointer m_Projection;
mitk::PointSet::Pointer m_OriginalPoints;
int m_SelectedInput;
/**
* \brief Creates an Affine Transformation from a Navigation Data Object.
*/
mitk::AffineTransform3D::Pointer NavigationDataToTransform(const mitk::NavigationData * nd);
/**
* \brief Creates an Geometry 3D Object from an AffineTransformation.
*/
mitk::Geometry3D::Pointer TransformToGeometry(mitk::AffineTransform3D::Pointer transform);
};
} // namespace mitk
#endif
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPunctuationIntervention.cpp b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPunctuationIntervention.cpp
index 7055f87860..add64852a0 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPunctuationIntervention.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPunctuationIntervention.cpp
@@ -1,267 +1,286 @@
/*===================================================================
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 "QmitkUSNavigationStepPunctuationIntervention.h"
#include "ui_QmitkUSNavigationStepPunctuationIntervention.h"
#include "mitkNeedleProjectionFilter.h"
#include "../Widgets/QmitkZoneProgressBar.h"
#include "../USNavigationMarkerPlacement.h"
#include "usModuleRegistry.h"
#include <mitkTrackingTypes.h>
QmitkUSNavigationStepPunctuationIntervention::QmitkUSNavigationStepPunctuationIntervention(QWidget *parent) :
QmitkUSAbstractNavigationStep(parent),
m_NeedleProjectionFilter(mitk::NeedleProjectionFilter::New()),
ui(new Ui::QmitkUSNavigationStepPunctuationIntervention),
m_SphereSource(vtkSmartPointer<vtkSphereSource>::New()),
m_OBBTree(vtkSmartPointer<vtkOBBTree>::New()),
m_IntersectPoints(vtkSmartPointer<vtkPoints>::New())
{
ui->setupUi(this);
connect(ui->m_AddNewAblationZone, SIGNAL(clicked()), this, SLOT(OnAddAblationZoneClicked()));
connect(ui->m_EnableAblationMarking, SIGNAL(clicked()), this, SLOT(OnEnableAblationZoneMarkingClicked()));
connect(ui->m_AblationZoneSizeSlider, SIGNAL(valueChanged(int)), this, SLOT(OnAblationZoneSizeSliderChanged(int)));
ui->m_AblationZonesBox->setVisible(false);
}
+QmitkUSNavigationStepPunctuationIntervention::QmitkUSNavigationStepPunctuationIntervention(mitk::Point3D toolAxis, QWidget *parent) :
+QmitkUSAbstractNavigationStep(parent),
+m_NeedleProjectionFilter(mitk::NeedleProjectionFilter::New()),
+ui(new Ui::QmitkUSNavigationStepPunctuationIntervention),
+m_SphereSource(vtkSmartPointer<vtkSphereSource>::New()),
+m_OBBTree(vtkSmartPointer<vtkOBBTree>::New()),
+m_IntersectPoints(vtkSmartPointer<vtkPoints>::New())
+{
+ m_ToolAxis.SetElement(0, (toolAxis.GetElement(0)));
+ m_ToolAxis.SetElement(1, (toolAxis.GetElement(1)));
+ m_ToolAxis.SetElement(2, (toolAxis.GetElement(2)));
+ m_NeedleProjectionFilter->SetToolAxisForFilter(m_ToolAxis);
+ ui->setupUi(this);
+ connect(ui->m_AddNewAblationZone, SIGNAL(clicked()), this, SLOT(OnAddAblationZoneClicked()));
+ connect(ui->m_EnableAblationMarking, SIGNAL(clicked()), this, SLOT(OnEnableAblationZoneMarkingClicked()));
+ connect(ui->m_AblationZoneSizeSlider, SIGNAL(valueChanged(int)), this, SLOT(OnAblationZoneSizeSliderChanged(int)));
+ ui->m_AblationZonesBox->setVisible(false);
+}
+
void QmitkUSNavigationStepPunctuationIntervention::OnEnableAblationZoneMarkingClicked()
{
if(ui->m_EnableAblationMarking->isChecked())
ui->m_AblationZonesBox->setVisible(true);
else
ui->m_AblationZonesBox->setVisible(false);
}
void QmitkUSNavigationStepPunctuationIntervention::OnAblationZoneSizeSliderChanged(int size)
{
int id = ui->m_AblationZonesList->currentRow();
if (id!=-1) {emit AblationZoneChanged(id,size);}
-}
+}//
void QmitkUSNavigationStepPunctuationIntervention::OnAddAblationZoneClicked()
{
QListWidgetItem* newItem = new QListWidgetItem("Ablation Zone (initial size: " + QString::number(ui->m_AblationZoneSizeSlider->value()) + " mm)", ui->m_AblationZonesList);
newItem->setSelected(true);
emit AddAblationZoneClicked(ui->m_AblationZoneSizeSlider->value());
}
QmitkUSNavigationStepPunctuationIntervention::~QmitkUSNavigationStepPunctuationIntervention()
{
mitk::DataStorage::Pointer dataStorage = this->GetDataStorage(false);
if ( dataStorage.IsNotNull() )
{
// remove needle path from data storage if it is there
mitk::DataNode::Pointer node = this->GetNamedDerivedNode
("Needle Path", QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
if ( node.IsNotNull() ) { dataStorage->Remove(node); }
}
delete ui;
}
bool QmitkUSNavigationStepPunctuationIntervention::OnStartStep()
{
// create node for Needle Projection
mitk::DataNode::Pointer node = this->GetNamedDerivedNodeAndCreate
("Needle Path", QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
node->SetData(m_NeedleProjectionFilter->GetProjection());
node->SetBoolProperty("show contour", true);
return true;
}
bool QmitkUSNavigationStepPunctuationIntervention::OnRestartStep()
{
return this->OnActivateStep();
}
bool QmitkUSNavigationStepPunctuationIntervention::OnFinishStep()
{
mitk::DataNode::Pointer finishPunctionResult = mitk::DataNode::New();
finishPunctionResult->SetName("PunctionResult");
mitk::Point3D needlePos = m_NeedleProjectionFilter->GetOutput(0)->GetPosition();
mitk::Quaternion needleRot = m_NeedleProjectionFilter->GetOutput(0)->GetOrientation();
finishPunctionResult->SetProperty("USNavigation::TipPositionEnd", mitk::Point3dProperty::New(needlePos));
MITK_INFO("USNavigationLogging") << "Instrument tip at end: " <<needlePos<< " / " << needleRot;
emit SignalIntermediateResult(finishPunctionResult);
return true;
}
bool QmitkUSNavigationStepPunctuationIntervention::OnActivateStep()
{
this->ClearZones();
mitk::DataStorage::Pointer dataStorage = this->GetDataStorage();
// add progress bars for risk zone nodes
m_ZoneNodes = dataStorage->GetDerivations(dataStorage->GetNamedNode(USNavigationMarkerPlacement::DATANAME_ZONES));
// add zones to the widgets for risk structures
for (mitk::DataStorage::SetOfObjects::ConstIterator it = m_ZoneNodes->Begin();
it != m_ZoneNodes->End(); ++it)
{
ui->riskStructuresRangeWidget->AddZone(it->Value());
float rgb[3];
it->Value()->GetColor(rgb);
mitk::Color color;
color.SetRed(rgb[0]);
color.SetGreen(rgb[1]);
color.SetBlue(rgb[2]);
m_OldColors[it->Value()] = color;
}
m_NeedleProjectionFilter->SelectInput(0);
return true;
}
void QmitkUSNavigationStepPunctuationIntervention::OnUpdate()
{
// get navigation data source and make sure that it is not null
mitk::NavigationDataSource::Pointer navigationDataSource =
this->GetCombinedModality()->GetNavigationDataSource();
if ( navigationDataSource.IsNull() )
{
MITK_ERROR("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepPunctuationIntervention")
<< "Navigation Data Source of Combined Modality must not be null.";
mitkThrow() << "Navigation Data Source of Combined Modality must not be null.";
}
// update body marker
this->UpdateBodyMarkerStatus(navigationDataSource->GetOutput(1));
// update critical structures
this->UpdateCriticalStructures(navigationDataSource->GetOutput(0),m_NeedleProjectionFilter->GetProjection());
//Update Distance to US image
mitk::Point3D point1 = m_NeedleProjectionFilter->GetProjection()->GetPoint(0);
mitk::Point3D point2 = m_NeedleProjectionFilter->GetProjection()->GetPoint(1);
double distance = point1.EuclideanDistanceTo(point2);
ui->m_DistanceToUSPlane->setText(QString::number(distance) + " mm");
}
void QmitkUSNavigationStepPunctuationIntervention::OnSettingsChanged(const itk::SmartPointer<mitk::DataNode> settingsNode)
{
if ( settingsNode.IsNull() ) { return; }
}
QString QmitkUSNavigationStepPunctuationIntervention::GetTitle()
{
return "Computer-assisted Intervention";
}
bool QmitkUSNavigationStepPunctuationIntervention::GetIsRestartable()
{
return false;
}
QmitkUSNavigationStepPunctuationIntervention::FilterVector QmitkUSNavigationStepPunctuationIntervention::GetFilter()
{
return FilterVector(1, m_NeedleProjectionFilter.GetPointer());
}
void QmitkUSNavigationStepPunctuationIntervention::OnSetCombinedModality()
{
mitk::USCombinedModality::Pointer combinedModality = this->GetCombinedModality(false);
if ( combinedModality.IsNotNull() )
{
// set calibration of the combined modality to the needle projection filter
mitk::AffineTransform3D::Pointer calibration = combinedModality->GetCalibration();
if ( calibration.IsNotNull() )
{
m_NeedleProjectionFilter->SetTargetPlane(calibration);
}
}
}
void QmitkUSNavigationStepPunctuationIntervention::ClearZones()
{
ui->riskStructuresRangeWidget->ClearZones();
}
void QmitkUSNavigationStepPunctuationIntervention::UpdateBodyMarkerStatus(mitk::NavigationData::Pointer bodyMarker)
{
if ( bodyMarker.IsNull() )
{
MITK_ERROR("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepPunctuationIntervention")
<< "Current Navigation Data for body marker of Combined Modality must not be null.";
mitkThrow() << "Current Navigation Data for body marker of Combined Modality must not be null.";
}
bool valid = bodyMarker->IsDataValid();
// update body marker status label
if (valid)
{
ui->bodyMarkerTrackingStatusLabel->setStyleSheet(
"background-color: #8bff8b; margin-right: 1em; margin-left: 1em; border: 1px solid grey");
ui->bodyMarkerTrackingStatusLabel->setText("Body marker is inside the tracking volume.");
}
else
{
ui->bodyMarkerTrackingStatusLabel->setStyleSheet(
"background-color: #ff7878; margin-right: 1em; margin-left: 1em; border: 1px solid grey");
ui->bodyMarkerTrackingStatusLabel->setText("Body marker is not inside the tracking volume.");
}
ui->riskStructuresRangeGroupBox->setEnabled(valid);
}
void QmitkUSNavigationStepPunctuationIntervention::UpdateCriticalStructures(mitk::NavigationData::Pointer needle, mitk::PointSet::Pointer path)
{
// update the distances for the risk structures widget
ui->riskStructuresRangeWidget->UpdateDistancesToNeedlePosition(needle);
//iterate through all zones
for (mitk::DataStorage::SetOfObjects::ConstIterator it = m_ZoneNodes->Begin();
it != m_ZoneNodes->End(); ++it)
{
mitk::DataNode::Pointer currentNode = it->Value();
//get center point and radius
float radius = -1;
mitk::Point3D center;
currentNode->GetFloatProperty("zone.size", radius);
center = currentNode->GetData()->GetGeometry()->GetIndexToWorldTransform()->GetTranslation();
mitk::Point3D point0 = path->GetPoint(0);
mitk::Point3D point1 = path->GetPoint(1);
if (CheckSphereLineIntersection(center,radius,point0,point1))
{currentNode->SetColor(mitk::IGTColor_WARNING);}
else
{currentNode->SetColor(m_OldColors[currentNode]);}
}
}
bool QmitkUSNavigationStepPunctuationIntervention::CheckSphereLineIntersection(mitk::Point3D& sphereOrigin, float& sphereRadius, mitk::Point3D& lineStart, mitk::Point3D& lineEnd)
{
double center[3] = {sphereOrigin[0],sphereOrigin[1],sphereOrigin[2]};
m_SphereSource->SetCenter(center);
m_SphereSource->SetRadius(sphereRadius);
m_SphereSource->Update();
m_OBBTree->SetDataSet(m_SphereSource->GetOutput());
m_OBBTree->BuildLocator();
double lineP0[3] = {lineStart[0], lineStart[1], lineStart[2]};
double lineP1[3] = {lineEnd[0], lineEnd[1], lineEnd[2]};
m_OBBTree->IntersectWithLine(lineP0, lineP1, m_IntersectPoints, nullptr);
if (m_IntersectPoints->GetNumberOfPoints() > 0) {return true;}
else {return false;}
}
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPunctuationIntervention.h b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPunctuationIntervention.h
index cf948c6cea..9c6e54b87f 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPunctuationIntervention.h
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPunctuationIntervention.h
@@ -1,117 +1,119 @@
/*===================================================================
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 QMITKUSNAVIGATIONSTEPPUNCTUATIONINTERVENTION_H
#define QMITKUSNAVIGATIONSTEPPUNCTUATIONINTERVENTION_H
#include "QmitkUSAbstractNavigationStep.h"
#include <mitkPointSet.h>
#include <vtkSmartPointer.h>
#include <vtkSphereSource.h>
#include <vtkLine.h>
#include <vtkOBBTree.h>
namespace mitk {
class DataNode;
class NeedleProjectionFilter;
class NodeDisplacementFilter;
class USNavigationGrabCutSegmentationUpdateFilter;
class USNavigationTargetUpdateFilter;
class USNavigationTargetOcclusionFilter;
class USPointMarkInteractor;
class LookupTableProperty;
class Surface;
}
namespace Ui {
class QmitkUSNavigationStepPunctuationIntervention;
}
class QmitkZoneProgressBar;
/**
* \brief Navigations step for the actual punctuation intervention.
* The needle path is projected onto the image plane and the distances to all
* risk structures are displayed in the widget.
*
* The risk structures are expected to be in the data storage under
* DATANAME_BASENODE -> DATANAME_ZONES. They should contain a property named
* "zone.size" and it is assumed that they are spherical.
*/
class QmitkUSNavigationStepPunctuationIntervention : public QmitkUSAbstractNavigationStep
{
Q_OBJECT
public:
explicit QmitkUSNavigationStepPunctuationIntervention(QWidget *parent = 0);
+ explicit QmitkUSNavigationStepPunctuationIntervention(mitk::Point3D toolAxis, QWidget *parent = 0);
~QmitkUSNavigationStepPunctuationIntervention();
virtual bool OnStartStep();
virtual bool OnRestartStep();
virtual bool OnFinishStep();
virtual bool OnActivateStep();
virtual void OnUpdate();
virtual void OnSettingsChanged(const itk::SmartPointer<mitk::DataNode>);
virtual QString GetTitle();
virtual bool GetIsRestartable();
virtual FilterVector GetFilter();
signals:
void AddAblationZoneClicked(int);
void AblationZoneChanged(int,int);
protected slots:
void OnAddAblationZoneClicked();
void OnEnableAblationZoneMarkingClicked();
void OnAblationZoneSizeSliderChanged(int size);
protected:
virtual void OnSetCombinedModality();
void ClearZones();
void UpdateBodyMarkerStatus(mitk::NavigationData::Pointer bodyMarker);
/** Updates the critical structures which means that the distance to the needle tip is updated
and also the color changes to red if the path projection intersects the critical structure. */
void UpdateCriticalStructures(mitk::NavigationData::Pointer needle, mitk::PointSet::Pointer path);
/** Checks if the given line intersects the given sphere. */
bool CheckSphereLineIntersection(mitk::Point3D& sphereOrigin, float& sphereRadius, mitk::Point3D& lineStart, mitk::Point3D& lineEnd);
mitk::DataStorage::SetOfObjects::ConstPointer m_ZoneNodes;
/**
* \brief Creates a Pointset that projects the needle's path
*/
itk::SmartPointer<mitk::NeedleProjectionFilter> m_NeedleProjectionFilter;
+ mitk::Point3D m_ToolAxis;
std::map<mitk::DataNode::Pointer,mitk::Color> m_OldColors; //stores the original color of the critical structrue nodes
//some help variables for the CheckSphereLineIntersection()-Method
vtkSmartPointer<vtkSphereSource> m_SphereSource;
vtkSmartPointer<vtkOBBTree> m_OBBTree;
vtkSmartPointer<vtkPoints> m_IntersectPoints;
private:
Ui::QmitkUSNavigationStepPunctuationIntervention *ui;
};
#endif // QMITKUSNAVIGATIONSTEPPUNCTUATIONINTERVENTION_H
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.cpp b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.cpp
index a7876c2677..380c84b225 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.cpp
@@ -1,738 +1,809 @@
/*===================================================================
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 "USNavigationMarkerPlacement.h"
#include "ui_USNavigationMarkerPlacement.h"
#include "NavigationStepWidgets/QmitkUSNavigationStepCombinedModality.h"
#include "NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.h"
#include "NavigationStepWidgets/QmitkUSNavigationStepPlacementPlanning.h"
#include "NavigationStepWidgets/QmitkUSNavigationStepPunctuationIntervention.h"
#include "NavigationStepWidgets/QmitkUSNavigationStepTumourSelection.h"
#include "NavigationStepWidgets/QmitkUSNavigationStepZoneMarking.h"
#include "SettingsWidgets/QmitkUSNavigationCombinedSettingsWidget.h"
#include "mitkIRenderingManager.h"
#include "mitkNodeDisplacementFilter.h"
#include "mitkUSCombinedModality.h"
#include <mitkIOUtil.h>
#include "IO/mitkUSNavigationExperimentLogging.h"
#include "IO/mitkUSNavigationStepTimer.h"
#include <QDateTime>
#include <QDir>
#include <QInputDialog>
#include <QMessageBox>
#include <QSignalMapper>
#include <QTimer>
#include "QmitkRenderWindow.h"
#include "QmitkStdMultiWidget.h"
#include "QmitkStdMultiWidgetEditor.h"
#include "mitkLayoutAnnotationRenderer.h"
// scene serialization
#include <mitkConvert2Dto3DImageFilter.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateProperty.h>
#include <mitkSceneIO.h>
#include <mitkSurface.h>
const std::string USNavigationMarkerPlacement::VIEW_ID = "org.mitk.views.usmarkerplacement";
const char *USNavigationMarkerPlacement::DATANAME_TUMOUR = "Tumour";
const char *USNavigationMarkerPlacement::DATANAME_TARGETSURFACE = "Target Surface";
const char *USNavigationMarkerPlacement::DATANAME_ZONES = "Zones";
const char *USNavigationMarkerPlacement::DATANAME_TARGETS = "Targets";
const char *USNavigationMarkerPlacement::DATANAME_TARGETS_PATHS = "Target Paths";
const char *USNavigationMarkerPlacement::DATANAME_REACHED_TARGETS = "Reached Targets";
USNavigationMarkerPlacement::USNavigationMarkerPlacement()
: m_Parent(nullptr),
m_UpdateTimer(new QTimer(this)),
m_ImageAndNavigationDataLoggingTimer(new QTimer(this)),
m_StdMultiWidget(0),
m_ReinitAlreadyDone(false),
m_IsExperimentRunning(false),
m_NavigationStepTimer(mitk::USNavigationStepTimer::New()),
m_ExperimentLogging(mitk::USNavigationExperimentLogging::New()),
m_AblationZonesDisplacementFilter(mitk::NodeDisplacementFilter::New()),
m_IconRunning(QPixmap(":/USNavigation/record.png")),
m_IconNotRunning(QPixmap(":/USNavigation/record-gray.png")),
m_USImageLoggingFilter(mitk::USImageLoggingFilter::New()),
m_NavigationDataRecorder(mitk::NavigationDataRecorder::New()),
m_SceneNumber(1),
m_WarnOverlay(mitk::TextAnnotation2D::New()),
m_ListenerDeviceChanged(this, &USNavigationMarkerPlacement::OnCombinedModalityPropertyChanged),
m_NeedleIndex(0),
m_MarkerIndex(1),
ui(new Ui::USNavigationMarkerPlacement)
{
connect(m_UpdateTimer, SIGNAL(timeout()), this, SLOT(OnTimeout()));
connect(
m_ImageAndNavigationDataLoggingTimer, SIGNAL(timeout()), this, SLOT(OnImageAndNavigationDataLoggingTimeout()));
// scale running (and not running) icon the specific height
m_IconRunning = m_IconRunning.scaledToHeight(20, Qt::SmoothTransformation);
m_IconNotRunning = m_IconNotRunning.scaledToHeight(20, Qt::SmoothTransformation);
// set prefix for experiment logging (only keys with this prefix are taken
// into consideration
m_ExperimentLogging->SetKeyPrefix("USNavigation::");
m_UpdateTimer->start(33); // every 33 Milliseconds = 30 Frames/Second
}
USNavigationMarkerPlacement::~USNavigationMarkerPlacement()
{
// remove listener for ultrasound device changes
if (m_CombinedModality.IsNotNull() && m_CombinedModality->GetUltrasoundDevice().IsNotNull())
{
m_CombinedModality->GetUltrasoundDevice()->RemovePropertyChangedListener(m_ListenerDeviceChanged);
}
// remove listener for ultrasound device changes
if (m_CombinedModality.IsNotNull() && m_CombinedModality->GetUltrasoundDevice().IsNotNull())
{
m_CombinedModality->GetUltrasoundDevice()->RemovePropertyChangedListener(m_ListenerDeviceChanged);
}
delete ui;
}
void USNavigationMarkerPlacement::OnChangeAblationZone(int id, int newSize)
{
if ((static_cast<int>(m_AblationZonesVector.size()) < id) || (id < 0))
{
return;
}
MITK_INFO << "Ablation Zone " << id << " changed, new size: " << newSize;
// create a vtk sphere with given radius
vtkSphereSource *vtkData = vtkSphereSource::New();
vtkData->SetRadius(newSize / 2);
vtkData->SetCenter(0, 0, 0);
vtkData->SetPhiResolution(20);
vtkData->SetThetaResolution(20);
vtkData->Update();
mitk::Surface::Pointer zoneSurface = dynamic_cast<mitk::Surface *>(m_AblationZonesVector.at(id)->GetData());
zoneSurface->SetVtkPolyData(vtkData->GetOutput());
vtkData->Delete();
}
void USNavigationMarkerPlacement::OnAddAblationZone(int size)
{
m_AblationZonesDisplacementFilter->SetInitialReferencePose(
m_CombinedModality->GetNavigationDataSource()->GetOutput(m_MarkerIndex));
mitk::DataNode::Pointer NewAblationZone = mitk::DataNode::New();
mitk::Point3D origin = m_CombinedModality->GetNavigationDataSource()->GetOutput(m_NeedleIndex)->GetPosition();
MITK_INFO("USNavigationLogging") << "Ablation Zone Added, initial size: " << size << ", origin: " << origin;
mitk::Surface::Pointer zone = mitk::Surface::New();
// create a vtk sphere with given radius
vtkSphereSource *vtkData = vtkSphereSource::New();
vtkData->SetRadius(size / 2);
vtkData->SetCenter(0, 0, 0);
vtkData->SetPhiResolution(20);
vtkData->SetThetaResolution(20);
vtkData->Update();
zone->SetVtkPolyData(vtkData->GetOutput());
vtkData->Delete();
// set vtk sphere and origin to data node (origin must be set
// again, because of the new sphere set as data)
NewAblationZone->SetData(zone);
NewAblationZone->GetData()->GetGeometry()->SetOrigin(origin);
mitk::Color SphereColor = mitk::Color();
// default color
SphereColor[0] = 102;
SphereColor[1] = 0;
SphereColor[2] = 204;
NewAblationZone->SetColor(SphereColor);
NewAblationZone->SetOpacity(0.3);
// set name of zone
std::stringstream name;
name << "Ablation Zone" << m_AblationZonesVector.size();
NewAblationZone->SetName(name.str());
// add zone to filter
m_AblationZonesDisplacementFilter->AddNode(NewAblationZone);
m_AblationZonesVector.push_back(NewAblationZone);
this->GetDataStorage()->Add(NewAblationZone);
}
void USNavigationMarkerPlacement::CreateQtPartControl(QWidget *parent)
{
m_Parent = parent;
ui->setupUi(parent);
connect(ui->navigationProcessWidget,
SIGNAL(SignalCombinedModalityChanged(itk::SmartPointer<mitk::USCombinedModality>)),
this,
SLOT(OnCombinedModalityChanged(itk::SmartPointer<mitk::USCombinedModality>)));
connect(ui->navigationProcessWidget,
SIGNAL(SignalSettingsChanged(itk::SmartPointer<mitk::DataNode>)),
this,
SLOT(OnSettingsChanged(itk::SmartPointer<mitk::DataNode>)));
connect(ui->navigationProcessWidget,
SIGNAL(SignalActiveNavigationStepChanged(int)),
this,
SLOT(OnActiveNavigationStepChanged(int)));
connect(ui->startExperimentButton, SIGNAL(clicked()), this, SLOT(OnStartExperiment()));
connect(ui->finishExperimentButton, SIGNAL(clicked()), this, SLOT(OnFinishExperiment()));
+ connect(ui->m_enableNavigationLayout, SIGNAL(clicked()), this, SLOT(OnChangeLayoutClicked()));
connect(ui->navigationProcessWidget,
SIGNAL(SignalIntermediateResult(const itk::SmartPointer<mitk::DataNode>)),
this,
SLOT(OnIntermediateResultProduced(const itk::SmartPointer<mitk::DataNode>)));
ui->navigationProcessWidget->SetDataStorage(this->GetDataStorage());
// indicate that no experiment is running at start
ui->runningLabel->setPixmap(m_IconNotRunning);
ui->navigationProcessWidget->SetSettingsWidget(new QmitkUSNavigationCombinedSettingsWidget(m_Parent));
}
void USNavigationMarkerPlacement::OnCombinedModalityPropertyChanged(const std::string &key, const std::string &)
{
if (key == mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_DEPTH)
{
m_ReinitAlreadyDone = false;
this->ReinitOnImage();
if (m_CombinedModality.IsNotNull() && !m_CombinedModality->GetIsCalibratedForCurrentStatus())
{
mitk::LayoutAnnotationRenderer::AddAnnotation(
m_WarnOverlay.GetPointer(), "stdmulti.widget1", mitk::LayoutAnnotationRenderer::TopLeft);
MITK_WARN << "No calibration available for the selected ultrasound image depth.";
}
}
}
+
+void USNavigationMarkerPlacement::SetToolAxisMarkerPlacement()
+{
+ m_NavigationDataSource = m_CombinedModality->GetNavigationDataSource();
+ m_ToolAxis.SetElement(0, 0);
+ m_ToolAxis.SetElement(1, 0);
+ m_ToolAxis.SetElement(2, 1);
+ if (m_NavigationDataSource.IsNull())
+ {
+ MITK_WARN << "Cannot retrieve tool axis as tracking source is null.";
+ }
+ else
+ {
+ us::ModuleContext* context = us::GetModuleContext();
+ std::string id = m_NavigationDataSource->US_PROPKEY_ID;
+ std::string filter = "(" + mitk::NavigationToolStorage::US_PROPKEY_SOURCE_ID + "=" + id + ")";
+ // Get Storage
+ std::vector<us::ServiceReference<mitk::NavigationToolStorage> > refs = context->GetServiceReferences<mitk::NavigationToolStorage>();
+ m_CurrentStorage = context->GetService(refs.front());
+ if (m_CurrentStorage.IsNull())
+ {
+ MITK_WARN << "Found an invalid storage object!";
+ }
+ if (m_CurrentStorage->GetToolCount() != m_NavigationDataSource->GetNumberOfOutputs()) //there is something wrong with the storage
+ {
+ MITK_WARN << "Found a tool storage, but it has not the same number of tools like the NavigationDataSource. This storage won't be used because it isn't the right one.";
+ m_CurrentStorage = NULL;
+ }
+
+ //getting the first tool in the tool storage, assuming this is the needle
+ mitk::NavigationTool::Pointer needle;
+ needle = m_CurrentStorage->GetTool(0);
+
+ m_ToolAxis.SetElement(0, (needle->GetToolAxis().GetElement(0)));
+ m_ToolAxis.SetElement(1, (needle->GetToolAxis().GetElement(1)));
+ m_ToolAxis.SetElement(2, (needle->GetToolAxis().GetElement(2)));
+ }
+}
+
+
void USNavigationMarkerPlacement::SetFocus()
{
this->ReinitOnImage();
}
void USNavigationMarkerPlacement::OnTimeout()
{
if (!m_StdMultiWidget)
{
// try to get the standard multi widget if it couldn't be got before
mitk::IRenderWindowPart *renderWindow = this->GetRenderWindowPart();
QmitkStdMultiWidgetEditor *multiWidgetEditor = dynamic_cast<QmitkStdMultiWidgetEditor *>(renderWindow);
// if there is a standard multi widget now, disable the level window and
// change the layout to 2D up and 3d down
if (multiWidgetEditor)
{
m_StdMultiWidget = multiWidgetEditor->GetStdMultiWidget();
if (m_StdMultiWidget)
{
m_StdMultiWidget->DisableStandardLevelWindow();
m_StdMultiWidget->changeLayoutTo2DUpAnd3DDown();
}
}
this->CreateOverlays();
}
if (m_CombinedModality.IsNotNull() &&
!this->m_CombinedModality->GetIsFreezed()) // if the combined modality is freezed: do nothing
{
ui->navigationProcessWidget->UpdateNavigationProgress();
m_AblationZonesDisplacementFilter->Update();
// update the 3D window only every fourth time to speed up the rendering (at least in 2D)
this->RequestRenderWindowUpdate(mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS);
// make sure that a reinit was performed on the image
this->ReinitOnImage();
}
}
+void USNavigationMarkerPlacement::OnEnableNavigationLayout()
+{
+ MITK_INFO << "Navigation Layout";
+ // try to get the standard multi widget if it couldn't be got before
+ mitk::IRenderWindowPart *renderWindow = this->GetRenderWindowPart();
+
+ QmitkStdMultiWidgetEditor *multiWidgetEditor = dynamic_cast<QmitkStdMultiWidgetEditor *>(renderWindow);
+
+ // if there is a standard multi widget now, disable the level window and
+ // change the layout to 2D up and 3d down
+ if (multiWidgetEditor)
+ {
+ m_StdMultiWidget = multiWidgetEditor->GetStdMultiWidget();
+ if (m_StdMultiWidget)
+ {
+ m_StdMultiWidget->DisableStandardLevelWindow();
+ m_StdMultiWidget->changeLayoutTo2DUpAnd3DDown();
+ this->GetDataStorage()->GetNamedNode("stdmulti.widget1.plane")->SetVisibility(false);
+ this->GetDataStorage()->GetNamedNode("stdmulti.widget3.plane")->SetVisibility(false);
+ }
+ }
+}
+
void USNavigationMarkerPlacement::OnResetStandardLayout()
{
- MITK_INFO << "Resetting Layout";
//reset render windows
mitk::DataNode::Pointer widget1 = this->GetDataStorage()->GetNamedNode("stdmulti.widget1.plane");
if (widget1.IsNotNull()) { widget1->SetVisibility(true); }
mitk::DataNode::Pointer widget3 = this->GetDataStorage()->GetNamedNode("stdmulti.widget3.plane");
if (widget3.IsNotNull()) { widget3->SetVisibility(true); }
m_StdMultiWidget->changeLayoutToDefault();
}
void USNavigationMarkerPlacement::OnChangeLayoutClicked()
{
if (ui->m_enableNavigationLayout->isChecked()) OnEnableNavigationLayout();
else OnResetStandardLayout();
}
void USNavigationMarkerPlacement::OnImageAndNavigationDataLoggingTimeout()
{
// update filter for logging navigation data and ultrasound images
if (m_CombinedModality.IsNotNull())
{
m_NavigationDataRecorder->Update();
// get last messages for logging filer and store them
std::vector<std::string> messages = m_LoggingBackend.GetNavigationMessages();
std::string composedMessage = "";
for (std::size_t i = 0; i < messages.size(); i++)
{
composedMessage += messages.at(i);
}
m_USImageLoggingFilter->AddMessageToCurrentImage(composedMessage);
m_LoggingBackend.ClearNavigationMessages();
// update logging filter
m_USImageLoggingFilter->Update();
}
}
void USNavigationMarkerPlacement::OnStartExperiment()
{
// get name for the experiment by a QInputDialog
bool ok;
if (m_ExperimentName.isEmpty())
{ // default: current date
m_ExperimentName = QString::number(QDateTime::currentDateTime().date().year()) + "_" +
QString::number(QDateTime::currentDateTime().date().month()) + "_" +
QString::number(QDateTime::currentDateTime().date().day()) + "_experiment_" +
QString::number(QDateTime::currentDateTime().time().hour()) + "." +
QString::number(QDateTime::currentDateTime().time().minute());
}
m_ExperimentName = QInputDialog::getText(
m_Parent, QString("Experiment Name"), QString("Name of the Experiment"), QLineEdit::Normal, m_ExperimentName, &ok);
MITK_INFO("USNavigationLogging") << "Experiment started: " << m_ExperimentName.toStdString();
if (ok && !m_ExperimentName.isEmpty())
{
// display error message and call the function recursivly if a directory
// with the given name already exists
QDir experimentResultsDir(m_ResultsDirectory + QDir::separator() + m_ExperimentName);
if (experimentResultsDir.exists())
{
QMessageBox::critical(
m_Parent, "Results Directory Exists", "The result directory already exists.\nPlease choose an other name.");
this->OnStartExperiment();
}
else
{
QDir(m_ResultsDirectory).mkdir(m_ExperimentName);
m_ExperimentResultsSubDirectory = m_ResultsDirectory + QDir::separator() + m_ExperimentName;
// experiment is running now
ui->runningLabel->setPixmap(m_IconRunning);
ui->navigationProcessWidget->EnableInteraction(true);
// (re)start timer for navigation step durations
m_NavigationStepTimer->Reset();
m_NavigationStepTimer->SetOutputFileName(
QString(m_ExperimentResultsSubDirectory + QDir::separator() + QString("durations.cvs")).toStdString());
m_NavigationStepTimer->SetActiveIndex(0, m_NavigationSteps.at(0)->GetTitle().toStdString());
ui->finishExperimentButton->setEnabled(true);
ui->startExperimentButton->setDisabled(true);
// initialize and register logging backend
QString loggingFilename = m_ExperimentResultsSubDirectory + QDir::separator() + "logging.txt";
m_LoggingBackend.SetOutputFileName(loggingFilename.toStdString());
mbilog::RegisterBackend(&m_LoggingBackend);
// initialize and start navigation data recorder form xml recording
m_NavigationDataRecorder->StartRecording();
m_IsExperimentRunning = true;
m_ImageAndNavigationDataLoggingTimer->start(1000);
// (re)start experiment logging and set output file name
m_ExperimentLogging->Reset();
m_ExperimentLogging->SetFileName(
QString(m_ExperimentResultsSubDirectory + QDir::separator() + "experiment-logging.xml").toStdString());
}
}
}
void USNavigationMarkerPlacement::OnFinishExperiment()
{
this->WaitCursorOn();
MITK_INFO("USNavigationLogging") << "Experiment finished!";
MITK_INFO("USNavigationLogging")
<< "Position/Orientation of needle tip: "
<< (dynamic_cast<mitk::NavigationData *>(m_CombinedModality->GetTrackingDevice()->GetOutput(0)))->GetPosition();
MITK_INFO("USNavigationLogging")
<< "Position of target: " << m_TargetNodeDisplacementFilter->GetRawDisplacementNavigationData(0)->GetPosition();
MITK_INFO("USNavigationLogging") << "Total duration: " << m_NavigationStepTimer->GetTotalDuration();
ui->navigationProcessWidget->FinishCurrentNavigationStep();
m_ImageAndNavigationDataLoggingTimer->stop();
ui->runningLabel->setPixmap(m_IconNotRunning);
ui->navigationProcessWidget->EnableInteraction(false);
m_NavigationStepTimer->Stop();
// make sure that the navigation process will be start from beginning at the
// next experiment
ui->navigationProcessWidget->ResetNavigationProcess();
ui->finishExperimentButton->setDisabled(true);
ui->startExperimentButton->setEnabled(true);
MITK_INFO("USNavigationLogging") << "Writing logging data to " << m_ExperimentResultsSubDirectory.toStdString();
// save ultrasound images to the file system
QDir(m_ExperimentResultsSubDirectory).mkdir("ImageStream");
m_USImageLoggingFilter->Update();
m_USImageLoggingFilter->SetImageFilesExtension(".jpg");
m_USImageLoggingFilter->SaveImages(
QString(m_ExperimentResultsSubDirectory + QDir::separator() + "ImageStream" + QDir::separator()).toStdString());
m_USImageLoggingFilter = mitk::USImageLoggingFilter::New();
m_NavigationDataRecorder->StopRecording();
// Write data to csv and xml file
mitk::IOUtil::Save(
m_NavigationDataRecorder->GetNavigationDataSet(),
(QString(m_ExperimentResultsSubDirectory + QDir::separator() + "navigation-data.xml").toStdString().c_str()));
mitk::IOUtil::Save(
m_NavigationDataRecorder->GetNavigationDataSet(),
(QString(m_ExperimentResultsSubDirectory + QDir::separator() + "navigation-data.csv").toStdString().c_str()));
// write logged navigation data messages to separate file
std::stringstream csvNavigationMessagesFilename;
csvNavigationMessagesFilename << m_ExperimentResultsSubDirectory.toStdString() << QDir::separator().toLatin1()
<< "CSVNavigationMessagesLogFile.csv";
MITK_INFO("USNavigationLogging") << "Writing logged navigation messages to separate csv file: "
<< csvNavigationMessagesFilename.str();
m_LoggingBackend.WriteCSVFileWithNavigationMessages(csvNavigationMessagesFilename.str());
mbilog::UnregisterBackend(&m_LoggingBackend);
m_IsExperimentRunning = false;
m_ImageAndNavigationDataLoggingTimer->stop();
m_CombinedModality = 0;
// reset scene number for next experiment
m_SceneNumber = 1;
this->WaitCursorOff();
MITK_INFO("USNavigationLogging") << "Finished!";
}
void USNavigationMarkerPlacement::OnCombinedModalityChanged(
itk::SmartPointer<mitk::USCombinedModality> combinedModality)
{
// remove old listener for ultrasound device changes
if (m_CombinedModality.IsNotNull() && m_CombinedModality->GetUltrasoundDevice().IsNotNull())
{
m_CombinedModality->GetUltrasoundDevice()->RemovePropertyChangedListener(m_ListenerDeviceChanged);
}
m_CombinedModality = combinedModality;
m_ReinitAlreadyDone = false;
// add a listener for ultrasound device changes
if (m_CombinedModality.IsNotNull() && m_CombinedModality->GetUltrasoundDevice().IsNotNull())
{
m_CombinedModality->GetUltrasoundDevice()->AddPropertyChangedListener(m_ListenerDeviceChanged);
}
// update navigation data recorder for using the new combined modality
mitk::NavigationDataSource::Pointer navigationDataSource = combinedModality->GetNavigationDataSource();
m_NavigationDataRecorder->ConnectTo(navigationDataSource);
m_NavigationDataRecorder->ResetRecording();
- // TODO check for correct connection
- // for (unsigned int n = 0; n < navigationDataSource->GetNumberOfIndexedOutputs(); ++n)
- // {
- // m_NavigationDataRecorder->AddNavigationData(navigationDataSource->GetOutput(n));
- // }
-
- // update ultrasound image logging filter for using the new combined modality
- mitk::USDevice::Pointer ultrasoundImageSource = combinedModality->GetUltrasoundDevice();
- for (unsigned int n = 0; n < ultrasoundImageSource->GetNumberOfIndexedOutputs(); ++n)
- {
- m_USImageLoggingFilter->SetInput(n, ultrasoundImageSource->GetOutput(n));
- }
+ //upate stored tool axis for current tool
+ this->SetToolAxisMarkerPlacement();
+ //store new tool axis
+ QmitkUSNavigationStepPunctuationIntervention* stepIntervention =
+ new QmitkUSNavigationStepPunctuationIntervention(m_ToolAxis, m_Parent);
+ m_NavigationSteps.pop_back();
+ m_NavigationSteps.push_back(stepIntervention);
+
+ // TODO check for correct connection
+ // for (unsigned int n = 0; n < navigationDataSource->GetNumberOfIndexedOutputs(); ++n)
+ // {
+ // m_NavigationDataRecorder->AddNavigationData(navigationDataSource->GetOutput(n));
+ // }
+
+ // update ultrasound image logging filter for using the new combined modality
+ mitk::USDevice::Pointer ultrasoundImageSource = combinedModality->GetUltrasoundDevice();
+ for (unsigned int n = 0; n < ultrasoundImageSource->GetNumberOfIndexedOutputs(); ++n)
+ {
+ m_USImageLoggingFilter->SetInput(n, ultrasoundImageSource->GetOutput(n));
+ }
- // update ablation zone filter for using the new combined modality
- for (unsigned int n = 0; n < navigationDataSource->GetNumberOfIndexedOutputs(); ++n)
- {
- m_AblationZonesDisplacementFilter->SetInput(n, navigationDataSource->GetOutput(n));
- }
- m_AblationZonesDisplacementFilter->SelectInput(m_MarkerIndex);
+ // update ablation zone filter for using the new combined modality
+ for (unsigned int n = 0; n < navigationDataSource->GetNumberOfIndexedOutputs(); ++n)
+ {
+ m_AblationZonesDisplacementFilter->SetInput(n, navigationDataSource->GetOutput(n));
+ }
+ m_AblationZonesDisplacementFilter->SelectInput(m_MarkerIndex);
- // make sure that a reinit is done for the new images
- this->ReinitOnImage();
+ // make sure that a reinit is done for the new images
+ this->ReinitOnImage();
}
void USNavigationMarkerPlacement::OnSettingsChanged(itk::SmartPointer<mitk::DataNode> settings)
{
std::string applicationName;
if (!settings->GetStringProperty("settings.application", applicationName))
{
// set default application if the string property is not available
applicationName = "Marker Placement";
}
// create navigation step widgets according to the selected application
if (applicationName != m_CurrentApplicationName)
{
m_CurrentApplicationName = applicationName;
QmitkUSNavigationProcessWidget::NavigationStepVector navigationSteps;
if (applicationName == "Puncture")
{
QmitkUSNavigationStepCombinedModality* stepCombinedModality =
new QmitkUSNavigationStepCombinedModality(m_Parent);
QmitkUSNavigationStepTumourSelection* stepTumourSelection =
new QmitkUSNavigationStepTumourSelection(m_Parent);
stepTumourSelection->SetTargetSelectionOptional(true);
m_TargetNodeDisplacementFilter = stepTumourSelection->GetTumourNodeDisplacementFilter();
QmitkUSNavigationStepZoneMarking* stepZoneMarking =
new QmitkUSNavigationStepZoneMarking(m_Parent);
QmitkUSNavigationStepPunctuationIntervention* stepIntervention =
new QmitkUSNavigationStepPunctuationIntervention(m_Parent);
connect(stepIntervention, SIGNAL(AddAblationZoneClicked(int)), this, SLOT(OnAddAblationZone(int)));
connect(stepIntervention, SIGNAL(AblationZoneChanged(int, int)), this, SLOT(OnChangeAblationZone(int, int)));
m_NavigationStepNames = std::vector<QString>();
navigationSteps.push_back(stepCombinedModality);
m_NavigationStepNames.push_back("Combined Modality Initialization");
navigationSteps.push_back(stepTumourSelection);
m_NavigationStepNames.push_back("Target Selection");
navigationSteps.push_back(stepZoneMarking);
m_NavigationStepNames.push_back("Critical Structure Marking");
navigationSteps.push_back(stepIntervention);
m_NavigationStepNames.push_back("Intervention");
}
else if (applicationName == "Marker Placement")
{
QmitkUSNavigationStepCombinedModality *stepCombinedModality = new QmitkUSNavigationStepCombinedModality(m_Parent);
QmitkUSNavigationStepTumourSelection *stepTumourSelection = new QmitkUSNavigationStepTumourSelection(m_Parent);
m_TargetNodeDisplacementFilter = stepTumourSelection->GetTumourNodeDisplacementFilter();
QmitkUSNavigationStepZoneMarking *stepZoneMarking = new QmitkUSNavigationStepZoneMarking(m_Parent);
QmitkUSNavigationStepPlacementPlanning *stepPlacementPlanning =
new QmitkUSNavigationStepPlacementPlanning(m_Parent);
QmitkUSNavigationStepMarkerIntervention *stepMarkerIntervention =
new QmitkUSNavigationStepMarkerIntervention(m_Parent);
m_NavigationStepNames = std::vector<QString>();
navigationSteps.push_back(stepCombinedModality);
m_NavigationStepNames.push_back("Combined Modality Initialization");
navigationSteps.push_back(stepTumourSelection);
m_NavigationStepNames.push_back("Target Selection");
navigationSteps.push_back(stepZoneMarking);
m_NavigationStepNames.push_back("Critical Structure Marking");
navigationSteps.push_back(stepPlacementPlanning);
m_NavigationStepNames.push_back("Placement Planning");
navigationSteps.push_back(stepMarkerIntervention);
m_NavigationStepNames.push_back("Marker Intervention");
}
// set navigation step widgets to the process widget
ui->navigationProcessWidget->SetNavigationSteps(navigationSteps);
for (QmitkUSNavigationProcessWidget::NavigationStepIterator it = m_NavigationSteps.begin();
it != m_NavigationSteps.end();
++it)
{
delete *it;
}
m_NavigationSteps.clear();
m_NavigationSteps = navigationSteps;
}
// initialize gui according to the experiment mode setting
bool experimentMode = false;
settings->GetBoolProperty("settings.experiment-mode", experimentMode);
ui->startExperimentButton->setVisible(experimentMode);
ui->finishExperimentButton->setVisible(experimentMode);
ui->runningLabel->setVisible(experimentMode);
if (experimentMode && !m_IsExperimentRunning)
{
ui->navigationProcessWidget->ResetNavigationProcess();
ui->navigationProcessWidget->EnableInteraction(false);
ui->runningLabel->setPixmap(m_IconNotRunning);
}
else if (!experimentMode)
{
if (m_IsExperimentRunning)
{
this->OnFinishExperiment();
}
ui->navigationProcessWidget->EnableInteraction(true);
}
// get the results directory from the settings and use home directory if
// there is no results directory configured
std::string resultsDirectory;
if (settings->GetStringProperty("settings.experiment-results-directory", resultsDirectory))
{
m_ResultsDirectory = QString::fromStdString(resultsDirectory);
}
else
{
m_ResultsDirectory = QDir::homePath();
}
// make sure that the results directory exists
QDir resultsDirectoryQDir = QDir(m_ResultsDirectory);
if (!resultsDirectoryQDir.exists())
{
resultsDirectoryQDir.mkpath(m_ResultsDirectory);
}
MITK_INFO << "Results Directory: " << m_ResultsDirectory.toStdString();
}
void USNavigationMarkerPlacement::OnActiveNavigationStepChanged(int index)
{
// update navigation step timer each time the active navigation step changes
m_NavigationStepTimer->SetActiveIndex(index, m_NavigationSteps.at(index)->GetTitle().toStdString());
if (static_cast<int>(m_NavigationStepNames.size()) <= index)
{
MITK_INFO("USNavigationLogging") << "Someting went wrong: unknown navigation step!";
}
else
{
MITK_INFO("USNavigationLogging") << "Navigation step finished/changed, next step: "
<< this->m_NavigationStepNames.at(index).toStdString()
<< "; duration until now: " << m_NavigationStepTimer->GetTotalDuration();
}
}
void USNavigationMarkerPlacement::OnIntermediateResultProduced(const itk::SmartPointer<mitk::DataNode> resultsNode)
{
// intermediate results only matter during an experiment
if (!m_IsExperimentRunning)
{
return;
}
this->WaitCursorOn();
// set results node to the experiment logging (for saving contents to the
// file system)
m_ExperimentLogging->SetResult(resultsNode);
std::string resultsName;
if (!resultsNode->GetName(resultsName))
{
MITK_WARN << "Could not get name of current results node.";
return;
}
// save the mitk scene
std::string scenefile = QString(m_ExperimentResultsSubDirectory + QDir::separator() +
QString("Scene %1 - ").arg(m_SceneNumber++, 2, 10, QChar('0')) +
QString::fromStdString(resultsName).replace(":", "_") + ".mitk")
.toStdString();
MITK_INFO << "Saving Scene File: " << scenefile;
mitk::SceneIO::Pointer sceneIO = mitk::SceneIO::New();
mitk::NodePredicateNot::Pointer isNotHelperObject =
mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object", mitk::BoolProperty::New(true)));
mitk::DataStorage::SetOfObjects::ConstPointer nodesToBeSaved = this->GetDataStorage()->GetSubset(isNotHelperObject);
this->Convert2DImagesTo3D(nodesToBeSaved);
sceneIO->SaveScene(nodesToBeSaved, this->GetDataStorage(), scenefile);
this->WaitCursorOff();
}
void USNavigationMarkerPlacement::ReinitOnImage()
{
if (!m_ReinitAlreadyDone && m_CombinedModality.IsNotNull())
{
// make sure that the output is already calibrated correctly
// (if the zoom level was changed recently)
m_CombinedModality->Modified();
m_CombinedModality->Update();
mitk::Image::Pointer image = m_CombinedModality->GetOutput();
if (image.IsNotNull() && image->IsInitialized())
{
// make a reinit on the ultrasound image
mitk::IRenderWindowPart *renderWindow = this->GetRenderWindowPart();
if (renderWindow != NULL && image->GetTimeGeometry()->IsValid())
{
renderWindow->GetRenderingManager()->InitializeViews(
image->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
renderWindow->GetRenderingManager()->RequestUpdateAll();
}
this->RequestRenderWindowUpdate();
m_ReinitAlreadyDone = true;
}
}
}
void USNavigationMarkerPlacement::Convert2DImagesTo3D(mitk::DataStorage::SetOfObjects::ConstPointer nodes)
{
for (mitk::DataStorage::SetOfObjects::ConstIterator it = nodes->Begin(); it != nodes->End(); ++it)
{
if (it->Value()->GetData() && strcmp(it->Value()->GetData()->GetNameOfClass(), "Image") == 0)
{
// convert image to 3d image if it is 2d at the moment
mitk::Image::Pointer image = dynamic_cast<mitk::Image *>(it->Value()->GetData());
if (image.IsNotNull() && image->GetDimension() == 2 && !image->GetGeometry()->Is2DConvertable())
{
mitk::Convert2Dto3DImageFilter::Pointer convert2DTo3DImageFilter = mitk::Convert2Dto3DImageFilter::New();
convert2DTo3DImageFilter->SetInput(image);
convert2DTo3DImageFilter->Update();
it->Value()->SetData(convert2DTo3DImageFilter->GetOutput());
}
}
}
}
void USNavigationMarkerPlacement::CreateOverlays()
{
// initialize warning overlay (and do not display it, yet)
m_WarnOverlay->SetText("Warning: No calibration available for current depth.");
// set position and font size for the text overlay
// (nonesense postition as a layouter is used, but it ignored
// the overlay without setting a position here)
mitk::Point2D overlayPosition;
overlayPosition.SetElement(0, -50.0f);
overlayPosition.SetElement(1, -50.0f);
m_WarnOverlay->SetPosition2D(overlayPosition);
m_WarnOverlay->SetFontSize(22);
m_WarnOverlay->SetColor(1, 0, 0); // overlay should be red
}
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.h b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.h
index 94b51b06f9..550c100edf 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.h
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.h
@@ -1,190 +1,206 @@
/*===================================================================
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 USNAVIGATIONMARKERPLACEMENT_H
#define USNAVIGATIONMARKERPLACEMENT_H
#include <QmitkAbstractView.h>
#include "IO/mitkUSNavigationLoggingBackend.h"
#include "Widgets/QmitkUSNavigationProcessWidget.h"
#include "mitkNavigationDataRecorder.h"
#include "mitkNodeDisplacementFilter.h"
#include "mitkUSImageLoggingFilter.h"
#include <mitkMessage.h>
#include <mitkTextAnnotation2D.h>
#include <mitkUSCombinedModality.h>
+#include <mitkNavigationToolStorage.h>
namespace itk
{
template <class T>
class SmartPointer;
}
namespace mitk
{
class USNavigationStepTimer;
class USNavigationExperimentLogging;
}
namespace Ui
{
class USNavigationMarkerPlacement;
}
class QmitkUSAbstractNavigationStep;
class QmitkStdMultiWidget;
class QTimer;
class QSignalMapper;
/**
* \brief View for navigated marker placement using the combined modality.
* This view utilizes the QmitkUSNavigationProcessWidget to do the navigation
* process. It can be switched between widgets for marker placement and widgets
* for punctuation.
*
* An experiment mode allows for logging results, durations and the ultrasound
* images.
*/
class USNavigationMarkerPlacement : public QmitkAbstractView
{
Q_OBJECT
protected slots:
/**
* \brief Called periodically to update the rendering.
* The standard multi widget is changed to fit the navigation process once it
* is available and a reinit on the ultrasound image is done for a new image
* node.
*/
void OnTimeout();
/**
* \brief Called periodically during an experiment for logging the ultrasound images.
*/
void OnImageAndNavigationDataLoggingTimeout();
/**
* \brief Initializes anything neccessary for an experiment.
* The user is asked for a directory for storing the results and the logging
* is started.
*/
void OnStartExperiment();
/**
* \brief Stops logging and saves everything to the file system.
*/
void OnFinishExperiment();
void OnCombinedModalityChanged(itk::SmartPointer<mitk::USCombinedModality>);
/**
* \brief Switches the navigation step widgets if the navigation application was changed.
*/
void OnSettingsChanged(itk::SmartPointer<mitk::DataNode>);
/**
* \brief Updates the timer for the navigation steps durations every time the active navigation step changes.
*/
void OnActiveNavigationStepChanged(int);
/**
* \brief The data node is given to the experiment logging and scene is saved to the file system.
*/
void OnIntermediateResultProduced(const itk::SmartPointer<mitk::DataNode>);
void OnAddAblationZone(int size);
+ void OnEnableNavigationLayout();
+
+ void OnResetStandardLayout();
+
+ void OnChangeLayoutClicked();
+
void OnChangeAblationZone(int id, int newSize);
public:
static const char *DATANAME_TUMOUR;
static const char *DATANAME_TARGETSURFACE;
static const char *DATANAME_ZONES;
static const char *DATANAME_TARGETS;
static const char *DATANAME_TARGETS_PATHS;
static const char *DATANAME_REACHED_TARGETS;
explicit USNavigationMarkerPlacement();
~USNavigationMarkerPlacement();
virtual void CreateQtPartControl(QWidget *parent);
static const std::string VIEW_ID;
void OnCombinedModalityPropertyChanged(const std::string &, const std::string &);
+ /**
+ * \returns the point defining the needle axis in the tool storage
+ */
+ void SetToolAxisMarkerPlacement();
+ mitk::Point3D m_ToolAxis;
protected:
/**
* \brief A reinit on the ultrasound image is performed every time the view gets the focus.
*/
virtual void SetFocus();
/**
* \brief Helper function which performs a reinit on the ultrasound image.
*/
void ReinitOnImage();
/**
* \brief Helper function for being able to serialize the 2d ultrasound image.
*/
void Convert2DImagesTo3D(mitk::DataStorage::SetOfObjects::ConstPointer nodes);
void CreateOverlays();
QWidget *m_Parent;
QmitkUSNavigationProcessWidget::NavigationStepVector m_NavigationSteps;
QTimer *m_UpdateTimer;
QTimer *m_ImageAndNavigationDataLoggingTimer;
QmitkStdMultiWidget *m_StdMultiWidget;
itk::SmartPointer<mitk::USCombinedModality> m_CombinedModality;
bool m_ReinitAlreadyDone;
bool m_IsExperimentRunning;
std::string m_CurrentApplicationName;
itk::SmartPointer<mitk::USNavigationStepTimer> m_NavigationStepTimer;
itk::SmartPointer<mitk::USNavigationExperimentLogging> m_ExperimentLogging;
QPixmap m_IconRunning;
QPixmap m_IconNotRunning;
QString m_ResultsDirectory;
QString m_ExperimentName;
QString m_ExperimentResultsSubDirectory;
std::vector<QString>
m_NavigationStepNames; // stores the names of the navigation steps which are currently used (for logging purposes)
mitk::USNavigationLoggingBackend m_LoggingBackend;
mitk::USImageLoggingFilter::Pointer m_USImageLoggingFilter;
mitk::NavigationDataRecorder::Pointer m_NavigationDataRecorder; // records navigation data files
mitk::NodeDisplacementFilter::Pointer m_TargetNodeDisplacementFilter;
mitk::NodeDisplacementFilter::Pointer m_AblationZonesDisplacementFilter;
std::vector<mitk::DataNode::Pointer> m_AblationZonesVector;
int m_NeedleIndex;
int m_MarkerIndex;
int m_SceneNumber;
itk::SmartPointer<mitk::TextAnnotation2D> m_WarnOverlay;
+ //To get tool storage
+ mitk::NavigationDataSource::Pointer m_NavigationDataSource;
+ mitk::NavigationToolStorage::Pointer m_CurrentStorage;
+
private:
mitk::MessageDelegate2<USNavigationMarkerPlacement, const std::string &, const std::string &> m_ListenerDeviceChanged;
Ui::USNavigationMarkerPlacement *ui;
};
#endif // USNAVIGATIONMARKERPLACEMENT_H
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..0c35dfb245 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.igttracking/src/internal/IGTNavigationToolCalibration.cpp b/Plugins/org.mitk.gui.qt.igttracking/src/internal/IGTNavigationToolCalibration.cpp
index 21d1cfcc86..2780806cb0 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/IGTNavigationToolCalibration.cpp
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/IGTNavigationToolCalibration.cpp
@@ -1,636 +1,636 @@
/*===================================================================
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 <numeric>
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Qmitk
#include "IGTNavigationToolCalibration.h"
// mitk
#include <mitkNavigationToolWriter.h>
#include <mitkTrackingDeviceSource.h>
#include <mitkTrackingDevice.h>
#include <mitkTrackingTool.h>
#include <mitkQuaternionAveraging.h>
#include <mitkPivotCalibration.h>
#include <mitkNavigationData.h>
// Qt
#include <QMessageBox>
#include <qfiledialog.h>
//vtk
#include <vtkSphereSource.h>
const std::string IGTNavigationToolCalibration::VIEW_ID = "org.mitk.views.igtnavigationtoolcalibration";
IGTNavigationToolCalibration::IGTNavigationToolCalibration()
{}
IGTNavigationToolCalibration::~IGTNavigationToolCalibration()
{
//The following code is required due to a bug in the point list widget.
//If this is removed, MITK crashes when closing the view:
m_Controls.m_RegistrationLandmarkWidget->SetPointSetNode(nullptr);
m_Controls.m_CalibrationLandmarkWidget->SetPointSetNode(nullptr);
}
void IGTNavigationToolCalibration::SetFocus()
{
}
void IGTNavigationToolCalibration::OnToolCalibrationMethodChanged(int index)
{
//if pivot calibration (3) or manual(0) is chosen only calibration pointer is needed
if (index == 0 || index == 3) {
- if (!CheckInitialization(FALSE)) {
+ if (!CheckInitialization(false)) {
return;
}
}
else{
if (!CheckInitialization()) { return; }
}
UpdateManualToolTipCalibrationView();
m_Controls.m_CalibrationMethodsWidget->setCurrentIndex(index);
m_IndexCurrentCalibrationMethod = index;
}
void IGTNavigationToolCalibration::CreateQtPartControl(QWidget *parent)
{
//initialize manual tool editing widget
m_ManualToolTipEditWidget = new QmitkNavigationToolCreationAdvancedWidget(parent);
m_ManualToolTipEditWidget->setWindowFlags(Qt::Tool | Qt::WindowStaysOnTopHint);
m_ManualToolTipEditWidget->setWindowTitle("Edit Tool Tip Manually");
m_ManualToolTipEditWidget->setModal(false);
m_ManualToolTipEditWidget->SetDataStorage(this->GetDataStorage());
m_TrackingTimer = new QTimer(this);
// create GUI widgets from the Qt Designer's .ui file
m_Controls.setupUi(parent);
connect(m_Controls.m_SetToolToCalibrate, SIGNAL(clicked()), this, SLOT(SetToolToCalibrate()));
connect(m_Controls.m_SetPointer, SIGNAL(clicked()), this, SLOT(SetCalibrationPointer()));
connect(m_TrackingTimer, SIGNAL(timeout()), this, SLOT(UpdateTrackingTimer()));
connect(m_Controls.m_AddLandmark, SIGNAL(clicked()), this, SLOT(AddLandmark()));
connect(m_Controls.m_SaveCalibratedTool, SIGNAL(clicked()), this, SLOT(SaveCalibratedTool()));
connect(m_Controls.m_AddPivotPose, SIGNAL(clicked()), this, SLOT(OnAddPivotPose()));
connect(m_Controls.m_ComputePivot, SIGNAL(clicked()), this, SLOT(OnComputePivot()));
connect(m_Controls.m_UseComputedPivotPoint, SIGNAL(clicked()), this, SLOT(OnUseComputedPivotPoint()));
connect(m_Controls.m_StartEditTooltipManually, SIGNAL(clicked()), this, SLOT(OnStartManualToolTipCalibration()));
connect((QObject*)(m_ManualToolTipEditWidget), SIGNAL(RetrieveDataForManualToolTipManipulation()), this, SLOT(OnRetrieveDataForManualTooltipManipulation()));
connect((QObject*)(m_ManualToolTipEditWidget), SIGNAL(DialogCloseRequested()), this, SLOT(OnProcessManualTooltipEditDialogCloseRequest()));
connect(m_Controls.m_CalibrationMethodComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(OnToolCalibrationMethodChanged(int)));
connect((QObject*)(m_Controls.m_RunCalibrationButton), SIGNAL(clicked()), (QObject*) this, SLOT(OnRunSingleRefToolCalibrationClicked()));
connect((QObject*)(m_Controls.m_CollectNavigationDataButton), SIGNAL(clicked()), (QObject*) this, SLOT(OnLoginSingleRefToolNavigationDataClicked()));
connect((QObject*)(m_Controls.m_SetNewToolTipPosButton), SIGNAL(clicked()), (QObject*) this, SLOT(OnSetNewToolTipPosButtonClicked()));
m_IDToolToCalibrate = -1;
m_IDCalibrationPointer = -1;
m_IndexCurrentCalibrationMethod = -1;
m_OnLoginSingleRefToolNavigationDataClicked = false;
m_NumberOfNavigationDataCounter = 0;
m_NumberOfNavigationData = -1;
//for pivot calibration
m_OnAddPivotPoseClicked = false;
PivotCount = 0;
m_PivotPoses = std::vector<mitk::NavigationData::Pointer>();
m_CalibrationLandmarks = mitk::PointSet::New();
m_CalibrationLandmarksNode = mitk::DataNode::New();
m_CalibrationLandmarksNode->SetData(m_CalibrationLandmarks);
m_Controls.m_CalibrationLandmarkWidget->SetPointSetNode(m_CalibrationLandmarksNode);
m_RegistrationLandmarks = mitk::PointSet::New();
m_RegistrationLandmarksNode = mitk::DataNode::New();
m_RegistrationLandmarksNode->SetData(m_RegistrationLandmarks);
m_Controls.m_RegistrationLandmarkWidget->SetPointSetNode(m_RegistrationLandmarksNode);
m_ToolSurfaceInToolCoordinatesDataNode = mitk::DataNode::New();
m_ToolSurfaceInToolCoordinatesDataNode->SetName("ToolSurface(ToolCoordinates)");
m_LoggedNavigationDataDifferences = std::vector< mitk::NavigationData::Pointer >();
}
void IGTNavigationToolCalibration::OnRunSingleRefToolCalibrationClicked()
{
if (!CheckInitialization()) { return; }
mitk::NavigationData::Pointer ToolTipTransform = mitk::NavigationData::New();
if (m_Controls.m_CalibratePosition->isChecked())
{
//1: Compute mean translational offset vector
m_ResultOffsetVector.Fill(0);
for (std::vector<mitk::Point3D>::iterator vecIter = m_LoggedNavigationDataOffsets.begin(); vecIter != m_LoggedNavigationDataOffsets.end(); vecIter++)
{
m_ResultOffsetVector[0] = m_ResultOffsetVector[0] + (*vecIter)[0];
m_ResultOffsetVector[1] = m_ResultOffsetVector[1] + (*vecIter)[1];
m_ResultOffsetVector[2] = m_ResultOffsetVector[2] + (*vecIter)[2];
}
m_ResultOffsetVector[0] = m_ResultOffsetVector[0] / m_LoggedNavigationDataOffsets.size();
m_ResultOffsetVector[1] = m_ResultOffsetVector[1] / m_LoggedNavigationDataOffsets.size();
m_ResultOffsetVector[2] = m_ResultOffsetVector[2] / m_LoggedNavigationDataOffsets.size();
this->m_Controls.m_ResultOfCalibration->setText(
QString("x: ") + QString(QString::number(m_ResultOffsetVector[0], 103, 3)) +
QString("; y: ") + (QString::number(m_ResultOffsetVector[1], 103, 3)) +
QString("; z: ") + (QString::number(m_ResultOffsetVector[2], 103, 3)));
ToolTipTransform->SetPosition(m_ResultOffsetVector);
}
if (m_Controls.m_CalibrateOrientation->isChecked())
{
//2: Compute mean orientation
mitk::Quaternion meanOrientation;
std::vector <mitk::Quaternion> allOrientations = std::vector <mitk::Quaternion>();
for (int i = 0; i < m_LoggedNavigationDataDifferences.size(); i++) { allOrientations.push_back(m_LoggedNavigationDataDifferences.at(i)->GetOrientation()); }
meanOrientation = mitk::QuaternionAveraging::CalcAverage(allOrientations);
this->m_Controls.m_ResultOfCalibrationOrientation->setText(
QString("qx: ") + QString(QString::number(meanOrientation.x(), 103, 3)) +
QString("; qy: ") + (QString::number(meanOrientation.y(), 103, 3)) +
QString("; qz: ") + (QString::number(meanOrientation.z(), 103, 3)) +
QString("; qr: ") + (QString::number(meanOrientation.r(), 103, 3)));
ToolTipTransform->SetOrientation(meanOrientation);
}
MITK_INFO << "Computed calibration: ";
MITK_INFO << "Translation Vector: " << ToolTipTransform->GetPosition();
MITK_INFO << "Quaternion: (" << ToolTipTransform->GetOrientation() << ")";
MITK_INFO << "Euler Angles [rad]: (" << ToolTipTransform->GetOrientation().rotation_euler_angles() << ")";
MITK_INFO << "Matrix:";
vnl_matrix_fixed<double, 3, 3> rotMatrix = ToolTipTransform->GetOrientation().rotation_matrix_transpose();
MITK_INFO << rotMatrix[0][0] << " " << rotMatrix[0][1] << " " << rotMatrix[0][2] << std::endl;
MITK_INFO << rotMatrix[1][0] << " " << rotMatrix[1][1] << " " << rotMatrix[1][2] << std::endl;
MITK_INFO << rotMatrix[2][0] << " " << rotMatrix[2][1] << " " << rotMatrix[2][2] << std::endl;
//3: write everything into the final tool tip transform and save it as member (it will be written to the tool later on)
mitk::NavigationData::Pointer ToolTipInTrackingCoordinates = mitk::NavigationData::New();
ToolTipInTrackingCoordinates->Compose(ToolTipTransform);
ToolTipInTrackingCoordinates->Compose(m_NavigationDataSourceOfToolToCalibrate->GetOutput(m_IDToolToCalibrate));
ShowToolTipPreview(ToolTipInTrackingCoordinates);
m_Controls.m_SetNewToolTipPosButton->setEnabled(true);
m_ComputedToolTipTransformation = ToolTipTransform;
}
void IGTNavigationToolCalibration::OnLoginSingleRefToolNavigationDataClicked()
{
if (!CheckInitialization()) { return; }
m_OnLoginSingleRefToolNavigationDataClicked = true;
m_Controls.m_CollectNavigationDataButton->setEnabled(false);
m_NumberOfNavigationData = m_Controls.m_NumberOfNavigationDataToCollect->value();
MITK_INFO << "Collecting " << m_NumberOfNavigationData << " NavigationData ... " << endl;
}
void IGTNavigationToolCalibration::LoginSingleRefToolNavigationData()
{
if (!CheckInitialization()) { return; }
if (m_NumberOfNavigationDataCounter < m_NumberOfNavigationData)
{
//update label text
QString labelText = "Collecting Data: " + QString::number(m_NumberOfNavigationDataCounter);
m_Controls.m_CollectionStatus->setText(labelText);
mitk::NavigationData::Pointer referenceTool = m_NavigationDataSourceOfCalibrationPointer->GetOutput(m_IDCalibrationPointer);
mitk::NavigationData::Pointer toolToCalibrate = m_NavigationDataSourceOfToolToCalibrate->GetOutput(m_IDToolToCalibrate);
//compute difference:
// differenceND = toolToCalibrate^-1 * referenceTool
mitk::NavigationData::Pointer differenceND = mitk::NavigationData::New();
differenceND->Compose(referenceTool);
differenceND->Compose(toolToCalibrate->GetInverse());
//inverse mode...
if (m_Controls.m_InvertQuaternions->isChecked())
{
// negate identity matrix to directly show parameters that will set up in NDI 6D Software Architect
differenceND = differenceND->GetInverse();
}
//save difference in member
m_LoggedNavigationDataOffsets.push_back(differenceND->GetPosition());
m_LoggedNavigationDataDifferences.push_back(differenceND);
m_NumberOfNavigationDataCounter++;
}
if (m_NumberOfNavigationDataCounter == m_NumberOfNavigationData)
{
m_NumberOfNavigationDataCounter = 0;
m_OnLoginSingleRefToolNavigationDataClicked = false;
m_Controls.m_CollectNavigationDataButton->setEnabled(true);
m_Controls.m_RunCalibrationButton->setEnabled(true);
MITK_INFO << "Collecting " << m_NumberOfNavigationData << " NavigationData ... Finished" << endl;
QString labelText = "Collected " + QString::number(m_NumberOfNavigationData) + " data samples!";
m_Controls.m_CollectionStatus->setText(labelText);
}
}
void IGTNavigationToolCalibration::OnSetNewToolTipPosButtonClicked()
{
ApplyToolTipTransform(m_ComputedToolTipTransformation);
RemoveToolTipPreview();
}
void IGTNavigationToolCalibration::ClearOldPivot()
{
mitk::NavigationData::Pointer tempND = mitk::NavigationData::New();
this->ApplyToolTipTransform(tempND);
UpdateManualToolTipCalibrationView();
m_ManualToolTipEditWidget->hide();
this->GetDataStorage()->Remove(m_ToolSurfaceInToolCoordinatesDataNode);
}
void IGTNavigationToolCalibration::OnAddPivotPose()
{
ClearOldPivot();
//When the collect Poses Button is Clicked
m_OnAddPivotPoseClicked = true;
m_NumberOfNavigationData = m_Controls.m_PosesToCollect->value();
}
void IGTNavigationToolCalibration::AddPivotPose()
{
//Save the poses to be used in computation
if (PivotCount < m_NumberOfNavigationData)
{
mitk::NavigationData::Pointer currentPose = mitk::NavigationData::New();
currentPose->Graft(m_Controls.m_SelectionWidget->GetSelectedNavigationDataSource()->GetOutput(m_IDToolToCalibrate));
m_PivotPoses.push_back(currentPose);
m_Controls.m_PoseNumber->setText(QString::number(m_PivotPoses.size()));
PivotCount++;
}
if (PivotCount == m_NumberOfNavigationData)
{
m_OnAddPivotPoseClicked = false;
}
}
void IGTNavigationToolCalibration::OnComputePivot()
{
mitk::PivotCalibration::Pointer myPivotCalibration = mitk::PivotCalibration::New();
for (int i = 0; i < this->m_PivotPoses.size(); i++)
{
myPivotCalibration->AddNavigationData(m_PivotPoses.at(i));
}
QString resultString;
if (myPivotCalibration->ComputePivotResult())
{
mitk::NavigationData::Pointer markerTransformationTrackingCoordinates = m_PivotPoses.at(0);
//Get computed pivot transfromation in tool coordinates
mitk::NavigationData::Pointer ToolTipToTool = mitk::NavigationData::New();
ToolTipToTool->SetPosition(myPivotCalibration->GetResultPivotPoint());
ToolTipToTool->SetOrientation(myPivotCalibration->GetResultPivotRotation());
mitk::NavigationData::Pointer TrackerToTool = mitk::NavigationData::New();
TrackerToTool->SetOrientation(markerTransformationTrackingCoordinates->GetOrientation());
TrackerToTool->SetPosition(markerTransformationTrackingCoordinates->GetPosition());
TrackerToTool->Compose(ToolTipToTool);
// Compute pivot point in relation to marker transformation for preview
mitk::NavigationData::Pointer ToolTipToTracker = mitk::NavigationData::New();
ToolTipToTracker->Compose(ToolTipToTool);
ToolTipToTracker->Compose(markerTransformationTrackingCoordinates);
//add the preview node to the data storage
ShowToolTipPreview(ToolTipToTracker);
//parse result string
resultString = QString("Pivot computation succeeded!\n")
+ QString("RMS Error: ") + QString::number(myPivotCalibration->GetResultRMSError()) + QString("\n")
+ QString("Pivot Point: ") + QString::number(myPivotCalibration->GetResultPivotPoint()[0]) + ";" + QString::number(myPivotCalibration->GetResultPivotPoint()[1]) + ";" + QString::number(myPivotCalibration->GetResultPivotPoint()[2]) + QString("\n")
+ QString("Pivot Rotation: ") + QString::number(myPivotCalibration->GetResultPivotRotation()[0]) + ";" + QString::number(myPivotCalibration->GetResultPivotRotation()[1]) + ";" + QString::number(myPivotCalibration->GetResultPivotRotation()[2]) + ";" + QString::number(myPivotCalibration->GetResultPivotRotation()[3]) + QString("\n");
//finally: save results to member variable
m_ComputedToolTipTransformation = ToolTipToTool;
//enable button to use the computed point with the tool
m_Controls.m_UseComputedPivotPoint->setEnabled(true);
}
else
{
resultString = "Pivot computation failed!";
}
MITK_INFO << resultString.toStdString().c_str();
m_Controls.m_ResultText->setText(resultString);
}
void IGTNavigationToolCalibration::UpdatePivotCount()
{
PivotCount = 0;
while (!m_PivotPoses.empty())
{
m_PivotPoses.pop_back();
}
m_Controls.m_PoseNumber->setText(QString::number(PivotCount));
}
void IGTNavigationToolCalibration::OnUseComputedPivotPoint()
{
RemoveToolTipPreview();
QString resultString = QString("Pivoted tool tip transformation was written to the tool ") + m_ToolToCalibrate->GetToolName().c_str();
ApplyToolTipTransform(m_ComputedToolTipTransformation, resultString.toStdString());
m_Controls.m_ResultText->setText(resultString);
UpdatePivotCount();
}
void IGTNavigationToolCalibration::ApplyToolTipTransform(mitk::NavigationData::Pointer ToolTipTransformInToolCoordinates, std::string message)
{
if (!CheckInitialization(false)) { return; }
//Update tool in tool storage
m_ToolToCalibrate->SetToolTipPosition(ToolTipTransformInToolCoordinates->GetPosition());
m_ToolToCalibrate->SetToolTipOrientation(ToolTipTransformInToolCoordinates->GetOrientation());
//And also update tracking device, so the transform is directly used
mitk::TrackingDeviceSource::Pointer trackingDeviceSource;
try
{
trackingDeviceSource = dynamic_cast<mitk::TrackingDeviceSource*>(m_NavigationDataSourceOfToolToCalibrate.GetPointer());
mitk::TrackingTool::Pointer TrackingToolToCalibrate = trackingDeviceSource->GetTrackingDevice()->GetTool(m_IDToolToCalibrate);
TrackingToolToCalibrate->SetToolTip(ToolTipTransformInToolCoordinates->GetPosition(), ToolTipTransformInToolCoordinates->GetOrientation());
}
catch (std::exception& e)
{
MITK_ERROR << "Error while trying to set the tool tip to the running tracking device. Aborting! (" << e.what() << ")";
}
MITK_INFO << message;
}
void IGTNavigationToolCalibration::ShowToolTipPreview(mitk::NavigationData::Pointer ToolTipInTrackingCoordinates)
{
mitk::DataNode::Pointer m_ToolTipPointPreview = mitk::DataNode::New();
m_ToolTipPointPreview->SetName("Modified Tool Tip Preview");
mitk::Color blue;
blue.SetBlue(1);
m_ToolTipPointPreview->SetColor(blue);
mitk::Surface::Pointer mySphere = mitk::Surface::New();
vtkSphereSource *vtkData = vtkSphereSource::New();
vtkData->SetRadius(3.0f);
vtkData->SetCenter(0.0, 0.0, 0.0);
vtkData->Update();
mySphere->SetVtkPolyData(vtkData->GetOutput());
vtkData->Delete();
m_ToolTipPointPreview->SetData(mySphere);
m_ToolTipPointPreview->GetData()->GetGeometry()->SetIndexToWorldTransform(ToolTipInTrackingCoordinates->GetAffineTransform3D());
this->GetDataStorage()->Add(m_ToolTipPointPreview);
}
void IGTNavigationToolCalibration::RemoveToolTipPreview()
{
this->GetDataStorage()->Remove(m_ToolTipPointPreview.GetPointer());
}
void IGTNavigationToolCalibration::UpdateManualToolTipCalibrationView()
{
if (m_ToolToCalibrate.IsNull()) { return; }
//parse human readable transformation data and display it
std::stringstream translation;
std::stringstream orientation;
translation << m_ToolToCalibrate->GetToolTipPosition();
orientation << "Quaternion: (" << m_ToolToCalibrate->GetToolTipOrientation() << ")" << std::endl;
orientation << std::endl;
orientation << "Euler Angles [rad]: (" << m_ToolToCalibrate->GetToolTipOrientation().rotation_euler_angles() << ")" << std::endl;
orientation << std::endl;
orientation << "Matrix:" << std::endl;
vnl_matrix_fixed<double, 3, 3> rotMatrix = m_ToolToCalibrate->GetToolTipOrientation().rotation_matrix_transpose();
orientation << rotMatrix[0][0] << " " << rotMatrix[0][1] << " " << rotMatrix[0][2] << std::endl;
orientation << rotMatrix[1][0] << " " << rotMatrix[1][1] << " " << rotMatrix[1][2] << std::endl;
orientation << rotMatrix[2][0] << " " << rotMatrix[2][1] << " " << rotMatrix[2][2] << std::endl;
m_Controls.m_ManualCurrentTranslation->setText(translation.str().c_str());
m_Controls.m_ManualCurrentOrientation->setPlainText(orientation.str().c_str());
}
void IGTNavigationToolCalibration::OnStartManualToolTipCalibration()
{
if (!CheckInitialization(false)) { return; }
m_ManualToolTipEditWidget->SetToolTipSurface(false, m_ToolToCalibrate->GetDataNode());
m_ManualToolTipEditWidget->show();
m_ManualToolTipEditWidget->SetDefaultTooltip(m_ToolToCalibrate->GetToolTipTransform());
m_ManualToolTipEditWidget->ReInitialize();
}
void IGTNavigationToolCalibration::OnRetrieveDataForManualTooltipManipulation()
{
this->GetDataStorage()->Add(m_ToolSurfaceInToolCoordinatesDataNode);
m_ManualToolTipEditWidget->SetToolTipSurface(false, m_ToolSurfaceInToolCoordinatesDataNode);
}
void IGTNavigationToolCalibration::OnProcessManualTooltipEditDialogCloseRequest()
{
mitk::NavigationData::Pointer tempND = mitk::NavigationData::New(m_ManualToolTipEditWidget->GetManipulatedToolTip());
this->ApplyToolTipTransform(tempND);
UpdateManualToolTipCalibrationView();
m_ManualToolTipEditWidget->hide();
this->GetDataStorage()->Remove(m_ToolSurfaceInToolCoordinatesDataNode);
}
void IGTNavigationToolCalibration::SetToolToCalibrate()
{
m_IDToolToCalibrate = m_Controls.m_SelectionWidget->GetSelectedToolID();
m_ToolToCalibrate = m_Controls.m_SelectionWidget->GetSelectedNavigationTool();
if (m_IDToolToCalibrate == -1) //no valid tool to calibrate
{
m_Controls.m_CalToolLabel->setText("<none>");
m_Controls.m_StatusWidgetToolToCalibrate->RemoveStatusLabels();
m_TrackingTimer->stop();
}
else
{
m_NavigationDataSourceOfToolToCalibrate = m_Controls.m_SelectionWidget->GetSelectedNavigationDataSource();
m_Controls.m_CalToolLabel->setText(m_NavigationDataSourceOfToolToCalibrate->GetOutput(m_IDToolToCalibrate)->GetName());
//initialize widget
m_Controls.m_StatusWidgetToolToCalibrate->RemoveStatusLabels();
m_Controls.m_StatusWidgetToolToCalibrate->SetShowPositions(true);
m_Controls.m_StatusWidgetToolToCalibrate->SetTextAlignment(Qt::AlignLeft);
m_Controls.m_StatusWidgetToolToCalibrate->AddNavigationData(m_NavigationDataSourceOfToolToCalibrate->GetOutput(m_IDToolToCalibrate));
m_Controls.m_StatusWidgetToolToCalibrate->ShowStatusLabels();
//initialize manual tool tip calibration view
UpdateManualToolTipCalibrationView();
//save tool surface in tool coordinates for further editing
mitk::Surface::Pointer ToolSurface = dynamic_cast<mitk::Surface*>(m_ToolToCalibrate->GetDataNode()->GetData())->Clone();
m_ToolSurfaceInToolCoordinatesDataNode->SetData(ToolSurface);
m_ToolSurfaceInToolCoordinatesDataNode->GetData()->GetGeometry()->SetIdentity();
//start updating timer for status widgets, etc.
if (!m_TrackingTimer->isActive()) m_TrackingTimer->start(100);
}
}
void IGTNavigationToolCalibration::SetCalibrationPointer()
{
m_IDCalibrationPointer = m_Controls.m_SelectionWidget->GetSelectedToolID();
m_NavigationDataSourceOfCalibrationPointer = m_Controls.m_SelectionWidget->GetSelectedNavigationDataSource();
if (m_IDCalibrationPointer == -1)
{
m_Controls.m_PointerLabel->setText("<none>");
m_Controls.m_StatusWidgetCalibrationPointer->RemoveStatusLabels();
m_TrackingTimer->stop();
}
else
{
m_Controls.m_PointerLabel->setText(m_NavigationDataSourceOfCalibrationPointer->GetOutput(m_IDCalibrationPointer)->GetName());
//initialize widget
m_Controls.m_StatusWidgetCalibrationPointer->RemoveStatusLabels();
m_Controls.m_StatusWidgetCalibrationPointer->SetShowPositions(true);
m_Controls.m_StatusWidgetCalibrationPointer->SetTextAlignment(Qt::AlignLeft);
m_Controls.m_StatusWidgetCalibrationPointer->AddNavigationData(m_NavigationDataSourceOfCalibrationPointer->GetOutput(m_IDCalibrationPointer));
m_Controls.m_StatusWidgetCalibrationPointer->ShowStatusLabels();
if (!m_TrackingTimer->isActive()) m_TrackingTimer->start(100);
}
}
void IGTNavigationToolCalibration::UpdateOffsetCoordinates()
{
if (m_NavigationDataSourceOfCalibrationPointer.IsNull() || m_NavigationDataSourceOfToolToCalibrate.IsNull())
{
return;
}
mitk::NavigationData::Pointer referenceToolND = m_NavigationDataSourceOfCalibrationPointer->GetOutput(m_IDCalibrationPointer);
mitk::NavigationData::Pointer toolToCalibrateND = m_NavigationDataSourceOfToolToCalibrate->GetOutput(m_IDToolToCalibrate);
if (referenceToolND->IsDataValid() && toolToCalibrateND->IsDataValid())
{
//computation: difference between both tools (in tool coordinates)
//differenceND = toolToCalibrateND^-1 * referenceToolND
mitk::NavigationData::Pointer differenceND = mitk::NavigationData::New();
differenceND->Compose(referenceToolND);
differenceND->Compose(toolToCalibrateND->GetInverse());
//display this orientation in the UI
m_Controls.m_OffsetCoordinates->setText(
QString("x: ") + QString(QString::number(differenceND->GetPosition()[0], 103, 3)) +
QString("; y: ") + (QString::number(differenceND->GetPosition()[1], 103, 3)) +
QString("; z: ") + (QString::number(differenceND->GetPosition()[2], 103, 3)));
m_Controls.m_OrientationOffsetCoordinates->setText(
QString("qx: ") + QString(QString::number(differenceND->GetOrientation().x(), 103, 3)) +
QString("; qy: ") + (QString::number(differenceND->GetOrientation().y(), 103, 3)) +
QString("; qz: ") + (QString::number(differenceND->GetOrientation().z(), 103, 3)) +
QString("; qr: ") + (QString::number(differenceND->GetOrientation().r(), 103, 3)));
//also update preview if active
if (m_ToolTipPointPreview.IsNotNull()) //NOT WORKING! TODO: fix or remove!
{
mitk::NavigationData::Pointer ToolTipTransform = mitk::NavigationData::New();
ToolTipTransform->SetPosition(m_ResultOffsetVector);
mitk::NavigationData::Pointer ToolTipInTrackingCoordinates = mitk::NavigationData::New(); //maybe store as for better peformance...
ToolTipInTrackingCoordinates->Compose(m_NavigationDataSourceOfToolToCalibrate->GetOutput(m_IDToolToCalibrate));
ToolTipInTrackingCoordinates->Compose(ToolTipTransform);
m_ToolTipPointPreview->GetData()->GetGeometry()->SetIndexToWorldTransform(ToolTipInTrackingCoordinates->GetAffineTransform3D());
}
}
}
void IGTNavigationToolCalibration::UpdateTrackingTimer()
{
m_Controls.m_StatusWidgetToolToCalibrate->Refresh();
m_Controls.m_StatusWidgetCalibrationPointer->Refresh();
if (m_OnLoginSingleRefToolNavigationDataClicked) LoginSingleRefToolNavigationData();
if (m_OnAddPivotPoseClicked) AddPivotPose();
// 1 == Single Reference Calibration Method
if (m_IndexCurrentCalibrationMethod == 1) UpdateOffsetCoordinates();
}
void IGTNavigationToolCalibration::AddLandmark()
{
if (!CheckInitialization()) { return; }
mitk::NavigationData::Pointer navDataTool = m_NavigationDataSourceOfToolToCalibrate->GetOutput(m_IDToolToCalibrate);
mitk::Point3D landmark = m_NavigationDataSourceOfCalibrationPointer->GetOutput(m_IDCalibrationPointer)->GetPosition();
//convert to itk transform
itk::Vector<double, 3> translation;
for (int k = 0; k < 3; k++) translation[k] = navDataTool->GetPosition()[k];
itk::Matrix<double, 3, 3> rotation;
for (int k = 0; k < 3; k++) for (int l = 0; l < 3; l++) rotation[k][l] = navDataTool->GetOrientation().rotation_matrix_transpose()[k][l];
rotation = rotation.GetTranspose();
itk::Vector<double> landmarkItk;
landmarkItk[0] = landmark[0];
landmarkItk[1] = landmark[1];
landmarkItk[2] = landmark[2];
//compute landmark in tool coordinates
itk::Matrix<double, 3, 3> rotationInverse;
for (int k = 0; k < 3; k++) for (int l = 0; l < 3; l++) rotationInverse[k][l] = rotation.GetInverse()[k][l];
landmarkItk = rotationInverse * (landmarkItk - translation);
//convert back and add landmark to pointset
landmark[0] = landmarkItk[0];
landmark[1] = landmarkItk[1];
landmark[2] = landmarkItk[2];
m_RegistrationLandmarks->InsertPoint(m_RegistrationLandmarks->GetSize(), landmark);
}
void IGTNavigationToolCalibration::SaveCalibratedTool()
{
if (m_ToolToCalibrate.IsNotNull())
{
mitk::NavigationTool::Pointer calibratedTool = m_ToolToCalibrate;
calibratedTool->SetToolCalibrationLandmarks(this->m_CalibrationLandmarks);
calibratedTool->SetToolRegistrationLandmarks(this->m_RegistrationLandmarks);
mitk::NavigationToolWriter::Pointer myWriter = mitk::NavigationToolWriter::New();
std::string filename = QFileDialog::getSaveFileName(nullptr,tr("Save Navigation Tool"), "/", "*.IGTTool").toUtf8().data();
filename.append(".IGTTool");
if (filename == "") return;
if (myWriter->DoWrite(filename, calibratedTool)) MITK_INFO << "Saved calibrated tool to file " << filename;
else MITK_WARN << "Can't write tool to file " << filename;
}
else
{
MITK_ERROR << "Did not find navigation tool storage of calibrated tool, aborting!";
}
}
bool IGTNavigationToolCalibration::CheckInitialization(bool CalibrationPointerRequired)
{
if ((m_IDToolToCalibrate == -1) ||
((CalibrationPointerRequired) &&
(m_IDCalibrationPointer == -1)
)
)
{
QMessageBox msgBox;
msgBox.setText("Tool to calibrate and/or calibration pointer not initialized, cannot proceed!");
msgBox.exec();
return false;
}
else { return true; }
}
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
index 5665af9590..570df2261a 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
@@ -1,1468 +1,1460 @@
/*===================================================================
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 "QmitkMITKIGTTrackingToolboxView.h"
#include "QmitkTrackingDeviceConfigurationWidget.h"
// Qt
#include <QMessageBox>
#include <QSettings>
#include <qfiledialog.h>
// MITK
#include <mitkNavigationToolStorageDeserializer.h>
#include <mitkTrackingDeviceSourceConfigurator.h>
#include <mitkTrackingVolumeGenerator.h>
#include <mitkNDITrackingDevice.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateProperty.h>
#include <mitkNavigationToolStorageSerializer.h>
//#include <mitkProgressBar.h>
#include <mitkIOUtil.h>
#include <mitkLog.h>
#include <usModule.h>
#include <mitkTrackingDeviceTypeCollection.h>
#include <mitkUnspecifiedTrackingTypeInformation.h>
#include "mitkNDIAuroraTypeInformation.h"
// vtk
#include <vtkSphereSource.h>
//for exceptions
#include <mitkIGTException.h>
#include <mitkIGTIOException.h>
//for Microservice
#include "mitkPluginActivator.h"
#include <usModuleContext.h>
#include <usGetModuleContext.h>
#include "usServiceReference.h"
const std::string QmitkMITKIGTTrackingToolboxView::VIEW_ID = "org.mitk.views.mitkigttrackingtoolbox";
QmitkMITKIGTTrackingToolboxView::QmitkMITKIGTTrackingToolboxView()
: QmitkAbstractView()
, m_Controls(nullptr)
, m_DeviceTypeCollection(nullptr)
{
m_TrackingLoggingTimer = new QTimer(this);
m_TrackingRenderTimer = new QTimer(this);
m_TimeoutTimer = new QTimer(this);
m_tracking = false;
m_connected = false;
m_logging = false;
m_loggedFrames = 0;
m_SimpleModeEnabled = false;
//create filename for autosaving of tool storage
QString loggingPathWithoutFilename = QString(mitk::LoggingBackend::GetLogFile().c_str());
if (!loggingPathWithoutFilename.isEmpty()) //if there already is a path for the MITK logging file use this one
{
//extract path from path+filename (if someone knows a better way to do this feel free to change it)
int lengthOfFilename = QFileInfo(QString::fromStdString(mitk::LoggingBackend::GetLogFile())).fileName().size();
loggingPathWithoutFilename.resize(loggingPathWithoutFilename.size() - lengthOfFilename);
m_AutoSaveFilename = loggingPathWithoutFilename + "TrackingToolboxAutoSave.IGTToolStorage";
}
else //if not: use a temporary path from IOUtil
{
m_AutoSaveFilename = QString(mitk::IOUtil::GetTempPath().c_str()) + "TrackingToolboxAutoSave.IGTToolStorage";
}
MITK_INFO("IGT Tracking Toolbox") << "Filename for auto saving of IGT ToolStorages: " << m_AutoSaveFilename.toStdString();
//! [Thread 1]
//initialize worker thread
m_WorkerThread = new QThread();
m_Worker = new QmitkMITKIGTTrackingToolboxViewWorker();
//! [Thread 1]
ctkPluginContext* pluginContext = mitk::PluginActivator::GetContext();
if (pluginContext)
{
QString interfaceName = QString::fromStdString(us_service_interface_iid<mitk::TrackingDeviceTypeCollection>());
QList<ctkServiceReference> serviceReference = pluginContext->getServiceReferences(interfaceName);
if (serviceReference.size() > 0)
{
m_DeviceTypeServiceReference = serviceReference.at(0);
const ctkServiceReference& r = serviceReference.at(0);
m_DeviceTypeCollection = pluginContext->getService<mitk::TrackingDeviceTypeCollection>(r);
}
else
{
MITK_INFO << "No Tracking Device Collection!";
}
}
}
QmitkMITKIGTTrackingToolboxView::~QmitkMITKIGTTrackingToolboxView()
{
this->StoreUISettings();
m_TrackingLoggingTimer->stop();
m_TrackingRenderTimer->stop();
m_TimeoutTimer->stop();
delete m_TrackingLoggingTimer;
delete m_TrackingRenderTimer;
delete m_TimeoutTimer;
try
{
//! [Thread 2]
// wait for thread to finish
m_WorkerThread->terminate();
m_WorkerThread->wait();
//clean up worker thread
if (m_WorkerThread) { delete m_WorkerThread; }
if (m_Worker) { delete m_Worker; }
//! [Thread 2]
//remove the tracking volume
this->GetDataStorage()->Remove(m_TrackingVolumeNode);
//unregister microservices
if (m_toolStorage) { m_toolStorage->UnRegisterMicroservice(); }
if (m_TrackingDeviceSource) { m_TrackingDeviceSource->UnRegisterMicroservice(); }
if (m_IGTLMessageProvider.IsNotNull()){ m_IGTLMessageProvider->UnRegisterMicroservice(); }
}
catch (std::exception& e) { MITK_WARN << "Unexpected exception during clean up of tracking toolbox view: " << e.what(); }
catch (...) { MITK_WARN << "Unexpected unknown error during clean up of tracking toolbox view!"; }
//store tool storage and UI settings for persistence
this->AutoSaveToolStorage();
this->StoreUISettings();
m_DeviceTypeCollection = nullptr;
mitk::PluginActivator::GetContext()->ungetService(m_DeviceTypeServiceReference);
}
void QmitkMITKIGTTrackingToolboxView::CreateQtPartControl(QWidget *parent)
{
// build up qt view, unless already done
if (!m_Controls)
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls = new Ui::QmitkMITKIGTTrackingToolboxViewControls;
m_Controls->setupUi(parent);
//create connections
connect(m_Controls->m_LoadTools, SIGNAL(clicked()), this, SLOT(OnLoadTools()));
connect(m_Controls->m_ConnectDisconnectButton, SIGNAL(clicked()), this, SLOT(OnConnectDisconnect()));
connect(m_Controls->m_StartStopTrackingButton, SIGNAL(clicked()), this, SLOT(OnStartStopTracking()));
connect(m_Controls->m_ConnectSimpleMode, SIGNAL(clicked()), this, SLOT(OnConnectDisconnect()));
connect(m_Controls->m_StartTrackingSimpleMode, SIGNAL(clicked()), this, SLOT(OnStartStopTracking()));
connect(m_Controls->m_FreezeUnfreezeTrackingButton, SIGNAL(clicked()), this, SLOT(OnFreezeUnfreezeTracking()));
connect(m_TrackingLoggingTimer, SIGNAL(timeout()), this, SLOT(UpdateLoggingTrackingTimer()));
connect(m_TrackingRenderTimer, SIGNAL(timeout()), this, SLOT(UpdateRenderTrackingTimer()));
connect(m_TimeoutTimer, SIGNAL(timeout()), this, SLOT(OnTimeOut()));
connect(m_Controls->m_ChooseFile, SIGNAL(clicked()), this, SLOT(OnChooseFileClicked()));
connect(m_Controls->m_StartLogging, SIGNAL(clicked()), this, SLOT(StartLogging()));
connect(m_Controls->m_StopLogging, SIGNAL(clicked()), this, SLOT(StopLogging()));
connect(m_Controls->m_VolumeSelectionBox, SIGNAL(currentIndexChanged(QString)), this, SLOT(OnTrackingVolumeChanged(QString)));
connect(m_Controls->m_ShowTrackingVolume, SIGNAL(clicked()), this, SLOT(OnShowTrackingVolumeChanged()));
connect(m_Controls->m_AutoDetectTools, SIGNAL(clicked()), this, SLOT(OnAutoDetectTools()));
connect(m_Controls->m_ResetTools, SIGNAL(clicked()), this, SLOT(OnResetTools()));
connect(m_Controls->m_AddSingleTool, SIGNAL(clicked()), this, SLOT(OnAddSingleTool()));
connect(m_Controls->m_NavigationToolCreationWidget, SIGNAL(NavigationToolFinished()), this, SLOT(OnAddSingleToolFinished()));
connect(m_Controls->m_NavigationToolCreationWidget, SIGNAL(Canceled()), this, SLOT(OnAddSingleToolCanceled()));
connect(m_Controls->m_csvFormat, SIGNAL(clicked()), this, SLOT(OnToggleFileExtension()));
connect(m_Controls->m_xmlFormat, SIGNAL(clicked()), this, SLOT(OnToggleFileExtension()));
connect(m_Controls->m_UseDifferentUpdateRates, SIGNAL(clicked()), this, SLOT(OnToggleDifferentUpdateRates()));
connect(m_Controls->m_RenderUpdateRate, SIGNAL(valueChanged(int)), this, SLOT(OnChangeRenderUpdateRate()));
connect(m_Controls->m_DisableAllTimers, SIGNAL(stateChanged(int)), this, SLOT(EnableDisableTimerButtons(int)));
connect(m_Controls->m_advancedUI, SIGNAL(clicked()), this, SLOT(OnToggleAdvancedSimpleMode()));
connect(m_Controls->m_simpleUI, SIGNAL(clicked()), this, SLOT(OnToggleAdvancedSimpleMode()));
//connections for the tracking device configuration widget
connect(m_Controls->m_configurationWidget, SIGNAL(TrackingDeviceSelectionChanged()), this, SLOT(OnTrackingDeviceChanged()));
//! [Thread 3]
//connect worker thread
connect(m_Worker, SIGNAL(AutoDetectToolsFinished(bool, QString)), this, SLOT(OnAutoDetectToolsFinished(bool, QString)));
connect(m_Worker, SIGNAL(ConnectDeviceFinished(bool, QString)), this, SLOT(OnConnectFinished(bool, QString)));
connect(m_Worker, SIGNAL(StartTrackingFinished(bool, QString)), this, SLOT(OnStartTrackingFinished(bool, QString)));
connect(m_Worker, SIGNAL(StopTrackingFinished(bool, QString)), this, SLOT(OnStopTrackingFinished(bool, QString)));
connect(m_Worker, SIGNAL(DisconnectDeviceFinished(bool, QString)), this, SLOT(OnDisconnectFinished(bool, QString)));
connect(m_WorkerThread, SIGNAL(started()), m_Worker, SLOT(ThreadFunc()));
//move the worker to the thread
m_Worker->moveToThread(m_WorkerThread);
//! [Thread 3]
//initialize widgets
m_Controls->m_TrackingToolsStatusWidget->SetShowPositions(true);
m_Controls->m_TrackingToolsStatusWidget->SetTextAlignment(Qt::AlignLeft);
m_Controls->m_simpleWidget->setVisible(false);
//initialize tracking volume node
m_TrackingVolumeNode = mitk::DataNode::New();
m_TrackingVolumeNode->SetName("TrackingVolume");
m_TrackingVolumeNode->SetBoolProperty("Backface Culling", true);
mitk::Color red;
red.SetRed(1);
m_TrackingVolumeNode->SetColor(red);
//initialize buttons
- m_Controls->m_AutoDetectTools->setVisible(false); //only visible if tracking device is Aurora
+ m_Controls->m_AutoDetectTools->setVisible(false); //only visible if supported by tracking device
m_Controls->m_StartStopTrackingButton->setEnabled(false);
m_Controls->m_StartTrackingSimpleMode->setEnabled(false);
m_Controls->m_FreezeUnfreezeTrackingButton->setEnabled(false);
//initialize warning labels
m_Controls->m_renderWarningLabel->setVisible(false);
m_Controls->m_TrackingFrozenLabel->setVisible(false);
//Update List of available models for selected tool.
std::vector<mitk::TrackingDeviceData> Compatibles;
if ((m_Controls == nullptr) || //check all these stuff for nullptr, latterly this causes crashes from time to time
(m_Controls->m_configurationWidget == nullptr) ||
(m_Controls->m_configurationWidget->GetTrackingDevice().IsNull()))
{
MITK_ERROR << "Couldn't get current tracking device or an object is nullptr, something went wrong!";
return;
}
else
{
Compatibles = m_DeviceTypeCollection->GetDeviceDataForLine(m_Controls->m_configurationWidget->GetTrackingDevice()->GetType());
}
m_Controls->m_VolumeSelectionBox->clear();
for (std::size_t i = 0; i < Compatibles.size(); i++)
{
m_Controls->m_VolumeSelectionBox->addItem(Compatibles[i].Model.c_str());
}
//initialize tool storage
m_toolStorage = mitk::NavigationToolStorage::New(GetDataStorage());
m_toolStorage->SetName("TrackingToolbox Default Storage");
m_toolStorage->RegisterAsMicroservice("no tracking device");
//set home directory as default path for logfile
m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(QDir::homePath()) + QDir::separator() + "logfile.csv");
//tracking device may be changed already by the persistence of the
//QmitkTrackingDeciveConfigurationWidget
this->OnTrackingDeviceChanged();
this->LoadUISettings();
//add tracking volume node only to data storage
this->GetDataStorage()->Add(m_TrackingVolumeNode);
if (!m_Controls->m_ShowTrackingVolume->isChecked()) m_TrackingVolumeNode->SetOpacity(0.0);
else m_TrackingVolumeNode->SetOpacity(0.25);
//Update List of available models for selected tool.
m_Controls->m_VolumeSelectionBox->clear();
for (std::size_t i = 0; i < Compatibles.size(); i++)
{
m_Controls->m_VolumeSelectionBox->addItem(Compatibles[i].Model.c_str());
}
}
}
void QmitkMITKIGTTrackingToolboxView::SetFocus()
{
m_Controls->m_configurationWidget->setFocus();
}
void QmitkMITKIGTTrackingToolboxView::OnLoadTools()
{
//read in filename
QString filename = QFileDialog::getOpenFileName(nullptr, tr("Open Tool Storage"), "/", tr("Tool Storage Files (*.IGTToolStorage)"));
if (filename.isNull()) return;
//read tool storage from disk
std::string errorMessage = "";
mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(GetDataStorage());
// try-catch block for exceptions
try
{
this->ReplaceCurrentToolStorage(myDeserializer->Deserialize(filename.toStdString()), filename.toStdString());
}
catch (mitk::IGTException)
{
std::string errormessage = "Error during loading the tool storage file. Please only load tool storage files created with the NavigationToolManager view.";
QMessageBox::warning(nullptr, "Tool Storage Loading Error", errormessage.c_str());
return;
}
if (m_toolStorage->isEmpty())
{
errorMessage = myDeserializer->GetErrorMessage();
MessageBox(errorMessage);
return;
}
//update label
UpdateToolStorageLabel(filename);
//update tool preview
m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
//save filename for persistent storage
m_ToolStorageFilename = filename;
}
void QmitkMITKIGTTrackingToolboxView::OnResetTools()
{
this->ReplaceCurrentToolStorage(mitk::NavigationToolStorage::New(GetDataStorage()), "TrackingToolbox Default Storage");
m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
QString toolLabel = QString("<none>");
m_Controls->m_toolLabel->setText(toolLabel);
m_ToolStorageFilename = "";
}
void QmitkMITKIGTTrackingToolboxView::OnStartStopTracking()
{
if (!m_connected)
{
MITK_WARN << "Can't start tracking if no device is connected. Aborting";
return;
}
if (m_tracking) { OnStopTracking(); }
else { OnStartTracking(); }
}
void QmitkMITKIGTTrackingToolboxView::OnFreezeUnfreezeTracking()
{
if (m_Controls->m_FreezeUnfreezeTrackingButton->text() == "Freeze Tracking")
{
m_TrackingDeviceSource->Freeze();
m_Controls->m_FreezeUnfreezeTrackingButton->setText("Unfreeze Tracking");
m_Controls->m_TrackingFrozenLabel->setVisible(true);
}
else if (m_Controls->m_FreezeUnfreezeTrackingButton->text() == "Unfreeze Tracking")
{
m_TrackingDeviceSource->UnFreeze();
m_Controls->m_FreezeUnfreezeTrackingButton->setText("Freeze Tracking");
m_Controls->m_TrackingFrozenLabel->setVisible(false);
}
}
void QmitkMITKIGTTrackingToolboxView::OnConnectDisconnect()
{
if (m_connected) { OnDisconnect(); }
else { OnConnect(); }
}
void QmitkMITKIGTTrackingToolboxView::OnConnect()
{
MITK_INFO << "Connect Clicked";
//check if everything is ready to start tracking
if (this->m_toolStorage.IsNull())
{
MessageBox("Error: No Tools Loaded Yet!");
return;
}
else if (this->m_toolStorage->GetToolCount() == 0)
{
MessageBox("Error: No Way To Track Without Tools!");
return;
}
//parse tracking device data
mitk::TrackingDeviceData data = mitk::UnspecifiedTrackingTypeInformation::GetDeviceDataUnspecified();
QString qstr = m_Controls->m_VolumeSelectionBox->currentText();
if ((!qstr.isNull()) || (!qstr.isEmpty())) {
std::string str = qstr.toStdString();
data = m_DeviceTypeCollection->GetDeviceDataByName(str); //Data will be set later, after device generation
}
//! [Thread 4]
//initialize worker thread
m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eConnectDevice);
m_Worker->SetTrackingDevice(this->m_Controls->m_configurationWidget->GetTrackingDevice());
m_Worker->SetInverseMode(m_Controls->m_InverseMode->isChecked());
m_Worker->SetNavigationToolStorage(this->m_toolStorage);
m_Worker->SetTrackingDeviceData(data);
//start worker thread
m_WorkerThread->start();
//! [Thread 4]
//disable buttons
this->m_Controls->m_MainWidget->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::EnableDisableTimerButtons(int enable)
{
bool enableBool = enable;
m_Controls->m_UpdateRateOptionsGroupBox->setEnabled(!enableBool);
m_Controls->m_renderWarningLabel->setVisible(enableBool);
}
void QmitkMITKIGTTrackingToolboxView::OnConnectFinished(bool success, QString errorMessage)
{
m_WorkerThread->quit();
m_WorkerThread->wait();
//enable buttons
this->m_Controls->m_MainWidget->setEnabled(true);
if (!success)
{
MITK_WARN << errorMessage.toStdString();
MessageBox(errorMessage.toStdString());
return;
}
//! [Thread 6]
//get data from worker thread
m_TrackingDeviceSource = m_Worker->GetTrackingDeviceSource();
m_TrackingDeviceData = m_Worker->GetTrackingDeviceData();
m_ToolVisualizationFilter = m_Worker->GetToolVisualizationFilter();
//! [Thread 6]
//enable/disable Buttons
DisableOptionsButtons();
DisableTrackingConfigurationButtons();
m_Controls->m_TrackingControlLabel->setText("Status: connected");
m_Controls->m_ConnectDisconnectButton->setText("Disconnect");
m_Controls->m_ConnectSimpleMode->setText("Disconnect");
m_Controls->m_StartStopTrackingButton->setEnabled(true);
m_Controls->m_StartTrackingSimpleMode->setEnabled(true);
m_connected = true;
}
void QmitkMITKIGTTrackingToolboxView::OnDisconnect()
{
m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eDisconnectDevice);
m_WorkerThread->start();
m_Controls->m_MainWidget->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::OnDisconnectFinished(bool success, QString errorMessage)
{
m_WorkerThread->quit();
m_WorkerThread->wait();
m_Controls->m_MainWidget->setEnabled(true);
if (!success)
{
MITK_WARN << errorMessage.toStdString();
MessageBox(errorMessage.toStdString());
return;
}
//enable/disable Buttons
m_Controls->m_StartStopTrackingButton->setEnabled(false);
m_Controls->m_StartTrackingSimpleMode->setEnabled(false);
EnableOptionsButtons();
EnableTrackingConfigurationButtons();
m_Controls->m_TrackingControlLabel->setText("Status: disconnected");
m_Controls->m_ConnectDisconnectButton->setText("Connect");
m_Controls->m_ConnectSimpleMode->setText("Connect");
m_Controls->m_FreezeUnfreezeTrackingButton->setText("Freeze Tracking");
m_Controls->m_TrackingFrozenLabel->setVisible(false);
m_connected = false;
}
void QmitkMITKIGTTrackingToolboxView::OnStartTracking()
{
//show tracking volume
this->OnTrackingVolumeChanged(m_Controls->m_VolumeSelectionBox->currentText());
//Reset the view to a defined start. Do it here and not in OnStartTrackingFinished, to give other tracking devices the chance to reset the view to a different direction.
this->GlobalReinit();
m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eStartTracking);
m_WorkerThread->start();
this->m_Controls->m_MainWidget->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::OnStartTrackingFinished(bool success, QString errorMessage)
{
//! [Thread 5]
m_WorkerThread->quit();
m_WorkerThread->wait();
//! [Thread 5]
this->m_Controls->m_MainWidget->setEnabled(true);
if (!success)
{
MessageBox(errorMessage.toStdString());
MITK_WARN << errorMessage.toStdString();
return;
}
if (!(m_Controls->m_DisableAllTimers->isChecked()))
{
if (m_Controls->m_UseDifferentUpdateRates->isChecked())
{
if (m_Controls->m_RenderUpdateRate->value() != 0)
m_TrackingRenderTimer->start(1000 / (m_Controls->m_RenderUpdateRate->value()));
m_TrackingLoggingTimer->start(1000 / (m_Controls->m_LogUpdateRate->value()));
}
else
{
m_TrackingRenderTimer->start(1000 / (m_Controls->m_UpdateRate->value()));
m_TrackingLoggingTimer->start(1000 / (m_Controls->m_UpdateRate->value()));
}
}
m_Controls->m_TrackingControlLabel->setText("Status: tracking");
//connect the tool visualization widget
for (std::size_t i = 0; i < m_TrackingDeviceSource->GetNumberOfOutputs(); i++)
{
m_Controls->m_TrackingToolsStatusWidget->AddNavigationData(m_TrackingDeviceSource->GetOutput(i));
}
m_Controls->m_TrackingToolsStatusWidget->ShowStatusLabels();
if (m_Controls->m_ShowToolQuaternions->isChecked()) { m_Controls->m_TrackingToolsStatusWidget->SetShowQuaternions(true); }
else { m_Controls->m_TrackingToolsStatusWidget->SetShowQuaternions(false); }
//if activated enable open IGT link microservice
if (m_Controls->m_EnableOpenIGTLinkMicroService->isChecked())
{
//create convertion filter
m_IGTLConversionFilter = mitk::NavigationDataToIGTLMessageFilter::New();
m_IGTLConversionFilter->SetName("IGT Tracking Toolbox");
+ QString dataModeSelection = this->m_Controls->m_OpenIGTLinkDataFormat->currentText();
+ if (dataModeSelection == "TDATA")
+ {m_IGTLConversionFilter->SetOperationMode(mitk::NavigationDataToIGTLMessageFilter::ModeSendTDataMsg);}
+ else if (dataModeSelection == "TRANSFORM")
+ {m_IGTLConversionFilter->SetOperationMode(mitk::NavigationDataToIGTLMessageFilter::ModeSendTransMsg);}
+ else if (dataModeSelection == "QTDATA")
+ {m_IGTLConversionFilter->SetOperationMode(mitk::NavigationDataToIGTLMessageFilter::ModeSendQTDataMsg);}
+ else if (dataModeSelection == "POSITION")
+ {m_IGTLConversionFilter->SetOperationMode(mitk::NavigationDataToIGTLMessageFilter::ModeSendQTransMsg);}
m_IGTLConversionFilter->ConnectTo(m_ToolVisualizationFilter);
- m_IGTLConversionFilter->SetOperationMode(mitk::NavigationDataToIGTLMessageFilter::ModeSendTDataMsg);
m_IGTLConversionFilter->RegisterAsMicroservice();
+
//create server and message provider
m_IGTLServer = mitk::IGTLServer::New(false);
m_IGTLServer->SetName("Tracking Toolbox IGTL Server");
m_IGTLMessageProvider = mitk::IGTLMessageProvider::New();
m_IGTLMessageProvider->SetIGTLDevice(m_IGTLServer);
m_IGTLMessageProvider->RegisterAsMicroservice();
}
m_tracking = true;
m_Controls->m_ConnectDisconnectButton->setEnabled(false);
m_Controls->m_StartStopTrackingButton->setText("Stop Tracking");
m_Controls->m_StartTrackingSimpleMode->setText("Stop\nTracking");
m_Controls->m_FreezeUnfreezeTrackingButton->setEnabled(true);
}
void QmitkMITKIGTTrackingToolboxView::OnStopTracking()
{
if (!m_tracking) return;
m_TrackingRenderTimer->stop();
m_TrackingLoggingTimer->stop();
m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eStopTracking);
m_WorkerThread->start();
m_Controls->m_MainWidget->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::OnStopTrackingFinished(bool success, QString errorMessage)
{
m_WorkerThread->quit();
m_WorkerThread->wait();
m_Controls->m_MainWidget->setEnabled(true);
if (!success)
{
MessageBox(errorMessage.toStdString());
MITK_WARN << errorMessage.toStdString();
return;
}
m_Controls->m_TrackingControlLabel->setText("Status: connected");
if (m_logging) StopLogging();
m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
m_tracking = false;
m_Controls->m_StartStopTrackingButton->setText("Start Tracking");
m_Controls->m_StartTrackingSimpleMode->setText("Start\nTracking");
m_Controls->m_ConnectDisconnectButton->setEnabled(true);
m_Controls->m_FreezeUnfreezeTrackingButton->setEnabled(false);
//unregister open IGT link micro service
if (m_Controls->m_EnableOpenIGTLinkMicroService->isChecked())
{
m_IGTLConversionFilter->UnRegisterMicroservice();
m_IGTLMessageProvider->UnRegisterMicroservice();
}
}
void QmitkMITKIGTTrackingToolboxView::OnTrackingDeviceChanged()
{
mitk::TrackingDeviceType Type;
if (m_Controls->m_configurationWidget->GetTrackingDevice().IsNotNull())
{
Type = m_Controls->m_configurationWidget->GetTrackingDevice()->GetType();
//enable controls because device is valid
m_Controls->m_TrackingToolsGoupBox->setEnabled(true);
m_Controls->m_TrackingControlsGroupBox->setEnabled(true);
}
else
{
Type = mitk::UnspecifiedTrackingTypeInformation::GetTrackingDeviceName();
MessageBox("Error: This tracking device is not included in this project. Please make sure that the device is installed and activated in your MITK build.");
m_Controls->m_TrackingToolsGoupBox->setEnabled(false);
m_Controls->m_TrackingControlsGroupBox->setEnabled(false);
return;
}
// Code to enable/disable device specific buttons
if (m_Controls->m_configurationWidget->GetTrackingDevice()->AutoDetectToolsAvailable())
{ m_Controls->m_AutoDetectTools->setVisible(true); }
else
{ m_Controls->m_AutoDetectTools->setVisible(false); }
if (Type == mitk::NDIAuroraTypeInformation::GetTrackingDeviceName()) //Aurora
{ m_Controls->m_AddSingleTool->setEnabled(false);}
else //other trackers
{ m_Controls->m_AddSingleTool->setEnabled(true); }
// Code to select appropriate tracking volume for current type
std::vector<mitk::TrackingDeviceData> Compatibles = m_DeviceTypeCollection->GetDeviceDataForLine(Type);
m_Controls->m_VolumeSelectionBox->clear();
for (std::size_t i = 0; i < Compatibles.size(); i++)
{
m_Controls->m_VolumeSelectionBox->addItem(Compatibles[i].Model.c_str());
}
}
void QmitkMITKIGTTrackingToolboxView::OnTrackingVolumeChanged(QString qstr)
{
if (qstr.isNull()) return;
if (qstr.isEmpty()) return;
mitk::TrackingVolumeGenerator::Pointer volumeGenerator = mitk::TrackingVolumeGenerator::New();
std::string str = qstr.toStdString();
mitk::TrackingDeviceData data = m_DeviceTypeCollection->GetDeviceDataByName(str);
m_TrackingDeviceData = data;
volumeGenerator->SetTrackingDeviceData(data);
volumeGenerator->Update();
mitk::Surface::Pointer volumeSurface = volumeGenerator->GetOutput();
m_TrackingVolumeNode->SetData(volumeSurface);
if (!m_Controls->m_ShowTrackingVolume->isChecked()) m_TrackingVolumeNode->SetOpacity(0.0);
else m_TrackingVolumeNode->SetOpacity(0.25);
GlobalReinit();
}
void QmitkMITKIGTTrackingToolboxView::OnShowTrackingVolumeChanged()
{
if (m_Controls->m_ShowTrackingVolume->isChecked())
{
OnTrackingVolumeChanged(m_Controls->m_VolumeSelectionBox->currentText());
m_TrackingVolumeNode->SetOpacity(0.25);
}
else
{
m_TrackingVolumeNode->SetOpacity(0.0);
}
}
void QmitkMITKIGTTrackingToolboxView::OnAutoDetectTools()
{
if (m_Controls->m_configurationWidget->GetTrackingDevice()->AutoDetectToolsAvailable())
{
DisableTrackingConfigurationButtons();
m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eAutoDetectTools);
m_Worker->SetTrackingDevice(m_Controls->m_configurationWidget->GetTrackingDevice().GetPointer());
m_Worker->SetDataStorage(this->GetDataStorage());
m_WorkerThread->start();
m_TimeoutTimer->start(5000);
//disable controls until worker thread is finished
this->m_Controls->m_MainWidget->setEnabled(false);
}
}
void QmitkMITKIGTTrackingToolboxView::OnAutoDetectToolsFinished(bool success, QString errorMessage)
{
m_TimeoutTimer->stop();
m_WorkerThread->quit();
m_WorkerThread->wait();
//enable controls again
this->m_Controls->m_MainWidget->setEnabled(true);
EnableTrackingConfigurationButtons();
if (!success)
{
MITK_WARN << errorMessage.toStdString();
MessageBox(errorMessage.toStdString());
EnableTrackingConfigurationButtons();
return;
}
mitk::NavigationToolStorage::Pointer autoDetectedStorage = m_Worker->GetNavigationToolStorage();
//save detected tools
this->ReplaceCurrentToolStorage(autoDetectedStorage, "Autodetected NDI Aurora Storage");
//auto save the new storage to hard disc (for persistence)
AutoSaveToolStorage();
//update label
QString toolLabel = QString("Loaded Tools: ") + QString::number(m_toolStorage->GetToolCount()) + " Tools (Auto Detected)";
m_Controls->m_toolLabel->setText(toolLabel);
//update tool preview
m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
EnableTrackingConfigurationButtons();
//print a logging message about the detected tools
switch (m_toolStorage->GetToolCount())
{
case 0:
MITK_INFO("IGT Tracking Toolbox") << "Found no tools. Empty ToolStorage was autosaved to " << m_ToolStorageFilename.toStdString();
break;
case 1:
MITK_INFO("IGT Tracking Toolbox") << "Found one tool. ToolStorage was autosaved to " << m_ToolStorageFilename.toStdString();
break;
default:
MITK_INFO("IGT Tracking Toolbox") << "Found " << m_toolStorage->GetToolCount() << " tools. ToolStorage was autosaved to " << m_ToolStorageFilename.toStdString();
}
}
void QmitkMITKIGTTrackingToolboxView::MessageBox(std::string s)
{
QMessageBox msgBox;
msgBox.setText(s.c_str());
msgBox.exec();
}
void QmitkMITKIGTTrackingToolboxView::UpdateRenderTrackingTimer()
{
//update filter
m_ToolVisualizationFilter->Update();
MITK_DEBUG << "Number of outputs ToolVisualizationFilter: " << m_ToolVisualizationFilter->GetNumberOfIndexedOutputs();
MITK_DEBUG << "Number of inputs ToolVisualizationFilter: " << m_ToolVisualizationFilter->GetNumberOfIndexedInputs();
//update tool colors to show tool status
for (unsigned int i = 0; i < m_ToolVisualizationFilter->GetNumberOfIndexedOutputs(); i++)
{
mitk::NavigationData::Pointer currentTool = m_ToolVisualizationFilter->GetOutput(i);
if (currentTool->IsDataValid())
{
this->m_toolStorage->GetTool(i)->GetDataNode()->SetColor(mitk::IGTColor_VALID);
}
else
{
this->m_toolStorage->GetTool(i)->GetDataNode()->SetColor(mitk::IGTColor_WARNING);
}
}
//refresh view and status widget
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
m_Controls->m_TrackingToolsStatusWidget->Refresh();
-
- //code to better isolate bug 17713, could be removed when bug 17713 is fixed
- static int i = 0;
- static mitk::Point3D lastPositionTool1 = m_ToolVisualizationFilter->GetOutput(0)->GetPosition();
- static itk::TimeStamp lastTimeStamp = m_ToolVisualizationFilter->GetOutput(0)->GetTimeStamp();
- i++;
- //every 20 frames: check if tracking is frozen
- if (i > 20)
- {
- i = 0;
- if (m_ToolVisualizationFilter->GetOutput(0)->IsDataValid())
- {
- if (mitk::Equal(lastPositionTool1, m_ToolVisualizationFilter->GetOutput(0)->GetPosition(), 0.000000001, false)
- && m_Controls->m_configurationWidget->GetTrackingDevice()->GetType() != "Da Vinci")
- {
- MITK_WARN << "Seems as tracking (of at least tool 1) is frozen which means that bug 17713 occurred. Restart tracking might help.";
- //display further information to find the bug
- MITK_WARN << "Timestamp of current navigation data: " << m_ToolVisualizationFilter->GetOutput(0)->GetTimeStamp();
- MITK_WARN << "Timestamp of last navigation data (which holds the same values): " << lastTimeStamp;
- }
- lastPositionTool1 = m_ToolVisualizationFilter->GetOutput(0)->GetPosition();
- lastTimeStamp = m_ToolVisualizationFilter->GetOutput(0)->GetTimeStamp();
- }
- }
}
void QmitkMITKIGTTrackingToolboxView::UpdateLoggingTrackingTimer()
{
//update logging
if (m_logging)
{
this->m_loggingFilter->Update();
m_loggedFrames = this->m_loggingFilter->GetNumberOfRecordedSteps();
this->m_Controls->m_LoggedFramesLabel->setText("Logged Frames: " + QString::number(m_loggedFrames));
//check if logging stopped automatically
if ((m_loggedFrames > 1) && (!m_loggingFilter->GetRecording())){ StopLogging(); }
}
//refresh status widget
m_Controls->m_TrackingToolsStatusWidget->Refresh();
}
void QmitkMITKIGTTrackingToolboxView::OnChooseFileClicked()
{
QDir currentPath = QFileInfo(m_Controls->m_LoggingFileName->text()).dir();
// if no path was selected (QDir would select current working dir then) or the
// selected path does not exist -> use home directory
if (currentPath == QDir() || !currentPath.exists())
{
currentPath = QDir(QDir::homePath());
}
QString filename = QFileDialog::getSaveFileName(nullptr, tr("Choose Logging File"), currentPath.absolutePath(), "*.*");
if (filename == "") return;
this->m_Controls->m_LoggingFileName->setText(filename);
this->OnToggleFileExtension();
}
// bug-16470: toggle file extension after clicking on radio button
void QmitkMITKIGTTrackingToolboxView::OnToggleFileExtension()
{
QString currentInputText = this->m_Controls->m_LoggingFileName->text();
QString currentFile = QFileInfo(currentInputText).baseName();
QDir currentPath = QFileInfo(currentInputText).dir();
if (currentFile.isEmpty())
{
currentFile = "logfile";
}
// Setting currentPath to default home path when currentPath is empty or it does not exist
if (currentPath == QDir() || !currentPath.exists())
{
currentPath = QDir::homePath();
}
// check if csv radio button is clicked
if (this->m_Controls->m_csvFormat->isChecked())
{
// you needn't add a seperator to the input text when currentpath is the rootpath
if (currentPath.isRoot())
{
this->m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(currentPath.absolutePath()) + currentFile + ".csv");
}
else
{
this->m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(currentPath.absolutePath()) + QDir::separator() + currentFile + ".csv");
}
}
// check if xml radio button is clicked
else if (this->m_Controls->m_xmlFormat->isChecked())
{
// you needn't add a seperator to the input text when currentpath is the rootpath
if (currentPath.isRoot())
{
this->m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(currentPath.absolutePath()) + currentFile + ".xml");
}
else
{
this->m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(currentPath.absolutePath()) + QDir::separator() + currentFile + ".xml");
}
}
}
void QmitkMITKIGTTrackingToolboxView::OnToggleAdvancedSimpleMode()
{
if (m_SimpleModeEnabled)
{
m_Controls->m_simpleWidget->setVisible(false);
m_Controls->m_MainWidget->setVisible(true);
m_Controls->m_simpleUI->setChecked(false);
m_SimpleModeEnabled = false;
}
else
{
m_Controls->m_simpleWidget->setVisible(true);
m_Controls->m_MainWidget->setVisible(false);
m_SimpleModeEnabled = true;
}
}
void QmitkMITKIGTTrackingToolboxView::OnToggleDifferentUpdateRates()
{
if (m_Controls->m_UseDifferentUpdateRates->isChecked())
{
if (m_Controls->m_RenderUpdateRate->value() == 0)
m_Controls->m_renderWarningLabel->setVisible(true);
else
m_Controls->m_renderWarningLabel->setVisible(false);
m_Controls->m_UpdateRate->setEnabled(false);
m_Controls->m_OptionsUpdateRateLabel->setEnabled(false);
m_Controls->m_RenderUpdateRate->setEnabled(true);
m_Controls->m_OptionsRenderUpdateRateLabel->setEnabled(true);
m_Controls->m_LogUpdateRate->setEnabled(true);
m_Controls->m_OptionsLogUpdateRateLabel->setEnabled(true);
}
else
{
m_Controls->m_renderWarningLabel->setVisible(false);
m_Controls->m_UpdateRate->setEnabled(true);
m_Controls->m_OptionsUpdateRateLabel->setEnabled(true);
m_Controls->m_RenderUpdateRate->setEnabled(false);
m_Controls->m_OptionsRenderUpdateRateLabel->setEnabled(false);
m_Controls->m_LogUpdateRate->setEnabled(false);
m_Controls->m_OptionsLogUpdateRateLabel->setEnabled(false);
}
}
void QmitkMITKIGTTrackingToolboxView::OnChangeRenderUpdateRate()
{
if (m_Controls->m_RenderUpdateRate->value() == 0)
m_Controls->m_renderWarningLabel->setVisible(true);
else
m_Controls->m_renderWarningLabel->setVisible(false);
}
void QmitkMITKIGTTrackingToolboxView::StartLogging()
{
if (m_ToolVisualizationFilter.IsNull())
{
MessageBox("Cannot activate logging without a connected device. Configure and connect a tracking device first.");
return;
}
if (!m_logging)
{
//initialize logging filter
m_loggingFilter = mitk::NavigationDataRecorder::New();
+ m_loggingFilter->SetRecordOnlyValidData(m_Controls->m_SkipInvalidData->isChecked());
m_loggingFilter->ConnectTo(m_ToolVisualizationFilter);
if (m_Controls->m_LoggingLimit->isChecked()){ m_loggingFilter->SetRecordCountLimit(m_Controls->m_LoggedFramesLimit->value()); }
//start filter with try-catch block for exceptions
try
{
m_loggingFilter->StartRecording();
}
catch (mitk::IGTException)
{
std::string errormessage = "Error during start recording. Recorder already started recording?";
QMessageBox::warning(nullptr, "IGTPlayer: Error", errormessage.c_str());
m_loggingFilter->StopRecording();
return;
}
//update labels / logging variables
this->m_Controls->m_LoggingLabel->setText("Logging ON");
this->m_Controls->m_LoggedFramesLabel->setText("Logged Frames: 0");
m_loggedFrames = 0;
m_logging = true;
DisableLoggingButtons();
}
}
void QmitkMITKIGTTrackingToolboxView::StopLogging()
{
if (m_logging)
{
//stop logging
m_loggingFilter->StopRecording();
m_logging = false;
//update GUI
this->m_Controls->m_LoggingLabel->setText("Logging OFF");
EnableLoggingButtons();
//write the results to a file
if (m_Controls->m_csvFormat->isChecked() || m_Controls->m_xmlFormat->isChecked())
mitk::IOUtil::Save(m_loggingFilter->GetNavigationDataSet(), this->m_Controls->m_LoggingFileName->text().toStdString());
}
}
void QmitkMITKIGTTrackingToolboxView::OnAddSingleTool()
{
QString Identifier = "Tool#";
QString Name = "NewTool";
if (m_toolStorage.IsNotNull()) {
Identifier += QString::number(m_toolStorage->GetToolCount());
Name += QString::number(m_toolStorage->GetToolCount());
}
else {
Identifier += "0";
Name += "0";
}
m_Controls->m_NavigationToolCreationWidget->Initialize(GetDataStorage(), Identifier.toStdString(), Name.toStdString());
m_Controls->m_NavigationToolCreationWidget->SetTrackingDeviceType(m_Controls->m_configurationWidget->GetTrackingDevice()->GetType(), false);
m_Controls->m_TrackingToolsWidget->setCurrentIndex(1);
//disable tracking volume during tool editing
lastTrackingVolumeState = m_Controls->m_ShowTrackingVolume->isChecked();
if (lastTrackingVolumeState) m_Controls->m_ShowTrackingVolume->click();
GlobalReinit();
}
void QmitkMITKIGTTrackingToolboxView::OnAddSingleToolFinished()
{
m_Controls->m_TrackingToolsWidget->setCurrentIndex(0);
if (this->m_toolStorage.IsNull())
{
//this shouldn't happen!
MITK_WARN << "No ToolStorage available, cannot add tool, aborting!";
return;
}
m_toolStorage->AddTool(m_Controls->m_NavigationToolCreationWidget->GetCreatedTool());
m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
m_Controls->m_toolLabel->setText("<manually added>");
//auto save current storage for persistence
MITK_INFO << "Auto saving manually added tools for persistence.";
AutoSaveToolStorage();
//enable tracking volume again
if (lastTrackingVolumeState) m_Controls->m_ShowTrackingVolume->click();
GlobalReinit();
}
void QmitkMITKIGTTrackingToolboxView::OnAddSingleToolCanceled()
{
m_Controls->m_TrackingToolsWidget->setCurrentIndex(0);
//enable tracking volume again
if (lastTrackingVolumeState) m_Controls->m_ShowTrackingVolume->click();
GlobalReinit();
}
void QmitkMITKIGTTrackingToolboxView::GlobalReinit()
{
// get all nodes that have not set "includeInBoundingBox" to false
mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox", mitk::BoolProperty::New(false)));
mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDataStorage()->GetSubset(pred);
// calculate bounding geometry of these nodes
mitk::TimeGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
// initialize the views to the bounding geometry
mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
}
void QmitkMITKIGTTrackingToolboxView::DisableLoggingButtons()
{
m_Controls->m_StartLogging->setEnabled(false);
m_Controls->m_LoggingFileName->setEnabled(false);
m_Controls->m_ChooseFile->setEnabled(false);
m_Controls->m_LoggingLimit->setEnabled(false);
m_Controls->m_LoggedFramesLimit->setEnabled(false);
m_Controls->m_csvFormat->setEnabled(false);
m_Controls->m_xmlFormat->setEnabled(false);
+ m_Controls->m_SkipInvalidData->setEnabled(false);
m_Controls->m_StopLogging->setEnabled(true);
}
void QmitkMITKIGTTrackingToolboxView::EnableLoggingButtons()
{
m_Controls->m_StartLogging->setEnabled(true);
m_Controls->m_LoggingFileName->setEnabled(true);
m_Controls->m_ChooseFile->setEnabled(true);
m_Controls->m_LoggingLimit->setEnabled(true);
m_Controls->m_LoggedFramesLimit->setEnabled(true);
m_Controls->m_csvFormat->setEnabled(true);
m_Controls->m_xmlFormat->setEnabled(true);
+ m_Controls->m_SkipInvalidData->setEnabled(true);
m_Controls->m_StopLogging->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::DisableOptionsButtons()
{
m_Controls->m_ShowTrackingVolume->setEnabled(false);
m_Controls->m_UseDifferentUpdateRates->setEnabled(false);
m_Controls->m_UpdateRate->setEnabled(false);
m_Controls->m_OptionsUpdateRateLabel->setEnabled(false);
m_Controls->m_RenderUpdateRate->setEnabled(false);
m_Controls->m_OptionsRenderUpdateRateLabel->setEnabled(false);
m_Controls->m_LogUpdateRate->setEnabled(false);
m_Controls->m_OptionsLogUpdateRateLabel->setEnabled(false);
m_Controls->m_DisableAllTimers->setEnabled(false);
m_Controls->m_OtherOptionsGroupBox->setEnabled(false);
+ m_Controls->m_EnableOpenIGTLinkMicroService->setEnabled(false);
+ m_Controls->m_OpenIGTLinkDataFormat->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::EnableOptionsButtons()
{
m_Controls->m_ShowTrackingVolume->setEnabled(true);
m_Controls->m_UseDifferentUpdateRates->setEnabled(true);
m_Controls->m_DisableAllTimers->setEnabled(true);
m_Controls->m_OtherOptionsGroupBox->setEnabled(true);
+ m_Controls->m_EnableOpenIGTLinkMicroService->setEnabled(true);
+ m_Controls->m_OpenIGTLinkDataFormat->setEnabled(true);
OnToggleDifferentUpdateRates();
}
void QmitkMITKIGTTrackingToolboxView::EnableTrackingControls()
{
m_Controls->m_TrackingControlsGroupBox->setEnabled(true);
}
void QmitkMITKIGTTrackingToolboxView::DisableTrackingControls()
{
m_Controls->m_TrackingControlsGroupBox->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::EnableTrackingConfigurationButtons()
{
m_Controls->m_AutoDetectTools->setEnabled(true);
if (m_Controls->m_configurationWidget->GetTrackingDevice()->GetType() != mitk::NDIAuroraTypeInformation::GetTrackingDeviceName()) m_Controls->m_AddSingleTool->setEnabled(true);
m_Controls->m_LoadTools->setEnabled(true);
m_Controls->m_ResetTools->setEnabled(true);
}
void QmitkMITKIGTTrackingToolboxView::DisableTrackingConfigurationButtons()
{
m_Controls->m_AutoDetectTools->setEnabled(false);
if (m_Controls->m_configurationWidget->GetTrackingDevice()->GetType() != mitk::NDIAuroraTypeInformation::GetTrackingDeviceName()) m_Controls->m_AddSingleTool->setEnabled(false);
m_Controls->m_LoadTools->setEnabled(false);
m_Controls->m_ResetTools->setEnabled(false);
}
void QmitkMITKIGTTrackingToolboxView::ReplaceCurrentToolStorage(mitk::NavigationToolStorage::Pointer newStorage, std::string newStorageName)
{
//first: get rid of the old one
//don't reset if there is no tool storage. BugFix #17793
if (m_toolStorage.IsNotNull()){
m_toolStorage->UnLockStorage(); //only to be sure...
m_toolStorage->UnRegisterMicroservice();
m_toolStorage = nullptr;
}
//now: replace by the new one
m_toolStorage = newStorage;
m_toolStorage->SetName(newStorageName);
m_toolStorage->RegisterAsMicroservice("no tracking device");
}
void QmitkMITKIGTTrackingToolboxView::OnTimeOut()
{
m_WorkerThread->terminate();
m_WorkerThread->wait();
m_TimeoutTimer->stop();
}
//! [StoreUISettings]
void QmitkMITKIGTTrackingToolboxView::StoreUISettings()
{
// persistence service does not directly work in plugins for now
// -> using QSettings
QSettings settings;
settings.beginGroup(QString::fromStdString(VIEW_ID));
MITK_INFO << "Store UI settings";
// set the values of some widgets and attrbutes to the QSettings
settings.setValue("ShowTrackingVolume", QVariant(m_Controls->m_ShowTrackingVolume->isChecked()));
settings.setValue("toolStorageFilename", QVariant(m_ToolStorageFilename));
settings.setValue("VolumeSelectionBox", QVariant(m_Controls->m_VolumeSelectionBox->currentIndex()));
settings.setValue("SimpleModeEnabled", QVariant(m_SimpleModeEnabled));
settings.endGroup();
}
//! [StoreUISettings]
//! [LoadUISettings]
void QmitkMITKIGTTrackingToolboxView::LoadUISettings()
{
// persistence service does not directly work in plugins for now
// -> using QSettings
QSettings settings;
settings.beginGroup(QString::fromStdString(VIEW_ID));
// set some widgets and attributes by the values from the QSettings
m_Controls->m_ShowTrackingVolume->setChecked(settings.value("ShowTrackingVolume", true).toBool());
m_Controls->m_VolumeSelectionBox->setCurrentIndex(settings.value("VolumeSelectionBox", 0).toInt());
m_ToolStorageFilename = settings.value("toolStorageFilename", QVariant("")).toString();
if (settings.value("SimpleModeEnabled", false).toBool()) { this->OnToggleAdvancedSimpleMode(); }
settings.endGroup();
//! [LoadUISettings]
//! [LoadToolStorage]
// try to deserialize the tool storage from the given tool storage file name
if (!m_ToolStorageFilename.isEmpty())
{
// try-catch block for exceptions
try
{
mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(GetDataStorage());
m_toolStorage->UnRegisterMicroservice();
m_toolStorage = myDeserializer->Deserialize(m_ToolStorageFilename.toStdString());
m_toolStorage->RegisterAsMicroservice("no tracking device");
//update label
UpdateToolStorageLabel(m_ToolStorageFilename);
//update tool preview
m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
}
catch (mitk::IGTException)
{
MITK_WARN("QmitkMITKIGTTrackingToolBoxView") << "Error during restoring tools. Problems with file (" << m_ToolStorageFilename.toStdString() << "), please check the file?";
this->OnResetTools(); //if there where errors reset the tool storage to avoid problems later on
}
}
//! [LoadToolStorage]
}
void QmitkMITKIGTTrackingToolboxView::UpdateToolStorageLabel(QString pathOfLoadedStorage)
{
QFileInfo myPath(pathOfLoadedStorage); //use this to seperate filename from path
QString toolLabel = myPath.fileName();
if (toolLabel.size() > 45) //if the tool storage name is to long trimm the string
{
toolLabel.resize(40);
toolLabel += "[...]";
}
m_Controls->m_toolLabel->setText(toolLabel);
}
void QmitkMITKIGTTrackingToolboxView::AutoSaveToolStorage()
{
m_ToolStorageFilename = m_AutoSaveFilename;
mitk::NavigationToolStorageSerializer::Pointer mySerializer = mitk::NavigationToolStorageSerializer::New();
mySerializer->Serialize(m_ToolStorageFilename.toStdString(), m_toolStorage);
}
void QmitkMITKIGTTrackingToolboxViewWorker::SetWorkerMethod(WorkerMethod w)
{
m_WorkerMethod = w;
}
void QmitkMITKIGTTrackingToolboxViewWorker::SetTrackingDevice(mitk::TrackingDevice::Pointer t)
{
m_TrackingDevice = t;
}
void QmitkMITKIGTTrackingToolboxViewWorker::SetDataStorage(mitk::DataStorage::Pointer d)
{
m_DataStorage = d;
}
void QmitkMITKIGTTrackingToolboxViewWorker::SetInverseMode(bool mode)
{
m_InverseMode = mode;
}
void QmitkMITKIGTTrackingToolboxViewWorker::SetTrackingDeviceData(mitk::TrackingDeviceData d)
{
m_TrackingDeviceData = d;
}
void QmitkMITKIGTTrackingToolboxViewWorker::SetNavigationToolStorage(mitk::NavigationToolStorage::Pointer n)
{
m_NavigationToolStorage = n;
}
//! [Thread 7]
void QmitkMITKIGTTrackingToolboxViewWorker::ThreadFunc()
{
switch (m_WorkerMethod)
{
case eAutoDetectTools:
this->AutoDetectTools();
break;
case eConnectDevice:
this->ConnectDevice();
break;
case eStartTracking:
this->StartTracking();
break;
case eStopTracking:
this->StopTracking();
break;
case eDisconnectDevice:
this->DisconnectDevice();
break;
default:
MITK_WARN << "Undefined worker method was set ... something went wrong!";
break;
}
}
//! [Thread 7]
void QmitkMITKIGTTrackingToolboxViewWorker::AutoDetectTools()
{
//mitk::ProgressBar::GetInstance()->AddStepsToDo(2);
mitk::NavigationToolStorage::Pointer autoDetectedStorage = mitk::NavigationToolStorage::New(m_DataStorage);
try
{
mitk::NavigationToolStorage::Pointer tempStorage = m_TrackingDevice->AutoDetectTools();
//mitk::ProgressBar::GetInstance()->Progress();
for (int i = 0; i < tempStorage->GetToolCount(); i++) { autoDetectedStorage->AddTool(tempStorage->GetTool(i)); }
}
catch (mitk::Exception& e)
{
MITK_WARN << e.GetDescription();
//mitk::ProgressBar::GetInstance()->Reset();
emit AutoDetectToolsFinished(false, e.GetDescription());
return;
}
m_NavigationToolStorage = autoDetectedStorage;
//::ProgressBar::GetInstance()->Progress();
emit AutoDetectToolsFinished(true, "");
}
void QmitkMITKIGTTrackingToolboxViewWorker::ConnectDevice()
{
std::string message = "";
//mitk::ProgressBar::GetInstance()->AddStepsToDo(4);
//build the IGT pipeline
mitk::TrackingDevice::Pointer trackingDevice = m_TrackingDevice;
trackingDevice->SetData(m_TrackingDeviceData);
//set device to rotation mode transposed becaus we are working with VNL style quaternions
if (m_InverseMode)
{
trackingDevice->SetRotationMode(mitk::TrackingDevice::RotationTransposed);
}
//Get Tracking Volume Data
mitk::TrackingDeviceData data = m_TrackingDeviceData;
//mitk::ProgressBar::GetInstance()->Progress();
//Create Navigation Data Source with the factory class
mitk::TrackingDeviceSourceConfigurator::Pointer myTrackingDeviceSourceFactory = mitk::TrackingDeviceSourceConfigurator::New(m_NavigationToolStorage, trackingDevice);
m_TrackingDeviceSource = myTrackingDeviceSourceFactory->CreateTrackingDeviceSource(m_ToolVisualizationFilter);
//mitk::ProgressBar::GetInstance()->Progress();
if (m_TrackingDeviceSource.IsNull())
{
message = std::string("Cannot connect to device: ") + myTrackingDeviceSourceFactory->GetErrorMessage();
emit ConnectDeviceFinished(false, QString(message.c_str()));
return;
}
//set filter to rotation mode transposed becaus we are working with VNL style quaternions
if (m_InverseMode)
m_ToolVisualizationFilter->SetRotationMode(mitk::NavigationDataObjectVisualizationFilter::RotationTransposed);
//First check if the created object is valid
if (m_TrackingDeviceSource.IsNull())
{
message = myTrackingDeviceSourceFactory->GetErrorMessage();
emit ConnectDeviceFinished(false, QString(message.c_str()));
return;
}
MITK_INFO << "Number of tools: " << m_TrackingDeviceSource->GetNumberOfOutputs();
//mitk::ProgressBar::GetInstance()->Progress();
//The tools are maybe reordered after initialization, e.g. in case of auto-detected tools of NDI Aurora
mitk::NavigationToolStorage::Pointer toolsInNewOrder = myTrackingDeviceSourceFactory->GetUpdatedNavigationToolStorage();
if ((toolsInNewOrder.IsNotNull()) && (toolsInNewOrder->GetToolCount() > 0))
{
//so delete the old tools in wrong order and add them in the right order
//we cannot simply replace the tool storage because the new storage is
//not correctly initialized with the right data storage
/*
m_NavigationToolStorage->DeleteAllTools();
for (int i=0; i < toolsInNewOrder->GetToolCount(); i++) {m_NavigationToolStorage->AddTool(toolsInNewOrder->GetTool(i));}
This was replaced and thereby fixed Bug 18318 DeleteAllTools() is not Threadsafe!
*/
for (int i = 0; i < toolsInNewOrder->GetToolCount(); i++)
{
m_NavigationToolStorage->AssignToolNumber(toolsInNewOrder->GetTool(i)->GetIdentifier(), i);
}
}
//mitk::ProgressBar::GetInstance()->Progress();
//connect to device
try
{
m_TrackingDeviceSource->Connect();
//mitk::ProgressBar::GetInstance()->Reset();
//Microservice registration:
m_TrackingDeviceSource->RegisterAsMicroservice();
m_NavigationToolStorage->UnRegisterMicroservice();
m_NavigationToolStorage->RegisterAsMicroservice(m_TrackingDeviceSource->GetMicroserviceID());
m_NavigationToolStorage->LockStorage();
}
catch (...) //todo: change to mitk::IGTException
{
message = "Error on connecting the tracking device.";
emit ConnectDeviceFinished(false, QString(message.c_str()));
return;
}
emit ConnectDeviceFinished(true, QString(message.c_str()));
//mitk::ProgressBar::GetInstance()->Reset();
}
void QmitkMITKIGTTrackingToolboxViewWorker::StartTracking()
{
QString errorMessage = "";
try
{
m_TrackingDeviceSource->StartTracking();
}
catch (...) //todo: change to mitk::IGTException
{
errorMessage += "Error while starting the tracking device!";
emit StartTrackingFinished(false, errorMessage);
return;
}
//remember the original colors of the tools
m_OriginalColors = std::map<mitk::DataNode::Pointer, mitk::Color>();
for (int i = 0; i < this->m_NavigationToolStorage->GetToolCount(); i++)
{
mitk::DataNode::Pointer currentToolNode = m_NavigationToolStorage->GetTool(i)->GetDataNode();
float c[3];
currentToolNode->GetColor(c);
mitk::Color color;
color.SetRed(c[0]);
color.SetGreen(c[1]);
color.SetBlue(c[2]);
m_OriginalColors[currentToolNode] = color;
}
emit StartTrackingFinished(true, errorMessage);
}
void QmitkMITKIGTTrackingToolboxViewWorker::StopTracking()
{
//stop tracking
try
{
m_TrackingDeviceSource->StopTracking();
}
catch (mitk::Exception& e)
{
emit StopTrackingFinished(false, e.GetDescription());
}
//restore the original colors of the tools
for (int i = 0; i < this->m_NavigationToolStorage->GetToolCount(); i++)
{
mitk::DataNode::Pointer currentToolNode = m_NavigationToolStorage->GetTool(i)->GetDataNode();
if (m_OriginalColors.find(currentToolNode) == m_OriginalColors.end())
{
MITK_WARN << "Cannot restore original color of tool " << m_NavigationToolStorage->GetTool(i)->GetToolName();
}
else
{
currentToolNode->SetColor(m_OriginalColors[currentToolNode]);
}
}
//emit signal
emit StopTrackingFinished(true, "");
}
void QmitkMITKIGTTrackingToolboxViewWorker::DisconnectDevice()
{
try
{
if (m_TrackingDeviceSource->IsTracking()) { m_TrackingDeviceSource->StopTracking(); }
m_TrackingDeviceSource->Disconnect();
m_TrackingDeviceSource->UnRegisterMicroservice();
m_NavigationToolStorage->UnLockStorage();
}
catch (mitk::Exception& e)
{
emit DisconnectDeviceFinished(false, e.GetDescription());
}
emit DisconnectDeviceFinished(true, "");
}
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxViewControls.ui b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxViewControls.ui
index 80774c501b..46a7777220 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxViewControls.ui
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxViewControls.ui
@@ -1,889 +1,936 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>QmitkMITKIGTTrackingToolboxViewControls</class>
<widget class="QWidget" name="QmitkMITKIGTTrackingToolboxViewControls">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>370</width>
- <height>747</height>
+ <height>723</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_3">
<item>
<widget class="QTabWidget" name="m_MainWidget">
<property name="currentIndex">
<number>0</number>
</property>
<widget class="QWidget" name="tab">
<attribute name="title">
<string>Tracking</string>
</attribute>
<layout class="QVBoxLayout" name="verticalLayout_9">
<item>
<widget class="QGroupBox" name="groupBox_3">
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="minimumSize">
<size>
<width>0</width>
<height>0</height>
</size>
</property>
<property name="maximumSize">
<size>
<width>16777215</width>
<height>280</height>
</size>
</property>
<property name="title">
<string/>
</property>
<layout class="QVBoxLayout" name="verticalLayout_4">
<item>
<widget class="QmitkTrackingDeviceConfigurationWidget" name="m_configurationWidget" native="true">
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QGroupBox" name="m_TrackingToolsGoupBox">
<property name="title">
<string/>
</property>
<layout class="QVBoxLayout" name="verticalLayout_5">
<item>
<widget class="QLabel" name="label_2">
<property name="font">
<font>
<pointsize>6</pointsize>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN" "http://www.w3.org/TR/REC-html40/strict.dtd">
<html><head><meta name="qrichtext" content="1" /><style type="text/css">
p, li { white-space: pre-wrap; }
</style></head><body style=" font-family:'MS Shell Dlg 2'; font-size:7.8pt; font-weight:400; font-style:normal;">
<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" font-size:10pt; font-weight:600;">Tracking Tools</span></p></body></html></string>
</property>
</widget>
</item>
<item>
<widget class="QStackedWidget" name="m_TrackingToolsWidget">
<property name="lineWidth">
<number>0</number>
</property>
<property name="currentIndex">
<number>0</number>
</property>
<widget class="QWidget" name="page">
<layout class="QVBoxLayout" name="verticalLayout_11">
<item>
<layout class="QHBoxLayout" name="horizontalLayout_3">
<item>
<widget class="QLabel" name="label_4">
<property name="text">
<string>ToolStorage:</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="m_toolLabel">
<property name="text">
<string><none></string>
</property>
</widget>
</item>
<item>
<spacer name="horizontalSpacer">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
</layout>
</item>
<item>
<widget class="QmitkToolTrackingStatusWidget" name="m_TrackingToolsStatusWidget" native="true">
<property name="minimumSize">
<size>
<width>200</width>
<height>80</height>
</size>
</property>
</widget>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_9">
<item>
<spacer name="horizontalSpacer_7">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>13</width>
<height>49</height>
</size>
</property>
</spacer>
</item>
<item>
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<widget class="QPushButton" name="m_AutoDetectTools">
<property name="minimumSize">
<size>
<width>120</width>
<height>0</height>
</size>
</property>
<property name="text">
<string>Auto Detection</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="m_AddSingleTool">
<property name="minimumSize">
<size>
<width>120</width>
<height>0</height>
</size>
</property>
<property name="text">
<string>Add Single Tool</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="m_LoadTools">
<property name="minimumSize">
<size>
<width>120</width>
<height>0</height>
</size>
</property>
<property name="text">
<string>Load Tool Storage</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="m_ResetTools">
<property name="minimumSize">
<size>
<width>120</width>
<height>0</height>
</size>
</property>
<property name="text">
<string>Reset</string>
</property>
</widget>
</item>
</layout>
</item>
</layout>
</item>
</layout>
</widget>
<widget class="QWidget" name="page_2">
<layout class="QVBoxLayout" name="verticalLayout_10">
<item>
<widget class="QmitkNavigationToolCreationWidget" name="m_NavigationToolCreationWidget" native="true"/>
</item>
</layout>
</widget>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QGroupBox" name="m_TrackingControlsGroupBox">
<property name="title">
<string/>
</property>
<layout class="QVBoxLayout" name="verticalLayout_2">
<item>
<widget class="QLabel" name="label_3">
<property name="text">
<string><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN" "http://www.w3.org/TR/REC-html40/strict.dtd">
<html><head><meta name="qrichtext" content="1" /><style type="text/css">
p, li { white-space: pre-wrap; }
</style></head><body style=" font-family:'MS Shell Dlg 2'; font-size:7.8pt; font-weight:400; font-style:normal;">
<p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;"><span style=" font-size:10pt; font-weight:600;">Tracking Control</span></p></body></html></string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="m_TrackingControlLabel">
<property name="text">
<string>Status: disconnected</string>
</property>
</widget>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
<spacer name="horizontalSpacer_11">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QPushButton" name="m_ConnectDisconnectButton">
<property name="minimumSize">
<size>
<width>142</width>
<height>0</height>
</size>
</property>
<property name="text">
<string>Connect</string>
</property>
</widget>
</item>
</layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_2">
<item>
<spacer name="horizontalSpacer_2">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QPushButton" name="m_StartStopTrackingButton">
<property name="minimumSize">
<size>
<width>142</width>
<height>0</height>
</size>
</property>
<property name="text">
<string>Start Tracking</string>
</property>
</widget>
</item>
</layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_11">
<item>
<spacer name="horizontalSpacer_9">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QLabel" name="m_TrackingFrozenLabel">
<property name="text">
<string><html><head/><body><p><span style=" color:#ff0000;">Tracking Frozen!</span></p></body></html></string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="m_FreezeUnfreezeTrackingButton">
<property name="enabled">
<bool>true</bool>
</property>
<property name="minimumSize">
<size>
<width>142</width>
<height>0</height>
</size>
</property>
<property name="text">
<string>Freeze Tracking</string>
</property>
</widget>
</item>
</layout>
</item>
</layout>
</widget>
</item>
<item>
<spacer name="verticalSpacer">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
<widget class="QWidget" name="tab_2">
<attribute name="title">
<string>Options</string>
</attribute>
<layout class="QVBoxLayout" name="verticalLayout_13">
<item>
<layout class="QHBoxLayout" name="horizontalLayout_12">
<item>
<widget class="QCheckBox" name="m_DisableAllTimers">
<property name="text">
<string>Disable All Timers</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="m_renderWarningLabel">
<property name="enabled">
<bool>true</bool>
</property>
<property name="text">
<string><html><head/><body><p align="right"><span style=" color:#ff0000;">Rendering Disabled!</span></p></body></html></string>
</property>
<property name="textFormat">
<enum>Qt::AutoText</enum>
</property>
</widget>
</item>
</layout>
</item>
<item>
<widget class="QGroupBox" name="m_UpdateRateOptionsGroupBox">
<property name="title">
<string>Update Rate Options</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_14">
<item>
<layout class="QHBoxLayout" name="horizontalLayout_6">
<item>
<widget class="QLabel" name="m_OptionsUpdateRateLabel">
<property name="text">
<string>Update Rate [per second]</string>
</property>
</widget>
</item>
<item>
<spacer name="horizontalSpacer_5">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QSpinBox" name="m_UpdateRate">
<property name="maximum">
<number>100</number>
</property>
<property name="value">
<number>10</number>
</property>
</widget>
</item>
</layout>
</item>
<item>
<widget class="QCheckBox" name="m_UseDifferentUpdateRates">
<property name="text">
<string>Use different Render and Log Update Rates</string>
</property>
</widget>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_8" stretch="0,0,0">
<item>
<widget class="QLabel" name="m_OptionsRenderUpdateRateLabel">
<property name="enabled">
<bool>false</bool>
</property>
<property name="text">
<string>Render Update Rate [fps]</string>
</property>
</widget>
</item>
<item>
<spacer name="horizontalSpacer_3">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QSpinBox" name="m_RenderUpdateRate">
<property name="enabled">
<bool>false</bool>
</property>
<property name="minimum">
<number>0</number>
</property>
<property name="maximum">
<number>100</number>
</property>
<property name="value">
<number>10</number>
</property>
</widget>
</item>
</layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_10">
<item>
<widget class="QLabel" name="m_OptionsLogUpdateRateLabel">
<property name="enabled">
<bool>false</bool>
</property>
<property name="text">
<string>Log Update Rate [per second]</string>
</property>
</widget>
</item>
<item>
<spacer name="horizontalSpacer_8">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QSpinBox" name="m_LogUpdateRate">
<property name="enabled">
<bool>false</bool>
</property>
<property name="minimum">
<number>1</number>
</property>
<property name="maximum">
<number>120</number>
</property>
<property name="singleStep">
<number>10</number>
</property>
<property name="value">
<number>60</number>
</property>
</widget>
</item>
</layout>
</item>
</layout>
</widget>
</item>
<item>
<widget class="QGroupBox" name="groupBox">
<property name="title">
<string>Tracking Volume Options</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_7">
<item>
<widget class="QCheckBox" name="m_ShowTrackingVolume">
<property name="enabled">
<bool>true</bool>
</property>
<property name="text">
<string>Show Tracking Volume</string>
</property>
<property name="checked">
<bool>true</bool>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="label_5">
<property name="text">
<string>Select Model:</string>
</property>
</widget>
</item>
<item>
<widget class="QComboBox" name="m_VolumeSelectionBox"/>
</item>
</layout>
</widget>
</item>
<item>
- <widget class="QGroupBox" name="m_OtherOptionsGroupBox">
+ <widget class="QGroupBox" name="groupBox_2">
<property name="title">
- <string>Other Options</string>
+ <string>Open IGT Link</string>
</property>
- <layout class="QVBoxLayout" name="verticalLayout_12">
+ <layout class="QVBoxLayout" name="verticalLayout_15">
<item>
- <widget class="QCheckBox" name="m_ShowToolQuaternions">
+ <widget class="QCheckBox" name="m_EnableOpenIGTLinkMicroService">
<property name="text">
- <string>Show Tool Quaternions</string>
+ <string>Enable Open IGT Link MicroService</string>
+ </property>
+ <property name="checked">
+ <bool>true</bool>
</property>
</widget>
</item>
<item>
- <widget class="QCheckBox" name="m_EnableOpenIGTLinkMicroService">
+ <widget class="QLabel" name="label_7">
<property name="text">
- <string>Enable Open IGT Link MicroService</string>
+ <string>Select Open IGT Link Data Format:</string>
</property>
- <property name="checked">
- <bool>true</bool>
+ </widget>
+ </item>
+ <item>
+ <widget class="QComboBox" name="m_OpenIGTLinkDataFormat">
+ <item>
+ <property name="text">
+ <string>TRANSFORM</string>
+ </property>
+ </item>
+ <item>
+ <property name="text">
+ <string>QTDATA</string>
+ </property>
+ </item>
+ <item>
+ <property name="text">
+ <string>TDATA</string>
+ </property>
+ </item>
+ <item>
+ <property name="text">
+ <string>POSITION</string>
+ </property>
+ </item>
+ </widget>
+ </item>
+ </layout>
+ </widget>
+ </item>
+ <item>
+ <widget class="QGroupBox" name="m_OtherOptionsGroupBox">
+ <property name="title">
+ <string>Other Options</string>
+ </property>
+ <layout class="QVBoxLayout" name="verticalLayout_12">
+ <item>
+ <widget class="QCheckBox" name="m_ShowToolQuaternions">
+ <property name="text">
+ <string>Show Tool Quaternions</string>
</property>
</widget>
</item>
<item>
<widget class="QCheckBox" name="m_simpleUI">
<property name="text">
<string>Simple UI</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="label_6">
<property name="text">
<string>Caution, only for backward compatibility:</string>
</property>
</widget>
</item>
<item>
<widget class="QCheckBox" name="m_InverseMode">
<property name="text">
<string>Inverse mode (Quaternions are stored inverse)</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<spacer name="verticalSpacer_3">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>600</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
<widget class="QWidget" name="tab_3">
<attribute name="title">
<string>Logging</string>
</attribute>
<layout class="QVBoxLayout" name="verticalLayout_8">
<item>
<layout class="QHBoxLayout" name="horizontalLayout_4">
<item>
<widget class="QLabel" name="label">
<property name="text">
<string>Filename:</string>
</property>
</widget>
</item>
<item>
<widget class="QLineEdit" name="m_LoggingFileName"/>
</item>
<item>
<widget class="QPushButton" name="m_ChooseFile">
<property name="text">
<string>Choose File</string>
</property>
</widget>
</item>
</layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_7">
<item>
<widget class="QCheckBox" name="m_LoggingLimit">
<property name="text">
<string>Limit Number Of Logged Frames:</string>
</property>
</widget>
</item>
<item>
<spacer name="horizontalSpacer_6">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QSpinBox" name="m_LoggedFramesLimit">
<property name="minimum">
<number>1</number>
</property>
<property name="maximum">
<number>9999</number>
</property>
<property name="value">
<number>300</number>
</property>
</widget>
</item>
</layout>
</item>
<item>
<widget class="QRadioButton" name="m_csvFormat">
<property name="text">
<string>CSV format</string>
</property>
<property name="checked">
<bool>true</bool>
</property>
</widget>
</item>
<item>
<widget class="QRadioButton" name="m_xmlFormat">
<property name="text">
<string>XML format</string>
</property>
</widget>
</item>
+ <item>
+ <widget class="QCheckBox" name="m_SkipInvalidData">
+ <property name="text">
+ <string>Skip invalid data</string>
+ </property>
+ </widget>
+ </item>
<item>
<widget class="QGroupBox" name="groupBox_4">
<property name="title">
<string>Logging Status</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout_6">
<item>
<widget class="QLabel" name="m_LoggingLabel">
<property name="text">
<string>Logging OFF</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="m_LoggedFramesLabel">
<property name="text">
<string>Logged Frames: 0</string>
</property>
</widget>
</item>
</layout>
</widget>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_5">
<item>
<spacer name="horizontalSpacer_4">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QPushButton" name="m_StartLogging">
<property name="text">
<string>Start Logging</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="m_StopLogging">
<property name="text">
<string>Stop Logging</string>
</property>
</widget>
</item>
</layout>
</item>
<item>
<spacer name="verticalSpacer_2">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
</widget>
</item>
<item>
<widget class="QWidget" name="m_simpleWidget" native="true">
<layout class="QHBoxLayout" name="horizontalLayout_13">
<item>
<layout class="QHBoxLayout" name="horizontalLayout_25">
<item>
<widget class="QPushButton" name="m_ConnectSimpleMode">
<property name="minimumSize">
<size>
<width>70</width>
<height>50</height>
</size>
</property>
<property name="text">
<string>Connect</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="m_StartTrackingSimpleMode">
<property name="minimumSize">
<size>
<width>70</width>
<height>50</height>
</size>
</property>
<property name="text">
<string>Start
Tracking</string>
</property>
</widget>
</item>
<item>
<spacer name="horizontalSpacer_21">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QPushButton" name="m_advancedUI">
<property name="minimumSize">
<size>
<width>70</width>
<height>50</height>
</size>
</property>
<property name="text">
<string>Advanced
Mode</string>
</property>
</widget>
</item>
</layout>
</item>
</layout>
</widget>
</item>
<item>
<spacer name="verticalSpacer_4">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
<layoutdefault spacing="6" margin="11"/>
<customwidgets>
<customwidget>
<class>QmitkTrackingDeviceConfigurationWidget</class>
<extends>QWidget</extends>
<header>QmitkTrackingDeviceConfigurationWidget.h</header>
<container>1</container>
</customwidget>
<customwidget>
<class>QmitkToolTrackingStatusWidget</class>
<extends>QWidget</extends>
<header>QmitkToolTrackingStatusWidget.h</header>
<container>1</container>
</customwidget>
<customwidget>
<class>QmitkNavigationToolCreationWidget</class>
<extends>QWidget</extends>
<header>QmitkNavigationToolCreationWidget.h</header>
<container>1</container>
</customwidget>
</customwidgets>
<resources/>
<connections/>
</ui>
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>