diff --git a/Modules/US/USModel/mitkUSDevice.cpp b/Modules/US/USModel/mitkUSDevice.cpp
index b21a44d3f6..a5ef150a61 100644
--- a/Modules/US/USModel/mitkUSDevice.cpp
+++ b/Modules/US/USModel/mitkUSDevice.cpp
@@ -1,556 +1,559 @@
 /*===================================================================
 
 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 "mitkUSDevice.h"
 #include "mitkImageReadAccessor.h"
 
 // US Control Interfaces
 #include "mitkUSControlInterfaceProbes.h"
 #include "mitkUSControlInterfaceBMode.h"
 #include "mitkUSControlInterfaceDoppler.h"
 
 // Microservices
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <usServiceProperties.h>
 #include <usModuleContext.h>
 
 mitk::USDevice::PropertyKeys mitk::USDevice::GetPropertyKeys()
 {
   static mitk::USDevice::PropertyKeys propertyKeys;
   return propertyKeys;
 }
 
 mitk::USDevice::USImageCropArea mitk::USDevice::GetCropArea()
 {
   MITK_INFO << "Return Crop Area L:" << m_CropArea.cropLeft
     << " R:" << m_CropArea.cropRight << " T:" << m_CropArea.cropTop
     << " B:" << m_CropArea.cropBottom;
   return m_CropArea;
 }
 
 mitk::USDevice::USDevice(std::string manufacturer, std::string model)
   : mitk::ImageSource(),
   m_IsFreezed(false),
   m_DeviceState(State_NoState),
   m_Manufacturer(manufacturer),
   m_Name(model),
   m_SpawnAcquireThread(true),
   m_MultiThreader(itk::MultiThreader::New()),
   m_ImageMutex(itk::FastMutexLock::New()),
   m_ThreadID(-1),
   m_UnregisteringStarted(false)
 {
   USImageCropArea empty;
   empty.cropBottom = 0;
   empty.cropTop = 0;
   empty.cropLeft = 0;
   empty.cropRight = 0;
   this->m_CropArea = empty;
 
   //set number of outputs
   this->SetNumberOfIndexedOutputs(1);
 
   //create a new output
   mitk::Image::Pointer newOutput = mitk::Image::New();
   this->SetNthOutput(0,newOutput);
 }
 
 mitk::USDevice::USDevice(mitk::USImageMetadata::Pointer metadata)
   : mitk::ImageSource(),
   m_IsFreezed(false),
   m_DeviceState(State_NoState),
   m_SpawnAcquireThread(true),
   m_MultiThreader(itk::MultiThreader::New()),
   m_ImageMutex(itk::FastMutexLock::New()),
   m_ThreadID(-1),
   m_UnregisteringStarted(false)
 {
   m_Manufacturer = metadata->GetDeviceManufacturer();
   m_Name = metadata->GetDeviceModel();
   m_Comment = metadata->GetDeviceComment();
 
   USImageCropArea empty;
   empty.cropBottom = 0;
   empty.cropTop = 0;
   empty.cropLeft = 0;
   empty.cropRight = 0;
   this->m_CropArea = empty;
 
   //set number of outputs
   this->SetNumberOfIndexedOutputs(1);
 
   //create a new output
   mitk::Image::Pointer newOutput = mitk::Image::New();
   this->SetNthOutput(0,newOutput);
 }
 
 mitk::USDevice::~USDevice()
 {
   if (m_ThreadID >= 0)
   {
     m_MultiThreader->TerminateThread(m_ThreadID);
   }
 
   // make sure that the us device is not registered at the micro service
   // anymore after it is destructed
   this->UnregisterOnService();
 }
 
 mitk::USAbstractControlInterface::Pointer mitk::USDevice::GetControlInterfaceCustom()
 {
   MITK_INFO << "Custom control interface does not exist for this object.";
   return 0;
 }
 
 mitk::USControlInterfaceBMode::Pointer mitk::USDevice::GetControlInterfaceBMode()
 {
   MITK_INFO << "Control interface BMode does not exist for this object.";
   return 0;
 }
 
 mitk::USControlInterfaceProbes::Pointer mitk::USDevice::GetControlInterfaceProbes()
 {
   MITK_INFO << "Control interface Probes does not exist for this object.";
   return 0;
 }
 
 mitk::USControlInterfaceDoppler::Pointer mitk::USDevice::GetControlInterfaceDoppler()
 {
   MITK_INFO << "Control interface Doppler does not exist for this object.";
   return 0;
 }
 
 void mitk::USDevice::SetManufacturer(std::string manufacturer)
 {
   m_Manufacturer = manufacturer;
   if ( m_DeviceState >= State_Initialized )
   {
     this->UpdateServiceProperty(mitk::USDevice::GetPropertyKeys().US_PROPKEY_MANUFACTURER, manufacturer);
   }
 }
 
 void mitk::USDevice::SetName(std::string name)
 {
   m_Name = name;
   if ( m_DeviceState >= State_Initialized )
   {
     this->UpdateServiceProperty(mitk::USDevice::GetPropertyKeys().US_PROPKEY_NAME, name);
   }
 }
 
 void mitk::USDevice::SetComment(std::string comment)
 {
   m_Comment = comment;
   if ( m_DeviceState >= State_Initialized )
   {
     this->UpdateServiceProperty(mitk::USDevice::GetPropertyKeys().US_PROPKEY_COMMENT, comment);
   }
 }
 
 us::ServiceProperties mitk::USDevice::ConstructServiceProperties()
 {
   mitk::USDevice::PropertyKeys propertyKeys = mitk::USDevice::GetPropertyKeys();
 
   us::ServiceProperties props;
 
   props[propertyKeys.US_PROPKEY_ISCONNECTED] = this->GetIsConnected() ? "true" : "false";
   props[propertyKeys.US_PROPKEY_ISACTIVE] = this->GetIsActive() ? "true" : "false";
 
   props[propertyKeys.US_PROPKEY_LABEL] = this->GetServicePropertyLabel();
 
   // get identifier of selected probe if there is one selected
   mitk::USControlInterfaceProbes::Pointer probesControls = this->GetControlInterfaceProbes();
   if (probesControls.IsNotNull() && probesControls->GetIsActive())
   {
     mitk::USProbe::Pointer probe = probesControls->GetSelectedProbe();
     if (probe.IsNotNull())
     {
       props[propertyKeys.US_PROPKEY_PROBES_SELECTED] = probe->GetName();
     }
   }
 
   props[ propertyKeys.US_PROPKEY_CLASS ] = GetDeviceClass();
   props[ propertyKeys.US_PROPKEY_MANUFACTURER ] = m_Manufacturer;
   props[ propertyKeys.US_PROPKEY_NAME ] = m_Name;
   props[ propertyKeys.US_PROPKEY_COMMENT ] = m_Comment;
 
   m_ServiceProperties = props;
 
   return props;
 }
 
 void mitk::USDevice::UnregisterOnService()
 {
   // unregister on micro service
   if ( m_ServiceRegistration && ! m_UnregisteringStarted)
   {
     // make sure that unregister is not started a second
     // time due to a callback during unregister for example
     m_UnregisteringStarted = true;
     m_ServiceRegistration.Unregister();
     m_ServiceRegistration = 0;
   }
 }
 
 bool mitk::USDevice::Initialize()
 {
   if (! this->OnInitialization() ) { return false; }
 
   m_DeviceState = State_Initialized;
 
   // Get Context and Module
   us::ModuleContext* context = us::GetModuleContext();
   us::ServiceProperties props = this->ConstructServiceProperties();
 
   m_ServiceRegistration = context->RegisterService(this, props);
 
   return true;
 }
 
 bool mitk::USDevice::Connect()
 {
   if ( this->GetIsConnected() )
   {
     MITK_INFO("mitkUSDevice") << "Tried to connect an ultrasound device that was already connected. Ignoring call...";
     return true;
   }
 
   if ( ! this->GetIsInitialized() )
   {
     MITK_ERROR("mitkUSDevice") << "Cannot connect device if it is not in initialized state.";
     return false;
   }
 
   // Prepare connection, fail if this fails.
   if ( ! this->OnConnection() ) { return false; }
 
   // Update state
   m_DeviceState = State_Connected;
 
   this->UpdateServiceProperty(mitk::USDevice::GetPropertyKeys().US_PROPKEY_ISCONNECTED, true);
   return true;
 }
 
 void mitk::USDevice::ConnectAsynchron()
 {
   this->m_MultiThreader->SpawnThread(this->ConnectThread, this);
 }
 
 bool mitk::USDevice::Disconnect()
 {
   if ( ! GetIsConnected())
   {
     MITK_WARN << "Tried to disconnect an ultrasound device that was not connected. Ignoring call...";
     return false;
   }
   // Prepare connection, fail if this fails.
   if (! this->OnDisconnection()) return false;
 
   // Update state
   m_DeviceState = State_Initialized;
 
   this->UpdateServiceProperty(mitk::USDevice::GetPropertyKeys().US_PROPKEY_ISCONNECTED, false);
 
   return true;
 }
 
 bool mitk::USDevice::Activate()
 {
   if (! this->GetIsConnected())
   {
     MITK_INFO("mitkUSDevice") << "Cannot activate device if it is not in connected state.";
     return true;
   }
 
   if ( OnActivation() )
   {
     m_DeviceState = State_Activated;
 
     m_FreezeBarrier = itk::ConditionVariable::New();
 
     // spawn thread for aquire images if us device is active
     if (m_SpawnAcquireThread)
     {
       this->m_ThreadID = this->m_MultiThreader->SpawnThread(this->Acquire, this);
     }
 
     this->UpdateServiceProperty(mitk::USDevice::GetPropertyKeys().US_PROPKEY_ISACTIVE, true);
     this->UpdateServiceProperty(mitk::USDevice::GetPropertyKeys().US_PROPKEY_LABEL, this->GetServicePropertyLabel());
 
     // initialize the b mode control properties of the micro service
     mitk::USControlInterfaceBMode::Pointer bmodeControls = this->GetControlInterfaceBMode();
     if ( bmodeControls.IsNotNull() ) { bmodeControls->Initialize(); }
   }
 
   return m_DeviceState == State_Activated;
 }
 
 void mitk::USDevice::Deactivate()
 {
   if ( ! this->GetIsActive() )
   {
     MITK_WARN("mitkUSDevice")
       << "Cannot deactivate a device which is not activae.";
     return;
   }
 
   if ( ! OnDeactivation() ) { return; }
 
   m_DeviceState = State_Connected;
 
   this->UpdateServiceProperty(mitk::USDevice::GetPropertyKeys().US_PROPKEY_ISACTIVE, false);
   this->UpdateServiceProperty(mitk::USDevice::GetPropertyKeys().US_PROPKEY_LABEL, this->GetServicePropertyLabel());
 }
 
 void mitk::USDevice::SetIsFreezed(bool freeze)
 {
   if ( ! this->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;
 
     // wake up the image acquisition thread
     m_FreezeBarrier->Signal();
   }
 }
 
 bool mitk::USDevice::GetIsFreezed()
 {
   if ( ! this->GetIsActive() )
   {
     MITK_WARN("mitkUSDevice")("mitkUSTelemedDevice")
       << "Cannot get freeze state if the hardware interface is not ready. Returning false...";
     return false;
   }
 
   return m_IsFreezed;
 }
 
 void mitk::USDevice::PushFilter(AbstractOpenCVImageFilter::Pointer filter)
 {
   mitk::USImageSource::Pointer imageSource = this->GetUSImageSource();
   if ( imageSource.IsNull() )
   {
     MITK_ERROR << "ImageSource must not be null when pushing a filter.";
     mitkThrow() << "ImageSource must not be null when pushing a filter.";
   }
 
   imageSource->PushFilter(filter);
 }
 
 void mitk::USDevice::PushFilterIfNotPushedBefore(AbstractOpenCVImageFilter::Pointer filter)
 {
   mitk::USImageSource::Pointer imageSource = this->GetUSImageSource();
   if ( imageSource.IsNull() )
   {
     MITK_ERROR << "ImageSource must not be null when pushing a filter.";
     mitkThrow() << "ImageSource must not be null when pushing a filter.";
   }
 
   if ( ! imageSource->GetIsFilterInThePipeline(filter) )
   {
     imageSource->PushFilter(filter);
   }
 }
 
 bool mitk::USDevice::RemoveFilter(AbstractOpenCVImageFilter::Pointer filter)
 {
   mitk::USImageSource::Pointer imageSource = this->GetUSImageSource();
   if ( imageSource.IsNull() )
   {
     MITK_ERROR << "ImageSource must not be null when pushing a filter.";
     mitkThrow() << "ImageSource must not be null when removing a filter.";
   }
 
   return imageSource->RemoveFilter(filter);
 }
 
 void mitk::USDevice::UpdateServiceProperty(std::string key, std::string value)
 {
   m_ServiceProperties[ key ] = value;
   m_ServiceRegistration.SetProperties(m_ServiceProperties);
+
+  // send event to notify listeners about the changed property
+  m_PropertyChangedMessage(key, value);
 }
 
 void mitk::USDevice::UpdateServiceProperty(std::string key, double value)
 {
   std::stringstream stream;
   stream << value;
   this->UpdateServiceProperty(key, stream.str());
 }
 
 void mitk::USDevice::UpdateServiceProperty(std::string key, bool value)
 {
   this->UpdateServiceProperty(key, value ? std::string("true") : std::string("false"));
 }
 
 /**
 mitk::Image* mitk::USDevice::GetOutput()
 {
 if (this->GetNumberOfOutputs() < 1)
 return NULL;
 
 return static_cast<USImage*>(this->ProcessObject::GetPrimaryOutput());
 }
 
 mitk::Image* mitk::USDevice::GetOutput(unsigned int idx)
 {
 if (this->GetNumberOfOutputs() < 1)
 return NULL;
 return static_cast<USImage*>(this->ProcessObject::GetOutput(idx));
 }
 
 void mitk::USDevice::GraftOutput(itk::DataObject *graft)
 {
 this->GraftNthOutput(0, graft);
 }
 
 void mitk::USDevice::GraftNthOutput(unsigned int idx, itk::DataObject *graft)
 {
 if ( idx >= this->GetNumberOfOutputs() )
 {
 itkExceptionMacro(<<"Requested to graft output " << idx <<
 " but this filter only has " << this->GetNumberOfOutputs() << " Outputs.");
 }
 
 if ( !graft )
 {
 itkExceptionMacro(<<"Requested to graft output with a NULL pointer object" );
 }
 
 itk::DataObject* output = this->GetOutput(idx);
 if ( !output )
 {
 itkExceptionMacro(<<"Requested to graft output that is a NULL pointer" );
 }
 // Call Graft on USImage to copy member data
 output->Graft( graft );
 }
 
 */
 
 void mitk::USDevice::GrabImage()
 {
   mitk::Image::Pointer image = this->GetUSImageSource()->GetNextImage();
   m_ImageMutex->Lock();
   this->SetImage(image);
   m_ImageMutex->Unlock();
 }
 
 //########### GETTER & SETTER ##################//
 
 bool mitk::USDevice::GetIsInitialized()
 {
   return m_DeviceState == State_Initialized;
 }
 
 bool mitk::USDevice::GetIsActive()
 {
   return m_DeviceState == State_Activated;
 }
 
 bool mitk::USDevice::GetIsConnected()
 {
   return m_DeviceState == State_Connected;
 }
 
 std::string mitk::USDevice::GetDeviceManufacturer(){
   return m_Manufacturer;
 }
 
 std::string mitk::USDevice::GetDeviceModel(){
   return m_Name;
 }
 
 std::string mitk::USDevice::GetDeviceComment(){
   return m_Comment;
 }
 
 void mitk::USDevice::GenerateData()
 {
   m_ImageMutex->Lock();
 
   if ( m_Image.IsNull() || ! m_Image->IsInitialized() ) { m_ImageMutex->Unlock(); return; }
 
   mitk::Image::Pointer output = this->GetOutput();
 
   if ( ! output->IsInitialized()
     || output->GetDimension(0) != m_Image->GetDimension(0) || output->GetDimension(1) != m_Image->GetDimension(1) )
   {
     output->Initialize(m_Image->GetPixelType(), m_Image->GetDimension(), m_Image->GetDimensions());
   }
 
   mitk::ImageReadAccessor inputReadAccessor(m_Image, m_Image->GetSliceData(0,0,0));
   output->SetSlice(inputReadAccessor.GetData());
 
   m_ImageMutex->Unlock();
 };
 
 std::string mitk::USDevice::GetServicePropertyLabel()
 {
   std::string isActive;
   if (this->GetIsActive()) { isActive = " (Active)"; }
   else { isActive = " (Inactive)"; }
   // e.g.: Zonare MyLab5 (Active)
   return m_Manufacturer + " " + m_Name + isActive;
 }
 
 ITK_THREAD_RETURN_TYPE mitk::USDevice::Acquire(void* pInfoStruct)
 {
   /* extract this pointer from Thread Info structure */
   struct itk::MultiThreader::ThreadInfoStruct * pInfo = (struct itk::MultiThreader::ThreadInfoStruct*)pInfoStruct;
   mitk::USDevice* device = (mitk::USDevice*) pInfo->UserData;
   while (device->GetIsActive())
   {
     // lock this thread when ultrasound device is freezed
     if ( device->m_IsFreezed )
     {
       itk::SimpleMutexLock* mutex = &(device->m_FreezeMutex);
       mutex->Lock();
 
       if (device->m_FreezeBarrier.IsNotNull())
       {
         device->m_FreezeBarrier->Wait(mutex);
       }
     }
 
     device->GrabImage();
   }
   return ITK_THREAD_RETURN_VALUE;
 }
 
 ITK_THREAD_RETURN_TYPE mitk::USDevice::ConnectThread(void* pInfoStruct)
 {
   /* extract this pointer from Thread Info structure */
   struct itk::MultiThreader::ThreadInfoStruct * pInfo = (struct itk::MultiThreader::ThreadInfoStruct*)pInfoStruct;
   mitk::USDevice* device = (mitk::USDevice*) pInfo->UserData;
 
   device->Connect();
 
   return ITK_THREAD_RETURN_VALUE;
 }
diff --git a/Modules/US/USModel/mitkUSDevice.h b/Modules/US/USModel/mitkUSDevice.h
index b622e7d168..4f89fb7811 100644
--- a/Modules/US/USModel/mitkUSDevice.h
+++ b/Modules/US/USModel/mitkUSDevice.h
@@ -1,429 +1,436 @@
 /*===================================================================
 
 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 MITKUSDevice_H_HEADER_INCLUDED_
 #define MITKUSDevice_H_HEADER_INCLUDED_
 
 // STL
 #include <vector>
 
 // MitkUS
 #include "mitkUSProbe.h"
 #include <MitkUSExports.h>
 #include "mitkUSImageSource.h"
 
 // MITK
 #include <mitkCommon.h>
+#include <mitkMessage.h>
 #include <mitkImageSource.h>
 
 // ITK
 #include <itkObjectFactory.h>
 #include <itkConditionVariable.h>
 
 // Microservices
 #include <usServiceInterface.h>
 #include <usServiceRegistration.h>
 #include <usServiceProperties.h>
 
 // DEPRECATED
 #include "mitkUSImageMetadata.h"
 
 namespace itk {
 template<class T> class SmartPointer;
 }
 
 namespace mitk {
 class USAbstractControlInterface;
 class USControlInterfaceBMode;
 class USControlInterfaceProbes;
 class USControlInterfaceDoppler;
 
   /**
   * \brief A device holds information about it's model, make and the connected probes. It is the
   * common super class for all devices and acts as an image source for mitkUSImages. It is the base class
   * for all US Devices, and every new device should extend it.
   *
   * US Devices support output of calibrated images, i.e. images that include a specific geometry.
   * To achieve this, call SetCalibration, and make sure that the subclass also calls apply
   * transformation at some point (The USDevice does not automatically apply the transformation to the image)
   *
   * Note that USDevices will be removed from micro servive when their
   * destructor is called. Registering into micro service is done when
   * mitk::USDevice::Initialize() is called.
   *
   * \ingroup US
   */
 
   class MitkUS_EXPORT USDevice : public mitk::ImageSource
   {
   public:
     enum DeviceStates { State_NoState, State_Initialized, State_Connected, State_Activated };
 
     mitkClassMacro(USDevice, mitk::ImageSource);
 
     struct USImageCropArea
     {
       int cropLeft;
       int cropRight;
       int cropBottom;
       int cropTop;
     };
 
     /**
      * \brief These constants are used in conjunction with Microservices.
      * The constants aren't defined as static member attributes to avoid the
      * "static initialization order fiasco", which would occur when objects of
      * this class are used in module activators (for restoring stored device,
      * for example).
      */
     struct PropertyKeys
     {
       const std::string US_INTERFACE_NAME;       // Common Interface name of all US Devices. Used to refer to this device via Microservices
       const std::string US_PROPKEY_MANUFACTURER;
       const std::string US_PROPKEY_NAME;
       const std::string US_PROPKEY_COMMENT;
       const std::string US_PROPKEY_LABEL;        // Human readable text represntation of this device
       const std::string US_PROPKEY_ISCONNECTED;  // Whether this device is connected or not.
       const std::string US_PROPKEY_ISACTIVE;     // Whether this device is active or not.
       const std::string US_PROPKEY_CLASS;        // Class Name of this Object
 
       const std::string US_PROPKEY_PROBES_SELECTED;
 
       const std::string US_PROPKEY_BMODE_FREQUENCY;
       const std::string US_PROPKEY_BMODE_POWER;
       const std::string US_PROPKEY_BMODE_DEPTH;
       const std::string US_PROPKEY_BMODE_GAIN;
       const std::string US_PROPKEY_BMODE_REJECTION;
       const std::string US_PROPKEY_BMODE_DYNAMIC_RANGE;
 
       PropertyKeys()
         : US_INTERFACE_NAME("org.mitk.services.UltrasoundDevice"),
           US_PROPKEY_MANUFACTURER(US_INTERFACE_NAME + ".manufacturer"),
           US_PROPKEY_NAME(US_INTERFACE_NAME + ".name"),
           US_PROPKEY_COMMENT(US_INTERFACE_NAME + ".comment"),
           US_PROPKEY_LABEL(US_INTERFACE_NAME + ".label"),
           US_PROPKEY_ISCONNECTED(US_INTERFACE_NAME + ".isConnected"),
           US_PROPKEY_ISACTIVE(US_INTERFACE_NAME + ".isActive"),
           US_PROPKEY_CLASS(US_INTERFACE_NAME + ".class"),
           US_PROPKEY_PROBES_SELECTED(US_INTERFACE_NAME + ".probes.selected"),
           US_PROPKEY_BMODE_FREQUENCY(US_INTERFACE_NAME + ".bmode.frequency"),
           US_PROPKEY_BMODE_POWER(US_INTERFACE_NAME + ".bmode.power"),
           US_PROPKEY_BMODE_DEPTH(US_INTERFACE_NAME + ".bmode.depth"),
           US_PROPKEY_BMODE_GAIN(US_INTERFACE_NAME + ".bmode.gain"),
           US_PROPKEY_BMODE_REJECTION(US_INTERFACE_NAME + ".bmode.rejection"),
           US_PROPKEY_BMODE_DYNAMIC_RANGE(US_INTERFACE_NAME + ".bmode.dynamicRange")
       {}
     };
 
+    /**
+     * \brief Event for being notified about changes of the micro service properties.
+     * This event can be used if no micro service context is available.
+     */
+    mitkNewMessage2Macro(PropertyChanged, const std::string&, const std::string&)
+
     /**
      * \return keys for the microservice properties of ultrasound devices
      */
     static mitk::USDevice::PropertyKeys GetPropertyKeys();
 
     /**
     * \brief Default getter for the custom control interface.
     * Has to be implemented in a subclass if a custom control interface is
     * available. Default implementation returns null.
     *
     * \return null pointer
     */
     virtual itk::SmartPointer<USAbstractControlInterface>   GetControlInterfaceCustom();
 
     /**
     * \brief Default getter for the b mode control interface.
     * Has to be implemented in a subclass if a b mode control interface is
     * available. Default implementation returns null.
     *
     * \return null pointer
     */
     virtual itk::SmartPointer<USControlInterfaceBMode>      GetControlInterfaceBMode();
 
     /**
     * \brief Default getter for the probes control interface.
     * Has to be implemented in a subclass if a probes control interface is
     * available. Default implementation returns null.
     *
     * \return null pointer
     */
     virtual itk::SmartPointer<USControlInterfaceProbes>     GetControlInterfaceProbes();
 
     /**
     * \brief Default getter for the doppler control interface.
     * Has to be implemented in a subclass if a doppler control interface is
     * available. Default implementation returns null.
     *
     * \return null pointer
     */
     virtual itk::SmartPointer<USControlInterfaceDoppler>    GetControlInterfaceDoppler();
 
     /**
     * \brief Changes device state to mitk::USDevice::State_Initialized.
     * During initialization the virtual method
     * mitk::USDevice::OnInitialization will be called. If this method
     * returns false the initialization process will be canceled. Otherwise
     * the mitk::USDevice is registered in a micro service.
     */
     bool Initialize();
 
     /**
     * \brief Connects this device. A connected device is ready to deliver images (i.e. be Activated). A Connected Device can be active. A disconnected Device cannot be active.
     *  Internally calls onConnect and then registers the device with the service. A device usually should
     *  override the OnConnection() method, but never the Connect() method, since this will possibly exclude the device
     *  from normal service management. The exact flow of events is:
     *  0. Check if the device is already connected. If yes, return true anyway, but don't do anything.
     *  1. Call OnConnection() Here, a device should establish it's connection with the hardware Afterwards, it should be ready to start transmitting images at any time.
     *  2. If OnConnection() returns true ("successful"), then the device is registered with the service.
     *  3. if not, it the method itself returns false or may throw an expection, depeneding on the device implementation.
     *
     */
     bool Connect();
 
     void ConnectAsynchron();
 
     /**
     * \brief Works analogously to mitk::USDevice::Connect(). Don't override this Method, but onDisconnection instead.
     */
     bool Disconnect();
 
     /**
     * \brief Activates this device.
     * After the activation process, the device will start to produce images.
     * This Method will fail, if the device is not connected.
     */
     bool Activate();
 
     /**
     * \brief Deactivates this device.
     * After the deactivation process, the device will no longer produce
     * images, but still be connected.
     */
     void Deactivate();
 
     /**
     * \brief Can toggle if ultrasound image is currently updated or freezed.
     *
     * \param freeze true to stop updating the ultrasound image, false to start updating again
     */
     virtual void SetIsFreezed(bool freeze);
 
     /**
     * \return true if device is currently freezed (no image update is done), false otherwise
     */
     virtual bool GetIsFreezed();
 
     void PushFilter(AbstractOpenCVImageFilter::Pointer filter);
     void PushFilterIfNotPushedBefore(AbstractOpenCVImageFilter::Pointer filter);
     bool RemoveFilter(AbstractOpenCVImageFilter::Pointer filter);
 
     /**
     * \brief Given property is updated in the device micro service.
     * This method is mainly for being used by the control interface
     * superclasses. You do not need to call it by yoursefs in your
     * concrete control interface classes.
     */
     void UpdateServiceProperty(std::string key, std::string value);
     void UpdateServiceProperty(std::string key, double value);
     void UpdateServiceProperty(std::string key, bool value);
 
     //########### GETTER & SETTER ##################//
 
     /**
     * \brief Returns the Class of the Device. This Method must be reimplemented by every Inheriting Class.
     */
     virtual std::string GetDeviceClass() = 0;
 
     /**
     * \brief True, if the device object is created and initialized, false otherwise.
     */
     bool GetIsInitialized();
 
     /**
     * \brief True, if the device is currently generating image data, false otherwise.
     */
     bool GetIsActive();
 
     /**
     * \brief True, if the device is currently ready to start transmitting image data or is already
     * transmitting image data. A disconnected device cannot be activated.
     */
     bool GetIsConnected();
 
     /* @return Returns the area that will be cropped from the US image. Is disabled / [0,0,0,0] by default. */
     mitk::USDevice::USImageCropArea GetCropArea();
 
     /** \deprecated Deprecated -> use GetManufacturer() instead */
     std::string GetDeviceManufacturer();
     /** \deprecated Deprecated -> use GetName() instead */
     std::string GetDeviceModel();
     /** \\deprecated Deprecated -> use GetCommend() instead */
     std::string GetDeviceComment();
 
     itkGetMacro(Manufacturer, std::string);
     itkGetMacro(Name, std::string);
     itkGetMacro(Comment, std::string);
 
     void SetManufacturer(std::string manufacturer);
     void SetName(std::string name);
     void SetComment(std::string comment);
 
     itkGetMacro(DeviceState, DeviceStates)
     itkGetMacro(ServiceProperties, us::ServiceProperties)
 
     void GrabImage();
 
     virtual USImageSource::Pointer GetUSImageSource() = 0;
 
   protected:
     itkSetMacro(Image, mitk::Image::Pointer);
     itkSetMacro(SpawnAcquireThread, bool);
     itkGetMacro(SpawnAcquireThread, bool);
 
     static ITK_THREAD_RETURN_TYPE Acquire(void* pInfoStruct);
     static ITK_THREAD_RETURN_TYPE ConnectThread(void* pInfoStruct);
 
     mitk::Image::Pointer m_Image;
     mitk::Image::Pointer m_OutputImage;
 
     bool m_IsFreezed;
 
     DeviceStates m_DeviceState;
 
     /* @brief defines the area that should be cropped from the US image */
     USImageCropArea m_CropArea;
 
     /**
     * \brief This Method constructs the service properties which can later be used to
     *  register the object with the Microservices
     *  Return service properties
     */
     us::ServiceProperties ConstructServiceProperties();
 
     /**
     * \brief Remove this device from the micro service.
     */
     void UnregisterOnService();
 
     /**
     * \brief Is called during the initialization process.
     * Override this method in a subclass to handle the actual initialization.
     * If it returns false, the initialization process will be canceled.
     *
     * \return true if successful and false if unsuccessful
     * \throw mitk::Exception implementation may throw an exception to clarify what went wrong
     */
     virtual bool OnInitialization() = 0;
 
     /**
     * \brief Is called during the connection process.
     * Override this method in a subclass to handle the actual connection.
     * If it returns false, the connection process will be canceled.
     *
     * \return true if successful and false if unsuccessful
     * \throw mitk::Exception implementation may throw an exception to clarify what went wrong
     */
     virtual bool OnConnection() = 0;
 
     /**
     * \brief Is called during the disconnection process.
     * Override this method in a subclass to handle the actual disconnection.
     * If it returns false, the disconnection process will be canceled.
     *
     * \return true if successful and false if unsuccessful
     * \throw mitk::Exception implementation may throw an exception to clarify what went wrong
     */
     virtual bool OnDisconnection() = 0;
 
     /**
     * \brief Is called during the activation process.
     * After this method is finished, the device should be generating images.
     * If it returns false, the activation process will be canceled.
     *
     * \return true if successful and false if unsuccessful
     * \throw mitk::Exception implementation may throw an exception to clarify what went wrong
     */
     virtual bool OnActivation() = 0;
 
     /**
     * \brief Is called during the deactivation process.
     * After a call to this method the device should still be connected,
     * but not producing images anymore.
     *
     * \return true if successful and false if unsuccessful
     * \throw mitk::Exception implementation may throw an exception to clarify what went wrong
     */
     virtual bool OnDeactivation() = 0;
 
     /**
     * \brief Called when mitk::USDevice::SetIsFreezed() is called.
     * Subclasses can overwrite this method to do additional actions. Default
     * implementation does noting.
     */
     virtual void OnFreeze(bool) { }
 
     /**
     * \brief Enforces minimal Metadata to be set.
     */
     USDevice(std::string manufacturer, std::string model);
 
     /**
     * \brief Constructs a device with the given Metadata. Make sure the Metadata contains meaningful content!
     * \deprecated Use USDevice(std::string manufacturer, std::string model) instead.
     */
     USDevice(mitk::USImageMetadata::Pointer metadata);
 
     virtual ~USDevice();
 
     /**
     * \brief Grabs the next frame from the Video input.
     * This method is called internally, whenever Update() is invoked by an Output.
     */
     virtual void GenerateData();
 
     std::string GetServicePropertyLabel();
 
   private:
 
     std::string m_Manufacturer;
     std::string m_Name;
     std::string m_Comment;
 
     bool m_SpawnAcquireThread;
 
     /**
     *  \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;
 
     // Threading-Related
     itk::ConditionVariable::Pointer m_FreezeBarrier;
     itk::SimpleMutexLock        m_FreezeMutex;
     itk::MultiThreader::Pointer m_MultiThreader; ///< itk::MultiThreader used for thread handling
     itk::FastMutexLock::Pointer m_ImageMutex; ///< mutex for images provided by the image source
     int m_ThreadID; ///< ID of the started thread
 
     bool m_UnregisteringStarted;
   };
 } // namespace mitk
 
 // This is the microservice declaration. Do not meddle!
 US_DECLARE_SERVICE_INTERFACE(mitk::USDevice, "org.mitk.services.UltrasoundDevice")
 
 #endif // MITKUSDevice_H_HEADER_INCLUDED_