diff --git a/Modules/US/USNavigation/mitkAbstractUltrasoundTrackerDevice.cpp b/Modules/US/USNavigation/mitkAbstractUltrasoundTrackerDevice.cpp
index 19e989ad48..f467d89616 100644
--- a/Modules/US/USNavigation/mitkAbstractUltrasoundTrackerDevice.cpp
+++ b/Modules/US/USNavigation/mitkAbstractUltrasoundTrackerDevice.cpp
@@ -1,474 +1,463 @@
 /*===================================================================
 
 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 "mitkAbstractUltrasoundTrackerDevice.h"
 #include "mitkImageReadAccessor.h"
-#include "mitkNavigationDataSmoothingFilter.h"
 #include "mitkNavigationDataDelayFilter.h"
 #include "mitkNavigationDataDisplacementFilter.h"
+#include "mitkNavigationDataSmoothingFilter.h"
 #include "mitkTrackingDeviceSource.h"
 
 // US Control Interfaces
-#include "mitkUSControlInterfaceProbes.h"
 #include "mitkUSControlInterfaceBMode.h"
 #include "mitkUSControlInterfaceDoppler.h"
+#include "mitkUSControlInterfaceProbes.h"
 
-//Microservices
+// Microservices
 #include <usGetModuleContext.h>
 #include <usModule.h>
-#include <usServiceProperties.h>
 #include <usModuleContext.h>
+#include <usServiceProperties.h>
 
 #include <algorithm>
 
-//TempIncludes
+// TempIncludes
 #include <tinyxml.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::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_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),
+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_NumberOfSmoothingValues(0),
+    m_DelayCount(0),
+    m_IsTrackedUltrasoundActive(trackedUltrasoundActive)
 {
   m_DisplacementFilter->SetTransform6DOF(true);
 
   this->RebuildFilterPipeline();
 
-  //create a new output (for the image data)
+  // 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();
+}
 
 mitk::AbstractUltrasoundTrackerDevice::~AbstractUltrasoundTrackerDevice()
 {
   if (m_ServiceRegistration != nullptr)
   {
     m_ServiceRegistration.Unregister();
   }
   m_ServiceRegistration = 0;
 }
 
-mitk::AffineTransform3D::Pointer
-  mitk::AbstractUltrasoundTrackerDevice::GetCalibration()
+mitk::AffineTransform3D::Pointer mitk::AbstractUltrasoundTrackerDevice::GetCalibration()
 {
-  return this->GetCalibration( this->GetCurrentDepthValue(),
-                               this->GetIdentifierForCurrentProbe() );
+  return this->GetCalibration(this->GetCurrentDepthValue(), this->GetIdentifierForCurrentProbe());
 }
 
-mitk::AffineTransform3D::Pointer
-  mitk::AbstractUltrasoundTrackerDevice::GetCalibration(std::string depth)
+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 )
+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;
+  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);
+  std::map<std::string, mitk::AffineTransform3D::Pointer>::iterator calibrationIterator =
+    m_Calibrations.find(calibrationKey);
 
-  if (calibrationIterator == m_Calibrations.end()) { return 0; }
+  if (calibrationIterator == m_Calibrations.end())
+  {
+    return 0;
+  }
 
   return calibrationIterator->second;
 }
 
-void mitk::AbstractUltrasoundTrackerDevice::SetCalibration(
-     mitk::AffineTransform3D::Pointer calibration )
+void mitk::AbstractUltrasoundTrackerDevice::SetCalibration(mitk::AffineTransform3D::Pointer calibration)
 {
-  if( calibration.IsNull() )
+  if (calibration.IsNull())
   {
     MITK_WARN << "Null pointer passed to SetCalibration of mitk::USDevice. Ignoring call.";
     return;
   }
 
   std::string calibrationKey = this->GetIdentifierForCurrentCalibration();
-  if( calibrationKey.empty() )
+  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() );
+  return this->RemoveCalibration(this->GetCurrentDepthValue(), this->GetIdentifierForCurrentProbe());
 }
 
 bool mitk::AbstractUltrasoundTrackerDevice::RemoveCalibration(std::string depth)
 {
-  return this->RemoveCalibration( depth,
-                                  this->GetIdentifierForCurrentProbe() );
+  return this->RemoveCalibration(depth, this->GetIdentifierForCurrentProbe());
 }
 
-bool mitk::AbstractUltrasoundTrackerDevice::RemoveCalibration( std::string depth,
-                                                               std::string probe )
+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;
+  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() )
+  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()
 {
   std::stringstream result;
   result << "<calibrations>" << std::endl;
   // For each calibration in the set
-  for( std::map<std::string,
-       mitk::AffineTransform3D::Pointer>::iterator it = m_Calibrations.begin();
-       it != m_Calibrations.end(); it++ )
+  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();
     TiXmlElement elem(it->first);
     // Serialize Matrix
     elem.SetDoubleAttribute("M00", matrix[0][0]);
     elem.SetDoubleAttribute("M01", matrix[0][1]);
     elem.SetDoubleAttribute("M02", matrix[0][2]);
     elem.SetDoubleAttribute("M10", matrix[1][0]);
     elem.SetDoubleAttribute("M11", matrix[1][1]);
     elem.SetDoubleAttribute("M12", matrix[1][2]);
     elem.SetDoubleAttribute("M20", matrix[2][0]);
     elem.SetDoubleAttribute("M21", matrix[2][1]);
     elem.SetDoubleAttribute("M22", matrix[2][2]);
     // Serialize Offset
     elem.SetDoubleAttribute("T0", translation[0]);
     elem.SetDoubleAttribute("T1", translation[1]);
     elem.SetDoubleAttribute("T2", translation[2]);
 
     result << elem << std::endl;
   }
   result << "</calibrations>" << std::endl;
 
   return result.str();
 }
 
-void mitk::AbstractUltrasoundTrackerDevice::DeserializeCalibration(
-                                              const std::string& xmlString,
-                                              bool clearPreviousCalibrations )
+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();
+  if (clearPreviousCalibrations)
+    m_Calibrations.clear();
 
   // Parse Input
   TiXmlDocument doc;
   if (!doc.Parse(xmlString.c_str()))
   {
     MITK_ERROR << "Unable to deserialize calibrations in CombinedModality. Error was: " << doc.ErrorDesc();
     mitkThrow() << "Unable to deserialize calibrations in CombinedModality. Error was: " << doc.ErrorDesc();
     return;
   }
-  TiXmlElement* root = doc.FirstChildElement();
+  TiXmlElement *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 (TiXmlElement* elem = root->FirstChildElement(); elem != nullptr; elem = elem->NextSiblingElement())
+  for (TiXmlElement *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 )
+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))
+  if ((oldNumber == 0 && numberOfSmoothingValues != 0) || (oldNumber != 0 && numberOfSmoothingValues == 0))
   {
     this->RebuildFilterPipeline();
   }
   m_SmoothingFilter->SetNumerOfValues(numberOfSmoothingValues);
 }
 
-void mitk::AbstractUltrasoundTrackerDevice::SetDelayCount( unsigned int delayCount )
+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))
+  if ((oldCount == 0 && delayCount != 0) || (oldCount != 0 && delayCount == 0))
   {
     this->RebuildFilterPipeline();
   }
   m_DelayFilter->SetDelay(delayCount);
 }
 
-void mitk::AbstractUltrasoundTrackerDevice::GenerateData()
-{
-}
+void mitk::AbstractUltrasoundTrackerDevice::GenerateData() {}
 
 std::string mitk::AbstractUltrasoundTrackerDevice::GetIdentifierForCurrentCalibration()
 {
-  return this->GetIdentifierForCurrentProbe()
-    + mitk::AbstractUltrasoundTrackerDevice::ProbeAndDepthSeperator
-    + this->GetCurrentDepthValue();
+  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);
+  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);
+  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 )
+  if (m_NumberOfSmoothingValues > 0)
   {
     m_SmoothingFilter->ConnectTo(m_LastFilterOfIGTPipeline.GetPointer());
     m_LastFilterOfIGTPipeline = m_SmoothingFilter;
   }
 
-  if( m_DelayCount > 0 )
+  if (m_DelayCount > 0)
   {
     m_DelayFilter->ConnectTo(m_LastFilterOfIGTPipeline.GetPointer());
     m_LastFilterOfIGTPipeline = m_DelayFilter;
   }
 
-  if( m_IsTrackedUltrasoundActive )
+  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();
+  // Get Context
+  us::ModuleContext *context = us::GetModuleContext();
 
-  //Define ServiceProps
-  //us::ServiceProperties props;
-  mitk::UIDGenerator uidGen =
-    mitk::UIDGenerator("org.mitk.services.AbstractUltrasoundTrackerDevice", 16);
+  // Define ServiceProps
+  // us::ServiceProperties props;
+  mitk::UIDGenerator uidGen = mitk::UIDGenerator("org.mitk.services.AbstractUltrasoundTrackerDevice", 16);
   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();
 }
diff --git a/Modules/US/USNavigation/mitkAbstractUltrasoundTrackerDevice.h b/Modules/US/USNavigation/mitkAbstractUltrasoundTrackerDevice.h
index 8e0f8bf705..03eb9b8728 100644
--- a/Modules/US/USNavigation/mitkAbstractUltrasoundTrackerDevice.h
+++ b/Modules/US/USNavigation/mitkAbstractUltrasoundTrackerDevice.h
@@ -1,257 +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.
 
 ===================================================================*/
 
 #ifndef __mitkAbstractUltrasoundTrackerDevice_h
 #define __mitkAbstractUltrasoundTrackerDevice_h
 
 #include <MitkUSNavigationExports.h>
 #include "mitkUSDevice.h"
 #include "mitkImageSource.h"
 #include "mitkNavigationDataSource.h"
 
 // Microservices
 #include <mitkServiceInterface.h>
 #include <usServiceRegistration.h>
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <usServiceProperties.h>
 #include <usModuleContext.h>
 
 namespace itk {
   template<class T> class SmartPointer;
 }
 
 namespace mitk {
   class NavigationDataSmoothingFilter;
   class NavigationDataDelayFilter;
   class NavigationDataDisplacementFilter;
 
   /**
   * \brief Abstract class for an easy handling of a combination of an USDevice and
   * a NavigationDataSource.
   * This class can be used as an ImageSource subclass. Additionally tracking data be
   * retrieved from the NavigationDataSource returned by GetTrackingDevice().
   *
   * A calibration of the ultrasound image stream to the navigation datas can be set
   * for the currently active zoom level (of the ultrasound device) by SetCalibration()
   * The ultrasound images are transformed according to this calibration in the
   * GenerateData() method.
   */
 
   class MITKUSNAVIGATION_EXPORT AbstractUltrasoundTrackerDevice : public mitk::ImageSource
   {
   public:
 
     static const std::string DeviceClassIdentifier;
     static const char*       DefaultProbeIdentifier;
     static const char*       ProbeAndDepthSeperator;
     static const std::string US_INTERFACE_NAME;
     static const std::string US_PROPKEY_DEVICENAME;
     static const std::string US_PROPKEY_CLASS;
     static const std::string US_PROPKEY_ID;
 
 
     mitkClassMacro(AbstractUltrasoundTrackerDevice, mitk::ImageSource);
     mitkNewMacro3Param(AbstractUltrasoundTrackerDevice, USDevice::Pointer, itk::SmartPointer<NavigationDataSource>, bool);
 
     itkGetMacro(UltrasoundDevice, itk::SmartPointer<USDevice>);
     itkSetMacro(UltrasoundDevice, itk::SmartPointer<USDevice>);
     itkGetMacro(TrackingDeviceDataSource, itk::SmartPointer<NavigationDataSource>);
     itkSetMacro(TrackingDeviceDataSource, itk::SmartPointer<NavigationDataSource>);
 
     itkGetMacro(IsTrackedUltrasoundActive, bool);
 
     /**
     * \brief Getter for calibration data of the currently active depth and probe.
     *
     * \return Transformation for calibration or null if no calibration is available.
     */
     AffineTransform3D::Pointer GetCalibration();
 
     /**
     * \brief Getter for calibration data of the given depth and the currently active probe.
     *
     * \param depth depth of the b mode ultrasound image for which the calibration should be returned
     * \return Transformation for calibration or null if no calibration is available.
     */
     AffineTransform3D::Pointer GetCalibration(std::string depth);
 
     /**
     * \brief Getter for calibration data of the given depth and probe.
     *
     * \param depth depth of the b mode ultrasound image for which the calibration should be returned
     * \param probe probe of the ultrasound device for which the calibration should be returned
     * \return Transformation for calibration or null if no calibration is available.
     */
     AffineTransform3D::Pointer GetCalibration(std::string depth, std::string probe);
 
+    /** Returns the index to world transform of the US plane. */
+    virtual AffineTransform3D::Pointer GetUSPlaneTransform();
+
     /**
     * \brief Sets a transformation as calibration data.
     * Calibration data is set for the currently activated probe and their current
     * zoom factor. It also marks the device as calibrated.
     */
     void SetCalibration(AffineTransform3D::Pointer calibration);
 
     /**
     * \brief Removes the calibration data of the currently active depth and probe.
     * \return true on success, false if there was no calibration
     */
     bool RemoveCalibration();
 
     /**
     * \brief Removes the calibration data of the given depth and the currently active probe.
     *
     * \param depth depth of the b mode ultrasound image for which the calibration should be removed
     * \return true on success, false if there was no calibration
     */
     bool RemoveCalibration(std::string depth);
 
     /**
     * \brief Removes the calibration data of the given depth and probe.
     *
     * \param depth depth of the b mode ultrasound image for which the calibration should be removed
     * \param probe probe of the ultrasound device for which the calibration should be removed
     * \return true on success, false if there was no calibration
     */
     bool RemoveCalibration(std::string depth, std::string probe);
 
     /**
     * \brief Returns the Class of the Device.
     */
     std::string GetDeviceClass();
 
     /**
     * \brief Wrapper for returning USImageSource of the UltrasoundDevice.
     */
     USImageSource::Pointer GetUSImageSource();
 
     itk::SmartPointer<mitk::NavigationDataSource> GetNavigationDataSource();
 
     /**
     * \return true if the device is calibrated for the currently selected probe with the current zoom level
     */
     bool GetIsCalibratedForCurrentStatus();
 
     /**
     * \return true if a calibration was loaded for at least one probe and depth
     */
     bool GetContainsAtLeastOneCalibration();
 
     /**
     * \brief Serializes all contained calibrations into an xml fragment.
     *
     * The returned string contains one parent node named "calibrations" and several
     * subnodes, one for each calibration that is present.
     */
     std::string SerializeCalibration();
 
     /**
     * \brief Deserializes a string provided by a prior call to Serialize().
     * If the bool flag is true, all prior calibrations will be deleted.
     * If the flag is set to false, prior calibrations will be retained, but overwritten
     * if one of equal name is present.
     *
     * \throws mitk::Exception if the given string could not be parsed correctly.
     */
     void DeserializeCalibration(const std::string &xmlString, bool clearPreviousCalibrations = true);
 
     void SetNumberOfSmoothingValues(unsigned int numberOfSmoothingValues);
 
     void SetDelayCount(unsigned int delayCount);
 
     /**
     * \brief Remove this device from the micro service.
     * This method is public for mitk::USCombinedModality, because this devices
     * can be completly removed. This is not possible for API devices, which
     * should be available while their sub module is loaded.
     */
     void UnregisterOnService();
 
     virtual void RegisterAsMicroservice();
 
     /**
     * \brief Wrapper for returning custom control interface of the UltrasoundDevice.
     */
     virtual itk::SmartPointer<USAbstractControlInterface> GetControlInterfaceCustom();
 
     /**
     * \brief Wrapper for returning B mode control interface of the UltrasoundDevice.
     */
     virtual itk::SmartPointer<USControlInterfaceBMode> GetControlInterfaceBMode();
 
     /**
     * \brief Wrapper for returning probes control interface of the UltrasoundDevice.
     */
     virtual itk::SmartPointer<USControlInterfaceProbes> GetControlInterfaceProbes();
 
     /**
     * \brief Wrapper for returning doppler control interface of the UltrasoundDevice.
     */
     virtual itk::SmartPointer<USControlInterfaceDoppler> GetControlInterfaceDoppler();
 
   protected:
     AbstractUltrasoundTrackerDevice( USDevice::Pointer usDevice,
                                      itk::SmartPointer<NavigationDataSource> trackingDevice,
                                      bool trackedUltrasoundActive );
     virtual ~AbstractUltrasoundTrackerDevice();
 
 
     /**
     * \brief Grabs the next frame from the input.
     * Must be implemented by the derived class.
     * This method is called internally, whenever Update() is invoked by an Output.
     */
     virtual void GenerateData() override;
 
     std::string GetIdentifierForCurrentCalibration();
     std::string GetIdentifierForCurrentProbe();
     std::string GetCurrentDepthValue();
 
     void RebuildFilterPipeline();
 
     USDevice::Pointer                                      m_UltrasoundDevice;
     itk::SmartPointer<NavigationDataSource>                m_TrackingDeviceDataSource;
     std::map<std::string, AffineTransform3D::Pointer>      m_Calibrations;
 
     itk::SmartPointer<mitk::NavigationDataSmoothingFilter> m_SmoothingFilter;
     itk::SmartPointer<mitk::NavigationDataDelayFilter>     m_DelayFilter;
     itk::SmartPointer<mitk::NavigationDataDisplacementFilter> m_DisplacementFilter;
     itk::SmartPointer<mitk::NavigationDataSource> m_LastFilterOfIGTPipeline;
 
     unsigned int m_NumberOfSmoothingValues;
     unsigned int m_DelayCount;
 
     /**
     *  \brief The device's ServiceRegistration object that allows to modify it's Microservice registraton details.
     */
     us::ServiceRegistration<Self>           m_ServiceRegistration;
 
     /**
     * \brief Properties of the device's Microservice.
     */
     us::ServiceProperties                   m_ServiceProperties;
 
   private:
 
 
     bool m_IsTrackedUltrasoundActive;
   };
 
 } // namespace mitk
 
 MITK_DECLARE_SERVICE_INTERFACE(mitk::AbstractUltrasoundTrackerDevice, "org.mitk.services.AbstractUltrasoundTrackerDevice")
 
 #endif
diff --git a/Modules/US/USNavigation/mitkTrackedUltrasound.cpp b/Modules/US/USNavigation/mitkTrackedUltrasound.cpp
index 774b3d9150..d8abef4d52 100644
--- a/Modules/US/USNavigation/mitkTrackedUltrasound.cpp
+++ b/Modules/US/USNavigation/mitkTrackedUltrasound.cpp
@@ -1,79 +1,84 @@
 /*===================================================================
 
 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 "mitkTrackedUltrasound.h"
 #include "mitkImageReadAccessor.h"
 #include <mitkNavigationDataSmoothingFilter.h>
 #include <mitkNavigationDataDelayFilter.h>
 #include "mitkNavigationDataDisplacementFilter.h"
 #include "mitkTrackingDeviceSource.h"
 
 
 
 
 mitk::TrackedUltrasound::TrackedUltrasound( USDevice::Pointer usDevice,
                                               NavigationDataSource::Pointer trackingDevice,
                                               bool trackedUltrasoundActive )
   : AbstractUltrasoundTrackerDevice( usDevice, trackingDevice, trackedUltrasoundActive )
 {
 }
 
 mitk::TrackedUltrasound::~TrackedUltrasound()
 {
 }
 
+mitk::AffineTransform3D::Pointer mitk::TrackedUltrasound::GetUSPlaneTransform()
+{
+  return m_UltrasoundDevice->GetOutput(0)->GetGeometry()->GetIndexToWorldTransform();
+}
+
 void mitk::TrackedUltrasound::GenerateData()
 {
   //Call Update auf US-Device + evtl. auf Tracker (???)
 
   if (m_UltrasoundDevice->GetIsFreezed()) { return; } //if the image is freezed: do nothing
 
   //get next image from ultrasound image source
   //FOR LATER: Be aware if the for loop behaves correct, if the UltrasoundDevice has more than 1 output.
   int i = 0;
   m_UltrasoundDevice->Update();
   mitk::Image::Pointer image = m_UltrasoundDevice->GetOutput(i);
   if (image.IsNull() || !image->IsInitialized()) //check the image
   {
     MITK_WARN << "Invalid image in TrackedUltrasound, aborting!";
     return;
   }
   //___MITK_INFO << "GetSpacing: " << image->GetGeometry()->GetSpacing();
 
   //get output and initialize it if it wasn't initialized before
   mitk::Image::Pointer output = this->GetOutput(i);
   if (!output->IsInitialized()) { output->Initialize(image); }
 
   //now update image data
   mitk::ImageReadAccessor inputReadAccessor(image, image->GetSliceData(0, 0, 0));
   output->SetSlice(inputReadAccessor.GetData()); //copy image data
   output->GetGeometry()->SetSpacing(image->GetGeometry()->GetSpacing()); //copy spacing because this might also change
  
   //and update calibration (= transformation of the image)
   std::string calibrationKey = this->GetIdentifierForCurrentCalibration();
   if (!calibrationKey.empty())
   {
     std::map<std::string, mitk::AffineTransform3D::Pointer>::iterator calibrationIterator
       = m_Calibrations.find(calibrationKey);
     if (calibrationIterator != m_Calibrations.end())
     {
       // transform image according to callibration if one is set
       // for current configuration of probe and depth
       m_DisplacementFilter->SetTransformation(calibrationIterator->second);
       //Setze Update auf Displacementfilter ????
     }
   }
 }
diff --git a/Modules/US/USNavigation/mitkTrackedUltrasound.h b/Modules/US/USNavigation/mitkTrackedUltrasound.h
index e05f650bd5..6395e63cb0 100644
--- a/Modules/US/USNavigation/mitkTrackedUltrasound.h
+++ b/Modules/US/USNavigation/mitkTrackedUltrasound.h
@@ -1,66 +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 __mitkTrackedUltrasound_h
 #define __mitkTrackedUltrasound_h
 
 #include <MitkUSNavigationExports.h>
 #include "mitkUSDevice.h"
 #include "mitkImageSource.h"
 #include "mitkAbstractUltrasoundTrackerDevice.h"
 #include "mitkNavigationDataSource.h"
 
 namespace itk {
   template<class T> class SmartPointer;
 }
 
 namespace mitk {
 
   /**
    * \brief Combination of USDevice and NavigationDataSource.
    * This class can be used as an ImageSource subclass. Additionally tracking data be
    * retrieved from the NavigationDataSource returned by GetTrackingDevice().
    *
    * A calibration of the ultrasound image stream to the navigation datas can be set
    * for the currently active zoom level (of the ultrasound device) by SetCalibration().
    * The ultrasound images are transformed according to this calibration in the
    * GenerateData() method.
    */
   class MITKUSNAVIGATION_EXPORT TrackedUltrasound : public mitk::AbstractUltrasoundTrackerDevice
   {
   public:
 
     mitkClassMacro(TrackedUltrasound, mitk::AbstractUltrasoundTrackerDevice);
     mitkNewMacro3Param(TrackedUltrasound, USDevice::Pointer, itk::SmartPointer<NavigationDataSource>, bool);
+    virtual AffineTransform3D::Pointer GetUSPlaneTransform();
 
 
 
 
   protected:
     TrackedUltrasound(  USDevice::Pointer usDevice,
                         itk::SmartPointer<NavigationDataSource> trackingDevice,
                         bool trackedUltrasoundActive = true );
     virtual ~TrackedUltrasound();
 
     /**
     * \brief Grabs the next frame from the input.
     * This method is called internally, whenever Update() is invoked by an Output.
     */
     void GenerateData() override;
 
   };
 } // namespace mitk
 #endif // __mitkTrackedUltrasound_h
diff --git a/Modules/US/USNavigation/mitkUSCombinedModality.cpp b/Modules/US/USNavigation/mitkUSCombinedModality.cpp
index b7c23d1470..4c9a33053c 100644
--- a/Modules/US/USNavigation/mitkUSCombinedModality.cpp
+++ b/Modules/US/USNavigation/mitkUSCombinedModality.cpp
@@ -1,77 +1,84 @@
 /*===================================================================
 
 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 "mitkUSCombinedModality.h"
 #include "mitkImageReadAccessor.h"
-#include <mitkNavigationDataSmoothingFilter.h>
-#include <mitkNavigationDataDelayFilter.h>
 #include "mitkTrackingDeviceSource.h"
+#include "mitkUSCombinedModality.h"
+#include <mitkNavigationDataDelayFilter.h>
+#include <mitkNavigationDataSmoothingFilter.h>
 
 // US Control Interfaces
-#include "mitkUSControlInterfaceProbes.h"
 #include "mitkUSControlInterfaceBMode.h"
 #include "mitkUSControlInterfaceDoppler.h"
+#include "mitkUSControlInterfaceProbes.h"
 
-mitk::USCombinedModality::USCombinedModality( USDevice::Pointer usDevice,
-                                              NavigationDataSource::Pointer trackingDevice,
-                                              bool trackedUltrasoundActive )
-  : AbstractUltrasoundTrackerDevice( usDevice, trackingDevice, trackedUltrasoundActive )
+mitk::USCombinedModality::USCombinedModality(USDevice::Pointer usDevice,
+                                             NavigationDataSource::Pointer trackingDevice,
+                                             bool trackedUltrasoundActive)
+  : AbstractUltrasoundTrackerDevice(usDevice, trackingDevice, trackedUltrasoundActive)
 {
 }
-
-mitk::USCombinedModality::~USCombinedModality()
+mitk::AffineTransform3D::Pointer mitk::USCombinedModality::GetUSPlaneTransform()
 {
+  return this->GetCalibration();
 }
 
+mitk::USCombinedModality::~USCombinedModality() {}
 
 void mitk::USCombinedModality::GenerateData()
 {
-  if (m_UltrasoundDevice->GetIsFreezed()) { return; } //if the image is freezed: do nothing
-  
-  //get next image from ultrasound image source
-  //FOR LATER: Be aware if the for loop behaves correct, if the UltrasoundDevice has more than 1 output.
+  if (m_UltrasoundDevice->GetIsFreezed())
+  {
+    return;
+  } // if the image is freezed: do nothing
+
+  // get next image from ultrasound image source
+  // FOR LATER: Be aware if the for loop behaves correct, if the UltrasoundDevice has more than 1 output.
   int i = 0;
   m_UltrasoundDevice->Update();
   mitk::Image::Pointer image = m_UltrasoundDevice->GetOutput(0);
-  if (image.IsNull() || !image->IsInitialized()) //check the image
+  if (image.IsNull() || !image->IsInitialized()) // check the image
   {
     MITK_WARN << "Invalid image in USCombinedModality, aborting!";
     return;
   }
 
-  //get output and initialize it if it wasn't initialized before
+  // get output and initialize it if it wasn't initialized before
   mitk::Image::Pointer output = this->GetOutput();
-  if (!output->IsInitialized()) { output->Initialize(image); }
+  if (!output->IsInitialized())
+  {
+    output->Initialize(image);
+  }
 
-  //now update image data
+  // now update image data
   mitk::ImageReadAccessor inputReadAccessor(image, image->GetSliceData(0, 0, 0));
-  output->SetSlice(inputReadAccessor.GetData()); //copy image data
-  output->GetGeometry()->SetSpacing(image->GetGeometry()->GetSpacing()); //copy spacing because this might also change
+  output->SetSlice(inputReadAccessor.GetData());                         // copy image data
+  output->GetGeometry()->SetSpacing(image->GetGeometry()->GetSpacing()); // copy spacing because this might also change
 
-  //and update calibration (= transformation of the image)
+  // and update calibration (= transformation of the image)
   std::string calibrationKey = this->GetIdentifierForCurrentCalibration();
   if (!calibrationKey.empty())
   {
-    std::map<std::string, mitk::AffineTransform3D::Pointer>::iterator calibrationIterator
-      = m_Calibrations.find(calibrationKey);
+    std::map<std::string, mitk::AffineTransform3D::Pointer>::iterator calibrationIterator =
+      m_Calibrations.find(calibrationKey);
     if (calibrationIterator != m_Calibrations.end())
     {
       // transform image according to callibration if one is set
       // for current configuration of probe and depth
       this->GetOutput()->GetGeometry()->SetIndexToWorldTransform(calibrationIterator->second);
     }
   }
 }
diff --git a/Modules/US/USNavigation/mitkUSCombinedModality.h b/Modules/US/USNavigation/mitkUSCombinedModality.h
index d9f5c3ae62..60963adcaf 100644
--- a/Modules/US/USNavigation/mitkUSCombinedModality.h
+++ b/Modules/US/USNavigation/mitkUSCombinedModality.h
@@ -1,71 +1,72 @@
 /*===================================================================
 
 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 MITKUSCombinedModality_H_HEADER_INCLUDED_
 #define MITKUSCombinedModality_H_HEADER_INCLUDED_
 
 #include <MitkUSNavigationExports.h>
 #include "mitkUSDevice.h"
 #include "mitkImageSource.h"
 #include "mitkAbstractUltrasoundTrackerDevice.h"
 #include "mitkNavigationDataSource.h"
 
 // Microservices
 #include <mitkServiceInterface.h>
 #include <usServiceRegistration.h>
 
 namespace itk {
   template<class T> class SmartPointer;
 }
 
 namespace mitk {
   class USControlInterfaceBMode;
   class USControlInterfaceProbes;
   class USControlInterfaceDoppler;
 
   /**
    * \brief Combination of USDevice and NavigationDataSource.
    * This class can be used as an ImageSource subclass. Additionally tracking data be
    * retrieved from the NavigationDataSource returned by GetTrackingDevice().
    *
    * A calibration of the ultrasound image stream to the navigation datas can be set
    * for the currently active zoom level (of the ultrasound device) by SetCalibration().
    * The ultrasound images are transformed according to this calibration in the
    * GenerateData() method.
    */
   class MITKUSNAVIGATION_EXPORT USCombinedModality : public mitk::AbstractUltrasoundTrackerDevice
   {
   public:
 
     mitkClassMacro(USCombinedModality, mitk::AbstractUltrasoundTrackerDevice);
     mitkNewMacro3Param(USCombinedModality, USDevice::Pointer, itk::SmartPointer<NavigationDataSource>, bool);
+    virtual AffineTransform3D::Pointer GetUSPlaneTransform();
 
   protected:
     USCombinedModality( USDevice::Pointer usDevice,
                         itk::SmartPointer<NavigationDataSource> trackingDevice,
                         bool trackedUltrasoundActive = false );
     virtual ~USCombinedModality();
 
     /**
     * \brief Grabs the next frame from the input.
     * This method is called internally, whenever Update() is invoked by an Output.
     */
     void GenerateData() override;
 
   };
 } // namespace mitk
 
 #endif // MITKUSCombinedModality_H_HEADER_INCLUDED_
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 4cc5291594..86635094b7 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,294 +1,294 @@
 /*===================================================================
 
 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 "../QmitkUSNavigationMarkerPlacement.h"
 
 #include "usModuleRegistry.h"
 
 #include <mitkTrackingTypes.h>
 
 QmitkUSNavigationStepPunctuationIntervention::QmitkUSNavigationStepPunctuationIntervention(QWidget *parent) :
   QmitkUSAbstractNavigationStep(parent),
   m_Ui(new Ui::QmitkUSNavigationStepPunctuationIntervention),
   m_ZoneNodes(nullptr),
   m_NeedleProjectionFilter(mitk::NeedleProjectionFilter::New()),
   m_NeedleNavigationTool(mitk::NavigationTool::New()),
   m_OldColors(),
   m_SphereSource(vtkSmartPointer<vtkSphereSource>::New()),
   m_OBBTree(vtkSmartPointer<vtkOBBTree>::New()),
   m_IntersectPoints(vtkSmartPointer<vtkPoints>::New())
 {
   m_Ui->setupUi(this);
   connect(m_Ui->m_AddNewAblationZone, SIGNAL(clicked()), this, SLOT(OnAddAblationZoneClicked()));
   connect(m_Ui->m_ShowToolAxisN, SIGNAL(stateChanged(int)), this, SLOT(OnShowToolAxisEnabled(int)));
   connect(m_Ui->m_EnableAblationMarking, SIGNAL(clicked()), this, SLOT(OnEnableAblationZoneMarkingClicked()));
   connect(m_Ui->m_AblationZoneSizeSlider, SIGNAL(valueChanged(int)), this, SLOT(OnAblationZoneSizeSliderChanged(int)));
   m_Ui->m_AblationZonesBox->setVisible(false);
 }
 
 void QmitkUSNavigationStepPunctuationIntervention::SetNeedleMetaData(mitk::NavigationTool::Pointer needleNavigationTool)
 
 {
   this->m_NeedleNavigationTool = needleNavigationTool;
 }
 
 void QmitkUSNavigationStepPunctuationIntervention::OnEnableAblationZoneMarkingClicked()
 {
   if(m_Ui->m_EnableAblationMarking->isChecked())
     m_Ui->m_AblationZonesBox->setVisible(true);
   else
     m_Ui->m_AblationZonesBox->setVisible(false);
 }
 
 void QmitkUSNavigationStepPunctuationIntervention::OnAblationZoneSizeSliderChanged(int size)
 {
 int id = m_Ui->m_AblationZonesList->currentRow();
 if (id!=-1) {emit AblationZoneChanged(id,size);}
 }//
 
 void QmitkUSNavigationStepPunctuationIntervention::OnAddAblationZoneClicked()
 {
   QListWidgetItem* newItem = new QListWidgetItem("Ablation Zone (initial size: " + QString::number(m_Ui->m_AblationZoneSizeSlider->value()) + " mm)", m_Ui->m_AblationZonesList);
   newItem->setSelected(true);
   emit AddAblationZoneClicked(m_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 m_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);
-  m_NeedleProjectionFilter->SetToolAxisForFilter(m_NeedleNavigationTool->GetToolAxis());
+  //m_NeedleProjectionFilter->SetToolAxisForFilter(m_NeedleNavigationTool->GetToolAxis());
   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(QmitkUSNavigationMarkerPlacement::DATANAME_ZONES));
 
   // add zones to the widgets for risk structures
   for (mitk::DataStorage::SetOfObjects::ConstIterator it = m_ZoneNodes->Begin();
        it != m_ZoneNodes->End(); ++it)
   {
     m_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::OnShowToolAxisEnabled(int enabled)
 {
   if (enabled == 0) { m_NeedleProjectionFilter->ShowToolAxis(false); }
   else { m_NeedleProjectionFilter->ShowToolAxis(true); }
 }
 
 void QmitkUSNavigationStepPunctuationIntervention::OnUpdate()
 {
   if (this->GetCombinedModality(false).IsNull()) return;
   // 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());
 
   m_NeedleProjectionFilter->Update();
 
   //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);
   m_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::AbstractUltrasoundTrackerDevice::Pointer combinedModality = this->GetCombinedModality(false);
   if ( combinedModality.IsNotNull() )
   {
     m_NeedleProjectionFilter->ConnectTo(combinedModality->GetNavigationDataSource());
 
     // set calibration of the combined modality to the needle projection filter
-    mitk::AffineTransform3D::Pointer calibration = combinedModality->GetCalibration();
-    if ( calibration.IsNotNull() )
+    mitk::AffineTransform3D::Pointer usPlaneTransform = combinedModality->GetUSPlaneTransform();
+    if (usPlaneTransform.IsNotNull())
     {
-      m_NeedleProjectionFilter->SetTargetPlane(calibration);
+      m_NeedleProjectionFilter->SetTargetPlane(usPlaneTransform);
     }
   }
   else
   {
     MITK_WARN << "CombinedModality is null!";
   }
 }
 
 void QmitkUSNavigationStepPunctuationIntervention::ClearZones()
 {
   m_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)
   {
     m_Ui->bodyMarkerTrackingStatusLabel->setStyleSheet(
       "background-color: #8bff8b; margin-right: 1em; margin-left: 1em; border: 1px solid grey");
     m_Ui->bodyMarkerTrackingStatusLabel->setText("Body marker is inside the tracking volume.");
   }
   else
   {
     m_Ui->bodyMarkerTrackingStatusLabel->setStyleSheet(
           "background-color: #ff7878; margin-right: 1em; margin-left: 1em; border: 1px solid grey");
     m_Ui->bodyMarkerTrackingStatusLabel->setText("Body marker is not inside the tracking volume.");
   }
 
   m_Ui->riskStructuresRangeGroupBox->setEnabled(valid);
 }
 
 void QmitkUSNavigationStepPunctuationIntervention::UpdateCriticalStructures(mitk::NavigationData::Pointer needle, mitk::PointSet::Pointer path)
 {
   // update the distances for the risk structures widget
   m_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;}
 }