diff --git a/Modules/US/USNavigation/Testing/mitkCombinedModalityTest.cpp b/Modules/US/USNavigation/Testing/mitkCombinedModalityTest.cpp
index e12ebc1b21..87465cbbd8 100644
--- a/Modules/US/USNavigation/Testing/mitkCombinedModalityTest.cpp
+++ b/Modules/US/USNavigation/Testing/mitkCombinedModalityTest.cpp
@@ -1,176 +1,171 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkUSCombinedModality.h"
 #include <mitkVirtualTrackingDevice.h>
 #include <mitkUSVideoDevice.h>
 #include <mitkTestingMacros.h>
 #include <mitkTrackingDeviceSource.h>
 
 class mitkCombinedModalityTestClass
 {
 public:
 
-  /*
-  * \brief Returns a reference string for serialized calibrations.
-  */
-
-  static std::string GetSerializedReference()
-  {
-
-    return std::string("<calibrations>\n<") + mitk::USCombinedModality::DefaultProbeIdentifier + mitk::USCombinedModality::ProbeAndDepthSeperator
-                       + "0 M00=\"1.1234\" M01=\"1.2234\" M02=\"1.3234\" M10=\"1.4234\" M11=\"1.5234\" M12=\"1.6234\" M20=\"1.7234\" M21=\"1.8234\" M22=\"1.9234\" T0=\"2.1234\" T1=\"2.2234\" T2=\"2.3234\" />\n</calibrations>\n";
-  }
-
   static bool CompareDoubles (double A, double B)
   {
-    float diff = A - B;
-    return (diff < 0.0001) && (-diff < 0.0001);
+    return std::abs(A - B) < 0.0001;
   }
 
   /*
   * \brief Creates a dummy combined modality.
   */
   static mitk::USCombinedModality::Pointer CreateModality()
   {
     mitk::USVideoDevice::Pointer  usDevice =  mitk::USVideoDevice::New("IllegalPath", "Manufacturer", "Model");
     mitk::VirtualTrackingDevice::Pointer tracker = mitk::VirtualTrackingDevice::New();
     tracker->AddTool("tool1");
     tracker->AddTool("tool2");
     mitk::TrackingDeviceSource::Pointer source = mitk::TrackingDeviceSource::New();
     source->SetTrackingDevice(tracker);
     source->Connect();
     source->StartTracking();
     return mitk::USCombinedModality::New(usDevice.GetPointer(), source.GetPointer(), false);
   }
 
   static void TestInstantiation()
   {
     mitk::USCombinedModality::Pointer combinedModality = CreateModality();
     MITK_TEST_CONDITION_REQUIRED(combinedModality.IsNotNull(), "CombinedModality should not be null after instantiation");
   }
 
   static void TestSerialization()
   {
-    mitk::USCombinedModality::Pointer modality = CreateModality();
+    auto modality = CreateModality();
 
     mitk::AffineTransform3D::MatrixType matrix;
     matrix[0][0] = 1.1234;
     matrix[0][1] = 1.2234;
     matrix[0][2] = 1.3234;
     matrix[1][0] = 1.4234;
     matrix[1][1] = 1.5234;
     matrix[1][2] = 1.6234;
     matrix[2][0] = 1.7234;
     matrix[2][1] = 1.8234;
     matrix[2][2] = 1.9234;
 
     mitk::AffineTransform3D::OffsetType offset;
     offset[0] = 2.1234;
     offset[1] = 2.2234;
     offset[2] = 2.3234;
 
     mitk::AffineTransform3D::Pointer transform = mitk::AffineTransform3D::New();
     transform->SetMatrix(matrix);
     transform->SetOffset(offset);
 
     modality->SetCalibration(transform);
 
-    MITK_TEST_CONDITION_REQUIRED(modality->SerializeCalibration() == GetSerializedReference(), "Testing correct Serialization...");
-  }
-
-  static void TestDeserialization()
-  {
-    mitk::USCombinedModality::Pointer modality = CreateModality();
-    modality->DeserializeCalibration(GetSerializedReference());
-    mitk::AffineTransform3D::Pointer transform = modality->GetCalibration();
-
-    mitk::AffineTransform3D::MatrixType matrix = transform->GetMatrix();
-    mitk::AffineTransform3D::OffsetType offset = transform->GetOffset();;
+    const auto xmlString = modality->SerializeCalibration();
+    auto otherModality = CreateModality();
+    otherModality->DeserializeCalibration(xmlString);
+    auto calibration = otherModality->GetCalibration();
+    const auto& otherMatrix = calibration->GetMatrix();
+    const auto& otherOffset = calibration->GetOffset();
 
     bool identical = true;
 
-    if (! CompareDoubles(matrix[0][0], 1.1234)) identical = false;
-    if (! CompareDoubles(matrix[0][1], 1.2234)) identical = false;
-    if (! CompareDoubles(matrix[0][2], 1.3234)) identical = false;
-    if (! CompareDoubles(matrix[1][0], 1.4234)) identical = false;
-    if (! CompareDoubles(matrix[1][1], 1.5234)) identical = false;
-    if (! CompareDoubles(matrix[1][2], 1.6234)) identical = false;
-    if (! CompareDoubles(matrix[2][0], 1.7234)) identical = false;
-    if (! CompareDoubles(matrix[2][1], 1.8234)) identical = false;
-    if (! CompareDoubles(matrix[2][2], 1.9234)) identical = false;
-
-    if (! CompareDoubles(offset[0], 2.1234)) identical = false;
-    if (! CompareDoubles(offset[1], 2.2234)) identical = false;
-    if (! CompareDoubles(offset[2], 2.3234)) identical = false;
+    for (size_t i = 0; i < 3; ++i)
+    {
+      for (size_t j = 0; j < 3; ++j)
+      {
+        if (!CompareDoubles(matrix[i][j], otherMatrix[i][j]))
+        {
+          identical = false;
+          break;
+        }
+      }
+
+      if (!identical)
+        break;
+    }
+
+    if (identical)
+    {
+      for (size_t i = 0; i < 3; ++i)
+      {
+        if (!CompareDoubles(offset[i], otherOffset[i]))
+        {
+          identical = false;
+          break;
+        }
+      }
+    }
 
     MITK_TEST_CONDITION_REQUIRED(identical, "Testing if deserialized calibration is identical to serialized one...");
 
     // test if invalid strings cause exceptions
     MITK_TEST_FOR_EXCEPTION(mitk::Exception, modality->DeserializeCalibration("invalid-string"));
     MITK_TEST_FOR_EXCEPTION(mitk::Exception, modality->DeserializeCalibration("<xml><test></xml>", false));
   }
 
   static void TestFilterPipeline()
   {
     /*mitk::USCombinedModality::Pointer combinedModality = mitkCombinedModalityTestClass::CreateModality();
     MITK_INFO << combinedModality->GetNavigationDataSource()->GetNameOfClass();
     MITK_TEST_CONDITION(strcmp(combinedModality->GetNavigationDataSource()->GetNameOfClass(), "TrackingDeviceSource") == 0,
                         "")*/
 
     mitk::USVideoDevice::Pointer  usDevice =  mitk::USVideoDevice::New("IllegalPath", "Manufacturer", "Model");
     mitk::VirtualTrackingDevice::Pointer tracker = mitk::VirtualTrackingDevice::New();
     tracker->AddTool("tool1");
     tracker->AddTool("tool2");
     mitk::TrackingDeviceSource::Pointer source = mitk::TrackingDeviceSource::New();
     source->SetTrackingDevice(tracker);
     source->Connect();
     source->StartTracking();
     mitk::USCombinedModality::Pointer modality = mitk::USCombinedModality::New(usDevice.GetPointer(), source.GetPointer(), false);
 
     MITK_TEST_CONDITION(source->GetOutput(0) == modality->GetNavigationDataSource()->GetOutput(0),
                         "Navigation data output of the Combined Modality should be the same as the source output as no filters are active.")
 
     modality->SetNumberOfSmoothingValues(2);
 
     mitk::NavigationDataSource::Pointer smoothingFilter = modality->GetNavigationDataSource();
     MITK_TEST_CONDITION(source->GetOutput(0) != smoothingFilter->GetOutput(0),
                         "Navigation data output of the Combined Modality should be different to the source output as smoothing filter is active.")
 
     modality->SetNumberOfSmoothingValues(0);
     MITK_TEST_CONDITION(source->GetOutput(0) == modality->GetNavigationDataSource()->GetOutput(0),
                         "Navigation data output of the Combined Modality should be the same as the source output again.")
 
     modality->SetDelayCount(5);
     MITK_TEST_CONDITION(source->GetOutput(0) != smoothingFilter->GetOutput(0),
                         "Navigation data output of the Combined Modality should be different to the source output as delay filter is active.")
 
     modality->SetDelayCount(0);
     MITK_TEST_CONDITION(source->GetOutput(0) == modality->GetNavigationDataSource()->GetOutput(0),
                         "Navigation data output of the Combined Modality should be the same as the source output again.")
   }
 };
 
 /**
 * This function is testing methods of the class USDevice.
 */
 int mitkCombinedModalityTest(int /* argc */, char* /*argv*/[])
 {
   MITK_TEST_BEGIN("mitkCombinedModalityTest");
 
   mitkCombinedModalityTestClass::TestInstantiation();
   mitkCombinedModalityTestClass::TestSerialization();
-  mitkCombinedModalityTestClass::TestDeserialization();
   mitkCombinedModalityTestClass::TestFilterPipeline();
 
   MITK_TEST_END();
 }
diff --git a/Modules/US/USNavigation/mitkAbstractUltrasoundTrackerDevice.cpp b/Modules/US/USNavigation/mitkAbstractUltrasoundTrackerDevice.cpp
index 6358961382..0f9e821238 100644
--- a/Modules/US/USNavigation/mitkAbstractUltrasoundTrackerDevice.cpp
+++ b/Modules/US/USNavigation/mitkAbstractUltrasoundTrackerDevice.cpp
@@ -1,492 +1,495 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkAbstractUltrasoundTrackerDevice.h"
 #include "mitkImageReadAccessor.h"
 #include "mitkNavigationDataDelayFilter.h"
 #include "mitkNavigationDataDisplacementFilter.h"
 #include "mitkNavigationDataSmoothingFilter.h"
 #include "mitkTrackingDeviceSource.h"
 
 // US Control Interfaces
 #include "mitkUSControlInterfaceBMode.h"
 #include "mitkUSControlInterfaceDoppler.h"
 #include "mitkUSControlInterfaceProbes.h"
 
 // Microservices
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <usModuleContext.h>
 #include <usServiceProperties.h>
 
 #include <algorithm>
 
 // TempIncludes
 #include <tinyxml2.h>
 
 const std::string mitk::AbstractUltrasoundTrackerDevice::DeviceClassIdentifier =
   "org.mitk.modules.us.AbstractUltrasoundTrackerDevice";
 const char *mitk::AbstractUltrasoundTrackerDevice::DefaultProbeIdentifier = "default";
 const char *mitk::AbstractUltrasoundTrackerDevice::ProbeAndDepthSeperator = "_";
 
 const std::string mitk::AbstractUltrasoundTrackerDevice::US_INTERFACE_NAME =
   "org.mitk.services.AbstractUltrasoundTrackerDevice";
 const std::string mitk::AbstractUltrasoundTrackerDevice::US_PROPKEY_DEVICENAME = US_INTERFACE_NAME + ".devicename";
 const std::string mitk::AbstractUltrasoundTrackerDevice::US_PROPKEY_CLASS = US_INTERFACE_NAME + ".class";
 const std::string mitk::AbstractUltrasoundTrackerDevice::US_PROPKEY_ID = US_INTERFACE_NAME + ".id";
 //____
 
 mitk::AbstractUltrasoundTrackerDevice::AbstractUltrasoundTrackerDevice(USDevice::Pointer usDevice,
                                                                        NavigationDataSource::Pointer trackingDevice,
                                                                        bool trackedUltrasoundActive)
   : m_UltrasoundDevice(usDevice),
     m_TrackingDeviceDataSource(trackingDevice),
     m_SmoothingFilter(mitk::NavigationDataSmoothingFilter::New()),
     m_DelayFilter(mitk::NavigationDataDelayFilter::New(0)),
     m_DisplacementFilter(mitk::NavigationDataDisplacementFilter::New()),
     m_LastFilterOfIGTPipeline(nullptr),
     m_NumberOfSmoothingValues(0),
     m_DelayCount(0),
     m_IsTrackedUltrasoundActive(trackedUltrasoundActive)
 {
   m_DisplacementFilter->SetTransform6DOF(true);
 
   this->RebuildFilterPipeline();
 
   // create a new output (for the image data)
   //___ mitk::Image::Pointer newOutput = mitk::Image::New();
   //___ this->SetNthOutput(0, newOutput);
 
   // Combined Modality should not spawn an own acquire thread, because
   // image acquiring is done by the included us device
   //___ m_UltrasoundDevice->SetSpawnAcquireThread(false);
 }
 
 mitk::AffineTransform3D::Pointer mitk::AbstractUltrasoundTrackerDevice::GetUSPlaneTransform()
 {
   return mitk::AffineTransform3D::New();
 }
 
 void mitk::AbstractUltrasoundTrackerDevice::SetIsFreezed(bool freeze)
 {
   if (m_UltrasoundDevice.IsNull() || m_TrackingDeviceDataSource.IsNull())
   {
     MITK_WARN << "Combined modality not correctly initialized, aborting!";
     return;
   }
 
   if (!m_UltrasoundDevice->GetIsActive())
   {
     MITK_WARN("mitkUSDevice")
       << "Cannot freeze or unfreeze if device is not active.";
     return;
   }
 
   this->OnFreeze(freeze);
 
   if (freeze)
   {
     m_IsFreezed = true;
   }
   else
   {
     m_IsFreezed = false;
   }
 }
 
 bool mitk::AbstractUltrasoundTrackerDevice::GetIsFreezed()
 {
   return m_IsFreezed;
 }
 
 mitk::AbstractUltrasoundTrackerDevice::~AbstractUltrasoundTrackerDevice()
 {
   if (m_ServiceRegistration != nullptr)
   {
     m_ServiceRegistration.Unregister();
   }
   m_ServiceRegistration = 0;
 }
 
 mitk::AffineTransform3D::Pointer mitk::AbstractUltrasoundTrackerDevice::GetCalibration()
 {
   return this->GetCalibration(this->GetCurrentDepthValue(), this->GetIdentifierForCurrentProbe());
 }
 
 mitk::AffineTransform3D::Pointer mitk::AbstractUltrasoundTrackerDevice::GetCalibration(std::string depth)
 {
   return this->GetCalibration(depth, this->GetIdentifierForCurrentProbe());
 }
 
 mitk::AffineTransform3D::Pointer mitk::AbstractUltrasoundTrackerDevice::GetCalibration(std::string depth,
                                                                                        std::string probe)
 {
   // make sure that there is no '/' which would cause problems for TinyXML
   std::replace(probe.begin(), probe.end(), '/', '-');
 
   // create identifier for calibration from probe and depth
   std::string calibrationKey = probe + mitk::AbstractUltrasoundTrackerDevice::ProbeAndDepthSeperator + depth;
 
   // find calibration for combination of probe identifier and depth
   std::map<std::string, mitk::AffineTransform3D::Pointer>::iterator calibrationIterator =
     m_Calibrations.find(calibrationKey);
 
   if (calibrationIterator == m_Calibrations.end())
   {
     return nullptr;
   }
 
   return calibrationIterator->second;
 }
 
 void mitk::AbstractUltrasoundTrackerDevice::SetCalibration(mitk::AffineTransform3D::Pointer calibration)
 {
   if (calibration.IsNull())
   {
     MITK_WARN << "Null pointer passed to SetCalibration of mitk::USDevice. Ignoring call.";
     return;
   }
 
   std::string calibrationKey = this->GetIdentifierForCurrentCalibration();
   if (calibrationKey.empty())
   {
     MITK_WARN << "Could not get a key for the calibration -> Calibration cannot be set.";
     return;
   }
 
   m_Calibrations[calibrationKey] = calibration;
 }
 
 bool mitk::AbstractUltrasoundTrackerDevice::RemoveCalibration()
 {
   return this->RemoveCalibration(this->GetCurrentDepthValue(), this->GetIdentifierForCurrentProbe());
 }
 
 bool mitk::AbstractUltrasoundTrackerDevice::RemoveCalibration(std::string depth)
 {
   return this->RemoveCalibration(depth, this->GetIdentifierForCurrentProbe());
 }
 
 bool mitk::AbstractUltrasoundTrackerDevice::RemoveCalibration(std::string depth, std::string probe)
 {
   // make sure that there is no '/' which would cause problems for TinyXML
   std::replace(probe.begin(), probe.end(), '/', '-');
 
   // create identifier for calibration from probe and depth
   std::string calibrationKey = probe + mitk::AbstractUltrasoundTrackerDevice::ProbeAndDepthSeperator + depth;
 
   return m_Calibrations.erase(calibrationKey) > 0;
 }
 
 std::string mitk::AbstractUltrasoundTrackerDevice::GetDeviceClass()
 {
   return DeviceClassIdentifier;
 }
 
 mitk::USImageSource::Pointer mitk::AbstractUltrasoundTrackerDevice::GetUSImageSource()
 {
   if (m_UltrasoundDevice.IsNull())
   {
     MITK_ERROR("AbstractUltrasoundTrackerDevice")("USDevice") << "UltrasoundDevice must not be null.";
     mitkThrow() << "UltrasoundDevice must not be null.";
   }
 
   return m_UltrasoundDevice->GetUSImageSource();
 }
 
 mitk::NavigationDataSource::Pointer mitk::AbstractUltrasoundTrackerDevice::GetNavigationDataSource()
 {
   if (m_LastFilterOfIGTPipeline.IsNull())
   {
     this->RebuildFilterPipeline();
   }
   m_LastFilterOfIGTPipeline->SetToolMetaDataCollection(this->m_TrackingDeviceDataSource->GetToolMetaDataCollection());
   return m_LastFilterOfIGTPipeline;
 }
 
 bool mitk::AbstractUltrasoundTrackerDevice::GetIsCalibratedForCurrentStatus()
 {
   return m_Calibrations.find(this->GetIdentifierForCurrentCalibration()) != m_Calibrations.end();
 }
 
 bool mitk::AbstractUltrasoundTrackerDevice::GetContainsAtLeastOneCalibration()
 {
   return !m_Calibrations.empty();
 }
 
 std::string mitk::AbstractUltrasoundTrackerDevice::SerializeCalibration()
 {
   tinyxml2::XMLDocument doc;
-  std::stringstream result;
-  result << "<calibrations>" << std::endl;
+  auto* calibrations = doc.NewElement("calibrations");
+  doc.InsertEndChild(calibrations);
+
   // For each calibration in the set
   for (std::map<std::string, mitk::AffineTransform3D::Pointer>::iterator it = m_Calibrations.begin();
        it != m_Calibrations.end();
        it++)
   {
     mitk::AffineTransform3D::MatrixType matrix = it->second->GetMatrix();
     mitk::AffineTransform3D::TranslationType translation = it->second->GetTranslation();
     auto *elem = doc.NewElement(it->first.c_str());
     // Serialize Matrix
     elem->SetAttribute("M00", matrix[0][0]);
     elem->SetAttribute("M01", matrix[0][1]);
     elem->SetAttribute("M02", matrix[0][2]);
     elem->SetAttribute("M10", matrix[1][0]);
     elem->SetAttribute("M11", matrix[1][1]);
     elem->SetAttribute("M12", matrix[1][2]);
     elem->SetAttribute("M20", matrix[2][0]);
     elem->SetAttribute("M21", matrix[2][1]);
     elem->SetAttribute("M22", matrix[2][2]);
     // Serialize Offset
     elem->SetAttribute("T0", translation[0]);
     elem->SetAttribute("T1", translation[1]);
     elem->SetAttribute("T2", translation[2]);
 
-    result << elem << std::endl;
+    calibrations->InsertEndChild(elem);
   }
-  result << "</calibrations>" << std::endl;
 
-  return result.str();
+  tinyxml2::XMLPrinter printer;
+  doc.Print(&printer);
+
+  return printer.CStr();
 }
 
 void mitk::AbstractUltrasoundTrackerDevice::DeserializeCalibration(const std::string &xmlString,
                                                                    bool clearPreviousCalibrations)
 {
   // Sanitize Input
   if (xmlString == "")
   {
     MITK_ERROR << "Empty string passed to Deserialize() method of CombinedModality. Aborting...";
     mitkThrow() << "Empty string passed to Deserialize() method of CombinedModality. Aborting...";
     return;
   }
   // Clear previous calibrations if necessary
   if (clearPreviousCalibrations)
     m_Calibrations.clear();
 
   // Parse Input
   tinyxml2::XMLDocument doc;
   if (tinyxml2::XML_SUCCESS != doc.Parse(xmlString.c_str()))
   {
     MITK_ERROR << "Unable to deserialize calibrations in CombinedModality. Error was: " << doc.ErrorStr();
     mitkThrow() << "Unable to deserialize calibrations in CombinedModality. Error was: " << doc.ErrorStr();
     return;
   }
   auto *root = doc.FirstChildElement();
   if (root == nullptr)
   {
     MITK_ERROR << "Unable to deserialize calibrations in CombinedModality. String contained no root element.";
     mitkThrow() << "Unable to deserialize calibrations in CombinedModality. String contained no root element.";
     return;
   }
   // Read Calibrations
   for (auto *elem = root->FirstChildElement(); elem != nullptr; elem = elem->NextSiblingElement())
   {
     mitk::AffineTransform3D::MatrixType matrix;
     mitk::AffineTransform3D::OffsetType translation;
 
     std::string calibName = elem->Value();
 
     // Deserialize Matrix
     elem->QueryDoubleAttribute("M00", &matrix[0][0]);
     elem->QueryDoubleAttribute("M01", &matrix[0][1]);
     elem->QueryDoubleAttribute("M02", &matrix[0][2]);
     elem->QueryDoubleAttribute("M10", &matrix[1][0]);
     elem->QueryDoubleAttribute("M11", &matrix[1][1]);
     elem->QueryDoubleAttribute("M12", &matrix[1][2]);
     elem->QueryDoubleAttribute("M20", &matrix[2][0]);
     elem->QueryDoubleAttribute("M21", &matrix[2][1]);
     elem->QueryDoubleAttribute("M22", &matrix[2][2]);
 
     // Deserialize Offset
     elem->QueryDoubleAttribute("T0", &translation[0]);
     elem->QueryDoubleAttribute("T1", &translation[1]);
     elem->QueryDoubleAttribute("T2", &translation[2]);
 
     mitk::AffineTransform3D::Pointer calibration = mitk::AffineTransform3D::New();
     calibration->SetMatrix(matrix);
     calibration->SetTranslation(translation);
     m_Calibrations[calibName] = calibration;
   }
 }
 
 void mitk::AbstractUltrasoundTrackerDevice::SetNumberOfSmoothingValues(unsigned int numberOfSmoothingValues)
 {
   unsigned int oldNumber = m_NumberOfSmoothingValues;
   m_NumberOfSmoothingValues = numberOfSmoothingValues;
 
   // if filter should be activated or deactivated
   if ((oldNumber == 0 && numberOfSmoothingValues != 0) || (oldNumber != 0 && numberOfSmoothingValues == 0))
   {
     this->RebuildFilterPipeline();
   }
   m_SmoothingFilter->SetNumerOfValues(numberOfSmoothingValues);
 }
 
 void mitk::AbstractUltrasoundTrackerDevice::SetDelayCount(unsigned int delayCount)
 {
   unsigned int oldCount = m_DelayCount;
   m_DelayCount = delayCount;
 
   // if filter should be activated or deactivated
   if ((oldCount == 0 && delayCount != 0) || (oldCount != 0 && delayCount == 0))
   {
     this->RebuildFilterPipeline();
   }
   m_DelayFilter->SetDelay(delayCount);
 }
 
 void mitk::AbstractUltrasoundTrackerDevice::GenerateData() {}
 
 std::string mitk::AbstractUltrasoundTrackerDevice::GetIdentifierForCurrentCalibration()
 {
   return this->GetIdentifierForCurrentProbe() + mitk::AbstractUltrasoundTrackerDevice::ProbeAndDepthSeperator +
          this->GetCurrentDepthValue();
 }
 
 std::string mitk::AbstractUltrasoundTrackerDevice::GetIdentifierForCurrentProbe()
 {
   us::ServiceProperties usdeviceProperties = m_UltrasoundDevice->GetServiceProperties();
 
   us::ServiceProperties::const_iterator probeIt =
     usdeviceProperties.find(mitk::USDevice::GetPropertyKeys().US_PROPKEY_PROBES_SELECTED);
 
   // get probe identifier from control interface for probes
   std::string probeName = mitk::AbstractUltrasoundTrackerDevice::DefaultProbeIdentifier;
   if (probeIt != usdeviceProperties.end())
   {
     probeName = (probeIt->second).ToString();
   }
 
   // make sure that there is no '/' which would cause problems for TinyXML
   std::replace(probeName.begin(), probeName.end(), '/', '-');
 
   return probeName;
 }
 
 std::string mitk::AbstractUltrasoundTrackerDevice::GetCurrentDepthValue()
 {
   us::ServiceProperties usdeviceProperties = m_UltrasoundDevice->GetServiceProperties();
 
   // get string for depth value from the micro service properties
   std::string depth;
   us::ServiceProperties::iterator depthIterator =
     usdeviceProperties.find(mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_DEPTH);
 
   if (depthIterator != usdeviceProperties.end())
   {
     depth = depthIterator->second.ToString();
   }
   else
   {
     depth = "0";
   }
 
   return depth;
 }
 
 void mitk::AbstractUltrasoundTrackerDevice::RebuildFilterPipeline()
 {
   m_LastFilterOfIGTPipeline = m_TrackingDeviceDataSource;
 
   if (m_NumberOfSmoothingValues > 0)
   {
     m_SmoothingFilter->ConnectTo(m_LastFilterOfIGTPipeline.GetPointer());
     m_LastFilterOfIGTPipeline = m_SmoothingFilter;
   }
 
   if (m_DelayCount > 0)
   {
     m_DelayFilter->ConnectTo(m_LastFilterOfIGTPipeline.GetPointer());
     m_LastFilterOfIGTPipeline = m_DelayFilter;
   }
 
   if (m_IsTrackedUltrasoundActive)
   {
     m_DisplacementFilter->ConnectTo(m_LastFilterOfIGTPipeline.GetPointer());
     m_LastFilterOfIGTPipeline = m_DisplacementFilter;
   }
 }
 
 void mitk::AbstractUltrasoundTrackerDevice::UnregisterOnService()
 {
   if (m_UltrasoundDevice->GetDeviceState() == USDevice::State_Activated)
   {
     m_UltrasoundDevice->Deactivate();
   }
   if (m_UltrasoundDevice->GetDeviceState() == USDevice::State_Connected)
   {
     m_UltrasoundDevice->Disconnect();
   }
 
   if (m_ServiceRegistration != nullptr)
     m_ServiceRegistration.Unregister();
   m_ServiceRegistration = 0;
 }
 
 void mitk::AbstractUltrasoundTrackerDevice::RegisterAsMicroservice()
 {
   // Get Context
   us::ModuleContext *context = us::GetModuleContext();
 
   // Define ServiceProps
   // us::ServiceProperties props;
   mitk::UIDGenerator uidGen = mitk::UIDGenerator("org.mitk.services.AbstractUltrasoundTrackerDevice");
   m_ServiceProperties[US_PROPKEY_ID] = uidGen.GetUID();
   m_ServiceProperties[US_PROPKEY_DEVICENAME] = m_UltrasoundDevice->GetName();
   m_ServiceProperties[US_PROPKEY_CLASS] = mitk::AbstractUltrasoundTrackerDevice::DeviceClassIdentifier;
 
   m_ServiceRegistration = context->RegisterService(this, m_ServiceProperties);
 }
 
 mitk::USAbstractControlInterface::Pointer mitk::AbstractUltrasoundTrackerDevice::GetControlInterfaceCustom()
 {
   if (m_UltrasoundDevice.IsNull())
   {
     MITK_ERROR("USCombinedModality")("USDevice") << "UltrasoundDevice must not be null.";
     mitkThrow() << "UltrasoundDevice must not be null.";
   }
 
   return m_UltrasoundDevice->GetControlInterfaceCustom();
 }
 
 mitk::USControlInterfaceBMode::Pointer mitk::AbstractUltrasoundTrackerDevice::GetControlInterfaceBMode()
 {
   if (m_UltrasoundDevice.IsNull())
   {
     MITK_ERROR("USCombinedModality")("USDevice") << "UltrasoundDevice must not be null.";
     mitkThrow() << "UltrasoundDevice must not be null.";
   }
 
   return m_UltrasoundDevice->GetControlInterfaceBMode();
 }
 
 mitk::USControlInterfaceProbes::Pointer mitk::AbstractUltrasoundTrackerDevice::GetControlInterfaceProbes()
 {
   if (m_UltrasoundDevice.IsNull())
   {
     MITK_ERROR("USCombinedModality")("USDevice") << "UltrasoundDevice must not be null.";
     mitkThrow() << "UltrasoundDevice must not be null.";
   }
 
   return m_UltrasoundDevice->GetControlInterfaceProbes();
 }
 
 mitk::USControlInterfaceDoppler::Pointer mitk::AbstractUltrasoundTrackerDevice::GetControlInterfaceDoppler()
 {
   if (m_UltrasoundDevice.IsNull())
   {
     MITK_ERROR("USCombinedModality")("USDevice") << "UltrasoundDevice must not be null.";
     mitkThrow() << "UltrasoundDevice must not be null.";
   }
 
   return m_UltrasoundDevice->GetControlInterfaceDoppler();
 }