diff --git a/Modules/US/USNavigation/mitkUSCombinedModality.cpp b/Modules/US/USNavigation/mitkUSCombinedModality.cpp
index 170ceab810..a7994121a1 100644
--- a/Modules/US/USNavigation/mitkUSCombinedModality.cpp
+++ b/Modules/US/USNavigation/mitkUSCombinedModality.cpp
@@ -1,492 +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.
 
 ===================================================================*/
 
 #include "mitkUSCombinedModality.h"
 #include "mitkUSDevice.h"
 #include "mitkNavigationDataSource.h"
 #include "mitkImageReadAccessor.h"
 #include <mitkNavigationDataSmoothingFilter.h>
 #include <mitkNavigationDataDelayFilter.h>
 #include "mitkTrackingDeviceSource.h"
 
 // US Control Interfaces
 #include "mitkUSControlInterfaceProbes.h"
 #include "mitkUSControlInterfaceBMode.h"
 #include "mitkUSControlInterfaceDoppler.h"
 
 //TempIncludes
 #include <tinyxml.h>
 
 const std::string mitk::USCombinedModality::DeviceClassIdentifier = "org.mitk.modules.us.USCombinedModality";
 
 mitk::USCombinedModality::USCombinedModality(USDevice::Pointer usDevice, NavigationDataSource::Pointer trackingDevice, std::string manufacturer, std::string model)
   : mitk::USDevice(manufacturer, model), m_UltrasoundDevice(usDevice), m_TrackingDevice(trackingDevice),
   m_SmoothingFilter(mitk::NavigationDataSmoothingFilter::New()), m_DelayFilter(mitk::NavigationDataDelayFilter::New(0)),
   m_NumberOfSmoothingValues(0), m_DelayCount(0)
 {
   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
   this->SetSpawnAcquireThread(false);
 }
 
 mitk::USCombinedModality::~USCombinedModality()
 {
 }
 
 std::string mitk::USCombinedModality::GetDeviceClass()
 {
   return DeviceClassIdentifier;
 }
 
 mitk::USImageSource::Pointer mitk::USCombinedModality::GetUSImageSource()
 {
   if (m_UltrasoundDevice.IsNull())
   {
     MITK_ERROR("USCombinedModality")("USDevice") << "UltrasoundDevice must not be null.";
     mitkThrow() << "UltrasoundDevice must not be null.";
   }
 
   return m_UltrasoundDevice->GetUSImageSource();
 }
 
 mitk::USAbstractControlInterface::Pointer mitk::USCombinedModality::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::USCombinedModality::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::USCombinedModality::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::USCombinedModality::GetControlInterfaceDoppler()
 {
   if (m_UltrasoundDevice.IsNull())
   {
     MITK_ERROR("USCombinedModality")("USDevice") << "UltrasoundDevice must not be null.";
     mitkThrow() << "UltrasoundDevice must not be null.";
   }
 
   return m_UltrasoundDevice->GetControlInterfaceDoppler();
 }
 
 void mitk::USCombinedModality::UnregisterOnService()
 {
   if (m_DeviceState == State_Activated) { this->Deactivate(); }
   if (m_DeviceState == State_Connected) { this->Disconnect(); }
 
   mitk::USDevice::UnregisterOnService();
 }
 
 mitk::AffineTransform3D::Pointer mitk::USCombinedModality::GetCalibration()
 {
   std::string calibrationKey = this->GetIdentifierForCurrentCalibration();
   if (calibrationKey.empty())
   {
     MITK_WARN("USCombinedModality")("USDevice")
         << "Could not get a key for the calibration.";
     return 0;
   }
 
   // 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())
   {
     MITK_WARN("USCombinedModality")("USDevice")
         << "No calibration found for selected probe and depth.";
     return 0;
   }
 
   return calibrationIterator->second;
 }
 
 void mitk::USCombinedModality::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;
 
   m_Metadata->SetDeviceIsCalibrated(true);
 
   if (m_ServiceRegistration != 0)
   {
     this->UpdateServiceProperty(mitk::USImageMetadata::PROP_DEV_ISCALIBRATED, true);
   }
 }
 
 void mitk::USCombinedModality::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::USCombinedModality::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);
 }
 
 bool mitk::USCombinedModality::OnInitialization()
 {
   if (m_UltrasoundDevice.IsNull())
   {
     MITK_ERROR("USCombinedModality")("USDevice") << "UltrasoundDevice must not be null.";
     mitkThrow() << "UltrasoundDevice must not be null.";
   }
 
   if ( m_UltrasoundDevice->GetDeviceState() < mitk::USDevice::State_Initialized )
   {
     return m_UltrasoundDevice->Initialize();
   }
   else
   {
     return true;
   }
 }
 
 bool mitk::USCombinedModality::OnConnection()
 {
   if (m_UltrasoundDevice.IsNull())
   {
     MITK_ERROR("USCombinedModality")("USDevice") << "UltrasoundDevice must not be null.";
     mitkThrow() << "UltrasoundDevice must not be null.";
   }
 
   // connect ultrasound device only if it is not already connected
   if ( m_UltrasoundDevice->GetDeviceState() >= mitk::USDevice::State_Connected )
   {
     return true;
   }
   else
   {
     return m_UltrasoundDevice->Connect();
   }
 }
 
 bool mitk::USCombinedModality::OnDisconnection()
 {
   if (m_UltrasoundDevice.IsNull())
   {
     MITK_ERROR("USCombinedModality")("USDevice") << "UltrasoundDevice must not be null.";
     mitkThrow() << "UltrasoundDevice must not be null.";
   }
 
   return m_UltrasoundDevice->Disconnect();
 }
 
 bool mitk::USCombinedModality::OnActivation()
 {
   if ( m_UltrasoundDevice.IsNull() )
   {
     MITK_ERROR("USCombinedModality")("USDevice") << "UltrasoundDevice must not be null.";
     mitkThrow() << "UltrasoundDevice must not be null.";
   }
 
   mitk::TrackingDeviceSource::Pointer trackingDeviceSource = dynamic_cast<mitk::TrackingDeviceSource*>(m_TrackingDevice.GetPointer());
   if ( trackingDeviceSource.IsNull() )
   {
     MITK_WARN("USCombinedModality")("USDevice") << "Cannot start tracking as TrackingDeviceSource is null.";
   }
   trackingDeviceSource->StartTracking();
 
   // activate ultrasound device only if it is not already activated
   if ( m_UltrasoundDevice->GetDeviceState() >= mitk::USDevice::State_Activated )
   {
     return true;
   }
   else
   {
     return m_UltrasoundDevice->Activate();
   }
 }
 
 bool mitk::USCombinedModality::OnDeactivation()
 {
   if ( m_UltrasoundDevice.IsNull() )
   {
     MITK_ERROR("USCombinedModality")("USDevice") << "UltrasoundDevice must not be null.";
     mitkThrow() << "UltrasoundDevice must not be null.";
   }
 
   mitk::TrackingDeviceSource::Pointer trackingDeviceSource = dynamic_cast<mitk::TrackingDeviceSource*>(m_TrackingDevice.GetPointer());
   if ( trackingDeviceSource.IsNull() )
   {
     MITK_WARN("USCombinedModality")("USDevice") << "Cannot stop tracking as TrackingDeviceSource is null.";
   }
   trackingDeviceSource->StopTracking();
 
   m_UltrasoundDevice->Deactivate();
 
   return m_UltrasoundDevice->GetIsConnected();
 }
 
 void mitk::USCombinedModality::OnFreeze(bool freeze)
 {
   if (m_UltrasoundDevice.IsNull())
   {
     MITK_ERROR("USCombinedModality")("USDevice") << "UltrasoundDevice must not be null.";
     mitkThrow() << "UltrasoundDevice must not be null.";
   }
   m_UltrasoundDevice->SetIsFreezed(freeze);
 
   mitk::TrackingDeviceSource::Pointer trackingDeviceSource = dynamic_cast<mitk::TrackingDeviceSource*>(m_TrackingDevice.GetPointer());
   if ( trackingDeviceSource.IsNull() )
   {
     MITK_WARN("USCombinedModality")("USDevice") << "Cannot freeze tracking.";
   }
   else
   {
     if ( freeze ) { trackingDeviceSource->StopTracking(); }
     else { trackingDeviceSource->StartTracking(); }
   }
 }
 
 mitk::NavigationDataSource::Pointer mitk::USCombinedModality::GetNavigationDataSource()
 {
   return m_LastFilter.GetPointer();
 }
 
 bool mitk::USCombinedModality::GetIsCalibratedForCurrentStatus()
 {
   return m_Calibrations.find(this->GetIdentifierForCurrentCalibration()) != m_Calibrations.end();
 }
 
+bool mitk::USCombinedModality::GetContainsAtLeastOneCalibration()
+{
+  return ! m_Calibrations.empty();
+}
+
 void mitk::USCombinedModality::GenerateData()
 {
   // update ultrasound image source and get current output then
   m_UltrasoundDevice->Modified();
   m_UltrasoundDevice->Update();
   mitk::Image::Pointer image = m_UltrasoundDevice->GetOutput();
   if ( image.IsNull() || ! image->IsInitialized() ) {
     return;
   }
 
   // get output and initialize it if it wasn't initialized before
   mitk::Image::Pointer output = this->GetOutput();
   if ( ! output->IsInitialized() ) { output->Initialize(image); }
 
   mitk::ImageReadAccessor inputReadAccessor(image, image->GetSliceData(0,0,0));
   output->SetSlice(inputReadAccessor.GetData());
 
   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
       output->GetGeometry()->SetIndexToWorldTransform(calibrationIterator->second);
     }
   }
 }
 
 std::string mitk::USCombinedModality::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++)
   {
     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::USCombinedModality::DeserializeCalibration(const std::string& xmlString, bool clearPreviousCalibrations)
 {
   // Sanitize Input
   if (xmlString == "")
   {
     MITK_WARN << "Empty string passed to Deserialize() method of CombinedModality. Aborting...";
     return;
   }
   // Clear previous calibrations if necessary
   if (clearPreviousCalibrations) m_Calibrations.clear();
 
   // Parse Input
   TiXmlDocument doc;
   if(!doc.Parse(xmlString.c_str()))
   {
     MITK_WARN << "Unable to deserialize calibrations in CombinedModality. Error was: " << doc.ErrorDesc();
     return;
   }
   TiXmlElement* root = doc.FirstChildElement();
   if(root == NULL)
   {
     MITK_WARN << "Unable to deserialize calibrations in CombinedModality. String contained no root element.";
     return;
   }
   // Read Calibrations
   for(TiXmlElement* elem = root->FirstChildElement(); elem != NULL; 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;
   }
 }
 
 std::string mitk::USCombinedModality::GetIdentifierForCurrentCalibration()
 {
   us::ServiceProperties::const_iterator probeIt = m_ServiceProperties.find(
         mitk::USCombinedModality::GetPropertyKeys().US_PROPKEY_PROBES_SELECTED);
 
   // get probe identifier from control interface for probes
   std::string probeName = "default";
   if (probeIt != m_ServiceProperties.end())
   {
     probeName = (probeIt->second).ToString();
   }
 
   // get string for depth value from the micro service properties
   std::string depth;
   us::ServiceProperties::iterator depthIterator = m_ServiceProperties.find(
         mitk::USCombinedModality::GetPropertyKeys().US_PROPKEY_BMODE_DEPTH);
   if (depthIterator != m_ServiceProperties.end())
   {
     depth = depthIterator->second.ToString();
   }
   else
   {
     depth = "0";
   }
 
   return probeName + depth;
 }
 
 void mitk::USCombinedModality::RebuildFilterPipeline()
 {
   m_LastFilter = m_TrackingDevice;
 
   if ( m_NumberOfSmoothingValues > 0 )
   {
     for (unsigned int i = 0; i < m_TrackingDevice->GetNumberOfOutputs(); i++)
     {
       m_SmoothingFilter->SetInput(i, m_LastFilter->GetOutput(i));
     }
     m_LastFilter = m_SmoothingFilter;
   }
 
   if ( m_DelayCount > 0 )
   {
     for (unsigned int i = 0; i < m_TrackingDevice->GetNumberOfOutputs(); i++)
     {
       m_DelayFilter->SetInput(i, m_LastFilter->GetOutput(i));
     }
     m_LastFilter = m_DelayFilter;
   }
 }
diff --git a/Modules/US/USNavigation/mitkUSCombinedModality.h b/Modules/US/USNavigation/mitkUSCombinedModality.h
index 3f8b8ab371..2f85d5f2cd 100644
--- a/Modules/US/USNavigation/mitkUSCombinedModality.h
+++ b/Modules/US/USNavigation/mitkUSCombinedModality.h
@@ -1,205 +1,210 @@
 /*===================================================================
 
 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 "mitkNavigationDataSource.h"
 
 namespace itk {
   template<class T> class SmartPointer;
 }
 
 namespace mitk {
   class NavigationDataSmoothingFilter;
   class NavigationDataDelayFilter;
   class USControlInterfaceBMode;
   class USControlInterfaceProbes;
   class USControlInterfaceDoppler;
 
   /**
    * \brief Combination of USDevice and NavigationDataSource.
    * This class can be used as any USDevice 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 USDevice
   {
   public:
     static const std::string DeviceClassIdentifier;
 
     mitkClassMacro(USCombinedModality, USDevice);
     mitkNewMacro4Param(USCombinedModality, USDevice::Pointer, itk::SmartPointer<NavigationDataSource>, std::string, std::string);
 
     itkGetMacro(UltrasoundDevice, itk::SmartPointer<USDevice>);
 
     itkSetMacro(UltrasoundDevice, itk::SmartPointer<USDevice>);
     itkSetMacro(TrackingDevice, itk::SmartPointer<NavigationDataSource>);
 
     /**
     * \brief Getter for calibration data of the currently active probe and depth.
     *
     * \return Transformation for calibration or null if no calibration is available.
     */
     AffineTransform3D::Pointer GetCalibration();
 
     /**
     * \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 Returns the Class of the Device.
     */
     virtual std::string GetDeviceClass();
 
     /**
     * \brief Wrapper for returning USImageSource of the UltrasoundDevice.
     */
     virtual USImageSource::Pointer GetUSImageSource();
 
     /**
     * \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();
 
     virtual 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 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();
 
     /**
     * \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.
     */
     void DeserializeCalibration(const std::string &xmlString, bool clearPreviousCalibrations = true);
 
     void SetNumberOfSmoothingValues(unsigned int numberOfSmoothingValues);
 
     void SetDelayCount(unsigned int delayCount);
 
   protected:
     USCombinedModality(USDevice::Pointer usDevice, itk::SmartPointer<NavigationDataSource> trackingDevice, std::string manufacturer = "", std::string model = "");
     virtual ~USCombinedModality();
 
     /**
     * \brief Initializes UltrasoundDevice.
     */
     virtual bool OnInitialization();
 
     /**
     * \brief Connects UltrasoundDevice.
     */
     virtual bool OnConnection();
 
     /**
     * \brief Disconnects UltrasoundDevice.
     */
     virtual bool OnDisconnection();
 
     /**
     * \brief Activates UltrasoundDevice.
     */
     virtual bool OnActivation();
 
     /**
     * \brief Deactivates UltrasoundDevice.
     */
     virtual bool OnDeactivation();
 
     /**
     * \brief Freezes or unfreezes UltrasoundDevice.
     */
     virtual void OnFreeze(bool);
 
     /**
     * \brief Grabs the next frame from the input.
     * This method is called internally, whenever Update() is invoked by an Output.
     */
     void GenerateData();
 
     std::string GetIdentifierForCurrentCalibration();
 
     void RebuildFilterPipeline();
 
     USDevice::Pointer                                      m_UltrasoundDevice;
     itk::SmartPointer<NavigationDataSource>                m_TrackingDevice;
     std::map<std::string, AffineTransform3D::Pointer>      m_Calibrations;
 
     itk::SmartPointer<mitk::NavigationDataSmoothingFilter> m_SmoothingFilter;
     itk::SmartPointer<mitk::NavigationDataDelayFilter>     m_DelayFilter;
     itk::SmartPointer<mitk::NavigationDataSource>          m_LastFilter;
 
     unsigned int m_NumberOfSmoothingValues;
     unsigned int m_DelayCount;
 
   private:
     /**
     *  \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;
   };
 } // namespace mitk
 
 #endif // MITKUSCombinedModality_H_HEADER_INCLUDED_