diff --git a/Applications/Workbench/target_libraries.cmake b/Applications/Workbench/target_libraries.cmake
index 454061bdda..d88d280b30 100644
--- a/Applications/Workbench/target_libraries.cmake
+++ b/Applications/Workbench/target_libraries.cmake
@@ -1,9 +1,8 @@
 
 # A list of plug-in targets which should be automatically enabled
 # (or be available in external projects) for this application.
 
 set(target_libraries
   org_blueberry_ui_qt
-  org_blueberry_ui_qt_help
   org_mitk_gui_qt_extapplication
 )
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/Algorithms/mitkPivotCalibration.cpp b/Modules/IGT/Algorithms/mitkPivotCalibration.cpp
new file mode 100644
index 0000000000..d1b519d480
--- /dev/null
+++ b/Modules/IGT/Algorithms/mitkPivotCalibration.cpp
@@ -0,0 +1,114 @@
+/*===================================================================
+
+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 "mitkPivotCalibration.h"
+#include "vnl/algo/vnl_svd.h"
+#include "vnl/vnl_matrix.h"
+#include "vnl/vnl_vector.h"
+#include <vtkMatrix4x4.h>
+
+mitk::PivotCalibration::PivotCalibration() : m_NavigationDatas(std::vector<mitk::NavigationData::Pointer>()), m_ResultPivotRotation(mitk::Quaternion(0, 0, 0, 1))
+{
+
+
+}
+
+mitk::PivotCalibration::~PivotCalibration()
+{
+
+}
+
+void mitk::PivotCalibration::AddNavigationData(mitk::NavigationData::Pointer data)
+{
+  m_NavigationDatas.push_back(data);
+}
+
+bool mitk::PivotCalibration::ComputePivotResult()
+{
+  return ComputePivotPoint();
+}
+
+bool mitk::PivotCalibration::ComputePivotPoint()
+{
+  double defaultThreshold = 1e-1;
+
+  std::vector<mitk::NavigationData::Pointer> _CheckedTransforms;
+  for (size_t i = 0; i < m_NavigationDatas.size(); ++i)
+  {
+    if (!m_NavigationDatas.at(i)->IsDataValid())
+    {
+      MITK_WARN << "Skipping invalid transform " << i << ".";
+      continue;
+    }
+    _CheckedTransforms.push_back(m_NavigationDatas.at(i));
+  }
+
+  if (_CheckedTransforms.empty())
+  {
+    MITK_WARN << "Checked Transforms are empty";
+    return false;
+  }
+
+  unsigned int rows = 3 * _CheckedTransforms.size();
+  unsigned int columns = 6;
+
+  vnl_matrix< double > A(rows, columns), minusI(3, 3, 0), R(3, 3);
+  vnl_vector< double > b(rows), x(columns), t(3);
+
+  minusI(0, 0) = -1;
+  minusI(1, 1) = -1;
+  minusI(2, 2) = -1;
+
+  //do the computation and set the internal variables
+  unsigned int currentRow = 0;
+
+
+  for (size_t i = 0; i < _CheckedTransforms.size(); ++i)
+  {
+    t = _CheckedTransforms.at(i)->GetPosition().GetVnlVector();// t = the current position of the tracked sensor
+    t *= -1;
+    b.update(t, currentRow); //b = combines the position for each collected transform in one column vector 
+    R = _CheckedTransforms.at(i)->GetOrientation().rotation_matrix_transpose().transpose(); // R = the current rotation of the tracked sensor, *rotation_matrix_transpose().transpose() is used to obtain original matrix
+    A.update(R, currentRow, 0); //A = the matrix which stores the rotations for each collected transform and -I
+    A.update(minusI, currentRow, 3);
+    currentRow += 3;
+  }
+  vnl_svd<double> svdA(A); //The singular value decomposition of matrix A
+  svdA.zero_out_absolute(defaultThreshold);
+
+  //there is a solution only if rank(A)=6 (columns are linearly
+  //independent)
+  if (svdA.rank() < 6)
+  {
+    MITK_WARN << "svdA.rank() < 6";
+    return false;
+  }
+  else
+  {
+    x = svdA.solve(b); //x = the resulting pivot point
+
+    m_ResultRMSError = (A * x - b).rms();  //the root mean sqaure error of the computation 
+
+    //sets the Pivot Point
+    m_ResultPivotPoint[0] = x[0];
+    m_ResultPivotPoint[1] = x[1];
+    m_ResultPivotPoint[2] = x[2];
+
+
+  }
+  return true;
+
+}
diff --git a/Modules/IGT/Algorithms/mitkPivotCalibration.h b/Modules/IGT/Algorithms/mitkPivotCalibration.h
new file mode 100644
index 0000000000..1caabf5358
--- /dev/null
+++ b/Modules/IGT/Algorithms/mitkPivotCalibration.h
@@ -0,0 +1,67 @@
+/*===================================================================
+
+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 PIVOTCALIBRATION_H_HEADER_INCLUDED_
+#define PIVOTCALIBRATION_H_HEADER_INCLUDED_
+
+#include "MitkIGTExports.h"
+#include <itkObject.h>
+#include <itkObjectFactory.h>
+#include <mitkCommon.h>
+#include <mitkVector.h>
+#include <mitkNavigationData.h>
+#include <vector>
+
+
+namespace mitk {
+    /**Documentation
+    * \brief Class for performing a pivot calibration out of a set of navigation datas
+    * \ingroup IGT
+    */
+  class MITKIGT_EXPORT PivotCalibration : public itk::Object
+    {
+    public:
+      mitkClassMacroItkParent(PivotCalibration, itk::Object);
+      itkNewMacro(Self);
+      void AddNavigationData(mitk::NavigationData::Pointer data);
+      /** @brief Computes the pivot point and rotation/axis on the given
+        *        navigation datas. You can get the results afterwards.
+        * @return Returns true if the computation was successfull, false if not.
+        */
+      bool ComputePivotResult();
+
+      itkGetMacro(ResultPivotPoint,mitk::Point3D);
+      itkGetMacro(ResultPivotRotation,mitk::Quaternion);
+      itkGetMacro(ResultRMSError,double);
+
+
+    protected:
+      PivotCalibration();
+      virtual ~PivotCalibration();
+
+      std::vector<mitk::NavigationData::Pointer> m_NavigationDatas;
+
+      bool ComputePivotPoint();
+      bool ComputePivotAxis();
+
+      mitk::Point3D m_ResultPivotPoint;
+      mitk::Quaternion m_ResultPivotRotation;
+      double m_ResultRMSError;
+
+    };
+} // Ende Namespace
+#endif
diff --git a/Modules/IGT/CMakeLists.txt b/Modules/IGT/CMakeLists.txt
index 6e5613a720..8246566077 100644
--- a/Modules/IGT/CMakeLists.txt
+++ b/Modules/IGT/CMakeLists.txt
@@ -1,59 +1,67 @@
 include(MITKIGTHardware.cmake)
 
 if(MITK_USE_MICRON_TRACKER)
-  set(INCLUDE_DIRS_INTERNAL ${INCLUDE_DIRS_INTERNAL} ${MITK_MICRON_TRACKER_INCLUDE_DIR})
+  set(ADDITIONAL_INCLUDE_DIRS ${ADDITIONAL_INCLUDE_DIRS} ${MITK_MICRON_TRACKER_INCLUDE_DIR})
   set(ADDITIONAL_LIBS ${ADDITIONAL_LIBS} ${MITK_MICRON_TRACKER_LIB})
 endif(MITK_USE_MICRON_TRACKER)
 
 if(MITK_USE_OPTITRACK_TRACKER)
-  set(INCLUDE_DIRS_INTERNAL ${INCLUDE_DIRS_INTERNAL} ${MITK_OPTITRACK_TRACKER_INCLUDE_DIR})
+  set(ADDITIONAL_INCLUDE_DIRS ${ADDITIONAL_INCLUDE_DIRS} ${MITK_OPTITRACK_TRACKER_INCLUDE_DIR})
   set(ADDITIONAL_LIBS ${ADDITIONAL_LIBS} ${MITK_OPTITRACK_TRACKER_LIB})
   add_definitions( -DMITK_USE_OPTITRACK_TRACKER )
 endif(MITK_USE_OPTITRACK_TRACKER)
 
 if(MITK_USE_MICROBIRD_TRACKER)
-  set(INCLUDE_DIRS_INTERNAL ${INCLUDE_DIRS_INTERNAL} ${MITK_USE_MICROBIRD_TRACKER_INCLUDE_DIR})
+  set(ADDITIONAL_INCLUDE_DIRS ${ADDITIONAL_INCLUDE_DIRS} ${MITK_USE_MICROBIRD_TRACKER_INCLUDE_DIR})
   set(ADDITIONAL_LIBS ${ADDITIONAL_LIBS} ${MITK_USE_MICROBIRD_TRACKER_LIB})
 endif(MITK_USE_MICROBIRD_TRACKER)
 
+if(MITK_USE_POLHEMUS_TRACKER)
+  set(ADDITIONAL_INCLUDE_DIRS ${ADDITIONAL_INCLUDE_DIRS} ${MITK_POLHEMUS_TRACKER_INCLUDE_DIR})
+  set(ADDITIONAL_LIBS ${ADDITIONAL_LIBS} ${MITK_POLHEMUS_TRACKER_LIB})
+endif(MITK_USE_POLHEMUS_TRACKER)
+
+message(STATUS "ADDITIONAL_INCLUDE_DIRS" ${ADDITIONAL_INCLUDE_DIRS})
+message(STATUS "ADDITIONAL_LIBS" ${ADDITIONAL_LIBS})
+
 MITK_CREATE_MODULE(
   SUBPROJECTS MITK-IGT
-  INCLUDE_DIRS Algorithms Common DataManagement ExceptionHandling IO Rendering TrackingDevices TestingHelper
-  INTERNAL_INCLUDE_DIRS ${INCLUDE_DIRS_INTERNAL}
+  INCLUDE_DIRS Algorithms Common DataManagement ExceptionHandling IO Rendering TrackingDevices TestingHelper 
+  INTERNAL_INCLUDE_DIRS ${ADDITIONAL_INCLUDE_DIRS}
   DEPENDS MitkImageStatistics MitkSceneSerialization MitkIGTBase MitkOpenIGTLink
   PACKAGE_DEPENDS ITK|ITKRegistrationCommon tinyxml OpenIGTLink
-  ADDITIONAL_LIBS "${ADDITIONAL_LIBS}"
+  ADDITIONAL_LIBS ${ADDITIONAL_LIBS}
   #WARNINGS_AS_ERRORS disabled for release 2014-03 because of bug 17463
 )
 
 if(MitkIGT_IS_ENABLED)
   MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/ClaronMicron.stl )
   MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/IntuitiveDaVinci.stl )
   MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/NDIAurora.stl )
   MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/NDIAurora_Dome.stl )
   MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/NDIAuroraCompactFG_Dome.stl )
   MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/NDIAuroraPlanarFG_Dome.stl )
   MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/NDIAuroraTabletopFG_Dome.stl )
   MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/NDIAuroraTabletopFG_Prototype_Dome.stl )
   MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/NDIPolarisOldModel.stl )
   MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/NDIPolarisSpectra.stl )
   MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/NDIPolarisSpectraExtendedPyramid.stl )
   MITK_INSTALL(FILES ${MITK_SOURCE_DIR}/Modules/IGT/Resources/NDIPolarisVicra.stl )
 endif()
 
 if(NOT MODULE_IS_ENABLED)
   message(STATUS "IGTTutorialStep1 won't be built. Missing: ${_RESULT}")
 else()
 ## create IGT config
 configure_file(mitkIGTConfig.h.in ${PROJECT_BINARY_DIR}/mitkIGTConfig.h @ONLY)
 
 # add test programm for serial communication classADD_EXECUTABLE(SerialCommunicationTest IGTTrackingDevices/mitkSerialCommunicationTest.cpp)target_link_libraries(SerialCommunicationTest mitkIGT Mitk tinyxml PocoXML)
 
 add_subdirectory(autoload/DeviceRegistry)
 
 add_subdirectory(Tutorial)
 
 add_subdirectory(Testing)
 
 endif()
 
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 b078a5f67c..2d35a82652 100644
--- a/Modules/IGT/IO/mitkNavigationToolReader.cpp
+++ b/Modules/IGT/IO/mitkNavigationToolReader.cpp
@@ -1,264 +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 e3b824091a..b07b333155 100644
--- a/Modules/IGT/IO/mitkNavigationToolWriter.cpp
+++ b/Modules/IGT/IO/mitkNavigationToolWriter.cpp
@@ -1,169 +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()!=nullptr) thisTool->SetData(Tool->GetDataNode()->GetData());
+    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 a7f4ad4eea..b18e590db4 100644
--- a/Modules/IGT/MITKIGTHardware.cmake
+++ b/Modules/IGT/MITKIGTHardware.cmake
@@ -1,42 +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/Testing/CMakeLists.txt b/Modules/IGT/Testing/CMakeLists.txt
index b4271e69c1..94d9fef6af 100644
--- a/Modules/IGT/Testing/CMakeLists.txt
+++ b/Modules/IGT/Testing/CMakeLists.txt
@@ -1,31 +1,35 @@
 if(BUILD_TESTING)
  include(MITKIGTTrackingDeviceHardwareTesting.cmake)
 endif(BUILD_TESTING)
 
 MITK_CREATE_MODULE_TESTS()
 
 if(MITK_TRACKING_DEVICES_HARDWARE_TESTS_ENABLED)
 
   if(MITK_NDI_AURORA_CONNECTED)
     mitkAddCustomModuleTest(mitkNDIAuroraHardwareTest mitkNDIAuroraHardwareTest ${MITK_NDI_AURORA_COM_PORT})
   endif(MITK_NDI_AURORA_CONNECTED)
 
   if(MITK_NDI_POLARIS_CONNECTED)
     mitkAddCustomModuleTest(mitkNDIPolarisHardwareTest mitkNDIPolarisHardwareTest ${MITK_NDI_POLARIS_COM_PORT})
   endif(MITK_NDI_POLARIS_CONNECTED)
 
   if(MITK_CLARON_MICRONTRACKER_CONNECTED)
     mitkAddCustomModuleTest(mitkClaronTrackingDeviceHardwareTest  mitkClaronTrackingDeviceHardwareTest ${MITK_DATA_DIR}/IGT-Data/MicronTrackerToolfiles/Tool_11 ${MITK_DATA_DIR}/IGT-Data/MicronTrackerToolfiles/Tool_12 ${MITK_DATA_DIR}/IGT-Data/MicronTrackerToolfiles/Tool_13)
   endif(MITK_CLARON_MICRONTRACKER_CONNECTED)
 
+  if(MITK_POLHEMUS_CONNECTED)
+    mitkAddCustomModuleTest(mitkPolhemusTrackingDeviceHardwareTest  mitkPolhemusTrackingDeviceHardwareTest)
+  endif(MITK_POLHEMUS_CONNECTED)
+
 endif(MITK_TRACKING_DEVICES_HARDWARE_TESTS_ENABLED)
 
 option(MITK_IGT_READER_WRITER_TESTS_ENABLED "Enable additional reader/writer tests of the IGT module." OFF)
 mark_as_advanced(MITK_IGT_READER_WRITER_TESTS_ENABLED)
 
 if(MITK_IGT_READER_WRITER_TESTS_ENABLED)
   mitkAddCustomModuleTest(mitkNavigationToolReaderAndWriterTest mitkNavigationToolReaderAndWriterTest)
   mitkAddCustomModuleTest(mitkNavigationToolStorageDeserializerTest mitkNavigationToolStorageDeserializerTest)
   mitkAddCustomModuleTest(mitkNavigationToolStorageSerializerAndDeserializerIntegrationTest mitkNavigationToolStorageSerializerAndDeserializerIntegrationTest)
   mitkAddCustomModuleTest(mitkNavigationToolStorageSerializerTest mitkNavigationToolStorageSerializerTest)
 endif(MITK_IGT_READER_WRITER_TESTS_ENABLED)
diff --git a/Modules/IGT/Testing/MITKIGTTrackingDeviceHardwareTesting.cmake b/Modules/IGT/Testing/MITKIGTTrackingDeviceHardwareTesting.cmake
index 90986ca608..43565a7593 100644
--- a/Modules/IGT/Testing/MITKIGTTrackingDeviceHardwareTesting.cmake
+++ b/Modules/IGT/Testing/MITKIGTTrackingDeviceHardwareTesting.cmake
@@ -1,31 +1,32 @@
 option(MITK_TRACKING_DEVICES_HARDWARE_TESTS_ENABLED "Enable support for testing tracking device hardware (this hardware must be connected to the system)" OFF)
 mark_as_advanced(MITK_TRACKING_DEVICES_HARDWARE_TESTS_ENABLED)
 
 if(MITK_TRACKING_DEVICES_HARDWARE_TESTS_ENABLED)
   option(MITK_NDI_AURORA_CONNECTED "Turn on if an Aurora system is connected and should be tested." OFF)
   option(MITK_NDI_POLARIS_CONNECTED "Turn on if a Polaris system is connected and should be tested." OFF)
+  option(MITK_POLHEMUS_CONNECTED "Turn on if a Polhemus system is connected and should be tested." OFF)
   option(MITK_CLARON_MICRONTRACKER_CONNECTED "Turn on if a MicronTracker system is connected and should be tested." OFF)
   mark_as_advanced(MITK_NDI_AURORA_CONNECTED MITK_NDI_POLARIS_CONNECTED MITK_CLARON_MICRONTRACKER_CONNECTED MITK_CLARON_MICRONTRACKER_CONNECTED)
 endif(MITK_TRACKING_DEVICES_HARDWARE_TESTS_ENABLED)
 
 if(MITK_NDI_AURORA_CONNECTED)
 if(WIN32)
    set(MITK_NDI_AURORA_COM_PORT "1" CACHE STRING "Serial port where the system is connected.")
 else(WIN32)
    set(MITK_NDI_AURORA_COM_PORT "/dev/ttyS1" CACHE STRING "Device path where the system is connected. (e.g. /dev/ttyS6 or /dev/ttyUSB1)")
 endif(WIN32)
 endif(MITK_NDI_AURORA_CONNECTED)
 
 if(MITK_NDI_POLARIS_CONNECTED)
 if(WIN32)
    set(MITK_NDI_POLARIS_COM_PORT "1" CACHE STRING "Serial port where the system is connected.")
 else(WIN32)
    set(MITK_NDI_POLARIS_COM_PORT "/dev/ttyS1" CACHE STRING "Device path where the system is connected. (e.g. /dev/ttyS6 or /dev/ttyUSB1)")
 endif(WIN32)
 endif(MITK_NDI_POLARIS_CONNECTED)
 
 if(MITK_CLARON_MICRONTRACKER_CONNECTED)
 if(WIN32)
     find_path(MITK_MICRON_TRACKER_CALIBRATION_DIR BumbleBee_6400420.calib DOC "Path which contains the MT2 calibration file.")
 endif(WIN32)
 endif(MITK_CLARON_MICRONTRACKER_CONNECTED)
diff --git a/Modules/IGT/Testing/files.cmake b/Modules/IGT/Testing/files.cmake
index 3f3bb46b60..4be7accede 100644
--- a/Modules/IGT/Testing/files.cmake
+++ b/Modules/IGT/Testing/files.cmake
@@ -1,67 +1,75 @@
 set(MODULE_TESTS
    # IMPORTANT: If you plan to deactivate / comment out a test please write a bug number to the commented out line of code.
    #
    #     Example: #mitkMyTest #this test is commented out because of bug 12345
    #
    # It is important that the bug is open and that the test will be activated again before the bug is closed. This assures that
    # no test is forgotten after it was commented out. If there is no bug for your current problem, please add a new one and
    # mark it as critical.
 
    ################## ON THE FENCE TESTS #################################################
    # none
 
    ################## DISABLED TESTS #####################################################
 
 
    ################# RUNNING TESTS #######################################################
    mitkCameraVisualizationTest.cpp
    mitkClaronInterfaceTest.cpp
    mitkClaronToolTest.cpp
    mitkClaronTrackingDeviceTest.cpp
    mitkInternalTrackingToolTest.cpp
    mitkNavigationDataDisplacementFilterTest.cpp
    mitkNavigationDataLandmarkTransformFilterTest.cpp
    mitkNavigationDataObjectVisualizationFilterTest.cpp
    mitkNavigationDataSetTest.cpp
    mitkNavigationDataTest.cpp
    mitkNavigationDataRecorderTest.cpp
    mitkNavigationDataReferenceTransformFilterTest.cpp
    mitkNavigationDataSequentialPlayerTest.cpp
    mitkNavigationDataSetReaderWriterXMLTest.cpp
    mitkNavigationDataSetReaderWriterCSVTest.cpp
    mitkNavigationDataSourceTest.cpp
    mitkNavigationDataToMessageFilterTest.cpp
    mitkNavigationDataToNavigationDataFilterTest.cpp
    mitkNavigationDataToPointSetFilterTest.cpp
    mitkNavigationDataToIGTLMessageFilterTest.cpp
    mitkNavigationDataTransformFilterTest.cpp
    mitkNDIPassiveToolTest.cpp
    mitkNDIProtocolTest.cpp
    mitkNDITrackingDeviceTest.cpp
    mitkTimeStampTest.cpp
    mitkTrackingVolumeGeneratorTest.cpp
    mitkTrackingDeviceTest.cpp
    mitkTrackingToolTest.cpp
    mitkVirtualTrackingDeviceTest.cpp
    # mitkNavigationDataPlayerTest.cpp # random fails see bug 16485.
    # We decided to won't fix because of complete restructuring via bug 15959.
    mitkTrackingDeviceSourceTest.cpp
    mitkTrackingDeviceSourceConfiguratorTest.cpp
    mitkNavigationDataEvaluationFilterTest.cpp
    mitkTrackingTypesTest.cpp
    mitkOpenIGTLinkTrackingDeviceTest.cpp
    # ------------------ Navigation Tool Management Tests -------------------
    mitkNavigationToolStorageDeserializerTest.cpp # Activated experimentally on dart clients, see task T17303 for details.
    mitkNavigationToolStorageTest.cpp
    mitkNavigationToolTest.cpp
    # -----------------------------------------------------------------------
 )
 
 set(MODULE_CUSTOM_TESTS
   mitkNDIAuroraHardwareTest.cpp
   mitkNDIPolarisHardwareTest.cpp
   mitkClaronTrackingDeviceHardwareTest.cpp
   mitkNavigationToolReaderAndWriterTest.cpp #deactivated because of bug 18835
   mitkNavigationToolStorageSerializerAndDeserializerIntegrationTest.cpp # This test was disabled because of bug 17181.
   mitkNavigationToolStorageSerializerTest.cpp # This test was disabled because of bug 18671
+  #mitkPolhemusTrackingDeviceHardwareTest.cpp
 )
+
+if(MITK_USE_POLHEMUS_TRACKER)
+set(MODULE_CUSTOM_TESTS
+  ${MODULE_CUSTOM_TESTS}
+  mitkPolhemusTrackingDeviceHardwareTest.cpp
+)
+endif(MITK_USE_POLHEMUS_TRACKER)
diff --git a/Modules/IGT/Testing/mitkPolhemusTrackingDeviceHardwareTest.cpp b/Modules/IGT/Testing/mitkPolhemusTrackingDeviceHardwareTest.cpp
new file mode 100644
index 0000000000..5538870444
--- /dev/null
+++ b/Modules/IGT/Testing/mitkPolhemusTrackingDeviceHardwareTest.cpp
@@ -0,0 +1,65 @@
+/*===================================================================
+
+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"
+#include "mitkTestingMacros.h"
+#include "mitkStandardFileLocations.h"
+#include <mitkIGTConfig.h>
+
+// Testing
+#include "mitkTestingMacros.h"
+#include "mitkTestFixture.h"
+
+class mitkPolhemusTrackingDeviceHardwareTestSuite : public mitk::TestFixture
+{
+  CPPUNIT_TEST_SUITE(mitkPolhemusTrackingDeviceHardwareTestSuite);
+  // Test the append method
+  MITK_TEST(testInterface);
+  CPPUNIT_TEST_SUITE_END();
+
+
+public:
+  void setUp() override
+  {
+
+  }
+  void tearDown() override
+  {
+
+  }
+
+  void testInterface()
+  {
+    mitk::PolhemusInterface::Pointer myInterface = mitk::PolhemusInterface::New();
+    CPPUNIT_ASSERT_MESSAGE("Testing connection.", myInterface->Connect());
+    CPPUNIT_ASSERT_MESSAGE("Start tracking.", myInterface->StartTracking());
+
+    CPPUNIT_ASSERT_MESSAGE("Tracking 20 frames ...", true);
+    for (int i = 0; i < 20; i++)
+    {
+      std::vector<mitk::PolhemusInterface::trackingData> lastFrame = myInterface->GetLastFrame();
+      MITK_INFO << "Frame " << i;
+      for (int j = 0; j < lastFrame.size(); j++)
+      {
+        MITK_INFO << "[" << j << "]" << " Pos:" << lastFrame.at(j).pos << " Rot:" << lastFrame.at(j).rot;
+      }
+    }
+
+  }
+
+};
+
+MITK_TEST_SUITE_REGISTRATION(mitkPolhemusTrackingDeviceHardware)
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/mitkNDITrackingDevice.cpp b/Modules/IGT/TrackingDevices/mitkNDITrackingDevice.cpp
index f8c8292534..04a190ddaa 100644
--- a/Modules/IGT/TrackingDevices/mitkNDITrackingDevice.cpp
+++ b/Modules/IGT/TrackingDevices/mitkNDITrackingDevice.cpp
@@ -1,1282 +1,1335 @@
 /*===================================================================
 
 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 "mitkNDITrackingDevice.h"
 #include "mitkIGTTimeStamp.h"
 #include "mitkIGTHardwareException.h"
 #include <stdio.h>
 
 #include <itksys/SystemTools.hxx>
 #include <itkMutexLockHolder.h>
 
 #include <mitkUnspecifiedTrackingTypeInformation.h>
 
 #include <mitkNDIPolarisTypeInformation.h>
 #include <mitkNDIAuroraTypeInformation.h>
 
+// vtk
+#include <vtkSphereSource.h>
+
 typedef itk::MutexLockHolder<itk::FastMutexLock> MutexLockHolder;
 
 
 const unsigned char CR = 0xD; // == '\r' - carriage return
 const unsigned char LF = 0xA; // == '\n' - line feed
 
 
 mitk::NDITrackingDevice::NDITrackingDevice() :
 TrackingDevice(),m_DeviceName(""), m_PortNumber(mitk::SerialCommunication::COM5), m_BaudRate(mitk::SerialCommunication::BaudRate9600),
 m_DataBits(mitk::SerialCommunication::DataBits8), m_Parity(mitk::SerialCommunication::None), m_StopBits(mitk::SerialCommunication::StopBits1),
 m_HardwareHandshake(mitk::SerialCommunication::HardwareHandshakeOff),
 m_IlluminationActivationRate(Hz20), m_DataTransferMode(TX), m_6DTools(), m_ToolsMutex(nullptr),
 m_SerialCommunication(nullptr), m_SerialCommunicationMutex(nullptr), m_DeviceProtocol(nullptr),
 m_MultiThreader(nullptr), m_ThreadID(0), m_OperationMode(ToolTracking6D), m_MarkerPointsMutex(nullptr), m_MarkerPoints()
 {
   m_Data = mitk::UnspecifiedTrackingTypeInformation::GetDeviceDataUnspecified();
   m_6DTools.clear();
   m_SerialCommunicationMutex = itk::FastMutexLock::New();
   m_DeviceProtocol = NDIProtocol::New();
   m_DeviceProtocol->SetTrackingDevice(this);
   m_DeviceProtocol->UseCRCOn();
   m_MultiThreader = itk::MultiThreader::New();
   m_ToolsMutex = itk::FastMutexLock::New();
   m_MarkerPointsMutex = itk::FastMutexLock::New();
   m_MarkerPoints.reserve(50);   // a maximum of 50 marker positions can be reported by the tracking device
 }
 
 
 bool mitk::NDITrackingDevice::UpdateTool(mitk::TrackingTool* tool)
 {
   if (this->GetState() != Setup)
   {
     mitk::NDIPassiveTool* ndiTool = dynamic_cast<mitk::NDIPassiveTool*>(tool);
     if (ndiTool == nullptr)
       return false;
 
     std::string portHandle = ndiTool->GetPortHandle();
 
     //return false if the SROM Data has not been set
     if (ndiTool->GetSROMData() == nullptr)
       return false;
 
     NDIErrorCode returnvalue;
     returnvalue = m_DeviceProtocol->PVWR(&portHandle, ndiTool->GetSROMData(), ndiTool->GetSROMDataLength());
     if (returnvalue != NDIOKAY)
       return false;
     returnvalue = m_DeviceProtocol->PINIT(&portHandle);
     if (returnvalue != NDIOKAY)
       return false;
     returnvalue = m_DeviceProtocol->PENA(&portHandle, ndiTool->GetTrackingPriority()); // Enable tool
     if (returnvalue != NDIOKAY)
       return false;
 
     return true;
   }
   else
   {
     return false;
   }
 }
 
 void mitk::NDITrackingDevice::SetRotationMode(RotationMode r)
 {
   m_RotationMode = r;
 }
 
 mitk::NDITrackingDevice::~NDITrackingDevice()
 {
   /* stop tracking and disconnect from tracking device */
   if (GetState() == Tracking)
   {
     this->StopTracking();
   }
   if (GetState() == Ready)
   {
     this->CloseConnection();
   }
   /* cleanup tracking thread */
   if ((m_ThreadID != 0) && (m_MultiThreader.IsNotNull()))
   {
     m_MultiThreader->TerminateThread(m_ThreadID);
   }
   m_MultiThreader = nullptr;
   /* free serial communication interface */
   if (m_SerialCommunication.IsNotNull())
   {
     m_SerialCommunication->ClearReceiveBuffer();
     m_SerialCommunication->ClearSendBuffer();
     m_SerialCommunication->CloseConnection();
     m_SerialCommunication = nullptr;
   }
 }
 
 
 void mitk::NDITrackingDevice::SetPortNumber(const PortNumber _arg)
 {
   if (this->GetState() != Setup)
     return;
   itkDebugMacro("setting PortNumber to " << _arg);
   if (this->m_PortNumber != _arg)
   {
     this->m_PortNumber = _arg;
     this->Modified();
   }
 }
 
 
 void mitk::NDITrackingDevice::SetDeviceName(std::string _arg)
 {
   if (this->GetState() != Setup)
     return;
   itkDebugMacro("setting eviceName to " << _arg);
   if (this->m_DeviceName != _arg)
   {
     this->m_DeviceName = _arg;
     this->Modified();
   }
 }
 
 
 void mitk::NDITrackingDevice::SetBaudRate(const BaudRate _arg)
 {
   if (this->GetState() != Setup)
     return;
   itkDebugMacro("setting BaudRate to " << _arg);
   if (this->m_BaudRate != _arg)
   {
     this->m_BaudRate = _arg;
     this->Modified();
   }
 }
 
 
 void mitk::NDITrackingDevice::SetDataBits(const DataBits _arg)
 {
   if (this->GetState() != Setup)
     return;
   itkDebugMacro("setting DataBits to " << _arg);
   if (this->m_DataBits != _arg)
   {
     this->m_DataBits = _arg;
     this->Modified();
   }
 }
 
 
 void mitk::NDITrackingDevice::SetParity(const Parity _arg)
 {
   if (this->GetState() != Setup)
     return;
   itkDebugMacro("setting Parity to " << _arg);
   if (this->m_Parity != _arg)
   {
     this->m_Parity = _arg;
     this->Modified();
   }
 }
 
 
 void mitk::NDITrackingDevice::SetStopBits(const StopBits _arg)
 {
   if (this->GetState() != Setup)
     return;
   itkDebugMacro("setting StopBits to " << _arg);
   if (this->m_StopBits != _arg)
   {
     this->m_StopBits = _arg;
     this->Modified();
   }
 }
 
 
 void mitk::NDITrackingDevice::SetHardwareHandshake(const HardwareHandshake _arg)
 {
   if (this->GetState() != Setup)
     return;
   itkDebugMacro("setting HardwareHandshake to " << _arg);
   if (this->m_HardwareHandshake != _arg)
   {
     this->m_HardwareHandshake = _arg;
     this->Modified();
   }
 }
 
 
 void mitk::NDITrackingDevice::SetIlluminationActivationRate(const IlluminationActivationRate _arg)
 {
   if (this->GetState() == Tracking)
     return;
   itkDebugMacro("setting IlluminationActivationRate to " << _arg);
   if (this->m_IlluminationActivationRate != _arg)
   {
     this->m_IlluminationActivationRate = _arg;
     this->Modified();
     if (this->GetState() == Ready)   // if the connection to the tracking system is established, send the new rate to the tracking device too
       m_DeviceProtocol->IRATE(this->m_IlluminationActivationRate);
   }
 }
 
 
 void mitk::NDITrackingDevice::SetDataTransferMode(const DataTransferMode _arg)
 {
   itkDebugMacro("setting DataTransferMode to " << _arg);
   if (this->m_DataTransferMode != _arg)
   {
     this->m_DataTransferMode = _arg;
     this->Modified();
   }
 }
 
 
 mitk::NDIErrorCode mitk::NDITrackingDevice::Send(const std::string* input, bool addCRC)
 {
   if (input == nullptr)
     return SERIALSENDERROR;
 
   std::string message;
 
   if (addCRC == true)
     message = *input + CalcCRC(input) + std::string(1, CR);
   else
     message = *input + std::string(1, CR);
 
   //unsigned int messageLength = message.length() + 1; // +1 for CR
 
   // Clear send buffer
   this->ClearSendBuffer();
   // Send the date to the device
   MutexLockHolder lock(*m_SerialCommunicationMutex); // lock and unlock the mutex
   long returnvalue = m_SerialCommunication->Send(message);
 
   if (returnvalue == 0)
     return SERIALSENDERROR;
   else
     return NDIOKAY;
 }
 
 
 mitk::NDIErrorCode mitk::NDITrackingDevice::Receive(std::string* answer, unsigned int numberOfBytes)
 {
   if (answer == nullptr)
     return SERIALRECEIVEERROR;
 
   MutexLockHolder lock(*m_SerialCommunicationMutex); // lock and unlock the mutex
   long returnvalue = m_SerialCommunication->Receive(*answer, numberOfBytes);  // never read more bytes than the device has send, the function will block until enough bytes are send...
 
   if (returnvalue == 0)
     return SERIALRECEIVEERROR;
   else
     return NDIOKAY;
 }
 
 
 mitk::NDIErrorCode mitk::NDITrackingDevice::ReceiveByte(char* answer)
 {
   if (answer == nullptr)
     return SERIALRECEIVEERROR;
 
   std::string m;
 
   MutexLockHolder lock(*m_SerialCommunicationMutex); // lock and unlock the mutex
 
   long returnvalue = m_SerialCommunication->Receive(m, 1);
 
   if ((returnvalue == 0) ||(m.size() != 1))
     return SERIALRECEIVEERROR;
 
   *answer = m.at(0);
   return NDIOKAY;
 }
 
 
 mitk::NDIErrorCode mitk::NDITrackingDevice::ReceiveLine(std::string* answer)
 {
   if (answer == nullptr)
     return SERIALRECEIVEERROR;
 
   std::string m;
 
   MutexLockHolder lock(*m_SerialCommunicationMutex); // lock and unlock the mutex
 
   do
   {
     long returnvalue = m_SerialCommunication->Receive(m, 1);
     if ((returnvalue == 0) ||(m.size() != 1))
       return SERIALRECEIVEERROR;
     *answer += m;
   } while (m.at(0) != LF);
   return NDIOKAY;
 }
 
 
 void mitk::NDITrackingDevice::ClearSendBuffer()
 {
   MutexLockHolder lock(*m_SerialCommunicationMutex); // lock and unlock the mutex
   m_SerialCommunication->ClearSendBuffer();
 }
 
 
 void mitk::NDITrackingDevice::ClearReceiveBuffer()
 {
   MutexLockHolder lock(*m_SerialCommunicationMutex); // lock and unlock the mutex
   m_SerialCommunication->ClearReceiveBuffer();
 }
 
 
 const std::string mitk::NDITrackingDevice::CalcCRC(const std::string* input)
 {
 
   if (input == nullptr)
     return "";
   /* the crc16 calculation code is taken from the NDI API guide example code section */
   static int oddparity[16] = {0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0};
   unsigned int data;  // copy of the input string's current character
   unsigned int crcValue = 0;  // the crc value is stored here
   unsigned int* puCRC16 = &crcValue;  // the algorithm uses a pointer to crcValue, so it's easier to provide that than to change the algorithm
   for (unsigned int i = 0; i < input->length(); i++)
   {
     data = (*input)[i];
     data = (data ^ (*(puCRC16) & 0xff)) & 0xff;
     *puCRC16 >>= 8;
     if (oddparity[data & 0x0f] ^ oddparity[data >> 4])
     {
       *(puCRC16) ^= 0xc001;
     }
     data <<= 6;
     *puCRC16 ^= data;
     data <<= 1;
     *puCRC16 ^= data;
   }
   // crcValue contains now the CRC16 value. Convert it to a string and return it
   char returnvalue[13];
   sprintf(returnvalue,"%04X", crcValue);  // 4 hexadecimal digit with uppercase format
   return std::string(returnvalue);
 }
 
 bool mitk::NDITrackingDevice::OpenConnection()
 {
 
   //this->m_ModeMutex->Lock();
   if (this->GetState() != Setup)
     {mitkThrowException(mitk::IGTException) << "Can only try to open the connection if in setup mode";}
 
   m_SerialCommunication = mitk::SerialCommunication::New();
 
   /* init local com port to standard com settings for a NDI tracking device:
   9600 baud, 8 data bits, no parity, 1 stop bit, no hardware handshake */
   if (m_DeviceName.empty())
     m_SerialCommunication->SetPortNumber(m_PortNumber);
   else
     m_SerialCommunication->SetDeviceName(m_DeviceName);
   m_SerialCommunication->SetBaudRate(mitk::SerialCommunication::BaudRate9600);
   m_SerialCommunication->SetDataBits(mitk::SerialCommunication::DataBits8);
   m_SerialCommunication->SetParity(mitk::SerialCommunication::None);
   m_SerialCommunication->SetStopBits(mitk::SerialCommunication::StopBits1);
   m_SerialCommunication->SetSendTimeout(5000);
   m_SerialCommunication->SetReceiveTimeout(5000);
   if (m_SerialCommunication->OpenConnection() == 0) // 0 == ERROR_VALUE
   {
     m_SerialCommunication->CloseConnection();
     m_SerialCommunication = nullptr;
     mitkThrowException(mitk::IGTHardwareException) << "Can not open serial port";
   }
 
   /* Reset Tracking device by sending a serial break for 500ms */
   m_SerialCommunication->SendBreak(400);
 
   /* Read answer from tracking device (RESETBE6F) */
   static const std::string reset("RESETBE6F\r");
   std::string answer = "";
   this->Receive(&answer, reset.length());  // read answer (should be RESETBE6F)
   this->ClearReceiveBuffer();     // flush the receive buffer of all remaining data (carriage return, strings other than reset
   if (reset.compare(answer) != 0)  // check for RESETBE6F
   {
     if (m_SerialCommunication.IsNotNull())
     {
       m_SerialCommunication->CloseConnection();
       m_SerialCommunication = nullptr;
     }
     mitkThrowException(mitk::IGTHardwareException) << "Hardware Reset of tracking device did not work";
   }
 
   /* Now the tracking device isSetData reset, start initialization */
   NDIErrorCode returnvalue;
 
   /* set device com settings to new values and wait for the device to change them */
   returnvalue = m_DeviceProtocol->COMM(m_BaudRate, m_DataBits, m_Parity, m_StopBits, m_HardwareHandshake);
 
   if (returnvalue != NDIOKAY)
     {mitkThrowException(mitk::IGTHardwareException) << "Could not set comm settings in trackingdevice";}
 
   //after changing COMM wait at least 100ms according to NDI Api documentation page 31
   itksys::SystemTools::Delay(500);
 
   /* now change local com settings accordingly */
   m_SerialCommunication->CloseConnection();
   m_SerialCommunication->SetBaudRate(m_BaudRate);
   m_SerialCommunication->SetDataBits(m_DataBits);
   m_SerialCommunication->SetParity(m_Parity);
   m_SerialCommunication->SetStopBits(m_StopBits);
   m_SerialCommunication->SetHardwareHandshake(m_HardwareHandshake);
   m_SerialCommunication->SetSendTimeout(5000);
   m_SerialCommunication->SetReceiveTimeout(5000);
   m_SerialCommunication->OpenConnection();
 
 
   /* initialize the tracking device */
   returnvalue = m_DeviceProtocol->INIT();
   if (returnvalue != NDIOKAY)
     {mitkThrowException(mitk::IGTHardwareException) << "Could not initialize the tracking device";}
 
   if (this->GetType() == mitk::UnspecifiedTrackingTypeInformation::GetTrackingDeviceName())  // if the type of tracking device is not specified, try to query the connected device
   {
     mitk::TrackingDeviceType deviceType;
     returnvalue = m_DeviceProtocol->VER(deviceType);
     if ((returnvalue != NDIOKAY) || (deviceType == mitk::UnspecifiedTrackingTypeInformation::GetTrackingDeviceName()))
       {mitkThrowException(mitk::IGTHardwareException) << "Could not determine tracking device type. Please set manually and try again.";}
     this->SetType(deviceType);
   }
 
   /****  Optional Polaris specific code, Work in progress
   // start diagnostic mode
   returnvalue = m_DeviceProtocol->DSTART();
   if (returnvalue != NDIOKAY)
   {
   this->SetErrorMessage("Could not start diagnostic mode");
   return false;
   }
   else    // we are in diagnostic mode
   {
   // initialize extensive IR checking
   returnvalue = m_DeviceProtocol->IRINIT();
   if (returnvalue != NDIOKAY)
   {
   this->SetErrorMessage("Could not initialize intense infrared light checking");
   return false;
   }
   bool intenseIR = false;
   returnvalue = m_DeviceProtocol->IRCHK(&intenseIR);
   if (returnvalue != NDIOKAY)
   {
   this->SetErrorMessage("Could not execute intense infrared light checking");
   return false;
   }
   if (intenseIR == true)
   // do something - warn the user, raise exception, write to protocol or similar
   std::cout << "Warning: Intense infrared light detected. Accurate tracking will probably not be possible.\n";
 
   // stop diagnictic mode
   returnvalue = m_DeviceProtocol->DSTOP();
   if (returnvalue != NDIOKAY)
   {
   this->SetErrorMessage("Could not stop diagnostic mode");
   return false;
   }
   }
   *** end of optional polaris code ***/
 
   /**
   * now add tools to the tracking system
   **/
 
   /* First, check if the tracking device has port handles that need to be freed and free them */
   returnvalue = FreePortHandles();
   // non-critical, therefore no error handling
 
   /**
   * POLARIS: initialize the tools that were added manually
   **/
   {
 
     MutexLockHolder toolsMutexLockHolder(*m_ToolsMutex); // lock and unlock the mutex
     std::string portHandle;
     auto endIt = m_6DTools.end();
     for(auto it = m_6DTools.begin(); it != endIt; ++it)
     {
       /* get a port handle for the tool */
       returnvalue = m_DeviceProtocol->PHRQ(&portHandle);
       if (returnvalue == NDIOKAY)
       {
         (*it)->SetPortHandle(portHandle.c_str());
         /* now write the SROM file of the tool to the tracking system using PVWR */
     if (this->m_Data.Line == mitk::NDIPolarisTypeInformation::GetTrackingDeviceName())
         {
           returnvalue = m_DeviceProtocol->PVWR(&portHandle, (*it)->GetSROMData(), (*it)->GetSROMDataLength());
           if (returnvalue != NDIOKAY)
             {mitkThrowException(mitk::IGTHardwareException) << (std::string("Could not write SROM file for tool '") + (*it)->GetToolName() + std::string("' to tracking device")).c_str();}
 
           returnvalue = m_DeviceProtocol->PINIT(&portHandle);
           if (returnvalue != NDIOKAY)
             {mitkThrowException(mitk::IGTHardwareException) << (std::string("Could not initialize tool '") + (*it)->GetToolName()).c_str();}
 
           if ((*it)->IsEnabled() == true)
           {
             returnvalue = m_DeviceProtocol->PENA(&portHandle, (*it)->GetTrackingPriority()); // Enable tool
             if (returnvalue != NDIOKAY)
             {
               mitkThrowException(mitk::IGTHardwareException) << (std::string("Could not enable port '") + portHandle +
                 std::string("' for tool '")+ (*it)->GetToolName() + std::string("'")).c_str();
             }
           }
         }
       }
     }
   } // end of toolsmutexlockholder scope
 
   /* check for wired tools and add them too */
   if (this->DiscoverWiredTools() == false)  // query the tracking device for wired tools and add them to our tool list
     return false; // \TODO: could we continue anyways?
 
 
   /*POLARIS: set the illuminator activation rate */
   if (this->m_Data.Line == mitk::NDIPolarisTypeInformation::GetTrackingDeviceName())
   {
     returnvalue = m_DeviceProtocol->IRATE(this->m_IlluminationActivationRate);
     if (returnvalue != NDIOKAY)
       {mitkThrowException(mitk::IGTHardwareException) << "Could not set the illuminator activation rate";}
   }
   /* finish  - now all tools should be added, initialized and enabled, so that tracking can be started */
   this->SetState(Ready);
   try
   {
     SetVolume(this->m_Data);
   }
   catch (mitk::IGTHardwareException e)
   {
     MITK_WARN<<e.GetDescription();
   }
 
   return true;
 }
 
 bool mitk::NDITrackingDevice::InitializeWiredTools()
 {
   NDIErrorCode returnvalue;
   std::string portHandle;
   returnvalue = m_DeviceProtocol->PHSR(OCCUPIED, &portHandle);
 
   if (returnvalue != NDIOKAY)
     {mitkThrowException(mitk::IGTHardwareException) << "Could not obtain a list of port handles that are connected";}
 
   /* if there are port handles that need to be initialized, initialize them. Furthermore instantiate tools for each handle that has no tool yet. */
   std::string ph;
 
   for (unsigned int i = 0; i < portHandle.size(); i += 2)
   {
     ph = portHandle.substr(i, 2);
     mitk::NDIPassiveTool* pt = this->GetInternalTool(ph);
     if ( pt == nullptr) // if we don't have a tool, something is wrong. Tools should be discovered first by calling DiscoverWiredTools()
       continue;
 
     if (pt->GetSROMData() == nullptr)
       continue;
 
     returnvalue = m_DeviceProtocol->PVWR(&ph, pt->GetSROMData(), pt->GetSROMDataLength());
     if (returnvalue != NDIOKAY)
       {mitkThrowException(mitk::IGTHardwareException) << (std::string("Could not write SROM file for tool '") + pt->GetToolName() + std::string("' to tracking device")).c_str();}
 
     returnvalue = m_DeviceProtocol->PINIT(&ph);
     if (returnvalue != NDIOKAY)
       {mitkThrowException(mitk::IGTHardwareException) << (std::string("Could not initialize tool '") + pt->GetToolName()).c_str();}
 
     if (pt->IsEnabled() == true)
     {
       returnvalue = m_DeviceProtocol->PENA(&ph, pt->GetTrackingPriority()); // Enable tool
       if (returnvalue != NDIOKAY)
       {
         mitkThrowException(mitk::IGTHardwareException) << (std::string("Could not enable port '") + portHandle +
           std::string("' for tool '")+ pt->GetToolName() + std::string("'")).c_str();
       }
     }
   }
   return true;
 }
 
 
 mitk::TrackingDeviceType mitk::NDITrackingDevice::TestConnection()
 {
   if (this->GetState() != Setup)
   {
     return mitk::UnspecifiedTrackingTypeInformation::GetTrackingDeviceName();
   }
 
   m_SerialCommunication = mitk::SerialCommunication::New();
   //m_DeviceProtocol =  mitk::NDIProtocol::New();
   //m_DeviceProtocol->SetTrackingDevice(this);
   //m_DeviceProtocol->UseCRCOn();
   /* init local com port to standard com settings for a NDI tracking device:
   9600 baud, 8 data bits, no parity, 1 stop bit, no hardware handshake
   */
   if (m_DeviceName.empty())
     m_SerialCommunication->SetPortNumber(m_PortNumber);
   else
     m_SerialCommunication->SetDeviceName(m_DeviceName);
 
   m_SerialCommunication->SetBaudRate(mitk::SerialCommunication::BaudRate9600);
   m_SerialCommunication->SetDataBits(mitk::SerialCommunication::DataBits8);
   m_SerialCommunication->SetParity(mitk::SerialCommunication::None);
   m_SerialCommunication->SetStopBits(mitk::SerialCommunication::StopBits1);
   m_SerialCommunication->SetSendTimeout(5000);
   m_SerialCommunication->SetReceiveTimeout(5000);
   if (m_SerialCommunication->OpenConnection() == 0) // error
   {
     m_SerialCommunication = nullptr;
     return mitk::UnspecifiedTrackingTypeInformation::GetTrackingDeviceName();
   }
 
   /* Reset Tracking device by sending a serial break for 500ms */
   m_SerialCommunication->SendBreak(400);
 
   /* Read answer from tracking device (RESETBE6F) */
   static const std::string reset("RESETBE6F\r");
   std::string answer = "";
   this->Receive(&answer, reset.length());  // read answer (should be RESETBE6F)
   this->ClearReceiveBuffer();     // flush the receive buffer of all remaining data (carriage return, strings other than reset
   if (reset.compare(answer) != 0)  // check for RESETBE6F
   {
     m_SerialCommunication->CloseConnection();
     m_SerialCommunication = nullptr;
     mitkThrowException(mitk::IGTHardwareException) << "Hardware Reset of tracking device did not work";
   }
 
   /* Now the tracking device is reset, start initialization */
   NDIErrorCode returnvalue;
 
   /* initialize the tracking device */
   //returnvalue = m_DeviceProtocol->INIT();
   //if (returnvalue != NDIOKAY)
   //{
   //  this->SetErrorMessage("Could not initialize the tracking device");
   //  return mitk::TrackingSystemNotSpecified;
   //}
 
 
     mitk::TrackingDeviceType deviceType;
     returnvalue = m_DeviceProtocol->VER(deviceType);
     if ((returnvalue != NDIOKAY) || (deviceType == mitk::UnspecifiedTrackingTypeInformation::GetTrackingDeviceName()))
     {
       m_SerialCommunication = nullptr;
       return mitk::UnspecifiedTrackingTypeInformation::GetTrackingDeviceName();
     }
     m_SerialCommunication = nullptr;
     return deviceType;
 }
 
 
 bool mitk::NDITrackingDevice::CloseConnection()
 {
   if (this->GetState() != Setup)
   {
     //init before closing to force the field generator from aurora to switch itself off
     m_DeviceProtocol->INIT();
     /* close the serial connection */
     m_SerialCommunication->CloseConnection();
     /* invalidate all tools */
     this->InvalidateAll();
     /* return to setup mode */
     this->SetState(Setup);
     m_SerialCommunication = nullptr;
   }
   return true;
 }
 
 
 ITK_THREAD_RETURN_TYPE mitk::NDITrackingDevice::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;
   }
   NDITrackingDevice *trackingDevice = (NDITrackingDevice*)pInfo->UserData;
   if (trackingDevice != nullptr)
   {
     if (trackingDevice->GetOperationMode() == ToolTracking6D)
       trackingDevice->TrackTools();             // call TrackTools() from the original object
     else if (trackingDevice->GetOperationMode() == MarkerTracking3D)
       trackingDevice->TrackMarkerPositions();   // call TrackMarkerPositions() from the original object
     else if (trackingDevice->GetOperationMode() == ToolTracking5D)
       trackingDevice->TrackMarkerPositions(); // call TrackMarkerPositions() from the original object
     else if (trackingDevice->GetOperationMode() == HybridTracking)
     {
       trackingDevice->TrackToolsAndMarkers();
     }
   }
   trackingDevice->m_ThreadID = 0;  // erase thread id, now that this thread will end.
   return ITK_THREAD_RETURN_VALUE;
 }
 
 
 bool mitk::NDITrackingDevice::StartTracking()
 {
   if (this->GetState() != Ready)
     return false;
 
   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();
 
   m_ThreadID = m_MultiThreader->SpawnThread(this->ThreadStartTracking, this);    // start a new thread that executes the TrackTools() method
   mitk::IGTTimeStamp::GetInstance()->Start(this);
   return true;
 }
 
 
 void mitk::NDITrackingDevice::TrackTools()
 {
   /* 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
 
   if (this->GetState() != Tracking)
     return;
 
   NDIErrorCode returnvalue;
   returnvalue = m_DeviceProtocol->TSTART();
   if (returnvalue != NDIOKAY)
     return;
 
 
 
   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))
   {
     if (this->m_DataTransferMode == TX)
     {
       returnvalue = this->m_DeviceProtocol->TX();
       if (!((returnvalue == NDIOKAY) || (returnvalue == NDICRCERROR) || (returnvalue == NDICRCDOESNOTMATCH))) // right now, do not stop on crc errors
         break;
     }
     else
     {
       returnvalue = this->m_DeviceProtocol->BX();
       if (returnvalue != NDIOKAY)
         break;
     }
     /* Update the local copy of m_StopTracking */
     this->m_StopTrackingMutex->Lock();
     localStopTracking = m_StopTracking;
     this->m_StopTrackingMutex->Unlock();
   }
   /* StopTracking was called, thus the mode should be changed back to Ready now that the tracking loop has ended. */
 
   returnvalue = m_DeviceProtocol->TSTOP();
   if (returnvalue != NDIOKAY)
     {mitkThrowException(mitk::IGTHardwareException) << "An error occured while tracking tools.";}
 
   return;       // returning from this function (and ThreadStartTracking()) this will end the thread and transfer control back to main thread by releasing trackingFinishedLockHolder
 }
 
 
 void mitk::NDITrackingDevice::TrackMarkerPositions()
 {
   MutexLockHolder trackingFinishedLockHolder(*m_TrackingFinishedMutex); // keep lock until end of scope
 
   if (m_OperationMode == ToolTracking6D)
     return;
 
   if (this->GetState() != Tracking)
     return;
 
   NDIErrorCode returnvalue;
 
   returnvalue = m_DeviceProtocol->DSTART();   // Start Diagnostic Mode
   if (returnvalue != NDIOKAY)
     return;
 
   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))
   {
     m_MarkerPointsMutex->Lock();                                    // lock points data structure
     returnvalue = this->m_DeviceProtocol->POS3D(&m_MarkerPoints); // update points data structure with new position data from tracking device
     m_MarkerPointsMutex->Unlock();
     if (!((returnvalue == NDIOKAY) || (returnvalue == NDICRCERROR) || (returnvalue == NDICRCDOESNOTMATCH))) // right now, do not stop on crc errors
     {
       std::cout << "Error in POS3D: could not read data. Possibly no markers present." << std::endl;
     }
     /* Update the local copy of m_StopTracking */
     this->m_StopTrackingMutex->Lock();
     localStopTracking = m_StopTracking;
     this->m_StopTrackingMutex->Unlock();
 
     itksys::SystemTools::Delay(1);
   }
   /* StopTracking was called, thus the mode should be changed back to Ready now that the tracking loop has ended. */
   returnvalue = m_DeviceProtocol->DSTOP();
   if (returnvalue != NDIOKAY)
     return;     // how can this thread tell the application, that an error has occured?
 
   this->SetState(Ready);
   return;       // returning from this function (and ThreadStartTracking()) this will end the thread
 }
 
 
 void mitk::NDITrackingDevice::TrackToolsAndMarkers()
 {
 
   MutexLockHolder trackingFinishedLockHolder(*m_TrackingFinishedMutex); // keep lock until end of scope
   if (m_OperationMode != HybridTracking)
     return;
 
   NDIErrorCode returnvalue;
 
   returnvalue = m_DeviceProtocol->TSTART();   // Start Diagnostic Mode
   if (returnvalue != NDIOKAY)
     return;
 
   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))
   {
     m_MarkerPointsMutex->Lock();                                     // lock points data structure
     returnvalue = this->m_DeviceProtocol->TX(true, &m_MarkerPoints); // update points data structure with new position data from tracking device
     m_MarkerPointsMutex->Unlock();
     if (!((returnvalue == NDIOKAY) || (returnvalue == NDICRCERROR) || (returnvalue == NDICRCDOESNOTMATCH))) // right now, do not stop on crc errors
     {
       std::cout << "Error in TX: could not read data. Possibly no markers present." << std::endl;
     }
     /* Update the local copy of m_StopTracking */
     this->m_StopTrackingMutex->Lock();
     localStopTracking = m_StopTracking;
     this->m_StopTrackingMutex->Unlock();
   }
   /* StopTracking was called, thus the mode should be changed back to Ready now that the tracking loop has ended. */
 
   returnvalue = m_DeviceProtocol->TSTOP();
   if (returnvalue != NDIOKAY)
     return;     // how can this thread tell the application, that an error has occurred?
 
   this->SetState(Ready);
   return;       // returning from this function (and ThreadStartTracking()) this will end the thread
 }
 
 
 mitk::TrackingTool* mitk::NDITrackingDevice::GetTool(unsigned int toolNumber) const
 {
   MutexLockHolder toolsMutexLockHolder(*m_ToolsMutex); // lock and unlock the mutex
   if (toolNumber < m_6DTools.size())
     return m_6DTools.at(toolNumber);
   return nullptr;
 }
 
 
 mitk::TrackingTool* mitk::NDITrackingDevice::GetToolByName(std::string name) const
 {
   MutexLockHolder toolsMutexLockHolder(*m_ToolsMutex); // lock and unlock the mutex
   auto end = m_6DTools.end();
   for (auto iterator = m_6DTools.begin(); iterator != end; ++iterator)
     if (name.compare((*iterator)->GetToolName()) == 0)
       return *iterator;
   return nullptr;
 }
 
 
 mitk::NDIPassiveTool* mitk::NDITrackingDevice::GetInternalTool(std::string portHandle)
 {
   MutexLockHolder toolsMutexLockHolder(*m_ToolsMutex); // lock and unlock the mutex
   auto end = m_6DTools.end();
   for (auto iterator = m_6DTools.begin(); iterator != end; ++iterator)
     if (portHandle.compare((*iterator)->GetPortHandle()) == 0)
       return *iterator;
   return nullptr;
 }
 
 
 unsigned int mitk::NDITrackingDevice::GetToolCount() const
 {
   MutexLockHolder toolsMutexLockHolder(*m_ToolsMutex); // lock and unlock the mutex
   return m_6DTools.size();
 }
 
 
 bool mitk::NDITrackingDevice::Beep(unsigned char count)
 {
   if (this->GetState() != Setup)
   {
     return (m_DeviceProtocol->BEEP(count) == NDIOKAY);
   }
   else
   {
     return false;
   }
 }
 
 mitk::TrackingTool* mitk::NDITrackingDevice::AddTool( const char* toolName, const char* fileName, TrackingPriority p /*= NDIPassiveTool::Dynamic*/ )
 {
   mitk::NDIPassiveTool::Pointer t = mitk::NDIPassiveTool::New();
   if (t->LoadSROMFile(fileName) == false)
     return nullptr;
   t->SetToolName(toolName);
   t->SetTrackingPriority(p);
   if (this->InternalAddTool(t) == false)
     return nullptr;
   return t.GetPointer();
 }
 
 
 bool mitk::NDITrackingDevice::InternalAddTool(mitk::NDIPassiveTool* tool)
 {
   if (tool == nullptr)
     return false;
   NDIPassiveTool::Pointer p = tool;
   /* if the connection to the tracking device is already established, add the new tool to the device now */
   if (this->GetState() == Ready)
   {
     /* get a port handle for the tool */
     std::string newPortHandle;
     NDIErrorCode returnvalue;
     returnvalue = m_DeviceProtocol->PHRQ(&newPortHandle);
     if (returnvalue == NDIOKAY)
     {
       p->SetPortHandle(newPortHandle.c_str());
       /* now write the SROM file of the tool to the tracking system using PVWR */
       returnvalue = m_DeviceProtocol->PVWR(&newPortHandle, p->GetSROMData(), p->GetSROMDataLength());
       if (returnvalue != NDIOKAY)
         {mitkThrowException(mitk::IGTHardwareException) << (std::string("Could not write SROM file for tool '") + p->GetToolName() + std::string("' to tracking device")).c_str();}
       /* initialize the port handle */
       returnvalue = m_DeviceProtocol->PINIT(&newPortHandle);
       if (returnvalue != NDIOKAY)
         {
           mitkThrowException(mitk::IGTHardwareException) << (std::string("Could not initialize port '") + newPortHandle +
           std::string("' for tool '")+ p->GetToolName() + std::string("'")).c_str();
         }
       /* enable the port handle */
       if (p->IsEnabled() == true)
       {
         returnvalue = m_DeviceProtocol->PENA(&newPortHandle, p->GetTrackingPriority()); // Enable tool
         if (returnvalue != NDIOKAY)
         {
           mitkThrowException(mitk::IGTHardwareException) << (std::string("Could not enable port '") + newPortHandle +
             std::string("' for tool '")+ p->GetToolName() + std::string("'")).c_str();
         }
       }
     }
     /* now that the tool is added to the device, add it to list too */
     m_ToolsMutex->Lock();
     this->m_6DTools.push_back(p);
     m_ToolsMutex->Unlock();
     this->Modified();
     return true;
   }
   else if (this->GetState() == Setup)
   {
     /* In Setup mode, we only add it to the list, so that OpenConnection() can add it later */
     m_ToolsMutex->Lock();
     this->m_6DTools.push_back(p);
     m_ToolsMutex->Unlock();
     this->Modified();
     return true;
   }
   else  // in Tracking mode, no tools can be added
     return false;
 }
 
 
 bool mitk::NDITrackingDevice::RemoveTool(mitk::TrackingTool* tool)
 {
   mitk::NDIPassiveTool* ndiTool = dynamic_cast<mitk::NDIPassiveTool*>(tool);
   if (ndiTool == nullptr)
     return false;
 
   std::string portHandle = ndiTool->GetPortHandle();
   /* a valid portHandle has length 2. If a valid handle exists, the tool is already added to the tracking device, so we have to remove it there
   if the connection to the tracking device has already been established.
   */
   if ((portHandle.length() == 2) && (this->GetState() == Ready))  // do not remove a tool in tracking mode
   {
     NDIErrorCode returnvalue;
     returnvalue = m_DeviceProtocol->PHF(&portHandle);
     if (returnvalue != NDIOKAY)
       return false;
     /* Now that the tool is removed from the tracking device, remove it from our tool list too */
     MutexLockHolder toolsMutexLockHolder(*m_ToolsMutex); // lock and unlock the mutex (scope is inside the if-block
     auto end = m_6DTools.end();
     for (auto iterator = m_6DTools.begin(); iterator != end; ++iterator)
     {
       if (iterator->GetPointer() == ndiTool)
       {
         m_6DTools.erase(iterator);
         this->Modified();
         return true;
       }
     }
     return false;
   }
   else if (this->GetState() == Setup)  // in Setup Mode, we are not connected to the tracking device, so we can just remove the tool from the tool list
   {
     MutexLockHolder toolsMutexLockHolder(*m_ToolsMutex); // lock and unlock the mutex
     auto end = m_6DTools.end();
     for (auto iterator = m_6DTools.begin(); iterator != end; ++iterator)
     {
       if ((*iterator).GetPointer() == ndiTool)
       {
         m_6DTools.erase(iterator);
         this->Modified();
         return true;
       }
     }
     return false;
   }
   return false;
 }
 
 
 void mitk::NDITrackingDevice::InvalidateAll()
 {
   MutexLockHolder toolsMutexLockHolder(*m_ToolsMutex); // lock and unlock the mutex
   auto end = m_6DTools.end();
   for (auto iterator = m_6DTools.begin(); iterator != end; ++iterator)
     (*iterator)->SetDataValid(false);
 }
 
 
 bool mitk::NDITrackingDevice::SetOperationMode(OperationMode mode)
 {
   if (GetState() == Tracking)
     return false;
 
   m_OperationMode = mode;
   return true;
 }
 
 
 mitk::OperationMode mitk::NDITrackingDevice::GetOperationMode()
 {
   return m_OperationMode;
 }
 
 
 bool mitk::NDITrackingDevice::GetMarkerPositions(MarkerPointContainerType* markerpositions)
 {
   m_MarkerPointsMutex->Lock();
   *markerpositions = m_MarkerPoints;  // copy the internal vector to the one provided
   m_MarkerPointsMutex->Unlock();
   return (markerpositions->size() != 0)  ;
 }
 
 
 bool mitk::NDITrackingDevice::DiscoverWiredTools()
 {
   /* First, check for disconnected tools and remove them */
   this->FreePortHandles();
 
   /* check for new tools, add and initialize them */
   NDIErrorCode returnvalue;
   std::string portHandle;
   returnvalue = m_DeviceProtocol->PHSR(OCCUPIED, &portHandle);
 
   if (returnvalue != NDIOKAY)
     {mitkThrowException(mitk::IGTHardwareException) << "Could not obtain a list of port handles that are connected";}
 
   /* if there are port handles that need to be initialized, initialize them. Furthermore instantiate tools for each handle that has no tool yet. */
   std::string ph;
 
   /* we need to remember the ports which are occupied to be able to readout the serial numbers of the connected tools later */
   std::vector<int> occupiedPorts = std::vector<int>();
   int numberOfToolsAtStart = this->GetToolCount(); //also remember the number of tools at start to identify the automatically detected tools later
 
   for (unsigned int i = 0; i < portHandle.size(); i += 2)
   {
     ph = portHandle.substr(i, 2);
     if (this->GetInternalTool(ph) != nullptr) // if we already have a tool with this handle
       continue;                            // then skip the initialization
 
     //instantiate an object for each tool that is connected
     mitk::NDIPassiveTool::Pointer newTool = mitk::NDIPassiveTool::New();
     newTool->SetPortHandle(ph.c_str());
     newTool->SetTrackingPriority(mitk::NDIPassiveTool::Dynamic);
 
     //set a name for identification
     newTool->SetToolName((std::string("Port ") + ph).c_str());
 
     returnvalue = m_DeviceProtocol->PINIT(&ph);
     if (returnvalue != NDIINITIALIZATIONFAILED) //if the initialization failed (AURORA) it can not be enabled. A srom file will have to be specified manually first. Still return true to be able to continue
     {
       if (returnvalue != NDIOKAY)
       {
         mitkThrowException(mitk::IGTHardwareException) << (std::string("Could not initialize port '") + ph +
           std::string("' for tool '")+ newTool->GetToolName() + std::string("'")).c_str();
       }
       /* enable the port handle */
       returnvalue = m_DeviceProtocol->PENA(&ph, newTool->GetTrackingPriority()); // Enable tool
       if (returnvalue != NDIOKAY)
       {
         mitkThrowException(mitk::IGTHardwareException) << (std::string("Could not enable port '") + ph +
           std::string("' for tool '")+ newTool->GetToolName() + std::string("'")).c_str();
       }
     }
     //we have to temporarily unlock m_ModeMutex here to avoid a deadlock with another lock inside InternalAddTool()
     if (this->InternalAddTool(newTool) == false)
       {mitkThrowException(mitk::IGTException) << "Error while adding new tool";}
     else occupiedPorts.push_back(i);
   }
 
 
   // after initialization readout serial numbers of automatically detected tools
   for (unsigned int i = 0; i < occupiedPorts.size(); i++)
     {
     ph = portHandle.substr(occupiedPorts.at(i), 2);
     std::string portInfo;
     NDIErrorCode returnvaluePort = m_DeviceProtocol->PHINF(ph, &portInfo);
     if ((returnvaluePort==NDIOKAY) && (portInfo.size()>31)) dynamic_cast<mitk::NDIPassiveTool*>(this->GetTool(i+numberOfToolsAtStart))->SetSerialNumber(portInfo.substr(23,8));
     itksys::SystemTools::Delay(10);
     }
 
   return true;
 }
 
 
 mitk::NDIErrorCode mitk::NDITrackingDevice::FreePortHandles()
 {
   /*  first search for port handles that need to be freed: e.g. because of a reset of the tracking system */
   NDIErrorCode returnvalue = NDIOKAY;
   std::string portHandle;
   returnvalue = m_DeviceProtocol->PHSR(FREED, &portHandle);
   if (returnvalue != NDIOKAY)
     {mitkThrowException(mitk::IGTHardwareException) << "Could not obtain a list of port handles that need to be freed";}
 
   /* if there are port handles that need to be freed, free them */
   if (portHandle.empty() == true)
     return returnvalue;
 
   std::string ph;
   for (unsigned int i = 0; i < portHandle.size(); i += 2)
   {
     ph = portHandle.substr(i, 2);
 
     mitk::NDIPassiveTool* t = this->GetInternalTool(ph);
     if (t != nullptr)  // if we have a tool for the port handle that needs to be freed
     {
       if (this->RemoveTool(t) == false)  // remove it (this will free the port too)
         returnvalue = NDIERROR;
     }
     else  // we don't have a tool, the port handle exists only in the tracking device
     {
       returnvalue = m_DeviceProtocol->PHF(&ph);  // free it there
       // What to do if port handle could not be freed? This seems to be a non critical error
       if (returnvalue != NDIOKAY)
         {mitkThrowException(mitk::IGTHardwareException) << "Could not free all port handles";}
     }
   }
   return returnvalue;
 }
 
 
 int mitk::NDITrackingDevice::GetMajorFirmwareRevisionNumber()
 {
   std::string revision;
   if (m_DeviceProtocol->APIREV(&revision) != mitk::NDIOKAY || revision.empty() || (revision.size() != 9) )
   {
     MITK_ERROR << "Could not receive firmware revision number!";
     return 0;
   }
 
   const std::string majrevno = revision.substr(2,3); //cut out "004" from "D.004.001"
 
   return std::atoi(majrevno.c_str());
 }
 
 const char* mitk::NDITrackingDevice::GetFirmwareRevisionNumber()
 {
   static std::string revision;
   if (m_DeviceProtocol->APIREV(&revision) != mitk::NDIOKAY || revision.empty() || (revision.size() != 9) )
   {
     MITK_ERROR << "Could not receive firmware revision number!";
     revision = "";
     return revision.c_str();
   }
   return revision.c_str();
 }
 
+bool mitk::NDITrackingDevice::AutoDetectToolsAvailable()
+{
+  if (this->GetType() == mitk::NDIAuroraTypeInformation::GetTrackingDeviceName()) { return true; }
+  else { return false; }
+}
+
+mitk::NavigationToolStorage::Pointer mitk::NDITrackingDevice::AutoDetectTools()
+{
+  mitk::NavigationToolStorage::Pointer autoDetectedStorage = mitk::NavigationToolStorage::New();
+  if (this->GetType() == mitk::NDIAuroraTypeInformation::GetTrackingDeviceName())
+  {
+    try
+    {
+      this->OpenConnection();
+      this->StartTracking();
+    }
+    catch (mitk::Exception& e)
+    {
+      MITK_WARN << "Warning, can not auto-detect tools! (" << e.GetDescription() << ")";
+      return autoDetectedStorage;
+    }
+
+    for (unsigned int i = 0; i < this->GetToolCount(); i++)
+    {
+      //create a navigation tool with sphere as surface
+      std::stringstream toolname;
+      toolname << "AutoDetectedTool" << i;
+      mitk::NavigationTool::Pointer newTool = mitk::NavigationTool::New();
+      newTool->SetSerialNumber(dynamic_cast<mitk::NDIPassiveTool*>(this->GetTool(i))->GetSerialNumber());
+      newTool->SetIdentifier(toolname.str());
+      newTool->SetTrackingDeviceType(mitk::NDIAuroraTypeInformation::GetTrackingDeviceName());
+      mitk::DataNode::Pointer newNode = mitk::DataNode::New();
+      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();
+      newNode->SetData(mySphere);
+      newNode->SetName(toolname.str());
+      newTool->SetDataNode(newNode);
+      autoDetectedStorage->AddTool(newTool);
+    }
+    this->StopTracking();
+    this->CloseConnection();
+  }
+  return autoDetectedStorage;
+}
+
 bool mitk::NDITrackingDevice::GetSupportedVolumes(unsigned int* numberOfVolumes, mitk::NDITrackingDevice::NDITrackingVolumeContainerType* volumes, mitk::NDITrackingDevice::TrackingVolumeDimensionType* volumesDimensions)
 {
   if (numberOfVolumes == nullptr || volumes == nullptr || volumesDimensions == nullptr)
     return false;
 
   static std::string info;
   if (m_DeviceProtocol->SFLIST(&info) != mitk::NDIOKAY || info.empty())
   {
     MITK_ERROR << "Could not receive tracking volume information of tracking system!";
     return false;
   }
 
   /*info contains the following:
   <HEX:number of volumes> (+n times:) <HEX:shape type> <shape parameters D1-D10> <HEX:reserved / number of wavelength supported> <metal resistant / supported wavelength>
   */
   (*numberOfVolumes) = (unsigned int) std::atoi(info.substr(0,1).c_str());
 
   for (unsigned int i=0; i<(*numberOfVolumes); i++)
   {
     //e.g. for cube:  "9-025000+025000-025000+025000-055000-005000+000000+000000+000000+00000011"
     //for dome:       "A+005000+048000+005000+066000+000000+000000+000000+000000+000000+00000011"
 
     std::string::size_type offset, end;
     offset = (i*73)+1;
     end = 73+(i*73);
     std::string currentVolume = info.substr(offset, end);//i=0: from 1 to 73 characters; i=1: from 75 to 148 char;
     // if i>0 then we have a return statement <LF> infront
     if (i>0)
       currentVolume = currentVolume.substr(1, currentVolume.size());
     if (currentVolume.compare(0, 1, NDIPolarisTypeInformation::GetDeviceDataPolarisOldModel().HardwareCode) == 0)
       volumes->push_back(NDIPolarisTypeInformation::GetDeviceDataPolarisOldModel().Model);
     if (currentVolume.compare(0, 3, NDIPolarisTypeInformation::GetDeviceDataPolarisSpectra().HardwareCode) == 0)
       volumes->push_back(NDIPolarisTypeInformation::GetDeviceDataPolarisSpectra().Model);
     if (currentVolume.compare(1, 3, NDIPolarisTypeInformation::GetDeviceDataSpectraExtendedPyramid().HardwareCode) == 0)
     {
       currentVolume = currentVolume.substr(1,currentVolume.size());
       volumes->push_back(NDIPolarisTypeInformation::GetDeviceDataSpectraExtendedPyramid().Model);
     }
     if (currentVolume.compare(0, 1, NDIPolarisTypeInformation::GetDeviceDataPolarisVicra().HardwareCode) == 0)
       volumes->push_back(NDIPolarisTypeInformation::GetDeviceDataPolarisVicra().Model);
     else if (currentVolume.compare(0, 1, mitk::NDIAuroraTypeInformation::GetDeviceDataAuroraPlanarCube().HardwareCode) == 0)
       volumes->push_back(mitk::NDIAuroraTypeInformation::GetDeviceDataAuroraPlanarCube().Model);//alias cube
     else if (currentVolume.compare(0, 1, mitk::NDIAuroraTypeInformation::GetDeviceDataAuroraPlanarDome().HardwareCode) == 0)
       volumes->push_back(mitk::NDIAuroraTypeInformation::GetDeviceDataAuroraPlanarDome().Model);
 
     //fill volumesDimensions
     for (unsigned int index = 0; index < 10; index++)
     {
       std::string::size_type offD, endD;
       offD = 1+(index*7); //7 digits per dimension and the first is the type of volume
       endD = offD+7;
       int dimension = std::atoi(currentVolume.substr(offD, endD).c_str());
       dimension /= 100; //given in mm. 7 digits are xxxx.xx according to NDI //strange, the last two digits (11) also for the metal flag get read also...
       volumesDimensions->push_back(dimension);
     }
   }
 
   return true;
 }
 
 bool mitk::NDITrackingDevice::SetVolume(mitk::TrackingDeviceData volume)
 {
   if (m_DeviceProtocol->VSEL(volume) != mitk::NDIOKAY)
   {
     mitkThrowException(mitk::IGTHardwareException) << "Could not set volume!";
   }
   return true;
 }
 
diff --git a/Modules/IGT/TrackingDevices/mitkNDITrackingDevice.h b/Modules/IGT/TrackingDevices/mitkNDITrackingDevice.h
index ce320dbcb3..9895aa12fe 100644
--- a/Modules/IGT/TrackingDevices/mitkNDITrackingDevice.h
+++ b/Modules/IGT/TrackingDevices/mitkNDITrackingDevice.h
@@ -1,324 +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.
 
 ===================================================================*/
 
 
 #ifndef MITKNDITRACKINGDEVICE_H_HEADER_INCLUDED_C1C2FCD2
 #define MITKNDITRACKINGDEVICE_H_HEADER_INCLUDED_C1C2FCD2
 
 #include "mitkTrackingDevice.h"
 
 #include <MitkIGTExports.h>
 #include <itkMultiThreader.h>
 #include "itkFastMutexLock.h"
 #include <vector>
 
 #include "mitkNDIProtocol.h"
 #include "mitkNDIPassiveTool.h"
 #include "mitkSerialCommunication.h"
 
 
 namespace mitk
 {
   class NDIProtocol;
 
   /** Documentation
   * \brief superclass for specific NDI tracking Devices that use serial communication.
   *
   * implements the TrackingDevice interface for NDI tracking devices (POLARIS, AURORA)
   *
   * \ingroup IGT
   */
   class MITKIGT_EXPORT NDITrackingDevice : public TrackingDevice
   {
     friend class NDIProtocol;
 
   public:
     typedef std::vector<NDIPassiveTool::Pointer> Tool6DContainerType;  ///< List of 6D tools of the correct type for this tracking device
 
     typedef mitk::TrackingDeviceType NDITrackingDeviceType;  ///< This enumeration includes the two types of NDI tracking devices (Polaris, Aurora).
     typedef mitk::SerialCommunication::PortNumber PortNumber; ///< Port number of the serial connection
     typedef mitk::SerialCommunication::BaudRate BaudRate;     ///< Baud rate of the serial connection
     typedef mitk::SerialCommunication::DataBits DataBits;     ///< Number of data bits used in the serial connection
     typedef mitk::SerialCommunication::Parity Parity;         ///< Parity mode used in the serial connection
     typedef mitk::SerialCommunication::StopBits StopBits;     ///< Number of stop bits used in the serial connection
     typedef mitk::SerialCommunication::HardwareHandshake HardwareHandshake; ///< Hardware handshake mode of the serial connection
     typedef mitk::NDIPassiveTool::TrackingPriority TrackingPriority; ///< Tracking priority used for tracking a tool
 
     mitkClassMacro(NDITrackingDevice, TrackingDevice);
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     /**
     * \brief Set the type of the NDI Tracking Device because it can not jet handle this itself
     */
     //itkSetMacro(Type, TrackingDeviceType);
 
 
     /**
     * \brief initialize the connection to the tracking device
     *
     * OpenConnection() establishes the connection to the tracking device by:
     * - initializing the serial port with the given parameters (port number, baud rate, ...)
     * - connection to the tracking device
     * - initializing the device
     * - initializing all manually added passive tools (user supplied srom file)
     * - initializing active tools that are connected to the tracking device
     * @throw mitk::IGTHardwareException Throws an exception if there are errors while connecting to the device.
     * @throw mitk::IGTException Throws a normal IGT exception if an error occures which is not related to the hardware.
     */
     virtual bool OpenConnection() override;
 
     /**
     * \brief Closes the connection
     *
     * CloseConnection() resets the tracking device, invalidates all tools and then closes the serial port.
     */
     virtual bool CloseConnection() override;
 
     /** @throw mitk::IGTHardwareException Throws an exception if there are errors while connecting to the device. */
     bool InitializeWiredTools();
 
     /** Sets the rotation mode of this class. See documentation of enum RotationMode for details
      *  on the different modes.
      */
     virtual void SetRotationMode(RotationMode r) override;
 
     /**
     * \brief TestConnection() tries to connect to a NDI tracking device on the current port/device and returns which device it has found
     *
     * TestConnection() tries to connect to a NDI tracking device on the current port/device.
     * \return It returns the type of the device that answers at the port/device. Throws an exception if no device is available on that port.
     * @throw mitk::IGTHardwareException Throws an exception if there are errors while connecting to the device.
     */
     virtual mitk::TrackingDeviceType TestConnection();
 
     /**
     * \brief retrieves all wired tools from the tracking device
     *
     * This method queries the tracking device for all wired tools, initializes them and creates TrackingTool representation objects
     * for them
     * \return True if the method was executed successful.
     * @throw mitk::IGTHardwareException Throws an exception if there are errors while connecting to the device.
     * @throw mitk::IGTException Throws a normal IGT exception if an error occures which is not related to the hardware.
     */
     bool DiscoverWiredTools();
 
     /**
     * \brief Start the tracking.
     *
     * A new thread is created, which continuously reads the position and orientation information of each tool and stores them inside the tools.
     * Depending on the current operation mode (see SetOperationMode()), either the 6D tools (ToolTracking6D), 5D tools (ToolTracking5D),
     * 3D marker positions (MarkerTracking3D) or both 6D tools and 3D markers (HybridTracking) are updated.
     * Call StopTracking() to stop the tracking thread.
     */
     virtual bool StartTracking() override;
 
     /**
     * \brief return the tool with index toolNumber
     */
     virtual TrackingTool* GetTool(unsigned int toolNumber) const override;
 
     virtual mitk::TrackingTool* GetToolByName(std::string name) const override;
     /**
     * \brief return current number of tools
     */
     virtual unsigned int GetToolCount() const override;
 
     /**
     * \brief Create a passive 6D tool with toolName and fileName and add it to the list of tools
     *
     * This method will create a new NDIPassiveTool object, load the SROM file fileName,
     * set the tool name toolName and the tracking priority p and then add
     * it to the list of tools. It returns a pointer of type mitk::TrackingTool to the tool
     * that can be used to read tracking data from it.
     * This is the only way to add tools to NDITrackingDevice.
     * @throw mitk::IGTHardwareException Throws an exception if there are errors while adding the tool.
     *
     * \warning adding tools is not possible in tracking mode, only in setup and ready.
     */
     mitk::TrackingTool* AddTool(const char* toolName, const char* fileName, TrackingPriority p = NDIPassiveTool::Dynamic);
 
     /**
     * \brief Remove a passive 6D tool from the list of tracked tools.
     *
     * \warning removing tools is not possible in tracking mode, only in setup and ready modes.
     */
     virtual bool RemoveTool(TrackingTool* tool);
 
     /**
     * \brief reloads the srom file and reinitializes the tool
     */
     virtual bool UpdateTool(mitk::TrackingTool* tool);
 
     virtual void SetPortNumber(const PortNumber _arg); ///< set port number for serial communication
     itkGetConstMacro(PortNumber, PortNumber);          ///< returns the port number for serial communication
     virtual void SetDeviceName(std::string _arg);      ///< set device name (e.g. COM1, /dev/ttyUSB0). If this is set, PortNumber will be ignored
     itkGetStringMacro(DeviceName);                     ///< returns the device name for serial communication
     virtual void SetBaudRate(const BaudRate _arg);     ///< set baud rate for serial communication
     itkGetConstMacro(BaudRate, BaudRate);              ///< returns the baud rate for serial communication
     virtual void SetDataBits(const DataBits _arg);     ///< set number of data bits
     itkGetConstMacro(DataBits, DataBits);              ///< returns the data bits for serial communication
     virtual void SetParity(const Parity _arg);         ///< set parity mode
     itkGetConstMacro(Parity, Parity);                  ///< returns the parity mode
     virtual void SetStopBits(const StopBits _arg);     ///< set number of stop bits
     itkGetConstMacro(StopBits, StopBits);              ///< returns the number of stop bits
     virtual void SetHardwareHandshake(const HardwareHandshake _arg);  ///< set use hardware handshake for serial communication
     itkGetConstMacro(HardwareHandshake, HardwareHandshake);              ///< returns the hardware handshake setting
     virtual void SetIlluminationActivationRate(const IlluminationActivationRate _arg); ///< set activation rate of IR illumator for polaris
     itkGetConstMacro(IlluminationActivationRate, IlluminationActivationRate);          ///< returns the activation rate of IR illumator for polaris
     virtual void SetDataTransferMode(const DataTransferMode _arg);    ///< set data transfer mode to text (TX) or binary (BX). \warning: only TX is supportet at the moment
     itkGetConstMacro(DataTransferMode, DataTransferMode);              ///< returns the data transfer mode
     virtual bool Beep(unsigned char count);   ///< Beep the tracking device 1 to 9 times
 
     NDIErrorCode GetErrorCode(const std::string* input);  ///< returns the error code for a string that contains an error code in hexadecimal format
 
     virtual bool SetOperationMode(OperationMode mode);  ///< set operation mode to 6D tool tracking, 3D marker tracking or 6D&3D hybrid tracking (see OperationMode)
     virtual OperationMode GetOperationMode();           ///< get current operation mode
 
     /**
     * \brief Get 3D marker positions (operation mode must be set to MarkerTracking3D or HybridTracking)
     */
     virtual bool GetMarkerPositions(MarkerPointContainerType* markerpositions);
 
     /**
     * \brief Get major revision number from tracking device
     * should not be called directly after starting to track
     **/
     virtual int GetMajorFirmwareRevisionNumber();
 
     /**
     * \brief Get revision number from tracking device as string
     * should not be called directly after starting to track
     **/
     virtual const char* GetFirmwareRevisionNumber();
 
+    /** @return Returns true if this device can autodetects its tools. */
+    virtual bool AutoDetectToolsAvailable();
 
+    /** Autodetects tools from this device and returns them as a navigation tool storage.
+    *  @return Returns the detected tools. Returns an empty storage if no tools are present
+    *          or if detection is not possible
+    */
+    virtual mitk::NavigationToolStorage::Pointer AutoDetectTools();
 
 
 
   protected:
 
     typedef std::vector<std::string> NDITrackingVolumeContainerType;  ///< vector of tracking volumes
     typedef std::vector<int> TrackingVolumeDimensionType;          ///< List of the supported tracking volume dimensions.
 
         /**
     * \brief Get number of supported tracking volumes, a vector containing the supported volumes and
     * a vector containing the signed dimensions in mm. For each volume 10 boundaries are stored in the order of
     * the supported volumes (see AURORA API GUIDE: SFLIST p.54).
     **/
     virtual bool GetSupportedVolumes(unsigned int* numberOfVolumes, NDITrackingVolumeContainerType* volumes, TrackingVolumeDimensionType* volumesDimensions);
 
        /**
     * \brief Sets the desired tracking volume. Returns true if the volume type could be set. It is set in the OpenConnection() Method and sets the tracking volume out of m_Data.
     * @throw mitk::IGTHardwareException Throws an IGT hardware exception if the volume could not be set.
     **/
     virtual bool SetVolume(mitk::TrackingDeviceData volume);
 
     /**
     * \brief Add a passive 6D tool to the list of tracked tools. This method is used by AddTool
     * @throw mitk::IGTHardwareException Throws an exception if there are errors while adding the tool.
     * \warning adding tools is not possible in tracking mode, only in setup and ready.
     */
     virtual bool InternalAddTool(NDIPassiveTool* tool);
 
     /* Methods for NDIProtocol friend class */
     virtual void InvalidateAll();             ///< invalidate all tools
     NDIPassiveTool* GetInternalTool(std::string portHandle); ///< returns the tool object that has been assigned the port handle or nullptr if no tool can be found
 
     /**
     * \brief free all port handles that need to be freed
     *
     * This method retrieves a list of all port handles that need to be freed (e.g. tool got disconnected)
     * and frees the handles at the tracking device and it removes the tools from the internal tool list
     * \warning This method can remove TrackingTools from the tool list! After calling this method, GetTool(i) could return
     *          a different tool, because tool indices could have changed.
     * @throw mitk::IGTHardwareException Throws an exception if there are errors while communicating with the device.
     * \return returns NDIOKAY if everything was sucessfull, returns an error code otherwise
     */
     NDIErrorCode FreePortHandles();
 
     NDIErrorCode Send(const std::string* message, bool addCRC = true);      ///< Send message to tracking device
     NDIErrorCode Receive(std::string* answer, unsigned int numberOfBytes);  ///< receive numberOfBytes bytes from tracking device
     NDIErrorCode ReceiveByte(char* answer);   ///< lightweight receive function, that reads just one byte
     NDIErrorCode ReceiveLine(std::string* answer); ///< receive characters until the first LF (The LF is included in the answer string)
     void ClearSendBuffer();                   ///< empty send buffer of serial communication interface
     void ClearReceiveBuffer();                ///< empty receive buffer of serial communication interface
     const std::string CalcCRC(const std::string* input);  ///< returns the CRC16 for input as a std::string
 
 public:
 
     /**
     * \brief TrackTools() continuously polls serial interface for new 6d tool positions until StopTracking is called.
     *
     * Continuously tracks the 6D position of all tools until StopTracking() is called.
     * This function is executed by the tracking thread (through StartTracking() and ThreadStartTracking()).
     * It should not be called directly.
     * @throw mitk::IGTHardwareException Throws an exception if there are errors while tracking the tools.
     */
     virtual void TrackTools();
 
     /**
     * \brief continuously polls serial interface for new 3D marker positions until StopTracking is called.
     *
     * Continuously tracks the 3D position of all markers until StopTracking() is called.
     * This function is executed by the tracking thread (through StartTracking() and ThreadStartTracking()).
     * It should not be called directly.
     */
     virtual void TrackMarkerPositions();
 
     /**
     * \brief continuously polls serial interface for new 3D marker positions and 6D tool positions until StopTracking is called.
     *
     * Continuously tracks the 3D position of all markers and the 6D position of all tools until StopTracking() is called.
     * This function is executed by the tracking thread (through StartTracking() and ThreadStartTracking()).
     * It should not be called directly.
     */
     virtual void TrackToolsAndMarkers();
 
     /**
     * \brief static start method for the tracking thread.
     */
     static ITK_THREAD_RETURN_TYPE ThreadStartTracking(void* data);
 
   protected:
     NDITrackingDevice();          ///< Constructor
     virtual ~NDITrackingDevice(); ///< Destructor
 
     std::string m_DeviceName;///< Device Name
     PortNumber m_PortNumber; ///< COM Port Number
     BaudRate m_BaudRate;     ///< COM Port Baud Rate
     DataBits m_DataBits;     ///< Number of Data Bits per token
     Parity m_Parity;         ///< Parity mode for communication
     StopBits m_StopBits;     ///< number of stop bits per token
     HardwareHandshake m_HardwareHandshake; ///< use hardware handshake for serial port connection
     ///< which tracking volume is currently used (if device supports multiple volumes) (\warning This parameter is not used yet)
     IlluminationActivationRate m_IlluminationActivationRate; ///< update rate of IR illuminator for Polaris
     DataTransferMode m_DataTransferMode;  ///< use TX (text) or BX (binary) (\warning currently, only TX mode is supported)
     Tool6DContainerType m_6DTools;        ///< list of 6D tools
 
     itk::FastMutexLock::Pointer m_ToolsMutex; ///< mutex for coordinated access of tool container
     mitk::SerialCommunication::Pointer m_SerialCommunication;    ///< serial communication interface
     itk::FastMutexLock::Pointer m_SerialCommunicationMutex; ///< mutex for coordinated access of serial communication interface
     NDIProtocol::Pointer m_DeviceProtocol;    ///< create and parse NDI protocol strings
 
     itk::MultiThreader::Pointer m_MultiThreader;      ///< creates tracking thread that continuously polls serial interface for new tracking data
     int m_ThreadID;                 ///< ID of tracking thread
     OperationMode m_OperationMode;  ///< tracking mode (6D tool tracking, 3D marker tracking,...)
     itk::FastMutexLock::Pointer m_MarkerPointsMutex;  ///< mutex for marker point data container
     MarkerPointContainerType m_MarkerPoints;          ///< container for markers (3D point tracking mode)
   };
 } // namespace mitk
 #endif /* MITKNDITRACKINGDEVICE_H_HEADER_INCLUDED_C1C2FCD2 */
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
new file mode 100644
index 0000000000..7e4af215c8
--- /dev/null
+++ b/Modules/IGT/TrackingDevices/mitkPolhemusInterface.cpp
@@ -0,0 +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() : 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)
+  {
+    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();
+    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/mitkPolhemusInterface.h b/Modules/IGT/TrackingDevices/mitkPolhemusInterface.h
new file mode 100644
index 0000000000..28eea88760
--- /dev/null
+++ b/Modules/IGT/TrackingDevices/mitkPolhemusInterface.h
@@ -0,0 +1,117 @@
+/*===================================================================
+
+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 MITKPolhemusINTERFACE_H_HEADER_INCLUDED_
+#define MITKPolhemusINTERFACE_H_HEADER_INCLUDED_
+
+
+#include <vector>
+#include <string>
+
+#include <MitkIGTExports.h>
+#include "mitkCommon.h"
+
+#include <itkObject.h>
+#include <itkObjectFactory.h>
+
+#include <windows.h>
+#include <tchar.h>
+#include <string>
+
+#include <mitkNavigationData.h>
+
+class CPDIdev;
+
+namespace mitk
+{
+
+  /** Documentation:
+  *   \brief An object of this class represents the interface to Polhemus trackers.
+  *   \ingroup IGT
+  */
+  class MITKIGT_EXPORT PolhemusInterface : public itk::Object
+  {
+  public:
+
+    mitkClassMacroItkParent(PolhemusInterface,itk::Object);
+    itkFactorylessNewMacro(Self);
+    itkCloneMacro(Self);
+
+    struct trackingData
+    {
+      mitk::Point3D pos;
+      mitk::Quaternion rot;
+      BYTE id;
+    };
+
+    /**
+    * \brief Opens the connection to the device and makes it ready to track tools.
+    * \return Returns true if there is a connection to the device and the device is ready to track tools, false if not.
+    */
+    bool StartTracking();
+
+    /**
+    * \brief Clears all resources. After this method have been called the system isn't ready to track any longer.
+    * \return Returns true if the operation was succesful, false if not.
+    */
+    bool StopTracking();
+
+    bool Connect();
+
+    bool Disconnect();
+
+    /** @return Returns a single frame. Only works if the tracking device is not in continous tracking mode. Returns an empty vector in case of an error.*/
+    std::vector<trackingData> GetSingleFrame();
+
+    /** @return Returns the last frame when the tracking device is in continous tracking mode. Returns an empty vector in case of an error.*/
+    std::vector<trackingData> GetLastFrame();
+
+    /** @return Returns the number of tools. Returns 0 if no information is avialable.*/
+    unsigned int GetNumberOfTools();
+
+    /** Enables/disables hemisphere tracking for all sensors. */
+    itkSetMacro(HemisphereTrackingEnabled, bool);
+
+  protected:
+    /**
+    * \brief standard constructor
+    */
+    PolhemusInterface();
+    /**
+    * \brief standard destructor
+    */
+    ~PolhemusInterface();
+
+	/** Polhemus liberty/patriot tracker object*/
+    CPDIdev* m_pdiDev;
+	
+	/** Parses polhemus raw data to a collection of tracking data of single tools. */
+    std::vector<mitk::PolhemusInterface::trackingData> ParsePolhemusRawData(PBYTE pBuf, DWORD dwSize);
+
+    unsigned int m_numberOfTools;
+
+    bool m_continousTracking;
+
+    bool InitializeDevice();
+
+    bool SetupDevice();
+
+    bool m_HemisphereTrackingEnabled;
+
+
+  };
+}//mitk
+#endif
diff --git a/Modules/IGT/TrackingDevices/mitkPolhemusTool.cpp b/Modules/IGT/TrackingDevices/mitkPolhemusTool.cpp
new file mode 100644
index 0000000000..dfa34e5769
--- /dev/null
+++ b/Modules/IGT/TrackingDevices/mitkPolhemusTool.cpp
@@ -0,0 +1,25 @@
+/*===================================================================
+
+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 "mitkPolhemusTool.h"
+
+mitk::PolhemusTool::PolhemusTool() :InternalTrackingTool()
+{
+}
+
+mitk::PolhemusTool::~PolhemusTool(void)
+{
+}
diff --git a/Modules/IGT/TrackingDevices/mitkPolhemusTool.h b/Modules/IGT/TrackingDevices/mitkPolhemusTool.h
new file mode 100644
index 0000000000..0d16bebb10
--- /dev/null
+++ b/Modules/IGT/TrackingDevices/mitkPolhemusTool.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 MITKPolhemusTOOL_H_HEADER_INCLUDED_
+#define MITKPolhemusTOOL_H_HEADER_INCLUDED_
+
+#include <mitkPolhemusInterface.h>
+#include <mitkInternalTrackingTool.h>
+#include <itkFastMutexLock.h>
+
+namespace mitk
+{
+  class PolhemusTrackingDevice;
+  /** Documentation:
+  *   \brief  An object of this class represents a tool of a Polhemus tracking device.
+  *           A tool has to be added to a tracking device which will then
+  *           continuously update the tool coordinates.
+  *   \ingroup IGT
+  */
+  class MITKIGT_EXPORT PolhemusTool : public InternalTrackingTool
+  {
+  public:
+    friend class PolhemusTrackingDevice;
+    mitkClassMacro(PolhemusTool, InternalTrackingTool);
+
+  protected:
+    itkFactorylessNewMacro(Self)
+    itkCloneMacro(Self)
+    PolhemusTool();
+    virtual ~PolhemusTool();
+  };
+}//mitk
+#endif // MITKPolhemusTOOL_H_HEADER_INCLUDED_
diff --git a/Modules/IGT/TrackingDevices/mitkPolhemusTrackerTypeInformation.cpp b/Modules/IGT/TrackingDevices/mitkPolhemusTrackerTypeInformation.cpp
new file mode 100644
index 0000000000..a4e7bed526
--- /dev/null
+++ b/Modules/IGT/TrackingDevices/mitkPolhemusTrackerTypeInformation.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 "mitkPolhemusTrackerTypeInformation.h"
+
+#include "mitkPolhemusTrackingDevice.h"
+
+namespace mitk
+{
+  std::string PolhemusTrackerTypeInformation::GetTrackingDeviceName()
+  {
+    return "Polhemus tracker";
+  }
+
+  TrackingDeviceData PolhemusTrackerTypeInformation::GetDeviceDataPolhemusTrackerLiberty()
+  {
+    TrackingDeviceData data = { PolhemusTrackerTypeInformation::GetTrackingDeviceName(), "Polhemus Liberty Tracker", "cube", "X" };
+    return data;
+  }
+
+  PolhemusTrackerTypeInformation::PolhemusTrackerTypeInformation()
+  {
+    m_DeviceName = PolhemusTrackerTypeInformation::GetTrackingDeviceName();
+    m_TrackingDeviceData.push_back(GetDeviceDataPolhemusTrackerLiberty());
+  }
+
+  PolhemusTrackerTypeInformation::~PolhemusTrackerTypeInformation()
+  {
+  }
+
+  mitk::TrackingDeviceSource::Pointer PolhemusTrackerTypeInformation::CreateTrackingDeviceSource(
+    mitk::TrackingDevice::Pointer trackingDevice,
+    mitk::NavigationToolStorage::Pointer navigationTools,
+    std::string* errorMessage,
+    std::vector<int>* toolCorrespondencesInToolStorage)
+  {
+    mitk::TrackingDeviceSource::Pointer returnValue = mitk::TrackingDeviceSource::New();
+    mitk::PolhemusTrackingDevice::Pointer thisDevice = dynamic_cast<mitk::PolhemusTrackingDevice*>(trackingDevice.GetPointer());
+    *toolCorrespondencesInToolStorage = std::vector<int>();
+    //add the tools to the tracking device
+    for (int i = 0; i < navigationTools->GetToolCount(); i++)
+    {
+      mitk::NavigationTool::Pointer thisNavigationTool = navigationTools->GetTool(i);
+      toolCorrespondencesInToolStorage->push_back(i);
+      bool toolAddSuccess = thisDevice->AddTool(thisNavigationTool->GetToolName().c_str());
+      if (!toolAddSuccess)
+      {
+        //todo error handling
+        errorMessage->append("Can't add tool, is the toolfile valid?");
+        return NULL;
+      }
+      thisDevice->GetTool(i)->SetToolTip(thisNavigationTool->GetToolTipPosition(), thisNavigationTool->GetToolTipOrientation());
+    }
+    returnValue->SetTrackingDevice(thisDevice);
+    return returnValue;
+  }
+}
diff --git a/Modules/IGT/TrackingDevices/mitkPolhemusTrackerTypeInformation.h b/Modules/IGT/TrackingDevices/mitkPolhemusTrackerTypeInformation.h
new file mode 100644
index 0000000000..52b8647821
--- /dev/null
+++ b/Modules/IGT/TrackingDevices/mitkPolhemusTrackerTypeInformation.h
@@ -0,0 +1,45 @@
+/*===================================================================
+
+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 mitkPolhemusTrackerTypeInformation_h
+#define mitkPolhemusTrackerTypeInformation_h
+
+#include "mitkTrackingDeviceTypeInformation.h"
+
+namespace mitk
+{
+  /** Documentation:
+  *   \brief Type information for Polhemus Tracking Devices.
+  *
+  *   \ingroup IGTUI
+  */
+  class MITKIGT_EXPORT PolhemusTrackerTypeInformation : public TrackingDeviceTypeInformation
+  {
+  public:
+    PolhemusTrackerTypeInformation();
+    virtual ~PolhemusTrackerTypeInformation();
+
+    virtual TrackingDeviceSource::Pointer CreateTrackingDeviceSource(mitk::TrackingDevice::Pointer trackingDevice,
+      mitk::NavigationToolStorage::Pointer navigationTools,
+      std::string* errorMessage,
+      std::vector<int>* toolCorrespondencesInToolStorage) override;
+
+    static std::string GetTrackingDeviceName();
+    static TrackingDeviceData GetDeviceDataPolhemusTrackerLiberty();
+  };
+} // namespace mitk
+
+#endif //mitkPolhemusTrackerTypeInformation_h
diff --git a/Modules/IGT/TrackingDevices/mitkPolhemusTrackingDevice.cpp b/Modules/IGT/TrackingDevices/mitkPolhemusTrackingDevice.cpp
new file mode 100644
index 0000000000..98bd67f4f7
--- /dev/null
+++ b/Modules/IGT/TrackingDevices/mitkPolhemusTrackingDevice.cpp
@@ -0,0 +1,250 @@
+/*===================================================================
+
+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 "mitkPolhemusTrackingDevice.h"
+#include "mitkPolhemusTool.h"
+#include "mitkIGTConfig.h"
+#include "mitkIGTTimeStamp.h"
+#include "mitkIGTHardwareException.h"
+#include <itksys/SystemTools.hxx>
+#include <iostream>
+#include <itkMutexLockHolder.h>
+#include "mitkPolhemusTrackerTypeInformation.h"
+#include <vtkConeSource.h>
+
+typedef itk::MutexLockHolder<itk::FastMutexLock> MutexLockHolder;
+
+
+mitk::PolhemusTrackingDevice::PolhemusTrackingDevice(): mitk::TrackingDevice()
+{
+  //set the type of this tracking device
+  this->m_Data = mitk::PolhemusTrackerTypeInformation::GetDeviceDataPolhemusTrackerLiberty();
+
+  this->m_MultiThreader = itk::MultiThreader::New();
+  m_ThreadID = 0;
+
+  m_Device = mitk::PolhemusInterface::New();
+}
+
+mitk::PolhemusTrackingDevice::~PolhemusTrackingDevice()
+{
+}
+
+bool mitk::PolhemusTrackingDevice::IsDeviceInstalled()
+{
+  return true;
+}
+
+mitk::TrackingTool* mitk::PolhemusTrackingDevice::AddTool( const char* toolName)
+{
+  mitk::PolhemusTool::Pointer t = mitk::PolhemusTool::New();
+  t->SetToolName(toolName);
+  if (this->InternalAddTool(t) == false)
+    return nullptr;
+  return t.GetPointer();
+}
+
+bool mitk::PolhemusTrackingDevice::InternalAddTool(PolhemusTool::Pointer tool)
+{
+  m_AllTools.push_back(tool);
+  return true;
+}
+
+bool mitk::PolhemusTrackingDevice::StartTracking()
+{
+  bool success = m_Device->StartTracking();
+  if (success)
+  {
+    mitk::IGTTimeStamp::GetInstance()->Start(this);
+    this->SetState(Tracking);
+    m_ThreadID = m_MultiThreader->SpawnThread(this->ThreadStartTracking, this);    // start a new thread that executes the TrackTools() method
+    return true;
+  }
+  else
+  {
+    this->SetState(Ready);
+    mitkThrowException(mitk::IGTHardwareException) << "Error while trying to start the device!";
+  }
+  return success;
+}
+
+bool mitk::PolhemusTrackingDevice::StopTracking()
+{
+  return Superclass::StopTracking();
+}
+
+
+unsigned int mitk::PolhemusTrackingDevice::GetToolCount() const
+{
+  return (unsigned int)this->m_AllTools.size();
+}
+
+
+mitk::TrackingTool* mitk::PolhemusTrackingDevice::GetTool(unsigned int toolNumber) const
+{
+  if ( toolNumber >= this->GetToolCount())
+    return nullptr;
+  else
+    return this->m_AllTools[toolNumber];
+}
+
+
+bool mitk::PolhemusTrackingDevice::OpenConnection()
+{
+  //reset everything
+  if (m_Device.IsNull()) {m_Device = mitk::PolhemusInterface::New();}
+  m_Device->SetHemisphereTrackingEnabled(m_HemisphereTrackingEnabled);
+  m_Device->Connect();
+  this->SetState(Ready);
+  return true;
+}
+
+bool mitk::PolhemusTrackingDevice::CloseConnection()
+{
+  bool returnValue = true;
+  if (this->GetState() == Setup)
+    return true;
+
+  returnValue = m_Device->Disconnect();
+
+  this->SetState(Setup);
+  return returnValue;
+}
+
+
+mitk::PolhemusInterface* mitk::PolhemusTrackingDevice::GetDevice()
+{
+  return m_Device;
+}
+
+
+std::vector<mitk::PolhemusTool::Pointer> mitk::PolhemusTrackingDevice::GetAllTools()
+{
+  return this->m_AllTools;
+}
+
+
+void mitk::PolhemusTrackingDevice::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();
+    Sleep(100);//Wait a bit until the tracker is ready...
+
+    while ((this->GetState() == Tracking) && (localStopTracking == false))
+    {
+      std::vector<mitk::PolhemusInterface::trackingData> lastData = this->GetDevice()->GetLastFrame();
+
+      if (lastData.size() != m_AllTools.size())
+      {
+        MITK_WARN << "Tool count is corrupt. Aborting!";
+      }
+      else
+      {
+        std::vector<mitk::PolhemusTool::Pointer> allTools = this->GetAllTools();
+        for (int i = 0; i < allTools.size(); i++)
+        {
+          mitk::PolhemusTool::Pointer currentTool = allTools.at(i);
+          currentTool->SetDataValid(true);
+          currentTool->SetPosition(lastData.at(i).pos);
+          currentTool->SetOrientation(lastData.at(i).rot);
+          currentTool->SetIGTTimeStamp(mitk::IGTTimeStamp::GetInstance()->GetElapsed());
+        }
+      }
+      /* 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.";
+  }
+}
+
+ITK_THREAD_RETURN_TYPE mitk::PolhemusTrackingDevice::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;
+  }
+  PolhemusTrackingDevice *trackingDevice = (PolhemusTrackingDevice*)pInfo->UserData;
+
+  if (trackingDevice != nullptr)
+    trackingDevice->TrackTools();
+
+  return ITK_THREAD_RETURN_VALUE;
+}
+
+bool mitk::PolhemusTrackingDevice::AutoDetectToolsAvailable()
+{
+  return true;
+}
+
+mitk::NavigationToolStorage::Pointer mitk::PolhemusTrackingDevice::AutoDetectTools()
+{
+  this->OpenConnection();
+  std::vector<mitk::PolhemusInterface::trackingData> singeFrameData = this->m_Device->GetSingleFrame();
+  MITK_INFO << "Found " << singeFrameData.size() << " tools.";
+  this->CloseConnection();
+  mitk::NavigationToolStorage::Pointer returnValue = mitk::NavigationToolStorage::New();
+  for each (mitk::PolhemusInterface::trackingData t in singeFrameData)
+  {
+
+    mitk::DataNode::Pointer newNode = mitk::DataNode::New();
+    std::stringstream name;
+    name << "Sensor-" << ((int)t.id);
+    newNode->SetName(name.str());
+
+    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);
+
+    std::stringstream identifier;
+    identifier << "AutoDetectedTool-" << ((int)t.id);
+    newTool->SetIdentifier(identifier.str());
+
+    newTool->SetTrackingDeviceType(mitk::PolhemusTrackerTypeInformation::GetDeviceDataPolhemusTrackerLiberty().Line);
+    returnValue->AddTool(newTool);
+  }
+  return returnValue;
+
+}
diff --git a/Modules/IGT/TrackingDevices/mitkPolhemusTrackingDevice.h b/Modules/IGT/TrackingDevices/mitkPolhemusTrackingDevice.h
new file mode 100644
index 0000000000..0d02827f2f
--- /dev/null
+++ b/Modules/IGT/TrackingDevices/mitkPolhemusTrackingDevice.h
@@ -0,0 +1,145 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef MITKPolhemusTRACKINGDEVICE_H_HEADER_INCLUDED_
+#define MITKPolhemusTRACKINGDEVICE_H_HEADER_INCLUDED_
+
+
+#include <vector>
+#include <mitkIGTConfig.h>
+#include <mitkTrackingDevice.h>
+#include <mitkPolhemusTool.h>
+#include <itkMultiThreader.h>
+
+namespace mitk
+{
+  /** Documentation:
+  *   \brief An object of this class represents Polhemus tracking 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 PolhemusTrackingDevice : public TrackingDevice
+  {
+  public:
+
+    mitkClassMacro(PolhemusTrackingDevice, TrackingDevice);
+    itkFactorylessNewMacro(Self)
+    itkCloneMacro(Self)
+
+    /**
+    * \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() override;
+
+    /**
+    * \brief Stops the tracking.
+    * \return Returns true if the tracking is stopped.
+    */
+    virtual bool StopTracking() override;
+
+    /**
+    * \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() override;
+
+    /**
+    * \brief Closes the connection and clears all resources.
+    */
+    virtual bool CloseConnection() override;
+
+    /**
+    * \return Returns the number of tools which have been added to the device.
+    */
+    virtual unsigned int GetToolCount() const override;
+
+    /**
+    * \param toolNumber The number of the tool which should be given back.
+    * \return Returns the tool which the number "toolNumber". Returns NULL, if there is
+    * no tool with this number.
+    */
+    TrackingTool* GetTool(unsigned int toolNumber)  const override;
+
+
+    /**
+    * \brief Create a new Polhemus tool with toolName and add it to the list of tools
+    *
+    * This method will create a new PolhemusTool object,
+    * set the tool name toolName and then add it to the list of tools.
+    * It returns a pointer of type mitk::TrackingTool to the tool
+    * that can be used to read tracking data from it.
+    * This is the only way to add tools to PolhemusTrackingDevice.
+    *
+    * \warning adding tools is not possible in tracking mode, only in setup and ready.
+    */
+    mitk::TrackingTool* AddTool(const char* toolName);
+
+    bool IsDeviceInstalled();
+
+    /** @return Returns true if this device can autodetects its tools. */
+    virtual bool AutoDetectToolsAvailable();
+
+    /** Autodetects tools from this device and returns them as a navigation tool storage.
+    *  @return Returns the detected tools. Returns an empty storage if no tools are present
+    *          or if detection is not possible
+    */
+    virtual mitk::NavigationToolStorage::Pointer AutoDetectTools();
+
+    /** Enables/disables hemisphere tracking for all sensors. */
+    itkSetMacro(HemisphereTrackingEnabled, bool);
+
+  protected:
+    PolhemusTrackingDevice();
+    ~PolhemusTrackingDevice();
+
+    /**
+    * \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(PolhemusTool::Pointer tool);
+
+    /**
+    * \brief This method tracks tools as long as the variable m_Mode is set to "Tracking".
+    * Tracking tools means grabbing frames from the camera an updating the tools.
+    * @throw mitk::IGTHardwareException Throws an exception if there is an error during tracking of tools.
+    */
+    void TrackTools();
+
+    /**
+    * \return Returns all tools of the tracking device.
+    */
+    std::vector<PolhemusTool::Pointer> GetAllTools();
+
+    /**
+    * \return Gives back the device which is represented by an object of the class PolhemusInterface.
+    */
+    PolhemusInterface* GetDevice();
+
+    static ITK_THREAD_RETURN_TYPE ThreadStartTracking(void* data);
+
+    std::vector<PolhemusTool::Pointer> m_AllTools; ///< vector holding all tools
+    PolhemusInterface::Pointer m_Device; ///< represents the interface to the tracking hardware
+    itk::MultiThreader::Pointer m_MultiThreader;
+    int m_ThreadID;
+    bool m_HemisphereTrackingEnabled;
+  };
+}//mitk
+#endif /* MITKPolhemusTRACKINGDEVICE_H_HEADER_INCLUDED_ */
diff --git a/Modules/IGT/TrackingDevices/mitkTrackingDevice.cpp b/Modules/IGT/TrackingDevices/mitkTrackingDevice.cpp
index ba47a9f700..dbb8bafa2d 100644
--- a/Modules/IGT/TrackingDevices/mitkTrackingDevice.cpp
+++ b/Modules/IGT/TrackingDevices/mitkTrackingDevice.cpp
@@ -1,138 +1,148 @@
 /*===================================================================
 
 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 "mitkTrackingDevice.h"
 #include "mitkIGTTimeStamp.h"
 #include "mitkTrackingTool.h"
 
 #include <itkMutexLockHolder.h>
 
 #include <usModuleContext.h>
 #include <usGetModuleContext.h>
 
 #include "mitkUnspecifiedTrackingTypeInformation.h"
 #include "mitkTrackingDeviceTypeCollection.h"
 
 typedef itk::MutexLockHolder<itk::FastMutexLock> MutexLockHolder;
 
 
 mitk::TrackingDevice::TrackingDevice() :
 m_Data(mitk::UnspecifiedTrackingTypeInformation::GetDeviceDataUnspecified()),
   m_State(mitk::TrackingDevice::Setup),
   m_StopTracking(false),
   m_RotationMode(mitk::TrackingDevice::RotationStandard)
 
 {
   m_StopTrackingMutex = itk::FastMutexLock::New();
   m_StateMutex = itk::FastMutexLock::New();
   m_TrackingFinishedMutex = itk::FastMutexLock::New();
 }
 
 
 mitk::TrackingDevice::~TrackingDevice()
 {
 }
 
 bool mitk::TrackingDevice::IsDeviceInstalled()
 {
 return true;
 //this is the default for all tracking device
 //If a device needs installation please reimplement
 //this method in the subclass.
 }
 
+bool mitk::TrackingDevice::AutoDetectToolsAvailable()
+{
+  return false;
+}
+
+mitk::NavigationToolStorage::Pointer mitk::TrackingDevice::AutoDetectTools()
+{
+  return mitk::NavigationToolStorage::New();
+}
+
 
 mitk::TrackingDevice::TrackingDeviceState mitk::TrackingDevice::GetState() const
 {
   MutexLockHolder lock(*m_StateMutex);
   return m_State;
 }
 
 
 void mitk::TrackingDevice::SetState( TrackingDeviceState state )
 {
   itkDebugMacro("setting  m_State to " << state);
 
   MutexLockHolder lock(*m_StateMutex); // lock and unlock the mutex
   if (m_State == state)
   {
     return;
   }
   m_State = state;
   this->Modified();
 }
 
 void mitk::TrackingDevice::SetRotationMode(RotationMode r)
 {
   MITK_WARN << "Rotation mode switching is not implemented for this device. Leaving it at mitk::TrackingDevice::RotationStandard";
 }
 
 mitk::TrackingDeviceType mitk::TrackingDevice::GetType() const{
   return m_Data.Line;
 }
 
 void mitk::TrackingDevice::SetType(mitk::TrackingDeviceType deviceType){
 
   us::ModuleContext* context = us::GetModuleContext();
 
    std::vector<us::ServiceReference<mitk::TrackingDeviceTypeCollection> > refs = context->GetServiceReferences<mitk::TrackingDeviceTypeCollection>();
    if (refs.empty())
    {
      MITK_ERROR << "No tracking device service found!";
    }
    mitk::TrackingDeviceTypeCollection* deviceTypeCollection = context->GetService<mitk::TrackingDeviceTypeCollection>(refs.front());
 
    m_Data = deviceTypeCollection->GetFirstCompatibleDeviceDataForLine(deviceType);
 }
 
 mitk::TrackingDeviceData mitk::TrackingDevice::GetData() const{
   return m_Data;
 }
 
 
 void mitk::TrackingDevice::SetData(mitk::TrackingDeviceData data){
   m_Data = data;
 }
 
 
 bool mitk::TrackingDevice::StopTracking()
 {
   if (this->GetState() == Tracking) // Only if the object is in the correct state
   {
     m_StopTrackingMutex->Lock();  // m_StopTracking is used by two threads, so we have to ensure correct thread handling
     m_StopTracking = true;
     m_StopTrackingMutex->Unlock();
     //we have to wait here that the other thread recognizes the STOP-command and executes it
     m_TrackingFinishedMutex->Lock();
     mitk::IGTTimeStamp::GetInstance()->Stop(this); // notify realtime clock
     // StopTracking was called, thus the mode should be changed back
     //   to Ready now that the tracking loop has ended.
     this->SetState(Ready);
     m_TrackingFinishedMutex->Unlock();
   }
   return true;
 }
 
 
 mitk::TrackingTool* mitk::TrackingDevice::GetToolByName( std::string name ) const
 {
   unsigned int toolCount = this->GetToolCount();
   for (unsigned int i = 0; i < toolCount; ++i)
     if (name == this->GetTool(i)->GetToolName())
       return this->GetTool(i);
   return nullptr;
 }
 
diff --git a/Modules/IGT/TrackingDevices/mitkTrackingDevice.h b/Modules/IGT/TrackingDevices/mitkTrackingDevice.h
index 2d29bfc7ce..1cadb52701 100644
--- a/Modules/IGT/TrackingDevices/mitkTrackingDevice.h
+++ b/Modules/IGT/TrackingDevices/mitkTrackingDevice.h
@@ -1,189 +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 MITKTRACKINGDEVICE_H_HEADER_INCLUDED_C1C2FCD2
 #define MITKTRACKINGDEVICE_H_HEADER_INCLUDED_C1C2FCD2
 
 #include <MitkIGTExports.h>
 #include "itkObject.h"
 #include "mitkCommon.h"
 #include "mitkTrackingTypes.h"
 #include "itkFastMutexLock.h"
+#include "mitkNavigationToolStorage.h"
 
 
 namespace mitk {
     class TrackingTool; // interface for a tool that can be tracked by the TrackingDevice
 
     /**Documentation
     * \brief Interface for all Tracking Devices
     *
     * Defines the methods that are common for all tracking devices.
     *
     *  \ingroup IGT
     */
     class MITKIGT_EXPORT TrackingDevice : public itk::Object
     {
     public:
       mitkClassMacroItkParent(TrackingDevice, itk::Object);
 
       /** Defines the rotation modes of this tracking device which results in different representations
        *  of quaternions.
        *
        *  - Standard: normal representation, rawdata from the device is not changed (DEFAULT)
        *
        *  - Transposed: the rotation is stored transposed, which is (by mistake!) expected by some older MITK classes due
        *                to an ambigious method naming in VNL.
        *
        *  CAUTION: The rotation mode can only be changed for backward compatibility of old WRONG code.
        *           PLEASE DO NOT CHANGE THE ROTATION MODE UNLESS YOU ARE KNOWING EXACTLY WHAT YOU ARE DOING!
        *
        *  use SetRotationMode to change the mode.
        */
       enum RotationMode {RotationStandard, RotationTransposed};
 
       enum TrackingDeviceState {Setup, Ready, Tracking};   ///< Type for state variable. The trackingdevice is always in one of these states
       /**
        * \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 tracking is
        * not running (e.g. object is in Ready state)
        */
       virtual bool CloseConnection() = 0; ///< Closes the connection with the device
 
       /**
        * \brief start retrieving tracking data from the device.
        *
        * This may only be called after the connection to the device has been established
        * with a call to OpenConnection() (E.g. object is in Ready mode). This will change the
        * object state from Ready to Tracking
        */
       virtual bool StartTracking() = 0;
 
       /**
        * \brief stop retrieving tracking data from the device.
        * stop retrieving tracking data from the device.
        * This may only be called after StartTracking was called
        * (e.g. the object is in Tracking mode).
        * This will change the object state from Tracking to Ready.
        */
       virtual bool StopTracking();
 
       /**
        * \brief Return tool with index toolNumber
        *
        * tools are numbered from 0 to GetToolCount() - 1.
        */
       virtual TrackingTool* GetTool(unsigned int toolNumber) const = 0;
 
       /**
       * \brief Returns the tool with the given tool name
       *
       * Note: subclasses can and should implement optimized versions of this method
       * \return the given tool or nullptr if no tool with that name exists
       */
       virtual mitk::TrackingTool* GetToolByName(std::string name) const;
 
       /**
        * \brief Returns number of tracking tools
        */
       virtual unsigned int GetToolCount() const = 0;
 
       /** Sets the rotation mode of this class. See documentation of enum RotationMode for details
        *  on the different modes. This method has to be implemented in a deriving class to become
        *  functional / if different rotation modes should be supported.
        *  CAUTION: The rotation mode can only be changed for backward compatibility of old WRONG code.
        *           PLEASE DO NOT CHANGE THE ROTATION MODE UNLESS YOU ARE KNOWING EXACTLY WHAT YOU ARE DOING!
        */
       virtual void SetRotationMode(RotationMode r);
 
      /** @return Returns the rotation mode of this class. See documentation of enum
        *         RotationMode for details on the different modes.
        */
       itkGetConstMacro(RotationMode,RotationMode);
 
       /**
        * \brief return current object state (Setup, Ready or Tracking)
        */
       TrackingDeviceState GetState() const;
 
       /**
        * \brief Deprecated! Use the more specific getDeviceData instead. return device type identifier
        */
     TrackingDeviceType GetType() const;
        /**
        * \brief Deprecated! Use the more specific setDeviceData instead. set device type
        */
     void SetType(TrackingDeviceType type);
 
      /**
        * \brief return device data
      */
     TrackingDeviceData GetData() const;
        /**
        * \brief set device type
        */
     void SetData(TrackingDeviceData data);
 
     /**
      * @return Returns true if the device is installed on this system an can be used.
      *         Installed means activated in MITK, in some cases this means the MITK
      *         installation / build has to know the installation path of the device
      *         libraries on this system. This path is usually given as cmake variable
      *         during the build configuration in devellopers mode. If the device should
      *         be available for end users with an installer the libraries can be included
      *         into the installer or the installer has to be adapted such that it asks
      *         for the path.
      *         Returns fals if the device is not installed. It cannot be used on this build
      *         in this case.
      *
      *         Note that some tracking systems communicate via a standard interface (e.g., serial
      *         port) and don't need any library or installation. These devices are always "installed".
      */
     virtual bool IsDeviceInstalled();
 
+    /** @return Returns true if this device can autodetects its tools. */
+    virtual bool AutoDetectToolsAvailable();
+
+    /** Autodetects tools from this device and returns them as a navigation tool storage.
+     *  @return Returns the detected tools. Returns an empty storage if no tools are present
+     *          or if detection is not possible
+     */
+    virtual mitk::NavigationToolStorage::Pointer AutoDetectTools();
+
     private:
       TrackingDeviceState m_State; ///< current object state (Setup, Ready or Tracking)
     protected:
 
       /**
       * \brief  change object state
       */
       void SetState(TrackingDeviceState state);
 
 
       TrackingDevice();
       virtual ~TrackingDevice();
 
     TrackingDeviceData m_Data; ///< current device Data
 
       bool m_StopTracking;       ///< signal stop to tracking thread
       itk::FastMutexLock::Pointer m_StopTrackingMutex; ///< mutex to control access to m_StopTracking
       itk::FastMutexLock::Pointer m_TrackingFinishedMutex; ///< mutex to manage control flow of StopTracking()
       itk::FastMutexLock::Pointer m_StateMutex; ///< mutex to control access to m_State
       RotationMode m_RotationMode; ///< defines the rotation mode Standard or Transposed, Standard is default
     };
 } // namespace mitk
 
 #endif /* MITKTRACKINGDEVICE_H_HEADER_INCLUDED_C1C2FCD2 */
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 b5608a31ab..9965796486 100644
--- a/Modules/IGT/autoload/DeviceRegistry/src/mitkIGTActivator.cpp
+++ b/Modules/IGT/autoload/DeviceRegistry/src/mitkIGTActivator.cpp
@@ -1,63 +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());
-    m_DeviceTypeCollection.RegisterAsMicroservice();
+#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/files.cmake b/Modules/IGT/files.cmake
index 5b73185897..8d9ec0bc9e 100644
--- a/Modules/IGT/files.cmake
+++ b/Modules/IGT/files.cmake
@@ -1,100 +1,113 @@
 set(CPP_FILES
 
   TestingHelper/mitkNavigationToolStorageTestHelper.cpp
 
   Algorithms/mitkNavigationDataDelayFilter.cpp
   Algorithms/mitkNavigationDataDisplacementFilter.cpp
   Algorithms/mitkNavigationDataEvaluationFilter.cpp
   Algorithms/mitkNavigationDataLandmarkTransformFilter.cpp
   Algorithms/mitkNavigationDataReferenceTransformFilter.cpp
   Algorithms/mitkNavigationDataSmoothingFilter.cpp
   Algorithms/mitkNavigationDataToMessageFilter.cpp
   Algorithms/mitkNavigationDataToNavigationDataFilter.cpp
   Algorithms/mitkNavigationDataToPointSetFilter.cpp
   Algorithms/mitkNavigationDataTransformFilter.cpp
   Algorithms/mitkNavigationDataToIGTLMessageFilter.cpp
   Algorithms/mitkIGTLMessageToNavigationDataFilter.cpp
+  Algorithms/mitkPivotCalibration.cpp
 
   Common/mitkIGTTimeStamp.cpp
   Common/mitkSerialCommunication.cpp
 
   DataManagement/mitkNavigationDataSource.cpp
   DataManagement/mitkNavigationTool.cpp
   DataManagement/mitkNavigationToolStorage.cpp
   DataManagement/mitkTrackingDeviceSourceConfigurator.cpp
   DataManagement/mitkTrackingDeviceSource.cpp
   DataManagement/mitkTrackingDeviceTypeCollection.cpp
 
   ExceptionHandling/mitkIGTException.cpp
   ExceptionHandling/mitkIGTHardwareException.cpp
   ExceptionHandling/mitkIGTIOException.cpp
 
   IO/mitkNavigationDataPlayer.cpp
   IO/mitkNavigationDataPlayerBase.cpp
   IO/mitkNavigationDataRecorder.cpp
   IO/mitkNavigationDataRecorderDeprecated.cpp
   IO/mitkNavigationDataSequentialPlayer.cpp
   IO/mitkNavigationToolReader.cpp
   IO/mitkNavigationToolStorageSerializer.cpp
   IO/mitkNavigationToolStorageDeserializer.cpp
   IO/mitkNavigationToolWriter.cpp
   IO/mitkNavigationDataReaderInterface.cpp
 
   Rendering/mitkCameraVisualization.cpp
   Rendering/mitkNavigationDataObjectVisualizationFilter.cpp
   Rendering/mitkNavigationDataSliceVisualization.cpp
 
   TrackingDevices/mitkClaronTool.cpp
   TrackingDevices/mitkClaronTrackingDevice.cpp
   TrackingDevices/mitkInternalTrackingTool.cpp
   TrackingDevices/mitkNDIPassiveTool.cpp
   TrackingDevices/mitkNDIProtocol.cpp
   TrackingDevices/mitkNDITrackingDevice.cpp
   TrackingDevices/mitkTrackingDevice.cpp
   TrackingDevices/mitkTrackingTool.cpp
   TrackingDevices/mitkTrackingVolumeGenerator.cpp
   TrackingDevices/mitkVirtualTrackingDevice.cpp
   TrackingDevices/mitkVirtualTrackingTool.cpp
   TrackingDevices/mitkOptitrackErrorMessages.cpp
   TrackingDevices/mitkOptitrackTrackingDevice.cpp
   TrackingDevices/mitkOptitrackTrackingTool.cpp
   TrackingDevices/mitkOpenIGTLinkTrackingDevice.cpp
   TrackingDevices/mitkOpenIGTLinkTrackingTool.cpp
   TrackingDevices/mitkNDIAuroraTypeInformation.cpp
   TrackingDevices/mitkNDIPolarisTypeInformation.cpp
   TrackingDevices/mitkNPOptitrackTrackingTypeInformation.cpp
   TrackingDevices/mitkVirtualTrackerTypeInformation.cpp
   TrackingDevices/mitkMicronTrackerTypeInformation.cpp
   TrackingDevices/mitkOpenIGTLinkTypeInformation.cpp
   TrackingDevices/mitkUnspecifiedTrackingTypeInformation.cpp
+#  TrackingDevices/mitkPolhemusTrackingDevice.cpp
+#  TrackingDevices/mitkPolhemusTool.cpp
+#  TrackingDevices/mitkPolhemusTrackerTypeInformation.cpp
 )
 
 set(H_FILES
   DataManagement/mitkTrackingDeviceTypeInformation.h
   Common/mitkTrackingTypes.h
 )
 
 set(RESOURCE_FILES
   ClaronMicron.stl
   IntuitiveDaVinci.stl
   NDIAurora.stl
   NDIAurora_Dome.stl
   NDIAuroraCompactFG_Dome.stl
   NDIAuroraPlanarFG_Dome.stl
   NDIAuroraTabletopFG_Dome.stl
   NDIAuroraTabletopFG_Prototype_Dome.stl
   NDIPolarisOldModel.stl
   NDIPolarisSpectra.stl
   NDIPolarisSpectraExtendedPyramid.stl
   NDIPolarisVicra.stl
 )
 
 if(MITK_USE_MICRON_TRACKER)
   set(CPP_FILES ${CPP_FILES} TrackingDevices/mitkClaronInterface.cpp)
 else()
   set(CPP_FILES ${CPP_FILES} TrackingDevices/mitkClaronInterfaceStub.cpp)
 endif(MITK_USE_MICRON_TRACKER)
 
 if(MITK_USE_MICROBIRD_TRACKER)
   set(CPP_FILES ${CPP_FILES} TrackingDevices/mitkMicroBirdTrackingDevice.cpp)
 endif(MITK_USE_MICROBIRD_TRACKER)
+
+if(MITK_USE_POLHEMUS_TRACKER)
+  set(CPP_FILES ${CPP_FILES}
+  TrackingDevices/mitkPolhemusInterface.cpp
+  TrackingDevices/mitkPolhemusTrackingDevice.cpp
+  TrackingDevices/mitkPolhemusTool.cpp
+  TrackingDevices/mitkPolhemusTrackerTypeInformation.cpp
+)
+endif(MITK_USE_POLHEMUS_TRACKER)
diff --git a/Modules/IGT/mitkIGTConfig.h.in b/Modules/IGT/mitkIGTConfig.h.in
index ad400cded3..c76df88a23 100644
--- a/Modules/IGT/mitkIGTConfig.h.in
+++ b/Modules/IGT/mitkIGTConfig.h.in
@@ -1,9 +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>&lt;not given&gt;</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>&lt;not given&gt;</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/Qmitk/QmitkPolhemusTrackerWidget.cpp b/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.cpp
new file mode 100644
index 0000000000..c1add0dd7a
--- /dev/null
+++ b/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.cpp
@@ -0,0 +1,85 @@
+/*===================================================================
+
+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 "QmitkPolhemusTrackerWidget.h"
+
+#include <QFileDialog>
+#include <QScrollBar>
+
+#include <mitkPolhemusTrackingDevice.h>
+
+#include <itksys/SystemTools.hxx>
+#include <Poco/Path.h>
+#include <QSettings>
+
+const std::string QmitkPolhemusTrackerWidget::VIEW_ID = "org.mitk.views.PolhemusTrackerWidget";
+
+QmitkPolhemusTrackerWidget::QmitkPolhemusTrackerWidget(QWidget* parent, Qt::WindowFlags f)
+  : QmitkAbstractTrackingDeviceWidget(parent, f)
+  , m_Controls(nullptr)
+{
+}
+void QmitkPolhemusTrackerWidget::Initialize()
+{
+  InitializeSuperclassWidget();
+  CreateQtPartControl(this);
+}
+
+QmitkPolhemusTrackerWidget::~QmitkPolhemusTrackerWidget()
+{
+  delete m_Controls;
+}
+
+void QmitkPolhemusTrackerWidget::CreateQtPartControl(QWidget *parent)
+{
+  if (!m_Controls)
+  {
+    // create GUI widgets
+    m_Controls = new Ui::QmitkPolhemusTrackerWidget;
+    m_Controls->setupUi(parent);
+  }
+}
+
+void QmitkPolhemusTrackerWidget::CreateConnections()
+{
+  if (m_Controls)
+  {
+
+  }
+}
+
+mitk::TrackingDevice::Pointer QmitkPolhemusTrackerWidget::GetTrackingDevice()
+{
+  if (m_TrackingDevice.IsNull()) m_TrackingDevice = ConstructTrackingDevice();
+  return m_TrackingDevice;
+}
+
+
+mitk::TrackingDevice::Pointer QmitkPolhemusTrackerWidget::ConstructTrackingDevice()
+{
+  mitk::PolhemusTrackingDevice::Pointer newDevice = mitk::PolhemusTrackingDevice::New();
+  newDevice->SetHemisphereTrackingEnabled(m_Controls->m_hemisphereTracking->isChecked());
+  return static_cast<mitk::TrackingDevice::Pointer>(newDevice);
+}
+
+
+
+QmitkPolhemusTrackerWidget* QmitkPolhemusTrackerWidget::Clone(QWidget* parent) const
+{
+  QmitkPolhemusTrackerWidget* clonedWidget = new QmitkPolhemusTrackerWidget(parent);
+  clonedWidget->Initialize();
+  return clonedWidget;
+}
diff --git a/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.h b/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.h
new file mode 100644
index 0000000000..dfd41ec261
--- /dev/null
+++ b/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.h
@@ -0,0 +1,65 @@
+/*===================================================================
+
+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 QmitkPolhemusTrackerWidget_H
+#define QmitkPolhemusTrackerWidget_H
+
+#include "ui_QmitkPolhemusTrackerWidget.h"
+
+#include "QmitkAbstractTrackingDeviceWidget.h"
+
+
+/** Documentation:
+ *   \brief Implementation of a configuration widget for Polhemus Tracking Devices.
+ *
+ *   \ingroup IGTUI
+ */
+class MITKIGTUI_EXPORT QmitkPolhemusTrackerWidget : public QmitkAbstractTrackingDeviceWidget
+{
+  Q_OBJECT // this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
+
+public:
+  static const std::string VIEW_ID;
+
+  QmitkPolhemusTrackerWidget(QWidget* parent = 0, Qt::WindowFlags f = 0);
+  ~QmitkPolhemusTrackerWidget();
+
+  mitk::TrackingDevice::Pointer GetTrackingDevice();
+
+  virtual void Initialize();
+
+signals:
+
+protected slots :
+
+private:
+
+  /// \brief Creation of the connections
+  void CreateConnections();
+
+  void CreateQtPartControl(QWidget *parent);
+
+protected:
+  virtual QmitkPolhemusTrackerWidget* Clone(QWidget* parent) const;
+
+  Ui::QmitkPolhemusTrackerWidget* m_Controls;
+
+  mitk::TrackingDevice::Pointer m_TrackingDevice;
+
+public:
+  virtual mitk::TrackingDevice::Pointer ConstructTrackingDevice();
+};
+#endif
diff --git a/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.ui b/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.ui
new file mode 100644
index 0000000000..9dee4ebd75
--- /dev/null
+++ b/Modules/IGTUI/Qmitk/QmitkPolhemusTrackerWidget.ui
@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>QmitkPolhemusTrackerWidget</class>
+ <widget class="QWidget" name="QmitkPolhemusTrackerWidget">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>475</width>
+    <height>181</height>
+   </rect>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout_11">
+   <item>
+    <widget class="QLabel" name="polhemus_label">
+     <property name="text">
+      <string>&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.0//EN&quot; &quot;http://www.w3.org/TR/REC-html40/strict.dtd&quot;&gt;
+&lt;html&gt;&lt;head&gt;&lt;meta name=&quot;qrichtext&quot; content=&quot;1&quot; /&gt;&lt;style type=&quot;text/css&quot;&gt;
+p, li { white-space: pre-wrap; }
+&lt;/style&gt;&lt;/head&gt;&lt;body style=&quot; font-family:'MS Shell Dlg 2'; font-size:8pt; font-weight:400; font-style:normal;&quot;&gt;
+&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; text-decoration: underline;&quot;&gt;Polhemus Tracker&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <widget class="QCheckBox" name="m_hemisphereTracking">
+     <property name="text">
+      <string>Enable hemisphere tracking</string>
+     </property>
+     <property name="checked">
+      <bool>true</bool>
+     </property>
+    </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>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/Modules/IGTUI/autoload/ConfigurationWidgetRegistry/src/mitkIGTUIActivator.cpp b/Modules/IGTUI/autoload/ConfigurationWidgetRegistry/src/mitkIGTUIActivator.cpp
index c77300921b..4820db746c 100644
--- a/Modules/IGTUI/autoload/ConfigurationWidgetRegistry/src/mitkIGTUIActivator.cpp
+++ b/Modules/IGTUI/autoload/ConfigurationWidgetRegistry/src/mitkIGTUIActivator.cpp
@@ -1,70 +1,80 @@
 /*===================================================================
 
 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 "mitkIGTUIActivator.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"
 
 //standard tracking devices, which always should be avaiable
 #include "QmitkNDIAuroraWidget.h"
 #include "QmitkNDIPolarisWidget.h"
 #include "QmitkMicronTrackerWidget.h"
 #include "QmitkNPOptitrackWidget.h"
 #include "QmitkVirtualTrackerWidget.h"
 #include "QmitkOpenIGTLinkWidget.h"
 
+// Polhemus tracking device
+#ifdef MITK_USE_POLHEMUS_TRACKER
+#include "mitkPolhemusTrackerTypeInformation.h"
+#include "QmitkPolhemusTrackerWidget.h"
+#endif
+
 namespace mitk
 {
   IGTUIActivator::IGTUIActivator()
   {
   }
 
   IGTUIActivator::~IGTUIActivator()
   {
   }
 
   void IGTUIActivator::Load(us::ModuleContext*)
   {
     m_DeviceWidgetCollection.RegisterAsMicroservice();
     //Add widgets of standard tracking devices
     m_DeviceWidgetCollection.RegisterTrackingDeviceWidget(mitk::NDIAuroraTypeInformation::GetTrackingDeviceName(), new QmitkNDIAuroraWidget);
     m_DeviceWidgetCollection.RegisterTrackingDeviceWidget(mitk::NDIPolarisTypeInformation::GetTrackingDeviceName(), new QmitkNDIPolarisWidget);
     m_DeviceWidgetCollection.RegisterTrackingDeviceWidget(mitk::MicronTrackerTypeInformation::GetTrackingDeviceName(), new QmitkMicronTrackerWidget);
     m_DeviceWidgetCollection.RegisterTrackingDeviceWidget(mitk::NPOptitrackTrackingTypeInformation::GetTrackingDeviceName(), new QmitkNPOptitrackWidget);
     m_DeviceWidgetCollection.RegisterTrackingDeviceWidget(mitk::VirtualTrackerTypeInformation::GetTrackingDeviceName(), new QmitkVirtualTrackerWidget);
     m_DeviceWidgetCollection.RegisterTrackingDeviceWidget(mitk::OpenIGTLinkTypeInformation::GetTrackingDeviceName(), new QmitkOpenIGTLinkWidget);
+#ifdef MITK_USE_POLHEMUS_TRACKER
+    m_DeviceWidgetCollection.RegisterTrackingDeviceWidget(mitk::PolhemusTrackerTypeInformation::GetTrackingDeviceName(), new QmitkPolhemusTrackerWidget);
+#endif
   }
 
   void IGTUIActivator::Unload(us::ModuleContext*)
   {
     try
     {
       m_DeviceWidgetCollection.UnRegisterMicroservice();
     }
     catch (std::exception& e)
     {
       MITK_WARN << "Unable to unregister IGTUI DeviceWidgetCollection Microservice: " << e.what();
     }
   }
 }
 
 US_EXPORT_MODULE_ACTIVATOR(mitk::IGTUIActivator)
\ No newline at end of file
diff --git a/Modules/IGTUI/files.cmake b/Modules/IGTUI/files.cmake
index a555fb4dea..df2e5e6088 100644
--- a/Modules/IGTUI/files.cmake
+++ b/Modules/IGTUI/files.cmake
@@ -1,108 +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/QtWidgets/include/QmitkStdMultiWidget.h b/Modules/QtWidgets/include/QmitkStdMultiWidget.h
index a29dde946f..366743c4bc 100644
--- a/Modules/QtWidgets/include/QmitkStdMultiWidget.h
+++ b/Modules/QtWidgets/include/QmitkStdMultiWidget.h
@@ -1,429 +1,433 @@
 /*===================================================================
 
 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 QmitkStdMultiWidget_h
 #define QmitkStdMultiWidget_h
 
 #include "MitkQtWidgetsExports.h"
 
 #include <mitkDataStorage.h>
 #include <mitkLogoAnnotation.h>
 
 #include <mitkMouseModeSwitcher.h>
 
 #include <QFrame>
 #include <qsplitter.h>
 #include <qwidget.h>
 
 #include <QmitkLevelWindowWidget.h>
 #include <QmitkRenderWindow.h>
 
 #include <mitkBaseRenderer.h>
 
 class QHBoxLayout;
 class QVBoxLayout;
 class QGridLayout;
 class QSpacerItem;
 class QmitkLevelWindowWidget;
 class QmitkRenderWindow;
 class vtkCornerAnnotation;
 class vtkMitkRectangleProp;
 
 namespace mitk
 {
   class RenderingManager;
 }
 
 /// \ingroup QmitkModule
 class MITKQTWIDGETS_EXPORT QmitkStdMultiWidget : public QWidget
 {
   Q_OBJECT
 
 public:
   QmitkStdMultiWidget(
     QWidget *parent = 0,
     Qt::WindowFlags f = 0,
     mitk::RenderingManager *renderingManager = 0,
     mitk::BaseRenderer::RenderingMode::Type renderingMode = mitk::BaseRenderer::RenderingMode::Standard,
     const QString &name = "stdmulti");
   virtual ~QmitkStdMultiWidget();
 
   mitk::SliceNavigationController *GetTimeNavigationController();
 
   void RequestUpdate();
 
   void ForceImmediateUpdate();
 
   mitk::MouseModeSwitcher *GetMouseModeSwitcher();
 
   QmitkRenderWindow *GetRenderWindow1() const;
 
   QmitkRenderWindow *GetRenderWindow2() const;
 
   QmitkRenderWindow *GetRenderWindow3() const;
 
   QmitkRenderWindow *GetRenderWindow4() const;
 
   const mitk::Point3D GetCrossPosition() const;
 
   void EnablePositionTracking();
 
   void DisablePositionTracking();
 
   int GetLayout() const;
 
   bool GetGradientBackgroundFlag() const;
 
   /*!
   \brief Access node of widget plane 1
   \return DataNode holding widget plane 1
   */
   mitk::DataNode::Pointer GetWidgetPlane1();
   /*!
   \brief Access node of widget plane 2
   \return DataNode holding widget plane 2
   */
   mitk::DataNode::Pointer GetWidgetPlane2();
   /*!
   \brief Access node of widget plane 3
   \return DataNode holding widget plane 3
   */
   mitk::DataNode::Pointer GetWidgetPlane3();
   /*!
   \brief Convenience method to access node of widget planes
   \param id number of widget plane to be returned
   \return DataNode holding widget plane 3
   */
   mitk::DataNode::Pointer GetWidgetPlane(int id);
 
   bool IsColoredRectanglesEnabled() const;
 
   bool IsDepartmentLogoEnabled() const;
 
   void InitializeWidget();
 
   /// called when the StdMultiWidget is closed to remove the 3 widget planes and the helper node from the DataStorage
   void RemovePlanesFromDataStorage();
 
   void AddPlanesToDataStorage();
 
   void SetDataStorage(mitk::DataStorage *ds);
 
   /** \brief Listener to the CrosshairPositionEvent
 
     Ensures the CrosshairPositionEvent is handled only once and at the end of the Qt-Event loop
   */
   void HandleCrosshairPositionEvent();
 
   /// activate Menu Widget. true: activated, false: deactivated
   void ActivateMenuWidget(bool state);
 
   bool IsMenuWidgetEnabled() const;
 
   void SetCornerAnnotationVisibility(bool visibility);
 
   bool IsCornerAnnotationVisible(void) const;
 
 protected:
   void UpdateAllWidgets();
 
   void HideAllWidgetToolbars();
 
   mitk::DataNode::Pointer GetTopLayerNode(mitk::DataStorage::SetOfObjects::ConstPointer nodes);
 
 public slots:
 
   /// Receives the signal from HandleCrosshairPositionEvent, executes the StatusBar update
   void HandleCrosshairPositionEventDelayed();
 
   void changeLayoutTo2DImagesUp();
 
   void changeLayoutTo2DImagesLeft();
 
   void changeLayoutToDefault();
 
   void changeLayoutToBig3D();
 
   void changeLayoutToWidget1();
 
   void changeLayoutToWidget2();
 
   void changeLayoutToWidget3();
 
   void changeLayoutToRowWidget3And4();
 
   void changeLayoutToColumnWidget3And4();
 
   void changeLayoutToRowWidgetSmall3andBig4();
 
   void changeLayoutToSmallUpperWidget2Big3and4();
 
   void changeLayoutTo2x2Dand3DWidget();
 
   void changeLayoutToLeft2Dand3DRight2D();
 
-  void changeLayoutTo2DUpAnd3DDown();
+  /** Changes the layout to one 2D window up and a 3D window down.
+   *  The 2D window can be defined by its id (1-3). If MITK default
+   *  settings were not changed, 1 is axial, 2 is sagittal and 3 is coronal.
+   */
+  void changeLayoutTo2DUpAnd3DDown(unsigned int id2Dwindow = 2);
 
   void Fit();
 
   void InitPositionTracking();
 
   void AddDisplayPlaneSubTree();
 
   void EnableStandardLevelWindow();
 
   void DisableStandardLevelWindow();
 
   bool InitializeStandardViews(const mitk::Geometry3D *geometry);
 
   void wheelEvent(QWheelEvent *e) override;
 
   void mousePressEvent(QMouseEvent *e) override;
 
   void moveEvent(QMoveEvent *e) override;
 
   void EnsureDisplayContainsPoint(mitk::BaseRenderer *renderer, const mitk::Point3D &p);
 
   void MoveCrossToPosition(const mitk::Point3D &newPosition);
 
   // void EnableNavigationControllerEventListening();
 
   // void DisableNavigationControllerEventListening();
 
   void EnableGradientBackground();
 
   void DisableGradientBackground();
 
   void EnableDepartmentLogo();
 
   void DisableDepartmentLogo();
 
   void EnableColoredRectangles();
 
   void DisableColoredRectangles();
 
   void SetWidgetPlaneVisibility(const char *widgetName, bool visible, mitk::BaseRenderer *renderer = nullptr);
 
   void SetWidgetPlanesVisibility(bool visible, mitk::BaseRenderer *renderer = nullptr);
 
   void SetWidgetPlanesLocked(bool locked);
 
   void SetWidgetPlanesRotationLocked(bool locked);
 
   void SetWidgetPlanesRotationLinked(bool link);
 
   void SetWidgetPlaneMode(int mode);
 
   void SetGradientBackgroundColors(const mitk::Color &upper, const mitk::Color &lower);
 
   void SetDepartmentLogoPath(const char *path);
 
   void SetWidgetPlaneModeToSlicing(bool activate);
 
   void SetWidgetPlaneModeToRotation(bool activate);
 
   void SetWidgetPlaneModeToSwivel(bool activate);
 
   void OnLayoutDesignChanged(int layoutDesignIndex);
 
   void ResetCrosshair();
 
 signals:
 
   void LeftMouseClicked(mitk::Point3D pointValue);
   void WheelMoved(QWheelEvent *);
   void WidgetPlanesRotationLinked(bool);
   void WidgetPlanesRotationEnabled(bool);
   void ViewsInitialized();
   void WidgetPlaneModeSlicing(bool);
   void WidgetPlaneModeRotation(bool);
   void WidgetPlaneModeSwivel(bool);
   void WidgetPlaneModeChange(int);
   void WidgetNotifyNewCrossHairMode(int);
   void Moved();
 
 public:
   /** Define RenderWindow (public)*/
   QmitkRenderWindow *mitkWidget1;
   QmitkRenderWindow *mitkWidget2;
   QmitkRenderWindow *mitkWidget3;
   QmitkRenderWindow *mitkWidget4;
   QmitkLevelWindowWidget *levelWindowWidget;
   /********************************/
 
   enum
   {
     PLANE_MODE_SLICING = 0,
     PLANE_MODE_ROTATION,
     PLANE_MODE_SWIVEL
   };
   enum
   {
     LAYOUT_DEFAULT = 0,
     LAYOUT_2D_IMAGES_UP,
     LAYOUT_2D_IMAGES_LEFT,
     LAYOUT_BIG_3D,
     LAYOUT_WIDGET1,
     LAYOUT_WIDGET2,
     LAYOUT_WIDGET3,
     LAYOUT_2X_2D_AND_3D_WIDGET,
     LAYOUT_ROW_WIDGET_3_AND_4,
     LAYOUT_COLUMN_WIDGET_3_AND_4,
     LAYOUT_ROW_WIDGET_SMALL3_AND_BIG4,
     LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4,
     LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET,
     LAYOUT_2D_UP_AND_3D_DOWN
   };
 
   enum
   {
     AXIAL,
     SAGITTAL,
     CORONAL,
     THREE_D
   };
 
   /**
    * @brief SetCornerAnnotation Create a corner annotation for a widget.
    * @param text The text of the annotation.
    * @param color The color.
    * @param widgetNumber The widget (0-3).
    */
   void SetDecorationProperties(std::string text, mitk::Color color, int widgetNumber);
   /**
    * @brief GetRenderWindow convinience method to get a widget.
    * @param number of the widget (0-3)
    * @return The renderwindow widget.
    */
   QmitkRenderWindow *GetRenderWindow(unsigned int number);
 
   /**
    * @brief SetGradientBackgroundColorForRenderWindow background for a widget.
    *
    * If two different input colors are, a gradient background is generated.
    *
    * @param upper Upper color of the gradient background.
    * @param lower Lower color of the gradient background.
    * @param widgetNumber The widget (0-3).
    */
   void SetGradientBackgroundColorForRenderWindow(const mitk::Color &upper,
                                                  const mitk::Color &lower,
                                                  unsigned int widgetNumber);
 
   /**
    * @brief GetDecorationColorForWidget Get the color for annotation, crosshair and rectangle.
    * @param widgetNumber Number of the renderwindow (0-3).
    * @return Color in mitk format.
    */
   mitk::Color GetDecorationColor(unsigned int widgetNumber);
 
   /**
    * @brief SetDecorationColor Set the color of the decoration of the 4 widgets.
    *
    * This is used to color the frame of the renderwindow and the corner annatation.
    * For the first 3 widgets, this color is a property of the helper object nodes
    * which contain the respective plane geometry. For widget 4, this is a member,
    * since there is no data node for this widget.
    */
   void SetDecorationColor(unsigned int widgetNumber, mitk::Color color);
 
   /**
    * @brief GetCornerAnnotationText Getter for corner annotation text.
    * @param widgetNumber the widget number (0-3).
    * @return The text in the corner annotation.
    */
   std::string GetCornerAnnotationText(unsigned int widgetNumber);
 
   /**
    * @brief GetGradientColors Getter for gradientbackground colors.
    * @param widgetNumber the widget number (0-3).
    * @return A pair of colors. First: upper, second: lower.
    */
   std::pair<mitk::Color, mitk::Color> GetGradientColors(unsigned int widgetNumber);
 
 protected:
   QHBoxLayout *QmitkStdMultiWidgetLayout;
 
   int m_Layout;
   int m_PlaneMode;
 
   mitk::RenderingManager *m_RenderingManager;
 
   mitk::LogoAnnotation::Pointer m_LogoRendering;
 
   bool m_GradientBackgroundFlag;
 
   mitk::MouseModeSwitcher::Pointer m_MouseModeSwitcher;
   mitk::SliceNavigationController *m_TimeNavigationController;
 
   mitk::DataStorage::Pointer m_DataStorage;
 
   /**
    * @brief m_PlaneNode1 the 3 helper objects which contain the plane geometry.
    */
   mitk::DataNode::Pointer m_PlaneNode1;
   mitk::DataNode::Pointer m_PlaneNode2;
   mitk::DataNode::Pointer m_PlaneNode3;
   /**
    * @brief m_ParentNodeForGeometryPlanes This helper object is added to the datastorage
    * and contains the 3 planes for displaying the image geometry (crosshair and 3D planes).
    */
   mitk::DataNode::Pointer m_ParentNodeForGeometryPlanes;
 
   /**
    * @brief m_DecorationColorWidget4 color for annotation and rectangle of widget 4.
    *
    * For other widgets1-3, the color is a property of the respective data node.
    * There is no node for widget 4, hence, we need an extra member.
    */
   mitk::Color m_DecorationColorWidget4;
 
   /**
    * @brief m_GradientBackgroundColors Contains the colors of the gradient background.
    *
    */
   std::pair<mitk::Color, mitk::Color> m_GradientBackgroundColors[4];
 
   QSplitter *m_MainSplit;
   QSplitter *m_LayoutSplit;
   QSplitter *m_SubSplit1;
   QSplitter *m_SubSplit2;
 
   QWidget *mitkWidget1Container;
   QWidget *mitkWidget2Container;
   QWidget *mitkWidget3Container;
   QWidget *mitkWidget4Container;
 
   vtkSmartPointer<vtkCornerAnnotation> m_CornerAnnotations[4];
   vtkSmartPointer<vtkMitkRectangleProp> m_RectangleProps[4];
 
   bool m_PendingCrosshairPositionEvent;
   bool m_CrosshairNavigationEnabled;
   /**
    * @brief CreateCornerAnnotation helper method to create a corner annotation.
    * @param text of the annotation.
    * @param color of the annotation.
    * @return the complete CornerAnnotation.
    */
   vtkSmartPointer<vtkCornerAnnotation> CreateCornerAnnotation(std::string text, mitk::Color color);
 
   /**
    * @brief FillGradientBackgroundWithBlack Internal helper method to initialize the
    * gradient background colors with black.
    */
   void FillGradientBackgroundWithBlack();
 };
 #endif /*QmitkStdMultiWidget_h*/
diff --git a/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp b/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
index 03b998e07f..736ce155b8 100644
--- a/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
@@ -1,2021 +1,2056 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #define SMW_INFO MITK_INFO("widget.stdmulti")
 
 #include "QmitkStdMultiWidget.h"
 
 #include <QGridLayout>
 #include <QHBoxLayout>
 #include <QList>
 #include <QMouseEvent>
 #include <QTimer>
 #include <QVBoxLayout>
 #include <qsplitter.h>
 
 #include "mitkImagePixelReadAccessor.h"
 #include "mitkPixelTypeMultiplex.h"
 #include <mitkManualPlacementAnnotationRenderer.h>
 #include <mitkCameraController.h>
 #include <mitkDataStorage.h>
 #include <mitkImage.h>
 #include <mitkInteractionConst.h>
 #include <mitkLine.h>
 #include <mitkNodePredicateBase.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkPlaneGeometryDataMapper2D.h>
 #include <mitkPointSet.h>
 #include <mitkProperties.h>
 #include <mitkStatusBar.h>
 #include <mitkVtkLayerController.h>
 #include <vtkCornerAnnotation.h>
 #include <vtkMitkRectangleProp.h>
 #include <vtkTextProperty.h>
 
 #include <iomanip>
 
 QmitkStdMultiWidget::QmitkStdMultiWidget(QWidget *parent,
                                          Qt::WindowFlags f,
                                          mitk::RenderingManager *renderingManager,
                                          mitk::BaseRenderer::RenderingMode::Type renderingMode,
                                          const QString &name)
   : QWidget(parent, f),
     mitkWidget1(nullptr),
     mitkWidget2(nullptr),
     mitkWidget3(nullptr),
     mitkWidget4(nullptr),
     levelWindowWidget(nullptr),
     QmitkStdMultiWidgetLayout(nullptr),
     m_Layout(LAYOUT_DEFAULT),
     m_PlaneMode(PLANE_MODE_SLICING),
     m_RenderingManager(renderingManager),
     m_GradientBackgroundFlag(true),
     m_TimeNavigationController(nullptr),
     m_MainSplit(nullptr),
     m_LayoutSplit(nullptr),
     m_SubSplit1(nullptr),
     m_SubSplit2(nullptr),
     mitkWidget1Container(nullptr),
     mitkWidget2Container(nullptr),
     mitkWidget3Container(nullptr),
     mitkWidget4Container(nullptr),
     m_PendingCrosshairPositionEvent(false),
     m_CrosshairNavigationEnabled(false)
 {
   /******************************************************
    * Use the global RenderingManager if none was specified
    * ****************************************************/
   if (m_RenderingManager == nullptr)
   {
     m_RenderingManager = mitk::RenderingManager::GetInstance();
   }
   m_TimeNavigationController = m_RenderingManager->GetTimeNavigationController();
 
   /*******************************/
   // Create Widget manually
   /*******************************/
 
   // create Layouts
   QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
   QmitkStdMultiWidgetLayout->setContentsMargins(0, 0, 0, 0);
 
   // Set Layout to widget
   this->setLayout(QmitkStdMultiWidgetLayout);
 
   // create main splitter
   m_MainSplit = new QSplitter(this);
   QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
 
   // create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter(Qt::Vertical, m_MainSplit);
   m_MainSplit->addWidget(m_LayoutSplit);
 
   // create m_SubSplit1 and m_SubSplit2
   m_SubSplit1 = new QSplitter(m_LayoutSplit);
   m_SubSplit2 = new QSplitter(m_LayoutSplit);
 
   // creae Widget Container
   mitkWidget1Container = new QWidget(m_SubSplit1);
   mitkWidget2Container = new QWidget(m_SubSplit1);
   mitkWidget3Container = new QWidget(m_SubSplit2);
   mitkWidget4Container = new QWidget(m_SubSplit2);
 
   mitkWidget1Container->setContentsMargins(0, 0, 0, 0);
   mitkWidget2Container->setContentsMargins(0, 0, 0, 0);
   mitkWidget3Container->setContentsMargins(0, 0, 0, 0);
   mitkWidget4Container->setContentsMargins(0, 0, 0, 0);
 
   // create Widget Layout
   QHBoxLayout *mitkWidgetLayout1 = new QHBoxLayout(mitkWidget1Container);
   QHBoxLayout *mitkWidgetLayout2 = new QHBoxLayout(mitkWidget2Container);
   QHBoxLayout *mitkWidgetLayout3 = new QHBoxLayout(mitkWidget3Container);
   QHBoxLayout *mitkWidgetLayout4 = new QHBoxLayout(mitkWidget4Container);
 
   m_CornerAnnotations[0] = vtkSmartPointer<vtkCornerAnnotation>::New();
   m_CornerAnnotations[1] = vtkSmartPointer<vtkCornerAnnotation>::New();
   m_CornerAnnotations[2] = vtkSmartPointer<vtkCornerAnnotation>::New();
   m_CornerAnnotations[3] = vtkSmartPointer<vtkCornerAnnotation>::New();
 
   m_RectangleProps[0] = vtkSmartPointer<vtkMitkRectangleProp>::New();
   m_RectangleProps[1] = vtkSmartPointer<vtkMitkRectangleProp>::New();
   m_RectangleProps[2] = vtkSmartPointer<vtkMitkRectangleProp>::New();
   m_RectangleProps[3] = vtkSmartPointer<vtkMitkRectangleProp>::New();
 
   mitkWidgetLayout1->setMargin(0);
   mitkWidgetLayout2->setMargin(0);
   mitkWidgetLayout3->setMargin(0);
   mitkWidgetLayout4->setMargin(0);
 
   // set Layout to Widget Container
   mitkWidget1Container->setLayout(mitkWidgetLayout1);
   mitkWidget2Container->setLayout(mitkWidgetLayout2);
   mitkWidget3Container->setLayout(mitkWidgetLayout3);
   mitkWidget4Container->setLayout(mitkWidgetLayout4);
 
   // set SizePolicy
   mitkWidget1Container->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
   mitkWidget2Container->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
   mitkWidget3Container->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
   mitkWidget4Container->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
 
   // insert Widget Container into the splitters
   m_SubSplit1->addWidget(mitkWidget1Container);
   m_SubSplit1->addWidget(mitkWidget2Container);
 
   m_SubSplit2->addWidget(mitkWidget3Container);
   m_SubSplit2->addWidget(mitkWidget4Container);
 
   // Create RenderWindows 1
   mitkWidget1 = new QmitkRenderWindow(mitkWidget1Container, name + ".widget1", nullptr, m_RenderingManager, renderingMode);
   mitkWidget1->SetLayoutIndex(AXIAL);
   mitkWidgetLayout1->addWidget(mitkWidget1);
 
   // Create RenderWindows 2
   mitkWidget2 = new QmitkRenderWindow(mitkWidget2Container, name + ".widget2", nullptr, m_RenderingManager, renderingMode);
   mitkWidget2->setEnabled(true);
   mitkWidget2->SetLayoutIndex(SAGITTAL);
   mitkWidgetLayout2->addWidget(mitkWidget2);
 
   // Create RenderWindows 3
   mitkWidget3 = new QmitkRenderWindow(mitkWidget3Container, name + ".widget3", nullptr, m_RenderingManager, renderingMode);
   mitkWidget3->SetLayoutIndex(CORONAL);
   mitkWidgetLayout3->addWidget(mitkWidget3);
 
   // Create RenderWindows 4
   mitkWidget4 = new QmitkRenderWindow(mitkWidget4Container, name + ".widget4", nullptr, m_RenderingManager, renderingMode);
   mitkWidget4->SetLayoutIndex(THREE_D);
   mitkWidgetLayout4->addWidget(mitkWidget4);
 
   // create SignalSlot Connection
   connect(mitkWidget1, SIGNAL(SignalLayoutDesignChanged(int)), this, SLOT(OnLayoutDesignChanged(int)));
   connect(mitkWidget1, SIGNAL(ResetView()), this, SLOT(ResetCrosshair()));
   connect(mitkWidget1, SIGNAL(ChangeCrosshairRotationMode(int)), this, SLOT(SetWidgetPlaneMode(int)));
   connect(this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget1, SLOT(OnWidgetPlaneModeChanged(int)));
 
   connect(mitkWidget2, SIGNAL(SignalLayoutDesignChanged(int)), this, SLOT(OnLayoutDesignChanged(int)));
   connect(mitkWidget2, SIGNAL(ResetView()), this, SLOT(ResetCrosshair()));
   connect(mitkWidget2, SIGNAL(ChangeCrosshairRotationMode(int)), this, SLOT(SetWidgetPlaneMode(int)));
   connect(this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget2, SLOT(OnWidgetPlaneModeChanged(int)));
 
   connect(mitkWidget3, SIGNAL(SignalLayoutDesignChanged(int)), this, SLOT(OnLayoutDesignChanged(int)));
   connect(mitkWidget3, SIGNAL(ResetView()), this, SLOT(ResetCrosshair()));
   connect(mitkWidget3, SIGNAL(ChangeCrosshairRotationMode(int)), this, SLOT(SetWidgetPlaneMode(int)));
   connect(this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget3, SLOT(OnWidgetPlaneModeChanged(int)));
 
   connect(mitkWidget4, SIGNAL(SignalLayoutDesignChanged(int)), this, SLOT(OnLayoutDesignChanged(int)));
   connect(mitkWidget4, SIGNAL(ResetView()), this, SLOT(ResetCrosshair()));
   connect(mitkWidget4, SIGNAL(ChangeCrosshairRotationMode(int)), this, SLOT(SetWidgetPlaneMode(int)));
   connect(this, SIGNAL(WidgetNotifyNewCrossHairMode(int)), mitkWidget4, SLOT(OnWidgetPlaneModeChanged(int)));
 
   // Create Level Window Widget
   levelWindowWidget = new QmitkLevelWindowWidget(m_MainSplit); // this
   levelWindowWidget->setObjectName(QString::fromUtf8("levelWindowWidget"));
   QSizePolicy sizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
   sizePolicy.setHorizontalStretch(0);
   sizePolicy.setVerticalStretch(0);
   sizePolicy.setHeightForWidth(levelWindowWidget->sizePolicy().hasHeightForWidth());
   levelWindowWidget->setSizePolicy(sizePolicy);
   levelWindowWidget->setMaximumWidth(50);
 
   // add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget(levelWindowWidget);
 
   // show mainSplitt and add to Layout
   m_MainSplit->show();
 
   // resize Image.
   this->resize(QSize(364, 477).expandedTo(minimumSizeHint()));
 
   // Initialize the widgets.
   this->InitializeWidget();
 
   // Activate Widget Menu
   this->ActivateMenuWidget(true);
 }
 
 void QmitkStdMultiWidget::InitializeWidget()
 {
   // Make all black and overwrite renderwindow 4
   this->FillGradientBackgroundWithBlack();
   // This is #191919 in hex
   float tmp1[3] = {0.098f, 0.098f, 0.098f};
   // This is #7F7F7F in hex
   float tmp2[3] = {0.498f, 0.498f, 0.498f};
   m_GradientBackgroundColors[3] = std::make_pair(mitk::Color(tmp1), mitk::Color(tmp2));
 
   // Yellow is default color for widget4
   m_DecorationColorWidget4[0] = 1.0f;
   m_DecorationColorWidget4[1] = 1.0f;
   m_DecorationColorWidget4[2] = 0.0f;
 
   // transfer colors in WorldGeometry-Nodes of the associated Renderer
   mitk::IntProperty::Pointer layer;
   // of widget 1
   m_PlaneNode1 = mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode1->SetColor(GetDecorationColor(0));
   layer = mitk::IntProperty::New(1000);
   m_PlaneNode1->SetProperty("layer", layer);
 
   // ... of widget 2
   m_PlaneNode2 = mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode2->SetColor(GetDecorationColor(1));
   layer = mitk::IntProperty::New(1000);
   m_PlaneNode2->SetProperty("layer", layer);
 
   // ... of widget 3
   m_PlaneNode3 = mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode3->SetColor(GetDecorationColor(2));
   layer = mitk::IntProperty::New(1000);
   m_PlaneNode3->SetProperty("layer", layer);
 
   // The parent node
   m_ParentNodeForGeometryPlanes =
     mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->GetCurrentWorldPlaneGeometryNode();
   layer = mitk::IntProperty::New(1000);
   m_ParentNodeForGeometryPlanes->SetProperty("layer", layer);
 
   mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->SetMapperID(mitk::BaseRenderer::Standard3D);
   // Set plane mode (slicing/rotation behavior) to slicing (default)
   m_PlaneMode = PLANE_MODE_SLICING;
 
   // Set default view directions for SNCs
   mitkWidget1->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Axial);
   mitkWidget2->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Sagittal);
   mitkWidget3->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Frontal);
   mitkWidget4->GetSliceNavigationController()->SetDefaultViewDirection(mitk::SliceNavigationController::Original);
 
   SetDecorationProperties("Axial", GetDecorationColor(0), 0);
   SetDecorationProperties("Sagittal", GetDecorationColor(1), 1);
   SetDecorationProperties("Coronal", GetDecorationColor(2), 2);
   SetDecorationProperties("3D", GetDecorationColor(3), 3);
 
   // connect to the "time navigation controller": send time via sliceNavigationControllers
   m_TimeNavigationController->ConnectGeometryTimeEvent(mitkWidget1->GetSliceNavigationController(), false);
   m_TimeNavigationController->ConnectGeometryTimeEvent(mitkWidget2->GetSliceNavigationController(), false);
   m_TimeNavigationController->ConnectGeometryTimeEvent(mitkWidget3->GetSliceNavigationController(), false);
   m_TimeNavigationController->ConnectGeometryTimeEvent(mitkWidget4->GetSliceNavigationController(), false);
   mitkWidget1->GetSliceNavigationController()->ConnectGeometrySendEvent(
     mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow()));
 
   // reverse connection between sliceNavigationControllers and m_TimeNavigationController
   mitkWidget1->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
   mitkWidget2->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
   mitkWidget3->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
   // mitkWidget4->GetSliceNavigationController()
   //  ->ConnectGeometryTimeEvent(m_TimeNavigationController, false);
 
   m_MouseModeSwitcher = mitk::MouseModeSwitcher::New();
 
   // setup the department logo rendering
   m_LogoRendering = mitk::LogoAnnotation::New();
   mitk::BaseRenderer::Pointer renderer4 = mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow());
   m_LogoRendering->SetOpacity(0.5);
   mitk::Point2D offset;
   offset.Fill(0.03);
   m_LogoRendering->SetOffsetVector(offset);
   m_LogoRendering->SetRelativeSize(0.15);
   m_LogoRendering->SetCornerPosition(1);
   m_LogoRendering->SetLogoImagePath("DefaultLogo");
   mitk::ManualPlacementAnnotationRenderer::AddAnnotation(m_LogoRendering.GetPointer(), renderer4);
 }
 
 void QmitkStdMultiWidget::FillGradientBackgroundWithBlack()
 {
   // We have 4 widgets and ...
   for (unsigned int i = 0; i < 4; ++i)
   {
     float black[3] = {0.0f, 0.0f, 0.0f};
     m_GradientBackgroundColors[i] = std::make_pair(mitk::Color(black), mitk::Color(black));
   }
 }
 
 std::pair<mitk::Color, mitk::Color> QmitkStdMultiWidget::GetGradientColors(unsigned int widgetNumber)
 {
   if (widgetNumber > 3)
   {
     MITK_ERROR << "Decoration color for unknown widget!";
     float black[3] = {0.0f, 0.0f, 0.0f};
     return std::make_pair(mitk::Color(black), mitk::Color(black));
   }
   return m_GradientBackgroundColors[widgetNumber];
 }
 
 mitk::Color QmitkStdMultiWidget::GetDecorationColor(unsigned int widgetNumber)
 {
   // The implementation looks a bit messy here, but it avoids
   // synchronization of the color of the geometry nodes and an
   // internal member here.
   // Default colors were chosen for decent visibitliy.
   // Feel free to change your preferences in the workbench.
   float tmp[3] = {0.0f, 0.0f, 0.0f};
   switch (widgetNumber)
   {
     case 0:
     {
       if (m_PlaneNode1.IsNotNull())
       {
         if (m_PlaneNode1->GetColor(tmp))
         {
           return dynamic_cast<mitk::ColorProperty *>(m_PlaneNode1->GetProperty("color"))->GetColor();
         }
       }
       float red[3] = {0.753f, 0.0f, 0.0f}; // This is #C00000 in hex
       return mitk::Color(red);
     }
     case 1:
     {
       if (m_PlaneNode2.IsNotNull())
       {
         if (m_PlaneNode2->GetColor(tmp))
         {
           return dynamic_cast<mitk::ColorProperty *>(m_PlaneNode2->GetProperty("color"))->GetColor();
         }
       }
       float green[3] = {0.0f, 0.69f, 0.0f}; // This is #00B000 in hex
       return mitk::Color(green);
     }
     case 2:
     {
       if (m_PlaneNode3.IsNotNull())
       {
         if (m_PlaneNode3->GetColor(tmp))
         {
           return dynamic_cast<mitk::ColorProperty *>(m_PlaneNode3->GetProperty("color"))->GetColor();
         }
       }
       float blue[3] = {0.0, 0.502f, 1.0f}; // This is #0080FF in hex
       return mitk::Color(blue);
     }
     case 3:
     {
       return m_DecorationColorWidget4;
     }
     default:
       MITK_ERROR << "Decoration color for unknown widget!";
       float black[3] = {0.0f, 0.0f, 0.0f};
       return mitk::Color(black);
   }
 }
 
 std::string QmitkStdMultiWidget::GetCornerAnnotationText(unsigned int widgetNumber)
 {
   if (widgetNumber > 3)
   {
     MITK_ERROR << "Decoration color for unknown widget!";
     return std::string("");
   }
   return std::string(m_CornerAnnotations[widgetNumber]->GetText(0));
 }
 
 QmitkStdMultiWidget::~QmitkStdMultiWidget()
 {
   DisablePositionTracking();
   // DisableNavigationControllerEventListening();
 
   m_TimeNavigationController->Disconnect(mitkWidget1->GetSliceNavigationController());
   m_TimeNavigationController->Disconnect(mitkWidget2->GetSliceNavigationController());
   m_TimeNavigationController->Disconnect(mitkWidget3->GetSliceNavigationController());
   m_TimeNavigationController->Disconnect(mitkWidget4->GetSliceNavigationController());
 }
 
 void QmitkStdMultiWidget::RemovePlanesFromDataStorage()
 {
   if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull() && m_PlaneNode3.IsNotNull() &&
       m_ParentNodeForGeometryPlanes.IsNotNull())
   {
     if (m_DataStorage.IsNotNull())
     {
       m_DataStorage->Remove(m_PlaneNode1);
       m_DataStorage->Remove(m_PlaneNode2);
       m_DataStorage->Remove(m_PlaneNode3);
       m_DataStorage->Remove(m_ParentNodeForGeometryPlanes);
     }
   }
 }
 
 void QmitkStdMultiWidget::AddPlanesToDataStorage()
 {
   if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull() && m_PlaneNode3.IsNotNull() &&
       m_ParentNodeForGeometryPlanes.IsNotNull())
   {
     if (m_DataStorage.IsNotNull())
     {
       m_DataStorage->Add(m_ParentNodeForGeometryPlanes);
       m_DataStorage->Add(m_PlaneNode1, m_ParentNodeForGeometryPlanes);
       m_DataStorage->Add(m_PlaneNode2, m_ParentNodeForGeometryPlanes);
       m_DataStorage->Add(m_PlaneNode3, m_ParentNodeForGeometryPlanes);
     }
   }
 }
 
 void QmitkStdMultiWidget::changeLayoutTo2DImagesUp()
 {
   SMW_INFO << "changing layout to 2D images up... " << std::endl;
 
   // Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout;
 
   // create Main Layout
   QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
 
   // Set Layout to widget
   this->setLayout(QmitkStdMultiWidgetLayout);
 
   // create main splitter
   m_MainSplit = new QSplitter(this);
   QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
 
   // create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter(Qt::Vertical, m_MainSplit);
   m_MainSplit->addWidget(m_LayoutSplit);
 
   // add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget(levelWindowWidget);
 
   // create m_SubSplit1 and m_SubSplit2
   m_SubSplit1 = new QSplitter(m_LayoutSplit);
   m_SubSplit2 = new QSplitter(m_LayoutSplit);
 
   // insert Widget Container into splitter top
   m_SubSplit1->addWidget(mitkWidget1Container);
   m_SubSplit1->addWidget(mitkWidget2Container);
   m_SubSplit1->addWidget(mitkWidget3Container);
 
   // set SplitterSize for splitter top
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_SubSplit1->setSizes(splitterSize);
 
   // insert Widget Container into splitter bottom
   m_SubSplit2->addWidget(mitkWidget4Container);
 
   // set SplitterSize for splitter m_LayoutSplit
   splitterSize.clear();
   splitterSize.push_back(400);
   splitterSize.push_back(1000);
   m_LayoutSplit->setSizes(splitterSize);
 
   // show mainSplitt
   m_MainSplit->show();
 
   // show Widget if hidden
   if (mitkWidget1->isHidden())
     mitkWidget1->show();
   if (mitkWidget2->isHidden())
     mitkWidget2->show();
   if (mitkWidget3->isHidden())
     mitkWidget3->show();
   if (mitkWidget4->isHidden())
     mitkWidget4->show();
 
   // Change Layout Name
   m_Layout = LAYOUT_2D_IMAGES_UP;
 
   // update Layout Design List
   mitkWidget1->LayoutDesignListChanged(LAYOUT_2D_IMAGES_UP);
   mitkWidget2->LayoutDesignListChanged(LAYOUT_2D_IMAGES_UP);
   mitkWidget3->LayoutDesignListChanged(LAYOUT_2D_IMAGES_UP);
   mitkWidget4->LayoutDesignListChanged(LAYOUT_2D_IMAGES_UP);
 
   // update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutTo2DImagesLeft()
 {
   SMW_INFO << "changing layout to 2D images left... " << std::endl;
 
   // Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout;
 
   // create Main Layout
   QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
 
   // create main splitter
   m_MainSplit = new QSplitter(this);
   QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
 
   // create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter(m_MainSplit);
   m_MainSplit->addWidget(m_LayoutSplit);
 
   // add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget(levelWindowWidget);
 
   // create m_SubSplit1 and m_SubSplit2
   m_SubSplit1 = new QSplitter(Qt::Vertical, m_LayoutSplit);
   m_SubSplit2 = new QSplitter(m_LayoutSplit);
 
   // insert Widget into the splitters
   m_SubSplit1->addWidget(mitkWidget1Container);
   m_SubSplit1->addWidget(mitkWidget2Container);
   m_SubSplit1->addWidget(mitkWidget3Container);
 
   // set splitterSize of SubSplit1
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_SubSplit1->setSizes(splitterSize);
 
   m_SubSplit2->addWidget(mitkWidget4Container);
 
   // set splitterSize of Layout Split
   splitterSize.clear();
   splitterSize.push_back(400);
   splitterSize.push_back(1000);
   m_LayoutSplit->setSizes(splitterSize);
 
   // show mainSplitt and add to Layout
   m_MainSplit->show();
 
   // show Widget if hidden
   if (mitkWidget1->isHidden())
     mitkWidget1->show();
   if (mitkWidget2->isHidden())
     mitkWidget2->show();
   if (mitkWidget3->isHidden())
     mitkWidget3->show();
   if (mitkWidget4->isHidden())
     mitkWidget4->show();
 
   // update Layout Name
   m_Layout = LAYOUT_2D_IMAGES_LEFT;
 
   // update Layout Design List
   mitkWidget1->LayoutDesignListChanged(LAYOUT_2D_IMAGES_LEFT);
   mitkWidget2->LayoutDesignListChanged(LAYOUT_2D_IMAGES_LEFT);
   mitkWidget3->LayoutDesignListChanged(LAYOUT_2D_IMAGES_LEFT);
   mitkWidget4->LayoutDesignListChanged(LAYOUT_2D_IMAGES_LEFT);
 
   // update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::SetDecorationProperties(std::string text, mitk::Color color, int widgetNumber)
 {
   if (widgetNumber > 3)
   {
     MITK_ERROR << "Unknown render window for annotation.";
     return;
   }
   vtkRenderer *renderer = this->GetRenderWindow(widgetNumber)->GetRenderer()->GetVtkRenderer();
   if (!renderer)
     return;
   vtkSmartPointer<vtkCornerAnnotation> annotation = m_CornerAnnotations[widgetNumber];
   annotation->SetText(0, text.c_str());
   annotation->SetMaximumFontSize(12);
   annotation->GetTextProperty()->SetColor(color[0], color[1], color[2]);
   if (!renderer->HasViewProp(annotation))
   {
     renderer->AddViewProp(annotation);
   }
   vtkSmartPointer<vtkMitkRectangleProp> frame = m_RectangleProps[widgetNumber];
   frame->SetColor(color[0], color[1], color[2]);
   if (!renderer->HasViewProp(frame))
   {
     renderer->AddViewProp(frame);
   }
 }
 
 void QmitkStdMultiWidget::SetCornerAnnotationVisibility(bool visibility)
 {
   for (int i = 0; i < 4; ++i)
   {
     m_CornerAnnotations[i]->SetVisibility(visibility);
   }
 }
 
 bool QmitkStdMultiWidget::IsCornerAnnotationVisible(void) const
 {
   return m_CornerAnnotations[0]->GetVisibility() > 0;
 }
 
 QmitkRenderWindow *QmitkStdMultiWidget::GetRenderWindow(unsigned int number)
 {
   switch (number)
   {
     case 0:
       return this->GetRenderWindow1();
     case 1:
       return this->GetRenderWindow2();
     case 2:
       return this->GetRenderWindow3();
     case 3:
       return this->GetRenderWindow4();
     default:
       MITK_ERROR << "Requested unknown render window";
       break;
   }
   return nullptr;
 }
 
 void QmitkStdMultiWidget::changeLayoutToDefault()
 {
   SMW_INFO << "changing layout to default... " << std::endl;
 
   // Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout;
 
   // create Main Layout
   QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
 
   // create main splitter
   m_MainSplit = new QSplitter(this);
   QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
 
   // create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter(Qt::Vertical, m_MainSplit);
   m_MainSplit->addWidget(m_LayoutSplit);
 
   // add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget(levelWindowWidget);
 
   // create m_SubSplit1 and m_SubSplit2
   m_SubSplit1 = new QSplitter(m_LayoutSplit);
   m_SubSplit2 = new QSplitter(m_LayoutSplit);
 
   // insert Widget container into the splitters
   m_SubSplit1->addWidget(mitkWidget1Container);
   m_SubSplit1->addWidget(mitkWidget2Container);
 
   m_SubSplit2->addWidget(mitkWidget3Container);
   m_SubSplit2->addWidget(mitkWidget4Container);
 
   // set splitter Size
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_SubSplit1->setSizes(splitterSize);
   m_SubSplit2->setSizes(splitterSize);
   m_LayoutSplit->setSizes(splitterSize);
 
   // show mainSplitt and add to Layout
   m_MainSplit->show();
 
   // show Widget if hidden
   if (mitkWidget1->isHidden())
     mitkWidget1->show();
   if (mitkWidget2->isHidden())
     mitkWidget2->show();
   if (mitkWidget3->isHidden())
     mitkWidget3->show();
   if (mitkWidget4->isHidden())
     mitkWidget4->show();
 
   m_Layout = LAYOUT_DEFAULT;
 
   // update Layout Design List
   mitkWidget1->LayoutDesignListChanged(LAYOUT_DEFAULT);
   mitkWidget2->LayoutDesignListChanged(LAYOUT_DEFAULT);
   mitkWidget3->LayoutDesignListChanged(LAYOUT_DEFAULT);
   mitkWidget4->LayoutDesignListChanged(LAYOUT_DEFAULT);
 
   // update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToBig3D()
 {
   SMW_INFO << "changing layout to big 3D ..." << std::endl;
 
   // Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout;
 
   // create Main Layout
   QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
 
   // create main splitter
   m_MainSplit = new QSplitter(this);
   QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
 
   // add widget Splitter to main Splitter
   m_MainSplit->addWidget(mitkWidget4Container);
 
   // add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget(levelWindowWidget);
 
   // show mainSplitt and add to Layout
   m_MainSplit->show();
 
   // show/hide Widgets
   mitkWidget1->hide();
   mitkWidget2->hide();
   mitkWidget3->hide();
   if (mitkWidget4->isHidden())
     mitkWidget4->show();
 
   m_Layout = LAYOUT_BIG_3D;
 
   // update Layout Design List
   mitkWidget1->LayoutDesignListChanged(LAYOUT_BIG_3D);
   mitkWidget2->LayoutDesignListChanged(LAYOUT_BIG_3D);
   mitkWidget3->LayoutDesignListChanged(LAYOUT_BIG_3D);
   mitkWidget4->LayoutDesignListChanged(LAYOUT_BIG_3D);
 
   // update Alle Widgets
   this->UpdateAllWidgets();
   mitk::RenderingManager::GetInstance()->SetRenderWindowFocus(mitkWidget4->GetVtkRenderWindow());
 }
 
 void QmitkStdMultiWidget::changeLayoutToWidget1()
 {
   SMW_INFO << "changing layout to big Widget1 ..." << std::endl;
 
   // Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout;
 
   // create Main Layout
   QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
 
   // create main splitter
   m_MainSplit = new QSplitter(this);
   QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
 
   // add widget Splitter to main Splitter
   m_MainSplit->addWidget(mitkWidget1Container);
 
   // add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget(levelWindowWidget);
 
   // show mainSplitt and add to Layout
   m_MainSplit->show();
 
   // show/hide Widgets
   if (mitkWidget1->isHidden())
     mitkWidget1->show();
   mitkWidget2->hide();
   mitkWidget3->hide();
   mitkWidget4->hide();
 
   m_Layout = LAYOUT_WIDGET1;
 
   // update Layout Design List
   mitkWidget1->LayoutDesignListChanged(LAYOUT_WIDGET1);
   mitkWidget2->LayoutDesignListChanged(LAYOUT_WIDGET1);
   mitkWidget3->LayoutDesignListChanged(LAYOUT_WIDGET1);
   mitkWidget4->LayoutDesignListChanged(LAYOUT_WIDGET1);
 
   // update Alle Widgets
   this->UpdateAllWidgets();
 
   mitk::RenderingManager::GetInstance()->SetRenderWindowFocus(mitkWidget1->GetVtkRenderWindow());
 }
 
 void QmitkStdMultiWidget::changeLayoutToWidget2()
 {
   SMW_INFO << "changing layout to big Widget2 ..." << std::endl;
 
   // Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout;
 
   // create Main Layout
   QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
 
   // create main splitter
   m_MainSplit = new QSplitter(this);
   QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
 
   // add widget Splitter to main Splitter
   m_MainSplit->addWidget(mitkWidget2Container);
 
   // add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget(levelWindowWidget);
 
   // show mainSplitt and add to Layout
   m_MainSplit->show();
 
   // show/hide Widgets
   mitkWidget1->hide();
   if (mitkWidget2->isHidden())
     mitkWidget2->show();
   mitkWidget3->hide();
   mitkWidget4->hide();
 
   m_Layout = LAYOUT_WIDGET2;
 
   // update Layout Design List
   mitkWidget1->LayoutDesignListChanged(LAYOUT_WIDGET2);
   mitkWidget2->LayoutDesignListChanged(LAYOUT_WIDGET2);
   mitkWidget3->LayoutDesignListChanged(LAYOUT_WIDGET2);
   mitkWidget4->LayoutDesignListChanged(LAYOUT_WIDGET2);
 
   // update Alle Widgets
   this->UpdateAllWidgets();
   mitk::RenderingManager::GetInstance()->SetRenderWindowFocus(mitkWidget2->GetVtkRenderWindow());
 }
 
 void QmitkStdMultiWidget::changeLayoutToWidget3()
 {
   SMW_INFO << "changing layout to big Widget3 ..." << std::endl;
 
   // Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout;
 
   // create Main Layout
   QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
 
   // create main splitter
   m_MainSplit = new QSplitter(this);
   QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
 
   // add widget Splitter to main Splitter
   m_MainSplit->addWidget(mitkWidget3Container);
 
   // add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget(levelWindowWidget);
 
   // show mainSplitt and add to Layout
   m_MainSplit->show();
 
   // show/hide Widgets
   mitkWidget1->hide();
   mitkWidget2->hide();
   if (mitkWidget3->isHidden())
     mitkWidget3->show();
   mitkWidget4->hide();
 
   m_Layout = LAYOUT_WIDGET3;
 
   // update Layout Design List
   mitkWidget1->LayoutDesignListChanged(LAYOUT_WIDGET3);
   mitkWidget2->LayoutDesignListChanged(LAYOUT_WIDGET3);
   mitkWidget3->LayoutDesignListChanged(LAYOUT_WIDGET3);
   mitkWidget4->LayoutDesignListChanged(LAYOUT_WIDGET3);
 
   // update Alle Widgets
   this->UpdateAllWidgets();
   mitk::RenderingManager::GetInstance()->SetRenderWindowFocus(mitkWidget3->GetVtkRenderWindow());
 }
 
 void QmitkStdMultiWidget::changeLayoutToRowWidget3And4()
 {
   SMW_INFO << "changing layout to Widget3 and 4 in a Row..." << std::endl;
 
   // Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout;
 
   // create Main Layout
   QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
 
   // create main splitter
   m_MainSplit = new QSplitter(this);
   QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
 
   // create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter(Qt::Vertical, m_MainSplit);
   m_MainSplit->addWidget(m_LayoutSplit);
 
   // add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget(levelWindowWidget);
 
   // add Widgets to splitter
   m_LayoutSplit->addWidget(mitkWidget3Container);
   m_LayoutSplit->addWidget(mitkWidget4Container);
 
   // set Splitter Size
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_LayoutSplit->setSizes(splitterSize);
 
   // show mainSplitt and add to Layout
   m_MainSplit->show();
 
   // show/hide Widgets
   mitkWidget1->hide();
   mitkWidget2->hide();
   if (mitkWidget3->isHidden())
     mitkWidget3->show();
   if (mitkWidget4->isHidden())
     mitkWidget4->show();
 
   m_Layout = LAYOUT_ROW_WIDGET_3_AND_4;
 
   // update Layout Design List
   mitkWidget1->LayoutDesignListChanged(LAYOUT_ROW_WIDGET_3_AND_4);
   mitkWidget2->LayoutDesignListChanged(LAYOUT_ROW_WIDGET_3_AND_4);
   mitkWidget3->LayoutDesignListChanged(LAYOUT_ROW_WIDGET_3_AND_4);
   mitkWidget4->LayoutDesignListChanged(LAYOUT_ROW_WIDGET_3_AND_4);
 
   // update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToColumnWidget3And4()
 {
   SMW_INFO << "changing layout to Widget3 and 4 in one Column..." << std::endl;
 
   // Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout;
 
   // create Main Layout
   QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
 
   // create main splitter
   m_MainSplit = new QSplitter(this);
   QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
 
   // create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter(m_MainSplit);
   m_MainSplit->addWidget(m_LayoutSplit);
 
   // add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget(levelWindowWidget);
 
   // add Widgets to splitter
   m_LayoutSplit->addWidget(mitkWidget3Container);
   m_LayoutSplit->addWidget(mitkWidget4Container);
 
   // set SplitterSize
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_LayoutSplit->setSizes(splitterSize);
 
   // show mainSplitt and add to Layout
   m_MainSplit->show();
 
   // show/hide Widgets
   mitkWidget1->hide();
   mitkWidget2->hide();
   if (mitkWidget3->isHidden())
     mitkWidget3->show();
   if (mitkWidget4->isHidden())
     mitkWidget4->show();
 
   m_Layout = LAYOUT_COLUMN_WIDGET_3_AND_4;
 
   // update Layout Design List
   mitkWidget1->LayoutDesignListChanged(LAYOUT_COLUMN_WIDGET_3_AND_4);
   mitkWidget2->LayoutDesignListChanged(LAYOUT_COLUMN_WIDGET_3_AND_4);
   mitkWidget3->LayoutDesignListChanged(LAYOUT_COLUMN_WIDGET_3_AND_4);
   mitkWidget4->LayoutDesignListChanged(LAYOUT_COLUMN_WIDGET_3_AND_4);
 
   // update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToRowWidgetSmall3andBig4()
 {
   SMW_INFO << "changing layout to Widget3 and 4 in a Row..." << std::endl;
 
   this->changeLayoutToRowWidget3And4();
 
   m_Layout = LAYOUT_ROW_WIDGET_SMALL3_AND_BIG4;
 }
 
 void QmitkStdMultiWidget::changeLayoutToSmallUpperWidget2Big3and4()
 {
   SMW_INFO << "changing layout to Widget3 and 4 in a Row..." << std::endl;
 
   // Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout;
 
   // create Main Layout
   QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
 
   // create main splitter
   m_MainSplit = new QSplitter(this);
   QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
 
   // create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter(Qt::Vertical, m_MainSplit);
   m_MainSplit->addWidget(m_LayoutSplit);
 
   // add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget(levelWindowWidget);
 
   // create m_SubSplit1 and m_SubSplit2
   m_SubSplit1 = new QSplitter(Qt::Vertical, m_LayoutSplit);
   m_SubSplit2 = new QSplitter(m_LayoutSplit);
 
   // insert Widget into the splitters
   m_SubSplit1->addWidget(mitkWidget2Container);
 
   m_SubSplit2->addWidget(mitkWidget3Container);
   m_SubSplit2->addWidget(mitkWidget4Container);
 
   // set Splitter Size
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_SubSplit2->setSizes(splitterSize);
   splitterSize.clear();
   splitterSize.push_back(500);
   splitterSize.push_back(1000);
   m_LayoutSplit->setSizes(splitterSize);
 
   // show mainSplitt
   m_MainSplit->show();
 
   // show Widget if hidden
   mitkWidget1->hide();
   if (mitkWidget2->isHidden())
     mitkWidget2->show();
   if (mitkWidget3->isHidden())
     mitkWidget3->show();
   if (mitkWidget4->isHidden())
     mitkWidget4->show();
 
   m_Layout = LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4;
 
   // update Layout Design List
   mitkWidget1->LayoutDesignListChanged(LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4);
   mitkWidget2->LayoutDesignListChanged(LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4);
   mitkWidget3->LayoutDesignListChanged(LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4);
   mitkWidget4->LayoutDesignListChanged(LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4);
 
   // update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutTo2x2Dand3DWidget()
 {
   SMW_INFO << "changing layout to 2 x 2D and 3D Widget" << std::endl;
 
   // Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout;
 
   // create Main Layout
   QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
 
   // create main splitter
   m_MainSplit = new QSplitter(this);
   QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
 
   // create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter(m_MainSplit);
   m_MainSplit->addWidget(m_LayoutSplit);
 
   // add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget(levelWindowWidget);
 
   // create m_SubSplit1 and m_SubSplit2
   m_SubSplit1 = new QSplitter(Qt::Vertical, m_LayoutSplit);
   m_SubSplit2 = new QSplitter(m_LayoutSplit);
 
   // add Widgets to splitter
   m_SubSplit1->addWidget(mitkWidget1Container);
   m_SubSplit1->addWidget(mitkWidget2Container);
   m_SubSplit2->addWidget(mitkWidget4Container);
 
   // set Splitter Size
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_SubSplit1->setSizes(splitterSize);
   m_LayoutSplit->setSizes(splitterSize);
 
   // show mainSplitt and add to Layout
   m_MainSplit->show();
 
   // show/hide Widgets
   if (mitkWidget1->isHidden())
     mitkWidget1->show();
   if (mitkWidget2->isHidden())
     mitkWidget2->show();
   mitkWidget3->hide();
   if (mitkWidget4->isHidden())
     mitkWidget4->show();
 
   m_Layout = LAYOUT_2X_2D_AND_3D_WIDGET;
 
   // update Layout Design List
   mitkWidget1->LayoutDesignListChanged(LAYOUT_2X_2D_AND_3D_WIDGET);
   mitkWidget2->LayoutDesignListChanged(LAYOUT_2X_2D_AND_3D_WIDGET);
   mitkWidget3->LayoutDesignListChanged(LAYOUT_2X_2D_AND_3D_WIDGET);
   mitkWidget4->LayoutDesignListChanged(LAYOUT_2X_2D_AND_3D_WIDGET);
 
   // update Alle Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::changeLayoutToLeft2Dand3DRight2D()
 {
   SMW_INFO << "changing layout to 2D and 3D left, 2D right Widget" << std::endl;
 
   // Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout;
 
   // create Main Layout
   QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
 
   // create main splitter
   m_MainSplit = new QSplitter(this);
   QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
 
   // create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter(m_MainSplit);
   m_MainSplit->addWidget(m_LayoutSplit);
 
   // add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget(levelWindowWidget);
 
   // create m_SubSplit1 and m_SubSplit2
   m_SubSplit1 = new QSplitter(Qt::Vertical, m_LayoutSplit);
   m_SubSplit2 = new QSplitter(m_LayoutSplit);
 
   // add Widgets to splitter
   m_SubSplit1->addWidget(mitkWidget1Container);
   m_SubSplit1->addWidget(mitkWidget4Container);
   m_SubSplit2->addWidget(mitkWidget2Container);
 
   // set Splitter Size
   QList<int> splitterSize;
   splitterSize.push_back(1000);
   splitterSize.push_back(1000);
   m_SubSplit1->setSizes(splitterSize);
   m_LayoutSplit->setSizes(splitterSize);
 
   // show mainSplitt and add to Layout
   m_MainSplit->show();
 
   // show/hide Widgets
   if (mitkWidget1->isHidden())
     mitkWidget1->show();
   if (mitkWidget2->isHidden())
     mitkWidget2->show();
   mitkWidget3->hide();
   if (mitkWidget4->isHidden())
     mitkWidget4->show();
 
   m_Layout = LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET;
 
   // update Layout Design List
   mitkWidget1->LayoutDesignListChanged(LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET);
   mitkWidget2->LayoutDesignListChanged(LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET);
   mitkWidget3->LayoutDesignListChanged(LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET);
   mitkWidget4->LayoutDesignListChanged(LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET);
 
   // update Alle Widgets
   this->UpdateAllWidgets();
 }
 
-void QmitkStdMultiWidget::changeLayoutTo2DUpAnd3DDown()
+void QmitkStdMultiWidget::changeLayoutTo2DUpAnd3DDown(unsigned int id2Dwindow)
 {
   SMW_INFO << "changing layout to 2D up and 3D down" << std::endl;
+  if (id2Dwindow < 1 || id2Dwindow > 3)
+  {
+    MITK_WARN << "Only 2D render window IDs 1,2 or 3 are valid. Got ID " << id2Dwindow << ". " << "Using default ID 2 instead.";
+    id2Dwindow = 2;
+  }
 
   // Hide all Menu Widgets
   this->HideAllWidgetToolbars();
 
   delete QmitkStdMultiWidgetLayout;
 
   // create Main Layout
   QmitkStdMultiWidgetLayout = new QHBoxLayout(this);
 
   // Set Layout to widget
   this->setLayout(QmitkStdMultiWidgetLayout);
 
   // create main splitter
   m_MainSplit = new QSplitter(this);
   QmitkStdMultiWidgetLayout->addWidget(m_MainSplit);
 
   // create m_LayoutSplit  and add to the mainSplit
   m_LayoutSplit = new QSplitter(Qt::Vertical, m_MainSplit);
   m_MainSplit->addWidget(m_LayoutSplit);
 
   // add LevelWindow Widget to mainSplitter
   m_MainSplit->addWidget(levelWindowWidget);
 
   // create m_SubSplit1 and m_SubSplit2
   m_SubSplit1 = new QSplitter(m_LayoutSplit);
   m_SubSplit2 = new QSplitter(m_LayoutSplit);
 
   // insert Widget Container into splitter top
-  m_SubSplit1->addWidget(mitkWidget1Container);
+  switch (id2Dwindow)
+  {
+  case 1:
+    m_SubSplit1->addWidget(mitkWidget1Container);
+    break;
+  case 2:
+    m_SubSplit1->addWidget(mitkWidget2Container);
+    break;
+  case 3:
+    m_SubSplit1->addWidget(mitkWidget3Container);
+    break;
+  }
 
   // set SplitterSize for splitter top
   QList<int> splitterSize;
   // insert Widget Container into splitter bottom
   m_SubSplit2->addWidget(mitkWidget4Container);
   // set SplitterSize for splitter m_LayoutSplit
   splitterSize.clear();
   splitterSize.push_back(700);
   splitterSize.push_back(700);
   m_LayoutSplit->setSizes(splitterSize);
 
   // show mainSplitt
   m_MainSplit->show();
 
   // show/hide Widgets
-  if (mitkWidget1->isHidden())
-    mitkWidget1->show();
-  mitkWidget2->hide();
-  mitkWidget3->hide();
+  switch (id2Dwindow)
+  {
+  case 1:
+    if (mitkWidget1->isHidden())
+      mitkWidget1->show();
+    mitkWidget2->hide();
+    mitkWidget3->hide();
+    break;
+  case 2:
+    if (mitkWidget2->isHidden())
+      mitkWidget2->show();
+    mitkWidget1->hide();
+    mitkWidget3->hide();
+    break;
+  case 3:
+    if (mitkWidget3->isHidden())
+      mitkWidget3->show();
+    mitkWidget1->hide();
+    mitkWidget2->hide();
+    break;
+  }
+
+  //always show 3D widget
   if (mitkWidget4->isHidden())
     mitkWidget4->show();
 
   m_Layout = LAYOUT_2D_UP_AND_3D_DOWN;
 
   // update Layout Design List
   mitkWidget1->LayoutDesignListChanged(LAYOUT_2D_UP_AND_3D_DOWN);
   mitkWidget2->LayoutDesignListChanged(LAYOUT_2D_UP_AND_3D_DOWN);
   mitkWidget3->LayoutDesignListChanged(LAYOUT_2D_UP_AND_3D_DOWN);
   mitkWidget4->LayoutDesignListChanged(LAYOUT_2D_UP_AND_3D_DOWN);
 
   // update all Widgets
   this->UpdateAllWidgets();
 }
 
 void QmitkStdMultiWidget::SetDataStorage(mitk::DataStorage *ds)
 {
   if (ds == m_DataStorage)
   {
     return;
   }
 
   mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->SetDataStorage(ds);
   mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->SetDataStorage(ds);
   mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->SetDataStorage(ds);
   mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->SetDataStorage(ds);
   m_DataStorage = ds;
 }
 
 void QmitkStdMultiWidget::Fit()
 {
   vtkSmartPointer<vtkRenderer> vtkrenderer;
   vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetVtkRenderer();
   if (vtkrenderer != nullptr)
     vtkrenderer->ResetCamera();
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->GetVtkRenderer();
   if (vtkrenderer != nullptr)
     vtkrenderer->ResetCamera();
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->GetVtkRenderer();
   if (vtkrenderer != nullptr)
     vtkrenderer->ResetCamera();
 
   vtkrenderer = mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->GetVtkRenderer();
   if (vtkrenderer != nullptr)
     vtkrenderer->ResetCamera();
 
   mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetCameraController()->Fit();
   mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow())->GetCameraController()->Fit();
   mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow())->GetCameraController()->Fit();
   mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow())->GetCameraController()->Fit();
 
   int w = vtkObject::GetGlobalWarningDisplay();
   vtkObject::GlobalWarningDisplayOff();
 
   vtkObject::SetGlobalWarningDisplay(w);
 }
 
 void QmitkStdMultiWidget::InitPositionTracking()
 {
   // TODO POSITIONTRACKER
 }
 
 void QmitkStdMultiWidget::AddDisplayPlaneSubTree()
 {
   // add the displayed planes of the multiwidget to a node to which the subtree
   // @a planesSubTree points ...
 
   mitk::PlaneGeometryDataMapper2D::Pointer mapper;
 
   // ... of widget 1
   mitk::BaseRenderer *renderer1 = mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow());
   m_PlaneNode1 = renderer1->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode1->SetProperty("visible", mitk::BoolProperty::New(true));
   m_PlaneNode1->SetProperty("name", mitk::StringProperty::New(std::string(renderer1->GetName()) + ".plane"));
   m_PlaneNode1->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_PlaneNode1->SetProperty("helper object", mitk::BoolProperty::New(true));
   mapper = mitk::PlaneGeometryDataMapper2D::New();
   m_PlaneNode1->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   // ... of widget 2
   mitk::BaseRenderer *renderer2 = mitk::BaseRenderer::GetInstance(mitkWidget2->GetRenderWindow());
   m_PlaneNode2 = renderer2->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode2->SetProperty("visible", mitk::BoolProperty::New(true));
   m_PlaneNode2->SetProperty("name", mitk::StringProperty::New(std::string(renderer2->GetName()) + ".plane"));
   m_PlaneNode2->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_PlaneNode2->SetProperty("helper object", mitk::BoolProperty::New(true));
   mapper = mitk::PlaneGeometryDataMapper2D::New();
   m_PlaneNode2->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   // ... of widget 3
   mitk::BaseRenderer *renderer3 = mitk::BaseRenderer::GetInstance(mitkWidget3->GetRenderWindow());
   m_PlaneNode3 = renderer3->GetCurrentWorldPlaneGeometryNode();
   m_PlaneNode3->SetProperty("visible", mitk::BoolProperty::New(true));
   m_PlaneNode3->SetProperty("name", mitk::StringProperty::New(std::string(renderer3->GetName()) + ".plane"));
   m_PlaneNode3->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
   m_PlaneNode3->SetProperty("helper object", mitk::BoolProperty::New(true));
   mapper = mitk::PlaneGeometryDataMapper2D::New();
   m_PlaneNode3->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
 
   m_ParentNodeForGeometryPlanes = mitk::DataNode::New();
   m_ParentNodeForGeometryPlanes->SetProperty("name", mitk::StringProperty::New("Widgets"));
   m_ParentNodeForGeometryPlanes->SetProperty("helper object", mitk::BoolProperty::New(true));
 }
 
 mitk::SliceNavigationController *QmitkStdMultiWidget::GetTimeNavigationController()
 {
   return m_TimeNavigationController;
 }
 
 void QmitkStdMultiWidget::EnableStandardLevelWindow()
 {
   levelWindowWidget->disconnect(this);
   levelWindowWidget->SetDataStorage(mitk::BaseRenderer::GetInstance(mitkWidget1->GetRenderWindow())->GetDataStorage());
   levelWindowWidget->show();
 }
 
 void QmitkStdMultiWidget::DisableStandardLevelWindow()
 {
   levelWindowWidget->disconnect(this);
   levelWindowWidget->hide();
 }
 
 // CAUTION: Legacy code for enabling Qt-signal-controlled view initialization.
 // Use RenderingManager::InitializeViews() instead.
 bool QmitkStdMultiWidget::InitializeStandardViews(const mitk::Geometry3D *geometry)
 {
   return m_RenderingManager->InitializeViews(geometry);
 }
 
 void QmitkStdMultiWidget::RequestUpdate()
 {
   m_RenderingManager->RequestUpdate(mitkWidget1->GetRenderWindow());
   m_RenderingManager->RequestUpdate(mitkWidget2->GetRenderWindow());
   m_RenderingManager->RequestUpdate(mitkWidget3->GetRenderWindow());
   m_RenderingManager->RequestUpdate(mitkWidget4->GetRenderWindow());
 }
 
 void QmitkStdMultiWidget::ForceImmediateUpdate()
 {
   m_RenderingManager->ForceImmediateUpdate(mitkWidget1->GetRenderWindow());
   m_RenderingManager->ForceImmediateUpdate(mitkWidget2->GetRenderWindow());
   m_RenderingManager->ForceImmediateUpdate(mitkWidget3->GetRenderWindow());
   m_RenderingManager->ForceImmediateUpdate(mitkWidget4->GetRenderWindow());
 }
 
 void QmitkStdMultiWidget::wheelEvent(QWheelEvent *e)
 {
   emit WheelMoved(e);
 }
 
 void QmitkStdMultiWidget::mousePressEvent(QMouseEvent *)
 {
 }
 
 void QmitkStdMultiWidget::moveEvent(QMoveEvent *e)
 {
   QWidget::moveEvent(e);
 
   // it is necessary to readjust the position of the Annotation as the StdMultiWidget has moved
   // unfortunately it's not done by QmitkRenderWindow::moveEvent -> must be done here
   emit Moved();
 }
 
 QmitkRenderWindow *QmitkStdMultiWidget::GetRenderWindow1() const
 {
   return mitkWidget1;
 }
 
 QmitkRenderWindow *QmitkStdMultiWidget::GetRenderWindow2() const
 {
   return mitkWidget2;
 }
 
 QmitkRenderWindow *QmitkStdMultiWidget::GetRenderWindow3() const
 {
   return mitkWidget3;
 }
 
 QmitkRenderWindow *QmitkStdMultiWidget::GetRenderWindow4() const
 {
   return mitkWidget4;
 }
 
 const mitk::Point3D QmitkStdMultiWidget::GetCrossPosition() const
 {
   const mitk::PlaneGeometry *plane1 = mitkWidget1->GetSliceNavigationController()->GetCurrentPlaneGeometry();
   const mitk::PlaneGeometry *plane2 = mitkWidget2->GetSliceNavigationController()->GetCurrentPlaneGeometry();
   const mitk::PlaneGeometry *plane3 = mitkWidget3->GetSliceNavigationController()->GetCurrentPlaneGeometry();
 
   mitk::Line3D line;
   if ((plane1 != nullptr) && (plane2 != nullptr) && (plane1->IntersectionLine(plane2, line)))
   {
     mitk::Point3D point;
     if ((plane3 != nullptr) && (plane3->IntersectionPoint(line, point)))
     {
       return point;
     }
   }
   // TODO BUG POSITIONTRACKER;
   mitk::Point3D p;
   return p;
   // return m_LastLeftClickPositionSupplier->GetCurrentPoint();
 }
 
 void QmitkStdMultiWidget::EnablePositionTracking()
 {
 }
 
 void QmitkStdMultiWidget::DisablePositionTracking()
 {
 }
 
 void QmitkStdMultiWidget::EnsureDisplayContainsPoint(mitk::BaseRenderer *renderer, const mitk::Point3D &p)
 {
   mitk::Point2D pointOnDisplay;
   renderer->WorldToDisplay(p, pointOnDisplay);
 
   if (pointOnDisplay[0] < renderer->GetVtkRenderer()->GetOrigin()[0] ||
       pointOnDisplay[1] < renderer->GetVtkRenderer()->GetOrigin()[1] ||
       pointOnDisplay[0] > renderer->GetVtkRenderer()->GetOrigin()[0] + renderer->GetViewportSize()[0] ||
       pointOnDisplay[1] > renderer->GetVtkRenderer()->GetOrigin()[1] + renderer->GetViewportSize()[1])
   {
     mitk::Point2D pointOnPlane;
     renderer->GetCurrentWorldPlaneGeometry()->Map(p, pointOnPlane);
     renderer->GetCameraController()->MoveCameraToPoint(pointOnPlane);
   }
 }
 
 void QmitkStdMultiWidget::MoveCrossToPosition(const mitk::Point3D &newPosition)
 {
   mitkWidget1->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
   mitkWidget2->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
   mitkWidget3->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
 
   m_RenderingManager->RequestUpdateAll();
 }
 
 void QmitkStdMultiWidget::HandleCrosshairPositionEvent()
 {
   if (!m_PendingCrosshairPositionEvent)
   {
     m_PendingCrosshairPositionEvent = true;
     QTimer::singleShot(0, this, SLOT(HandleCrosshairPositionEventDelayed()));
   }
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetTopLayerNode(mitk::DataStorage::SetOfObjects::ConstPointer nodes)
 {
   mitk::Point3D crosshairPos = this->GetCrossPosition();
   mitk::DataNode::Pointer node;
   int maxlayer = -32768;
 
   if (nodes.IsNotNull())
   {
     mitk::BaseRenderer *baseRenderer = this->mitkWidget1->GetSliceNavigationController()->GetRenderer();
     // find node with largest layer, that is the node shown on top in the render window
     for (unsigned int x = 0; x < nodes->size(); x++)
     {
       if ((nodes->at(x)->GetData()->GetGeometry() != nullptr) &&
           nodes->at(x)->GetData()->GetGeometry()->IsInside(crosshairPos))
       {
         int layer = 0;
         if (!(nodes->at(x)->GetIntProperty("layer", layer)))
           continue;
         if (layer > maxlayer)
         {
           if (static_cast<mitk::DataNode::Pointer>(nodes->at(x))->IsVisible(baseRenderer))
           {
             node = nodes->at(x);
             maxlayer = layer;
           }
         }
       }
     }
   }
   return node;
 }
 
 void QmitkStdMultiWidget::HandleCrosshairPositionEventDelayed()
 {
   m_PendingCrosshairPositionEvent = false;
 
   // find image with highest layer
   mitk::TNodePredicateDataType<mitk::Image>::Pointer isImageData = mitk::TNodePredicateDataType<mitk::Image>::New();
   mitk::DataStorage::SetOfObjects::ConstPointer nodes = this->m_DataStorage->GetSubset(isImageData).GetPointer();
 
   mitk::DataNode::Pointer node;
   mitk::DataNode::Pointer topSourceNode;
   mitk::Image::Pointer image;
   bool isBinary = false;
   node = this->GetTopLayerNode(nodes);
   int component = 0;
   if (node.IsNotNull())
   {
     node->GetBoolProperty("binary", isBinary);
     if (isBinary)
     {
       mitk::DataStorage::SetOfObjects::ConstPointer sourcenodes = m_DataStorage->GetSources(node, nullptr, true);
       if (!sourcenodes->empty())
       {
         topSourceNode = this->GetTopLayerNode(sourcenodes);
       }
       if (topSourceNode.IsNotNull())
       {
         image = dynamic_cast<mitk::Image *>(topSourceNode->GetData());
         topSourceNode->GetIntProperty("Image.Displayed Component", component);
       }
       else
       {
         image = dynamic_cast<mitk::Image *>(node->GetData());
         node->GetIntProperty("Image.Displayed Component", component);
       }
     }
     else
     {
       image = dynamic_cast<mitk::Image *>(node->GetData());
       node->GetIntProperty("Image.Displayed Component", component);
     }
   }
 
   mitk::Point3D crosshairPos = this->GetCrossPosition();
   std::string statusText;
   std::stringstream stream;
   itk::Index<3> p;
   mitk::BaseRenderer *baseRenderer = this->mitkWidget1->GetSliceNavigationController()->GetRenderer();
   unsigned int timestep = baseRenderer->GetTimeStep();
 
   if (image.IsNotNull() && (image->GetTimeSteps() > timestep))
   {
     image->GetGeometry()->WorldToIndex(crosshairPos, p);
     stream.precision(2);
     stream << "Position: <" << std::fixed << crosshairPos[0] << ", " << std::fixed << crosshairPos[1] << ", "
            << std::fixed << crosshairPos[2] << "> mm";
     stream << "; Index: <" << p[0] << ", " << p[1] << ", " << p[2] << "> ";
 
     mitk::ScalarType pixelValue;
 
     mitkPixelTypeMultiplex5(mitk::FastSinglePixelAccess,
                             image->GetChannelDescriptor().GetPixelType(),
                             image,
                             image->GetVolumeData(baseRenderer->GetTimeStep()),
                             p,
                             pixelValue,
                             component);
 
     if (fabs(pixelValue) > 1000000 || fabs(pixelValue) < 0.01)
     {
       stream << "; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: " << std::scientific << pixelValue << "  ";
     }
     else
     {
       stream << "; Time: " << baseRenderer->GetTime() << " ms; Pixelvalue: " << pixelValue << "  ";
     }
   }
   else
   {
     stream << "No image information at this position!";
   }
 
   statusText = stream.str();
   mitk::StatusBar::GetInstance()->DisplayGreyValueText(statusText.c_str());
 }
 
 int QmitkStdMultiWidget::GetLayout() const
 {
   return m_Layout;
 }
 
 bool QmitkStdMultiWidget::GetGradientBackgroundFlag() const
 {
   return m_GradientBackgroundFlag;
 }
 
 void QmitkStdMultiWidget::EnableGradientBackground()
 {
   // gradient background is by default only in widget 4, otherwise
   // interferences between 2D rendering and VTK rendering may occur.
   for (unsigned int i = 0; i < 4; ++i)
   {
     GetRenderWindow(i)->GetRenderer()->GetVtkRenderer()->GradientBackgroundOn();
   }
   m_GradientBackgroundFlag = true;
 }
 
 void QmitkStdMultiWidget::DisableGradientBackground()
 {
   for (unsigned int i = 0; i < 4; ++i)
   {
     GetRenderWindow(i)->GetRenderer()->GetVtkRenderer()->GradientBackgroundOff();
   }
   m_GradientBackgroundFlag = false;
 }
 
 void QmitkStdMultiWidget::EnableDepartmentLogo()
 {
   m_LogoRendering->SetVisibility(true);
   RequestUpdate();
 }
 
 void QmitkStdMultiWidget::DisableDepartmentLogo()
 {
   m_LogoRendering->SetVisibility(false);
   RequestUpdate();
 }
 
 bool QmitkStdMultiWidget::IsDepartmentLogoEnabled() const
 {
   return m_LogoRendering->IsVisible();
 }
 
 void QmitkStdMultiWidget::SetWidgetPlaneVisibility(const char *widgetName, bool visible, mitk::BaseRenderer *renderer)
 {
   if (m_DataStorage.IsNotNull())
   {
     mitk::DataNode *n = m_DataStorage->GetNamedNode(widgetName);
     if (n != nullptr)
       n->SetVisibility(visible, renderer);
   }
 }
 
 void QmitkStdMultiWidget::SetWidgetPlanesVisibility(bool visible, mitk::BaseRenderer *renderer)
 {
   if (m_PlaneNode1.IsNotNull())
   {
     m_PlaneNode1->SetVisibility(visible, renderer);
   }
   if (m_PlaneNode2.IsNotNull())
   {
     m_PlaneNode2->SetVisibility(visible, renderer);
   }
   if (m_PlaneNode3.IsNotNull())
   {
     m_PlaneNode3->SetVisibility(visible, renderer);
   }
   m_RenderingManager->RequestUpdateAll();
 }
 
 void QmitkStdMultiWidget::SetWidgetPlanesLocked(bool locked)
 {
   // do your job and lock or unlock slices.
   GetRenderWindow1()->GetSliceNavigationController()->SetSliceLocked(locked);
   GetRenderWindow2()->GetSliceNavigationController()->SetSliceLocked(locked);
   GetRenderWindow3()->GetSliceNavigationController()->SetSliceLocked(locked);
 }
 
 void QmitkStdMultiWidget::SetWidgetPlanesRotationLocked(bool locked)
 {
   // do your job and lock or unlock slices.
   GetRenderWindow1()->GetSliceNavigationController()->SetSliceRotationLocked(locked);
   GetRenderWindow2()->GetSliceNavigationController()->SetSliceRotationLocked(locked);
   GetRenderWindow3()->GetSliceNavigationController()->SetSliceRotationLocked(locked);
 }
 
 void QmitkStdMultiWidget::SetWidgetPlanesRotationLinked(bool link)
 {
   emit WidgetPlanesRotationLinked(link);
 }
 
 void QmitkStdMultiWidget::SetWidgetPlaneMode(int userMode)
 {
   MITK_DEBUG << "Changing crosshair mode to " << userMode;
 
   emit WidgetNotifyNewCrossHairMode(userMode);
   // Convert user interface mode to actual mode
   {
     switch (userMode)
     {
       case 0:
         m_MouseModeSwitcher->SetInteractionScheme(mitk::MouseModeSwitcher::InteractionScheme::MITK);
         break;
       case 1:
         m_MouseModeSwitcher->SetInteractionScheme(mitk::MouseModeSwitcher::InteractionScheme::ROTATION);
         break;
 
       case 2:
         m_MouseModeSwitcher->SetInteractionScheme(mitk::MouseModeSwitcher::InteractionScheme::ROTATIONLINKED);
         break;
 
       case 3:
         m_MouseModeSwitcher->SetInteractionScheme(mitk::MouseModeSwitcher::InteractionScheme::SWIVEL);
         break;
     }
   }
 }
 
 void QmitkStdMultiWidget::SetGradientBackgroundColorForRenderWindow(const mitk::Color &upper,
                                                                     const mitk::Color &lower,
                                                                     unsigned int widgetNumber)
 {
   if (widgetNumber > 3)
   {
     MITK_ERROR << "Gradientbackground for unknown widget!";
     return;
   }
   m_GradientBackgroundColors[widgetNumber].first = upper;
   m_GradientBackgroundColors[widgetNumber].second = lower;
   vtkRenderer *renderer = GetRenderWindow(widgetNumber)->GetRenderer()->GetVtkRenderer();
   renderer->SetBackground2(upper[0], upper[1], upper[2]);
   renderer->SetBackground(lower[0], lower[1], lower[2]);
   m_GradientBackgroundFlag = true;
 }
 
 void QmitkStdMultiWidget::SetGradientBackgroundColors(const mitk::Color &upper, const mitk::Color &lower)
 {
   for (unsigned int i = 0; i < 4; ++i)
   {
     vtkRenderer *renderer = GetRenderWindow(i)->GetRenderer()->GetVtkRenderer();
     renderer->SetBackground2(upper[0], upper[1], upper[2]);
     renderer->SetBackground(lower[0], lower[1], lower[2]);
   }
   m_GradientBackgroundFlag = true;
 }
 
 void QmitkStdMultiWidget::SetDepartmentLogoPath(const char *path)
 {
   m_LogoRendering->SetLogoImagePath(path);
   mitk::BaseRenderer *renderer = mitk::BaseRenderer::GetInstance(mitkWidget4->GetRenderWindow());
   m_LogoRendering->Update(renderer);
   RequestUpdate();
 }
 
 void QmitkStdMultiWidget::SetWidgetPlaneModeToSlicing(bool activate)
 {
   if (activate)
   {
     this->SetWidgetPlaneMode(PLANE_MODE_SLICING);
   }
 }
 
 void QmitkStdMultiWidget::SetWidgetPlaneModeToRotation(bool activate)
 {
   if (activate)
   {
     this->SetWidgetPlaneMode(PLANE_MODE_ROTATION);
   }
 }
 
 void QmitkStdMultiWidget::SetWidgetPlaneModeToSwivel(bool activate)
 {
   if (activate)
   {
     this->SetWidgetPlaneMode(PLANE_MODE_SWIVEL);
   }
 }
 
 void QmitkStdMultiWidget::OnLayoutDesignChanged(int layoutDesignIndex)
 {
   switch (layoutDesignIndex)
   {
     case LAYOUT_DEFAULT:
     {
       this->changeLayoutToDefault();
       break;
     }
     case LAYOUT_2D_IMAGES_UP:
     {
       this->changeLayoutTo2DImagesUp();
       break;
     }
     case LAYOUT_2D_IMAGES_LEFT:
     {
       this->changeLayoutTo2DImagesLeft();
       break;
     }
     case LAYOUT_BIG_3D:
     {
       this->changeLayoutToBig3D();
       break;
     }
     case LAYOUT_WIDGET1:
     {
       this->changeLayoutToWidget1();
       break;
     }
     case LAYOUT_WIDGET2:
     {
       this->changeLayoutToWidget2();
       break;
     }
     case LAYOUT_WIDGET3:
     {
       this->changeLayoutToWidget3();
       break;
     }
     case LAYOUT_2X_2D_AND_3D_WIDGET:
     {
       this->changeLayoutTo2x2Dand3DWidget();
       break;
     }
     case LAYOUT_ROW_WIDGET_3_AND_4:
     {
       this->changeLayoutToRowWidget3And4();
       break;
     }
     case LAYOUT_COLUMN_WIDGET_3_AND_4:
     {
       this->changeLayoutToColumnWidget3And4();
       break;
     }
     case LAYOUT_ROW_WIDGET_SMALL3_AND_BIG4:
     {
       this->changeLayoutToRowWidgetSmall3andBig4();
       break;
     }
     case LAYOUT_SMALL_UPPER_WIDGET2_BIG3_AND4:
     {
       this->changeLayoutToSmallUpperWidget2Big3and4();
       break;
     }
     case LAYOUT_2D_AND_3D_LEFT_2D_RIGHT_WIDGET:
     {
       this->changeLayoutToLeft2Dand3DRight2D();
       break;
     }
   };
 }
 
 void QmitkStdMultiWidget::UpdateAllWidgets()
 {
   mitkWidget1->resize(mitkWidget1Container->frameSize().width() - 1, mitkWidget1Container->frameSize().height());
   mitkWidget1->resize(mitkWidget1Container->frameSize().width(), mitkWidget1Container->frameSize().height());
 
   mitkWidget2->resize(mitkWidget2Container->frameSize().width() - 1, mitkWidget2Container->frameSize().height());
   mitkWidget2->resize(mitkWidget2Container->frameSize().width(), mitkWidget2Container->frameSize().height());
 
   mitkWidget3->resize(mitkWidget3Container->frameSize().width() - 1, mitkWidget3Container->frameSize().height());
   mitkWidget3->resize(mitkWidget3Container->frameSize().width(), mitkWidget3Container->frameSize().height());
 
   mitkWidget4->resize(mitkWidget4Container->frameSize().width() - 1, mitkWidget4Container->frameSize().height());
   mitkWidget4->resize(mitkWidget4Container->frameSize().width(), mitkWidget4Container->frameSize().height());
 }
 
 void QmitkStdMultiWidget::HideAllWidgetToolbars()
 {
   mitkWidget1->HideRenderWindowMenu();
   mitkWidget2->HideRenderWindowMenu();
   mitkWidget3->HideRenderWindowMenu();
   mitkWidget4->HideRenderWindowMenu();
 }
 
 void QmitkStdMultiWidget::ActivateMenuWidget(bool state)
 {
   mitkWidget1->ActivateMenuWidget(state, this);
   mitkWidget2->ActivateMenuWidget(state, this);
   mitkWidget3->ActivateMenuWidget(state, this);
   mitkWidget4->ActivateMenuWidget(state, this);
 }
 
 bool QmitkStdMultiWidget::IsMenuWidgetEnabled() const
 {
   return mitkWidget1->GetActivateMenuWidgetFlag();
 }
 
 void QmitkStdMultiWidget::SetDecorationColor(unsigned int widgetNumber, mitk::Color color)
 {
   switch (widgetNumber)
   {
     case 0:
       if (m_PlaneNode1.IsNotNull())
       {
         m_PlaneNode1->SetColor(color);
       }
       break;
     case 1:
       if (m_PlaneNode2.IsNotNull())
       {
         m_PlaneNode2->SetColor(color);
       }
       break;
     case 2:
       if (m_PlaneNode3.IsNotNull())
       {
         m_PlaneNode3->SetColor(color);
       }
       break;
     case 3:
       m_DecorationColorWidget4 = color;
       break;
     default:
       MITK_ERROR << "Decoration color for unknown widget!";
       break;
   }
 }
 
 void QmitkStdMultiWidget::ResetCrosshair()
 {
   if (m_DataStorage.IsNotNull())
   {
     m_RenderingManager->InitializeViewsByBoundingObjects(m_DataStorage);
     // m_RenderingManager->InitializeViews( m_DataStorage->ComputeVisibleBoundingGeometry3D() );
     // reset interactor to normal slicing
     this->SetWidgetPlaneMode(PLANE_MODE_SLICING);
   }
 }
 
 void QmitkStdMultiWidget::EnableColoredRectangles()
 {
   m_RectangleProps[0]->SetVisibility(1);
   m_RectangleProps[1]->SetVisibility(1);
   m_RectangleProps[2]->SetVisibility(1);
   m_RectangleProps[3]->SetVisibility(1);
 }
 
 void QmitkStdMultiWidget::DisableColoredRectangles()
 {
   m_RectangleProps[0]->SetVisibility(0);
   m_RectangleProps[1]->SetVisibility(0);
   m_RectangleProps[2]->SetVisibility(0);
   m_RectangleProps[3]->SetVisibility(0);
 }
 
 bool QmitkStdMultiWidget::IsColoredRectanglesEnabled() const
 {
   return m_RectangleProps[0]->GetVisibility() > 0;
 }
 
 mitk::MouseModeSwitcher *QmitkStdMultiWidget::GetMouseModeSwitcher()
 {
   return m_MouseModeSwitcher;
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane1()
 {
   return this->m_PlaneNode1;
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane2()
 {
   return this->m_PlaneNode2;
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane3()
 {
   return this->m_PlaneNode3;
 }
 
 mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane(int id)
 {
   switch (id)
   {
     case 1:
       return this->m_PlaneNode1;
       break;
     case 2:
       return this->m_PlaneNode2;
       break;
     case 3:
       return this->m_PlaneNode3;
       break;
     default:
       return nullptr;
   }
 }
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/PluginList.cmake b/Plugins/PluginList.cmake
index 69a9b62e79..9193ed80c3 100644
--- a/Plugins/PluginList.cmake
+++ b/Plugins/PluginList.cmake
@@ -1,98 +1,98 @@
 
 # Plug-ins must be ordered according to their dependencies
 
 set(MITK_PLUGINS
 
   org.blueberry.core.runtime:ON
   org.blueberry.core.expressions:OFF
   org.blueberry.core.commands:OFF
   org.blueberry.core.jobs:OFF
   org.blueberry.ui.qt:OFF
-  org.blueberry.ui.qt.help:OFF
+  org.blueberry.ui.qt.help:ON
   org.blueberry.ui.qt.log:ON
   org.blueberry.ui.qt.objectinspector:OFF
 
   #org.blueberry.test:ON
   #org.blueberry.uitest:ON
 
   #Testing/org.blueberry.core.runtime.tests:ON
   #Testing/org.blueberry.osgi.tests:ON
 
   org.mitk.core.services:ON
   org.mitk.gui.common:ON
   org.mitk.planarfigure:ON
   org.mitk.core.ext:OFF
   org.mitk.core.jobs:OFF
   org.mitk.simulation:OFF
   org.mitk.gui.qt.application:ON
   org.mitk.gui.qt.coreapplication:OFF
   org.mitk.gui.qt.ext:OFF
   org.mitk.gui.qt.extapplication:OFF
   org.mitk.gui.qt.common:ON
   org.mitk.gui.qt.stdmultiwidgeteditor:ON
   org.mitk.gui.qt.common.legacy:OFF
   org.mitk.gui.qt.cmdlinemodules:OFF
   org.mitk.gui.qt.diffusionimagingapp:OFF
   org.mitk.gui.qt.datamanager:ON
   org.mitk.gui.qt.datamanagerlight:OFF
   org.mitk.gui.qt.properties:ON
   org.mitk.gui.qt.basicimageprocessing:OFF
   org.mitk.gui.qt.dicom:OFF
   org.mitk.gui.qt.dicominspector:OFF
   org.mitk.gui.qt.diffusionimaging:OFF
   org.mitk.gui.qt.diffusionimaging.connectomics:OFF
   org.mitk.gui.qt.diffusionimaging.denoising:OFF
   org.mitk.gui.qt.diffusionimaging.fiberfox:OFF
   org.mitk.gui.qt.diffusionimaging.fiberprocessing:OFF
   org.mitk.gui.qt.diffusionimaging.ivim:OFF
   org.mitk.gui.qt.diffusionimaging.odfpeaks:OFF
   org.mitk.gui.qt.diffusionimaging.partialvolume:OFF
   org.mitk.gui.qt.diffusionimaging.preprocessing:OFF
   org.mitk.gui.qt.diffusionimaging.reconstruction:OFF
   org.mitk.gui.qt.diffusionimaging.registration:OFF
   org.mitk.gui.qt.diffusionimaging.tbss:OFF
   org.mitk.gui.qt.diffusionimaging.tractography:OFF
   org.mitk.gui.qt.dosevisualization:OFF
   org.mitk.gui.qt.geometrytools:OFF
   org.mitk.gui.qt.igtexamples:OFF
   org.mitk.gui.qt.igttracking:OFF
   org.mitk.gui.qt.openigtlink:OFF
   org.mitk.gui.qt.imagecropper:OFF
   org.mitk.gui.qt.imagenavigator:ON
   org.mitk.gui.qt.viewnavigator:OFF
   org.mitk.gui.qt.materialeditor:OFF
   org.mitk.gui.qt.measurementtoolbox:OFF
   org.mitk.gui.qt.moviemaker:OFF
   org.mitk.gui.qt.pointsetinteraction:OFF
   org.mitk.gui.qt.pointsetinteractionmultispectrum:OFF
   org.mitk.gui.qt.python:OFF
   org.mitk.gui.qt.remeshing:OFF
   org.mitk.gui.qt.segmentation:OFF
   org.mitk.gui.qt.simulation:OFF
   org.mitk.gui.qt.aicpregistration:OFF
   org.mitk.gui.qt.renderwindowmanager:OFF
   org.mitk.gui.qt.toftutorial:OFF
   org.mitk.gui.qt.tofutil:OFF
   org.mitk.gui.qt.tubegraph:OFF
   org.mitk.gui.qt.ugvisualization:OFF
   org.mitk.gui.qt.ultrasound:OFF
   org.mitk.gui.qt.volumevisualization:OFF
   org.mitk.gui.qt.eventrecorder:OFF
   org.mitk.gui.qt.xnat:OFF
   org.mitk.gui.qt.igt.app.echotrack:OFF
   org.mitk.gui.qt.spectrocamrecorder:OFF
   org.mitk.gui.qt.classificationsegmentation:OFF
   org.mitk.gui.qt.overlaymanager:OFF
   org.mitk.gui.qt.igt.app.hummelprotocolmeasurements:OFF
   org.mitk.gui.qt.multilabelsegmentation:OFF
   org.mitk.matchpoint.core.helper:OFF
   org.mitk.gui.qt.matchpoint.algorithm.browser:OFF
   org.mitk.gui.qt.matchpoint.algorithm.control:OFF
   org.mitk.gui.qt.matchpoint.algorithm.batch:OFF
   org.mitk.gui.qt.matchpoint.mapper:OFF
   org.mitk.gui.qt.matchpoint.framereg:OFF
   org.mitk.gui.qt.matchpoint.visualizer:OFF
   org.mitk.gui.qt.matchpoint.evaluator:OFF
   org.mitk.gui.qt.matchpoint.manipulator:OFF
   org.mitk.gui.qt.cest:OFF
 )
diff --git a/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.cpp b/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.cpp
index 45a47366b5..196ab23caf 100644
--- a/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.cpp
+++ b/Plugins/org.mitk.gui.qt.datamanager/src/QmitkDataManagerView.cpp
@@ -1,1144 +1,1145 @@
 /*===================================================================
 
 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 "QmitkDataManagerView.h"
 
 //# Own Includes
 //## mitk
 #include "mitkDataStorageEditorInput.h"
 #include "mitkIDataStorageReference.h"
 #include "mitkNodePredicateDataType.h"
 #include "mitkCoreObjectFactory.h"
 #include "mitkColorProperty.h"
 #include "mitkCommon.h"
 #include "mitkNodePredicateData.h"
 #include "mitkNodePredicateNot.h"
 #include "mitkNodePredicateOr.h"
 #include "mitkNodePredicateProperty.h"
 #include "mitkEnumerationProperty.h"
 #include "mitkLookupTableProperty.h"
 #include "mitkProperties.h"
 #include <mitkNodePredicateAnd.h>
 #include <mitkITKImageImport.h>
 #include <mitkIDataStorageService.h>
 #include <mitkIRenderingManager.h>
 #include <mitkImageCast.h>
 //## Qmitk
 #include <QmitkDnDFrameWidget.h>
 #include <QmitkIOUtil.h>
 #include <QmitkDataStorageTreeModel.h>
 #include <QmitkCustomVariants.h>
 #include <QmitkFileSaveAction.h>
 #include <QmitkDataStorageFilterProxyModel.h>
 #include <QmitkNumberPropertySlider.h>
 #include "src/internal/QmitkNodeTableViewKeyFilter.h"
 #include "src/internal/QmitkInfoDialog.h"
 #include "src/internal/QmitkDataManagerItemDelegate.h"
 //## Berry
 #include <berryAbstractUICTKPlugin.h>
 #include <berryIContributor.h>
 #include <berryIEditorPart.h>
 #include <berryIWorkbenchPage.h>
 #include <berryIPreferencesService.h>
 #include <berryPlatform.h>
 #include <berryPlatformUI.h>
 #include <berryIEditorRegistry.h>
 
 //# Toolkit Includes
 #include <QTableView>
 #include <QGroupBox>
 #include <QGridLayout>
 #include <QHBoxLayout>
 #include <QVBoxLayout>
 #include <QLabel>
 #include <QListView>
 #include <QMenu>
 #include <QAction>
 #include <QComboBox>
 #include <QApplication>
 #include <QCursor>
 #include <QHeaderView>
 #include <QTreeView>
 #include <QWidgetAction>
 #include <QSplitter>
 #include <QPushButton>
 #include <QFileDialog>
 #include <QMessageBox>
 #include <QToolBar>
 #include <QKeyEvent>
 #include <QColor>
 #include <QColorDialog>
 #include <QSizePolicy>
 #include <QSortFilterProxyModel>
 #include <QSignalMapper>
 
 #include "mitkDataNodeObject.h"
 #include "mitkIContextMenuAction.h"
 #include "berryIExtensionRegistry.h"
 #include "mitkRenderingModeProperty.h"
 
 const QString QmitkDataManagerView::VIEW_ID = "org.mitk.views.datamanager";
 
 QmitkDataManagerView::QmitkDataManagerView()
     : m_GlobalReinitOnNodeDelete(true),
       m_ItemDelegate(nullptr)
 {
 }
 
 QmitkDataManagerView::~QmitkDataManagerView()
 {
   //Remove all registered actions from each descriptor
   for (std::vector< std::pair< QmitkNodeDescriptor*, QAction* > >::iterator it = m_DescriptorActionList.begin();it != m_DescriptorActionList.end(); it++)
   {
     // first== the NodeDescriptor; second== the registered QAction
     (it->first)->RemoveAction(it->second);
   }
 }
 
 void QmitkDataManagerView::CreateQtPartControl(QWidget* parent)
 {
   m_CurrentRowCount = 0;
   m_Parent = parent;
   //# Preferences
   berry::IPreferencesService* prefService = berry::Platform::GetPreferencesService();
 
   berry::IBerryPreferences::Pointer prefs
       = (prefService->GetSystemPreferences()->Node(VIEW_ID))
         .Cast<berry::IBerryPreferences>();
   assert( prefs );
   prefs->OnChanged.AddListener( berry::MessageDelegate1<QmitkDataManagerView
     , const berry::IBerryPreferences*>( this
       , &QmitkDataManagerView::OnPreferencesChanged ) );
 
   //# GUI
   m_NodeTreeModel = new QmitkDataStorageTreeModel(this->GetDataStorage());
   m_NodeTreeModel->setParent( parent );
   m_NodeTreeModel->SetPlaceNewNodesOnTop(
       prefs->GetBool("Place new nodes on top", true) );
   m_NodeTreeModel->SetAllowHierarchyChange(
     prefs->GetBool("Allow changing of parent node", false));
   m_SurfaceDecimation = prefs->GetBool("Use surface decimation", false);
   // Prepare filters
   m_HelperObjectFilterPredicate = mitk::NodePredicateOr::New(
    mitk::NodePredicateProperty::New("helper object", mitk::BoolProperty::New(true)),
    mitk::NodePredicateProperty::New("hidden object", mitk::BoolProperty::New(true)));
   m_NodeWithNoDataFilterPredicate = mitk::NodePredicateData::New(0);
 
   m_FilterModel = new QmitkDataStorageFilterProxyModel();
   m_FilterModel->setSourceModel(m_NodeTreeModel);
   m_FilterModel->AddFilterPredicate(m_HelperObjectFilterPredicate);
   m_FilterModel->AddFilterPredicate(m_NodeWithNoDataFilterPredicate);
 
   //# Tree View (experimental)
   m_NodeTreeView = new QTreeView;
   m_NodeTreeView->setHeaderHidden(true);
   m_NodeTreeView->setSelectionMode( QAbstractItemView::ExtendedSelection );
   m_NodeTreeView->setSelectionBehavior( QAbstractItemView::SelectRows );
   m_NodeTreeView->setAlternatingRowColors(true);
   m_NodeTreeView->setDragEnabled(true);
   m_NodeTreeView->setDropIndicatorShown(true);
   m_NodeTreeView->setAcceptDrops(true);
   m_NodeTreeView->setContextMenuPolicy(Qt::CustomContextMenu);
   m_NodeTreeView->setModel(m_FilterModel);
   m_NodeTreeView->setTextElideMode(Qt::ElideMiddle);
   m_NodeTreeView->installEventFilter(new QmitkNodeTableViewKeyFilter(this));
 
   m_ItemDelegate = new QmitkDataManagerItemDelegate(m_NodeTreeView);
   m_NodeTreeView->setItemDelegate(m_ItemDelegate);
 
   QObject::connect( m_NodeTreeView, SIGNAL(customContextMenuRequested(const QPoint&))
     , this, SLOT(NodeTableViewContextMenuRequested(const QPoint&)) );
   QObject::connect( m_NodeTreeModel, SIGNAL(rowsInserted (const QModelIndex&, int, int))
     , this, SLOT(NodeTreeViewRowsInserted ( const QModelIndex&, int, int )) );
   QObject::connect( m_NodeTreeModel, SIGNAL(rowsRemoved (const QModelIndex&, int, int))
     , this, SLOT(NodeTreeViewRowsRemoved( const QModelIndex&, int, int )) );
   QObject::connect( m_NodeTreeView->selectionModel()
     , SIGNAL( selectionChanged ( const QItemSelection &, const QItemSelection & ) )
     , this
     , SLOT( NodeSelectionChanged ( const QItemSelection &, const QItemSelection & ) ) );
 
   //# m_NodeMenu
   m_NodeMenu = new QMenu(m_NodeTreeView);
 
   // # Actions
   berry::IEditorRegistry* editorRegistry = berry::PlatformUI::GetWorkbench()->GetEditorRegistry();
   QList<berry::IEditorDescriptor::Pointer> editors = editorRegistry->GetEditors("*.mitk");
   if (editors.size() > 1)
   {
     m_ShowInMapper = new QSignalMapper(this);
     foreach(berry::IEditorDescriptor::Pointer descriptor, editors)
     {
       QAction* action = new QAction(descriptor->GetLabel(), this);
       m_ShowInActions << action;
       m_ShowInMapper->connect(action, SIGNAL(triggered()), m_ShowInMapper, SLOT(map()));
       m_ShowInMapper->setMapping(action, descriptor->GetId());
     }
     connect(m_ShowInMapper, SIGNAL(mapped(QString)), this, SLOT(ShowIn(QString)));
   }
 
   auto unknownDataNodeDescriptor =
     QmitkNodeDescriptorManager::GetInstance()->GetUnknownDataNodeDescriptor();
 
   auto imageDataNodeDescriptor =
     QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("Image");
 
   auto multiComponentImageDataNodeDescriptor =
     QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("MultiComponentImage");
 
   auto diffusionImageDataNodeDescriptor =
     QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("DiffusionImage");
 
   auto surfaceDataNodeDescriptor =
     QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("Surface");
 
   auto pointSetNodeDescriptor =
     QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PointSet");
 
   auto planarLineNodeDescriptor =
     QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarLine");
   auto planarCircleNodeDescriptor =
     QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarCircle");
   auto planarEllipseNodeDescriptor =
     QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarEllipse");
   auto planarAngleNodeDescriptor =
     QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarAngle");
   auto planarFourPointAngleNodeDescriptor =
     QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarFourPointAngle");
   auto planarRectangleNodeDescriptor =
     QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarRectangle");
   auto planarPolygonNodeDescriptor =
     QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarPolygon");
   auto planarPathNodeDescriptor =
     QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarPath");
   auto planarDoubleEllipseNodeDescriptor =
     QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarDoubleEllipse");
   auto planarBezierCurveNodeDescriptor =
     QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarBezierCurve");
   auto planarSubdivisionPolygonNodeDescriptor =
     QmitkNodeDescriptorManager::GetInstance()->GetDescriptor("PlanarSubdivisionPolygon");
 
   QAction* globalReinitAction = new QAction(QIcon(":/org.mitk.gui.qt.datamanager/Refresh_48.png"), tr("Global Reinit"), this);
   QObject::connect( globalReinitAction, SIGNAL( triggered(bool) )
     , this, SLOT( GlobalReinit(bool) ) );
   unknownDataNodeDescriptor->AddAction(globalReinitAction);
   m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(unknownDataNodeDescriptor, globalReinitAction));
 
   QAction* saveAction = new QmitkFileSaveAction(QIcon(":/org.mitk.gui.qt.datamanager/Save_48.png"),
                                                 this->GetSite()->GetWorkbenchWindow());
   unknownDataNodeDescriptor->AddAction(saveAction);
   m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(unknownDataNodeDescriptor,saveAction));
 
   QAction* removeAction = new QAction(QIcon(":/org.mitk.gui.qt.datamanager/Remove_48.png"), tr("Remove"), this);
   QObject::connect( removeAction, SIGNAL( triggered(bool) )
     , this, SLOT( RemoveSelectedNodes(bool) ) );
   unknownDataNodeDescriptor->AddAction(removeAction);
   m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(unknownDataNodeDescriptor,removeAction));
 
   QAction* reinitAction = new QAction(QIcon(":/org.mitk.gui.qt.datamanager/Refresh_48.png"), tr("Reinit"), this);
   QObject::connect( reinitAction, SIGNAL( triggered(bool) )
     , this, SLOT( ReinitSelectedNodes(bool) ) );
   unknownDataNodeDescriptor->AddAction(reinitAction);
   m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(unknownDataNodeDescriptor,reinitAction));
 
   // find contextMenuAction extension points and add them to the node descriptor
   berry::IExtensionRegistry* extensionPointService = berry::Platform::GetExtensionRegistry();
   QList<berry::IConfigurationElement::Pointer> cmActions(
     extensionPointService->GetConfigurationElementsFor("org.mitk.gui.qt.datamanager.contextMenuActions") );
   QList<berry::IConfigurationElement::Pointer>::iterator cmActionsIt;
 
   QmitkNodeDescriptor* tmpDescriptor;
   QAction* contextMenuAction;
   QVariant cmActionDataIt;
   m_ConfElements.clear();
 
   int i=1;
   for (cmActionsIt = cmActions.begin()
     ; cmActionsIt != cmActions.end()
     ; ++cmActionsIt)
   {
     QString cmNodeDescriptorName = (*cmActionsIt)->GetAttribute("nodeDescriptorName");
     QString cmLabel = (*cmActionsIt)->GetAttribute("label");
     QString cmClass = (*cmActionsIt)->GetAttribute("class");
     if(!cmNodeDescriptorName.isEmpty() &&
        !cmLabel.isEmpty() &&
        !cmClass.isEmpty())
     {
       QString cmIcon = (*cmActionsIt)->GetAttribute("icon");
       // create context menu entry here
       tmpDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor(cmNodeDescriptorName);
       if(!tmpDescriptor)
       {
         MITK_WARN << "cannot add action \"" << cmLabel << "\" because descriptor " << cmNodeDescriptorName << " does not exist";
         continue;
       }
       // check if the user specified an icon attribute
       if ( !cmIcon.isEmpty() )
       {
         QIcon icon;
         if (QFile::exists(cmIcon))
         {
           icon = QIcon(cmIcon);
         }
         else
         {
           icon = berry::AbstractUICTKPlugin::ImageDescriptorFromPlugin(
             (*cmActionsIt)->GetContributor()->GetName(), cmIcon);
         }
         contextMenuAction = new QAction(icon, cmLabel, parent);
       }
       else
       {
         contextMenuAction = new QAction( cmLabel, parent);
       }
       tmpDescriptor->AddAction(contextMenuAction);
       m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(tmpDescriptor,contextMenuAction));
       m_ConfElements[contextMenuAction] = *cmActionsIt;
 
       cmActionDataIt.setValue<int>(i);
       contextMenuAction->setData( cmActionDataIt );
       connect( contextMenuAction, SIGNAL( triggered(bool) ) , this, SLOT( ContextMenuActionTriggered(bool) ) );
       ++i;
     }
   }
 
   m_OpacitySlider = new QSlider;
   m_OpacitySlider->setMinimum(0);
   m_OpacitySlider->setMaximum(100);
   m_OpacitySlider->setOrientation(Qt::Horizontal);
   QObject::connect( m_OpacitySlider, SIGNAL( valueChanged(int) )
     , this, SLOT( OpacityChanged(int) ) );
 
   QLabel* _OpacityLabel = new QLabel(tr("Opacity: "));
   QHBoxLayout* _OpacityWidgetLayout = new QHBoxLayout;
   _OpacityWidgetLayout->setContentsMargins(4,4,4,4);
   _OpacityWidgetLayout->addWidget(_OpacityLabel);
   _OpacityWidgetLayout->addWidget(m_OpacitySlider);
   QWidget* _OpacityWidget = new QWidget;
   _OpacityWidget->setLayout(_OpacityWidgetLayout);
 
   QWidgetAction* opacityAction = new QWidgetAction(this);
   opacityAction ->setDefaultWidget(_OpacityWidget);
   QObject::connect( opacityAction , SIGNAL( changed() )
     , this, SLOT( OpacityActionChanged() ) );
   unknownDataNodeDescriptor->AddAction(opacityAction , false);
   m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(unknownDataNodeDescriptor,opacityAction));
 
   m_ColorButton = new QPushButton;
   m_ColorButton->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Minimum);
   //m_ColorButton->setText("Change color");
   QObject::connect( m_ColorButton, SIGNAL( clicked() )
     , this, SLOT( ColorChanged() ) );
 
   QLabel* _ColorLabel = new QLabel(tr("Color: "));
   _ColorLabel->setSizePolicy(QSizePolicy::Minimum,QSizePolicy::Minimum);
   QHBoxLayout* _ColorWidgetLayout = new QHBoxLayout;
   _ColorWidgetLayout->setContentsMargins(4,4,4,4);
   _ColorWidgetLayout->addWidget(_ColorLabel);
   _ColorWidgetLayout->addWidget(m_ColorButton);
   QWidget* _ColorWidget = new QWidget;
   _ColorWidget->setLayout(_ColorWidgetLayout);
 
   QWidgetAction* colorAction = new QWidgetAction(this);
   colorAction->setDefaultWidget(_ColorWidget);
   QObject::connect( colorAction, SIGNAL( changed() )
     , this, SLOT( ColorActionChanged() ) );
 
   { // only give the color context menu option where appropriate
     if (imageDataNodeDescriptor != nullptr)
     {
       imageDataNodeDescriptor->AddAction(colorAction, false);
       m_DescriptorActionList.push_back(
         std::pair<QmitkNodeDescriptor *, QAction *>(imageDataNodeDescriptor, colorAction));
     }
     if (multiComponentImageDataNodeDescriptor != nullptr)
     {
       multiComponentImageDataNodeDescriptor->AddAction(colorAction, false);
       m_DescriptorActionList.push_back(
         std::pair<QmitkNodeDescriptor *, QAction *>(multiComponentImageDataNodeDescriptor, colorAction));
     }
     if (diffusionImageDataNodeDescriptor != nullptr)
     {
       diffusionImageDataNodeDescriptor->AddAction(colorAction, false);
       m_DescriptorActionList.push_back(
         std::pair<QmitkNodeDescriptor *, QAction *>(diffusionImageDataNodeDescriptor, colorAction));
     }
     if (surfaceDataNodeDescriptor != nullptr)
     {
       surfaceDataNodeDescriptor->AddAction(colorAction, false);
       m_DescriptorActionList.push_back(
         std::pair<QmitkNodeDescriptor *, QAction *>(surfaceDataNodeDescriptor, colorAction));
     }
     if (pointSetNodeDescriptor != nullptr)
     {
       pointSetNodeDescriptor->AddAction(colorAction, false);
       m_DescriptorActionList.push_back(
         std::pair<QmitkNodeDescriptor *, QAction *>(pointSetNodeDescriptor, colorAction));
     }
 
     if (planarLineNodeDescriptor != nullptr)
     {
       planarLineNodeDescriptor->AddAction(colorAction, false);
       m_DescriptorActionList.push_back(
         std::pair<QmitkNodeDescriptor *, QAction *>(planarLineNodeDescriptor, colorAction));
     }
 
     if (planarCircleNodeDescriptor != nullptr)
     {
       planarCircleNodeDescriptor->AddAction(colorAction, false);
       m_DescriptorActionList.push_back(
         std::pair<QmitkNodeDescriptor *, QAction *>(planarCircleNodeDescriptor, colorAction));
     }
 
     if (planarEllipseNodeDescriptor != nullptr)
     {
       planarEllipseNodeDescriptor->AddAction(colorAction, false);
       m_DescriptorActionList.push_back(
         std::pair<QmitkNodeDescriptor *, QAction *>(planarEllipseNodeDescriptor, colorAction));
     }
 
     if (planarAngleNodeDescriptor != nullptr)
     {
       planarAngleNodeDescriptor->AddAction(colorAction, false);
       m_DescriptorActionList.push_back(
         std::pair<QmitkNodeDescriptor *, QAction *>(planarAngleNodeDescriptor, colorAction));
     }
 
     if (planarFourPointAngleNodeDescriptor != nullptr)
     {
       planarFourPointAngleNodeDescriptor->AddAction(colorAction, false);
       m_DescriptorActionList.push_back(
         std::pair<QmitkNodeDescriptor *, QAction *>(planarFourPointAngleNodeDescriptor, colorAction));
     }
 
     if (planarRectangleNodeDescriptor != nullptr)
     {
       planarRectangleNodeDescriptor->AddAction(colorAction, false);
       m_DescriptorActionList.push_back(
         std::pair<QmitkNodeDescriptor *, QAction *>(planarRectangleNodeDescriptor, colorAction));
     }
 
     if (planarPolygonNodeDescriptor != nullptr)
     {
       planarPolygonNodeDescriptor->AddAction(colorAction, false);
       m_DescriptorActionList.push_back(
         std::pair<QmitkNodeDescriptor *, QAction *>(planarPolygonNodeDescriptor, colorAction));
     }
 
     if (planarPathNodeDescriptor != nullptr)
     {
       planarPathNodeDescriptor->AddAction(colorAction, false);
       m_DescriptorActionList.push_back(
         std::pair<QmitkNodeDescriptor *, QAction *>(planarPathNodeDescriptor, colorAction));
     }
 
     if (planarDoubleEllipseNodeDescriptor != nullptr)
     {
       planarDoubleEllipseNodeDescriptor->AddAction(colorAction, false);
       m_DescriptorActionList.push_back(
         std::pair<QmitkNodeDescriptor *, QAction *>(planarDoubleEllipseNodeDescriptor, colorAction));
     }
 
     if (planarBezierCurveNodeDescriptor != nullptr)
     {
       planarBezierCurveNodeDescriptor->AddAction(colorAction, false);
       m_DescriptorActionList.push_back(
         std::pair<QmitkNodeDescriptor *, QAction *>(planarBezierCurveNodeDescriptor, colorAction));
     }
 
     if (planarSubdivisionPolygonNodeDescriptor != nullptr)
     {
       planarSubdivisionPolygonNodeDescriptor->AddAction(colorAction, false);
       m_DescriptorActionList.push_back(
         std::pair<QmitkNodeDescriptor *, QAction *>(planarSubdivisionPolygonNodeDescriptor, colorAction));
     }
   }
 
   m_ComponentSlider = new QmitkNumberPropertySlider;
   m_ComponentSlider->setOrientation(Qt::Horizontal);
   //QObject::connect( m_OpacitySlider, SIGNAL( valueChanged(int) )
   //  , this, SLOT( OpacityChanged(int) ) );
 
   QLabel* _ComponentLabel = new QLabel(tr("Component: "));
   QHBoxLayout* _ComponentWidgetLayout = new QHBoxLayout;
   _ComponentWidgetLayout->setContentsMargins(4,4,4,4);
   _ComponentWidgetLayout->addWidget(_ComponentLabel);
   _ComponentWidgetLayout->addWidget(m_ComponentSlider);
   QLabel* _ComponentValueLabel = new QLabel();
   _ComponentWidgetLayout->addWidget(_ComponentValueLabel);
   connect(m_ComponentSlider, SIGNAL(valueChanged(int)), _ComponentValueLabel, SLOT(setNum(int)));
   QWidget* _ComponentWidget = new QWidget;
   _ComponentWidget->setLayout(_ComponentWidgetLayout);
 
   QWidgetAction* componentAction = new QWidgetAction(this);
   componentAction->setDefaultWidget(_ComponentWidget);
   QObject::connect( componentAction , SIGNAL( changed() )
     , this, SLOT( ComponentActionChanged() ) );
   multiComponentImageDataNodeDescriptor->AddAction(componentAction, false);
   m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(multiComponentImageDataNodeDescriptor,componentAction));
   if (diffusionImageDataNodeDescriptor!=nullptr)
   {
       diffusionImageDataNodeDescriptor->AddAction(componentAction, false);
       m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(diffusionImageDataNodeDescriptor,componentAction));
   }
 
   m_TextureInterpolation = new QAction(tr("Texture Interpolation"), this);
   m_TextureInterpolation->setCheckable ( true );
   QObject::connect( m_TextureInterpolation, SIGNAL( changed() )
     , this, SLOT( TextureInterpolationChanged() ) );
   QObject::connect( m_TextureInterpolation, SIGNAL( toggled(bool) )
     , this, SLOT( TextureInterpolationToggled(bool) ) );
   imageDataNodeDescriptor->AddAction(m_TextureInterpolation, false);
   m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(imageDataNodeDescriptor,m_TextureInterpolation));
   if (diffusionImageDataNodeDescriptor!=nullptr)
   {
       diffusionImageDataNodeDescriptor->AddAction(m_TextureInterpolation, false);
       m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(diffusionImageDataNodeDescriptor,m_TextureInterpolation));
   }
 
   m_ColormapAction = new QAction(tr("Colormap"), this);
   m_ColormapAction->setMenu(new QMenu);
   QObject::connect( m_ColormapAction->menu(), SIGNAL( aboutToShow() )
     , this, SLOT( ColormapMenuAboutToShow() ) );
   imageDataNodeDescriptor->AddAction(m_ColormapAction, false);
   m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(imageDataNodeDescriptor, m_ColormapAction));
   if (diffusionImageDataNodeDescriptor!=nullptr)
   {
       diffusionImageDataNodeDescriptor->AddAction(m_ColormapAction, false);
       m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(diffusionImageDataNodeDescriptor, m_ColormapAction));
   }
 
   m_SurfaceRepresentation = new QAction(tr("Surface Representation"), this);
   m_SurfaceRepresentation->setMenu(new QMenu(m_NodeTreeView));
   QObject::connect( m_SurfaceRepresentation->menu(), SIGNAL( aboutToShow() )
     , this, SLOT( SurfaceRepresentationMenuAboutToShow() ) );
   surfaceDataNodeDescriptor->AddAction(m_SurfaceRepresentation, false);
   m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(surfaceDataNodeDescriptor, m_SurfaceRepresentation));
 
   QAction* showOnlySelectedNodes
     = new QAction(QIcon(":/org.mitk.gui.qt.datamanager/ShowSelectedNode_48.png")
     , tr("Show only selected nodes"), this);
   QObject::connect( showOnlySelectedNodes, SIGNAL( triggered(bool) )
     , this, SLOT( ShowOnlySelectedNodes(bool) ) );
   unknownDataNodeDescriptor->AddAction(showOnlySelectedNodes);
   m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(unknownDataNodeDescriptor, showOnlySelectedNodes));
 
   QAction* toggleSelectedVisibility
     = new QAction(QIcon(":/org.mitk.gui.qt.datamanager/InvertShowSelectedNode_48.png")
     , tr("Toggle visibility"), this);
   QObject::connect( toggleSelectedVisibility, SIGNAL( triggered(bool) )
     , this, SLOT( ToggleVisibilityOfSelectedNodes(bool) ) );
   unknownDataNodeDescriptor->AddAction(toggleSelectedVisibility);
   m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(unknownDataNodeDescriptor,toggleSelectedVisibility));
 
   QAction* actionShowInfoDialog
     = new QAction(QIcon(":/org.mitk.gui.qt.datamanager/ShowDataInfo_48.png")
     , tr("Details..."), this);
   QObject::connect( actionShowInfoDialog, SIGNAL( triggered(bool) )
     , this, SLOT( ShowInfoDialogForSelectedNodes(bool) ) );
   unknownDataNodeDescriptor->AddAction(actionShowInfoDialog);
   m_DescriptorActionList.push_back(std::pair<QmitkNodeDescriptor*, QAction*>(unknownDataNodeDescriptor,actionShowInfoDialog));
 
   QGridLayout* _DndFrameWidgetLayout = new QGridLayout;
   _DndFrameWidgetLayout->addWidget(m_NodeTreeView, 0, 0);
   _DndFrameWidgetLayout->setContentsMargins(0,0,0,0);
 
   m_DndFrameWidget = new QmitkDnDFrameWidget(m_Parent);
   m_DndFrameWidget->setLayout(_DndFrameWidgetLayout);
 
   QVBoxLayout* layout = new QVBoxLayout(parent);
   layout->addWidget(m_DndFrameWidget);
   layout->setContentsMargins(0,0,0,0);
 
   m_Parent->setLayout(layout);
 }
 
 void QmitkDataManagerView::SetFocus()
 {
 }
 
 void QmitkDataManagerView::ContextMenuActionTriggered( bool )
 {
   QAction* action = qobject_cast<QAction*> ( sender() );
 
   std::map<QAction*, berry::IConfigurationElement::Pointer>::iterator it
     = m_ConfElements.find( action );
   if( it == m_ConfElements.end() )
   {
     MITK_WARN << "associated conf element for action " << action->text().toStdString() << " not found";
     return;
   }
   berry::IConfigurationElement::Pointer confElem = it->second;
   mitk::IContextMenuAction* contextMenuAction = confElem->CreateExecutableExtension<mitk::IContextMenuAction>("class");
 
   QString className = confElem->GetAttribute("class");
   QString smoothed = confElem->GetAttribute("smoothed");
 
   contextMenuAction->SetDataStorage(this->GetDataStorage());
 
   if(className == "QmitkCreatePolygonModelAction")
   {
+
     if(smoothed == "false")
     {
       contextMenuAction->SetSmoothed(false);
     }
     else
     {
       contextMenuAction->SetSmoothed(true);
     }
     contextMenuAction->SetDecimated(m_SurfaceDecimation);
   }
   else if(className == "QmitkStatisticsAction")
   {
     contextMenuAction->SetFunctionality(this);
   }
 
   contextMenuAction->Run( this->GetCurrentSelection() ); // run the action
 }
 
 void QmitkDataManagerView::OnPreferencesChanged(const berry::IBerryPreferences* prefs)
 {
   if( m_NodeTreeModel->GetPlaceNewNodesOnTopFlag() !=  prefs->GetBool("Place new nodes on top", true) )
     m_NodeTreeModel->SetPlaceNewNodesOnTop( !m_NodeTreeModel->GetPlaceNewNodesOnTopFlag() );
 
   bool hideHelperObjects = !prefs->GetBool("Show helper objects", false);
   if (m_FilterModel->HasFilterPredicate(m_HelperObjectFilterPredicate) != hideHelperObjects)
   {
     if (hideHelperObjects)
     {
         m_FilterModel->AddFilterPredicate(m_HelperObjectFilterPredicate);
     }
     else
     {
         m_FilterModel->RemoveFilterPredicate(m_HelperObjectFilterPredicate);
     }
   }
   bool hideNodesWithNoData = !prefs->GetBool("Show nodes containing no data", false);
 
   if (m_FilterModel->HasFilterPredicate(m_NodeWithNoDataFilterPredicate) != hideNodesWithNoData)
   {
     if (hideNodesWithNoData)
     {
         m_FilterModel->AddFilterPredicate(m_NodeWithNoDataFilterPredicate);
     }
     else
     {
         m_FilterModel->RemoveFilterPredicate(m_NodeWithNoDataFilterPredicate);
     }
   }
 
   m_GlobalReinitOnNodeDelete = prefs->GetBool("Call global reinit if node is deleted", true);
 
   m_NodeTreeView->expandAll();
 
   m_SurfaceDecimation = prefs->GetBool("Use surface decimation", false);
 
   m_NodeTreeModel->SetAllowHierarchyChange(
     prefs->GetBool("Allow changing of parent node", false));
 
   this->GlobalReinit();
 
 
 }
 
 void QmitkDataManagerView::NodeTableViewContextMenuRequested( const QPoint & pos )
 {
   QModelIndex selectedProxy = m_NodeTreeView->indexAt ( pos );
   QModelIndex selected = m_FilterModel->mapToSource(selectedProxy);
   mitk::DataNode::Pointer node = m_NodeTreeModel->GetNode(selected);
   QList<mitk::DataNode::Pointer> selectedNodes = this->GetCurrentSelection();
 
   if(!selectedNodes.isEmpty())
   {
     m_NodeMenu->clear();
     QList<QAction*> actions;
     if(selectedNodes.size() == 1 )
     {
       actions = QmitkNodeDescriptorManager::GetInstance()->GetActions(node);
 
       for(QList<QAction*>::iterator it = actions.begin(); it != actions.end(); ++it)
       {
         (*it)->setData(QVariant::fromValue(node.GetPointer()));
       }
     }
     else
       actions = QmitkNodeDescriptorManager::GetInstance()->GetActions(selectedNodes);
 
     if (!m_ShowInActions.isEmpty())
     {
       QMenu* showInMenu = m_NodeMenu->addMenu(tr("Show In"));
       showInMenu->addActions(m_ShowInActions);
     }
     m_NodeMenu->addActions(actions);
     m_NodeMenu->popup(QCursor::pos());
   }
 }
 
 void QmitkDataManagerView::OpacityChanged(int value)
 {
   mitk::DataNode* node = m_NodeTreeModel->GetNode(m_FilterModel->mapToSource(m_NodeTreeView->selectionModel()->currentIndex()));
   if(node)
   {
     float opacity = static_cast<float>(value)/100.0f;
     node->SetFloatProperty("opacity", opacity);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkDataManagerView::OpacityActionChanged()
 {
   mitk::DataNode* node = m_NodeTreeModel->GetNode(m_FilterModel->mapToSource(m_NodeTreeView->selectionModel()->currentIndex()));
   if(node)
   {
     float opacity = 0.0;
     if(node->GetFloatProperty("opacity", opacity))
     {
       m_OpacitySlider->setValue(static_cast<int>(opacity*100));
     }
   }
 }
 
 void QmitkDataManagerView::ComponentActionChanged()
 {
   mitk::DataNode* node = m_NodeTreeModel->GetNode(m_FilterModel->mapToSource(m_NodeTreeView->selectionModel()->currentIndex()));
   mitk::IntProperty* componentProperty = nullptr;
   int numComponents = 0;
   if(node)
   {
     componentProperty =
         dynamic_cast<mitk::IntProperty*>(node->GetProperty("Image.Displayed Component"));
     mitk::Image* img = dynamic_cast<mitk::Image*>(node->GetData());
     if (img != nullptr)
     {
       numComponents = img->GetPixelType().GetNumberOfComponents();
     }
   }
   if (componentProperty && numComponents > 1)
   {
     m_ComponentSlider->SetProperty(componentProperty);
     m_ComponentSlider->setMinValue(0);
     m_ComponentSlider->setMaxValue(numComponents-1);
   }
   else
   {
     m_ComponentSlider->SetProperty(static_cast<mitk::IntProperty*>(nullptr));
   }
 }
 
 void QmitkDataManagerView::ColorChanged()
  {
    mitk::DataNode* node = m_NodeTreeModel->GetNode(m_FilterModel->mapToSource(m_NodeTreeView->selectionModel()->currentIndex()));
    if(node)
    {
     mitk::Color color;
     mitk::ColorProperty::Pointer colorProp;
     node->GetProperty(colorProp,"color");
     if(colorProp.IsNull())
       return;
     color = colorProp->GetValue();
     QColor initial(color.GetRed()*255,color.GetGreen()*255,color.GetBlue()*255);
     QColor qcolor = QColorDialog::getColor(initial,0,QString(tr("Change color")));
     if (!qcolor.isValid())
       return;
     m_ColorButton->setAutoFillBackground(true);
     node->SetProperty("color",mitk::ColorProperty::New(qcolor.red()/255.0,qcolor.green()/255.0,qcolor.blue()/255.0));
     if (node->GetProperty("binaryimage.selectedcolor"))
     {
       node->SetProperty("binaryimage.selectedcolor",mitk::ColorProperty::New(qcolor.red()/255.0,qcolor.green()/255.0,qcolor.blue()/255.0));
     }
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
    }
  }
 
 void QmitkDataManagerView::ColorActionChanged()
 {
   mitk::DataNode* node = m_NodeTreeModel->GetNode(m_FilterModel->mapToSource(m_NodeTreeView->selectionModel()->currentIndex()));
   if(node)
   {
     mitk::Color color;
     mitk::ColorProperty::Pointer colorProp;
     node->GetProperty(colorProp,"color");
     if(colorProp.IsNull())
       return;
     color = colorProp->GetValue();
 
     QString styleSheet = "background-color:rgb(";
     styleSheet.append(QString::number(color[0]*255));
     styleSheet.append(",");
     styleSheet.append(QString::number(color[1]*255));
     styleSheet.append(",");
     styleSheet.append(QString::number(color[2]*255));
     styleSheet.append(")");
     m_ColorButton->setStyleSheet(styleSheet);
   }
 }
 
 void QmitkDataManagerView::TextureInterpolationChanged()
 {
   mitk::DataNode* node = m_NodeTreeModel->GetNode(m_FilterModel->mapToSource(m_NodeTreeView->selectionModel()->currentIndex()));
   if(node)
   {
     bool textureInterpolation = false;
     node->GetBoolProperty("texture interpolation", textureInterpolation);
     m_TextureInterpolation->setChecked(textureInterpolation);
   }
 }
 
 void QmitkDataManagerView::TextureInterpolationToggled( bool checked )
 {
   mitk::DataNode* node = m_NodeTreeModel->GetNode(m_FilterModel->mapToSource(m_NodeTreeView->selectionModel()->currentIndex()));
   if(node)
   {
     node->SetBoolProperty("texture interpolation", checked);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 
 }
 
 void QmitkDataManagerView::ColormapActionToggled( bool /*checked*/ )
 {
   mitk::DataNode* node = m_NodeTreeModel->GetNode(m_FilterModel->mapToSource(m_NodeTreeView->selectionModel()->currentIndex()));
   if(!node)
     return;
 
   mitk::LookupTableProperty::Pointer lookupTableProperty =
     dynamic_cast<mitk::LookupTableProperty*>(node->GetProperty("LookupTable"));
   if (!lookupTableProperty)
     return;
 
   QAction* senderAction = qobject_cast<QAction*>(QObject::sender());
   if(!senderAction)
     return;
 
   std::string activatedItem = senderAction->text().toStdString();
 
   mitk::LookupTable::Pointer lookupTable = lookupTableProperty->GetValue();
   if (!lookupTable)
     return;
 
   lookupTable->SetType(activatedItem);
   lookupTableProperty->SetValue(lookupTable);
   mitk::RenderingModeProperty::Pointer renderingMode =
     dynamic_cast<mitk::RenderingModeProperty*>(node->GetProperty("Image Rendering.Mode"));
   renderingMode->SetValue(mitk::RenderingModeProperty::LOOKUPTABLE_LEVELWINDOW_COLOR);
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkDataManagerView::ColormapMenuAboutToShow()
 {
   mitk::DataNode* node = m_NodeTreeModel->GetNode(m_FilterModel->mapToSource(m_NodeTreeView->selectionModel()->currentIndex()));
   if(!node)
     return;
 
   mitk::LookupTableProperty::Pointer lookupTableProperty =
     dynamic_cast<mitk::LookupTableProperty*>(node->GetProperty("LookupTable"));
   if (!lookupTableProperty)
   {
     mitk::LookupTable::Pointer mitkLut = mitk::LookupTable::New();
     lookupTableProperty = mitk::LookupTableProperty::New();
     lookupTableProperty->SetLookupTable(mitkLut);
     node->SetProperty("LookupTable", lookupTableProperty);
   }
 
   mitk::LookupTable::Pointer lookupTable = lookupTableProperty->GetValue();
   if (!lookupTable)
     return;
 
   m_ColormapAction->menu()->clear();
   QAction* tmp;
 
   int i = 0;
   std::string lutType = lookupTable->typenameList[i];
 
   while (lutType != "END_OF_ARRAY")
   {
     tmp = m_ColormapAction->menu()->addAction(QString::fromStdString(lutType));
     tmp->setCheckable(true);
 
     if (lutType == lookupTable->GetActiveTypeAsString())
     {
       tmp->setChecked(true);
     }
 
     QObject::connect(tmp, SIGNAL(triggered(bool)), this, SLOT(ColormapActionToggled(bool)));
 
     lutType = lookupTable->typenameList[++i];
   }
 }
 
 void QmitkDataManagerView::SurfaceRepresentationMenuAboutToShow()
 {
   mitk::DataNode* node = m_NodeTreeModel->GetNode(m_FilterModel->mapToSource(m_NodeTreeView->selectionModel()->currentIndex()));
   if(!node)
     return;
 
   mitk::EnumerationProperty* representationProp =
       dynamic_cast<mitk::EnumerationProperty*> (node->GetProperty("material.representation"));
   if(!representationProp)
     return;
 
   // clear menu
   m_SurfaceRepresentation->menu()->clear();
   QAction* tmp;
 
   // create menu entries
   for(mitk::EnumerationProperty::EnumConstIterator it=representationProp->Begin(); it!=representationProp->End()
     ; it++)
   {
     tmp = m_SurfaceRepresentation->menu()->addAction(QString::fromStdString(it->second));
     tmp->setCheckable(true);
 
     if(it->second == representationProp->GetValueAsString())
     {
       tmp->setChecked(true);
     }
 
     QObject::connect( tmp, SIGNAL( triggered(bool) )
       , this, SLOT( SurfaceRepresentationActionToggled(bool) ) );
   }
 }
 
 void QmitkDataManagerView::SurfaceRepresentationActionToggled( bool /*checked*/ )
 {
   mitk::DataNode* node = m_NodeTreeModel->GetNode(m_FilterModel->mapToSource(m_NodeTreeView->selectionModel()->currentIndex()));
   if(!node)
     return;
 
   mitk::EnumerationProperty* representationProp =
       dynamic_cast<mitk::EnumerationProperty*> (node->GetProperty("material.representation"));
   if(!representationProp)
     return;
 
   QAction* senderAction = qobject_cast<QAction*> ( QObject::sender() );
 
   if(!senderAction)
     return;
 
   std::string activatedItem = senderAction->text().toStdString();
 
   if ( activatedItem != representationProp->GetValueAsString() )
   {
     if ( representationProp->IsValidEnumerationValue( activatedItem ) )
     {
       representationProp->SetValue( activatedItem );
       representationProp->InvokeEvent( itk::ModifiedEvent() );
       representationProp->Modified();
 
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
   }
 
 }
 
 void QmitkDataManagerView::ReinitSelectedNodes( bool )
 {
   mitk::IRenderWindowPart* renderWindow = this->GetRenderWindowPart();
 
   if (renderWindow == nullptr)
     renderWindow = this->OpenRenderWindowPart(false);
 
   QList<mitk::DataNode::Pointer> selectedNodes = this->GetCurrentSelection();
 
   foreach(mitk::DataNode::Pointer node, selectedNodes)
   {
     mitk::BaseData::Pointer basedata = node->GetData();
     if ( basedata.IsNotNull() &&
       basedata->GetTimeGeometry()->IsValid() )
     {
       renderWindow->GetRenderingManager()->InitializeViews(
           basedata->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
     }
   }
 }
 
 void QmitkDataManagerView::RemoveSelectedNodes( bool )
 {
   QModelIndexList indexesOfSelectedRowsFiltered = m_NodeTreeView->selectionModel()->selectedRows();
   QModelIndexList indexesOfSelectedRows;
   for (int i = 0; i < indexesOfSelectedRowsFiltered.size(); ++i)
   {
     indexesOfSelectedRows.push_back(m_FilterModel->mapToSource(indexesOfSelectedRowsFiltered[i]));
   }
   if(indexesOfSelectedRows.size() < 1)
   {
     return;
   }
   std::vector<mitk::DataNode::Pointer> selectedNodes;
 
   mitk::DataNode::Pointer node = 0;
   QString question = tr("Do you really want to remove ");
 
   for (QModelIndexList::iterator it = indexesOfSelectedRows.begin()
     ; it != indexesOfSelectedRows.end(); it++)
   {
     node = m_NodeTreeModel->GetNode(*it);
     // if node is not defined or if the node contains geometry data do not remove it
     if ( node.IsNotNull() /*& strcmp(node->GetData()->GetNameOfClass(), "PlaneGeometryData") != 0*/ )
     {
       selectedNodes.push_back(node);
       question.append(QString::fromStdString(node->GetName()));
       question.append(", ");
     }
   }
   // remove the last two characters = ", "
   question = question.remove(question.size()-2, 2);
   question.append(tr(" from data storage?"));
 
   QMessageBox::StandardButton answerButton = QMessageBox::question( m_Parent
     , tr("DataManager")
     , question
     , QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
 
   if(answerButton == QMessageBox::Yes)
   {
     for (std::vector<mitk::DataNode::Pointer>::iterator it = selectedNodes.begin()
       ; it != selectedNodes.end(); it++)
     {
       node = *it;
       this->GetDataStorage()->Remove(node);
       if (m_GlobalReinitOnNodeDelete)
           this->GlobalReinit(false);
     }
   }
 }
 
 void QmitkDataManagerView::MakeAllNodesInvisible( bool )
 {
   QList<mitk::DataNode::Pointer> nodes = m_NodeTreeModel->GetNodeSet();
 
   foreach(mitk::DataNode::Pointer node, nodes)
   {
     node->SetVisibility(false);
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkDataManagerView::ShowOnlySelectedNodes( bool )
 {
   QList<mitk::DataNode::Pointer> selectedNodes = this->GetCurrentSelection();
   QList<mitk::DataNode::Pointer> allNodes = m_NodeTreeModel->GetNodeSet();
 
   foreach(mitk::DataNode::Pointer node, allNodes)
   {
     node->SetVisibility(selectedNodes.contains(node));
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkDataManagerView::ToggleVisibilityOfSelectedNodes( bool )
 {
   QList<mitk::DataNode::Pointer> selectedNodes = this->GetCurrentSelection();
 
   bool isVisible = false;
   foreach(mitk::DataNode::Pointer node, selectedNodes)
   {
     isVisible = false;
     node->GetBoolProperty("visible", isVisible);
     node->SetVisibility(!isVisible);
   }
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkDataManagerView::ShowInfoDialogForSelectedNodes( bool )
 {
   QList<mitk::DataNode::Pointer> selectedNodes = this->GetCurrentSelection();
 
   QmitkInfoDialog _QmitkInfoDialog(selectedNodes, this->m_Parent);
   _QmitkInfoDialog.exec();
 }
 
 void QmitkDataManagerView::NodeChanged(const mitk::DataNode* /*node*/)
 {
   // m_FilterModel->invalidate();
   // fix as proposed by R. Khlebnikov in the mitk-users mail from 02.09.2014
   QMetaObject::invokeMethod( m_FilterModel, "invalidate", Qt::QueuedConnection );
 }
 
 QItemSelectionModel *QmitkDataManagerView::GetDataNodeSelectionModel() const
 {
   return m_NodeTreeView->selectionModel();
 }
 
 void QmitkDataManagerView::GlobalReinit( bool )
 {
   mitk::IRenderWindowPart* renderWindow = this->GetRenderWindowPart();
 
   if (renderWindow == nullptr)
     renderWindow = this->OpenRenderWindowPart(false);
 
   // no render window available
   if (renderWindow == nullptr) return;
 
   mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(this->GetDataStorage());
 }
 
 void QmitkDataManagerView::NodeTreeViewRowsRemoved (
   const QModelIndex & /*parent*/, int /*start*/, int /*end*/ )
 {
   m_CurrentRowCount = m_NodeTreeModel->rowCount();
 }
 void QmitkDataManagerView::NodeTreeViewRowsInserted( const QModelIndex & parent, int, int )
 {
   QModelIndex viewIndex = m_FilterModel->mapFromSource(parent);
   m_NodeTreeView->setExpanded(viewIndex, true);
 
   // a new row was inserted
   if( m_CurrentRowCount == 0 && m_NodeTreeModel->rowCount() == 1 )
   {
     this->OpenRenderWindowPart();
     m_CurrentRowCount = m_NodeTreeModel->rowCount();
   }
 }
 
 void QmitkDataManagerView::NodeSelectionChanged( const QItemSelection & /*selected*/, const QItemSelection & /*deselected*/ )
 {
   QList<mitk::DataNode::Pointer> nodes = m_NodeTreeModel->GetNodeSet();
 
   foreach(mitk::DataNode::Pointer node, nodes)
   {
     if ( node.IsNotNull() )
       node->SetBoolProperty("selected", false);
   }
 
   nodes.clear();
   nodes = this->GetCurrentSelection();
 
   foreach(mitk::DataNode::Pointer node, nodes)
   {
     if ( node.IsNotNull() )
       node->SetBoolProperty("selected", true);
   }
   //changing the selection does NOT require any rendering processes!
   //mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkDataManagerView::ShowIn(const QString &editorId)
 {
   berry::IWorkbenchPage::Pointer page = this->GetSite()->GetPage();
   berry::IEditorInput::Pointer input(new mitk::DataStorageEditorInput(this->GetDataStorageReference()));
   page->OpenEditor(input, editorId, false, berry::IWorkbenchPage::MATCH_ID);
 }
 
 mitk::IRenderWindowPart* QmitkDataManagerView::OpenRenderWindowPart(bool activatedEditor)
 {
   if (activatedEditor)
   {
     return this->GetRenderWindowPart(QmitkAbstractView::ACTIVATE | QmitkAbstractView::OPEN);
   }
   else
   {
     return this->GetRenderWindowPart(QmitkAbstractView::BRING_TO_FRONT | QmitkAbstractView::OPEN);
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCombinedModality.ui b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCombinedModality.ui
index a65c698b89..e7f25ad991 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCombinedModality.ui
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCombinedModality.ui
@@ -1,398 +1,398 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkUSNavigationStepCombinedModality</class>
  <widget class="QWidget" name="QmitkUSNavigationStepCombinedModality">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>286</width>
     <height>339</height>
    </rect>
   </property>
   <property name="minimumSize">
    <size>
     <width>0</width>
     <height>300</height>
    </size>
   </property>
   <property name="windowTitle">
    <string>Form</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
     <widget class="QLabel" name="combinedModalityLabel">
      <property name="text">
       <string>Available Combined Modalities</string>
      </property>
      <property name="alignment">
-      <set>Qt::AlignCenter</set>
+      <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter</set>
      </property>
     </widget>
    </item>
    <item>
     <widget class="QmitkServiceListWidget" name="combinedModalityListWidget" native="true">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Ignored">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="minimumSize">
       <size>
        <width>0</width>
        <height>0</height>
       </size>
      </property>
     </widget>
    </item>
    <item>
     <layout class="QGridLayout" name="gridLayout">
      <item row="0" column="0">
       <widget class="QToolButton" name="combinedModalityCreateButton">
        <property name="toolTip">
         <string>Create New Combined Modality</string>
        </property>
        <property name="text">
         <string/>
        </property>
        <property name="icon">
         <iconset resource="../../../resources/USNavigation.qrc">
          <normaloff>:/USNavigation/plus.png</normaloff>:/USNavigation/plus.png</iconset>
        </property>
       </widget>
      </item>
      <item row="0" column="1">
       <widget class="QToolButton" name="combinedModalityDeleteButton">
        <property name="enabled">
         <bool>false</bool>
        </property>
        <property name="toolTip">
         <string>Delete Selected Combined Modality</string>
        </property>
        <property name="text">
         <string/>
        </property>
        <property name="icon">
         <iconset resource="../../../resources/USNavigation.qrc">
          <normaloff>:/USNavigation/minus.png</normaloff>:/USNavigation/minus.png</iconset>
        </property>
       </widget>
      </item>
      <item row="0" column="3">
       <widget class="QToolButton" name="combinedModalitEditButton">
        <property name="enabled">
         <bool>false</bool>
        </property>
        <property name="toolTip">
         <string>Edit Selected Combined Modality</string>
        </property>
        <property name="text">
         <string/>
        </property>
        <property name="icon">
         <iconset resource="../../../resources/USNavigation.qrc">
          <normaloff>:/USNavigation/preferences.png</normaloff>:/USNavigation/preferences.png</iconset>
        </property>
       </widget>
      </item>
      <item row="0" column="6">
       <widget class="QToolButton" name="combinedModalityDistconnectButton">
        <property name="enabled">
         <bool>false</bool>
        </property>
        <property name="toolTip">
         <string>Disconnect Selected Combined Modality</string>
        </property>
        <property name="text">
         <string/>
        </property>
        <property name="icon">
         <iconset resource="../../../resources/USNavigation.qrc">
          <normaloff>:/USNavigation/process-stop.png</normaloff>:/USNavigation/process-stop.png</iconset>
        </property>
       </widget>
      </item>
      <item row="0" column="4">
       <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 row="0" column="2">
       <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 row="0" column="5">
       <widget class="QToolButton" name="combinedModalityActivateButton">
        <property name="enabled">
         <bool>false</bool>
        </property>
        <property name="toolTip">
         <string>Activate Selected Combined Modality</string>
        </property>
        <property name="text">
         <string/>
        </property>
        <property name="icon">
         <iconset resource="../../../resources/USNavigation.qrc">
          <normaloff>:/USNavigation/accept.png</normaloff>:/USNavigation/accept.png</iconset>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item>
     <spacer name="verticalSpacer_9">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeType">
       <enum>QSizePolicy::Fixed</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>13</height>
       </size>
      </property>
     </spacer>
    </item>
    <item>
     <widget class="QLabel" name="helpLabel">
      <property name="font">
       <font>
        <pointsize>8</pointsize>
       </font>
      </property>
      <property name="text">
       <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Select a Combined Modality from the list above or create a new one first. A calibration file must be loaded if the Combined Modality isn't calibrated already. Calibrations can be managed by hitting the &lt;span style=&quot; text-decoration: underline;&quot;&gt;Edit&lt;/span&gt; button above.&lt;/p&gt;&lt;p&gt;You can proceed by hitting the &lt;span style=&quot; text-decoration: underline;&quot;&gt;Next&lt;/span&gt; button.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
      </property>
      <property name="wordWrap">
       <bool>true</bool>
      </property>
     </widget>
    </item>
    <item>
     <spacer name="verticalSpacer_10">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeType">
       <enum>QSizePolicy::Fixed</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>13</height>
       </size>
      </property>
     </spacer>
    </item>
    <item>
     <widget class="QmitkUSCombinedModalityCreationWidget" name="combinedModalityCreateWidget" native="true"/>
    </item>
    <item>
     <widget class="QmitkUSCombinedModalityEditWidget" name="combinedModalityEditWidget" native="true"/>
    </item>
    <item>
     <widget class="QGroupBox" name="calibrationGroupBox">
      <property name="enabled">
       <bool>false</bool>
      </property>
      <property name="title">
       <string>Calibration</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_2">
       <item>
        <widget class="QLabel" name="calibrationLoadStateLabel">
         <property name="font">
          <font>
           <italic>true</italic>
          </font>
         </property>
         <property name="text">
          <string>Selected device is not calibrated.</string>
         </property>
         <property name="alignment">
          <set>Qt::AlignCenter</set>
         </property>
         <property name="wordWrap">
          <bool>true</bool>
         </property>
        </widget>
       </item>
       <item>
        <widget class="QPushButton" name="calibrationLoadButton">
         <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="text">
          <string>&amp;Load Calibration</string>
         </property>
         <property name="icon">
          <iconset resource="../../../resources/USNavigation.qrc">
           <normaloff>:/USNavigation/document-open.png</normaloff>:/USNavigation/document-open.png</iconset>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>QmitkUSCombinedModalityCreationWidget</class>
    <extends>QWidget</extends>
    <header>src/internal/Widgets/QmitkUSCombinedModalityCreationWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkServiceListWidget</class>
    <extends>QWidget</extends>
    <header>QmitkServiceListWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkUSCombinedModalityEditWidget</class>
    <extends>QWidget</extends>
    <header>src/internal/Widgets/QmitkUSCombinedModalityEditWidget.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources>
   <include location="../../../resources/USNavigation.qrc"/>
  </resources>
  <connections>
   <connection>
    <sender>calibrationLoadButton</sender>
    <signal>clicked()</signal>
    <receiver>QmitkUSNavigationStepCombinedModality</receiver>
    <slot>OnLoadCalibration()</slot>
    <hints>
     <hint type="sourcelabel">
      <x>142</x>
      <y>268</y>
     </hint>
     <hint type="destinationlabel">
      <x>142</x>
      <y>149</y>
     </hint>
    </hints>
   </connection>
   <connection>
    <sender>combinedModalityCreateButton</sender>
    <signal>clicked()</signal>
    <receiver>QmitkUSNavigationStepCombinedModality</receiver>
    <slot>OnCombinedModalityCreateNewButtonClicked()</slot>
    <hints>
     <hint type="sourcelabel">
      <x>52</x>
      <y>73</y>
     </hint>
     <hint type="destinationlabel">
      <x>142</x>
      <y>149</y>
     </hint>
    </hints>
   </connection>
   <connection>
    <sender>combinedModalityDeleteButton</sender>
    <signal>clicked()</signal>
    <receiver>QmitkUSNavigationStepCombinedModality</receiver>
    <slot>OnDeleteButtonClicked()</slot>
    <hints>
     <hint type="sourcelabel">
      <x>112</x>
      <y>73</y>
     </hint>
     <hint type="destinationlabel">
      <x>142</x>
      <y>149</y>
     </hint>
    </hints>
   </connection>
   <connection>
    <sender>combinedModalityDistconnectButton</sender>
    <signal>clicked()</signal>
    <receiver>QmitkUSNavigationStepCombinedModality</receiver>
    <slot>OnDisconnectButtonClicked()</slot>
    <hints>
     <hint type="sourcelabel">
      <x>232</x>
      <y>73</y>
     </hint>
     <hint type="destinationlabel">
      <x>142</x>
      <y>149</y>
     </hint>
    </hints>
   </connection>
   <connection>
    <sender>combinedModalitEditButton</sender>
    <signal>clicked()</signal>
    <receiver>QmitkUSNavigationStepCombinedModality</receiver>
    <slot>OnCombinedModalityEditButtonClicked()</slot>
    <hints>
     <hint type="sourcelabel">
      <x>172</x>
      <y>73</y>
     </hint>
     <hint type="destinationlabel">
      <x>142</x>
      <y>149</y>
     </hint>
    </hints>
   </connection>
   <connection>
    <sender>combinedModalityActivateButton</sender>
    <signal>clicked()</signal>
    <receiver>QmitkUSNavigationStepCombinedModality</receiver>
    <slot>OnActivateButtonClicked()</slot>
    <hints>
     <hint type="sourcelabel">
      <x>235</x>
      <y>60</y>
     </hint>
     <hint type="destinationlabel">
      <x>142</x>
      <y>149</y>
     </hint>
    </hints>
   </connection>
  </connections>
  <slots>
   <slot>OnCombinedModalityCreateNewButtonClicked()</slot>
   <slot>OnDeleteButtonClicked()</slot>
   <slot>OnLoadCalibration()</slot>
   <slot>OnDisconnectButtonClicked()</slot>
   <slot>OnCombinedModalityEditButtonClicked()</slot>
   <slot>OnActivateButtonClicked()</slot>
  </slots>
 </ui>
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.cpp b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.cpp
index 2aa6285e54..f00972ed30 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepMarkerIntervention.cpp
@@ -1,1020 +1,1020 @@
 /*===================================================================
 
 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 "QmitkUSNavigationStepMarkerIntervention.h"
 #include "ui_QmitkUSNavigationStepMarkerIntervention.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkContourModel.h"
 #include "mitkNeedleProjectionFilter.h"
 #include "mitkNodeDisplacementFilter.h"
 #include "mitkSurface.h"
 #include "mitkTextAnnotation2D.h"
 #include <mitkBaseGeometry.h>
 #include <mitkManualPlacementAnnotationRenderer.h>
 
 #include "../Filter/mitkUSNavigationTargetIntersectionFilter.h"
 #include "../Filter/mitkUSNavigationTargetOcclusionFilter.h"
 #include "../Filter/mitkUSNavigationTargetUpdateFilter.h"
 
 #include "../USNavigationMarkerPlacement.h"
 #include "../Widgets/QmitkZoneProgressBar.h"
 #include "../mitkUSTargetPlacementQualityCalculator.h"
 
 #include "../Interactors/mitkUSPointMarkInteractor.h"
 #include "usModuleRegistry.h"
 
 #include "mitkLookupTable.h"
 #include "mitkLookupTableProperty.h"
 
 #include "mitkSurface.h"
 
 // VTK
 #include "vtkCellLocator.h"
 #include "vtkDataSet.h"
 #include "vtkDoubleArray.h"
 #include "vtkFloatArray.h"
 #include "vtkIdList.h"
 #include "vtkLinearTransform.h"
 #include "vtkLookupTable.h"
 #include "vtkMath.h"
 #include "vtkOBBTree.h"
 #include "vtkPointData.h"
 #include "vtkPointData.h"
 #include "vtkPolyData.h"
 #include "vtkSelectEnclosedPoints.h"
 #include "vtkSmartPointer.h"
 #include "vtkSphereSource.h"
 #include "vtkTransformPolyDataFilter.h"
 #include "vtkWarpScalar.h"
 
 QmitkUSNavigationStepMarkerIntervention::QmitkUSNavigationStepMarkerIntervention(QWidget *parent)
   : QmitkUSAbstractNavigationStep(parent),
-  m_NumberOfTargets(0),
-  m_TargetProgressBar(0),
-  m_PlannedTargetProgressBar(0),
-  m_CurrentTargetIndex(0),
-  m_CurrentTargetReached(false),
-  m_ShowPlanningColors(false),
-  m_NeedleProjectionFilter(mitk::NeedleProjectionFilter::New()),
-  m_NodeDisplacementFilter(mitk::NodeDisplacementFilter::New()),
-  m_TargetUpdateFilter(mitk::USNavigationTargetUpdateFilter::New()),
-  m_TargetOcclusionFilter(mitk::USNavigationTargetOcclusionFilter::New()),
-  m_TargetIntersectionFilter(mitk::USNavigationTargetIntersectionFilter::New()),
-  m_PlacementQualityCalculator(mitk::USTargetPlacementQualityCalculator::New()),
-  m_ListenerTargetCoordinatesChanged(this, &QmitkUSNavigationStepMarkerIntervention::UpdateTargetCoordinates),
-  m_TargetStructureWarnOverlay(mitk::TextAnnotation2D::New()),
-  m_ReferenceSensorIndex(1),
-  m_NeedleSensorIndex(0),
-  ui(new Ui::QmitkUSNavigationStepMarkerIntervention)
+    m_NumberOfTargets(0),
+    m_TargetProgressBar(0),
+    m_PlannedTargetProgressBar(0),
+    m_CurrentTargetIndex(0),
+    m_CurrentTargetReached(false),
+    m_ShowPlanningColors(false),
+    m_NeedleProjectionFilter(mitk::NeedleProjectionFilter::New()),
+    m_NodeDisplacementFilter(mitk::NodeDisplacementFilter::New()),
+    m_TargetUpdateFilter(mitk::USNavigationTargetUpdateFilter::New()),
+    m_TargetOcclusionFilter(mitk::USNavigationTargetOcclusionFilter::New()),
+    m_TargetIntersectionFilter(mitk::USNavigationTargetIntersectionFilter::New()),
+    m_PlacementQualityCalculator(mitk::USTargetPlacementQualityCalculator::New()),
+    m_ListenerTargetCoordinatesChanged(this, &QmitkUSNavigationStepMarkerIntervention::UpdateTargetCoordinates),
+    m_TargetStructureWarnOverlay(mitk::TextAnnotation2D::New()),
+    m_ReferenceSensorIndex(1),
+    m_NeedleSensorIndex(0),
+    ui(new Ui::QmitkUSNavigationStepMarkerIntervention)
 {
   m_ActiveTargetColor[0] = 1;
   m_ActiveTargetColor[1] = 1;
   m_ActiveTargetColor[2] = 0;
   m_InactiveTargetColor[0] = 1;
   m_InactiveTargetColor[1] = 1;
   m_InactiveTargetColor[2] = 0.5;
   m_ReachedTargetColor[0] = 0.6;
   m_ReachedTargetColor[1] = 1;
   m_ReachedTargetColor[2] = 0.6;
 
   ui->setupUi(this);
 
   connect(ui->freezeImageButton, SIGNAL(SignalFreezed(bool)), this, SLOT(OnFreeze(bool)));
   connect(ui->backToLastTargetButton, SIGNAL(clicked()), this, SLOT(OnBackToLastTargetClicked()));
   connect(ui->targetReachedButton, SIGNAL(clicked()), this, SLOT(OnTargetLeft()));
   connect(this, SIGNAL(TargetReached(int)), this, SLOT(OnTargetReached()));
   connect(this, SIGNAL(TargetLeft(int)), this, SLOT(OnTargetLeft()));
   connect(ui->riskStructuresRangeWidget,
-    SIGNAL(SignalZoneViolated(const mitk::DataNode *, mitk::Point3D)),
-    this,
-    SLOT(OnRiskZoneViolated(const mitk::DataNode *, mitk::Point3D)));
+          SIGNAL(SignalZoneViolated(const mitk::DataNode *, mitk::Point3D)),
+          this,
+          SLOT(OnRiskZoneViolated(const mitk::DataNode *, mitk::Point3D)));
 
   m_PointMarkInteractor = mitk::USPointMarkInteractor::New();
   m_PointMarkInteractor->CoordinatesChangedEvent.AddListener(m_ListenerTargetCoordinatesChanged);
 
   this->GenerateTargetColorLookupTable();
 
   m_TargetProgressBar = new QmitkZoneProgressBar(QString::fromStdString("Target: %1 mm"), 200, 0, this);
   m_TargetProgressBar->SetTextFormatInvalid("Target is not on Needle Path");
   ui->targetStructuresRangeLayout->addWidget(m_TargetProgressBar);
 
   m_TargetUpdateFilter->SetScalarArrayIdentifier("USNavigation::ReachedTargetScores");
 }
 
 QmitkUSNavigationStepMarkerIntervention::~QmitkUSNavigationStepMarkerIntervention()
 {
   mitk::DataStorage::Pointer dataStorage = this->GetDataStorage(false);
   if (dataStorage.IsNotNull())
   {
     // remove the node for the needle path
     mitk::DataNode::Pointer node =
       this->GetNamedDerivedNode("Needle Path", QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
     if (node.IsNotNull())
     {
       dataStorage->Remove(node);
     }
   }
 
   if (m_SegmentationNode.IsNotNull())
   {
     this->GetDataStorage()->Remove(m_SegmentationNode);
   }
   if (m_ForegroundModelPointsNode.IsNotNull())
   {
     this->GetDataStorage()->Remove(m_ForegroundModelPointsNode);
   }
 
   delete ui;
 
   m_PointMarkInteractor->CoordinatesChangedEvent.RemoveListener(m_ListenerTargetCoordinatesChanged);
 }
 
 bool QmitkUSNavigationStepMarkerIntervention::OnStartStep()
 {
   m_NeedleProjectionFilter->SelectInput(m_NeedleSensorIndex);
 
   // 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);
 
   // initialize warning overlay (and do not display it, yet)
   m_TargetStructureWarnOverlay->SetText("Warning: Needle is Inside the Target Structure.");
   m_TargetStructureWarnOverlay->SetVisibility(false);
 
   // set position and font size for the text overlay
   mitk::Point2D overlayPosition;
   overlayPosition.SetElement(0, 10.0f);
   overlayPosition.SetElement(1, 10.0f);
   m_TargetStructureWarnOverlay->SetPosition2D(overlayPosition);
   m_TargetStructureWarnOverlay->SetFontSize(18);
 
   // overlay should be red
   mitk::Color color;
   color[0] = 1;
   color[1] = 0;
   color[2] = 0;
   m_TargetStructureWarnOverlay->SetColor(color);
 
   mitk::ManualPlacementAnnotationRenderer::AddAnnotation(m_TargetStructureWarnOverlay.GetPointer(), "stdmulti.widget4");
 
   return true;
 }
 
 bool QmitkUSNavigationStepMarkerIntervention::OnStopStep()
 {
   mitk::DataStorage::Pointer dataStorage = this->GetDataStorage();
 
   // remove all reached nodes from the data storage
   for (QVector<itk::SmartPointer<mitk::DataNode>>::iterator it = m_ReachedTargetsNodes.begin();
-    it != m_ReachedTargetsNodes.end();
-    ++it)
+       it != m_ReachedTargetsNodes.end();
+       ++it)
   {
     dataStorage->Remove(*it);
   }
   m_ReachedTargetsNodes.clear();
   m_CurrentTargetIndex = 0;
 
   // reset button states
   ui->freezeImageButton->setEnabled(false);
   ui->backToLastTargetButton->setEnabled(false);
   ui->targetReachedButton->setEnabled(true);
 
   // make sure that it is unfreezed after stopping the step
   ui->freezeImageButton->Unfreeze();
 
   // remove base node for reached targets from the data storage
   mitk::DataNode::Pointer reachedTargetsNode = this->GetNamedDerivedNode(
     QmitkUSAbstractNavigationStep::DATANAME_BASENODE, USNavigationMarkerPlacement::DATANAME_REACHED_TARGETS);
   if (reachedTargetsNode.IsNotNull())
   {
     dataStorage->Remove(reachedTargetsNode);
   }
 
   return true;
 }
 
 bool QmitkUSNavigationStepMarkerIntervention::OnFinishStep()
 {
   return true;
 }
 
 bool QmitkUSNavigationStepMarkerIntervention::OnActivateStep()
 {
   this->ClearZones(); // clear risk zones before adding new ones
 
   // get target node from data storage and make sure that it contains data
   m_TargetNode = this->GetNamedDerivedNode(USNavigationMarkerPlacement::DATANAME_TARGETSURFACE,
-    USNavigationMarkerPlacement::DATANAME_TUMOUR);
+                                           USNavigationMarkerPlacement::DATANAME_TUMOUR);
   if (m_TargetNode.IsNull() || m_TargetNode->GetData() == 0)
   {
     mitkThrow() << "Target node (" << USNavigationMarkerPlacement::DATANAME_TARGETSURFACE << ") must not be null.";
   }
 
   // get target data and make sure that it is a surface
   m_TargetSurface = dynamic_cast<mitk::Surface *>(m_TargetNode->GetData());
   if (m_TargetSurface.IsNull())
   {
     mitkThrow() << "Target node (" << USNavigationMarkerPlacement::DATANAME_TARGETSURFACE
-      << ") data must be of type mitk::Surface";
+                << ") data must be of type mitk::Surface";
   }
 
   // delete progress bars for reinitializing them again afterwards
   if (m_PlannedTargetProgressBar)
   {
     ui->targetStructuresRangeLayout->removeWidget(m_PlannedTargetProgressBar);
     delete m_PlannedTargetProgressBar;
     m_PlannedTargetProgressBar = 0;
   }
 
   m_NodeDisplacementFilter->SelectInput(m_ReferenceSensorIndex);
 
   this->UpdateTargetProgressDisplay();
 
   mitk::DataNode::Pointer tumourNode = this->GetNamedDerivedNode(USNavigationMarkerPlacement::DATANAME_TUMOUR,
-    QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
+                                                                 QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
   if (tumourNode.IsNotNull())
   {
     // do not show tumour node during intervention (target surface is shown)
     tumourNode->SetBoolProperty("visible", false);
 
     // add tumour as a risk structure
     ui->riskStructuresRangeWidget->AddZone(tumourNode);
   }
 
   // set target structure for target update filter
   m_TargetUpdateFilter->SetTargetStructure(m_TargetNode);
   m_TargetOcclusionFilter->SetTargetStructure(m_TargetNode);
 
   // set lookup table of tumour node
   m_TargetNode->SetProperty("LookupTable", m_TargetColorLookupTableProperty);
 
   //
   mitk::DataNode::Pointer targetsBaseNode = this->GetNamedDerivedNode(USNavigationMarkerPlacement::DATANAME_TARGETS,
-    QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
+                                                                      QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
   mitk::DataStorage::SetOfObjects::ConstPointer plannedTargetNodes;
   if (targetsBaseNode.IsNotNull())
   {
     plannedTargetNodes = this->GetDataStorage()->GetDerivations(targetsBaseNode);
   }
   if (plannedTargetNodes.IsNotNull() && plannedTargetNodes->Size() > 0)
   {
     for (mitk::DataStorage::SetOfObjects::ConstIterator it = plannedTargetNodes->Begin();
-      it != plannedTargetNodes->End();
-      ++it)
+         it != plannedTargetNodes->End();
+         ++it)
     {
       m_PlannedTargetsNodes.push_back(it->Value());
     }
 
     m_PlannedTargetProgressBar = new QmitkZoneProgressBar(QString::fromStdString("Planned Target"), 200, 0);
     ui->targetStructuresRangeLayout->addWidget(m_PlannedTargetProgressBar);
   }
 
   // add progress bars for risk zone nodes
   mitk::DataNode::Pointer zonesBaseNode = this->GetNamedDerivedNode(USNavigationMarkerPlacement::DATANAME_ZONES,
-    QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
+                                                                    QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
   // only add progress bars if the base node for zones was created
   if (zonesBaseNode.IsNotNull())
   {
     mitk::DataStorage::SetOfObjects::ConstPointer zoneNodes = this->GetDataStorage()->GetDerivations(zonesBaseNode);
 
     for (mitk::DataStorage::SetOfObjects::ConstIterator it = zoneNodes->Begin(); it != zoneNodes->End(); ++it)
     {
       ui->riskStructuresRangeWidget->AddZone(it->Value());
     }
 
     m_TargetOcclusionFilter->SelectStartPositionInput(m_NeedleSensorIndex);
     m_TargetOcclusionFilter->SetObstacleStructures(zoneNodes);
   }
 
   return true;
 }
 
 bool QmitkUSNavigationStepMarkerIntervention::OnDeactivateStep()
 {
   ui->freezeImageButton->Unfreeze();
 
   return true;
 }
 
 void QmitkUSNavigationStepMarkerIntervention::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")
-      ("QmitkUSNavigationStepMarkerIntervention") << "Navigation Data Source of Combined Modality must not be null.";
+    ("QmitkUSNavigationStepMarkerIntervention") << "Navigation Data Source of Combined Modality must not be null.";
     mitkThrow() << "Navigation Data Source of Combined Modality must not be null.";
   }
 
   ui->riskStructuresRangeWidget->UpdateDistancesToNeedlePosition(navigationDataSource->GetOutput(m_NeedleSensorIndex));
   this->UpdateBodyMarkerStatus(navigationDataSource->GetOutput(m_ReferenceSensorIndex));
 
   this->UpdateTargetColors();
   this->UpdateTargetScore();
 
   this->UpdateTargetViolationStatus();
 }
 
 void QmitkUSNavigationStepMarkerIntervention::OnSettingsChanged(const itk::SmartPointer<mitk::DataNode> settingsNode)
 {
   if (settingsNode.IsNull())
   {
     return;
   }
 
   int numberOfTargets;
   if (settingsNode->GetIntProperty("settings.number-of-targets", numberOfTargets))
   {
     m_NumberOfTargets = numberOfTargets;
     m_TargetUpdateFilter->SetNumberOfTargets(numberOfTargets);
 
     m_PlacementQualityCalculator->SetOptimalAngle(m_TargetUpdateFilter->GetOptimalAngle());
   }
 
   std::string referenceSensorName;
   if (settingsNode->GetStringProperty("settings.reference-name-selected", referenceSensorName))
   {
     m_ReferenceSensorName = referenceSensorName;
   }
 
   std::string needleSensorName;
   if (settingsNode->GetStringProperty("settings.needle-name-selected", needleSensorName))
   {
     m_NeedleSensorName = needleSensorName;
   }
 
   this->UpdateSensorsNames();
 }
 
 QString QmitkUSNavigationStepMarkerIntervention::GetTitle()
 {
   return "Computer-assisted Intervention";
 }
 
 bool QmitkUSNavigationStepMarkerIntervention::GetIsRestartable()
 {
   return true;
 }
 
 QmitkUSAbstractNavigationStep::FilterVector QmitkUSNavigationStepMarkerIntervention::GetFilter()
 {
   FilterVector filter;
   filter.push_back(m_NeedleProjectionFilter.GetPointer());
   filter.push_back(m_NodeDisplacementFilter.GetPointer());
   filter.push_back(m_TargetOcclusionFilter.GetPointer());
   return filter;
 }
 
 void QmitkUSNavigationStepMarkerIntervention::OnSetCombinedModality()
 {
   mitk::USCombinedModality::Pointer combinedModality = this->GetCombinedModality(false);
   if (combinedModality.IsNotNull())
   {
     mitk::AffineTransform3D::Pointer calibration = combinedModality->GetCalibration();
     if (calibration.IsNotNull())
     {
       m_NeedleProjectionFilter->SetTargetPlane(calibration);
     }
   }
 
   ui->freezeImageButton->SetCombinedModality(combinedModality, m_ReferenceSensorIndex);
 
   this->UpdateSensorsNames();
 }
 
 void QmitkUSNavigationStepMarkerIntervention::OnTargetReached()
 {
   m_CurrentTargetReached = true;
 }
 
 void QmitkUSNavigationStepMarkerIntervention::OnTargetLeft()
 {
   m_CurrentTargetReached = false;
 
   m_CurrentTargetIndex++;
 
   if (m_CurrentTargetIndex >= 0 && static_cast<unsigned int>(m_CurrentTargetIndex) >= m_NumberOfTargets)
   {
     ui->targetReachedButton->setDisabled(true);
   }
 
   ui->backToLastTargetButton->setEnabled(true);
   ui->freezeImageButton->setEnabled(true);
 
   this->UpdateTargetProgressDisplay();
 
   if (m_ReachedTargetsNodes.size() < m_CurrentTargetIndex)
   {
     mitk::DataNode::Pointer node = mitk::DataNode::New();
     node->SetName(
       (QString("Target ") + QString("%1").arg(m_CurrentTargetIndex, 2, 10, QLatin1Char('0'))).toStdString());
     this->GetDataStorage()->Add(
       node,
       this->GetNamedDerivedNodeAndCreate(USNavigationMarkerPlacement::DATANAME_REACHED_TARGETS,
-      QmitkUSAbstractNavigationStep::DATANAME_BASENODE));
+                                         QmitkUSAbstractNavigationStep::DATANAME_BASENODE));
     m_ReachedTargetsNodes.push_back(node);
   }
 
   mitk::DataNode::Pointer node = m_ReachedTargetsNodes.at(m_CurrentTargetIndex - 1);
   mitk::Surface::Pointer zone = mitk::Surface::New();
 
   // create a vtk sphere with given radius
   vtkSphereSource *vtkData = vtkSphereSource::New();
   vtkData->SetRadius(5);
   vtkData->SetCenter(0, 0, 0);
   vtkData->Update();
   zone->SetVtkPolyData(vtkData->GetOutput());
   vtkData->Delete();
 
   // set vtk sphere and origin to data node
   node->SetData(zone);
   node->GetData()->GetGeometry()->SetOrigin(
     this->GetCombinedModality()->GetNavigationDataSource()->GetOutput(m_NeedleSensorIndex)->GetPosition());
   node->SetColor(0.2, 0.9, 0.2);
   this->UpdateTargetCoordinates(node);
 }
 
 void QmitkUSNavigationStepMarkerIntervention::OnBackToLastTargetClicked()
 {
   if (m_CurrentTargetIndex < 1)
   {
     MITK_WARN << "Cannot go back to last target as there is no last target.";
     return;
   }
 
   m_CurrentTargetIndex--;
 
   if (m_ReachedTargetsNodes.size() > m_CurrentTargetIndex)
   {
     this->GetDataStorage()->Remove(m_ReachedTargetsNodes.last());
     MITK_INFO("QmitkUSAbstractNavigationStep")
-      ("QmitkUSNavigationStepMarkerIntervention") << "Removed Target " << m_ReachedTargetsNodes.size();
+    ("QmitkUSNavigationStepMarkerIntervention") << "Removed Target " << m_ReachedTargetsNodes.size();
     m_ReachedTargetsNodes.pop_back();
   }
 
   if (m_CurrentTargetIndex == 0)
   {
     ui->backToLastTargetButton->setDisabled(true);
   }
   if (m_CurrentTargetIndex >= 0 && static_cast<unsigned int>(m_CurrentTargetIndex) < m_NumberOfTargets)
   {
     ui->targetReachedButton->setEnabled(true);
   }
 
   ui->freezeImageButton->setEnabled(false);
   ui->freezeImageButton->Unfreeze();
 
   this->UpdateTargetProgressDisplay();
 
   m_TargetUpdateFilter->RemovePositionOfTarget(m_CurrentTargetIndex);
 }
 
 void QmitkUSNavigationStepMarkerIntervention::OnFreeze(bool freezed)
 {
   if (freezed)
   {
     this->GetCombinedModality()->SetIsFreezed(true);
     // load state machine and event config for data interactor
     m_PointMarkInteractor->LoadStateMachine("USPointMarkInteractions.xml", us::ModuleRegistry::GetModule("MitkUS"));
     m_PointMarkInteractor->SetEventConfig("globalConfig.xml");
 
     if (m_CurrentTargetIndex < 1)
     {
       mitkThrow() << "Current target index has to be greater zero when freeze button is clicked.";
     }
 
     if (m_ReachedTargetsNodes.size() < m_CurrentTargetIndex)
     {
       mitk::DataNode::Pointer node = mitk::DataNode::New();
       node->SetName(
         (QString("Target ") + QString("%1").arg(m_CurrentTargetIndex, 2, 10, QLatin1Char('0'))).toStdString());
       this->GetDataStorage()->Add(
         node,
         this->GetNamedDerivedNodeAndCreate(USNavigationMarkerPlacement::DATANAME_REACHED_TARGETS,
-        QmitkUSAbstractNavigationStep::DATANAME_BASENODE));
+                                           QmitkUSAbstractNavigationStep::DATANAME_BASENODE));
       m_ReachedTargetsNodes.push_back(node);
     }
 
     m_PointMarkInteractor->SetDataNode(m_ReachedTargetsNodes.last());
   }
   else
   {
     m_PointMarkInteractor->SetDataNode(0);
     this->GetCombinedModality()->SetIsFreezed(false);
   }
 }
 
 void QmitkUSNavigationStepMarkerIntervention::OnShowPlanningView(bool show)
 {
   m_ShowPlanningColors = show;
 }
 
 void QmitkUSNavigationStepMarkerIntervention::OnRiskZoneViolated(const mitk::DataNode *node, mitk::Point3D position)
 {
   MITK_INFO << "Risk zone (" << node->GetName() << ") violated at position " << position << ".";
 }
 
 void QmitkUSNavigationStepMarkerIntervention::ClearZones()
 {
   ui->riskStructuresRangeWidget->ClearZones();
 
   // remove all reached target nodes from the data storage and clear the list
   mitk::DataStorage::Pointer dataStorage = this->GetDataStorage();
   for (QVector<mitk::DataNode::Pointer>::iterator it = m_ReachedTargetsNodes.begin(); it != m_ReachedTargetsNodes.end();
-    ++it)
+       ++it)
   {
     if (it->IsNotNull())
     {
       dataStorage->Remove(*it);
     }
   }
   m_ReachedTargetsNodes.clear();
 }
 
 void QmitkUSNavigationStepMarkerIntervention::UpdateTargetCoordinates(mitk::DataNode *dataNode)
 {
   m_NodeDisplacementFilter->ResetNodes();
   for (QVector<itk::SmartPointer<mitk::DataNode>>::iterator it = m_ReachedTargetsNodes.begin();
-    it != m_ReachedTargetsNodes.end();
-    ++it)
+       it != m_ReachedTargetsNodes.end();
+       ++it)
   {
     if (it->IsNotNull() && (*it)->GetData() != 0)
     {
       m_NodeDisplacementFilter->AddNode(*it);
     }
   }
 
   mitk::BaseData *baseData = dataNode->GetData();
   if (!baseData)
   {
     mitkThrow() << "Data of the data node must not be null.";
   }
 
   mitk::BaseGeometry::Pointer geometry = baseData->GetGeometry();
   if (geometry.IsNull())
   {
     mitkThrow() << "Geometry of the data node must not be null.";
   }
 
   m_TargetUpdateFilter->SetControlNode(m_CurrentTargetIndex - 1, dataNode);
 
   if (m_PlannedTargetsNodes.size() > m_CurrentTargetIndex - 1)
   {
     m_PlannedTargetsNodes.at(m_CurrentTargetIndex - 1)->SetVisibility(false);
   }
 
   MITK_INFO("QmitkUSAbstractNavigationStep")
-    ("QmitkUSNavigationStepMarkerIntervention") << "Target " << m_CurrentTargetIndex << " reached at position "
-    << geometry->GetOrigin();
+  ("QmitkUSNavigationStepMarkerIntervention") << "Target " << m_CurrentTargetIndex << " reached at position "
+                                              << geometry->GetOrigin();
 
   this->CalculateTargetPlacementQuality();
 }
 
 void QmitkUSNavigationStepMarkerIntervention::UpdateBodyMarkerStatus(mitk::NavigationData::Pointer bodyMarker)
 {
   if (bodyMarker.IsNull())
   {
     MITK_ERROR("QmitkUSAbstractNavigationStep")
-      ("QmitkUSNavigationStepMarkerIntervention")
+    ("QmitkUSNavigationStepMarkerIntervention")
       << "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->targetStructuresRangeGroupBox->setEnabled(valid);
   ui->riskStructuresRangeGroupBox->setEnabled(valid);
 }
 
 void QmitkUSNavigationStepMarkerIntervention::GenerateTargetColorLookupTable()
 {
   vtkSmartPointer<vtkLookupTable> lookupTable = vtkSmartPointer<vtkLookupTable>::New();
   lookupTable->SetHueRange(0.0, 0.33);
   lookupTable->SetSaturationRange(1.0, 1.0);
   lookupTable->SetValueRange(1.0, 1.0);
   lookupTable->SetTableRange(0.0, 1.0);
   lookupTable->Build();
 
   mitk::LookupTable::Pointer lut = mitk::LookupTable::New();
   lut->SetVtkLookupTable(lookupTable);
 
   m_TargetColorLookupTableProperty = mitk::LookupTableProperty::New(lut);
 }
 
 void QmitkUSNavigationStepMarkerIntervention::UpdateTargetColors()
 {
   if (m_TargetNode.IsNull())
   {
     return;
   }
 
   m_TargetNode->SetColor(1, 1, 1);
 
   mitk::BaseData *targetNodeData = m_TargetNode->GetData();
   if (targetNodeData == 0)
   {
     return;
   }
 
   mitk::Surface::Pointer targetNodeSurface = dynamic_cast<mitk::Surface *>(targetNodeData);
   vtkSmartPointer<vtkPolyData> targetNodeSurfaceVtk = targetNodeSurface->GetVtkPolyData();
 
   vtkPointData *targetPointData = targetNodeSurface->GetVtkPolyData()->GetPointData();
 
   vtkFloatArray *scalars = dynamic_cast<vtkFloatArray *>(targetPointData->GetScalars("USNavigation::Occlusion"));
   vtkFloatArray *targetScoreScalars;
 
   if (m_ShowPlanningColors)
   {
     targetScoreScalars = dynamic_cast<vtkFloatArray *>(targetPointData->GetScalars("USNavigation::PlanningScalars"));
   }
   else
   {
     targetScoreScalars =
       dynamic_cast<vtkFloatArray *>(targetPointData->GetScalars("USNavigation::ReachedTargetScores"));
   }
 
   if (!scalars || !targetScoreScalars)
   {
     return;
   }
 
   unsigned int numberOfTupels = scalars->GetNumberOfTuples();
 
   vtkSmartPointer<vtkFloatArray> colors = vtkSmartPointer<vtkFloatArray>::New();
   colors->SetNumberOfComponents(1);
   colors->SetNumberOfTuples(numberOfTupels);
   colors->SetName("Colors");
 
   double color, intersection, markerScore;
 
   for (unsigned int n = 0; n < numberOfTupels; n++)
   {
     scalars->GetTuple(n, &intersection);
     targetScoreScalars->GetTuple(n, &markerScore);
 
     if (intersection > 0)
     {
       color = 0;
     }
     else
     {
       color = markerScore;
     }
 
     colors->SetTuple(n, &color);
   }
 
   if (numberOfTupels > 0)
   {
     targetNodeSurfaceVtk->GetPointData()->SetScalars(colors);
     targetNodeSurfaceVtk->GetPointData()->Update();
   }
 }
 
 void QmitkUSNavigationStepMarkerIntervention::UpdateTargetScore()
 {
   if (m_NeedleProjectionFilter->GetProjection()->GetSize() != 2)
   {
     return;
   }
 
   vtkSmartPointer<vtkPolyData> targetSurfaceVtk = m_TargetSurface->GetVtkPolyData();
 
   m_TargetIntersectionFilter->SetTargetSurface(m_TargetSurface);
   m_TargetIntersectionFilter->SetLine(m_NeedleProjectionFilter->GetProjection());
 
   m_TargetIntersectionFilter->CalculateIntersection();
 
   if (m_TargetIntersectionFilter->GetIsIntersecting())
   {
     vtkFloatArray *scalars =
       dynamic_cast<vtkFloatArray *>(targetSurfaceVtk->GetPointData()->GetScalars("USNavigation::ReachedTargetScores"));
     double score;
     scalars->GetTuple(m_TargetIntersectionFilter->GetIntersectionNearestSurfacePointId(), &score);
 
     double color[3];
     m_TargetColorLookupTableProperty->GetLookupTable()->GetVtkLookupTable()->GetColor(score, color);
 
     float colorF[3];
     colorF[0] = color[0];
     colorF[1] = color[1];
     colorF[2] = color[2];
     m_TargetProgressBar->SetColor(colorF);
     m_TargetProgressBar->SetBorderColor(colorF);
     m_TargetProgressBar->setValue(m_TargetIntersectionFilter->GetDistanceToIntersection());
 
     if (m_PlannedTargetProgressBar)
     {
       vtkFloatArray *scalars =
         dynamic_cast<vtkFloatArray *>(targetSurfaceVtk->GetPointData()->GetScalars("USNavigation::PlanningScalars"));
       if (scalars)
       {
         double score;
         scalars->GetTuple(m_TargetIntersectionFilter->GetIntersectionNearestSurfacePointId(), &score);
 
         double color[3];
         m_TargetColorLookupTableProperty->GetLookupTable()->GetVtkLookupTable()->GetColor(score, color);
 
         float colorF[3];
         colorF[0] = color[0];
         colorF[1] = color[1];
         colorF[2] = color[2];
         m_PlannedTargetProgressBar->SetColor(colorF);
         m_PlannedTargetProgressBar->SetBorderColor(colorF);
         m_PlannedTargetProgressBar->SetTextFormatValid("Planned Target: %1 mm");
 
         mitk::Point3D intersectionPoint = m_TargetIntersectionFilter->GetIntersectionPoint();
 
         mitk::ScalarType minDistance = -1;
         for (QVector<itk::SmartPointer<mitk::DataNode>>::iterator it = m_PlannedTargetsNodes.begin();
-          it != m_PlannedTargetsNodes.end();
-          ++it)
+             it != m_PlannedTargetsNodes.end();
+             ++it)
         {
           mitk::ScalarType distance =
             intersectionPoint.EuclideanDistanceTo((*it)->GetData()->GetGeometry()->GetOrigin());
           if (minDistance < 0 || distance < minDistance)
           {
             minDistance = distance;
           }
         }
 
         m_PlannedTargetProgressBar->setValue(minDistance);
       }
     }
   }
   else
   {
     m_TargetProgressBar->setValueInvalid();
   }
 }
 
 void QmitkUSNavigationStepMarkerIntervention::UpdateTargetProgressDisplay()
 {
   QString description;
   if (m_CurrentTargetIndex >= m_NumberOfTargets)
   {
     description = "All Targets Reached";
     if (m_TargetProgressBar)
     {
       m_TargetProgressBar->hide();
     }
   }
   else
   {
     description = QString("Distance to Target ") + QString::number(m_CurrentTargetIndex + 1) + QString(" of ") +
-      QString::number(m_NumberOfTargets);
+                  QString::number(m_NumberOfTargets);
     if (m_TargetProgressBar)
     {
       m_TargetProgressBar->show();
     }
   }
 
   ui->targetStructuresRangeGroupBox->setTitle(description);
 }
 
 void QmitkUSNavigationStepMarkerIntervention::UpdatePlannedTargetProgressDisplay()
 {
   // make sure that the needle projection consists of two points
   if (m_NeedleProjectionFilter->GetProjection()->GetSize() != 2)
   {
     return;
   }
 
   vtkSmartPointer<vtkPolyData> targetSurfaceVtk = m_TargetSurface->GetVtkPolyData();
 
   m_TargetIntersectionFilter->SetTargetSurface(m_TargetSurface);
   m_TargetIntersectionFilter->SetLine(m_NeedleProjectionFilter->GetProjection());
 
   m_TargetIntersectionFilter->CalculateIntersection();
 
   // update target progress bar according to the color of the intersection
   // point on the target surface and the distance to the intersection
   if (m_TargetIntersectionFilter->GetIsIntersecting())
   {
     vtkFloatArray *scalars = dynamic_cast<vtkFloatArray *>(targetSurfaceVtk->GetPointData()->GetScalars("Colors"));
     double score;
     scalars->GetTuple(m_TargetIntersectionFilter->GetIntersectionNearestSurfacePointId(), &score);
 
     double color[3];
     m_TargetColorLookupTableProperty->GetLookupTable()->GetVtkLookupTable()->GetColor(score, color);
 
     float colorF[3];
     colorF[0] = color[0];
     colorF[1] = color[1];
     colorF[2] = color[2];
     m_TargetProgressBar->SetColor(colorF);
     m_TargetProgressBar->SetBorderColor(colorF);
     m_TargetProgressBar->setValue(m_TargetIntersectionFilter->GetDistanceToIntersection());
   }
   else
   {
-    float red[3] = { 0.6, 0, 0 };
+    float red[3] = {0.6, 0, 0};
     m_TargetProgressBar->SetBorderColor(red);
     m_TargetProgressBar->setValueInvalid();
   }
 }
 
 void QmitkUSNavigationStepMarkerIntervention::UpdateTargetViolationStatus()
 {
   // transform vtk polydata according to mitk geometry
   vtkSmartPointer<vtkTransformPolyDataFilter> transformFilter = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
   transformFilter->SetInputData(0, m_TargetSurface->GetVtkPolyData());
   transformFilter->SetTransform(m_TargetSurface->GetGeometry()->GetVtkTransform());
   transformFilter->Update();
 
   vtkSmartPointer<vtkSelectEnclosedPoints> enclosedPoints = vtkSmartPointer<vtkSelectEnclosedPoints>::New();
   enclosedPoints->Initialize(transformFilter->GetOutput());
 
   mitk::Point3D needleTip = m_NeedleProjectionFilter->GetProjection()->GetPoint(0);
 
   // show warning if the needle tip is inside the target surface
   if (enclosedPoints->IsInsideSurface(needleTip[0], needleTip[1], needleTip[2]))
   {
-    if (!m_TargetStructureWarnOverlay->IsVisible())
+    if (!m_TargetStructureWarnOverlay->IsVisible(NULL))
     {
       m_TargetStructureWarnOverlay->SetVisibility(true);
 
       mitk::DataNode::Pointer targetViolationResult = mitk::DataNode::New();
       targetViolationResult->SetName("TargetViolation");
       targetViolationResult->SetProperty("USNavigation::TargetViolationPoint", mitk::Point3dProperty::New(needleTip));
 
       emit SignalIntermediateResult(targetViolationResult);
     }
 
     MITK_INFO("QmitkUSAbstractNavigationStep")
-      ("QmitkUSNavigationStepMarkerIntervention") << "Target surface violated at " << needleTip << ".";
+    ("QmitkUSNavigationStepMarkerIntervention") << "Target surface violated at " << needleTip << ".";
   }
   else
   {
     m_TargetStructureWarnOverlay->SetVisibility(false);
   }
 }
 
 void QmitkUSNavigationStepMarkerIntervention::CalculateTargetPlacementQuality()
 {
   // clear quality display if there aren't all targets reached
   if (m_ReachedTargetsNodes.size() != m_NumberOfTargets)
   {
     ui->placementQualityGroupBox->setEnabled(false);
     ui->angleDifferenceValue->setText("");
     ui->centersOfMassValue->setText("");
     return;
   }
 
   ui->placementQualityGroupBox->setEnabled(true);
 
   mitk::Surface::Pointer targetSurface = dynamic_cast<mitk::Surface *>(m_TargetNode->GetData());
   if (targetSurface.IsNull())
   {
     mitkThrow() << "Target surface must not be null.";
   }
 
   m_PlacementQualityCalculator->SetTargetSurface(targetSurface);
   mitk::PointSet::Pointer targetPointSet = mitk::PointSet::New();
 
   // copy the origins of all reached target nodes into a point set
   // for the quality calculator
   mitk::PointSet::PointIdentifier n = 0;
   for (QVector<itk::SmartPointer<mitk::DataNode>>::iterator it = m_ReachedTargetsNodes.begin();
-    it != m_ReachedTargetsNodes.end();
-    ++it)
+       it != m_ReachedTargetsNodes.end();
+       ++it)
   {
     targetPointSet->InsertPoint(n++, (*it)->GetData()->GetGeometry()->GetOrigin());
   }
   m_PlacementQualityCalculator->SetTargetPoints(targetPointSet);
 
   m_PlacementQualityCalculator->Update();
 
   double centersOfMassDistance = m_PlacementQualityCalculator->GetCentersOfMassDistance();
   ui->centersOfMassValue->setText(QString::number(centersOfMassDistance, 103, 2) + " mm");
 
   double meanAnglesDifference = m_PlacementQualityCalculator->GetMeanAngleDifference();
   ui->angleDifferenceValue->setText(QString::number(meanAnglesDifference, 103, 2) + QString::fromLatin1(" °"));
 
   // create an intermediate result of the placement quality
   mitk::DataNode::Pointer placementQualityResult = mitk::DataNode::New();
   placementQualityResult->SetName("PlacementQuality");
   placementQualityResult->SetFloatProperty("USNavigation::CentersOfMassDistance", centersOfMassDistance);
   placementQualityResult->SetFloatProperty("USNavigation::MeanAngleDifference", meanAnglesDifference);
   placementQualityResult->SetProperty(
     "USNavigation::AngleDifferences",
     mitk::GenericProperty<mitk::VnlVector>::New(m_PlacementQualityCalculator->GetAngleDifferences()));
 
   if (m_PlannedTargetsNodes.size() == m_NumberOfTargets)
   {
     mitk::VnlVector reachedPlannedDifferences;
     double reachedPlannedDifferencesSum = 0;
     double reachedPlannedDifferencesMax = 0;
     reachedPlannedDifferences.set_size(m_NumberOfTargets);
 
     // get sum and maximum of the planning / reality differences
     for (unsigned int n = 0; n < m_NumberOfTargets; ++n)
     {
       mitk::ScalarType distance =
         m_PlannedTargetsNodes.at(n)->GetData()->GetGeometry()->GetOrigin().EuclideanDistanceTo(
-        m_ReachedTargetsNodes.at(n)->GetData()->GetGeometry()->GetOrigin());
+          m_ReachedTargetsNodes.at(n)->GetData()->GetGeometry()->GetOrigin());
 
       reachedPlannedDifferences.put(n, distance);
       reachedPlannedDifferencesSum += distance;
 
       if (distance > reachedPlannedDifferencesMax)
       {
         reachedPlannedDifferencesMax = distance;
       }
     }
 
     // add distances between planning and reality to the quality intermediate result
     placementQualityResult->SetProperty("USNavigation::PlanningRealityDistances",
-      mitk::GenericProperty<mitk::VnlVector>::New(reachedPlannedDifferences));
+                                        mitk::GenericProperty<mitk::VnlVector>::New(reachedPlannedDifferences));
     placementQualityResult->SetProperty(
       "USNavigation::MeanPlanningRealityDistance",
       mitk::DoubleProperty::New(reachedPlannedDifferencesSum / static_cast<double>(m_NumberOfTargets)));
     placementQualityResult->SetProperty("USNavigation::MaximumPlanningRealityDistance",
-      mitk::DoubleProperty::New(reachedPlannedDifferencesMax));
+                                        mitk::DoubleProperty::New(reachedPlannedDifferencesMax));
   }
 
   emit SignalIntermediateResult(placementQualityResult);
 }
 
 void QmitkUSNavigationStepMarkerIntervention::UpdateSensorsNames()
 {
   mitk::USCombinedModality::Pointer combinedModality = this->GetCombinedModality(false);
   if (combinedModality.IsNull())
   {
     return;
   }
 
   mitk::NavigationDataSource::Pointer navigationDataSource = combinedModality->GetNavigationDataSource();
   if (navigationDataSource.IsNull())
   {
     return;
   }
 
   if (!m_NeedleSensorName.empty())
   {
     try
     {
       m_NeedleSensorIndex = navigationDataSource->GetOutputIndex(m_NeedleSensorName);
     }
     catch (const std::exception &e)
     {
       MITK_WARN("QmitkUSAbstractNavigationStep")
-        ("QmitkUSNavigationStepPlacementPlanning") << "Cannot get index for needle sensor name: " << e.what();
+      ("QmitkUSNavigationStepPlacementPlanning") << "Cannot get index for needle sensor name: " << e.what();
     }
   }
   if (this->GetNavigationStepState() >= QmitkUSAbstractNavigationStep::State_Active)
   {
     m_NeedleProjectionFilter->SelectInput(m_NeedleSensorIndex);
   }
 
   if (!m_ReferenceSensorName.empty())
   {
     try
     {
       m_ReferenceSensorIndex = navigationDataSource->GetOutputIndex(m_ReferenceSensorName);
     }
     catch (const std::exception &e)
     {
       MITK_WARN("QmitkUSAbstractNavigationStep")
-        ("QmitkUSNavigationStepPlacementPlanning") << "Cannot get index for reference sensor name: " << e.what();
+      ("QmitkUSNavigationStepPlacementPlanning") << "Cannot get index for reference sensor name: " << e.what();
     }
   }
   if (this->GetNavigationStepState() >= QmitkUSAbstractNavigationStep::State_Active)
   {
     m_NodeDisplacementFilter->SelectInput(m_ReferenceSensorIndex);
   }
 
   ui->freezeImageButton->SetCombinedModality(combinedModality, m_ReferenceSensorIndex);
 }
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 8e8f75c857..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,266 +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->setEnabled(true);
+    ui->m_AblationZonesBox->setVisible(true);
   else
-    ui->m_AblationZonesBox->setEnabled(false);
+    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/NavigationStepWidgets/QmitkUSNavigationStepPunctuationIntervention.ui b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPunctuationIntervention.ui
index 110fb6de85..a3b454f70a 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPunctuationIntervention.ui
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepPunctuationIntervention.ui
@@ -1,222 +1,222 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkUSNavigationStepPunctuationIntervention</class>
  <widget class="QWidget" name="QmitkUSNavigationStepPunctuationIntervention">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>317</width>
-    <height>337</height>
+    <height>393</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Form</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout_4">
    <item>
     <widget class="QLabel" name="bodyMarkerTrackingStatusLabel">
      <property name="styleSheet">
       <string notr="true">
               background-color: #ff7878; margin-right: 1em; margin-left: 1em;
               border: 1px solid grey
             </string>
      </property>
      <property name="text">
       <string>Body marker is not inside the tracking volume.</string>
      </property>
      <property name="alignment">
       <set>Qt::AlignCenter</set>
      </property>
      <property name="wordWrap">
       <bool>true</bool>
      </property>
     </widget>
    </item>
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout">
      <item>
       <widget class="QLabel" name="label">
        <property name="text">
         <string>Distance Needle to US plane:</string>
        </property>
        <property name="alignment">
         <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QLabel" name="m_DistanceToUSPlane">
        <property name="text">
         <string>&lt;not available&gt;</string>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item>
     <widget class="QGroupBox" name="riskStructuresRangeGroupBox">
      <property name="title">
       <string>Distances to Critical Structures</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_5">
       <item>
        <widget class="QmitkUSNavigationZoneDistancesWidget" name="riskStructuresRangeWidget" native="true"/>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QCheckBox" name="m_EnableAblationMarking">
      <property name="text">
       <string>Enable Manual Ablation Zone Marking</string>
      </property>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="m_AblationZonesBox">
      <property name="enabled">
-      <bool>false</bool>
+      <bool>true</bool>
      </property>
      <property name="title">
       <string>Ablation Zones</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_3">
       <item>
        <widget class="QListWidget" name="m_AblationZonesList"/>
       </item>
       <item>
        <layout class="QHBoxLayout" name="horizontalLayout_3">
         <item>
          <layout class="QVBoxLayout" name="verticalLayout_2">
           <item>
            <widget class="QLabel" name="label_3">
             <property name="text">
              <string>Size:</string>
             </property>
            </widget>
           </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>
         </item>
         <item>
          <layout class="QVBoxLayout" name="verticalLayout">
           <item>
            <widget class="QSlider" name="m_AblationZoneSizeSlider">
             <property name="maximum">
              <number>100</number>
             </property>
             <property name="value">
              <number>10</number>
             </property>
             <property name="orientation">
              <enum>Qt::Horizontal</enum>
             </property>
             <property name="tickPosition">
              <enum>QSlider::TicksBelow</enum>
             </property>
             <property name="tickInterval">
              <number>10</number>
             </property>
            </widget>
           </item>
           <item>
            <layout class="QHBoxLayout" name="horizontalLayout_2">
             <item>
              <widget class="QLabel" name="label_4">
               <property name="text">
                <string>0 cm</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>
             <item>
              <widget class="QLabel" name="label_5">
               <property name="text">
                <string>10 cm</string>
               </property>
              </widget>
             </item>
            </layout>
           </item>
          </layout>
         </item>
        </layout>
       </item>
       <item>
        <layout class="QHBoxLayout" name="horizontalLayout_4">
         <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_AddNewAblationZone">
           <property name="text">
            <string>Add New Ablation Zone</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>
  <customwidgets>
   <customwidget>
    <class>QmitkUSNavigationZoneDistancesWidget</class>
    <extends>QWidget</extends>
    <header>src/internal/Widgets/QmitkUSNavigationZoneDistancesWidget.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepZoneMarking.cpp b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepZoneMarking.cpp
index 1bbdb96558..b1380808ff 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepZoneMarking.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepZoneMarking.cpp
@@ -1,260 +1,269 @@
 /*===================================================================
 
 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 "QmitkUSNavigationStepZoneMarking.h"
 #include "ui_QmitkUSNavigationStepZoneMarking.h"
 
 #include "mitkNodeDisplacementFilter.h"
 
 #include "../USNavigationMarkerPlacement.h"
 
 QmitkUSNavigationStepZoneMarking::QmitkUSNavigationStepZoneMarking(QWidget *parent) :
   QmitkUSAbstractNavigationStep(parent),
   m_ZoneDisplacementFilter(mitk::NodeDisplacementFilter::New()),
   m_ReferenceSensorIndex(1),
   m_CurrentlyAddingZone(false),
   ui(new Ui::QmitkUSNavigationStepZoneMarking)
 {
   ui->setupUi(this);
 
   connect( ui->freezeButton, SIGNAL(SignalFreezed(bool)), this, SLOT(OnFreeze(bool)) );
   connect( ui->zonesWidget, SIGNAL(ZoneAdded()), this, SLOT(OnZoneAdded()) );
   connect( ui->zonesWidget, SIGNAL(ZoneRemoved()), this, SLOT(OnZoneRemoved()) );
+  connect(ui->showStructureList, SIGNAL(stateChanged(int)), this, SLOT(OnShowListClicked(int)));
+  ui->zonesLabel->setVisible(false);
+  ui->zonesWidget->setVisible(false);
+}
+
+void QmitkUSNavigationStepZoneMarking::OnShowListClicked(int state)
+{
+  ui->zonesLabel->setVisible(state);
+  ui->zonesWidget->setVisible(state);
 }
 
 QmitkUSNavigationStepZoneMarking::~QmitkUSNavigationStepZoneMarking()
 {
   delete ui;
 }
 
 bool QmitkUSNavigationStepZoneMarking::OnStartStep()
 {
   this->GetNamedDerivedNodeAndCreate(USNavigationMarkerPlacement::DATANAME_ZONES,
                                      QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
 
   ui->zonesWidget->SetDataStorage(this->GetDataStorage(), USNavigationMarkerPlacement::DATANAME_ZONES);
 
   return true;
 }
 
 bool QmitkUSNavigationStepZoneMarking::OnStopStep()
 {
   m_ZoneDisplacementFilter->ResetNodes();
   ui->zonesWidget->OnResetZones();
   m_ZoneNodes.clear();
 
   // remove zone nodes from the data storage
   mitk::DataStorage::Pointer dataStorage = this->GetDataStorage(false);
   if ( dataStorage.IsNotNull() )
   {
     mitk::DataNode::Pointer baseNode = dataStorage->GetNamedNode(QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
     if ( baseNode.IsNotNull() )
     {
       dataStorage->Remove(dataStorage->GetNamedDerivedNode(USNavigationMarkerPlacement::DATANAME_ZONES, baseNode));
     }
   }
 
   return true;
 }
 
 bool QmitkUSNavigationStepZoneMarking::OnFinishStep()
 {
   return true;
 }
 
 bool QmitkUSNavigationStepZoneMarking::OnActivateStep()
 {
   m_ZoneDisplacementFilter->SelectInput(m_ReferenceSensorIndex);
 
   emit SignalReadyForNextStep();
 
   return true;
 }
 
 bool QmitkUSNavigationStepZoneMarking::OnDeactivateStep()
 {
   ui->freezeButton->Unfreeze();
 
   return true;
 }
 
 void QmitkUSNavigationStepZoneMarking::OnUpdate()
 {
   if (m_NavigationDataSource.IsNull()) { return; }
 
   m_NavigationDataSource->Update();
 
   bool valid = m_NavigationDataSource->GetOutput(m_ReferenceSensorIndex)->IsDataValid();
 
   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->freezeButton->setEnabled(valid);
 }
 
 void QmitkUSNavigationStepZoneMarking::OnSettingsChanged(const itk::SmartPointer<mitk::DataNode> settingsNode)
 {
   if ( settingsNode.IsNull() ) { return; }
 
   std::string stateMachineFilename;
   if ( settingsNode->GetStringProperty("settings.interaction-concept", stateMachineFilename) && stateMachineFilename != m_StateMachineFilename )
   {
     m_StateMachineFilename = stateMachineFilename;
     ui->zonesWidget->SetStateMachineFilename(stateMachineFilename);
   }
 
   std::string referenceSensorName;
   if ( settingsNode->GetStringProperty("settings.reference-name-selected", referenceSensorName) )
   {
     m_ReferenceSensorName = referenceSensorName;
   }
 
   this->UpdateReferenceSensorName();
 }
 
 QString QmitkUSNavigationStepZoneMarking::GetTitle()
 {
   return "Critical Structures";
 }
 
 QmitkUSAbstractNavigationStep::FilterVector QmitkUSNavigationStepZoneMarking::GetFilter()
 {
   return FilterVector(1, m_ZoneDisplacementFilter.GetPointer());
 }
 
 void QmitkUSNavigationStepZoneMarking::OnFreeze(bool freezed)
 {
   if (freezed) this->GetCombinedModality()->SetIsFreezed(true);
 
   ui->zoneAddingExplanationLabel->setEnabled(freezed);
 
   if ( freezed )
   {
     m_CurrentlyAddingZone = true;
     ui->zonesWidget->OnStartAddingZone();
     // feed reference pose to node displacement filter
       m_ZoneDisplacementFilter->SetInitialReferencePose(this->GetCombinedModality()->GetNavigationDataSource()->GetOutput(m_ReferenceSensorIndex)->Clone());
   }
   else if ( m_CurrentlyAddingZone )
   {
     m_CurrentlyAddingZone = false;
     ui->zonesWidget->OnAbortAddingZone();
   }
 
   if (!freezed) this->GetCombinedModality()->SetIsFreezed(false);
 }
 
 void QmitkUSNavigationStepZoneMarking::OnZoneAdded()
 {
   m_CurrentlyAddingZone = false;
 
   ui->freezeButton->Unfreeze();
 
   ui->zoneAddingExplanationLabel->setEnabled(ui->freezeButton->isChecked());
 
   mitk::DataStorage::SetOfObjects::ConstPointer zoneNodesSet = ui->zonesWidget->GetZoneNodes();
   for (mitk::DataStorage::SetOfObjects::ConstIterator it = zoneNodesSet->Begin();
        it != zoneNodesSet->End(); ++it)
   {
     // add all zones to zone filter which aren't added until now
     if ( std::find(m_ZoneNodes.begin(), m_ZoneNodes.end(), it->Value()) == m_ZoneNodes.end() )
     {
       // logging center point and radius
       float radius = -1;
       it->Value()->GetFloatProperty("zone.size", radius);
       MITK_INFO("QmitkUSNavigationStepZoneMarking")("QmitkUSAbstractNavigationStep")
         << "Risk zone (" << it->Value()->GetName() << ") added with center "
         << it->Value()->GetData()->GetGeometry()->GetOrigin() << " and radius " << radius << ".";
 
       m_ZoneNodes.push_back(it->Value());
       m_ZoneDisplacementFilter->AddNode(it->Value());
     }
   }
 }
 
 void QmitkUSNavigationStepZoneMarking::OnZoneRemoved()
 {
   mitk::DataStorage::SetOfObjects::ConstPointer zoneNodesSet = ui->zonesWidget->GetZoneNodes();
 
   for ( int n = m_ZoneNodes.size() - 1; n >= 0; --n )
   {
     bool found = false;
 
     // test if the node can be found in the set of zone nodes
     for (mitk::DataStorage::SetOfObjects::ConstIterator itSet = zoneNodesSet->Begin();
        itSet != zoneNodesSet->End(); ++itSet)
     {
       if ( m_ZoneNodes.at(n) == itSet->Value() ) { found = true; break; }
     }
 
     if ( ! found )
     {
       MITK_INFO("QmitkUSNavigationStepZoneMarking")("QmitkUSAbstractNavigationStep")
         << "Risk zone (" << m_ZoneNodes.at(n)->GetName() << ") removed.";
 
       m_ZoneNodes.erase(m_ZoneNodes.begin()+n);
       m_ZoneDisplacementFilter->RemoveNode(n);
     }
   }
 }
 
 void QmitkUSNavigationStepZoneMarking::OnSetCombinedModality()
 {
   mitk::USCombinedModality::Pointer combinedModality = this->GetCombinedModality(false);
   if (combinedModality.IsNotNull())
   {
     m_NavigationDataSource = combinedModality->GetNavigationDataSource();
   }
 
   ui->freezeButton->SetCombinedModality(combinedModality, m_ReferenceSensorIndex);
 
   this->UpdateReferenceSensorName();
 }
 
 void QmitkUSNavigationStepZoneMarking::UpdateReferenceSensorName()
 {
   if ( m_NavigationDataSource.IsNull() ) { return; }
 
   if ( ! m_ReferenceSensorName.empty() )
   {
     try
     {
       m_ReferenceSensorIndex = m_NavigationDataSource->GetOutputIndex(m_ReferenceSensorName);
     }
     catch ( const std::exception &e )
     {
       MITK_WARN("QmitkUSAbstractNavigationStep")("QmitkUSNavigationStepZoneMarking")
         << "Cannot get index for reference sensor name: " << e.what();
     }
   }
 
   if ( this->GetNavigationStepState() >= QmitkUSAbstractNavigationStep::State_Active )
   {
     m_ZoneDisplacementFilter->SelectInput(m_ReferenceSensorIndex);
   }
 
   ui->freezeButton->SetCombinedModality(this->GetCombinedModality(false), m_ReferenceSensorIndex);
 }
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepZoneMarking.h b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepZoneMarking.h
index 46eb1eb34b..6bdf3ded4e 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepZoneMarking.h
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepZoneMarking.h
@@ -1,132 +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.
 
 ===================================================================*/
 
 #ifndef QMITKUSNAVIGATIONSTEPZONEMARKING_H
 #define QMITKUSNAVIGATIONSTEPZONEMARKING_H
 
 #include "QmitkUSAbstractNavigationStep.h"
 
 namespace itk {
 template<class T> class SmartPointer;
 }
 
 namespace mitk {
 class NodeDisplacementFilter;
 class NavigationDataSource;
 }
 
 namespace Ui {
 class QmitkUSNavigationStepZoneMarking;
 }
 
 /**
  * \brief Navigation step for marking risk structures.
  * The user can add risk structures by interacting with the render windows. The
  * risk structures are organized in an embedded table view.
  *
  * The risk structures are stored under DATANAME_BASENODE -> DATANAME_ZONES.
  *
  * This step is ready for the next step directly after activating. All actions
  * to be done in this step are optional.
  */
 class QmitkUSNavigationStepZoneMarking : public QmitkUSAbstractNavigationStep
 {
   Q_OBJECT
 
 protected slots:
   void OnFreeze(bool freezed);
 
   /**
    * \brief Triggered when a risk zone was added.
    * Adds the zone to a member variable and to the node displacement filter.
    */
   void OnZoneAdded();
 
   /**
    * \brief Triggered when a risk zone was removed.
    * Removes the zone from a member variable and from the node displacement
    * filter.
    */
   void OnZoneRemoved();
 
+  void OnShowListClicked(int state);
+
 public:
   explicit QmitkUSNavigationStepZoneMarking(QWidget *parent = 0);
   ~QmitkUSNavigationStepZoneMarking();
 
   /**
    * \brief Initialization of the data storage nodes.
    * \return always true
    */
   virtual bool OnStartStep();
 
   /**
    * \brief Resets widget and filter and removes nodes from the data storage.
    * \return always true
    */
   virtual bool OnStopStep();
 
   /**
    * \brief There is nothing to be done.
    * \return always true
    */
   virtual bool OnFinishStep();
 
   /**
    * \brief Selects input for the node displacement filter and emits "ReadyForNextStep" signal.
    * The input selection cannot be done earlier.
    * \return
    */
   virtual bool OnActivateStep();
 
   virtual bool OnDeactivateStep();
 
   /**
    * \brief Updates just the tracking validity status.
    */
   virtual void OnUpdate();
 
   /**
    * The property "settings.interaction-concept" is used.
    */
   virtual void OnSettingsChanged(const itk::SmartPointer<mitk::DataNode> settingsNode);
 
   virtual QString GetTitle();
 
   /**
    * @return a node displacement filter for the zone surfaces
    */
   virtual FilterVector GetFilter();
 
 protected:
   virtual void OnSetCombinedModality();
 
   void UpdateReferenceSensorName();
 
   itk::SmartPointer<mitk::NavigationDataSource>   m_NavigationDataSource;
   itk::SmartPointer<mitk::NodeDisplacementFilter> m_ZoneDisplacementFilter;
   std::vector<itk::SmartPointer<mitk::DataNode> > m_ZoneNodes;
 
   std::string                                     m_StateMachineFilename;
   std::string                                     m_ReferenceSensorName;
   unsigned int                                    m_ReferenceSensorIndex;
 
   bool                                            m_CurrentlyAddingZone;
 
 private:
   Ui::QmitkUSNavigationStepZoneMarking *ui;
 };
 
 #endif // QMITKUSNAVIGATIONSTEPZONEMARKING_H
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepZoneMarking.ui b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepZoneMarking.ui
index 8606d16885..d510c7a755 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepZoneMarking.ui
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepZoneMarking.ui
@@ -1,127 +1,147 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkUSNavigationStepZoneMarking</class>
  <widget class="QWidget" name="QmitkUSNavigationStepZoneMarking">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>400</width>
     <height>395</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Form</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
     <widget class="QLabel" name="bodyMarkerTrackingStatusLabel">
      <property name="styleSheet">
       <string notr="true">
               background-color: #ff7878; margin-right: 1em; margin-left: 1em;
               border: 1px solid grey
             </string>
      </property>
      <property name="text">
       <string>Body marker is not inside the tracking volume.</string>
      </property>
      <property name="alignment">
       <set>Qt::AlignCenter</set>
      </property>
      <property name="wordWrap">
       <bool>true</bool>
      </property>
     </widget>
    </item>
    <item>
     <widget class="QLabel" name="label_6">
      <property name="text">
       <string>You can mark critical structures by navigating to them using the ultrasound probe and freezing the image.</string>
      </property>
      <property name="wordWrap">
       <bool>true</bool>
      </property>
     </widget>
    </item>
    <item>
     <widget class="QmitkUSNavigationFreezeButton" name="freezeButton"/>
    </item>
    <item>
     <widget class="QLabel" name="zoneAddingExplanationLabel">
      <property name="enabled">
       <bool>false</bool>
      </property>
      <property name="text">
       <string>&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.0//EN&quot; &quot;http://www.w3.org/TR/REC-html40/strict.dtd&quot;&gt;
 &lt;html&gt;&lt;head&gt;&lt;meta name=&quot;qrichtext&quot; content=&quot;1&quot; /&gt;&lt;style type=&quot;text/css&quot;&gt;
 p, li { white-space: pre-wrap; }
 &lt;/style&gt;&lt;/head&gt;&lt;body style=&quot; font-family:'MS Shell Dlg 2'; font-size:7.8pt; font-weight:400; font-style:normal;&quot;&gt;
 &lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Now you can add a critical structure by clicking on its center in the ultrasound image, moving the mouse until the arc radius is as desired and clicking again then.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
      </property>
      <property name="wordWrap">
       <bool>true</bool>
      </property>
     </widget>
    </item>
    <item>
     <spacer name="verticalSpacer_6">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeType">
       <enum>QSizePolicy::Fixed</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>20</height>
       </size>
      </property>
     </spacer>
    </item>
    <item>
-    <widget class="QLabel" name="label_5">
+    <widget class="QCheckBox" name="showStructureList">
+     <property name="text">
+      <string>Show critical structure list</string>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <widget class="QLabel" name="zonesLabel">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
      <property name="text">
       <string>Critical Structures</string>
      </property>
      <property name="alignment">
       <set>Qt::AlignCenter</set>
      </property>
     </widget>
    </item>
    <item>
     <widget class="QmitkUSZoneManagementWidget" name="zonesWidget" native="true">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
     </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>
  <customwidgets>
   <customwidget>
    <class>QmitkUSZoneManagementWidget</class>
    <extends>QWidget</extends>
    <header>src/internal/Widgets/QmitkUSZoneManagementWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkUSNavigationFreezeButton</class>
    <extends>QPushButton</extends>
    <header>src/internal/Widgets/QmitkUSNavigationFreezeButton.h</header>
   </customwidget>
  </customwidgets>
  <resources>
   <include location="../../../resources/USNavigation.qrc"/>
  </resources>
  <connections/>
 </ui>
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/QmitkUSNavigationPerspective.cpp b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/QmitkUSNavigationPerspective.cpp
index 2afe6176cc..aa06b99bf9 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/QmitkUSNavigationPerspective.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/QmitkUSNavigationPerspective.cpp
@@ -1,36 +1,31 @@
 /*===================================================================
 
 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 "QmitkUSNavigationPerspective.h"
 
 QmitkUSNavigationPerspective::QmitkUSNavigationPerspective()
 {
 }
 
 void QmitkUSNavigationPerspective::CreateInitialLayout (berry::IPageLayout::Pointer layout)
 {
   // place navigation plugin on the right side (not closable)
-  layout->AddStandaloneView("org.mitk.views.usmarkerplacement", false, berry::IPageLayout::RIGHT, 0.8f, layout->GetEditorArea());
+  layout->AddStandaloneView("org.mitk.views.usmarkerplacement", false, berry::IPageLayout::RIGHT, 0.75f, layout->GetEditorArea());
 
   // place tracking toolbox and ultrasound support on the left into a folder
   // layout (closeable)
-  berry::IFolderLayout::Pointer leftFolder = layout->CreateFolder("left", berry::IPageLayout::LEFT, 0.3f, layout->GetEditorArea());
-
-  leftFolder->AddView("org.mitk.views.mitkigttrackingtoolbox");
-  leftFolder->AddView("org.mitk.views.ultrasoundsupport");
-
-  layout->GetViewLayout("org.mitk.views.mitkigttrackingtoolbox")->SetCloseable(false);
-  layout->GetViewLayout("org.mitk.views.ultrasoundsupport")->SetCloseable(false);
+  layout->AddStandaloneView("org.mitk.views.ultrasoundsupport", false, berry::IPageLayout::LEFT, 0.3f, layout->GetEditorArea());
+  layout->AddStandaloneView("org.mitk.views.mitkigttrackingtoolbox", false, berry::IPageLayout::BOTTOM, 0.9f, "org.mitk.views.ultrasoundsupport");
 }
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/SettingsWidgets/QmitkUSNavigationCombinedSettingsWidget.ui b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/SettingsWidgets/QmitkUSNavigationCombinedSettingsWidget.ui
index a17a457684..a390e4d978 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/SettingsWidgets/QmitkUSNavigationCombinedSettingsWidget.ui
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/SettingsWidgets/QmitkUSNavigationCombinedSettingsWidget.ui
@@ -1,256 +1,256 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkUSNavigationCombinedSettingsWidget</class>
  <widget class="QWidget" name="QmitkUSNavigationCombinedSettingsWidget">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>400</width>
     <height>546</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Form</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
     <widget class="QGroupBox" name="globalGroupBox">
      <property name="title">
       <string>Global</string>
      </property>
      <layout class="QFormLayout" name="formLayout_2">
       <property name="fieldGrowthPolicy">
        <enum>QFormLayout::AllNonFixedFieldsGrow</enum>
       </property>
       <item row="0" column="0">
        <widget class="QLabel" name="applicationLabel">
         <property name="text">
          <string>Application</string>
         </property>
        </widget>
       </item>
       <item row="0" column="1">
        <widget class="QComboBox" name="applicationComboBox">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <item>
          <property name="text">
-          <string>Punction</string>
+          <string>Puncture</string>
          </property>
         </item>
         <item>
          <property name="text">
           <string>Marker Placement</string>
          </property>
         </item>
        </widget>
       </item>
       <item row="1" column="0">
        <widget class="QLabel" name="interactionConceptLabel">
         <property name="text">
          <string>Interaction Concept</string>
         </property>
        </widget>
       </item>
       <item row="1" column="1">
        <widget class="QComboBox" name="interactionConceptComboBox">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <item>
          <property name="text">
           <string>Click, Move and Click</string>
          </property>
         </item>
        </widget>
       </item>
       <item row="2" column="0" colspan="2">
        <widget class="Line" name="line">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
        </widget>
       </item>
       <item row="3" column="0">
        <widget class="QLabel" name="experimentModeLabel">
         <property name="text">
          <string>Experiment Mode</string>
         </property>
        </widget>
       </item>
       <item row="3" column="1">
        <widget class="QCheckBox" name="experimentModeCheckBox">
         <property name="text">
          <string>Enable Experiment Mode</string>
         </property>
        </widget>
       </item>
       <item row="4" column="0">
        <widget class="QLabel" name="label_4">
         <property name="text">
          <string>Results Path</string>
         </property>
        </widget>
       </item>
       <item row="4" column="1">
        <widget class="ctkDirectoryButton" name="experimentResultsPathButton" native="true"/>
       </item>
       <item row="5" column="0" colspan="2">
        <widget class="Line" name="line_2">
         <property name="orientation">
          <enum>Qt::Horizontal</enum>
         </property>
        </widget>
       </item>
       <item row="6" column="0">
        <widget class="QLabel" name="label">
         <property name="text">
          <string>Needle Name</string>
         </property>
        </widget>
       </item>
       <item row="7" column="0">
        <widget class="QLabel" name="label_5">
         <property name="text">
          <string>Reference Name</string>
         </property>
        </widget>
       </item>
       <item row="6" column="1">
        <widget class="QComboBox" name="needleNameComboBox">
         <property name="editable">
          <bool>true</bool>
         </property>
        </widget>
       </item>
       <item row="7" column="1">
        <widget class="QComboBox" name="referenceNameComboBox">
         <property name="editable">
          <bool>true</bool>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="punctuationGroupBox">
      <property name="title">
       <string>Punction</string>
      </property>
      <layout class="QFormLayout" name="formLayout">
       <property name="fieldGrowthPolicy">
        <enum>QFormLayout::AllNonFixedFieldsGrow</enum>
       </property>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="markerPlacementGroupBox">
      <property name="title">
       <string>Marker Placement</string>
      </property>
      <layout class="QFormLayout" name="formLayout_3">
       <property name="fieldGrowthPolicy">
        <enum>QFormLayout::ExpandingFieldsGrow</enum>
       </property>
       <item row="0" column="0">
        <widget class="QLabel" name="tumourSegmentationLabel">
         <property name="text">
          <string>Tumour Segmentation</string>
         </property>
        </widget>
       </item>
       <item row="0" column="1">
        <widget class="QComboBox" name="tumourSegmentationComboBox">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <item>
          <property name="text">
           <string>Simple Segmentation</string>
          </property>
         </item>
        </widget>
       </item>
       <item row="1" column="0">
        <widget class="QLabel" name="securityDistanceLabel">
         <property name="text">
          <string>Security Distance (cm)</string>
         </property>
        </widget>
       </item>
       <item row="1" column="1">
        <widget class="QDoubleSpinBox" name="securityDistanceSpinBox">
         <property name="singleStep">
          <double>0.500000000000000</double>
         </property>
         <property name="value">
          <double>2.000000000000000</double>
         </property>
        </widget>
       </item>
       <item row="2" column="0">
        <widget class="QLabel" name="numberOfTargetsLabel">
         <property name="text">
          <string>Number of Targets</string>
         </property>
        </widget>
       </item>
       <item row="2" column="1">
        <widget class="QSpinBox" name="numberOfTargetsSpinBox">
         <property name="minimum">
          <number>1</number>
         </property>
         <property name="maximum">
          <number>4</number>
         </property>
         <property name="value">
          <number>3</number>
         </property>
        </widget>
       </item>
       <item row="3" column="0">
        <widget class="QLabel" name="planningStepUsageLabel">
         <property name="text">
          <string>Planning</string>
         </property>
        </widget>
       </item>
       <item row="3" column="1">
        <widget class="QCheckBox" name="planningStepUsageCheckBox">
         <property name="text">
          <string>Use Planning Step</string>
         </property>
         <property name="checked">
          <bool>true</bool>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>ctkDirectoryButton</class>
    <extends>QWidget</extends>
    <header location="global">ctkDirectoryButton.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
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 e2c412cc5e..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,714 +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_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_AblationZonesDisplacementFilter(mitk::NodeDisplacementFilter::New()),
-    m_NeedleIndex(0),
-    m_MarkerIndex(1),
     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()));
+    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);
+    // 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::");
+    // 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
+    m_UpdateTimer->start(33); // every 33 Milliseconds = 30 Frames/Second
 }
 
 USNavigationMarkerPlacement::~USNavigationMarkerPlacement()
 {
-  // make sure that the experiment got finished before destructing the object
-  if (m_IsExperimentRunning)
-  {
-    this->OnFinishExperiment();
-  }
+
+    // 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;
+    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();
+    // 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();
+    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);
+    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);
+    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(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(SignalSettingsChanged(itk::SmartPointer<mitk::DataNode>)),
+        this,
+        SLOT(OnSettingsChanged(itk::SmartPointer<mitk::DataNode>)));
 
-  connect(ui->navigationProcessWidget,
-          SIGNAL(SignalActiveNavigationStepChanged(int)),
-          this,
-          SLOT(OnActiveNavigationStepChanged(int)));
+    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->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>)));
+    connect(ui->navigationProcessWidget,
+        SIGNAL(SignalIntermediateResult(const itk::SmartPointer<mitk::DataNode>)),
+        this,
+        SLOT(OnIntermediateResultProduced(const itk::SmartPointer<mitk::DataNode>)));
 
-  ui->navigationProcessWidget->SetDataStorage(this->GetDataStorage());
+    ui->navigationProcessWidget->SetDataStorage(this->GetDataStorage());
 
-  // indicate that no experiment is running at start
-  ui->runningLabel->setPixmap(m_IconNotRunning);
+    // indicate that no experiment is running at start
+    ui->runningLabel->setPixmap(m_IconNotRunning);
 
-  ui->navigationProcessWidget->SetSettingsWidget(new QmitkUSNavigationCombinedSettingsWidget(m_Parent));
+    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 (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.";
+        }
+    }
+}
 
-    if (m_CombinedModality.IsNotNull() && !m_CombinedModality->GetIsCalibratedForCurrentStatus())
+
+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::LayoutAnnotationRenderer::AddAnnotation(
-        m_WarnOverlay.GetPointer(), "stdmulti.widget1", mitk::LayoutAnnotationRenderer::TopLeft);
-      MITK_WARN << "No calibration available for the selected ultrasound image depth.";
+      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();
+    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 (!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 there is a standard multi widget now, disable the level window and
-    // change the layout to 2D up and 3d down
-    if (multiWidgetEditor)
+    if (m_CombinedModality.IsNotNull() &&
+        !this->m_CombinedModality->GetIsFreezed()) // if the combined modality is freezed: do nothing
     {
-      m_StdMultiWidget = multiWidgetEditor->GetStdMultiWidget();
-      if (m_StdMultiWidget)
-      {
-        m_StdMultiWidget->DisableStandardLevelWindow();
-        m_StdMultiWidget->changeLayoutTo2DUpAnd3DDown();
-      }
+        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();
     }
+}
 
-    this->CreateOverlays();
-  }
+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();
 
-  if (m_CombinedModality.IsNotNull() &&
-      !this->m_CombinedModality->GetIsFreezed()) // if the combined modality is freezed: do nothing
+  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)
   {
-    ui->navigationProcessWidget->UpdateNavigationProgress();
-    m_AblationZonesDisplacementFilter->Update();
+    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);
+    }
+  }
+}
 
-    // update the 3D window only every fourth time to speed up the rendering (at least in 2D)
-    this->RequestRenderWindowUpdate(mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS);
+void USNavigationMarkerPlacement::OnResetStandardLayout()
+{
+  //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();
+}
 
-    // make sure that a reinit was performed on the image
-    this->ReinitOnImage();
-  }
+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();
+    // 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());
     }
-    else
+    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())
     {
-      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());
+        // 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();
+    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();
+    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->navigationProcessWidget->FinishCurrentNavigationStep();
+    m_ImageAndNavigationDataLoggingTimer->stop();
 
-  ui->runningLabel->setPixmap(m_IconNotRunning);
-  ui->navigationProcessWidget->EnableInteraction(false);
+    ui->runningLabel->setPixmap(m_IconNotRunning);
+    ui->navigationProcessWidget->EnableInteraction(false);
 
-  m_NavigationStepTimer->Stop();
+    m_NavigationStepTimer->Stop();
 
-  // make sure that the navigation process will be start from beginning at the
-  // next experiment
-  ui->navigationProcessWidget->ResetNavigationProcess();
+    // 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);
+    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();
+    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();
+    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());
+    // 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);
+    mbilog::UnregisterBackend(&m_LoggingBackend);
 
-  m_IsExperimentRunning = false;
+    m_IsExperimentRunning = false;
 
-  m_ImageAndNavigationDataLoggingTimer->stop();
-  m_CombinedModality = 0;
+    m_ImageAndNavigationDataLoggingTimer->stop();
+    m_CombinedModality = 0;
 
-  // reset scene number for next experiment
-  m_SceneNumber = 1;
+    // reset scene number for next experiment
+    m_SceneNumber = 1;
 
-  this->WaitCursorOff();
-  MITK_INFO("USNavigationLogging") << "Finished!";
+    this->WaitCursorOff();
+    MITK_INFO("USNavigationLogging") << "Finished!";
 }
 
 void USNavigationMarkerPlacement::OnCombinedModalityChanged(
-  itk::SmartPointer<mitk::USCombinedModality> combinedModality)
+    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);
-  }
+    // 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;
+    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);
-  }
+    // 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();
 
-  // update navigation data recorder for using the new combined modality
-  mitk::NavigationDataSource::Pointer navigationDataSource = combinedModality->GetNavigationDataSource();
-  m_NavigationDataRecorder->ConnectTo(navigationDataSource);
-  m_NavigationDataRecorder->ResetRecording();
+  //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);
 
   // 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";
-  }
+    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;
+    // create navigation step widgets according to the selected application
+    if (applicationName != m_CurrentApplicationName)
+    {
+        m_CurrentApplicationName = applicationName;
 
     QmitkUSNavigationProcessWidget::NavigationStepVector navigationSteps;
-    if (applicationName == "Punction")
+    if (applicationName == "Puncture")
     {
-      QmitkUSNavigationStepCombinedModality *stepCombinedModality = new QmitkUSNavigationStepCombinedModality(m_Parent);
-      QmitkUSNavigationStepTumourSelection *stepTumourSelection = new QmitkUSNavigationStepTumourSelection(m_Parent);
+      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 =
+      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");
+            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;
     }
-    else if (applicationName == "Marker Placement")
+
+    // 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)
     {
-      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");
+        ui->navigationProcessWidget->ResetNavigationProcess();
+        ui->navigationProcessWidget->EnableInteraction(false);
+        ui->runningLabel->setPixmap(m_IconNotRunning);
     }
-
-    // set navigation step widgets to the process widget
-    ui->navigationProcessWidget->SetNavigationSteps(navigationSteps);
-
-    for (QmitkUSNavigationProcessWidget::NavigationStepIterator it = m_NavigationSteps.begin();
-         it != m_NavigationSteps.end();
-         ++it)
+    else if (!experimentMode)
     {
-      delete *it;
+        if (m_IsExperimentRunning)
+        {
+            this->OnFinishExperiment();
+        }
+        ui->navigationProcessWidget->EnableInteraction(true);
     }
-    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)
+    // 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))
     {
-      this->OnFinishExperiment();
+        m_ResultsDirectory = QString::fromStdString(resultsDirectory);
+    }
+    else
+    {
+        m_ResultsDirectory = QDir::homePath();
     }
-    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);
-  }
+    // 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();
+    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;
-  }
+    // intermediate results only matter during an experiment
+    if (!m_IsExperimentRunning)
+    {
+        return;
+    }
 
-  this->WaitCursorOn();
+    this->WaitCursorOn();
 
-  // set results node to the experiment logging (for saving contents to the
-  // file system)
-  m_ExperimentLogging->SetResult(resultsNode);
+    // 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;
-  }
+    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;
+    // 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);
+    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);
+    this->Convert2DImagesTo3D(nodesToBeSaved);
 
-  sceneIO->SaveScene(nodesToBeSaved, this->GetDataStorage(), scenefile);
+    sceneIO->SaveScene(nodesToBeSaved, this->GetDataStorage(), scenefile);
 
-  this->WaitCursorOff();
+    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())
+    if (!m_ReinitAlreadyDone && m_CombinedModality.IsNotNull())
     {
-      // make a reinit on the ultrasound image
-      mitk::IRenderWindowPart *renderWindow = this->GetRenderWindowPart();
-      if (renderWindow != nullptr && image->GetTimeGeometry()->IsValid())
-      {
-        renderWindow->GetRenderingManager()->InitializeViews(
-          image->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
-        renderWindow->GetRenderingManager()->RequestUpdateAll();
-      }
-
-      this->RequestRenderWindowUpdate();
-
-      m_ReinitAlreadyDone = true;
+        // 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)
+    for (mitk::DataStorage::SetOfObjects::ConstIterator it = nodes->Begin(); it != nodes->End(); ++it)
     {
-      // 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());
-      }
+        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
+    // 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 f43ddf3e90..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;
+	template <class T>
+	class SmartPointer;
 }
 
 namespace mitk
 {
-  class USNavigationStepTimer;
-  class USNavigationExperimentLogging;
+	class USNavigationStepTimer;
+	class USNavigationExperimentLogging;
 }
 
 namespace Ui
 {
-  class USNavigationMarkerPlacement;
+	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.
- */
+* \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
+	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();
+		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 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 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();
+	/**
+	* \brief Stops logging and saves everything to the file system.
+	*/
+	void OnFinishExperiment();
 
-  void OnCombinedModalityChanged(itk::SmartPointer<mitk::USCombinedModality>);
+	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 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 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>);
+	/**
+	* \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 OnAddAblationZone(int size);
 
-  void OnChangeAblationZone(int id, int newSize);
+  void OnEnableNavigationLayout();
 
-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;
+  void OnResetStandardLayout();
 
-  explicit USNavigationMarkerPlacement();
-  ~USNavigationMarkerPlacement();
+  void OnChangeLayoutClicked();
 
-  virtual void CreateQtPartControl(QWidget *parent);
+	void OnChangeAblationZone(int id, int newSize);
 
-  static const std::string VIEW_ID;
+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;
 
-  void OnCombinedModalityPropertyChanged(const std::string &, const std::string &);
+	explicit USNavigationMarkerPlacement();
+	~USNavigationMarkerPlacement();
 
-protected:
-  /**
-   * \brief A reinit on the ultrasound image is performed every time the view gets the focus.
-   */
-  virtual void SetFocus();
+	virtual void CreateQtPartControl(QWidget *parent);
 
-  /**
-   * \brief Helper function which performs a reinit on the ultrasound image.
-   */
-  void ReinitOnImage();
+	static const std::string VIEW_ID;
 
+	void OnCombinedModalityPropertyChanged(const std::string &, const std::string &);
   /**
-   * \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;
+  * \returns the point defining the needle axis in the tool storage
+  */
+  void SetToolAxisMarkerPlacement();
+  mitk::Point3D m_ToolAxis;
 
-  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;
+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;
+	mitk::MessageDelegate2<USNavigationMarkerPlacement, const std::string &, const std::string &> m_ListenerDeviceChanged;
 
-  Ui::USNavigationMarkerPlacement *ui;
+	Ui::USNavigationMarkerPlacement *ui;
 };
 
 #endif // USNAVIGATIONMARKERPLACEMENT_H
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.ui b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.ui
index be5cde1399..eb816e0225 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.ui
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/USNavigationMarkerPlacement.ui
@@ -1,83 +1,102 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>USNavigationMarkerPlacement</class>
  <widget class="QWidget" name="USNavigationMarkerPlacement">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>400</width>
     <height>146</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Form</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <property name="spacing">
     <number>0</number>
    </property>
-   <property name="margin">
+   <property name="leftMargin">
+    <number>0</number>
+   </property>
+   <property name="topMargin">
+    <number>0</number>
+   </property>
+   <property name="rightMargin">
+    <number>0</number>
+   </property>
+   <property name="bottomMargin">
     <number>0</number>
    </property>
    <item>
     <widget class="QmitkUSNavigationProcessWidget" name="navigationProcessWidget" native="true"/>
    </item>
    <item>
     <widget class="Line" name="line">
      <property name="orientation">
       <enum>Qt::Horizontal</enum>
      </property>
     </widget>
    </item>
+   <item>
+    <widget class="QCheckBox" name="m_enableNavigationLayout">
+     <property name="text">
+      <string>Enable Navigation Render Window Layout</string>
+     </property>
+     <property name="checked">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout">
      <item>
       <widget class="QPushButton" name="startExperimentButton">
        <property name="text">
         <string>Start New Experiment</string>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QPushButton" name="finishExperimentButton">
        <property name="enabled">
         <bool>false</bool>
        </property>
        <property name="text">
         <string>Finish Experiment</string>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QLabel" name="runningLabel">
        <property name="maximumSize">
         <size>
          <width>20</width>
          <height>20</height>
         </size>
        </property>
        <property name="text">
         <string/>
        </property>
       </widget>
      </item>
     </layout>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>QmitkUSNavigationProcessWidget</class>
    <extends>QWidget</extends>
    <header>src/internal/Widgets/QmitkUSNavigationProcessWidget.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
  <slots>
   <slot>OnStartExperiment()</slot>
   <slot>OnFinishExperiment()</slot>
  </slots>
 </ui>
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/Widgets/QmitkUSNavigationProcessWidget.cpp b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/Widgets/QmitkUSNavigationProcessWidget.cpp
index d98b81f3c0..02b1f4064f 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/Widgets/QmitkUSNavigationProcessWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/Widgets/QmitkUSNavigationProcessWidget.cpp
@@ -1,556 +1,556 @@
 /*===================================================================
 
 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 "QmitkUSNavigationProcessWidget.h"
 #include "ui_QmitkUSNavigationProcessWidget.h"
 
 #include "../NavigationStepWidgets/QmitkUSAbstractNavigationStep.h"
 #include "../SettingsWidgets/QmitkUSNavigationAbstractSettingsWidget.h"
 
 #include "mitkDataNode.h"
 #include "mitkNavigationDataToNavigationDataFilter.h"
 
 #include <QTimer>
 #include <QSignalMapper>
 #include <QShortcut>
 
 QmitkUSNavigationProcessWidget::QmitkUSNavigationProcessWidget(QWidget* parent) :
   QWidget(parent),
   m_SettingsWidget(0),
   m_BaseNode(mitk::DataNode::New()), m_CurrentTabIndex(0), m_CurrentMaxStep(0),
   m_ImageAlreadySetToNode(false),
   m_ReadySignalMapper(new QSignalMapper(this)), m_NoLongerReadySignalMapper(new QSignalMapper(this)),
   m_StdMultiWidget(0),
   m_UsePlanningStepWidget(false),
   ui(new Ui::QmitkUSNavigationProcessWidget)
 {
   m_Parent = parent;
 
   ui->setupUi(this);
 
   // remove the default page
-  ui->stepsToolBox->removeItem(0);
+  ui->stepsToolBox->setCurrentIndex(1);// ->removeItem(0);
 
   //set shortcuts
   QShortcut *nextShortcut = new QShortcut(QKeySequence("F10"), parent);
   QShortcut *prevShortcut = new QShortcut(QKeySequence("F11"), parent);
   connect(nextShortcut, SIGNAL(activated()), this, SLOT(OnNextButtonClicked()));
   connect(prevShortcut, SIGNAL(activated()), this, SLOT(OnPreviousButtonClicked()));
 
   //connect other slots
   connect( ui->restartStepButton, SIGNAL(clicked()), this, SLOT(OnRestartStepButtonClicked()) );
   connect( ui->previousButton, SIGNAL(clicked()), this, SLOT(OnPreviousButtonClicked()) );
   connect( ui->nextButton, SIGNAL(clicked()), this, SLOT(OnNextButtonClicked()) );
   connect( ui->stepsToolBox, SIGNAL(currentChanged(int)), this, SLOT(OnTabChanged(int)) );
   connect (ui->settingsButton, SIGNAL(clicked()), this, SLOT(OnSettingsButtonClicked()) );
   connect( m_ReadySignalMapper, SIGNAL(mapped(int)), this, SLOT(OnStepReady(int)) );
   connect( m_NoLongerReadySignalMapper, SIGNAL(mapped(int)), this, SLOT(OnStepNoLongerReady(int)) );
 
   ui->settingsFrameWidget->setHidden(true);
 }
 
 QmitkUSNavigationProcessWidget::~QmitkUSNavigationProcessWidget()
 {
   ui->stepsToolBox->blockSignals(true);
 
   for ( NavigationStepVector::iterator it = m_NavigationSteps.begin();
     it != m_NavigationSteps.end(); ++it )
   {
     if ( (*it)->GetNavigationStepState() > QmitkUSAbstractNavigationStep::State_Stopped ) { (*it)->StopStep(); }
     delete *it;
   }
   m_NavigationSteps.clear();
 
   if ( m_SettingsNode.IsNotNull() && m_DataStorage.IsNotNull() )
   {
     m_DataStorage->Remove(m_SettingsNode);
   }
 
   delete ui;
 }
 
 void QmitkUSNavigationProcessWidget::EnableInteraction(bool enable)
 {
   if (enable)
   {
     ui->restartStepButton->setEnabled(true);
     ui->previousButton->setEnabled(true);
     ui->nextButton->setEnabled(true);
     ui->stepsToolBox->setEnabled(true);
   }
   else
   {
     ui->restartStepButton->setEnabled(false);
     ui->previousButton->setEnabled(false);
     ui->nextButton->setEnabled(false);
     ui->stepsToolBox->setEnabled(false);
   }
 }
 
 void QmitkUSNavigationProcessWidget::SetDataStorage(itk::SmartPointer<mitk::DataStorage> dataStorage)
 {
   m_DataStorage = dataStorage;
 
   if ( dataStorage.IsNull() )
   {
     mitkThrow() << "Data Storage must not be null for QmitkUSNavigationProcessWidget.";
   }
 
   // test if base node is already in the data storage and add it if not
   m_BaseNode = dataStorage->GetNamedNode(QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
   if ( m_BaseNode.IsNull() )
   {
     m_BaseNode = mitk::DataNode::New();
     m_BaseNode->SetName(QmitkUSAbstractNavigationStep::DATANAME_BASENODE);
     dataStorage->Add(m_BaseNode);
   }
 
   // base node and image stream node may be the same node
   if ( strcmp(QmitkUSAbstractNavigationStep::DATANAME_BASENODE, QmitkUSAbstractNavigationStep::DATANAME_IMAGESTREAM) != 0)
   {
     m_ImageStreamNode = dataStorage->GetNamedNode(QmitkUSAbstractNavigationStep::DATANAME_IMAGESTREAM);
     if (m_ImageStreamNode.IsNull())
     {
       // Create Node for US Stream
       m_ImageStreamNode = mitk::DataNode::New();
       m_ImageStreamNode->SetName(QmitkUSAbstractNavigationStep::DATANAME_IMAGESTREAM);
       dataStorage->Add(m_ImageStreamNode);
     }
   }
   else
   {
     m_ImageStreamNode = m_BaseNode;
   }
 
 
   m_SettingsNode =
     dataStorage->GetNamedDerivedNode(QmitkUSAbstractNavigationStep::DATANAME_SETTINGS, m_BaseNode);
 
   if ( m_SettingsNode.IsNull() )
   {
     m_SettingsNode = mitk::DataNode::New();
     m_SettingsNode->SetName(QmitkUSAbstractNavigationStep::DATANAME_SETTINGS);
     dataStorage->Add(m_SettingsNode, m_BaseNode);
   }
 
   if (m_SettingsWidget) { m_SettingsWidget->SetSettingsNode(m_SettingsNode); }
 
 }
 
 void QmitkUSNavigationProcessWidget::SetSettingsWidget(QmitkUSNavigationAbstractSettingsWidget* settingsWidget)
 {
   // disconnect slots to settings widget if there was a widget before
   if ( m_SettingsWidget )
   {
     disconnect( ui->settingsSaveButton, SIGNAL(clicked()), m_SettingsWidget, SLOT(OnSave()) );
     disconnect( ui->settingsCancelButton, SIGNAL(clicked()), m_SettingsWidget, SLOT(OnCancel()) );
 
     disconnect (m_SettingsWidget, SIGNAL(Saved()), this, SLOT(OnSettingsWidgetReturned()) );
     disconnect (m_SettingsWidget, SIGNAL(Canceled()), this, SLOT(OnSettingsWidgetReturned()) );
     disconnect (m_SettingsWidget, SIGNAL(SettingsChanged(itk::SmartPointer<mitk::DataNode>)), this, SLOT(OnSettingsChanged(itk::SmartPointer<mitk::DataNode>)) );
 
     ui->settingsWidget->removeWidget(m_SettingsWidget);
   }
 
   m_SettingsWidget = settingsWidget;
   if ( m_SettingsWidget )
   {
     m_SettingsWidget->LoadSettings();
 
     connect( ui->settingsSaveButton, SIGNAL(clicked()), m_SettingsWidget, SLOT(OnSave()) );
     connect( ui->settingsCancelButton, SIGNAL(clicked()), m_SettingsWidget, SLOT(OnCancel()) );
 
     connect (m_SettingsWidget, SIGNAL(Saved()), this, SLOT(OnSettingsWidgetReturned()) );
     connect (m_SettingsWidget, SIGNAL(Canceled()), this, SLOT(OnSettingsWidgetReturned()) );
     connect (m_SettingsWidget, SIGNAL(SettingsChanged(itk::SmartPointer<mitk::DataNode>)), this, SLOT(OnSettingsChanged(itk::SmartPointer<mitk::DataNode>)) );
 
     if ( m_SettingsNode.IsNotNull() ) { m_SettingsWidget->SetSettingsNode(m_SettingsNode, true); }
 
     ui->settingsWidget->addWidget(m_SettingsWidget);
   }
   ui->settingsButton->setEnabled(m_SettingsWidget != 0);
 }
 
 void QmitkUSNavigationProcessWidget::SetNavigationSteps(NavigationStepVector navigationSteps)
 {
   disconnect( this, SLOT(OnTabChanged(int)) );
 
   for ( int n = ui->stepsToolBox->count()-1; n >= 0; --n )
   {
-    ui->stepsToolBox->removeItem(n);
+    //ui->stepsToolBox->removeItem(n);
   }
 
   connect( ui->stepsToolBox, SIGNAL(currentChanged(int)), this, SLOT(OnTabChanged(int)) );
 
   m_NavigationSteps.clear();
 
   m_NavigationSteps = navigationSteps;
 
   this->InitializeNavigationStepWidgets();
 
   // notify all navigation step widgets about the current settings
   for (NavigationStepIterator it = m_NavigationSteps.begin(); it != m_NavigationSteps.end(); ++it)
   {
     (*it)->OnSettingsChanged(m_SettingsNode);
   }
 }
 
 void QmitkUSNavigationProcessWidget::ResetNavigationProcess()
 {
   MITK_INFO("QmitkUSNavigationProcessWidget") << "Resetting navigation process.";
 
   ui->stepsToolBox->blockSignals(true);
   for ( int n = 0; n <= m_CurrentMaxStep; ++n )
   {
     m_NavigationSteps.at(n)->StopStep();
-    if ( n > 0 ) { ui->stepsToolBox->setItemEnabled(n, false); }
+    //if ( n > 0 ) { ui->stepsToolBox->setItemEnabled(n, false); }
   }
   ui->stepsToolBox->blockSignals(false);
 
   m_CurrentMaxStep = 0;
 
   ui->stepsToolBox->setCurrentIndex(0);
 
   if ( m_NavigationSteps.size() > 0 )
   {
     m_NavigationSteps.at(0)->ActivateStep();
   }
 
   this->UpdatePrevNextButtons();
 }
 
 void QmitkUSNavigationProcessWidget::UpdateNavigationProgress()
 {
   if ( m_CombinedModality.IsNotNull() && !m_CombinedModality->GetIsFreezed() )
   {
     m_CombinedModality->Modified();
     m_CombinedModality->Update();
 
     if ( m_LastNavigationDataFilter.IsNotNull() ) { m_LastNavigationDataFilter->Update(); }
 
     mitk::Image::Pointer image = m_CombinedModality->GetOutput();
     // make sure that always the current image is set to the data node
     if ( image.IsNotNull() && m_ImageStreamNode->GetData() != image.GetPointer() && image->IsInitialized() )
     {
       m_ImageStreamNode->SetData(image);
       m_ImageAlreadySetToNode = true;
     }
   }
 
   if ( m_CurrentTabIndex > 0 && static_cast<unsigned int>(m_CurrentTabIndex) < m_NavigationSteps.size() )
   {
     m_NavigationSteps.at(m_CurrentTabIndex)->Update();
   }
 }
 
 void QmitkUSNavigationProcessWidget::OnNextButtonClicked()
 {
   if (m_CombinedModality.IsNotNull() && m_CombinedModality->GetIsFreezed()) {return;} //no moving through steps when the modality is nullptr or frozen
 
   int currentIndex = ui->stepsToolBox->currentIndex();
   if (currentIndex >= m_CurrentMaxStep)
   {
     MITK_WARN << "Next button clicked though no next tab widget is available.";
     return;
   }
 
   ui->stepsToolBox->setCurrentIndex(++currentIndex);
 
   this->UpdatePrevNextButtons();
 }
 
 void QmitkUSNavigationProcessWidget::OnPreviousButtonClicked()
 {
   if (m_CombinedModality.IsNotNull() && m_CombinedModality->GetIsFreezed()) {return;} //no moving through steps when the modality is nullptr or frozen
 
   int currentIndex = ui->stepsToolBox->currentIndex();
   if (currentIndex <= 0)
   {
     MITK_WARN << "Previous button clicked though no previous tab widget is available.";
     return;
   }
 
   ui->stepsToolBox->setCurrentIndex(--currentIndex);
 
   this->UpdatePrevNextButtons();
 }
 
 void QmitkUSNavigationProcessWidget::OnRestartStepButtonClicked()
 {
   MITK_INFO("QmitkUSNavigationProcessWidget") << "Restarting step "
     << m_CurrentTabIndex << " (" << m_NavigationSteps.at(m_CurrentTabIndex)->GetTitle().toStdString() << ").";
 
   m_NavigationSteps.at(ui->stepsToolBox->currentIndex())->RestartStep();
   m_NavigationSteps.at(ui->stepsToolBox->currentIndex())->ActivateStep();
 }
 
 void QmitkUSNavigationProcessWidget::OnTabChanged(int index)
 {
   if ( index < 0 || index >= static_cast<int>(m_NavigationSteps.size()) )
   {
     return;
   }
   else if ( m_CurrentTabIndex == index )
   {
     // just activate the step if it is the same step againg
     m_NavigationSteps.at(index)->ActivateStep();
     return;
   }
 
   MITK_INFO("QmitkUSNavigationProcessWidget") << "Activating navigation step "
     << index << " (" << m_NavigationSteps.at(index)->GetTitle().toStdString() <<").";
 
   if (index > m_CurrentTabIndex)
   {
     this->UpdateFilterPipeline();
 
     // finish all previous steps to make sure that all data is valid
     for (int n = m_CurrentTabIndex; n < index; ++n)
     {
       m_NavigationSteps.at(n)->FinishStep();
     }
   }
 
   // deactivate the previously active step
   if ( m_CurrentTabIndex > 0 && m_NavigationSteps.size() > static_cast<unsigned int>(m_CurrentTabIndex) )
   {
     m_NavigationSteps.at(m_CurrentTabIndex)->DeactivateStep();
   }
 
   // start step of the current tab if it wasn't started before
   if ( m_NavigationSteps.at(index)->GetNavigationStepState() == QmitkUSAbstractNavigationStep::State_Stopped )
   {
     m_NavigationSteps.at(index)->StartStep();
   }
 
   m_NavigationSteps.at(index)->ActivateStep();
 
   if (static_cast<unsigned int>(index) < m_NavigationSteps.size())
     ui->restartStepButton->setEnabled(m_NavigationSteps.at(index)->GetIsRestartable());
 
   this->UpdatePrevNextButtons();
 
   m_CurrentTabIndex = index;
   emit SignalActiveNavigationStepChanged(index);
 }
 
 void QmitkUSNavigationProcessWidget::OnSettingsButtonClicked()
 {
   this->SetSettingsWidgetVisible(true);
 }
 
 void QmitkUSNavigationProcessWidget::OnSettingsWidgetReturned()
 {
   this->SetSettingsWidgetVisible(false);
 }
 
 void QmitkUSNavigationProcessWidget::OnSettingsNodeChanged(itk::SmartPointer<mitk::DataNode> dataNode)
 {
   if ( m_SettingsWidget ) m_SettingsWidget->SetSettingsNode(dataNode);
 }
 
 void QmitkUSNavigationProcessWidget::OnStepReady(int index)
 {
   if (m_CurrentMaxStep <= index)
   {
     m_CurrentMaxStep = index + 1;
     this->UpdatePrevNextButtons();
     for (int n = 0; n <= m_CurrentMaxStep; ++n)
     {
-      ui->stepsToolBox->setItemEnabled(n, true);
+      //ui->stepsToolBox->setItemEnabled(n, true);
     }
   }
 
   emit SignalNavigationStepFinished(index, true);
 }
 
 void QmitkUSNavigationProcessWidget::OnStepNoLongerReady(int index)
 {
   if (m_CurrentMaxStep > index)
   {
     m_CurrentMaxStep = index;
     this->UpdatePrevNextButtons();
     this->UpdateFilterPipeline();
     for (int n = m_CurrentMaxStep+1; n < ui->stepsToolBox->count(); ++n)
     {
-      ui->stepsToolBox->setItemEnabled(n, false);
+      //ui->stepsToolBox->setItemEnabled(n, false);
       m_NavigationSteps.at(n)->StopStep();
     }
   }
 
   emit SignalNavigationStepFinished(index, false);
 }
 
 void QmitkUSNavigationProcessWidget::OnCombinedModalityChanged(itk::SmartPointer<mitk::USCombinedModality> combinedModality)
 {
   m_CombinedModality = combinedModality;
   m_ImageAlreadySetToNode = false;
 
   if ( combinedModality.IsNotNull() )
   {
     if ( combinedModality->GetNavigationDataSource().IsNull() )
     {
       MITK_WARN << "There is no navigation data source set for the given combined modality.";
       return;
     }
 
     this->UpdateFilterPipeline();
   }
 
   for (NavigationStepIterator it = m_NavigationSteps.begin(); it != m_NavigationSteps.end(); ++it)
   {
     (*it)->SetCombinedModality(combinedModality);
   }
 
   emit SignalCombinedModalityChanged(combinedModality);
 }
 
 void QmitkUSNavigationProcessWidget::OnSettingsChanged(const mitk::DataNode::Pointer dataNode)
 {
   static bool methodEntered = false;
   if ( methodEntered )
   {
     MITK_WARN("QmitkUSNavigationProcessWidget") << "Ignoring recursive call to 'OnSettingsChanged()'. "
       << "Make sure to no emit 'SignalSettingsNodeChanged' in an 'OnSettingsChanged()' method.";
     return;
   }
   methodEntered = true;
 
   std::string application;
   if ( dataNode->GetStringProperty("settings.application", application) )
   {
     QString applicationQString = QString::fromStdString(application);
     if ( applicationQString != ui->titleLabel->text() )
     {
       ui->titleLabel->setText(applicationQString);
     }
   }
 
   // notify all navigation step widgets about the changed settings
   for (NavigationStepIterator it = m_NavigationSteps.begin(); it != m_NavigationSteps.end(); ++it)
   {
     (*it)->OnSettingsChanged(dataNode);
   }
 
   emit SignalSettingsChanged(dataNode);
 
   methodEntered = false;
 }
 
 void QmitkUSNavigationProcessWidget::InitializeNavigationStepWidgets()
 {
   // do not listen for steps tool box signal during insertion of items into tool box
   disconnect( ui->stepsToolBox, SIGNAL(currentChanged(int)), this, SLOT(OnTabChanged(int)) );
 
   m_CurrentMaxStep = 0;
 
   mitk::DataStorage::Pointer dataStorage = m_DataStorage;
 
   for (unsigned int n = 0; n < m_NavigationSteps.size(); ++n)
   {
     QmitkUSAbstractNavigationStep* curNavigationStep = m_NavigationSteps.at(n);
 
     curNavigationStep->SetDataStorage(dataStorage);
 
     connect( curNavigationStep, SIGNAL(SignalReadyForNextStep()), m_ReadySignalMapper, SLOT(map()));
     connect( curNavigationStep, SIGNAL(SignalNoLongerReadyForNextStep()), m_NoLongerReadySignalMapper, SLOT(map()) );
     connect( curNavigationStep, SIGNAL(SignalCombinedModalityChanged(itk::SmartPointer<mitk::USCombinedModality>)), this, SLOT(OnCombinedModalityChanged(itk::SmartPointer<mitk::USCombinedModality>)) );
     connect( curNavigationStep, SIGNAL(SignalIntermediateResult(const itk::SmartPointer<mitk::DataNode>)), this, SIGNAL(SignalIntermediateResult(const itk::SmartPointer<mitk::DataNode>)) );
     connect( curNavigationStep, SIGNAL(SignalSettingsNodeChanged(itk::SmartPointer<mitk::DataNode>)), this, SLOT(OnSettingsNodeChanged(itk::SmartPointer<mitk::DataNode>)) );
 
     m_ReadySignalMapper->setMapping(curNavigationStep, n);
     m_NoLongerReadySignalMapper->setMapping(curNavigationStep, n);
 
-    ui->stepsToolBox->insertItem(n, curNavigationStep, QString("Step ") + QString::number(n+1) + ": " + curNavigationStep->GetTitle());
-    if ( n > 0 ) { ui->stepsToolBox->setItemEnabled(n, false); }
+    ui->stepsToolBox->insertWidget(n, curNavigationStep);
+    //if ( n > 0 ) { ui->stepsToolBox->get(n, false); }
   }
 
   ui->restartStepButton->setEnabled(m_NavigationSteps.at(0)->GetIsRestartable());
   ui->stepsToolBox->setCurrentIndex(0);
 
   // activate the first navigation step widgets
   if ( ! m_NavigationSteps.empty() ) { m_NavigationSteps.at(0)->ActivateStep(); }
 
   // after filling the steps tool box the signal is interesting again
   connect( ui->stepsToolBox, SIGNAL(currentChanged(int)), this, SLOT(OnTabChanged(int)) );
 
   this->UpdateFilterPipeline();
 }
 
 void QmitkUSNavigationProcessWidget::UpdatePrevNextButtons()
 {
   int currentIndex = ui->stepsToolBox->currentIndex();
 
   ui->previousButton->setEnabled(currentIndex > 0);
   ui->nextButton->setEnabled(currentIndex < m_CurrentMaxStep);
 }
 
 void QmitkUSNavigationProcessWidget::UpdateFilterPipeline()
 {
   if ( m_CombinedModality.IsNull() ) { return; }
 
   std::vector<mitk::NavigationDataToNavigationDataFilter::Pointer> filterList;
 
   mitk::NavigationDataSource::Pointer navigationDataSource = m_CombinedModality->GetNavigationDataSource();
 
   for (unsigned int n = 0; n <= static_cast<unsigned int>(m_CurrentMaxStep) && n < m_NavigationSteps.size(); ++n)
   {
     QmitkUSAbstractNavigationStep::FilterVector filter = m_NavigationSteps.at(n)->GetFilter();
     if ( ! filter.empty() ) { filterList.insert(filterList.end(), filter.begin(), filter.end()); }
   }
 
   if ( ! filterList.empty() )
   {
     for (unsigned int n = 0; n < navigationDataSource->GetNumberOfOutputs(); ++n)
     {
       filterList.at(0)->SetInput(n, navigationDataSource->GetOutput(n));
     }
 
     for (std::vector<mitk::NavigationDataToNavigationDataFilter::Pointer>::iterator it = filterList.begin()+1;
       it != filterList.end(); ++it)
     {
       std::vector<mitk::NavigationDataToNavigationDataFilter::Pointer>::iterator prevIt = it-1;
 
       for (unsigned int n = 0; n < (*prevIt)->GetNumberOfOutputs(); ++n)
       {
         (*it)->SetInput(n, (*prevIt)->GetOutput(n));
       }
     }
 
     m_LastNavigationDataFilter = filterList.at(filterList.size()-1);
   }
   else
   {
     m_LastNavigationDataFilter = navigationDataSource.GetPointer();
   }
 }
 
 void QmitkUSNavigationProcessWidget::SetSettingsWidgetVisible(bool visible)
 {
  ui->settingsFrameWidget->setVisible(visible);
  ui->stepsToolBox->setHidden(visible);
  ui->settingsButton->setHidden(visible);
  ui->restartStepButton->setHidden(visible);
  ui->previousButton->setHidden(visible);
  ui->nextButton->setHidden(visible);
 }
 
 void QmitkUSNavigationProcessWidget::FinishCurrentNavigationStep()
 {
   int currentIndex = ui->stepsToolBox->currentIndex();
   QmitkUSAbstractNavigationStep* curNavigationStep = m_NavigationSteps.at(currentIndex);
   curNavigationStep->FinishStep();
 }
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/Widgets/QmitkUSNavigationProcessWidget.ui b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/Widgets/QmitkUSNavigationProcessWidget.ui
index dc61a9bfeb..5526f413c9 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/Widgets/QmitkUSNavigationProcessWidget.ui
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/Widgets/QmitkUSNavigationProcessWidget.ui
@@ -1,213 +1,203 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkUSNavigationProcessWidget</class>
  <widget class="QWidget" name="QmitkUSNavigationProcessWidget">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>400</width>
+    <width>465</width>
     <height>757</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Form</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout">
    <item>
     <widget class="QLabel" name="titleLabel">
      <property name="styleSheet">
       <string notr="true">
               font-size: 10pt;
               font-weight: bold;
             </string>
      </property>
      <property name="text">
       <string/>
      </property>
      <property name="alignment">
-      <set>Qt::AlignCenter</set>
+      <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter</set>
      </property>
     </widget>
    </item>
    <item>
-    <widget class="QToolBox" name="stepsToolBox">
+    <widget class="QStackedWidget" name="stepsToolBox">
      <property name="currentIndex">
       <number>0</number>
      </property>
-     <widget class="QWidget" name="page">
-      <property name="geometry">
-       <rect>
-        <x>0</x>
-        <y>0</y>
-        <width>378</width>
-        <height>300</height>
-       </rect>
-      </property>
-      <attribute name="label">
-       <string>No navigation step widgets loaded.</string>
-      </attribute>
+     <widget class="QWidget" name="stepsStackedWidgetPage1">
       <layout class="QVBoxLayout" name="verticalLayout_3"/>
      </widget>
+     <widget class="QWidget" name="page"/>
     </widget>
    </item>
    <item>
     <layout class="QHBoxLayout" name="navigationButtonsLayout">
      <item>
       <widget class="QToolButton" name="settingsButton">
        <property name="enabled">
         <bool>false</bool>
        </property>
        <property name="toolTip">
         <string>Open Preferences</string>
        </property>
        <property name="text">
         <string>Preferences</string>
        </property>
        <property name="icon">
         <iconset resource="../../../resources/USNavigation.qrc">
          <normaloff>:/USNavigation/preferences.png</normaloff>:/USNavigation/preferences.png</iconset>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QPushButton" name="restartStepButton">
        <property name="enabled">
         <bool>false</bool>
        </property>
        <property name="mouseTracking">
         <bool>false</bool>
        </property>
        <property name="toolTip">
         <string>Restart the Current Step</string>
        </property>
        <property name="text">
         <string>&amp;Restart Step</string>
        </property>
        <property name="icon">
         <iconset resource="../../../resources/USNavigation.qrc">
          <normaloff>:/USNavigation/restart.png</normaloff>:/USNavigation/restart.png</iconset>
        </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>
      <item>
       <widget class="QPushButton" name="previousButton">
        <property name="enabled">
         <bool>false</bool>
        </property>
        <property name="toolTip">
         <string>Go to Previous Step</string>
        </property>
        <property name="text">
         <string>&amp;Prev</string>
        </property>
        <property name="icon">
         <iconset resource="../../../resources/USNavigation.qrc">
          <normaloff>:/USNavigation/go-previous.png</normaloff>:/USNavigation/go-previous.png</iconset>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QPushButton" name="nextButton">
        <property name="enabled">
         <bool>false</bool>
        </property>
        <property name="toolTip">
         <string>Go to Next Step</string>
        </property>
        <property name="text">
         <string>&amp;Next</string>
        </property>
        <property name="icon">
         <iconset resource="../../../resources/USNavigation.qrc">
          <normaloff>:/USNavigation/go-next.png</normaloff>:/USNavigation/go-next.png</iconset>
        </property>
       </widget>
      </item>
     </layout>
    </item>
    <item>
     <widget class="QWidget" name="settingsFrameWidget" native="true">
      <layout class="QVBoxLayout" name="verticalLayout_2">
       <item>
        <widget class="QLabel" name="settingsTitleLabel">
         <property name="text">
          <string>&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.0//EN&quot; &quot;http://www.w3.org/TR/REC-html40/strict.dtd&quot;&gt;
 &lt;html&gt;&lt;head&gt;&lt;meta name=&quot;qrichtext&quot; content=&quot;1&quot; /&gt;&lt;style type=&quot;text/css&quot;&gt;
 p, li { white-space: pre-wrap; }
-&lt;/style&gt;&lt;/head&gt;&lt;body style=&quot; font-family:'MS Shell Dlg 2'; font-size:7.8pt; font-weight:400; font-style:normal;&quot;&gt;
-&lt;p align=&quot;center&quot; style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-size:10pt; font-weight:600;&quot;&gt;Settings&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+&lt;/style&gt;&lt;/head&gt;&lt;body style=&quot; font-family:'MS Shell Dlg 2'; font-size:8pt; font-weight:400; font-style:normal;&quot;&gt;
+&lt;p style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-size:10pt; font-weight:600;&quot;&gt;Settings&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
         </property>
        </widget>
       </item>
       <item>
        <layout class="QVBoxLayout" name="settingsWidget"/>
       </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="settingsButtonsLayout">
         <item>
          <widget class="QPushButton" name="settingsSaveButton">
           <property name="text">
            <string>Save</string>
           </property>
           <property name="icon">
            <iconset resource="../../../resources/USNavigation.qrc">
             <normaloff>:/USNavigation/document-save.png</normaloff>:/USNavigation/document-save.png</iconset>
           </property>
          </widget>
         </item>
         <item>
          <widget class="QPushButton" name="settingsCancelButton">
           <property name="text">
            <string>Cancel</string>
           </property>
           <property name="icon">
            <iconset resource="../../../resources/USNavigation.qrc">
             <normaloff>:/USNavigation/restart.png</normaloff>:/USNavigation/restart.png</iconset>
           </property>
          </widget>
         </item>
        </layout>
       </item>
      </layout>
     </widget>
    </item>
   </layout>
  </widget>
  <resources>
   <include location="../../../resources/USNavigation.qrc"/>
  </resources>
  <connections/>
  <slots>
   <slot>OnNextButtonClicked()</slot>
   <slot>OnPreviousButtonClicked()</slot>
   <slot>OnRestartStepButtonClicked()</slot>
   <slot>OnTabChanged(int)</slot>
  </slots>
 </ui>
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/org_mbi_gui_qt_usnavigation_Activator.cpp b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/org_mbi_gui_qt_usnavigation_Activator.cpp
index e7baba9e85..f8a17098f1 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/org_mbi_gui_qt_usnavigation_Activator.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/org_mbi_gui_qt_usnavigation_Activator.cpp
@@ -1,67 +1,67 @@
 /*===================================================================
 
 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 "org_mbi_gui_qt_usnavigation_Activator.h"
 
 #include <usModuleInitialization.h>
 #include <QtPlugin>
 
 //#include "USNavigation.h"
 #include "UltrasoundCalibration.h"
 #include "USNavigationMarkerPlacement.h"
 #include "QmitkUSNavigationPerspective.h"
 
 #include "mitkVirtualTrackingDevice.h"
 
 namespace mitk {
   ctkPluginContext* org_mbi_gui_qt_usnavigation_Activator::m_Context = 0;
 
   void org_mbi_gui_qt_usnavigation_Activator::start(ctkPluginContext* context)
   {
     m_Context = context;
 
     //BERRY_REGISTER_EXTENSION_CLASS(USNavigation, context)
     BERRY_REGISTER_EXTENSION_CLASS(UltrasoundCalibration, context)
       BERRY_REGISTER_EXTENSION_CLASS(USNavigationMarkerPlacement, context)
       BERRY_REGISTER_EXTENSION_CLASS(QmitkUSNavigationPerspective, context)
 
       // create a combined modality persitence object for loading and storing
       // combined modality objects persistently
       m_USCombinedModalityPersistence = mitk::USNavigationCombinedModalityPersistence::New();
   }
 
   void org_mbi_gui_qt_usnavigation_Activator::stop(ctkPluginContext* context)
   {
     m_USCombinedModalityPersistence = 0;
 
     m_Context = 0;
 
     Q_UNUSED(context)
   }
 
   ctkPluginContext *org_mbi_gui_qt_usnavigation_Activator::GetContext()
   {
     return m_Context;
   }
 }
 
 #if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
-Q_EXPORT_PLUGIN2(org_mbi_gui_qt_usnavigation, mitk::org_mbi_gui_qt_usnavigation_Activator)
+Q_EXPORT_PLUGIN2(org_mitk_gui_qt_igt_app_echotrack, mitk::org_mbi_gui_qt_usnavigation_Activator)
 #endif
 
 // necessary for us::GetModuleContext() in USNavigationCombinedModalityPersistence
 // (see: https://www.mail-archive.com/mitk-users@lists.sourceforge.net/msg04421.html)
 US_INITIALIZE_MODULE
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 87649fef28..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,574 +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)) {
+      return;
+    }
+  }
+  else{
+    if (!CheckInitialization()) { return; }
+  }
+
   UpdateManualToolTipCalibrationView();
   m_Controls.m_CalibrationMethodsWidget->setCurrentIndex(index);
   m_IndexCurrentCalibrationMethod = index;
 }
 
-void IGTNavigationToolCalibration::CreateQtPartControl( QWidget *parent )
+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(OnComutePivot()));
-  connect( m_Controls.m_UseComputedPivotPoint, SIGNAL(clicked()), this, SLOT(OnUseComutedPivotPoint()));
-  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_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_PivotPoses = std::vector<mitk::NavigationData::Pointer>();
-
   m_LoggedNavigationDataDifferences = std::vector< mitk::NavigationData::Pointer >();
 }
 
 
 void IGTNavigationToolCalibration::OnRunSingleRefToolCalibrationClicked()
 {
-    if (!CheckInitialization()) { return; }
+  if (!CheckInitialization()) { return; }
 
-    mitk::NavigationData::Pointer ToolTipTransform = mitk::NavigationData::New();
+  mitk::NavigationData::Pointer ToolTipTransform = mitk::NavigationData::New();
 
-    if (m_Controls.m_CalibratePosition->isChecked())
+  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++)
     {
-        //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);
+      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)));
 
-    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;
+    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;}
+  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;
+  MITK_INFO << "Collecting " << m_NumberOfNavigationData << " NavigationData ... " << endl;
 }
 
 void IGTNavigationToolCalibration::LoginSingleRefToolNavigationData()
 {
-  if (!CheckInitialization()) {return;}
+  if (!CheckInitialization()) { return; }
 
-  if(m_NumberOfNavigationDataCounter < m_NumberOfNavigationData)
+  if (m_NumberOfNavigationDataCounter < m_NumberOfNavigationData)
   {
-  //update label text
-  QString labelText = "Collecting Data: " + QString::number(m_NumberOfNavigationDataCounter);
-  m_Controls.m_CollectionStatus->setText(labelText);
+    //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);
+    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());
+    //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())
+    //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();
+      // 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++;
+    //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);
-     }
+  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()
 {
-  if (!CheckInitialization()) {return;}
-  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()));
+  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::OnComutePivot()
+void IGTNavigationToolCalibration::OnComputePivot()
 {
-  MITK_WARN << "Not implemented yet!";
-  /*
+
   mitk::PivotCalibration::Pointer myPivotCalibration = mitk::PivotCalibration::New();
-  for (int i=0; i<this->m_PivotPoses.size(); i++)
+  for (int i = 0; i < this->m_PivotPoses.size(); i++)
   {
     myPivotCalibration->AddNavigationData(m_PivotPoses.at(i));
   }
   QString resultString;
   if (myPivotCalibration->ComputePivotResult())
   {
-  //Get first marker transformation (TODO: compute for each pivot pose and average laster... this would be more accurate!)
-  mitk::NavigationData::Pointer markerTransformationTrackingCoordinates = m_PivotPoses.at(0);
-
-  //Get computed pivot transfromation in tool coordinates
-  mitk::NavigationData::Pointer pivotPointToolCoordinates = mitk::NavigationData::New();
-  pivotPointToolCoordinates->SetPosition(myPivotCalibration->GetResultPivotPoint());
-  pivotPointToolCoordinates->SetOrientation(myPivotCalibration->GetResultPivotRotation());
-  mitk::NavigationData::Pointer toolRotation = mitk::NavigationData::New();
-  toolRotation->SetOrientation(markerTransformationTrackingCoordinates->GetOrientation());
-  pivotPointToolCoordinates->Compose(toolRotation);
-
-  //Compute pivot point in relation to marker transformation for preview
-  mitk::NavigationData::Pointer pivotInTrackingCoordinates = mitk::NavigationData::New();
-  pivotInTrackingCoordinates->Compose(pivotPointToolCoordinates);
-  pivotInTrackingCoordinates->Compose(markerTransformationTrackingCoordinates);
-
-  //add the preview node to the data storage
-  ShowToolTipPreview(pivotInTrackingCoordinates);
-
-  //parse result string
-  resultString = QString("Pivot comutation 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 = pivotPointToolCoordinates;
-
-  //enable button to use the computed point with the tool
-  m_Controls.m_UseComputedPivotPoint->setEnabled(true);
+
+    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 comutation failed!";
+    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::OnUseComutedPivotPoint()
+void IGTNavigationToolCalibration::OnUseComputedPivotPoint()
 {
-  if (!CheckInitialization(false)) {return;}
   RemoveToolTipPreview();
   QString resultString = QString("Pivoted tool tip transformation was written to the tool ") + m_ToolToCalibrate->GetToolName().c_str();
-  ApplyToolTipTransform(m_ComputedToolTipTransformation,resultString.toStdString());
+  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;}
+  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());
-    }
+    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 red;
-  red.SetRed(1);
-  m_ToolTipPointPreview->SetColor(red);
+  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;}
+  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;
+  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());
+  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);
+  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
+  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)
+  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())
+  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)));
+      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)));
+      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_OnLoginSingleRefToolNavigationDataClicked) LoginSingleRefToolNavigationData();
+
+  if (m_OnAddPivotPoseClicked) AddPivotPose();
 
   // 1 == Single Reference Calibration Method
-  if(m_IndexCurrentCalibrationMethod == 1 ) UpdateOffsetCoordinates();
+  if (m_IndexCurrentCalibrationMethod == 1) UpdateOffsetCoordinates();
 
 }
 
 void IGTNavigationToolCalibration::AddLandmark()
 {
-  if (!CheckInitialization()) {return;}
+  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];
+  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) ;
+  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);
+  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;
+    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)
-      )
-   )
+  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;
+    QMessageBox msgBox;
+    msgBox.setText("Tool to calibrate and/or calibration pointer not initialized, cannot proceed!");
+    msgBox.exec();
+    return false;
   }
-else {return true;}
+  else { return true; }
 }
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/IGTNavigationToolCalibration.h b/Plugins/org.mitk.gui.qt.igttracking/src/internal/IGTNavigationToolCalibration.h
index f48ce2e133..ae582db713 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/IGTNavigationToolCalibration.h
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/IGTNavigationToolCalibration.h
@@ -1,127 +1,135 @@
 /*===================================================================
 
 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 IGTNavigationToolCalibration_h
 #define IGTNavigationToolCalibration_h
 
 #include <berryISelectionListener.h>
 
 #include <QmitkAbstractView.h>
 
 #include <mitkNavigationData.h>
 #include <QmitkNavigationToolCreationAdvancedWidget.h>
 
 #include "ui_IGTNavigationToolCalibrationControls.h"
 
+#include <mitkNavigationDataRecorder.h>
+
 //QT headers
 #include <QTimer>
 
 
 /*!
   \brief IGTNavigationToolCalibration
 
   \warning  This class is not yet documented. Use "git blame" and ask the author to provide basic documentation.
 
   \ingroup ${plugin_target}_internal
-*/
+  */
 class IGTNavigationToolCalibration : 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:
+public:
 
-    IGTNavigationToolCalibration();
+  IGTNavigationToolCalibration();
 
-    virtual ~IGTNavigationToolCalibration();
+  virtual ~IGTNavigationToolCalibration();
 
-    static const std::string VIEW_ID;
+  static const std::string VIEW_ID;
 
-    virtual void CreateQtPartControl(QWidget *parent);
+  virtual void CreateQtPartControl(QWidget *parent);
 
   protected slots:
 
-    void OnAddPivotPose();
-    void OnComutePivot();
-    void OnUseComutedPivotPoint();
-    void SetToolToCalibrate();
-    void SetCalibrationPointer();
-    void UpdateTrackingTimer();
-    void AddLandmark();
-    void SaveCalibratedTool();
-    void OnToolCalibrationMethodChanged(int index);
-    void OnStartManualToolTipCalibration();
-    void OnRetrieveDataForManualTooltipManipulation();
-    void OnProcessManualTooltipEditDialogCloseRequest();
-    void OnRunSingleRefToolCalibrationClicked();
-    void OnLoginSingleRefToolNavigationDataClicked();
-    void OnSetNewToolTipPosButtonClicked();
-
-
-  protected:
-
-    virtual void SetFocus();
-
-    void UpdateOffsetCoordinates();
-
-    int m_IndexCurrentCalibrationMethod;
-
-    Ui::IGTNavigationToolCalibrationControls m_Controls;
-
-    //some general members
-    mitk::NavigationTool::Pointer m_ToolToCalibrate; //<<< tool that will be calibrated
-    int m_IDToolToCalibrate; //<<< id of tool that will be calibrated (of the navigation data source)
-    mitk::NavigationDataSource::Pointer m_NavigationDataSourceOfToolToCalibrate; //<<< navigation data source of the tool that will be calibrated
-    mitk::NavigationDataSource::Pointer m_NavigationDataSourceOfCalibrationPointer; //<<< navigation data source of the calibration pointer
-    mitk::DataNode::Pointer m_ToolSurfaceInToolCoordinatesDataNode; //<<< holds the tool surface in tool coordinates (for preview purposes)
-    int m_IDCalibrationPointer; //<<< id of the calibration pointer (of the corresponding navigation data source)
-    QTimer* m_TrackingTimer; //<<< tracking timer that updates the status widgets
-    void ApplyToolTipTransform(mitk::NavigationData::Pointer ToolTipTransformInToolCoordinates, std::string message = "Tool was updated with the calibrated tool tip!"); //<<< applys the given tool tip transform to the tool to calibrate
-    bool CheckInitialization(bool CalibrationPointerRequired = true); //<<< checks if the tool to calibrate and (if required) the calibration pointer is initialized. Displays a warning and returns false if not.
-    mitk::NavigationData::Pointer m_ComputedToolTipTransformation; //<<< holds the new tooltip transformation after it was computed to write it into the tool later
-
-    // members and helper methods for pivot tool calibration
-    std::vector<mitk::NavigationData::Pointer> m_PivotPoses;
-
-    // members and helper methods for manual tool calibration
-    void UpdateManualToolTipCalibrationView();
-    QmitkNavigationToolCreationAdvancedWidget* m_ManualToolTipEditWidget;
-
-    // members and helper methods for single reference tool calibration
-    void LoginSingleRefToolNavigationData();
-    std::vector< mitk::Point3D > m_LoggedNavigationDataOffsets;
-    std::vector< mitk::NavigationData::Pointer > m_LoggedNavigationDataDifferences;
-    bool m_OnLoginSingleRefToolNavigationDataClicked;
-    int m_NumberOfNavigationData;
-    int m_NumberOfNavigationDataCounter;
-    mitk::Point3D m_ResultOffsetVector;
-
-    // members and helper methods for tool tip preview
-    mitk::DataNode::Pointer m_ToolTipPointPreview; //<<< Data node of the tool tip preview
-    void ShowToolTipPreview(mitk::NavigationData::Pointer ToolTipInTrackingCoordinates); //<<< Adds a preview of the tool tip into the data storage
-    void RemoveToolTipPreview(); //<<< Removes the preview
-
-    // members for the tool landmark calibration
-    mitk::PointSet::Pointer m_CalibrationLandmarks;
-    mitk::DataNode::Pointer m_CalibrationLandmarksNode;
-    mitk::PointSet::Pointer m_RegistrationLandmarks;
-    mitk::DataNode::Pointer m_RegistrationLandmarksNode;
+
+  void OnAddPivotPose();
+  void OnComputePivot();
+  void OnUseComputedPivotPoint();
+  void SetToolToCalibrate();
+  void SetCalibrationPointer();
+  void UpdateTrackingTimer();
+  void AddLandmark();
+  void SaveCalibratedTool();
+  void OnToolCalibrationMethodChanged(int index);
+  void OnStartManualToolTipCalibration();
+  void OnRetrieveDataForManualTooltipManipulation();
+  void OnProcessManualTooltipEditDialogCloseRequest();
+  void OnRunSingleRefToolCalibrationClicked();
+  void OnLoginSingleRefToolNavigationDataClicked();
+  void OnSetNewToolTipPosButtonClicked();
+
+
+protected:
+
+  virtual void SetFocus();
+
+  void UpdateOffsetCoordinates();
+
+  int m_IndexCurrentCalibrationMethod;
+
+  Ui::IGTNavigationToolCalibrationControls m_Controls;
+
+  //some general members
+  mitk::NavigationTool::Pointer m_ToolToCalibrate; //<<< tool that will be calibrated
+  int m_IDToolToCalibrate; //<<< id of tool that will be calibrated (of the navigation data source)
+  mitk::NavigationDataSource::Pointer m_NavigationDataSourceOfToolToCalibrate; //<<< navigation data source of the tool that will be calibrated
+  mitk::NavigationDataSource::Pointer m_NavigationDataSourceOfCalibrationPointer; //<<< navigation data source of the calibration pointer
+  mitk::DataNode::Pointer m_ToolSurfaceInToolCoordinatesDataNode; //<<< holds the tool surface in tool coordinates (for preview purposes)
+  int m_IDCalibrationPointer; //<<< id of the calibration pointer (of the corresponding navigation data source)
+  QTimer* m_TrackingTimer; //<<< tracking timer that updates the status widgets
+  void ApplyToolTipTransform(mitk::NavigationData::Pointer ToolTipTransformInToolCoordinates, std::string message = "Tool was updated with the calibrated tool tip!"); //<<< applys the given tool tip transform to the tool to calibrate
+  bool CheckInitialization(bool CalibrationPointerRequired = true); //<<< checks if the tool to calibrate and (if required) the calibration pointer is initialized. Displays a warning and returns false if not.
+  mitk::NavigationData::Pointer m_ComputedToolTipTransformation; //<<< holds the new tooltip transformation after it was computed to write it into the tool later
+
+  // members and helper methods for pivot tool calibration
+  std::vector<mitk::NavigationData::Pointer> m_PivotPoses;
+  void AddPivotPose();
+  void ClearOldPivot();
+  void UpdatePivotCount();
+  bool  m_OnAddPivotPoseClicked;
+  int PivotCount;
+
+  // members and helper methods for manual tool calibration
+  void UpdateManualToolTipCalibrationView();
+  QmitkNavigationToolCreationAdvancedWidget* m_ManualToolTipEditWidget;
+
+  // members and helper methods for single reference tool calibration
+  void LoginSingleRefToolNavigationData();
+  std::vector< mitk::Point3D > m_LoggedNavigationDataOffsets;
+  std::vector< mitk::NavigationData::Pointer > m_LoggedNavigationDataDifferences;
+  bool m_OnLoginSingleRefToolNavigationDataClicked;
+  int m_NumberOfNavigationData;
+  int m_NumberOfNavigationDataCounter;
+  mitk::Point3D m_ResultOffsetVector;
+
+  // members and helper methods for tool tip preview
+  mitk::DataNode::Pointer m_ToolTipPointPreview; //<<< Data node of the tool tip preview
+  void ShowToolTipPreview(mitk::NavigationData::Pointer ToolTipInTrackingCoordinates); //<<< Adds a preview of the tool tip into the data storage
+  void RemoveToolTipPreview(); //<<< Removes the preview
+
+  // members for the tool landmark calibration
+  mitk::PointSet::Pointer m_CalibrationLandmarks;
+  mitk::DataNode::Pointer m_CalibrationLandmarksNode;
+  mitk::PointSet::Pointer m_RegistrationLandmarks;
+  mitk::DataNode::Pointer m_RegistrationLandmarksNode;
 
 };
 
 #endif // IGTNavigationToolCalibration_h
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/IGTNavigationToolCalibrationControls.ui b/Plugins/org.mitk.gui.qt.igttracking/src/internal/IGTNavigationToolCalibrationControls.ui
index 99779e5f67..d4688a157a 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/IGTNavigationToolCalibrationControls.ui
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/IGTNavigationToolCalibrationControls.ui
@@ -1,976 +1,1004 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>IGTNavigationToolCalibrationControls</class>
  <widget class="QWidget" name="IGTNavigationToolCalibrationControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>430</width>
     <height>958</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">
      <property name="text">
       <string>&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.0//EN&quot; &quot;http://www.w3.org/TR/REC-html40/strict.dtd&quot;&gt;
 &lt;html&gt;&lt;head&gt;&lt;meta name=&quot;qrichtext&quot; content=&quot;1&quot; /&gt;&lt;style type=&quot;text/css&quot;&gt;
 p, li { white-space: pre-wrap; }
 &lt;/style&gt;&lt;/head&gt;&lt;body style=&quot; font-family:'MS Shell Dlg 2'; font-size:8.25pt; font-weight:400; font-style:normal;&quot;&gt;
 &lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-size:10pt; font-weight:600;&quot;&gt;Navigation Tool Calibration&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
      </property>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="groupBox">
      <property name="title">
       <string>Tool to calibrate</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_4">
       <item>
        <widget class="QmitkToolTrackingStatusWidget" name="m_StatusWidgetToolToCalibrate" native="true">
         <property name="minimumSize">
          <size>
           <width>0</width>
           <height>50</height>
          </size>
         </property>
         <property name="maximumSize">
          <size>
           <width>16777215</width>
           <height>50</height>
          </size>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QGroupBox" name="groupBox_2">
      <property name="title">
       <string>Calibration pointer</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout_5">
       <item>
        <widget class="QmitkToolTrackingStatusWidget" name="m_StatusWidgetCalibrationPointer" native="true">
         <property name="minimumSize">
          <size>
           <width>0</width>
           <height>30</height>
          </size>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item>
     <widget class="QTabWidget" name="tabWidget">
      <property name="enabled">
       <bool>true</bool>
      </property>
      <property name="currentIndex">
       <number>0</number>
      </property>
      <widget class="QWidget" name="tab">
       <attribute name="title">
        <string>Initialization</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout">
        <item>
         <widget class="QLabel" name="label_2">
          <property name="text">
           <string>&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.0//EN&quot; &quot;http://www.w3.org/TR/REC-html40/strict.dtd&quot;&gt;
 &lt;html&gt;&lt;head&gt;&lt;meta name=&quot;qrichtext&quot; content=&quot;1&quot; /&gt;&lt;style type=&quot;text/css&quot;&gt;
 p, li { white-space: pre-wrap; }
 &lt;/style&gt;&lt;/head&gt;&lt;body style=&quot; font-family:'MS Shell Dlg 2'; font-size:7.8pt; font-weight:400; font-style:normal;&quot;&gt;
 &lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-size:8pt; text-decoration: underline;&quot;&gt;Choose Tracking Device and Tools&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QmitkNavigationDataSourceSelectionWidget" name="m_SelectionWidget" native="true"/>
        </item>
        <item>
         <widget class="Line" name="line_5">
          <property name="orientation">
           <enum>Qt::Horizontal</enum>
          </property>
         </widget>
        </item>
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout_3">
          <item>
           <widget class="QLabel" name="label_4">
            <property name="minimumSize">
             <size>
              <width>120</width>
              <height>0</height>
             </size>
            </property>
            <property name="text">
             <string>Tool to Calibrate:</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>
          <item>
           <widget class="QLabel" name="m_CalToolLabel">
            <property name="text">
             <string>&lt;none&gt;</string>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout">
          <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="QPushButton" name="m_SetToolToCalibrate">
            <property name="minimumSize">
             <size>
              <width>150</width>
              <height>0</height>
             </size>
            </property>
            <property name="text">
             <string>Use as Tool to Calibrate</string>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item>
         <widget class="Line" name="line_6">
          <property name="orientation">
           <enum>Qt::Horizontal</enum>
          </property>
         </widget>
        </item>
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout_11">
          <item>
           <widget class="QLabel" name="label_5">
            <property name="minimumSize">
             <size>
              <width>120</width>
              <height>0</height>
             </size>
            </property>
            <property name="text">
             <string>Calibration Pointer:</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="QLabel" name="m_PointerLabel">
            <property name="text">
             <string>&lt;none&gt;</string>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout_2">
          <item>
           <spacer name="horizontalSpacer_10">
            <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_SetPointer">
            <property name="minimumSize">
             <size>
              <width>150</width>
              <height>0</height>
             </size>
            </property>
            <property name="text">
             <string> Use as Calibration Pointer</string>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item>
         <widget class="Line" name="line_7">
          <property name="orientation">
           <enum>Qt::Horizontal</enum>
          </property>
         </widget>
        </item>
        <item>
         <spacer name="verticalSpacer">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>586</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="tab_3">
       <attribute name="title">
        <string>Tool Tip Calibration</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout_10">
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout_9">
          <item>
           <widget class="QLabel" name="label_8">
            <property name="font">
             <font>
              <weight>50</weight>
              <bold>false</bold>
             </font>
            </property>
            <property name="text">
             <string>Calibration Method:</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="QComboBox" name="m_CalibrationMethodComboBox">
            <item>
             <property name="text">
              <string>Manual</string>
             </property>
            </item>
            <item>
             <property name="text">
              <string>Single Reference Tool</string>
             </property>
            </item>
            <item>
             <property name="text">
              <string>Multiple Tools Reference</string>
             </property>
            </item>
            <item>
             <property name="text">
              <string>Pivoting</string>
             </property>
            </item>
           </widget>
          </item>
         </layout>
        </item>
        <item>
         <widget class="Line" name="line">
          <property name="orientation">
           <enum>Qt::Horizontal</enum>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QStackedWidget" name="m_CalibrationMethodsWidget">
          <property name="currentIndex">
           <number>0</number>
          </property>
          <widget class="QWidget" name="page_4">
           <layout class="QVBoxLayout" name="verticalLayout_11">
            <item>
             <widget class="QLabel" name="label_9">
              <property name="text">
               <string>Current Tool Tip Translation:</string>
              </property>
             </widget>
            </item>
            <item>
             <widget class="QLineEdit" name="m_ManualCurrentTranslation">
              <property name="enabled">
               <bool>true</bool>
              </property>
              <property name="readOnly">
               <bool>true</bool>
              </property>
             </widget>
            </item>
            <item>
             <widget class="QLabel" name="label_10">
              <property name="text">
               <string>Current Tool Tip Orientation:</string>
              </property>
             </widget>
            </item>
            <item>
             <widget class="QPlainTextEdit" name="m_ManualCurrentOrientation">
              <property name="enabled">
               <bool>true</bool>
              </property>
              <property name="readOnly">
               <bool>true</bool>
              </property>
             </widget>
            </item>
            <item>
             <layout class="QHBoxLayout" name="horizontalLayout_4">
              <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_StartEditTooltipManually">
                <property name="text">
                 <string>Start Edit Tooltip</string>
                </property>
               </widget>
              </item>
             </layout>
            </item>
           </layout>
          </widget>
          <widget class="QWidget" name="page_6">
           <layout class="QVBoxLayout" name="verticalLayout_12">
            <item>
             <widget class="QFrame" name="frameExample">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Maximum" vsizetype="Maximum">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="minimumSize">
               <size>
                <width>319</width>
                <height>160</height>
               </size>
              </property>
              <property name="maximumSize">
               <size>
                <width>319</width>
                <height>160</height>
               </size>
              </property>
              <property name="styleSheet">
               <string notr="true">
                      QFrame {
                      border-image: url(:/IGTNavigationToolCalibration/Description.svg);
                      }
                    </string>
              </property>
              <property name="frameShape">
               <enum>QFrame::Box</enum>
              </property>
              <property name="frameShadow">
               <enum>QFrame::Plain</enum>
              </property>
              <property name="lineWidth">
               <number>1</number>
              </property>
             </widget>
            </item>
            <item>
             <widget class="QLabel" name="label_12">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="text">
               <string>Current Offset between Tool to calibrate and Calibration pointer:</string>
              </property>
             </widget>
            </item>
            <item>
             <layout class="QHBoxLayout" name="horizontalLayout_12">
              <item>
               <widget class="QLabel" name="label_3">
                <property name="text">
                 <string>Pos:</string>
                </property>
               </widget>
              </item>
              <item>
               <widget class="QLineEdit" name="m_OffsetCoordinates">
                <property name="font">
                 <font>
                  <pointsize>8</pointsize>
                 </font>
                </property>
                <property name="text">
                 <string/>
                </property>
                <property name="alignment">
                 <set>Qt::AlignCenter</set>
                </property>
               </widget>
              </item>
             </layout>
            </item>
            <item>
             <layout class="QHBoxLayout" name="horizontalLayout_13">
              <item>
               <widget class="QLabel" name="label_14">
                <property name="text">
                 <string>Rot:</string>
                </property>
               </widget>
              </item>
              <item>
               <widget class="QLineEdit" name="m_OrientationOffsetCoordinates">
                <property name="font">
                 <font>
                  <pointsize>8</pointsize>
                 </font>
                </property>
                <property name="text">
                 <string/>
                </property>
                <property name="alignment">
                 <set>Qt::AlignCenter</set>
                </property>
               </widget>
              </item>
             </layout>
            </item>
            <item>
             <widget class="Line" name="line_2">
              <property name="orientation">
               <enum>Qt::Horizontal</enum>
              </property>
             </widget>
            </item>
            <item>
             <layout class="QHBoxLayout" name="horizontalLayout_6">
              <item>
               <widget class="QLabel" name="label_11">
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
                  <horstretch>0</horstretch>
                  <verstretch>0</verstretch>
                 </sizepolicy>
                </property>
                <property name="text">
                 <string>Number of tracking data to collect:</string>
                </property>
               </widget>
              </item>
              <item>
               <widget class="QSpinBox" name="m_NumberOfNavigationDataToCollect">
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                  <horstretch>0</horstretch>
                  <verstretch>0</verstretch>
                 </sizepolicy>
                </property>
                <property name="maximum">
                 <number>10000</number>
                </property>
                <property name="value">
                 <number>100</number>
                </property>
               </widget>
              </item>
             </layout>
            </item>
            <item>
             <widget class="QLabel" name="m_CollectionStatus">
              <property name="text">
               <string/>
              </property>
              <property name="alignment">
               <set>Qt::AlignCenter</set>
              </property>
             </widget>
            </item>
            <item>
             <widget class="QPushButton" name="m_CollectNavigationDataButton">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="text">
               <string>1: Collect Navigation Data</string>
              </property>
             </widget>
            </item>
            <item>
             <widget class="Line" name="line_3">
              <property name="orientation">
               <enum>Qt::Horizontal</enum>
              </property>
             </widget>
            </item>
            <item>
             <widget class="QCheckBox" name="m_InvertQuaternions">
              <property name="text">
               <string>Invert calibration transformation</string>
              </property>
             </widget>
            </item>
            <item>
             <layout class="QHBoxLayout" name="horizontalLayout_16">
              <item>
               <widget class="QCheckBox" name="m_CalibratePosition">
                <property name="text">
                 <string>Calibrate position</string>
                </property>
                <property name="checked">
                 <bool>true</bool>
                </property>
               </widget>
              </item>
              <item>
               <widget class="QCheckBox" name="m_CalibrateOrientation">
                <property name="text">
                 <string>Calibrate orientation</string>
                </property>
                <property name="checked">
                 <bool>true</bool>
                </property>
               </widget>
              </item>
             </layout>
            </item>
            <item>
             <widget class="QPushButton" name="m_RunCalibrationButton">
              <property name="enabled">
               <bool>false</bool>
              </property>
              <property name="text">
               <string>2: Run Calibration</string>
              </property>
             </widget>
            </item>
            <item>
             <widget class="Line" name="line_4">
              <property name="orientation">
               <enum>Qt::Horizontal</enum>
              </property>
             </widget>
            </item>
            <item>
             <widget class="QLabel" name="label_13">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="text">
               <string>New Tool Tip Position and/or Orientation of Tool to calibrate:</string>
              </property>
             </widget>
            </item>
            <item>
             <layout class="QHBoxLayout" name="horizontalLayout_14">
              <item>
               <widget class="QLabel" name="label_15">
                <property name="text">
                 <string>Pos:</string>
                </property>
               </widget>
              </item>
              <item>
               <widget class="QLineEdit" name="m_ResultOfCalibration">
                <property name="font">
                 <font>
                  <pointsize>8</pointsize>
                 </font>
                </property>
                <property name="alignment">
                 <set>Qt::AlignCenter</set>
                </property>
               </widget>
              </item>
             </layout>
            </item>
            <item>
             <layout class="QHBoxLayout" name="horizontalLayout_15">
              <item>
               <widget class="QLabel" name="label_16">
                <property name="text">
                 <string>Rot:</string>
                </property>
               </widget>
              </item>
              <item>
               <widget class="QLineEdit" name="m_ResultOfCalibrationOrientation">
                <property name="font">
                 <font>
                  <pointsize>8</pointsize>
                 </font>
                </property>
                <property name="alignment">
                 <set>Qt::AlignCenter</set>
                </property>
               </widget>
              </item>
             </layout>
            </item>
            <item>
             <widget class="QPushButton" name="m_SetNewToolTipPosButton">
              <property name="enabled">
               <bool>false</bool>
              </property>
              <property name="text">
               <string>3: Set New Tool Tip Position and/or Tool Orientation</string>
              </property>
             </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>
          <widget class="QWidget" name="page_5"/>
          <widget class="QWidget" name="page">
           <layout class="QVBoxLayout" name="verticalLayout_9">
+           <item>
+            <layout class="QHBoxLayout" name="horizontalLayout_17">
+             <item>
+              <widget class="QLabel" name="label_17">
+               <property name="text">
+                <string>Number of pivot poses to collect:</string>
+               </property>
+              </widget>
+             </item>
+             <item>
+              <widget class="QSpinBox" name="m_PosesToCollect">
+               <property name="minimum">
+                <number>10</number>
+               </property>
+               <property name="maximum">
+                <number>1000</number>
+               </property>
+               <property name="value">
+                <number>100</number>
+               </property>
+              </widget>
+             </item>
+            </layout>
+           </item>
            <item>
             <layout class="QHBoxLayout" name="horizontalLayout_7">
              <item>
               <widget class="QLabel" name="label_7">
                <property name="text">
                 <string>Number of saved poses:</string>
                </property>
               </widget>
              </item>
              <item>
               <widget class="QLabel" name="m_PoseNumber">
                <property name="text">
                 <string>0</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="QPushButton" name="m_AddPivotPose">
                <property name="text">
-                <string>Add Current Pose</string>
+                <string>Collect Pivot Poses</string>
                </property>
               </widget>
              </item>
             </layout>
            </item>
            <item>
             <widget class="QGroupBox" name="groupBox_5">
              <property name="title">
               <string>Calibration Result:</string>
              </property>
              <layout class="QVBoxLayout" name="verticalLayout_8">
               <item>
                <widget class="QTextEdit" name="m_ResultText"/>
               </item>
              </layout>
             </widget>
            </item>
            <item>
             <layout class="QHBoxLayout" name="horizontalLayout_8">
              <item>
               <spacer name="horizontalSpacer_7">
                <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_ComputePivot">
                <property name="minimumSize">
                 <size>
                  <width>175</width>
                  <height>0</height>
                 </size>
                </property>
                <property name="text">
-                <string>Comute Pivot Point</string>
+                <string>Compute Pivot Point</string>
                </property>
               </widget>
              </item>
             </layout>
            </item>
            <item>
             <layout class="QHBoxLayout" name="horizontalLayout_10">
              <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="QPushButton" name="m_UseComputedPivotPoint">
                <property name="enabled">
                 <bool>false</bool>
                </property>
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
                  <horstretch>0</horstretch>
                  <verstretch>0</verstretch>
                 </sizepolicy>
                </property>
                <property name="minimumSize">
                 <size>
                  <width>175</width>
                  <height>0</height>
                 </size>
                </property>
                <property name="text">
                 <string>Use Computed Pivot Point</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>99</height>
               </size>
              </property>
             </spacer>
            </item>
           </layout>
          </widget>
         </widget>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="tab_2">
       <attribute name="title">
        <string>Tool Landmark Calibration</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout_3">
        <item>
         <widget class="QLabel" name="label_6">
          <property name="text">
           <string>&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.0//EN&quot; &quot;http://www.w3.org/TR/REC-html40/strict.dtd&quot;&gt;
 &lt;html&gt;&lt;head&gt;&lt;meta name=&quot;qrichtext&quot; content=&quot;1&quot; /&gt;&lt;style type=&quot;text/css&quot;&gt;
 p, li { white-space: pre-wrap; }
 &lt;/style&gt;&lt;/head&gt;&lt;body style=&quot; font-family:'MS Shell Dlg 2'; font-size:7.8pt; font-weight:400; font-style:normal;&quot;&gt;
 &lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-size:8pt; text-decoration: underline;&quot;&gt;Calibrate tool by marking the landmarks with the pointer&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QGroupBox" name="groupBox_3">
          <property name="title">
           <string>Registration Landmarks</string>
          </property>
          <layout class="QVBoxLayout" name="verticalLayout_6">
           <item>
            <widget class="QmitkPointListWidget" name="m_RegistrationLandmarkWidget" native="true">
             <property name="minimumSize">
              <size>
               <width>0</width>
               <height>170</height>
              </size>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QPushButton" name="m_AddLandmark">
             <property name="text">
              <string>Add Pointer Position</string>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <widget class="QGroupBox" name="groupBox_4">
          <property name="title">
           <string>Calibration Landmarks</string>
          </property>
          <layout class="QVBoxLayout" name="verticalLayout_7">
           <item>
            <widget class="QmitkPointListWidget" name="m_CalibrationLandmarkWidget" native="true"/>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <spacer name="verticalSpacer_2">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>259</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
     </widget>
    </item>
    <item>
     <layout class="QHBoxLayout" name="horizontalLayout_5">
      <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="QPushButton" name="m_SaveCalibratedTool">
        <property name="text">
         <string>Save Calibrated Navigation Tool</string>
        </property>
       </widget>
      </item>
     </layout>
    </item>
   </layout>
+  <zorder>tabWidget</zorder>
+  <zorder>label</zorder>
+  <zorder>groupBox</zorder>
+  <zorder>groupBox_2</zorder>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <customwidgets>
   <customwidget>
    <class>QmitkNavigationDataSourceSelectionWidget</class>
    <extends>QWidget</extends>
    <header>QmitkNavigationDataSourceSelectionWidget.h</header>
    <container>1</container>
   </customwidget>
   <customwidget>
    <class>QmitkToolTrackingStatusWidget</class>
    <extends>QWidget</extends>
    <header>QmitkToolTrackingStatusWidget.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/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
index 6b4cf9749a..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,1518 +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 <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_AutoDetectTools->setVisible(true);
-    m_Controls->m_AddSingleTool->setEnabled(false);
-  }
-  else //Polaris or Microntracker
-  {
-    m_Controls->m_AutoDetectTools->setVisible(false);
-    m_Controls->m_AddSingleTool->setEnabled(true);
-  }
+    { 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()->GetType() == mitk::NDIAuroraTypeInformation::GetTrackingDeviceName())
+  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);
-    MITK_INFO << "Timeout Timer started";
     //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();
 
-  if (m_toolStorage->GetToolCount() > 0)
-  {
-    //ask the user if he wants to save the detected tools
-    QMessageBox msgBox;
-    switch (m_toolStorage->GetToolCount())
-    {
-    case 1:
-      msgBox.setText("Found one tool!");
-      break;
-    default:
-      msgBox.setText("Found " + QString::number(m_toolStorage->GetToolCount()) + " tools!");
-    }
-    msgBox.setInformativeText("Do you want to save this tools as tool storage, so you can load them again?");
-    msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
-    msgBox.setDefaultButton(QMessageBox::No);
-    int ret = msgBox.exec();
-
-    if (ret == 16384) //yes
-    {
-      //ask the user for a filename
-      QString fileName = QFileDialog::getSaveFileName(nullptr, tr("Save File"), "/", tr("*.IGTToolStorage"));
-      //check for empty filename
-      if (fileName == "") { return; }
-      mitk::NavigationToolStorageSerializer::Pointer mySerializer = mitk::NavigationToolStorageSerializer::New();
-
-      //when Serialize method is used exceptions are thrown, need to be adapted
-      //try-catch block for exception handling in Serializer
-      try
-      {
-        mySerializer->Serialize(fileName.toStdString(), m_toolStorage);
-      }
-      catch (mitk::IGTException)
-      {
-        std::string errormessage = "Error during serialization. Please check the Zip file.";
-        QMessageBox::warning(nullptr, "IGTPlayer: Error", errormessage.c_str());
-      }
-
-      return;
-    }
-    else if (ret == 65536) //no
-    {
-      return;
-    }
-  }
   //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()
 {
-  MITK_INFO << "Time Out";
   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(4);
+  //mitk::ProgressBar::GetInstance()->AddStepsToDo(2);
   mitk::NavigationToolStorage::Pointer autoDetectedStorage = mitk::NavigationToolStorage::New(m_DataStorage);
-  mitk::NDITrackingDevice::Pointer currentDevice = dynamic_cast<mitk::NDITrackingDevice*>(m_TrackingDevice.GetPointer());
   try
   {
-    currentDevice->OpenConnection();
-    mitk::ProgressBar::GetInstance()->Progress();
-    currentDevice->StartTracking();
+    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)
   {
-    QString message = QString("Warning, can not auto-detect tools! (") + QString(e.GetDescription()) + QString(")");
-    //MessageBox(message.toStdString()); //TODO: give message to the user here!
-
-    MITK_WARN << message.toStdString();
-    mitk::ProgressBar::GetInstance()->Progress(4);
-    emit AutoDetectToolsFinished(false, message.toStdString().c_str());
+    MITK_WARN << e.GetDescription();
+    //mitk::ProgressBar::GetInstance()->Reset();
+    emit AutoDetectToolsFinished(false, e.GetDescription());
     return;
   }
-
-  for (unsigned int i = 0; i < currentDevice->GetToolCount(); i++)
-  {
-    //create a navigation tool with sphere as surface
-    std::stringstream toolname;
-    toolname << "AutoDetectedTool" << i;
-    mitk::NavigationTool::Pointer newTool = mitk::NavigationTool::New();
-    newTool->SetSerialNumber(dynamic_cast<mitk::NDIPassiveTool*>(currentDevice->GetTool(i))->GetSerialNumber());
-    newTool->SetIdentifier(toolname.str());
-    newTool->SetTrackingDeviceType(mitk::NDIAuroraTypeInformation::GetTrackingDeviceName());
-    mitk::DataNode::Pointer newNode = mitk::DataNode::New();
-    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();
-    newNode->SetData(mySphere);
-    newNode->SetName(toolname.str());
-    newTool->SetDataNode(newNode);
-    autoDetectedStorage->AddTool(newTool);
-  }
-
   m_NavigationToolStorage = autoDetectedStorage;
-
-  currentDevice->StopTracking();
-  mitk::ProgressBar::GetInstance()->Progress();
-  currentDevice->CloseConnection();
-
+  //::ProgressBar::GetInstance()->Progress();
   emit AutoDetectToolsFinished(true, "");
-  mitk::ProgressBar::GetInstance()->Progress(4);
 }
 
 void QmitkMITKIGTTrackingToolboxViewWorker::ConnectDevice()
 {
   std::string message = "";
-  mitk::ProgressBar::GetInstance()->AddStepsToDo(10);
+  //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();
+  //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();
+  //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();
+  //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();
+  //mitk::ProgressBar::GetInstance()->Progress();
 
   //connect to device
   try
   {
     m_TrackingDeviceSource->Connect();
-    mitk::ProgressBar::GetInstance()->Progress();
+    //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()->Progress(10);
+  //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/QmitkMITKIGTTrackingToolboxView.h b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.h
index 51920c02c2..318db6d8cd 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.h
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.h
@@ -1,303 +1,305 @@
 /*===================================================================
 
 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 QmitkMITKIGTTrackingToolboxView_h
 #define QmitkMITKIGTTrackingToolboxView_h
 
 #include <berryISelectionListener.h>
 #include <ctkServiceReference.h>
 
 #include <QmitkAbstractView.h>
 
 #include "ui_QmitkMITKIGTTrackingToolboxViewControls.h"
 
 //mitk headers
 #include <mitkNavigationToolStorage.h>
 #include <mitkTrackingDeviceSource.h>
 #include <mitkNavigationDataObjectVisualizationFilter.h>
 #include <mitkNavigationDataRecorder.h>
 #include <mitkNavigationDataToIGTLMessageFilter.h>
 #include <mitkIGTLServer.h>
 #include <mitkIGTLMessageProvider.h>
 
 //QT headers
 #include <QTimer>
 
 class QmitkMITKIGTTrackingToolboxViewWorker;
 
 /*!
   \brief QmitkMITKIGTTrackingToolboxView
 
    This is the view of the bundle IGT Tracking Toolbox. The IGT Tracking Toolbox can be used to access tracking devices with MITK-IGT. The Tracking Toolbox can be used to log tracking data in     XML or CSV format for measurement purposes. The Tracking Toolbox further allows for visualization of tools with given surfaces in combination with the NaviagtionToolManager.
 */
 class QmitkMITKIGTTrackingToolboxView : 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;
 
     QmitkMITKIGTTrackingToolboxView();
     virtual ~QmitkMITKIGTTrackingToolboxView();
 
     virtual void CreateQtPartControl(QWidget *parent) override;
 
     ///
     /// Sets the focus to an internal widget.
     ///
     virtual void SetFocus() override;
 
   protected slots:
 
     /** @brief changes name of the filename when switching fileextension by radio button */
     void OnToggleFileExtension();
     /** @brief This slot is called if the user wants to load a new tool file. A new window opens where the user can choose a file. If the chosen file is
                corrupt or not valid the user gets an error message. If the file was loaded successfully the tools are show in the tool status widget. */
     void OnLoadTools();
 
     /** Starts tracking if tracking is stopped / stops tracking if tracking is started. */
     void OnStartStopTracking();
 
     /** Connects the device if it is disconnected / disconnects the device if it is connected. */
     void OnConnectDisconnect();
 
     /** Freezes the device if it is not frozen / unfreezes the device if it is frozen. */
     void OnFreezeUnfreezeTracking();
 
     /** @brief This slot connects to the device. In status "connected" configuration of the device is disabled. */
     void OnConnect();
 
     /** @brief This slot disconnects from the device. */
     void OnDisconnect();
 
     /** @brief This slot tries to start tracking with the current device. If start tracking fails the user gets an error message and tracking stays off.*/
     void OnStartTracking();
 
     /** @brief This slot stops tracking. If tracking is not strated it does nothing.*/
     void OnStopTracking();
 
     /** @brief This slot is called if the user want's to choose a file name for logging. A new windows to navigate through the file system and choose
                a file opens.*/
     void OnChooseFileClicked();
 
     /** @brief This slot starts logging. Logging is only possible if a device is tracking. If not the logging mechanism start when the start tracking
                is called.*/
     void StartLogging();
 
     /** @brief This slot stops logging. If logging is not running it does nothing.*/
     void StopLogging();
 
     /** @brief This slot enables / disables UI elements depending on the tracking device after a device is changed.*/
     void OnTrackingDeviceChanged();
 
     /** @brief This slot selects the Tracking Volume appropriate for a given model */
     void OnTrackingVolumeChanged(QString qstr);
 
     /** @brief Shows or hides the tracking volume according to the checkboxe's state */
     void OnShowTrackingVolumeChanged();
 
     /** @brief This slot auto detects tools of a NDI Aurora tracking device. If tools where found they will be stored internally as a tool storage.
         The user is also asked if he wants to save this tool storage to load it later. Only call it if a Aurora device was configured because other
         devices don't support auto detection.*/
     void OnAutoDetectTools();
 
     /** @brief Slot for tracking timer. The timer updates the IGT pipline and also the logging filter if logging is activated.*/
     void UpdateRenderTrackingTimer();
     void UpdateLoggingTrackingTimer();
 
     /** @brief Slot for showing the rendering disabled warning label*/
     void OnChangeRenderUpdateRate();
 
     /** @brief Resets the Tracking Tools: this means all tools are removed. */
     void OnResetTools();
 
     /** @brief Opens a dialog where a new navigation tool can be created. */
     void OnAddSingleTool();
 
     /** @brief This slot is called if the user finishes the creation of a new tool. */
     void OnAddSingleToolFinished();
 
     /** @brief This slot is called if the user cancels the creation of a new tool. */
     void OnAddSingleToolCanceled();
 
     void OnTimeOut();
 
   protected slots:
 
    //help slots for enable/disable buttons
    void DisableLoggingButtons();
    void EnableLoggingButtons();
    void DisableOptionsButtons();
    void EnableOptionsButtons();
    void EnableTrackingConfigurationButtons();
    void DisableTrackingConfigurationButtons();
    void EnableTrackingControls();
    void DisableTrackingControls();
    void EnableDisableTimerButtons(int enable);
-
+   void OnToggleAdvancedSimpleMode();
    void OnToggleDifferentUpdateRates();
 
    //slots for worker thread
    void OnAutoDetectToolsFinished(bool success, QString errorMessage);
    void OnConnectFinished(bool success, QString errorMessage);
    void OnStartTrackingFinished(bool success, QString errorMessage);
    void OnStopTrackingFinished(bool success, QString errorMessage);
    void OnDisconnectFinished(bool success, QString errorMessage);
 
   protected:
 
     Ui::QmitkMITKIGTTrackingToolboxViewControls* m_Controls;
 
     bool m_tracking;    ///> bool which is true if tracking is running, false if not
     bool m_connected;   ///> bool that is true when a tracking device is connected
     bool m_logging;     ///> bool which is true if logging is running, false if not
     int m_loggedFrames; ///> stores the current number of logged frames if logging is on
 
     mitk::NavigationToolStorage::Pointer m_toolStorage;  ///>stores the loaded tools
     mitk::DataNode::Pointer m_TrackingVolumeNode;        ///>holds the data node of the tracking volume if volume is visualized
     bool lastTrackingVolumeState;                        ///>temporary holds the state of the tracking volume (activated/not activated) during some methods
 
     QString m_ToolStorageFilename; ///>stores the filename of the current tool storage
     QString m_AutoSaveFilename; ///>a filename for auto saving tools if no m_ToolStorageFilename was given by the user
 
     /** @brief Shows a message box with the text given as parameter. */
     void MessageBox(std::string s);
 
     /** @brief reinits the view globally. */
     void GlobalReinit();
 
    //members for the filter pipeline
    mitk::TrackingDeviceSource::Pointer m_TrackingDeviceSource; ///> member for the source of the IGT pipeline
    mitk::TrackingDeviceData m_TrackingDeviceData; ///> stores the tracking device data as long as this is not handled by the tracking device configuration widget
    mitk::NavigationDataObjectVisualizationFilter::Pointer m_ToolVisualizationFilter; ///> holds the tool visualization filter (second filter of the IGT pipeline)
    mitk::NavigationDataRecorder::Pointer m_loggingFilter; ///> holds the logging filter if logging is on (third filter of the IGT pipeline)
 
    //members for open IGT link server
    mitk::NavigationDataToIGTLMessageFilter::Pointer m_IGTLConversionFilter; ///> Converts the navigation data as open IGT link message and makes this filter available as microservice
    mitk::IGTLServer::Pointer m_IGTLServer;
    mitk::IGTLMessageProvider::Pointer m_IGTLMessageProvider;
 
    /** @brief This timer updates the IGT pipline and also the logging filter if logging is activated.*/
    QTimer* m_TrackingRenderTimer;
    QTimer* m_TrackingLoggingTimer;
    QTimer* m_TimeoutTimer;
 
+   bool m_SimpleModeEnabled; ///>Stores if simple UI mode is enabled
+
    /** Replaces the current navigation tool storage which is stored in m_toolStorage.
     *  Basically handles the microservice stuff: unregisteres the old storage, then
     *  replaces the storage and registers the new one.
     */
    void ReplaceCurrentToolStorage(mitk::NavigationToolStorage::Pointer newStorage, std::string newStorageName);
 
    /**
     * \brief Stores the properties of some QWidgets (and the tool storage file name) to QSettings.
     */
    void StoreUISettings();
 
    /**
     * \brief Loads the properties of some QWidgets (and the tool storage file name) from QSettings.
     */
    void LoadUISettings();
    /**
     * Help method for updating the tool label
     */
    void UpdateToolStorageLabel(QString pathOfLoadedStorage);
    /**
     * Auto saves the current tool storage to a temporary file. This ist used for persistence.
   */
    void AutoSaveToolStorage();
 
    //members for worker thread
    QThread* m_WorkerThread;
    QmitkMITKIGTTrackingToolboxViewWorker* m_Worker;
 
   private:
    ctkServiceReference m_DeviceTypeServiceReference;
    mitk::TrackingDeviceTypeCollection* m_DeviceTypeCollection;
 };
 
 
 /**
  * Worker thread class for this view.
  */
 class QmitkMITKIGTTrackingToolboxViewWorker : public QObject
 {
   Q_OBJECT
 
 public:
   enum WorkerMethod{
     eAutoDetectTools = 0,
     eConnectDevice = 1,
     eStartTracking = 2,
     eStopTracking = 3,
     eDisconnectDevice = 4
   };
 
   void SetWorkerMethod(WorkerMethod w);
   void SetTrackingDevice(mitk::TrackingDevice::Pointer t);
   void SetDataStorage(mitk::DataStorage::Pointer d);
   void SetInverseMode(bool mode);
   void SetTrackingDeviceData(mitk::TrackingDeviceData d);
   void SetNavigationToolStorage(mitk::NavigationToolStorage::Pointer n);
 
   itkGetMacro(NavigationToolStorage,mitk::NavigationToolStorage::Pointer);
 
   itkGetMacro(TrackingDeviceSource,mitk::TrackingDeviceSource::Pointer);
   itkGetMacro(TrackingDeviceData,mitk::TrackingDeviceData);
   itkGetMacro(ToolVisualizationFilter,mitk::NavigationDataObjectVisualizationFilter::Pointer);
 
   public slots:
     void ThreadFunc();
 
   signals:
     void AutoDetectToolsFinished(bool success, QString errorMessage);
     void ConnectDeviceFinished(bool success, QString errorMessage);
     void StartTrackingFinished(bool success, QString errorMessage);
     void StopTrackingFinished(bool success, QString errorMessage);
     void DisconnectDeviceFinished(bool success, QString errorMessage);
 
 
   protected:
 
     mitk::TrackingDevice::Pointer m_TrackingDevice;
     WorkerMethod m_WorkerMethod;
     mitk::DataStorage::Pointer m_DataStorage;
     mitk::NavigationToolStorage::Pointer m_NavigationToolStorage;
 
     //members for the filter pipeline which is created in the worker thread during ConnectDevice()
     mitk::TrackingDeviceSource::Pointer m_TrackingDeviceSource; ///> member for the source of the IGT pipeline
     mitk::TrackingDeviceData m_TrackingDeviceData; ///> stores the tracking device data as long as this is not handled by the tracking device configuration widget
     mitk::NavigationDataObjectVisualizationFilter::Pointer m_ToolVisualizationFilter; ///> holds the tool visualization filter (second filter of the IGT pipeline)
 
     //members some internal flags
     bool m_InverseMode;     //flag that is true when the inverse mode is enabled
 
     //stores the original colors of the tracking tools
     std::map<mitk::DataNode::Pointer,mitk::Color> m_OriginalColors;
 
     //internal methods
     void AutoDetectTools();
     void ConnectDevice();
     void StartTracking();
     void StopTracking();
     void DisconnectDevice();
 };
 
 
 
 #endif // _QMITKMITKIGTTRACKINGTOOLBOXVIEW_H_INCLUDED
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 ecad7c0c5b..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,805 +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>1009</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>&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.0//EN&quot; &quot;http://www.w3.org/TR/REC-html40/strict.dtd&quot;&gt;
 &lt;html&gt;&lt;head&gt;&lt;meta name=&quot;qrichtext&quot; content=&quot;1&quot; /&gt;&lt;style type=&quot;text/css&quot;&gt;
 p, li { white-space: pre-wrap; }
 &lt;/style&gt;&lt;/head&gt;&lt;body style=&quot; font-family:'MS Shell Dlg 2'; font-size:7.8pt; font-weight:400; font-style:normal;&quot;&gt;
 &lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-size:10pt; font-weight:600;&quot;&gt;Tracking Tools&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</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>&lt;none&gt;</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>&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.0//EN&quot; &quot;http://www.w3.org/TR/REC-html40/strict.dtd&quot;&gt;
 &lt;html&gt;&lt;head&gt;&lt;meta name=&quot;qrichtext&quot; content=&quot;1&quot; /&gt;&lt;style type=&quot;text/css&quot;&gt;
 p, li { white-space: pre-wrap; }
 &lt;/style&gt;&lt;/head&gt;&lt;body style=&quot; font-family:'MS Shell Dlg 2'; font-size:7.8pt; font-weight:400; font-style:normal;&quot;&gt;
 &lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-size:10pt; font-weight:600;&quot;&gt;Tracking Control&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</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>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; color:#ff0000;&quot;&gt;Tracking Frozen!&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</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>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p align=&quot;right&quot;&gt;&lt;span style=&quot; color:#ff0000;&quot;&gt;Rendering Disabled!&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</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="groupBox_2">
+         <property name="title">
+          <string>Open IGT Link</string>
+         </property>
+         <layout class="QVBoxLayout" name="verticalLayout_15">
+          <item>
+           <widget class="QCheckBox" name="m_EnableOpenIGTLinkMicroService">
+            <property name="text">
+             <string>Enable Open IGT Link MicroService</string>
+            </property>
+            <property name="checked">
+             <bool>true</bool>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QLabel" name="label_7">
+            <property name="text">
+             <string>Select Open IGT Link Data Format:</string>
+            </property>
+           </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_EnableOpenIGTLinkMicroService">
+           <widget class="QCheckBox" name="m_simpleUI">
             <property name="text">
-             <string>Enable Open IGT Link MicroService</string>
-            </property>
-            <property name="checked">
-             <bool>true</bool>
+             <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>
diff --git a/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupport.cpp b/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupport.cpp
index 3862f7413f..a064a6463c 100644
--- a/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupport.cpp
+++ b/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupport.cpp
@@ -1,498 +1,497 @@
 /*===================================================================
 
 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>
 
 //Mitk
 #include <mitkDataNode.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkIRenderingManager.h>
 #include <mitkImageGenerator.h>
 
 // Qmitk
 #include "UltrasoundSupport.h"
 
 // Qt
 #include <QMessageBox>
 #include <QSettings>
 #include <QTimer>
 
 // Ultrasound
 #include "mitkUSDevice.h"
 #include "QmitkUSAbstractCustomWidget.h"
 
 #include <usModuleContext.h>
 #include <usGetModuleContext.h>
 #include "usServiceReference.h"
 #include "internal/org_mitk_gui_qt_ultrasound_Activator.h"
 
 const std::string UltrasoundSupport::VIEW_ID = "org.mitk.views.ultrasoundsupport";
 
 void UltrasoundSupport::SetFocus()
 {
 }
 
 void UltrasoundSupport::CreateQtPartControl(QWidget *parent)
 {
   //initialize timers
   m_UpdateTimer = new QTimer(this);
   m_RenderingTimer2d = new QTimer(this);
   m_RenderingTimer3d = new QTimer(this);
 
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi(parent);
 
   //load persistence data before connecting slots (so no slots are called in this phase...)
   LoadUISettings();
 
   //connect signals and slots...
   connect(m_Controls.m_DeviceManagerWidget, SIGNAL(NewDeviceButtonClicked()), this, SLOT(OnClickedAddNewDevice())); // Change Widget Visibilities
   connect(m_Controls.m_DeviceManagerWidget, SIGNAL(NewDeviceButtonClicked()), this->m_Controls.m_NewVideoDeviceWidget, SLOT(CreateNewDevice())); // Init NewDeviceWidget
   connect(m_Controls.m_ActiveVideoDevices, SIGNAL(ServiceSelectionChanged(us::ServiceReferenceU)), this, SLOT(OnChangedActiveDevice()));
   connect(m_Controls.m_RunImageTimer, SIGNAL(clicked()), this, SLOT(OnChangedActiveDevice()));
   connect(m_Controls.m_ShowImageStream, SIGNAL(clicked()), this, SLOT(OnChangedActiveDevice()));
   connect(m_Controls.m_NewVideoDeviceWidget, SIGNAL(Finished()), this, SLOT(OnNewDeviceWidgetDone())); // After NewDeviceWidget finished editing
   connect(m_Controls.m_FrameRatePipeline, SIGNAL(valueChanged(int)), this, SLOT(OnChangedFramerateLimit()));
   connect(m_Controls.m_FrameRate2d, SIGNAL(valueChanged(int)), this, SLOT(OnChangedFramerateLimit()));
   connect(m_Controls.m_FrameRate3d, SIGNAL(valueChanged(int)), this, SLOT(OnChangedFramerateLimit()));
   connect(m_Controls.m_FreezeButton, SIGNAL(clicked()), this, SLOT(OnClickedFreezeButton()));
   connect(m_UpdateTimer, SIGNAL(timeout()), this, SLOT(UpdateImage()));
   connect(m_RenderingTimer2d, SIGNAL(timeout()), this, SLOT(RenderImage2d()));
   connect(m_RenderingTimer3d, SIGNAL(timeout()), this, SLOT(RenderImage3d()));
   connect(m_Controls.m_Update2DView, SIGNAL(clicked()), this, SLOT(StartTimers()));
   connect(m_Controls.m_Update3DView, SIGNAL(clicked()), this, SLOT(StartTimers()));
   connect(m_Controls.m_DeviceManagerWidget, SIGNAL(EditDeviceButtonClicked(mitk::USDevice::Pointer)), this, SLOT(OnClickedEditDevice())); //Change Widget Visibilities
   connect(m_Controls.m_DeviceManagerWidget, SIGNAL(EditDeviceButtonClicked(mitk::USDevice::Pointer)), this->m_Controls.m_NewVideoDeviceWidget, SLOT(EditDevice(mitk::USDevice::Pointer)));
 
   // Initializations
   m_Controls.m_NewVideoDeviceWidget->setVisible(false);
   std::string filter = "(&(" + us::ServiceConstants::OBJECTCLASS() + "="
     + "org.mitk.services.UltrasoundDevice)("
     + mitk::USDevice::GetPropertyKeys().US_PROPKEY_ISACTIVE + "=true))";
   m_Controls.m_ActiveVideoDevices->Initialize<mitk::USDevice>(
     mitk::USDevice::GetPropertyKeys().US_PROPKEY_LABEL, filter);
   m_Controls.m_ActiveVideoDevices->SetAutomaticallySelectFirstEntry(true);
   m_FrameCounterPipeline = 0;
   m_FrameCounter2d = 0;
   m_FrameCounter3d = 0;
 
   // Create Node for US Stream
   if (m_Node.IsNull())
   {
     m_Node = mitk::DataNode::New();
     m_Node->SetName("US Support Viewing Stream");
     //create a dummy image (gray values 0..255) for correct initialization of level window, etc.
     mitk::Image::Pointer dummyImage = mitk::ImageGenerator::GenerateRandomImage<float>(100, 100, 1, 1, 1, 1, 1, 255, 0);
     m_Node->SetData(dummyImage);
     m_OldGeometry = dynamic_cast<mitk::SlicedGeometry3D*>(dummyImage->GetGeometry());
   }
 
   m_Controls.tabWidget->setTabEnabled(1, false);
 }
 
 void UltrasoundSupport::OnClickedAddNewDevice()
 {
   m_Controls.m_NewVideoDeviceWidget->setVisible(true);
   m_Controls.m_DeviceManagerWidget->setVisible(false);
   m_Controls.m_Headline->setText("Add New Video Device:");
   m_Controls.m_WidgetActiveDevices->setVisible(false);
 }
 
 void UltrasoundSupport::OnClickedEditDevice()
 {
   m_Controls.m_NewVideoDeviceWidget->setVisible(true);
   m_Controls.m_DeviceManagerWidget->setVisible(false);
   m_Controls.m_WidgetActiveDevices->setVisible(false);
   m_Controls.m_Headline->setText("Edit Video Device:");
 }
 
 void UltrasoundSupport::UpdateImage()
 {
   //Update device
   m_Device->Modified();
   m_Device->Update();
 
   //Only update the view if the image is shown
   if (m_Controls.m_ShowImageStream->isChecked())
   {
     //Update data node
     mitk::Image::Pointer curOutput = m_Device->GetOutput();
     if (curOutput->IsEmpty())
     {
       m_Node->SetName("No Data received yet ...");
       //create a noise image for correct initialization of level window, etc.
       mitk::Image::Pointer randomImage = mitk::ImageGenerator::GenerateRandomImage<float>(32, 32, 1, 1, 1, 1, 1, 255, 0);
       m_Node->SetData(randomImage);
       curOutput->SetGeometry(randomImage->GetGeometry());
     }
     else
     {
       m_Node->SetName("US Support Viewing Stream");
       m_Node->SetData(curOutput);
     }
     // if the geometry changed: reinitialize the ultrasound image
     if ((m_OldGeometry.IsNotNull()) &&
       (curOutput->GetGeometry() != nullptr) &&
       (!mitk::Equal(m_OldGeometry.GetPointer(), curOutput->GetGeometry(), 0.0001, false))
       )
     {
       mitk::IRenderWindowPart* renderWindow = this->GetRenderWindowPart();
       if ((renderWindow != nullptr) && (curOutput->GetTimeGeometry()->IsValid()) && (m_Controls.m_ShowImageStream->isChecked()))
       {
         renderWindow->GetRenderingManager()->InitializeViews(
           curOutput->GetGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
         renderWindow->GetRenderingManager()->RequestUpdateAll();
       }
       m_CurrentImageWidth = curOutput->GetDimension(0);
       m_CurrentImageHeight = curOutput->GetDimension(1);
       m_OldGeometry = dynamic_cast<mitk::SlicedGeometry3D*>(curOutput->GetGeometry());
     }
   }
 
   //Update frame counter
   m_FrameCounterPipeline++;
   if (m_FrameCounterPipeline >= 10)
   {
     //compute framerate of pipeline update
     int nMilliseconds = m_Clock.restart();
     int fps = 10000.0f / (nMilliseconds);
     m_FPSPipeline = fps;
     m_FrameCounterPipeline = 0;
 
     //display lowest framerate in UI
     int lowestFPS = m_FPSPipeline;
     if (m_Controls.m_Update2DView->isChecked() && (m_FPS2d < lowestFPS)) { lowestFPS = m_FPS2d; }
     if (m_Controls.m_Update3DView->isChecked() && (m_FPS3d < lowestFPS)) { lowestFPS = m_FPS3d; }
     m_Controls.m_FramerateLabel->setText("Current Framerate: " + QString::number(lowestFPS) + " FPS");
   }
 }
 
 void UltrasoundSupport::RenderImage2d()
 {
   this->RequestRenderWindowUpdate(mitk::RenderingManager::REQUEST_UPDATE_2DWINDOWS);
   m_FrameCounter2d++;
   if (m_FrameCounter2d >= 10)
   {
     //compute framerate of 2d render window update
     int nMilliseconds = m_Clock2d.restart();
     int fps = 10000.0f / (nMilliseconds);
     m_FPS2d = fps;
     m_FrameCounter2d = 0;
   }
 }
 
 void UltrasoundSupport::RenderImage3d()
 {
   this->RequestRenderWindowUpdate(mitk::RenderingManager::REQUEST_UPDATE_3DWINDOWS);
   m_FrameCounter3d++;
   if (m_FrameCounter3d >= 10)
   {
     //compute framerate of 2d render window update
     int nMilliseconds = m_Clock3d.restart();
     int fps = 10000.0f / (nMilliseconds);
     m_FPS3d = fps;
     m_FrameCounter3d = 0;
   }
 }
 
 void UltrasoundSupport::OnChangedFramerateLimit()
 {
   StopTimers();
   int intervalPipeline = (1000 / m_Controls.m_FrameRatePipeline->value());
   int interval2D = (1000 / m_Controls.m_FrameRate2d->value());
   int interval3D = (1000 / m_Controls.m_FrameRate3d->value());
   SetTimerIntervals(intervalPipeline, interval2D, interval3D);
   StartTimers();
 }
 
 void UltrasoundSupport::OnClickedFreezeButton()
 {
   if (m_Device.IsNull())
   {
     MITK_WARN("UltrasoundSupport") << "Freeze button clicked though no device is selected.";
     return;
   }
   if (m_Device->GetIsFreezed())
   {
     m_Device->SetIsFreezed(false);
     m_Controls.m_FreezeButton->setText("Freeze");
   }
   else
   {
     m_Device->SetIsFreezed(true);
     m_Controls.m_FreezeButton->setText("Start Viewing Again");
   }
 }
 
 void UltrasoundSupport::OnChangedActiveDevice()
 {
   //clean up and stop timer
   StopTimers();
   this->RemoveControlWidgets();
   this->GetDataStorage()->Remove(m_Node);
   m_Node->ReleaseData();
 
   //get current device, abort if it is invalid
   m_Device = m_Controls.m_ActiveVideoDevices->GetSelectedService<mitk::USDevice>();
   if (m_Device.IsNull())
   {
     m_Controls.tabWidget->setTabEnabled(1, false);
     return;
   }
 
   //create the widgets for this device and enable the widget tab
   this->CreateControlWidgets();
   m_Controls.tabWidget->setTabEnabled(1, true);
 
   //show node if the option is enabled
   if (m_Controls.m_ShowImageStream->isChecked())
   {
     this->GetDataStorage()->Add(m_Node);
   }
 
   //start timer
   if (m_Controls.m_RunImageTimer->isChecked())
   {
     int intervalPipeline = (1000 / m_Controls.m_FrameRatePipeline->value());
     int interval2D = (1000 / m_Controls.m_FrameRate2d->value());
     int interval3D = (1000 / m_Controls.m_FrameRate3d->value());
     SetTimerIntervals(intervalPipeline, interval2D, interval3D);
     StartTimers();
     m_Controls.m_TimerWidget->setEnabled(true);
   }
   else
   {
     m_Controls.m_TimerWidget->setEnabled(false);
   }
 }
 
 void UltrasoundSupport::OnNewDeviceWidgetDone()
 {
   m_Controls.m_NewVideoDeviceWidget->setVisible(false);
   m_Controls.m_DeviceManagerWidget->setVisible(true);
   m_Controls.m_Headline->setText("Ultrasound Devices:");
   m_Controls.m_WidgetActiveDevices->setVisible(true);
 }
 
 void UltrasoundSupport::CreateControlWidgets()
 {
   m_ControlProbesWidget = new QmitkUSControlsProbesWidget(m_Device->GetControlInterfaceProbes(), m_Controls.m_ToolBoxControlWidgets);
   m_Controls.probesWidgetContainer->addWidget(m_ControlProbesWidget);
 
   // create b mode widget for current device
   m_ControlBModeWidget = new QmitkUSControlsBModeWidget(m_Device->GetControlInterfaceBMode(), m_Controls.m_ToolBoxControlWidgets);
   m_Controls.m_ToolBoxControlWidgets->addItem(m_ControlBModeWidget, "B Mode Controls");
   if (!m_Device->GetControlInterfaceBMode())
   {
     m_Controls.m_ToolBoxControlWidgets->setItemEnabled(m_Controls.m_ToolBoxControlWidgets->count() - 1, false);
   }
 
   // create doppler widget for current device
   m_ControlDopplerWidget = new QmitkUSControlsDopplerWidget(m_Device->GetControlInterfaceDoppler(), m_Controls.m_ToolBoxControlWidgets);
   m_Controls.m_ToolBoxControlWidgets->addItem(m_ControlDopplerWidget, "Doppler Controls");
   if (!m_Device->GetControlInterfaceDoppler())
   {
     m_Controls.m_ToolBoxControlWidgets->setItemEnabled(m_Controls.m_ToolBoxControlWidgets->count() - 1, false);
   }
 
   ctkPluginContext* pluginContext = mitk::PluginActivator::GetContext();
   if (pluginContext)
   {
     std::string filter = "(ork.mitk.services.UltrasoundCustomWidget.deviceClass=" + m_Device->GetDeviceClass() + ")";
 
     QString interfaceName = QString::fromStdString(us_service_interface_iid<QmitkUSAbstractCustomWidget>());
     m_CustomWidgetServiceReference = pluginContext->getServiceReferences(interfaceName, QString::fromStdString(filter));
 
     if (m_CustomWidgetServiceReference.size() > 0)
     {
       m_ControlCustomWidget = pluginContext->getService<QmitkUSAbstractCustomWidget>
         (m_CustomWidgetServiceReference.at(0))->CloneForQt(m_Controls.tab2);
       m_ControlCustomWidget->SetDevice(m_Device);
       m_Controls.m_ToolBoxControlWidgets->addItem(m_ControlCustomWidget, "Custom Controls");
     }
     else
     {
       m_Controls.m_ToolBoxControlWidgets->addItem(new QWidget(m_Controls.m_ToolBoxControlWidgets), "Custom Controls");
       m_Controls.m_ToolBoxControlWidgets->setItemEnabled(m_Controls.m_ToolBoxControlWidgets->count() - 1, false);
     }
   }
 
   // select first enabled control widget
   for (int n = 0; n < m_Controls.m_ToolBoxControlWidgets->count(); ++n)
   {
     if (m_Controls.m_ToolBoxControlWidgets->isItemEnabled(n))
     {
       m_Controls.m_ToolBoxControlWidgets->setCurrentIndex(n);
       break;
     }
   }
 }
 
 void UltrasoundSupport::RemoveControlWidgets()
 {
   if (!m_ControlProbesWidget) { return; } //widgets do not exist... nothing to do
 
   // remove all control widgets from the tool box widget
   while (m_Controls.m_ToolBoxControlWidgets->count() > 0)
   {
     m_Controls.m_ToolBoxControlWidgets->removeItem(0);
   }
 
   // remove probes widget (which is not part of the tool box widget)
   m_Controls.probesWidgetContainer->removeWidget(m_ControlProbesWidget);
   delete m_ControlProbesWidget;
   m_ControlProbesWidget = 0;
 
   delete m_ControlBModeWidget;
   m_ControlBModeWidget = 0;
 
   delete m_ControlDopplerWidget;
   m_ControlDopplerWidget = 0;
 
   // delete custom widget if it is present
   if (m_ControlCustomWidget)
   {
     ctkPluginContext* pluginContext = mitk::PluginActivator::GetContext();
     delete m_ControlCustomWidget; m_ControlCustomWidget = 0;
     if (m_CustomWidgetServiceReference.size() > 0)
     {
       pluginContext->ungetService(m_CustomWidgetServiceReference.at(0));
     }
   }
 }
 
 void UltrasoundSupport::OnDeciveServiceEvent(const ctkServiceEvent event)
 {
   if (m_Device.IsNull() || event.getType() != static_cast<ctkServiceEvent::Type>(us::ServiceEvent::MODIFIED))
   {
     return;
   }
 
   ctkServiceReference service = event.getServiceReference();
 
   if (m_Device->GetManufacturer() != service.getProperty(QString::fromStdString(mitk::USDevice::GetPropertyKeys().US_PROPKEY_MANUFACTURER)).toString().toStdString()
     && m_Device->GetName() != service.getProperty(QString::fromStdString(mitk::USDevice::GetPropertyKeys().US_PROPKEY_NAME)).toString().toStdString())
   {
     return;
   }
 
   if (!m_Device->GetIsActive() && m_UpdateTimer->isActive())
   {
     StopTimers();
   }
 
   if (m_CurrentDynamicRange != service.getProperty(QString::fromStdString(mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_DYNAMIC_RANGE)).toDouble())
   {
     m_CurrentDynamicRange = service.getProperty(QString::fromStdString(mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_DYNAMIC_RANGE)).toDouble();
 
     // update level window for the current dynamic range
     mitk::LevelWindow levelWindow;
     m_Node->GetLevelWindow(levelWindow);
     levelWindow.SetAuto(m_Image, true, true);
     m_Node->SetLevelWindow(levelWindow);
   }
 }
 
 UltrasoundSupport::UltrasoundSupport()
   : m_ControlCustomWidget(0), m_ControlBModeWidget(0),
   m_ControlProbesWidget(0), m_ImageAlreadySetToNode(false),
   m_CurrentImageWidth(0), m_CurrentImageHeight(0)
 {
   ctkPluginContext* pluginContext = mitk::PluginActivator::GetContext();
 
   if (pluginContext)
   {
     // to be notified about service event of an USDevice
     pluginContext->connectServiceListener(this, "OnDeciveServiceEvent",
       QString::fromStdString("(" + us::ServiceConstants::OBJECTCLASS() + "=" + us_service_interface_iid<mitk::USDevice>() + ")"));
   }
 }
 
 UltrasoundSupport::~UltrasoundSupport()
 {
   try
   {
+    StoreUISettings();
     StopTimers();
 
     // Get all active devicesand deactivate them to prevent freeze
     for (auto device : this->m_Controls.m_ActiveVideoDevices->GetAllServices<mitk::USDevice>())
     {
       if (device != nullptr && device->GetIsActive())
       {
         device->Deactivate();
         device->Disconnect();
       }
     }
-
-    StoreUISettings();
   }
   catch (std::exception &e)
   {
     MITK_ERROR << "Exception during call of destructor! Message: " << e.what();
   }
 }
 
 void UltrasoundSupport::StoreUISettings()
 {
   QSettings settings;
   settings.beginGroup(QString::fromStdString(VIEW_ID));
   settings.setValue("DisplayImage", QVariant(m_Controls.m_ShowImageStream->isChecked()));
   settings.setValue("RunImageTimer", QVariant(m_Controls.m_RunImageTimer->isChecked()));
   settings.setValue("Update2DView", QVariant(m_Controls.m_Update2DView->isChecked()));
   settings.setValue("Update3DView", QVariant(m_Controls.m_Update3DView->isChecked()));
   settings.setValue("UpdateRatePipeline", QVariant(m_Controls.m_FrameRatePipeline->value()));
   settings.setValue("UpdateRate2d", QVariant(m_Controls.m_FrameRate2d->value()));
   settings.setValue("UpdateRate3d", QVariant(m_Controls.m_FrameRate3d->value()));
   settings.endGroup();
 }
 
 void UltrasoundSupport::LoadUISettings()
 {
   QSettings settings;
   settings.beginGroup(QString::fromStdString(VIEW_ID));
   m_Controls.m_ShowImageStream->setChecked(settings.value("DisplayImage", true).toBool());
   m_Controls.m_RunImageTimer->setChecked(settings.value("RunImageTimer", true).toBool());
   m_Controls.m_Update2DView->setChecked(settings.value("Update2DView", true).toBool());
   m_Controls.m_Update3DView->setChecked(settings.value("Update3DView", true).toBool());
   m_Controls.m_FrameRatePipeline->setValue(settings.value("UpdateRatePipeline", 50).toInt());
   m_Controls.m_FrameRate2d->setValue(settings.value("UpdateRate2d", 20).toInt());
   m_Controls.m_FrameRate3d->setValue(settings.value("UpdateRate3d", 5).toInt());
   settings.endGroup();
 }
 
 void UltrasoundSupport::StartTimers()
 {
   m_UpdateTimer->start();
   if (m_Controls.m_Update2DView->isChecked()) { m_RenderingTimer2d->start(); }
   if (m_Controls.m_Update3DView->isChecked()) { m_RenderingTimer3d->start(); }
 }
 
 void UltrasoundSupport::StopTimers()
 {
   m_UpdateTimer->stop();
   m_RenderingTimer2d->stop();
   m_RenderingTimer3d->stop();
 }
 
 void UltrasoundSupport::SetTimerIntervals(int intervalPipeline, int interval2D, int interval3D)
 {
   m_UpdateTimer->setInterval(intervalPipeline);
   m_RenderingTimer2d->setInterval(interval2D);
   m_RenderingTimer3d->setInterval(interval3D);
 }