diff --git a/Modules/IGTUI/Qmitk/QmitkTrackingDeviceConfigurationWidget.cpp b/Modules/IGTUI/Qmitk/QmitkTrackingDeviceConfigurationWidget.cpp
index 5c0ebff1f0..9676f660e9 100644
--- a/Modules/IGTUI/Qmitk/QmitkTrackingDeviceConfigurationWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkTrackingDeviceConfigurationWidget.cpp
@@ -1,678 +1,716 @@
 /*===================================================================
 
 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 "QmitkTrackingDeviceConfigurationWidget.h"
 #include <mitkClaronTrackingDevice.h>
 #include <mitkNDITrackingDevice.h>
 #include <mitkOptitrackTrackingDevice.h>
 #include <mitkIGTException.h>
 #include <mitkSerialCommunication.h>
 #include <mitkProgressBar.h>
 #include <qscrollbar.h>
 #include <qmessagebox.h>
 #include <qfiledialog.h>
 #include <mitkIGTException.h>
+#include <QSettings>
 
 #include <itksys/SystemTools.hxx>
 #include <Poco/Path.h>
 
 
 
 const std::string QmitkTrackingDeviceConfigurationWidget::VIEW_ID = "org.mitk.views.trackingdeviceconfigurationwidget";
 
 QmitkTrackingDeviceConfigurationWidget::QmitkTrackingDeviceConfigurationWidget(QWidget* parent, Qt::WindowFlags f)
   : QWidget(parent, f)
 {
   //initialize worker thread
   m_TestConnectionWorker = new QmitkTrackingDeviceConfigurationWidgetConnectionWorker();
   m_ScanPortsWorker = new QmitkTrackingDeviceConfigurationWidgetScanPortsWorker();
   m_ScanPortsWorkerThread = new QThread();
   m_TestConnectionWorkerThread = new QThread();
 
   m_Controls = NULL;
   CreateQtPartControl(this);
   CreateConnections();
   m_MTCalibrationFile = "";
 
 
 
   //reset a few things
   ResetOutput();
   AddOutput("<br>NDI Polaris selected");
   this->m_TrackingDeviceConfigurated = false;
 
   m_AdvancedUserControl = true;
 }
 
 void QmitkTrackingDeviceConfigurationWidget::SetGUIStyle(QmitkTrackingDeviceConfigurationWidget::Style style)
 {
 switch(style)
   {
   case QmitkTrackingDeviceConfigurationWidget::SIMPLE:
 
     //move all UI elements to an empty dummy layout
     //m_Controls->dummyLayout->addItem(m_Controls->mainLayout);
     m_Controls->dummyLayout->addWidget(m_Controls->widget_title_label);
     m_Controls->dummyLayout->addWidget(m_Controls->choose_tracking_device_label);
     m_Controls->dummyLayout->addWidget(m_Controls->polaris_label);
     m_Controls->dummyLayout->addWidget(m_Controls->aurora_label);
     //m_Controls->dummyLayout->addWidget(m_Controls->aurora_label);
     m_Controls->dummyLayout->addWidget(m_Controls->microntracker_label);
     m_Controls->dummyLayout->addWidget(m_Controls->m_testConnectionMicronTracker);
     m_Controls->dummyLayout->addWidget(m_Controls->m_outputTextMicronTracker);
     m_Controls->dummyLayout->addWidget(m_Controls->m_outputTextAurora);
     m_Controls->dummyLayout->addWidget(m_Controls->m_testConnectionAurora);
     m_Controls->dummyLayout->addWidget(m_Controls->m_outputTextPolaris);
     m_Controls->dummyLayout->addWidget(m_Controls->m_testConnectionPolaris);
     m_Controls->dummyLayout->addWidget(m_Controls->m_polarisTrackingModeBox);
     m_Controls->dummyLayout->addWidget(m_Controls->m_testConnectionOptitrack);
     m_Controls->dummyLayout->addWidget(m_Controls->m_outputTextOptitrack);
     m_Controls->dummyLayout->addWidget(m_Controls->m_OptitrackExp);
     m_Controls->dummyLayout->addWidget(m_Controls->m_OptitrackThr);
     m_Controls->dummyLayout->addWidget(m_Controls->m_OptitrackLed);
     m_Controls->dummyLayout->addWidget(m_Controls->Optitrack_label);
     m_Controls->dummyLayout->addWidget(m_Controls->m_finishedLine);
     m_Controls->dummyLayout->addWidget(m_Controls->line);
     m_Controls->dummyLayout->addWidget(m_Controls->configuration_finished_label);
     m_Controls->dummyLayout->addItem(m_Controls->horizontalLayout_4);
     m_Controls->mainLayout->removeItem(m_Controls->horizontalLayout_4);
     m_Controls->dummyLayout->addWidget(m_Controls->configuration_finished_label);
     m_Controls->dummyLayout->addItem(m_Controls->verticalSpacer_2);
     m_Controls->verticalLayout_3->removeItem(m_Controls->verticalSpacer_2);
     m_Controls->dummyLayout->addItem(m_Controls->horizontalSpacer_9);
     m_Controls->horizontalLayout_9->removeItem(m_Controls->horizontalSpacer_9);
     m_Controls->dummyLayout->addItem(m_Controls->horizontalSpacer_3);
     m_Controls->horizontalLayout_11->removeItem(m_Controls->horizontalSpacer_3);
     m_Controls->dummyLayout->addItem(m_Controls->verticalSpacer_3);
     m_Controls->verticalLayout_7->removeItem(m_Controls->verticalSpacer_3);
     m_Controls->dummyLayout->addItem(m_Controls->verticalSpacer_4);
     m_Controls->verticalLayout_10->removeItem(m_Controls->verticalSpacer_4);
     m_Controls->dummyLayout->addItem(m_Controls->horizontalSpacer_10);
     m_Controls->verticalLayout_10->removeItem(m_Controls->horizontalSpacer_10);
 
     //set height to min
     m_Controls->m_outputTextPolaris->setMinimumHeight(0);
     m_Controls->m_outputTextPolaris->setMaximumHeight(0);
     m_Controls->m_outputTextMicronTracker->setMinimumHeight(0);
     m_Controls->m_outputTextMicronTracker->setMaximumHeight(0);
     m_Controls->m_outputTextAurora->setMinimumHeight(0);
     m_Controls->m_outputTextAurora->setMaximumHeight(0);
     m_Controls->m_finishedButton->setMinimumHeight(0);
     m_Controls->m_finishedButton->setMaximumHeight(0);
     m_Controls->m_resetButton->setMinimumHeight(0);
     m_Controls->m_resetButton->setMaximumHeight(0);
 
 
     //set the height of the tracking device combo box
     m_Controls->m_trackingDeviceChooser->setMinimumHeight(50);
 
     //move back the used elemets to the main layout
     m_Controls->simpleLayout->addWidget(m_Controls->m_trackingDeviceChooser);
     m_Controls->simpleLayout->addWidget(m_Controls->m_TrackingSystemWidget);
 
     m_Controls->mainWidget->setCurrentIndex(1);
 
     this->setMaximumHeight(150);
 
     this->EnableAdvancedUserControl(false);
 
 
     break;
 
   case QmitkTrackingDeviceConfigurationWidget::ADVANCED:
 
     //default at the moment => start settings are advanced
 
     break;
 
   }
 
 }
 
 QmitkTrackingDeviceConfigurationWidget::~QmitkTrackingDeviceConfigurationWidget()
 {
 StoreUISettings();
 if (m_ScanPortsWorker) delete m_ScanPortsWorker;
 if (m_TestConnectionWorker) delete m_TestConnectionWorker;
 if (m_ScanPortsWorkerThread) delete m_ScanPortsWorkerThread;
 if (m_TestConnectionWorkerThread) delete m_TestConnectionWorkerThread;
 }
 
 void QmitkTrackingDeviceConfigurationWidget::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
   // create GUI widgets
   m_Controls = new Ui::QmitkTrackingDeviceConfigurationWidgetControls;
   m_Controls->setupUi(parent);
   }
 }
 
 void QmitkTrackingDeviceConfigurationWidget::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_trackingDeviceChooser), SIGNAL(currentIndexChanged(int)), this, SLOT(TrackingDeviceChanged()) );
     connect( (QObject*)(m_Controls->m_testConnectionPolaris), SIGNAL(clicked()), this, SLOT(TestConnection()) );
     connect( (QObject*)(m_Controls->m_testConnectionAurora), SIGNAL(clicked()), this, SLOT(TestConnection()) );
     connect( (QObject*)(m_Controls->m_testConnectionMicronTracker), SIGNAL(clicked()), this, SLOT(TestConnection()) );
     connect( (QObject*)(m_Controls->m_testConnectionOptitrack), SIGNAL(clicked()), this, SLOT(TestConnection()) );
     connect( (QObject*)(m_Controls->m_resetButton), SIGNAL(clicked()), this, SLOT(ResetByUser()) );
     connect( (QObject*)(m_Controls->m_finishedButton), SIGNAL(clicked()), this, SLOT(Finished()) );
     connect( (QObject*)(m_Controls->m_AutoScanPolaris), SIGNAL(clicked()), this, SLOT(AutoScanPorts()) );
     connect( (QObject*)(m_Controls->m_AutoScanAurora), SIGNAL(clicked()), this, SLOT(AutoScanPorts()) );
     connect( (QObject*)(m_Controls->m_SetMTCalibrationFile), SIGNAL(clicked()), this, SLOT(SetMTCalibrationFileClicked()) );
     connect( (QObject*)(m_Controls->m_SetOptitrackCalibrationFile), SIGNAL(clicked()), this, SLOT(SetOptitrackCalibrationFileClicked()) );
 
     //slots for the worker thread
     connect(m_ScanPortsWorker, SIGNAL(PortsScanned(int,int,QString,int,int)), this, SLOT(AutoScanPortsFinished(int,int,QString,int,int)) );
     connect(m_TestConnectionWorker, SIGNAL(ConnectionTested(bool,QString)), this, SLOT(TestConnectionFinished(bool,QString)) );
     connect(m_ScanPortsWorkerThread,SIGNAL(started()), m_ScanPortsWorker, SLOT(ScanPortsThreadFunc()) );
     connect(m_TestConnectionWorkerThread,SIGNAL(started()), m_TestConnectionWorker, SLOT(TestConnectionThreadFunc()) );
 
     //move the worker to the thread
     m_ScanPortsWorker->moveToThread(m_ScanPortsWorkerThread);
     m_TestConnectionWorker->moveToThread(m_TestConnectionWorkerThread);
 
     //set a few UI components depending on Windows / Linux
     #ifdef WIN32
     m_Controls->portTypeLabelPolaris->setVisible(false);
     m_Controls->portTypePolaris->setVisible(false);
     m_Controls->portTypeLabelAurora->setVisible(false);
     m_Controls->portTypeAurora->setVisible(false);
     #else
     m_Controls->comPortLabelAurora->setText("Port Nr:");
     m_Controls->m_comPortLabelPolaris->setText("Port Nr:");
     m_Controls->m_portSpinBoxAurora->setPrefix("");
     m_Controls->m_portSpinBoxPolaris->setPrefix("");
     #endif
 
     //disable unused UI component
     m_Controls->m_polarisTrackingModeBox->setVisible(false); //don't delete this component, because it is used in the MBI part of MITK
   }
   LoadUISettings();
 }
 
 void QmitkTrackingDeviceConfigurationWidget::TrackingDeviceChanged()
 {
   //show the correspondig widget
   m_Controls->m_TrackingSystemWidget->setCurrentIndex(m_Controls->m_trackingDeviceChooser->currentIndex());
 
   //the new trackingdevice is not configurated yet
   m_TrackingDeviceConfigurated = false;
 
   //reset output
   ResetOutput();
 
   //print output and do further initializations
   if (m_Controls->m_trackingDeviceChooser->currentIndex()==0)//NDI Polaris
     {
     AddOutput("<br>NDI Polaris selected");
     }
   else if (m_Controls->m_trackingDeviceChooser->currentIndex()==1)  //NDI Aurora
     {
     AddOutput("<br>NDI Aurora selected");
     }
   else if (m_Controls->m_trackingDeviceChooser->currentIndex()==2) //ClaronTechnology MicronTracker 2
     {
     AddOutput("<br>Microntracker selected");
     if (!mitk::ClaronTrackingDevice::New()->IsDeviceInstalled())
       {
       AddOutput("<br>ERROR: not installed!");
       }
     else if (this->m_MTCalibrationFile == "") //if configuration file for MicronTracker is empty: load default
       {
       mitk::ClaronTrackingDevice::Pointer tempDevice = mitk::ClaronTrackingDevice::New();
       m_MTCalibrationFile = tempDevice->GetCalibrationDir();
       Poco::Path myPath = Poco::Path(m_MTCalibrationFile.c_str());
       m_Controls->m_MTCalibrationFile->setText("Calibration File: " + QString(myPath.getFileName().c_str()));
       }
     }
   else if (m_Controls->m_trackingDeviceChooser->currentIndex()==3)
   {
     AddOutput("<br>Optitrack selected");
     if (!mitk::OptitrackTrackingDevice::New()->IsDeviceInstalled())
       {
       AddOutput("<br>ERROR: not installed!");
       }
   }
 
 emit TrackingDeviceSelectionChanged();
 }
 
 void QmitkTrackingDeviceConfigurationWidget::EnableUserReset(bool enable)
 {
   if (enable) m_Controls->m_resetButton->setVisible(true);
   else m_Controls->m_resetButton->setVisible(false);
 }
 
 void QmitkTrackingDeviceConfigurationWidget::TestConnection()
 {
 this->setEnabled(false);
 //construct a tracking device:
 mitk::TrackingDevice::Pointer testTrackingDevice = ConstructTrackingDevice();
 m_TestConnectionWorker->SetTrackingDevice(testTrackingDevice);
 m_TestConnectionWorkerThread->start();
 emit ProgressStarted();
 }
 
 void QmitkTrackingDeviceConfigurationWidget::TestConnectionFinished(bool connected, QString output)
 {
 m_TestConnectionWorkerThread->quit();
 AddOutput(output.toStdString());
 MITK_INFO << "Test connection: " << connected;
 this->setEnabled(true);
 emit ProgressFinished();
 }
 
 void QmitkTrackingDeviceConfigurationWidget::Finished()
   {
   m_TrackingDevice = ConstructTrackingDevice();
   m_Controls->m_TrackingSystemWidget->setEnabled(false);
   m_Controls->m_trackingDeviceChooser->setEnabled(false);
   m_Controls->choose_tracking_device_label->setEnabled(false);
   m_Controls->configuration_finished_label->setText("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0//EN\" \"http://www.w3.org/TR/REC-html40/strict.dtd\">\n<html><head><meta name=\"qrichtext\" content=\"1\" /><style type=\"text/css\">\np, li { white-space: pre-wrap; }\n</style></head><body style=\" font-family:\'MS Shell Dlg 2\'; font-size:8.25pt; font-weight:400; font-style:normal;\">\n<p align=\"right\" style=\" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px; font-size:8pt;\"><span style=\" font-weight:600;\">Configuration finished</span></p></body></html>");
   this->m_TrackingDeviceConfigurated = true;
   emit TrackingDeviceConfigurationFinished();
   }
 
 void QmitkTrackingDeviceConfigurationWidget::Reset()
   {
   m_TrackingDevice = NULL;
   m_Controls->m_TrackingSystemWidget->setEnabled(true);
   m_Controls->m_trackingDeviceChooser->setEnabled(true);
   m_Controls->choose_tracking_device_label->setEnabled(true);
   m_Controls->configuration_finished_label->setText("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0//EN\" \"http://www.w3.org/TR/REC-html40/strict.dtd\">\n<html><head><meta name=\"qrichtext\" content=\"1\" /><style type=\"text/css\">\np, li { white-space: pre-wrap; }\n</style></head><body style=\" font-family:\'MS Shell Dlg 2\'; font-size:8.25pt; font-weight:400; font-style:normal;\">\n<p align=\"right\" style=\" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px; font-size:8pt;\"><span style=\" font-weight:600;\">Press \"Finished\" to confirm configuration</span></p></body></html>");
   this->m_TrackingDeviceConfigurated = false;
   emit TrackingDeviceConfigurationReseted();
   }
 
 void QmitkTrackingDeviceConfigurationWidget::ResetByUser()
   {
   Reset();
   }
 
 void QmitkTrackingDeviceConfigurationWidget::AutoScanPorts()
   {
   this->setEnabled(false);
   AddOutput("<br>Scanning...");
   m_ScanPortsWorkerThread->start();
   emit ProgressStarted();
   }
 
 void QmitkTrackingDeviceConfigurationWidget::AutoScanPortsFinished(int PolarisPort, int AuroraPort, QString result, int PortTypePolaris, int PortTypeAurora)
   {
   m_ScanPortsWorkerThread->quit();
   #ifdef WIN32
     if((PortTypePolaris!=-1)||(PortTypeAurora!=-1)) {MITK_WARN << "Port type is specified although this should not be the case for Windows. Ignoring port type.";}
   #else //linux systems
     if (PortTypePolaris!=-1) {m_Controls->portTypePolaris->setCurrentIndex(PortTypePolaris);}
     if (PortTypeAurora!=-1)  {m_Controls->portTypeAurora->setCurrentIndex(PortTypeAurora);}
   #endif
   m_Controls->m_portSpinBoxPolaris->setValue(PolarisPort);
   m_Controls->m_portSpinBoxAurora->setValue(AuroraPort);
   AddOutput(result.toStdString());
   this->setEnabled(true);
   emit ProgressFinished();
   }
 
 void QmitkTrackingDeviceConfigurationWidget::SetMTCalibrationFileClicked()
   {
   std::string filename = QFileDialog::getOpenFileName(NULL,tr("Open Calibration File"), "/", "*.*").toAscii().data();
   if (filename=="") {return;}
   else
     {
     m_MTCalibrationFile = filename;
     Poco::Path myPath = Poco::Path(m_MTCalibrationFile.c_str());
     m_Controls->m_MTCalibrationFile->setText("Calibration File: " + QString(myPath.getFileName().c_str()));
     }
   }
 
 void QmitkTrackingDeviceConfigurationWidget::SetOptitrackCalibrationFileClicked()
   {
   std::string filename = QFileDialog::getOpenFileName(NULL,tr("Open Calibration File"), "/", "*.*").toAscii().data();
   if (filename=="") {return;}
   else
     {
     m_OptitrackCalibrationFile = filename;
     Poco::Path myPath = Poco::Path(m_OptitrackCalibrationFile.c_str());
     m_Controls->m_OptitrackCalibrationFile->setText("Calibration File: " + QString(myPath.getFileName().c_str()));
     }
   }
 //######################### internal help methods #######################################
 void QmitkTrackingDeviceConfigurationWidget::ResetOutput()
   {
   m_output.str("");
   m_output <<"<body style=\" font-family:\'MS Shell Dlg 2\'; font-size:7pt; font-weight:400; font-style:normal;\" bgcolor=black><span style=\"color:#ffffff;\"><u>output:</u>";
   m_Controls->m_outputTextAurora->setHtml(QString(m_output.str().c_str()));
   m_Controls->m_outputTextPolaris->setHtml(QString(m_output.str().c_str()));
   m_Controls->m_outputTextMicronTracker->setHtml(QString(m_output.str().c_str()));
   }
 void QmitkTrackingDeviceConfigurationWidget::AddOutput(std::string s)
   {
   //print output
   m_output << s;
   m_Controls->m_outputTextAurora->setHtml(QString(m_output.str().c_str()));
   m_Controls->m_outputTextPolaris->setHtml(QString(m_output.str().c_str()));
   m_Controls->m_outputTextMicronTracker->setHtml(QString(m_output.str().c_str()));
   m_Controls->m_outputTextOptitrack->setHtml(QString(m_output.str().c_str()));
   m_Controls->m_outputTextPolaris->verticalScrollBar()->setValue(m_Controls->m_outputTextPolaris->verticalScrollBar()->maximum());
   m_Controls->m_outputTextAurora->verticalScrollBar()->setValue(m_Controls->m_outputTextAurora->verticalScrollBar()->maximum());
   m_Controls->m_outputTextMicronTracker->verticalScrollBar()->setValue(m_Controls->m_outputTextMicronTracker->verticalScrollBar()->maximum());
   m_Controls->m_outputTextOptitrack->verticalScrollBar()->setValue(m_Controls->m_outputTextOptitrack->verticalScrollBar()->maximum());
   repaint();
   }
 mitk::TrackingDevice::Pointer QmitkTrackingDeviceConfigurationWidget::ConstructTrackingDevice()
   {
   mitk::TrackingDevice::Pointer returnValue;
   //#### Step 1: configure tracking device:
   if (m_Controls->m_trackingDeviceChooser->currentIndex()==0)//NDI Polaris
       {
       if(m_Controls->m_radioPolaris5D->isChecked()) //5D Tracking
         {
         //not yet in the open source part so we'll only get NULL here.
         returnValue = ConfigureNDI5DTrackingDevice();
         }
       else //6D Tracking
         {
         returnValue = ConfigureNDI6DTrackingDevice();
         returnValue->SetType(mitk::NDIPolaris);
         }
       }
   else if (m_Controls->m_trackingDeviceChooser->currentIndex()==1)//NDI Aurora
         {
         returnValue = ConfigureNDI6DTrackingDevice();
         returnValue->SetType(mitk::NDIAurora);
         }
   else if (m_Controls->m_trackingDeviceChooser->currentIndex()==2)//ClaronTechnology MicronTracker 2
         {
 
         mitk::ClaronTrackingDevice::Pointer newDevice = mitk::ClaronTrackingDevice::New();
         if(this->m_MTCalibrationFile=="") AddOutput("<br>Warning: Calibration file is not set!");
         else
           {
           //extract path from calibration file and set the calibration dir of the device
           std::string path =  itksys::SystemTools::GetFilenamePath(m_MTCalibrationFile);
           newDevice->SetCalibrationDir(path);
           }
         returnValue = newDevice;
         }
   else if (m_Controls->m_trackingDeviceChooser->currentIndex()==3)
   {
     // Create the Tracking Device this->m_OptitrackDevice = mitk::OptitrackTrackingDevice::New();
     returnValue = ConfigureOptitrackTrackingDevice();
     returnValue->SetType(mitk::NPOptitrack);
   }
   return returnValue;
   }
 
 mitk::TrackingDevice::Pointer QmitkTrackingDeviceConfigurationWidget::ConfigureNDI5DTrackingDevice()
   {
   return NULL;
   }
 
 mitk::TrackingDevice::Pointer QmitkTrackingDeviceConfigurationWidget::ConfigureOptitrackTrackingDevice()
   {
   mitk::OptitrackTrackingDevice::Pointer tempTrackingDevice = mitk::OptitrackTrackingDevice::New();
   // Set the calibration File
   tempTrackingDevice->SetCalibrationPath(m_OptitrackCalibrationFile);
 
   //Set the camera parameters
   tempTrackingDevice->SetExp(m_Controls->m_OptitrackExp->value());
   tempTrackingDevice->SetLed(m_Controls->m_OptitrackLed->value());
   tempTrackingDevice->SetThr(m_Controls->m_OptitrackThr->value());
 
   mitk::TrackingDevice::Pointer returnValue = static_cast<mitk::TrackingDevice*>(tempTrackingDevice);
   return returnValue;
   }
 
 mitk::TrackingDevice::Pointer QmitkTrackingDeviceConfigurationWidget::ConfigureNDI6DTrackingDevice()
   {
   mitk::NDITrackingDevice::Pointer tempTrackingDevice = mitk::NDITrackingDevice::New();
 
   //get port
   int port = 0;
   if (m_Controls->m_trackingDeviceChooser->currentIndex()==1) port = m_Controls->m_portSpinBoxAurora->value();
   else port = m_Controls->m_portSpinBoxPolaris->value();
 
   //build prefix (depends on linux/win)
   QString prefix = "";
   #ifdef WIN32
   prefix ="COM";
   tempTrackingDevice->SetPortNumber(static_cast<mitk::SerialCommunication::PortNumber>(port)); //also set the com port for compatibility
   #else
   if (m_Controls->m_trackingDeviceChooser->currentIndex()==1) //Aurora
     prefix = m_Controls->portTypeAurora->currentText();
   else //Polaris
     prefix = m_Controls->portTypePolaris->currentText();
   #endif
 
   //build port name string
   QString portName = prefix + QString::number(port);
 
   tempTrackingDevice->SetDeviceName(portName.toStdString()); //set the port name
   tempTrackingDevice->SetBaudRate(mitk::SerialCommunication::BaudRate115200);//set baud rate
   mitk::TrackingDevice::Pointer returnValue = static_cast<mitk::TrackingDevice*>(tempTrackingDevice);
   return returnValue;
   }
 
 mitk::TrackingDevice::Pointer QmitkTrackingDeviceConfigurationWidget::GetTrackingDevice()
   {
   if (!m_AdvancedUserControl) m_TrackingDevice = ConstructTrackingDevice();
   if (m_TrackingDevice.IsNull() || !m_TrackingDevice->IsDeviceInstalled()) return NULL;
   else return this->m_TrackingDevice;
   }
 
 bool QmitkTrackingDeviceConfigurationWidget::GetTrackingDeviceConfigured()
   {
   return this->m_TrackingDeviceConfigurated;
   }
 
 void QmitkTrackingDeviceConfigurationWidget::ConfigurationFinished()
   {
   Finished();
 
   }
 
 void QmitkTrackingDeviceConfigurationWidget::EnableAdvancedUserControl(bool enable)
   {
   m_AdvancedUserControl = enable;
   m_Controls->configuration_finished_label->setVisible(enable);
   m_Controls->m_finishedLine->setVisible(enable);
   m_Controls->m_resetButton->setVisible(enable);
   m_Controls->m_finishedButton->setVisible(enable);
   }
 
 
 void QmitkTrackingDeviceConfigurationWidget::StoreUISettings()
 {
-std::string id = "org.mitk.modules.igt.ui.trackingdeviceconfigurationwidget";
-if (!this->GetPeristenceService())
+  std::string id = "org.mitk.modules.igt.ui.trackingdeviceconfigurationwidget";
+  if ( this->GetPeristenceService() )
   {
-  MITK_ERROR << "Persistence service not available, could not store UI settings!";
-  return;
+    mitk::PropertyList::Pointer propList = this->GetPeristenceService()->GetPropertyList(id);
+    propList->Set("PolarisPortWin",m_Controls->m_portSpinBoxPolaris->value());
+    propList->Set("AuroraPortWin",m_Controls->m_portSpinBoxAurora->value());
+    propList->Set("PortTypePolaris", m_Controls->portTypePolaris->currentIndex());
+    propList->Set("PortTypeAurora", m_Controls->portTypeAurora->currentIndex());
+    propList->Set("MTCalibrationFile",m_MTCalibrationFile);
+    propList->Set("SelectedDevice",m_Controls->m_trackingDeviceChooser->currentIndex());
+  }
+  else
+  {
+    // QSettings as a fallback if the persistence service is not available
+    QSettings settings;
+
+    settings.beginGroup(QString::fromStdString(id));
+
+    settings.setValue("trackingDeviceChooser", QVariant(m_Controls->m_trackingDeviceChooser->currentIndex()));
+    settings.setValue("portSpinBoxAurora", QVariant(m_Controls->m_portSpinBoxAurora->value()));
+    settings.setValue("portSpinBoxPolaris", QVariant(m_Controls->m_portSpinBoxPolaris->value()));
+    settings.setValue("portTypePolaris", QVariant(m_Controls->portTypePolaris->currentIndex()));
+    settings.setValue("portTypeAurora", QVariant(m_Controls->portTypeAurora->currentIndex()));
+    settings.setValue("mTCalibrationFile", QVariant(QString::fromStdString(m_MTCalibrationFile)));
+
+    settings.endGroup();
   }
-mitk::PropertyList::Pointer propList = this->GetPeristenceService()->GetPropertyList(id);
-propList->Set("PolarisPortWin",m_Controls->m_portSpinBoxPolaris->value());
-propList->Set("AuroraPortWin",m_Controls->m_portSpinBoxAurora->value());
-propList->Set("MTCalibrationFile",m_MTCalibrationFile);
-propList->Set("SelectedDevice",m_Controls->m_trackingDeviceChooser->currentIndex());
 }
 
 void QmitkTrackingDeviceConfigurationWidget::LoadUISettings()
 {
-std::string id = "org.mitk.modules.igt.ui.trackingdeviceconfigurationwidget";
-if (!this->GetPeristenceService())
-  {MITK_ERROR << "Persistence service not available, could not load UI settings!"; return;}
-mitk::PropertyList::Pointer propList = this->GetPeristenceService()->GetPropertyList(id);
-if (propList.IsNull())
-  {MITK_ERROR << "Property list for this UI (" << id <<") is not available, could not load UI settings!"; return;}
-int portPolarisWin,portAuroraWin,SelectedDevice;
-propList->Get("PolarisPortWin",portPolarisWin);
-propList->Get("AuroraPortWin",portAuroraWin);
-propList->Get("MTCalibrationFile",m_MTCalibrationFile);
-propList->Get("SelectedDevice",SelectedDevice);
-if (SelectedDevice<0)
+  std::string id = "org.mitk.modules.igt.ui.trackingdeviceconfigurationwidget";
+  if ( this->GetPeristenceService() )
   {
-  MITK_ERROR << "Loaded data from persistence service is invalid (SelectedDevice:" <<SelectedDevice<<"): aborted to restore data!";
-  return;
+    mitk::PropertyList::Pointer propList = this->GetPeristenceService()->GetPropertyList(id);
+    if (propList.IsNull())
+    {MITK_ERROR << "Property list for this UI (" << id <<") is not available, could not load UI settings!"; return;}
+    int portPolarisWin,portAuroraWin,portTypePolaris,portTypeAurora,SelectedDevice;
+    propList->Get("PolarisPortWin",portPolarisWin);
+    propList->Get("AuroraPortWin",portAuroraWin);
+    propList->Get("PortTypePolaris", portTypePolaris);
+    propList->Get("PortTypeAurora", portTypeAurora);
+    propList->Get("MTCalibrationFile",m_MTCalibrationFile);
+    propList->Get("SelectedDevice",SelectedDevice);
+    if (SelectedDevice<0)
+    {
+      MITK_ERROR << "Loaded data from persistence service is invalid (SelectedDevice:" <<SelectedDevice<<"): aborted to restore data!";
+      return;
+    }
+    m_Controls->m_portSpinBoxPolaris->setValue(portPolarisWin);
+    m_Controls->m_portSpinBoxAurora->setValue(portAuroraWin);
+    m_Controls->portTypePolaris->setCurrentIndex(portTypePolaris);
+    m_Controls->portTypeAurora->setCurrentIndex(portTypeAurora);
+    m_Controls->m_TrackingSystemWidget->setCurrentIndex(SelectedDevice);
+    m_Controls->m_trackingDeviceChooser->setCurrentIndex(SelectedDevice);
+    MITK_INFO << "Sucessfully restored UI settings";
+  }
+  else
+  {
+    // QSettings as a fallback if the persistence service is not available
+    QSettings settings;
+    settings.beginGroup(QString::fromStdString(id));
+
+    m_Controls->m_trackingDeviceChooser->setCurrentIndex(settings.value("trackingDeviceChooser", 0).toInt());
+    m_Controls->m_portSpinBoxAurora->setValue(settings.value("portSpinBoxAurora", 0).toInt());
+    m_Controls->m_portSpinBoxPolaris->setValue(settings.value("portSpinBoxPolaris", 0).toInt());
+    m_Controls->portTypePolaris->setCurrentIndex(settings.value("portTypePolaris", 0).toInt());
+    m_Controls->portTypeAurora->setCurrentIndex(settings.value("portTypeAurora", 0).toInt());
+    m_MTCalibrationFile = settings.value("mTCalibrationFile", "").toString().toStdString();
+
+    settings.endGroup();
   }
-m_Controls->m_portSpinBoxPolaris->setValue(portPolarisWin);
-m_Controls->m_portSpinBoxAurora->setValue(portAuroraWin);
-m_Controls->m_TrackingSystemWidget->setCurrentIndex(SelectedDevice);
-m_Controls->m_trackingDeviceChooser->setCurrentIndex(SelectedDevice);
-m_Controls->m_MTCalibrationFile->setText("Calibration File: " + QString(m_MTCalibrationFile.c_str()));
-}
 
+  m_Controls->m_MTCalibrationFile->setText("Calibration File: " + QString::fromStdString(m_MTCalibrationFile));
+}
 void QmitkTrackingDeviceConfigurationWidgetConnectionWorker::TestConnectionThreadFunc()
 {
 MITK_INFO << "Testing Connection!";
 QString output;
 bool connected = false;
 mitk::ProgressBar::GetInstance()->AddStepsToDo(4);
 try
   {
   if (!m_TrackingDevice->IsDeviceInstalled())
      {
      output = "ERROR: Device is not installed!";
      }
   else
     {
     //test connection and start tracking, generate output
     output = "<br>testing connection <br>  ...";
     m_TrackingDevice->OpenConnection();
     output += "OK";
     mitk::ProgressBar::GetInstance()->Progress();
 
     //try start/stop tracking
     output += "<br>testing tracking <br>  ...";
     m_TrackingDevice->StartTracking();
     mitk::ProgressBar::GetInstance()->Progress();
     m_TrackingDevice->StopTracking();
     mitk::ProgressBar::GetInstance()->Progress();
 
     //try close connection
     m_TrackingDevice->CloseConnection();
     mitk::ProgressBar::GetInstance()->Progress();
     output += "OK";
     connected = true;
     }
   }
 catch(mitk::IGTException &e)
   {
   output += "ERROR!";
   MITK_WARN << "Error while testing connection / start tracking of the device: " << e.GetDescription();
   }
 mitk::ProgressBar::GetInstance()->Progress(4);
 emit ConnectionTested(connected,output);
 }
 
 void QmitkTrackingDeviceConfigurationWidgetScanPortsWorker::ScanPortsThreadFunc()
 {
   int PolarisPort = -1;
   int AuroraPort = -1;
   int PortTypePolaris = -1;
   int PortTypeAurora = -1;
 
   QString result = "<br>Found Devices:";
   int resultSize = result.size(); //remember size of result: if it stays the same no device were found
 
   #ifdef WIN32
     mitk::ProgressBar::GetInstance()->AddStepsToDo(19);
 
     QString devName;
     for (unsigned int i = 1; i < 20; ++i)
     {
       QString statusOutput = "Scanning Port #" + QString::number(i);
       MITK_INFO << statusOutput.toStdString().c_str();
       if (i<10) devName = QString("COM%1").arg(i);
       else devName = QString("\\\\.\\COM%1").arg(i); // prepend "\\.\ to COM ports >9, to be able to allow connection"
       mitk::TrackingDeviceType scannedPort = ScanPort(devName);
       switch (scannedPort)
       {
       case mitk::NDIPolaris:
         result += "<br>" + devName + ": " + "NDI Polaris";
         PolarisPort = i;
         break;
       case mitk::NDIAurora:
         result += "<br>" + devName + ": " + "NDI Aurora";
         AuroraPort = i;
         break;
       }
       mitk::ProgressBar::GetInstance()->Progress();
     }
   #else //linux systems
     for(unsigned int i = 1; i < 6; ++i)
     {
       QString devName = QString("/dev/ttyS%1").arg(i);
       mitk::TrackingDeviceType scannedPort = ScanPort(devName);
       switch (scannedPort)
       {
       case mitk::NDIPolaris:
         result += "<br>" + devName + ": " + "NDI Polaris";
         PolarisPort = i;
         PortTypePolaris = 1;
         break;
       case mitk::NDIAurora:
         result += "<br>" + devName + ": " + "NDI Aurora";
         AuroraPort = i;
         PortTypeAurora = 1;
         break;
       }
 
     }
     for(unsigned int i = 0; i <7; ++i)
     {
       QString devName = QString("/dev/ttyUSB%1").arg(i);
       mitk::TrackingDeviceType scannedPort = ScanPort(devName);
       switch (scannedPort)
       {
       case mitk::NDIPolaris:
         result += "<br>" + devName + ": " + "NDI Polaris";
         PolarisPort = i;
         PortTypePolaris = 0;
         break;
       case mitk::NDIAurora:
         result += "<br>" + devName + ": " + "NDI Aurora";
         AuroraPort = i;
         PortTypeAurora = 0;
         break;
       }
 
     }
   #endif
 
   if ( result.size() == resultSize) result += "<br>none";
 
   emit PortsScanned(PolarisPort,AuroraPort,result,PortTypePolaris,PortTypeAurora);
 }
 
 mitk::TrackingDeviceType QmitkTrackingDeviceConfigurationWidgetScanPortsWorker::ScanPort(QString port)
 {
   mitk::NDITrackingDevice::Pointer tracker = mitk::NDITrackingDevice::New();
   tracker->SetDeviceName(port.toStdString());
   mitk::TrackingDeviceType returnValue = mitk::TrackingSystemInvalid;
   try
   {returnValue = tracker->TestConnection();}
   catch (mitk::IGTException)
   {}//do nothing: there is simply no device on this port
   return returnValue;
 }
 
 void QmitkTrackingDeviceConfigurationWidgetConnectionWorker::SetTrackingDevice(mitk::TrackingDevice::Pointer t)
 {
   m_TrackingDevice = t;
 }
diff --git a/Modules/QtWidgets/QmitkServiceListWidget.h b/Modules/QtWidgets/QmitkServiceListWidget.h
index 78c8fa268f..500ebd6e3c 100644
--- a/Modules/QtWidgets/QmitkServiceListWidget.h
+++ b/Modules/QtWidgets/QmitkServiceListWidget.h
@@ -1,261 +1,261 @@
 /*===================================================================
 
 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 _QmitkServiceListWidget_H_INCLUDED
 #define _QmitkServiceListWidget_H_INCLUDED
 
 #include "MitkQtWidgetsExports.h"
 #include "ui_QmitkServiceListWidgetControls.h"
 #include <vector>
 
 //QT headers
 #include <QWidget>
 #include <QListWidgetItem>
 
 //Microservices
 #include "usServiceReference.h"
 #include "usModuleContext.h"
 #include "usServiceEvent.h"
 #include "usServiceInterface.h"
 
 
 
 /**
  * \ingroup QmitkModule
  *
  * \brief This widget provides abstraction for the handling of MicroServices.
  *
  * Place one in your Plugin and set it to look for a certain interface.
  * One can also specify a filter and / or a property to use for captioning of
  * the services. It also offers functionality to signal
  * ServiceEvents and to return the actual classes, so only a minimum of
  * interaction with the MicroserviceInterface is required.
  * To get started, just put it in your Plugin or Widget, call the Initialize
  * Method and optionally connect it's signals.
  * As QT limits templating possibilities, events only throw ServiceReferences.
  * You can manually dereference them using TranslateServiceReference()
 */
 class QMITK_EXPORT QmitkServiceListWidget :public QWidget
 {
 
   //this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
   Q_OBJECT
 
   private:
 
     us::ModuleContext* m_Context;
     /** \brief a filter to further narrow down the list of results*/
     std::string m_Filter;
     /** \brief The name of the ServiceInterface that this class should list */
     std::string m_Interface;
     /** \brief The name of the ServiceProperty that will be displayed in the list to represent the service */
     std::string m_NamingProperty;
     /** \brief Determines if the first entry of the list should be selected automatically if no entry was selected before (default false). */
     bool m_AutomaticallySelectFirstEntry;
 
   public:
 
     static const std::string VIEW_ID;
 
     QmitkServiceListWidget(QWidget* p = 0, Qt::WindowFlags f1 = 0);
     virtual ~QmitkServiceListWidget();
 
     /** \brief Set if the first entry of the list should be selected automatically if no entry was selected before. */
     void SetAutomaticallySelectFirstEntry(bool automaticallySelectFirstEntry);
 
     /** \brief This method is part of the widget an needs not to be called separately. */
     virtual void CreateQtPartControl(QWidget *parent);
     /** \brief This method is part of the widget an needs not to be called separately. (Creation of the connections of main and control widget.)*/
     virtual void CreateConnections();
 
     /**
     * \brief Will return true, if a service is currently selected and false otherwise.
     *
     * Call this before requesting service references to avoid invalid ServiceReferences.
     */
     bool GetIsServiceSelected();
 
     /**
     * \brief Returns the currently selected Service as a ServiceReference.
     *
     * If no Service is selected, the result will probably be a bad pointer. call GetIsServiceSelected()
     * beforehand to avoid this
     */
     us::ServiceReferenceU GetSelectedServiceReference();
 
     /**
     * \brief Use this function to return the currently selected service as a class directly.
     *
     *  Make sure you pass the appropriate type, or else this call will fail.
     *  Usually, you will pass the class itself, not the SmartPointer, but the function returns a pointer. Example:
     *  \verbatim mitk::USDevice::Pointer device = GetSelectedService<mitk::USDevice>(); \endverbatim
     *  @return Returns the current selected device. Returns NULL if no device is selected.
     */
     template <class T>
     T* GetSelectedService()
     {
       if (this->m_Controls->m_ServiceList->currentRow()==-1) return NULL;
       us::ServiceReferenceU ref = GetServiceForListItem( this->m_Controls->m_ServiceList->currentItem() );
       return ( m_Context->GetService(us::ServiceReference<T>(ref)) );
     }
 
     /**
     * \brief  Initializes the Widget with essential parameters.
     *
     * The string filter is an LDAP parsable String, compare mitk::ModuleContext for examples on filtering.
     * Pass class T to tell the widget which class it should filter for - only services of this class will be listed.
     * NamingProperty is a property that will be used to caption the Items in the list. If no filter is supplied, all
     * matching interfaces are shown. If no namingProperty is supplied, the interfaceName will be used to caption Items in the list.
     * For example, this Initialization will filter for all USDevices that are set to active. The USDevice's model will be used to display it in the list:
     * \verbatim
         std::string filter = "(&(" + us::ServiceConstants::OBJECTCLASS() + "=" + "org.mitk.services.UltrasoundDevice)(IsActive=true))";
-        m_Controls.m_ActiveVideoDevices->Initialize<mitk::USDevice>(mitk::USImageMetadata::PROP_DEV_MODEL ,filter);
+        m_Controls.m_ActiveVideoDevices->Initialize<mitk::USDevice>(mitk::USDevice::GetPropertyKeys().US_PROPKEY_NAME ,filter);
     * \endverbatim
     */
     template <class T>
     void Initialize(const std::string& namingProperty = static_cast< std::string >(""),const std::string& filter = static_cast< std::string >(""))
       {
         std::string interfaceName ( us_service_interface_iid<T>() );
         m_Interface = interfaceName;
         InitPrivate(namingProperty, filter);
       }
 
     /**
     * \brief Translates a serviceReference to a class of the given type.
     *
     * Use this to translate the signal's parameters. To adhere to the MicroService contract,
     * only ServiceReferences stemming from the same widget should be used as parameters for this method.
     * \verbatim mitk::USDevice::Pointer device = TranslateReference<mitk::USDevice>(myDeviceReference); \endverbatim
     */
     template <class T>
     T* TranslateReference(const us::ServiceReferenceU& reference)
       {
         return m_Context->GetService(us::ServiceReference<T>(reference));
       }
 
     /**
     *\brief This Function listens to ServiceRegistry changes and updates the list of services accordingly.
     *
     * The user of this widget does not need to call this method, it is instead used to recieve events from the module registry.
     */
     void OnServiceEvent(const us::ServiceEvent event);
 
   signals:
 
     /**
     *\brief Emitted when a new Service matching the filter is being registered.
     *
     * Be careful if you use a filter:
     * If a device does not match the filter when registering, but modifies it's properties later to match the filter,
     * then the first signal you will see this device in will be ServiceModified.
     */
     void ServiceRegistered(us::ServiceReferenceU);
 
     /**
     *\brief Emitted directly before a Service matching the filter is being unregistered.
     */
     void ServiceUnregistering(us::ServiceReferenceU);
 
     /**
     *\brief Emitted when a Service matching the filter changes it's properties, or when a service that formerly not matched the filter
     * changed it's properties and now matches the filter.
     */
     void ServiceModified(us::ServiceReferenceU);
 
     /**
     *\brief Emitted when a Service matching the filter changes it's properties,
     *
     * and the new properties make it fall trough the filter. This effectively means that
     * the widget will not track the service anymore. Usually, the Service should still be useable though
     */
     void ServiceModifiedEndMatch(us::ServiceReferenceU);
 
     /**
     *\brief Emitted if the user selects a Service from the list.
     *
     * If no service is selected, an invalid serviceReference is returned. The user can easily check for this.
     * if (serviceReference) will evaluate to false, if the reference is invalid and true if valid.
     */
     void ServiceSelectionChanged(us::ServiceReferenceU);
 
   public slots:
 
   protected slots:
 
     /**
     \brief Called, when the selection in the list of Services changes.
     */
     void OnServiceSelectionChanged();
 
 
   protected:
 
     Ui::QmitkServiceListWidgetControls* m_Controls; ///< member holding the UI elements of this widget
 
     /**
     * \brief  Internal structure used to link ServiceReferences to their QListWidgetItems
     */
     struct ServiceListLink {
       us::ServiceReferenceU service;
       QListWidgetItem* item;
     };
 
     /**
     * \brief Finishes initialization after Initialize has been called.
     *
     * This function assumes that m_Interface is set correctly (Which Initialize does).
     */
     void InitPrivate(const std::string& namingProperty, const std::string& filter);
 
     /**
     * \brief Contains a list of currently active services and their entires in the list. This is wiped with every ServiceRegistryEvent.
     */
     std::vector<ServiceListLink> m_ListContent;
 
     /**
     * \brief Constructs a ListItem from the given service, displays it, and locally stores the service.
     */
     QListWidgetItem* AddServiceToList(const us::ServiceReferenceU& serviceRef);
 
     /**
     * \brief Removes the given service from the list and cleans up. Returns true if successful, false if service was not found.
     */
     bool RemoveServiceFromList(const us::ServiceReferenceU& serviceRef);
 
     /**
      * \brief Changes list entry of given service to match the changed service properties.
      * \return true if successful, false if service was not found
      */
     bool ChangeServiceOnList(const us::ServiceReferenceU& serviceRef);
 
     /**
     * \brief Returns the serviceReference corresponding to the given ListEntry or an invalid one if none was found (will evaluate to false in bool expressions).
     */
     us::ServiceReferenceU GetServiceForListItem(QListWidgetItem* item);
 
     /**
     * \brief Returns a list of ServiceReferences matching the filter criteria by querying the service registry.
     */
     std::vector<us::ServiceReferenceU> GetAllRegisteredServices();
 
     /**
      * \brief Gets string from the naming property of the service.
      * \return caption string for given us::ServiceReferenceU
      */
     QString CreateCaptionForService(const us::ServiceReferenceU& serviceRef);
 };
 
 #endif // _QmitkServiceListWidget_H_INCLUDED
diff --git a/Modules/US/USControlInterfaces/mitkUSControlInterfaceBMode.cpp b/Modules/US/USControlInterfaces/mitkUSControlInterfaceBMode.cpp
index 1d4b815a01..a25dd9dc3d 100644
--- a/Modules/US/USControlInterfaces/mitkUSControlInterfaceBMode.cpp
+++ b/Modules/US/USControlInterfaces/mitkUSControlInterfaceBMode.cpp
@@ -1,68 +1,95 @@
 /*===================================================================
 
 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 "mitkUSControlInterfaceBMode.h"
 #include "mitkUSDevice.h"
 
 mitk::USControlInterfaceBMode::USControlInterfaceBMode( itk::SmartPointer<USDevice> device )
   : mitk::USAbstractControlInterface(device)
 {
   if (device.IsNull())
   {
     MITK_ERROR << "USDevice must not be null for USControlInterfaceBMode.";
     mitkThrow() << "USDevice must not be null for USControlInterfaceBMode.";
   }
 }
 
 mitk::USControlInterfaceBMode::~USControlInterfaceBMode()
 {
 }
 
+void mitk::USControlInterfaceBMode::Initialize()
+{
+  m_Device->UpdateServiceProperty(
+    mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_FREQUENCY,
+    this->GetScanningFrequency());
+
+  m_Device->UpdateServiceProperty(
+    mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_POWER,
+    this->GetScanningPower());
+
+  m_Device->UpdateServiceProperty(
+    mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_DEPTH,
+    this->GetScanningDepth());
+
+  m_Device->UpdateServiceProperty(
+    mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_GAIN,
+    this->GetScanningGain());
+
+  m_Device->UpdateServiceProperty(
+    mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_REJECTION,
+    this->GetScanningRejection());
+
+  m_Device->UpdateServiceProperty(
+    mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_DYNAMIC_RANGE,
+    this->GetScanningDynamicRange());
+}
+
 void mitk::USControlInterfaceBMode::SetScanningFrequency( double frequency )
 {
   this->OnSetScanningFrequency(frequency);
   m_Device->UpdateServiceProperty(mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_FREQUENCY, frequency);
 }
 
 void mitk::USControlInterfaceBMode::SetScanningPower( double power )
 {
   this->OnSetScanningPower(power);
   m_Device->UpdateServiceProperty(mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_POWER, power);
 }
 
 void mitk::USControlInterfaceBMode::SetScanningDepth( double depth )
 {
   this->OnSetScanningDepth(depth);
   m_Device->UpdateServiceProperty(mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_DEPTH, depth);
 }
 
 void mitk::USControlInterfaceBMode::SetScanningGain( double gain )
 {
   this->OnSetScanningGain(gain);
   m_Device->UpdateServiceProperty(mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_GAIN, gain);
 }
 
 void mitk::USControlInterfaceBMode::SetScanningRejection( double rejection )
 {
   this->OnSetScanningRejection(rejection);
   m_Device->UpdateServiceProperty(mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_REJECTION, rejection);
 }
 
 void mitk::USControlInterfaceBMode::SetScanningDynamicRange( double dynamicRange )
 {
   this->OnSetScanningDynamicRange(dynamicRange);
   m_Device->UpdateServiceProperty(mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_DYNAMIC_RANGE, dynamicRange);
 }
diff --git a/Modules/US/USControlInterfaces/mitkUSControlInterfaceBMode.h b/Modules/US/USControlInterfaces/mitkUSControlInterfaceBMode.h
index 77411095a4..b569c828bd 100644
--- a/Modules/US/USControlInterfaces/mitkUSControlInterfaceBMode.h
+++ b/Modules/US/USControlInterfaces/mitkUSControlInterfaceBMode.h
@@ -1,249 +1,258 @@
 /*===================================================================
 
 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 MITKUSControlInterfaceBMode_H_HEADER_INCLUDED_
 #define MITKUSControlInterfaceBMode_H_HEADER_INCLUDED_
 
 #include "mitkUSAbstractControlInterface.h"
 
 namespace mitk {
 /**
   * \brief Interface defining methods for scanning mode b of ultrasound devices.
   * It consists of methods for scanning depth, scanning gaing and scanning
   * rejection.
   *
   * Scanning Depth: Defines the clipping of the ultrasound image. Small depth
   * for looking at structures just below the skin. Great depth for seeing deeper
   * structures.
   *
   * Scanning Gain: Defines amplification of ultrasound echo.
   *
   * Scanning Rejection: Defines range of the received values from the ultrasound
   * signal.
   *
   * Scanning Dynamic Range: Ability of displaying strong and weak signals at the same
   * time. High dynamic range means that strong and weak signals can be distinguished.
   * Lower dynamic range can lead to more contrast.
   *
   * There is a getter and a setter defined for each kind of value. Additionaly
   * there are methods for getting the range of the possible values. For
   * uniformly distributed values there are three methods Get<VALUE>Min(),
   * Get<VALUE>Max() and Get<VALUE>Tick(). For non-uniformly distributed values
   * there is one method Get<VALUE>Values() which shoule return a list of all
   * possible values.
   *
   * All getters of this interface must be implemented in a concrete
   * subclass. Additionally all OnSet* methods must be implemented. They handle
   * the acutal setting of the values at the device api. The Set* methods are
   * already implemented in this class and should not be overwritten. There are
   * some pure virtual methods in the superclass
   * mitk::USAbstractControlInterface which must be implemented, too.
   *
   */
 class MitkUS_EXPORT USControlInterfaceBMode : public USAbstractControlInterface
 {
 public:
   mitkClassMacro(USControlInterfaceBMode, USAbstractControlInterface);
 
+  /**
+    * \brief Initializes the microservice properties with the current values from the device.
+    * This method must be called before one would like to get the
+    * b mode values (e.g. frequency, power, ...) from the microservice
+    * and after the device is ready to deliver the values by the methods
+    * of this control interface.
+    */
+  void Initialize();
+
   /**
     * \return current frequency value
     */
   virtual double GetScanningFrequency( ) = 0;
 
   /**
     * \param depth new frequency value
     * Do not override this method in a subclass. Implement
     * mitk::USControlInterfaceBMode::OnSetScanningFrequency instead.
     */
   void SetScanningFrequency( double frequency );
 
   /**
     * \brief Virtual method which is called inside mitk::USControlInterfaceBMode::SetScanningFrequency.
     */
   virtual void OnSetScanningFrequency( double frequency ) = 0;
 
   /**
     * \return vector of all possible frequency values for the utrasound device
     */
   virtual std::vector<double> GetScanningFrequencyValues( ) = 0;
 
     /**
     * \return current power value
     */
   virtual double GetScanningPower( ) = 0;
 
   /**
     * \param depth new power value
     * Do not override this method in a subclass. Implement
     * mitk::USControlInterfaceBMode::OnSetScanningPower instead.
     */
   void SetScanningPower( double power );
 
   /**
     * \brief Virtual method which is called inside mitk::USControlInterfaceBMode::SetScanningPower.
     * Implement this method to handle the actual setting of the
     * value at the device api.
     */
   virtual void OnSetScanningPower( double power ) = 0;
 
   /**
     * \return minimum power value for the ultrasound device
     */
   virtual double GetScanningPowerMin( ) = 0;
 
   /**
     * \return maximum power value for the ultrasound device
     */
   virtual double GetScanningPowerMax( ) = 0;
 
   /**
     * \return interval between two power values for the ultrasound device
     */
   virtual double GetScanningPowerTick( ) = 0;
 
   /**
     * \return current depth value
     */
   virtual double GetScanningDepth( ) = 0;
 
   /**
     * \param depth new depth value
     * Do not override this method in a subclass. Implement
     * mitk::USControlInterfaceBMode::OnSetScanningDepth instead.
     */
   void SetScanningDepth( double depth );
 
   /**
     * \brief Virtual method which is called inside mitk::USControlInterfaceBMode::SetScanningDepth.
     * Implement this method to handle the actual setting of the
     * value at the device api.
     */
   virtual void OnSetScanningDepth( double depth ) = 0;
 
   /**
     * \return vector of all possible depth values for the utrasound device
     */
   virtual std::vector<double> GetScanningDepthValues( ) = 0;
 
   /**
     * \return current scanning gain
     */
   virtual double GetScanningGain( ) = 0;
 
   /**
     * \param gain new gain value
     * Do not override this method in a subclass. Implement
     * mitk::USControlInterfaceBMode::OnSetScanningGain instead.
     */
   void SetScanningGain( double gain );
 
   /**
     * \brief Virtual method which is called inside mitk::USControlInterfaceBMode::SetScanningGain.
     * Implement this method to handle the actual setting of the
     * value at the device api.
     */
   virtual void OnSetScanningGain( double gain ) = 0;
 
   /**
     * \return minimum gain value for the ultrasound device
     */
   virtual double GetScanningGainMin( ) = 0;
 
   /**
     * \return maximum gain value for the ultrasound device
     */
   virtual double GetScanningGainMax( ) = 0;
 
   /**
     * \return interval between two gain values for the ultrasound device
     */
   virtual double GetScanningGainTick( ) = 0;
 
   /**
     * \return current scanning rejection
     */
   virtual double GetScanningRejection( ) = 0;
 
   /**
     * \param rejection new rejection value
     * Do not override this method in a subclass. Implement
     * mitk::USControlInterfaceBMode::OnSetScanningRejection instead.
     */
   void SetScanningRejection( double rejection );
 
   /**
     * \brief Virtual method which is called inside mitk::USControlInterfaceBMode::SetScanningRejection.
     * Implement this method to handle the actual setting of the
     * value at the device api.
     */
   virtual void OnSetScanningRejection( double rejection ) = 0;
 
   /**
     * \return minimum rejection value for the ultrasound device
     */
   virtual double GetScanningRejectionMin( ) = 0;
 
   /**
     * \return maximum rejection value for the ultrasound device
     */
   virtual double GetScanningRejectionMax( ) = 0;
 
   /**
     * \return interval between two rejection values for the ultrasound device
     */
   virtual double GetScanningRejectionTick( ) = 0;
 
   /**
     * \return current scanning dynamic range
     */
   virtual double GetScanningDynamicRange( ) = 0;
 
   /**
     * \param rejection new dynamic range value
     * Do not override this method in a subclass. Implement
     * mitk::USControlInterfaceBMode::OnSetScanningDynamicRange instead.
     */
   virtual void SetScanningDynamicRange( double dynamicRange );
 
   /**
     * \brief Virtual method which is called inside mitk::USControlInterfaceBMode::SetScanningDynamicRange.
     * Implement this method to handle the actual setting of the
     * value at the device api.
     */
   virtual void OnSetScanningDynamicRange( double dynamicRange ) = 0;
 
   /**
   * \return minimum dynamic range value for the ultrasound device
   */
   virtual double GetScanningDynamicRangeMin( ) = 0;
 
   /**
   * \return maximum dynamic range value for the ultrasound device
   */
   virtual double GetScanningDynamicRangeMax( ) = 0;
 
   /**
   * \return interval between two dynamic range values for the ultrasound device
   */
   virtual double GetScanningDynamicRangeTick( ) = 0;
 
 protected:
   USControlInterfaceBMode( itk::SmartPointer<USDevice> device );
   virtual ~USControlInterfaceBMode( );
 };
 } // namespace mitk
 
 #endif // MITKUSControlInterfaceBMode_H_HEADER_INCLUDED_
\ No newline at end of file
diff --git a/Modules/US/USFilters/mitkUSImageVideoSource.cpp b/Modules/US/USFilters/mitkUSImageVideoSource.cpp
index 64d109f857..000844e418 100644
--- a/Modules/US/USFilters/mitkUSImageVideoSource.cpp
+++ b/Modules/US/USFilters/mitkUSImageVideoSource.cpp
@@ -1,225 +1,225 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // MITK HEADER
 #include "mitkUSImageVideoSource.h"
 #include "mitkImage.h"
 
 //OpenCV HEADER
 #include <cv.h>
 #include <highgui.h>
 
 //Other
 #include <stdio.h>
 
 mitk::USImageVideoSource::USImageVideoSource()
   : m_VideoCapture(new cv::VideoCapture()),
   m_IsVideoReady(false),
   m_IsGreyscale(false),
   m_IsCropped(false),
   m_ResolutionOverrideWidth(0),
   m_ResolutionOverrideHeight(0),
   m_ResolutionOverride(false),
   m_GrayscaleFilter(mitk::ConvertGrayscaleOpenCVImageFilter::New()),
   m_CropFilter(mitk::CropOpenCVImageFilter::New())
 {
 }
 
 mitk::USImageVideoSource::~USImageVideoSource()
 {
   m_VideoCapture->release();
   delete m_VideoCapture;
 }
 
 void mitk::USImageVideoSource::SetVideoFileInput(std::string path)
 {
   m_VideoCapture->open(path.c_str());
 
   // check if we succeeded
   if(!m_VideoCapture->isOpened()) { m_IsVideoReady = false; }
   else { m_IsVideoReady = true; }
 
   // if Override is enabled, use it
   if (m_ResolutionOverride)
   {
     m_VideoCapture->set(CV_CAP_PROP_FRAME_WIDTH, this->m_ResolutionOverrideWidth);
     m_VideoCapture->set(CV_CAP_PROP_FRAME_HEIGHT, this->m_ResolutionOverrideHeight);
   }
 }
 
 void mitk::USImageVideoSource::SetCameraInput(int deviceID)
 {
   m_VideoCapture->open(deviceID);
   if(!m_VideoCapture->isOpened())  // check if we succeeded
     m_IsVideoReady = false;
   else
     m_IsVideoReady = true;
 
   // if Override is enabled, use it
   if (m_ResolutionOverride)
   {
     m_VideoCapture->set(CV_CAP_PROP_FRAME_WIDTH, this->m_ResolutionOverrideWidth);
     m_VideoCapture->set(CV_CAP_PROP_FRAME_HEIGHT, this->m_ResolutionOverrideHeight);
   }
 }
 
 void mitk::USImageVideoSource::ReleaseInput()
 {
   m_VideoCapture->release();
   delete m_VideoCapture;
   m_VideoCapture = new cv::VideoCapture();
 }
 
 void mitk::USImageVideoSource::SetColorOutput(bool isColor){
   if ( ! isColor && ! m_IsGreyscale )
   {
     this->PushFilter(m_GrayscaleFilter.GetPointer());
   }
   else if ( isColor && m_IsGreyscale )
   {
     this->RemoveFilter(m_GrayscaleFilter.GetPointer());
   }
 
   m_IsGreyscale = !isColor;
 }
 
 int mitk::USImageVideoSource::GetImageHeight()
 {
   if (m_VideoCapture) { return m_VideoCapture->get(CV_CAP_PROP_FRAME_HEIGHT); }
   else { return 0; }
 }
 
 int mitk::USImageVideoSource::GetImageWidth()
 {
   if (m_VideoCapture) { return m_VideoCapture->get(CV_CAP_PROP_FRAME_WIDTH); }
   else { return 0; }
 }
 
 bool mitk::USImageVideoSource::GetIsReady()
 {
   if (!m_VideoCapture) { return false; }
 
   return m_VideoCapture->isOpened();
 }
 
 void mitk::USImageVideoSource::SetRegionOfInterest(int topLeftX, int topLeftY, int bottomRightX, int bottomRightY)
 {
   m_CropFilter->SetCropRegion(topLeftX, topLeftY, bottomRightX, bottomRightY);
 
   if (! m_IsCropped && ! m_CropFilter->GetIsCropRegionEmpty())
   {
     this->PushFilter(m_CropFilter.GetPointer());
     m_IsCropped = true;
   }
 }
 
 void mitk::USImageVideoSource::SetRegionOfInterest(USImageRoi roi)
 {
   this->SetRegionOfInterest(roi.topLeftX, roi.topLeftY, roi.bottomRightX, roi.bottomRightY);
 }
 
 void mitk::USImageVideoSource::SetCropping(USImageCropping cropping)
 {
   int width = this->GetImageWidth();
   int height = this->GetImageHeight();
 
   this->SetRegionOfInterest(cropping.left, cropping.top, width - cropping.right, height - cropping.bottom);
 }
 
 mitk::USImageVideoSource::USImageCropping mitk::USImageVideoSource::GetCropping()
 {
   cv::Rect cropRect = m_CropFilter->GetCropRegion();
 
   USImageCropping cropping;
   cropping.left = cropRect.x;
   cropping.top = cropRect.y;
 
   if ( cropRect.height == 0 )
   {
     cropping.bottom = 0;
   }
   else
   {
     cropping.bottom = this->GetImageHeight() - (cropRect.y + cropRect.height);
   }
 
   if ( cropRect.width == 0 )
   {
     cropping.right = 0;
   }
   else
   {
     cropping.right = this->GetImageWidth() - (cropRect.x + cropRect.width);
   }
 
   return cropping;
 }
 
 mitk::USImageVideoSource::USImageRoi  mitk::USImageVideoSource::GetRegionOfInterest()
 {
   cv::Rect cropRect = m_CropFilter->GetCropRegion();
 
   return USImageRoi(cropRect.x, cropRect.y, cropRect.x + cropRect.width, cropRect.y + cropRect.height);
 }
 
 void mitk::USImageVideoSource::RemoveRegionOfInterest()
 {
   this->RemoveFilter(m_CropFilter.GetPointer());
   m_IsCropped = false;
 }
 
 void mitk::USImageVideoSource::GetNextRawImage( cv::Mat& image )
 {
   // loop video if necessary
-  if (m_VideoCapture->get(CV_CAP_PROP_POS_AVI_RATIO) >= 0.99 )
+  if (m_VideoCapture->get(CV_CAP_PROP_POS_FRAMES) == m_VideoCapture->get(CV_CAP_PROP_FRAME_COUNT))
   {
-    m_VideoCapture->set(CV_CAP_PROP_POS_AVI_RATIO, 0);
+    m_VideoCapture->set(CV_CAP_PROP_POS_FRAMES, 0);
   }
 
   // retrieve image
   *m_VideoCapture >> image; // get a new frame from camera
 }
 
 void mitk::USImageVideoSource::GetNextRawImage( mitk::Image::Pointer& image )
 {
   cv::Mat cv_img;
 
   this->GetNextRawImage(cv_img);
 
   // convert to MITK-Image
   IplImage ipl_img = cv_img;
 
   this->m_OpenCVToMitkFilter->SetOpenCVImage(&ipl_img);
   this->m_OpenCVToMitkFilter->Update();
 
   // OpenCVToMitkImageFilter returns a standard mitk::image. We then transform it into an USImage
   image = this->m_OpenCVToMitkFilter->GetOutput();
 
   // clean up
   cv_img.release();
 }
 
 void mitk::USImageVideoSource::OverrideResolution(int width, int height)
 {
   this->m_ResolutionOverrideHeight = height;
   this->m_ResolutionOverrideWidth = width;
 
   if (m_VideoCapture != 0)
   {
     m_VideoCapture->set(CV_CAP_PROP_FRAME_WIDTH, width);
     m_VideoCapture->set(CV_CAP_PROP_FRAME_HEIGHT, height);
   }
 }
diff --git a/Modules/US/USModel/mitkUSDevice.cpp b/Modules/US/USModel/mitkUSDevice.cpp
index 75e1e80bbe..d2ad068de4 100644
--- a/Modules/US/USModel/mitkUSDevice.cpp
+++ b/Modules/US/USModel/mitkUSDevice.cpp
@@ -1,529 +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_Manufacturer(manufacturer),
+  m_Name(model),
   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)
 {
-  // Initialize Members
-  m_Metadata = mitk::USImageMetadata::New();
-  m_Metadata->SetDeviceManufacturer(manufacturer);
-  m_Metadata->SetDeviceModel(model);
-
   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_Metadata = metadata;
+  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[ mitk::USImageMetadata::PROP_DEV_MANUFACTURER ] = m_Metadata->GetDeviceManufacturer();
-  props[ mitk::USImageMetadata::PROP_DEV_MODEL ] = m_Metadata->GetDeviceModel();
-  props[ mitk::USImageMetadata::PROP_DEV_COMMENT ] = m_Metadata->GetDeviceComment();
-  props[ mitk::USImageMetadata::PROP_PROBE_NAME ] = m_Metadata->GetProbeName();
-  props[ mitk::USImageMetadata::PROP_PROBE_FREQUENCY ] = m_Metadata->GetProbeFrequency();
-  props[ mitk::USImageMetadata::PROP_ZOOM ] = m_Metadata->GetZoom();
+  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 this->m_Metadata->GetDeviceManufacturer();
+  return m_Manufacturer;
 }
 
 std::string mitk::USDevice::GetDeviceModel(){
-  return this->m_Metadata->GetDeviceModel();
+  return m_Name;
 }
 
 std::string mitk::USDevice::GetDeviceComment(){
-  return this->m_Metadata->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_Metadata->GetDeviceManufacturer() + " " + m_Metadata->GetDeviceModel() + isActive;
+  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 3d50dbd980..0db9a74385 100644
--- a/Modules/US/USModel/mitkUSDevice.h
+++ b/Modules/US/USModel/mitkUSDevice.h
@@ -1,413 +1,435 @@
 /*===================================================================
 
 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 "mitkUSImageMetadata.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_LABEL(US_INTERFACE_NAME + ".label"),
+          US_PROPKEY_COMMENT(US_INTERFACE_NAME + ".comment"),
           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();
 
-    std::string GetDeviceManufacturer();
-    std::string GetDeviceModel();
-    std::string GetDeviceComment();
+    /** \brief Deprecated -> use GetManufacturer() instead */
+    DEPRECATED(std::string GetDeviceManufacturer());
+    /** \brief Deprecated -> use GetName() instead */
+    DEPRECATED(std::string GetDeviceModel());
+    /** \brief Deprecated -> use GetCommend() instead */
+    DEPRECATED(std::string GetDeviceComment());
 
-    itkGetMacro(DeviceState, DeviceStates);
+    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 This metadata set is privately used to imprint USImages with Metadata later.
-    * At instantiation time, it only contains Information about the Device.
-    * At scan time, it integrates this data with the probe information and
-    * imprints it on the produced images. This field is intentionally hidden
-    * from outside interference.
-    */
-    mitk::USImageMetadata::Pointer m_Metadata;
-
     /**
     * \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!
     */
-    USDevice(mitk::USImageMetadata::Pointer metadata);
+    DEPRECATED(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_
diff --git a/Modules/US/USModel/mitkUSDevicePersistence.cpp b/Modules/US/USModel/mitkUSDevicePersistence.cpp
index aaf3127d3b..c41481dad3 100644
--- a/Modules/US/USModel/mitkUSDevicePersistence.cpp
+++ b/Modules/US/USModel/mitkUSDevicePersistence.cpp
@@ -1,213 +1,207 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkUSDevicePersistence.h"
 
 //Microservices
 #include <usServiceReference.h>
 #include <usModuleContext.h>
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 
 mitk::USDevicePersistence::USDevicePersistence() : m_devices("MITK US","Device Settings")
 {
 }
 
 void mitk::USDevicePersistence::StoreCurrentDevices()
 {
   us::ModuleContext* thisContext = us::GetModuleContext();
 
   std::vector<us::ServiceReference<USDevice> > services = thisContext->GetServiceReferences<USDevice>();
   MITK_INFO << "Trying to save " << services.size() << " US devices.";
   int numberOfSavedDevices = 0;
   for(std::vector<us::ServiceReference<USDevice> >::iterator it = services.begin(); it != services.end(); ++it)
   {
     mitk::USDevice::Pointer currentDevice = thisContext->GetService(*it);
     //check if it is a USVideoDevice
     if (currentDevice->GetDeviceClass() == "org.mitk.modules.us.USVideoDevice")
     {
       mitk::USVideoDevice::Pointer currentVideoDevice = dynamic_cast<mitk::USVideoDevice*>(currentDevice.GetPointer());
       QString identifier = "device" + QString::number(numberOfSavedDevices);
       m_devices.setValue(identifier,USVideoDeviceToString(currentVideoDevice));
       numberOfSavedDevices++;
     }
 
     else
     {
       MITK_WARN << "Saving of US devices of the type " << currentDevice->GetDeviceClass() << " is not supported at the moment. Skipping device.";
     }
   }
   m_devices.setValue("numberOfSavedDevices",numberOfSavedDevices);
   MITK_INFO << "Successfully saved " << numberOfSavedDevices << " US devices.";
 }
 
 std::vector<mitk::USDevice::Pointer> mitk::USDevicePersistence::RestoreLastDevices()
 {
   std::vector<mitk::USDevice::Pointer> devices;
 
   int numberOfSavedDevices = m_devices.value("numberOfSavedDevices").toInt();
 
   for(int i=0; i<numberOfSavedDevices; i++)
   {
     // Try each device. If an exception occurs: Ignore device and notify user
     try
     {
       QString currentString = m_devices.value("device"+QString::number(i)).toString();
       mitk::USDevice::Pointer currentDevice = dynamic_cast<mitk::USDevice*>(StringToUSVideoDevice(currentString).GetPointer());
       //currentDevice->Initialize();
       devices.push_back(currentDevice.GetPointer());
     }
     catch (...)
     {
       MITK_ERROR << "Error occured while loading a USVideoDevice from persistence. Device assumed corrupt, will be deleted.";
       //QMessageBox::warning(NULL, "Could not load device" ,"A stored ultrasound device is corrupted and could not be loaded. The device will be deleted.");
     }
   }
 
   MITK_INFO << "Restoring " << numberOfSavedDevices << " US devices.";
 
   return devices;
 }
 
 QString mitk::USDevicePersistence::USVideoDeviceToString(mitk::USVideoDevice::Pointer d)
 {
-  QString manufacturer = d->GetDeviceManufacturer().c_str();
-  QString model = d->GetDeviceModel().c_str();
-  QString comment = d->GetDeviceComment().c_str();
+  QString manufacturer = d->GetManufacturer().c_str();
+  QString model = d->GetName().c_str();
+  QString comment = d->GetComment().c_str();
   int source = d->GetDeviceID();
   std::string file = d->GetFilePath();
   if (file == "") file = "none";
 
   mitk::USImageVideoSource::Pointer imageSource = dynamic_cast<mitk::USImageVideoSource*>(d->GetUSImageSource().GetPointer());
   if ( ! imageSource )
   {
     MITK_ERROR << "There is no USImageVideoSource at the current device.";
     mitkThrow() << "There is no USImageVideoSource at the current device.";
   }
 
   int greyscale = imageSource->GetIsGreyscale();
   int resOverride = imageSource->GetResolutionOverride();
   int resWidth = imageSource->GetResolutionOverrideWidth();
   int resHight = imageSource->GetResolutionOverrideHeight();
 
   mitk::USImageVideoSource::USImageRoi roi = imageSource->GetRegionOfInterest();
 
   char seperator = '|';
 
   QString returnValue = manufacturer + seperator
                        + model + seperator
                        + comment + seperator
                        + QString::number(source) + seperator
                        + file.c_str() + seperator
                        + QString::number(greyscale) + seperator
                        + QString::number(resOverride) + seperator
                        + QString::number(resWidth) + seperator
                        + QString::number(resHight) + seperator
                        + QString::number(roi.topLeftX) + seperator
                        + QString::number(roi.topLeftY) + seperator
                        + QString::number(roi.bottomRightX) + seperator
                        + QString::number(roi.bottomRightY)
                        ;
 
   MITK_INFO << "Output String: " << returnValue.toStdString();
   return returnValue;
 }
 
 mitk::USVideoDevice::Pointer mitk::USDevicePersistence::StringToUSVideoDevice(QString s)
 {
   MITK_INFO << "Input String: " << s.toStdString();
   std::vector<std::string> data;
   std::string seperators = "|";
   std::string text = s.toStdString();
   split(text,seperators,data);
   if(data.size() != 13)
   {
     MITK_ERROR << "Cannot parse US device! (Size: " << data.size() << ")";
     return mitk::USVideoDevice::New("INVALID","INVALID","INVALID");
   }
 
   std::string manufacturer = data.at(0);
   std::string model = data.at(1);
   std::string comment = data.at(2);
   int source = (QString(data.at(3).c_str())).toInt();
   std::string file = data.at(4);
   bool greyscale = (QString(data.at(5).c_str())).toInt();
   bool resOverride = (QString(data.at(6).c_str())).toInt();
   int resWidth = (QString(data.at(7).c_str())).toInt();
   int resHight = (QString(data.at(8).c_str())).toInt();
   mitk::USImageVideoSource::USImageRoi cropArea;
   cropArea.topLeftX = (QString(data.at(9).c_str())).toInt();
   cropArea.topLeftY = (QString(data.at(10).c_str())).toInt();
   cropArea.bottomRightX = (QString(data.at(11).c_str())).toInt();
   cropArea.bottomRightY = (QString(data.at(12).c_str())).toInt();
 
-  // Assemble Metadata
-  mitk::USImageMetadata::Pointer metadata = mitk::USImageMetadata::New();
-  metadata->SetDeviceManufacturer(manufacturer);
-  metadata->SetDeviceComment(comment);
-  metadata->SetDeviceModel(model);
-  metadata->SetProbeName("");
-  metadata->SetZoom("");
-
   // Create Device
   mitk::USVideoDevice::Pointer returnValue;
   if (file == "none")
   {
-    returnValue = mitk::USVideoDevice::New(source, metadata);
+    returnValue = mitk::USVideoDevice::New(source, manufacturer, model);
+    returnValue->SetComment(comment);
   }
   else
   {
-    returnValue = mitk::USVideoDevice::New(file, metadata);
+    returnValue = mitk::USVideoDevice::New(file, manufacturer, model);
+    returnValue->SetComment(comment);
   }
 
   mitk::USImageVideoSource::Pointer imageSource =
     dynamic_cast<mitk::USImageVideoSource*>(returnValue->GetUSImageSource().GetPointer());
   if ( ! imageSource )
   {
     MITK_ERROR << "There is no USImageVideoSource at the current device.";
     mitkThrow() << "There is no USImageVideoSource at the current device.";
   }
 
   // Set Video Options
   imageSource->SetColorOutput(!greyscale);
 
   // If Resolution override is activated, apply it
   if (resOverride)
     {
     imageSource->OverrideResolution(resWidth, resHight);
     imageSource->SetResolutionOverride(true);
     }
 
   // Set Crop Area
   imageSource->SetRegionOfInterest(cropArea);
 
   return returnValue;
 }
 
 void mitk::USDevicePersistence::split(std::string& text, std::string& separators, std::vector<std::string>& words)
 {
   int n = text.length();
   int start, stop;
 
   start = text.find_first_not_of(separators);
   while ((start >= 0) && (start < n))
   {
     stop = text.find_first_of(separators, start);
     if ((stop < 0) || (stop > n)) stop = n;
     words.push_back(text.substr(start, stop - start));
     start = text.find_first_not_of(separators, stop + 1);
   }
 }
\ No newline at end of file
diff --git a/Modules/US/USModel/mitkUSImage.h b/Modules/US/USModel/mitkUSImage.h
index dcee511a48..fad354b739 100644
--- a/Modules/US/USModel/mitkUSImage.h
+++ b/Modules/US/USModel/mitkUSImage.h
@@ -1,72 +1,74 @@
 /*===================================================================
 
 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 MITKUSIMAGE_H_HEADER_INCLUDED_
 #define MITKUSIMAGE_H_HEADER_INCLUDED_
 
 #include <MitkUSExports.h>
 #include <mitkCommon.h>
 #include <mitkImage.h>
 #include "mitkUSImageMetadata.h"
 
 namespace mitk {
 
     /**DocumentationZ
     * \brief This specialization of mitk::Image only appends necessary Metadata to an MITK image. Otherwise it can safely be treated like it's mother class.
     *  To generate an USImage from a standard mitkImage, call the appropriate constructor USImage(image::Pointer)
     * \ingroup US
+    *
+    * \deprecated Deprecated since 2014-06 -> use mitk::Image instead
     */
   class MitkUS_EXPORT USImage : public mitk::Image
     {
     public:
       mitkClassMacro(USImage, mitk::Image);
       itkFactorylessNewMacro(Self)
       itkCloneMacro(Self)
       /**
       * \brief this constructor creates an US Image identical to the recieved mitkImage. The Metadata are set to default.
       *  The image data is shared, so don't continue to manipulate the original image.
       * @throw mitk::Exception Throws an exception if there is a problem with access to the data while constructing the image.
       */
       mitkNewMacro1Param(Self, mitk::Image::Pointer);
 
       /**
       * \brief Reads out this image's Metadata set from the properties and returns a corresponding USImageMetadata object.
       */
       mitk::USImageMetadata::Pointer GetMetadata();
 
       /**
       * \brief Writes the information of the metadata object into the image's properties.
       */
       void SetMetadata(mitk::USImageMetadata::Pointer metadata);
 
 
     protected:
       /**
       * \brief This constructor creates an empty USImage. The Metadata are set to default.
       */
       USImage();
       /**
       * \brief this constructor creates an US Image identical to the recieved mitkImage. The Metadata are set to default.
       *  The image data is shared, so don't continue to manipulate the original image.
       */
       USImage(mitk::Image::Pointer image);
       virtual ~USImage();
 
 
     };
 } // namespace mitk
 #endif
diff --git a/Modules/US/USModel/mitkUSImageMetadata.h b/Modules/US/USModel/mitkUSImageMetadata.h
index 83eb294cf0..187697e2e1 100644
--- a/Modules/US/USModel/mitkUSImageMetadata.h
+++ b/Modules/US/USModel/mitkUSImageMetadata.h
@@ -1,88 +1,90 @@
 /*===================================================================
 
 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 MITKUSIMAGEMETADATA_H_HEADER_INCLUDED_
 #define MITKUSIMAGEMETADATA_H_HEADER_INCLUDED_
 
 #include <MitkUSExports.h>
 #include <mitkCommon.h>
 #include <itkObject.h>
 #include <itkObjectFactory.h>
 
 namespace mitk {
   /**Documentation
   * \brief This class encapsulates all necessary metadata to describe a US Image.
   * \ingroup US
+  *
+  * \deprecated Deprecated since 2014-06
   */
   class MitkUS_EXPORT USImageMetadata : public itk::Object
   {
   public:
     mitkClassMacro(USImageMetadata, itk::Object);
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     //## getter and setter ##
     itkGetMacro(DeviceManufacturer, std::string);
     itkSetMacro(DeviceManufacturer, std::string);
     itkGetMacro(DeviceModel, std::string);
     itkSetMacro(DeviceModel, std::string);
     itkGetMacro(DeviceComment, std::string);
     itkSetMacro(DeviceComment, std::string);
     itkGetMacro(ProbeName,  std::string);
     itkSetMacro(ProbeName,  std::string);
     itkGetMacro(ProbeFrequency,  std::string);
     itkSetMacro(ProbeFrequency,  std::string);
     itkGetMacro(Zoom,  std::string);
     itkSetMacro(Zoom,  std::string);
     itkGetMacro(DeviceIsVideoOnly, bool);
     itkSetMacro(DeviceIsVideoOnly, bool);
     itkGetMacro(DeviceIsCalibrated, bool);
     itkSetMacro(DeviceIsCalibrated, bool);
     itkGetMacro(DeviceClass, std::string);
     itkSetMacro(DeviceClass, std::string);
 
     // The following constants define how metadata is written to and read from an mitk image
     // when defining new properties, add them here, define them in the cpp, and add them to
     // USImage's getMetadata and setMetadata methods as well
     static const char* PROP_DEV_MANUFACTURER;
     static const char* PROP_DEV_MODEL;
     static const char* PROP_DEV_COMMENT;
     static const char* PROP_DEV_ISVIDEOONLY;
     static const char* PROP_DEV_ISCALIBRATED;
     static const char* PROP_PROBE_NAME;
     static const char* PROP_PROBE_FREQUENCY;
     static const char* PROP_ZOOM;
     static const char* PROP_DEVICE_CLASS;
 
   protected:
     /**
     * \brief Creates a new metadata object with all fields set to default values.
     */
     USImageMetadata();
     virtual ~USImageMetadata();
 
     std::string m_DeviceManufacturer;
     std::string m_DeviceModel;
     std::string m_DeviceComment;
     std::string m_ProbeName;
     std::string m_ProbeFrequency;
     std::string m_Zoom;
     std::string m_DeviceClass;
     bool m_DeviceIsVideoOnly;
     bool m_DeviceIsCalibrated;
   };
 } // namespace mitk
 #endif
diff --git a/Modules/US/USNavigation/mitkUSCombinedModality.cpp b/Modules/US/USNavigation/mitkUSCombinedModality.cpp
index 65d8d6aab7..44c0438805 100644
--- a/Modules/US/USNavigation/mitkUSCombinedModality.cpp
+++ b/Modules/US/USNavigation/mitkUSCombinedModality.cpp
@@ -1,495 +1,551 @@
 /*===================================================================
 
 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"
 
+#include <algorithm>
+
 //TempIncludes
 #include <tinyxml.h>
 
 const std::string mitk::USCombinedModality::DeviceClassIdentifier = "org.mitk.modules.us.USCombinedModality";
+const char* mitk::USCombinedModality::DefaultProbeIdentifier = "default";
+const char* mitk::USCombinedModality::ProbeAndDepthSeperator = "_";
 
 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;
-  }
+  return this->GetCalibration(this->GetCurrentDepthValue(), this->GetIdentifierForCurrentProbe());
+}
+
+mitk::AffineTransform3D::Pointer mitk::USCombinedModality::GetCalibration(std::string depth)
+{
+  return this->GetCalibration(depth, this->GetIdentifierForCurrentProbe());
+}
+
+mitk::AffineTransform3D::Pointer mitk::USCombinedModality::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::USCombinedModality::ProbeAndDepthSeperator + depth;
 
   // find calibration for combination of probe identifier and depth
   std::map<std::string, mitk::AffineTransform3D::Pointer>::iterator calibrationIterator
     = m_Calibrations.find(calibrationKey);
 
   if (calibrationIterator == m_Calibrations.end())
   {
-    MITK_WARN("USCombinedModality")("USDevice")
+    MITK_INFO("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);
   }
 }
 
+bool mitk::USCombinedModality::RemoveCalibration()
+{
+  return this->RemoveCalibration(this->GetCurrentDepthValue(), this->GetIdentifierForCurrentProbe());
+}
+
+bool mitk::USCombinedModality::RemoveCalibration(std::string depth)
+{
+  return this->RemoveCalibration(depth, this->GetIdentifierForCurrentProbe());
+}
+
+bool mitk::USCombinedModality::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::USCombinedModality::ProbeAndDepthSeperator + depth;
+
+  return m_Calibrations.erase(calibrationKey) > 0;
+}
+
 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_ERROR << "Empty string passed to Deserialize() method of CombinedModality. Aborting...";
     mitkThrow() << "Empty string passed to Deserialize() method of CombinedModality. Aborting...";
     return;
   }
   // Clear previous calibrations if necessary
   if (clearPreviousCalibrations) m_Calibrations.clear();
 
   // Parse Input
   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();
   if(root == NULL)
   {
     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 != 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(
+  return this->GetIdentifierForCurrentProbe()
+    + mitk::USCombinedModality::ProbeAndDepthSeperator
+    + this->GetCurrentDepthValue();
+}
+
+std::string mitk::USCombinedModality::GetIdentifierForCurrentProbe()
+{
+  us::ServiceProperties usdeviceProperties = m_UltrasoundDevice->GetServiceProperties();
+
+  us::ServiceProperties::const_iterator probeIt = usdeviceProperties.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())
+  std::string probeName = mitk::USCombinedModality::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::USCombinedModality::GetCurrentDepthValue()
+{
+  us::ServiceProperties usdeviceProperties = m_UltrasoundDevice->GetServiceProperties();
+
   // 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())
+  us::ServiceProperties::iterator depthIterator = usdeviceProperties.find(
+    mitk::USCombinedModality::GetPropertyKeys().US_PROPKEY_BMODE_DEPTH);
+
+  if (depthIterator != usdeviceProperties.end())
   {
     depth = depthIterator->second.ToString();
   }
   else
   {
     depth = "0";
   }
 
-  return probeName + depth;
+  return 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 1c63d0416d..9ea5049983 100644
--- a/Modules/US/USNavigation/mitkUSCombinedModality.h
+++ b/Modules/US/USNavigation/mitkUSCombinedModality.h
@@ -1,207 +1,256 @@
 /*===================================================================
 
 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;
+    static const char*       DefaultProbeIdentifier;
+    static const char*       ProbeAndDepthSeperator;
 
     mitkClassMacro(USCombinedModality, USDevice);
     mitkNewMacro4Param(USCombinedModality, USDevice::Pointer, itk::SmartPointer<NavigationDataSource>, std::string, std::string);
 
     itkGetMacro(UltrasoundDevice, itk::SmartPointer<USDevice>);
     itkSetMacro(UltrasoundDevice, itk::SmartPointer<USDevice>);
     itkGetMacro(TrackingDevice, itk::SmartPointer<NavigationDataSource>);
     itkSetMacro(TrackingDevice, itk::SmartPointer<NavigationDataSource>);
 
     /**
-    * \brief Getter for calibration data of the currently active probe and depth.
+    * \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);
+
     /**
     * \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.
     */
     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.
     *
     * \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);
 
   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();
+    std::string GetIdentifierForCurrentProbe();
+    std::string GetCurrentDepthValue();
 
     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_
diff --git a/Modules/USUI/Qmitk/QmitkUSNewVideoDeviceWidget.cpp b/Modules/USUI/Qmitk/QmitkUSNewVideoDeviceWidget.cpp
index 67f99d5c57..b5a6791746 100644
--- a/Modules/USUI/Qmitk/QmitkUSNewVideoDeviceWidget.cpp
+++ b/Modules/USUI/Qmitk/QmitkUSNewVideoDeviceWidget.cpp
@@ -1,164 +1,163 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 //#define _USE_MATH_DEFINES
 #include <QmitkUSNewVideoDeviceWidget.h>
 
 //QT headers
+#include <QFileDialog>
 
 //mitk headers
 
 //itk headers
 
 const std::string QmitkUSNewVideoDeviceWidget::VIEW_ID = "org.mitk.views.QmitkUSNewVideoDeviceWidget";
 
 QmitkUSNewVideoDeviceWidget::QmitkUSNewVideoDeviceWidget(QWidget* parent, Qt::WindowFlags f): QWidget(parent, f)
 {
   m_Controls = NULL;
   CreateQtPartControl(this);
-
-  //disable a few UI components which are not needed at the moment
-  m_Controls->probe_label->setVisible(false);
-  m_Controls->probe_label2->setVisible(false);
-  m_Controls->zoom_label->setVisible(false);
-  m_Controls->m_Probe->setVisible(false);
-  m_Controls->m_Zoom->setVisible(false);
 }
 
 QmitkUSNewVideoDeviceWidget::~QmitkUSNewVideoDeviceWidget()
 {
 }
 
 //////////////////// INITIALIZATION /////////////////////
 
 void QmitkUSNewVideoDeviceWidget::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkUSNewVideoDeviceWidgetControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
   }
 }
 
 void QmitkUSNewVideoDeviceWidget::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( m_Controls->m_BtnDone,   SIGNAL(clicked()), this, SLOT(OnClickedDone()) );
     connect( m_Controls->m_BtnCancel, SIGNAL(clicked()), this, SLOT(OnClickedCancel()) );
     connect( m_Controls->m_RadioDeviceSource, SIGNAL(clicked()), this, SLOT(OnDeviceTypeSelection()) );
     connect( m_Controls->m_RadioFileSource,   SIGNAL(clicked()), this, SLOT(OnDeviceTypeSelection()) );
+    connect( m_Controls->m_OpenFileButton, SIGNAL(clicked()), this, SLOT(OnOpenFileButtonClicked()) );
   }
 }
 
 ///////////// Methods & Slots Handling Direct Interaction /////////////////
 
-void QmitkUSNewVideoDeviceWidget::OnClickedDone(){
+void QmitkUSNewVideoDeviceWidget::OnClickedDone()
+{
   m_Active = false;
 
-  // Assemble Metadata
-  mitk::USImageMetadata::Pointer metadata = mitk::USImageMetadata::New();
-  metadata->SetDeviceComment(m_Controls->m_Comment->text().toStdString());
-  metadata->SetDeviceModel(m_Controls->m_Model->text().toStdString());
-  metadata->SetDeviceManufacturer(m_Controls->m_Manufacturer->text().toStdString());
-  metadata->SetProbeName(m_Controls->m_Probe->text().toStdString());
-  metadata->SetZoom(m_Controls->m_Zoom->text().toStdString());
-
   // Create Device
   mitk::USVideoDevice::Pointer newDevice;
-  if (m_Controls->m_RadioDeviceSource->isChecked()){
-    int deviceID = m_Controls->m_DeviceSelector->value();
-    newDevice = mitk::USVideoDevice::New(deviceID, metadata);
-  } else {
-    std::string filepath = m_Controls->m_FilePathSelector->text().toStdString();
-    newDevice = mitk::USVideoDevice::New(filepath, metadata);
+  if (m_Controls->m_RadioDeviceSource->isChecked())
+  {
+    newDevice = mitk::USVideoDevice::New(
+      m_Controls->m_DeviceSelector->value(),
+      m_Controls->m_Manufacturer->text().toStdString(),
+      m_Controls->m_Model->text().toStdString());
+    newDevice->SetComment(m_Controls->m_Comment->text().toStdString());
+  }
+  else
+  {
+    newDevice = mitk::USVideoDevice::New(
+      m_Controls->m_FilePathSelector->text().toStdString(),
+      m_Controls->m_Manufacturer->text().toStdString(),
+      m_Controls->m_Model->text().toStdString());
+    newDevice->SetComment(m_Controls->m_Comment->text().toStdString());
   }
 
   // get USImageVideoSource from new device
   mitk::USImageVideoSource::Pointer imageSource =
     dynamic_cast<mitk::USImageVideoSource*>(newDevice->GetUSImageSource().GetPointer());
   if ( ! imageSource )
   {
     MITK_ERROR << "There is no USImageVideoSource at the current device.";
     mitkThrow() << "There is no USImageVideoSource at the current device.";
   }
 
   // Set Video Options
   imageSource->SetColorOutput(! m_Controls->m_CheckGreyscale->isChecked());
 
   // If Resolution override is activated, apply it
   if (m_Controls->m_CheckResolutionOverride->isChecked())
   {
     int width  = m_Controls->m_ResolutionWidth->value();
     int height = m_Controls->m_ResolutionHeight->value();
     imageSource->OverrideResolution(width, height);
     imageSource->SetResolutionOverride(true);
   }
 
   newDevice->Initialize();
 
   emit Finished();
 }
 
 void QmitkUSNewVideoDeviceWidget::OnClickedCancel(){
   m_TargetDevice = 0;
   m_Active = false;
   emit Finished();
 }
 
 void QmitkUSNewVideoDeviceWidget::OnDeviceTypeSelection(){
   m_Controls->m_FilePathSelector->setEnabled(m_Controls->m_RadioFileSource->isChecked());
   m_Controls->m_DeviceSelector->setEnabled(m_Controls->m_RadioDeviceSource->isChecked());
 }
 
+void QmitkUSNewVideoDeviceWidget::OnOpenFileButtonClicked()
+{
+  QString fileName = QFileDialog::getOpenFileName(NULL, "Open Video File");
+  if ( fileName.isNull() ) { return; } // user pressed cancel
+
+  m_Controls->m_FilePathSelector->setText(fileName);
+
+  m_Controls->m_RadioFileSource->setChecked(true);
+  this->OnDeviceTypeSelection();
+}
+
 ///////////////// Methods & Slots Handling Logic //////////////////////////
 
 void QmitkUSNewVideoDeviceWidget::EditDevice(mitk::USDevice::Pointer device)
 {
   // If no VideoDevice is given, throw an exception
   if (device->GetDeviceClass().compare("org.mitk.modules.us.USVideoDevice") != 0){
     // TODO Alert if bad path
     mitkThrow() << "NewVideoDeviceWidget recieved an incompatible device type to edit. Type was: " << device->GetDeviceClass();
   }
   m_TargetDevice = static_cast<mitk::USVideoDevice*> (device.GetPointer());
   m_Active = true;
 }
 
 void QmitkUSNewVideoDeviceWidget::CreateNewDevice()
 {
   m_TargetDevice = 0;
-  InitFields(mitk::USImageMetadata::New());
   m_Active = true;
 }
 
 /////////////////////// HOUSEHOLDING CODE ///////////////////////////////
 
 QListWidgetItem* QmitkUSNewVideoDeviceWidget::ConstructItemFromDevice(mitk::USDevice::Pointer device){
   QListWidgetItem *result = new QListWidgetItem;
   std::string text = device->GetDeviceManufacturer() + "|" + device->GetDeviceModel();
   result->setText(text.c_str());
   return result;
 }
-
-void QmitkUSNewVideoDeviceWidget::InitFields(mitk::USImageMetadata::Pointer metadata){
-  this->m_Controls->m_Manufacturer->setText (metadata->GetDeviceManufacturer().c_str());
-  this->m_Controls->m_Model->setText (metadata->GetDeviceModel().c_str());
-  this->m_Controls->m_Comment->setText (metadata->GetDeviceComment().c_str());
-  this->m_Controls->m_Probe->setText (metadata->GetProbeName().c_str());
-  this->m_Controls->m_Zoom->setText (metadata->GetZoom().c_str());
-}
diff --git a/Modules/USUI/Qmitk/QmitkUSNewVideoDeviceWidget.h b/Modules/USUI/Qmitk/QmitkUSNewVideoDeviceWidget.h
index 7b25638785..c8d6d4e7fc 100644
--- a/Modules/USUI/Qmitk/QmitkUSNewVideoDeviceWidget.h
+++ b/Modules/USUI/Qmitk/QmitkUSNewVideoDeviceWidget.h
@@ -1,122 +1,116 @@
 /*===================================================================
 
 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 _QmitkUSNewVideoDeviceWidget_H_INCLUDED
 #define _QmitkUSNewVideoDeviceWidget_H_INCLUDED
 
 #include "MitkUSUIExports.h"
 #include "ui_QmitkUSNewVideoDeviceWidgetControls.h"
 #include "mitkUSVideoDevice.h"
-#include "mitkUSImageMetadata.h"
 
 //QT headers
 #include <QWidget>
 #include <QListWidgetItem>
 
 //mitk header
 
 /**
 * @brief This Widget enables the USer to create and connect Video Devices.
 *
 * @ingroup USUI
 */
 class MitkUSUI_EXPORT QmitkUSNewVideoDeviceWidget :public QWidget
 {
 
   //this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
   Q_OBJECT
 
   public:
 
     static const std::string VIEW_ID;
 
     QmitkUSNewVideoDeviceWidget(QWidget* p = 0, Qt::WindowFlags f1 = 0);
     virtual ~QmitkUSNewVideoDeviceWidget();
 
     /* @brief This method is part of the widget an needs not to be called seperately. */
     virtual void CreateQtPartControl(QWidget *parent);
     /* @brief This method is part of the widget an needs not to be called seperately. (Creation of the connections of main and control widget.)*/
     virtual void CreateConnections();
 
   signals:
 
     void Finished();
 
   public slots:
 
     /*
     \brief Activates the widget and displays the given device's Data to edit.
     */
     void EditDevice(mitk::USDevice::Pointer device);
 
     /*
     \brief Activates the widget with fields empty.
     */
     void CreateNewDevice();
 
   protected slots:
 
     /*
     \brief Called, when the the user clicks the "Done" button (Labeled either "Add Device" or "Edit Device", depending on the situation.
     */
     void OnClickedDone();
 
     /*
     \brief Called, when the button "Cancel" was clicked
     */
     void OnClickedCancel();
 
     /*
     \brief Called, when the Use selects one of the Radiobuttons
     */
     void OnDeviceTypeSelection();
 
-
+    void OnOpenFileButtonClicked();
 
 
 
   protected:
 
     Ui::QmitkUSNewVideoDeviceWidgetControls* m_Controls; ///< member holding the UI elements of this widget
 
     /*
     \brief Constructs a ListItem from the given device for display in the list of active devices
     */
     QListWidgetItem* ConstructItemFromDevice(mitk::USDevice::Pointer device);
 
-    /*
-    \brief Initializes the Widget's ListItems with the given Metadata Object.
-    */
-    void InitFields(mitk::USImageMetadata::Pointer);
-
     /*
     \brief Displays whether this widget is active or not. It gets activated by either sending a Signal to
     *  the "CreateNewDevice" Slot or to the "EditDevice" Slot. If the user finishes editing the device, a
     * "EditingComplete" Signal is sent, and the widget is set to inactive again. Clicking Cancel also
     *  deactivates it.
     */
     bool m_Active;
 
     /**
     *   \brief This is the device to edit. It is either the device transmitted in the "EditDevice" signal, or a new one
     *  if the "CreateNewDevice slot was called.
     */
     mitk::USVideoDevice::Pointer m_TargetDevice;
 
 
 };
 
 #endif // _QmitkUSNewVideoDeviceWidget_H_INCLUDED
diff --git a/Modules/USUI/Qmitk/QmitkUSNewVideoDeviceWidgetControls.ui b/Modules/USUI/Qmitk/QmitkUSNewVideoDeviceWidgetControls.ui
index 336a499aaa..e8ff88718e 100644
--- a/Modules/USUI/Qmitk/QmitkUSNewVideoDeviceWidgetControls.ui
+++ b/Modules/USUI/Qmitk/QmitkUSNewVideoDeviceWidgetControls.ui
@@ -1,327 +1,312 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>QmitkUSNewVideoDeviceWidgetControls</class>
  <widget class="QWidget" name="QmitkUSNewVideoDeviceWidgetControls">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>285</width>
     <height>595</height>
    </rect>
   </property>
   <property name="minimumSize">
    <size>
     <width>0</width>
     <height>0</height>
    </size>
   </property>
   <property name="windowTitle">
    <string>QmitkUSNewVideoDeviceWidget</string>
   </property>
   <layout class="QFormLayout" name="formLayout">
    <property name="fieldGrowthPolicy">
     <enum>QFormLayout::AllNonFixedFieldsGrow</enum>
    </property>
    <property name="margin">
     <number>0</number>
    </property>
    <item row="0" column="0" colspan="2">
     <widget class="QGroupBox" name="m_BoxMetadata">
      <property name="title">
       <string>Metadata:</string>
      </property>
      <layout class="QGridLayout" name="gridLayout">
+      <item row="3" column="0">
+       <widget class="QLabel" name="label_5">
+        <property name="text">
+         <string>Comment</string>
+        </property>
+       </widget>
+      </item>
       <item row="0" column="1">
        <widget class="QLabel" name="label_6">
         <property name="font">
          <font>
           <weight>50</weight>
           <bold>false</bold>
           <underline>true</underline>
          </font>
         </property>
         <property name="text">
          <string>Device Information:</string>
         </property>
        </widget>
       </item>
       <item row="1" column="0">
        <widget class="QLabel" name="label">
         <property name="text">
          <string>Manufacturer</string>
         </property>
        </widget>
       </item>
       <item row="1" column="1">
-       <widget class="QLineEdit" name="m_Manufacturer"/>
+       <widget class="QLineEdit" name="m_Manufacturer">
+        <property name="text">
+         <string>Unknown Manufacturer</string>
+        </property>
+       </widget>
       </item>
       <item row="2" column="0">
        <widget class="QLabel" name="label_2">
         <property name="text">
          <string>Model</string>
         </property>
        </widget>
       </item>
       <item row="2" column="1">
-       <widget class="QLineEdit" name="m_Model"/>
-      </item>
-      <item row="3" column="0">
-       <widget class="QLabel" name="label_5">
+       <widget class="QLineEdit" name="m_Model">
         <property name="text">
-         <string>Comment</string>
+         <string>Unknown Model</string>
         </property>
        </widget>
       </item>
       <item row="3" column="1">
-       <widget class="QLineEdit" name="m_Comment"/>
-      </item>
-      <item row="4" column="1">
-       <widget class="QLabel" name="probe_label">
-        <property name="font">
-         <font>
-          <underline>true</underline>
-         </font>
-        </property>
+       <widget class="QLineEdit" name="m_Comment">
         <property name="text">
-         <string>Probe Information:</string>
+         <string>None</string>
         </property>
        </widget>
       </item>
-      <item row="5" column="0">
-       <widget class="QLabel" name="probe_label2">
-        <property name="text">
-         <string>Probe</string>
-        </property>
-       </widget>
-      </item>
-      <item row="5" column="1">
-       <widget class="QLineEdit" name="m_Probe"/>
-      </item>
-      <item row="6" column="0">
-       <widget class="QLabel" name="zoom_label">
-        <property name="text">
-         <string>Zoom</string>
-        </property>
-       </widget>
-      </item>
-      <item row="6" column="1">
-       <widget class="QLineEdit" name="m_Zoom"/>
-      </item>
      </layout>
     </widget>
    </item>
    <item row="1" column="0" colspan="2">
     <widget class="QGroupBox" name="groupBox">
      <property name="title">
       <string>Video Source:</string>
      </property>
-     <layout class="QFormLayout" name="formLayout_2">
-      <property name="labelAlignment">
-       <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter</set>
-      </property>
-      <item row="1" column="1">
-       <widget class="QLineEdit" name="m_FilePathSelector">
-        <property name="enabled">
-         <bool>false</bool>
-        </property>
+     <layout class="QFormLayout" name="formLayout_3">
+      <item row="1" column="0">
+       <widget class="QRadioButton" name="m_RadioDeviceSource">
         <property name="text">
-         <string/>
+         <string>From Device:</string>
+        </property>
+        <property name="checked">
+         <bool>true</bool>
         </property>
        </widget>
       </item>
-      <item row="0" column="1">
+      <item row="1" column="1">
        <widget class="QSpinBox" name="m_DeviceSelector">
         <property name="minimum">
-         <number>-1</number>
+         <number>0</number>
         </property>
         <property name="maximum">
          <number>10</number>
         </property>
         <property name="value">
-         <number>-1</number>
+         <number>0</number>
         </property>
        </widget>
       </item>
-      <item row="0" column="0">
-       <widget class="QRadioButton" name="m_RadioDeviceSource">
-        <property name="text">
-         <string>From Device:</string>
-        </property>
-        <property name="checked">
-         <bool>true</bool>
-        </property>
-       </widget>
-      </item>
-      <item row="1" column="0">
+      <item row="2" column="0">
        <widget class="QRadioButton" name="m_RadioFileSource">
         <property name="text">
          <string>From File:</string>
         </property>
        </widget>
       </item>
+      <item row="2" column="1">
+       <layout class="QHBoxLayout" name="horizontalLayout_2">
+        <item>
+         <widget class="QLineEdit" name="m_FilePathSelector">
+          <property name="enabled">
+           <bool>false</bool>
+          </property>
+          <property name="text">
+           <string/>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QToolButton" name="m_OpenFileButton">
+          <property name="text">
+           <string>...</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
      </layout>
     </widget>
    </item>
    <item row="2" column="0" colspan="2">
     <widget class="QGroupBox" name="groupBox_3">
      <property name="title">
       <string>Video Options:</string>
      </property>
      <layout class="QVBoxLayout" name="verticalLayout">
       <item>
        <widget class="QCheckBox" name="m_CheckGreyscale">
         <property name="text">
          <string>Greyscale Image (Significantly faster)</string>
         </property>
         <property name="checked">
          <bool>true</bool>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item row="5" column="0" colspan="2">
     <widget class="QGroupBox" name="groupBox_2">
      <property name="title">
       <string>Override:</string>
      </property>
      <layout class="QGridLayout" name="gridLayout_2">
       <item row="0" column="1" colspan="2">
        <widget class="QLabel" name="label_8">
         <property name="text">
          <string>If you encounter problems with devices (e.g. Images of uniform color and error messages in the log window), then try to set the resolution externally using the device's driver panel and then enter the same resolution here.</string>
         </property>
         <property name="wordWrap">
          <bool>true</bool>
         </property>
        </widget>
       </item>
       <item row="2" column="1">
        <widget class="QLabel" name="label_9">
         <property name="text">
          <string>Width:</string>
         </property>
        </widget>
       </item>
       <item row="3" column="1">
        <widget class="QSpinBox" name="m_ResolutionWidth">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="minimum">
          <number>10</number>
         </property>
         <property name="maximum">
          <number>2048</number>
         </property>
         <property name="singleStep">
          <number>10</number>
         </property>
         <property name="value">
          <number>640</number>
         </property>
        </widget>
       </item>
       <item row="3" column="2">
        <widget class="QSpinBox" name="m_ResolutionHeight">
         <property name="sizePolicy">
          <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
           <horstretch>0</horstretch>
           <verstretch>0</verstretch>
          </sizepolicy>
         </property>
         <property name="minimum">
          <number>10</number>
         </property>
         <property name="maximum">
          <number>2048</number>
         </property>
         <property name="singleStep">
          <number>10</number>
         </property>
         <property name="value">
          <number>480</number>
         </property>
        </widget>
       </item>
       <item row="2" column="2">
        <widget class="QLabel" name="label_10">
         <property name="text">
          <string>Height:</string>
         </property>
        </widget>
       </item>
       <item row="1" column="1" colspan="2">
        <widget class="QCheckBox" name="m_CheckResolutionOverride">
         <property name="text">
          <string>Enable Resolution Override</string>
         </property>
        </widget>
       </item>
      </layout>
     </widget>
    </item>
    <item row="6" column="0" colspan="2">
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>40</height>
       </size>
      </property>
     </spacer>
    </item>
    <item row="3" column="1">
     <layout class="QHBoxLayout" name="horizontalLayout">
      <item>
       <widget class="QPushButton" name="m_BtnDone">
        <property name="text">
         <string>Add Video Device</string>
        </property>
        <property name="icon">
         <iconset resource="../resources/USUI.qrc">
          <normaloff>:/USUI/accept.png</normaloff>:/USUI/accept.png</iconset>
        </property>
       </widget>
      </item>
      <item>
       <widget class="QPushButton" name="m_BtnCancel">
        <property name="text">
         <string>Cancel</string>
        </property>
        <property name="icon">
         <iconset resource="../resources/USUI.qrc">
          <normaloff>:/USUI/restart.png</normaloff>:/USUI/restart.png</iconset>
        </property>
       </widget>
      </item>
     </layout>
    </item>
   </layout>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <tabstops>
   <tabstop>m_Manufacturer</tabstop>
   <tabstop>m_Model</tabstop>
   <tabstop>m_Comment</tabstop>
-  <tabstop>m_Probe</tabstop>
-  <tabstop>m_Zoom</tabstop>
   <tabstop>m_RadioDeviceSource</tabstop>
   <tabstop>m_DeviceSelector</tabstop>
   <tabstop>m_RadioFileSource</tabstop>
-  <tabstop>m_FilePathSelector</tabstop>
   <tabstop>m_CheckResolutionOverride</tabstop>
  </tabstops>
  <resources>
   <include location="../resources/USUI.qrc"/>
  </resources>
  <connections/>
 </ui>
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
index 9eca91eb8d..fa7a58eec1 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.cpp
@@ -1,1106 +1,1181 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "QmitkMITKIGTTrackingToolboxView.h"
 #include "QmitkStdMultiWidget.h"
 
 // Qt
 #include <QMessageBox>
+#include <QSettings>
 #include <qfiledialog.h>
 
 // MITK
 #include <mitkNavigationToolStorageDeserializer.h>
 #include <mitkTrackingDeviceSourceConfigurator.h>
 #include <mitkTrackingVolumeGenerator.h>
 #include <mitkNDITrackingDevice.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNavigationToolStorageSerializer.h>
 #include <mitkProgressBar.h>
 
 // vtk
 #include <vtkSphereSource.h>
 //for exceptions
 #include <mitkIGTException.h>
 #include <mitkIGTIOException.h>
 
 
 
 const std::string QmitkMITKIGTTrackingToolboxView::VIEW_ID = "org.mitk.views.mitkigttrackingtoolbox";
 
 QmitkMITKIGTTrackingToolboxView::QmitkMITKIGTTrackingToolboxView()
 : QmitkFunctionality()
 , m_Controls( 0 )
 , m_MultiWidget( NULL )
 {
   m_TrackingTimer = new QTimer(this);
   m_tracking = false;
   m_logging = false;
   m_loggedFrames = 0;
 
   //initialize worker thread
   m_WorkerThread = new QThread();
   m_Worker = new QmitkMITKIGTTrackingToolboxViewWorker();
 }
 
 QmitkMITKIGTTrackingToolboxView::~QmitkMITKIGTTrackingToolboxView()
 {
 try
   {
   //clean up worker thread
   if(m_WorkerThread) {delete m_WorkerThread;}
   if(m_Worker) {delete m_Worker;}
   //remove the tracking volume
   this->GetDataStorage()->Remove(m_TrackingVolumeNode);
   //remove the tool storage
   if(m_toolStorage) {m_toolStorage->UnRegisterMicroservice();}
   if(m_TrackingDeviceSource) {m_TrackingDeviceSource->UnRegisterMicroservice();}
   }
 catch(std::exception& e) {MITK_WARN << "Unexpected exception during clean up of tracking toolbox view: " << e.what();}
 catch(...) {MITK_WARN << "Unexpected unknown error during clean up of tracking toolbox view!";}
+  this->StoreUISettings();
 }
 
 
 void QmitkMITKIGTTrackingToolboxView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkMITKIGTTrackingToolboxViewControls;
     m_Controls->setupUi( parent );
 
     //create connections
     connect( m_Controls->m_LoadTools, SIGNAL(clicked()), this, SLOT(OnLoadTools()) );
     connect( m_Controls->m_Connect, SIGNAL(clicked()), this, SLOT(OnConnect()) );
     connect( m_Controls->m_Disconnect, SIGNAL(clicked()), this, SLOT(OnDisconnect()) );
     connect( m_Controls->m_StartTracking, SIGNAL(clicked()), this, SLOT(OnStartTracking()) );
     connect( m_Controls->m_StopTracking, SIGNAL(clicked()), this, SLOT(OnStopTracking()) );
     connect( m_TrackingTimer, SIGNAL(timeout()), this, SLOT(UpdateTrackingTimer()));
     connect( m_Controls->m_ChooseFile, SIGNAL(clicked()), this, SLOT(OnChooseFileClicked()));
     connect( m_Controls->m_StartLogging, SIGNAL(clicked()), this, SLOT(StartLogging()));
     connect( m_Controls->m_StopLogging, SIGNAL(clicked()), this, SLOT(StopLogging()));
     connect( m_Controls->m_VolumeSelectionBox, SIGNAL(currentIndexChanged(QString)), this, SLOT(OnTrackingVolumeChanged(QString)));
     connect( m_Controls->m_ShowTrackingVolume, SIGNAL(clicked()), this, SLOT(OnShowTrackingVolumeChanged()));
     connect( m_Controls->m_AutoDetectTools, SIGNAL(clicked()), this, SLOT(OnAutoDetectTools()));
     connect( m_Controls->m_ResetTools, SIGNAL(clicked()), this, SLOT(OnResetTools()));
     connect( m_Controls->m_AddSingleTool, SIGNAL(clicked()), this, SLOT(OnAddSingleTool()));
     connect( m_Controls->m_NavigationToolCreationWidget, SIGNAL(NavigationToolFinished()), this, SLOT(OnAddSingleToolFinished()));
     connect( m_Controls->m_NavigationToolCreationWidget, SIGNAL(Canceled()), this, SLOT(OnAddSingleToolCanceled()));
     connect( m_Controls->m_csvFormat, SIGNAL(clicked()), this, SLOT(OnToggleFileExtension()));
     connect( m_Controls->m_xmlFormat, SIGNAL(clicked()), this, SLOT(OnToggleFileExtension()));
 
     //connections for the tracking device configuration widget
     connect( m_Controls->m_configurationWidget, SIGNAL(TrackingDeviceSelectionChanged()), this, SLOT(OnTrackingDeviceChanged()));
     connect( m_Controls->m_configurationWidget, SIGNAL(ProgressStarted()), this, SLOT(DisableOptionsButtons()));
     connect( m_Controls->m_configurationWidget, SIGNAL(ProgressStarted()), this, SLOT(DisableTrackingConfigurationButtons()));
     connect( m_Controls->m_configurationWidget, SIGNAL(ProgressStarted()), this, SLOT(DisableTrackingControls()));
     connect( m_Controls->m_configurationWidget, SIGNAL(ProgressFinished()), this, SLOT(EnableOptionsButtons()));
     connect( m_Controls->m_configurationWidget, SIGNAL(ProgressFinished()), this, SLOT(EnableTrackingConfigurationButtons()));
     connect( m_Controls->m_configurationWidget, SIGNAL(ProgressFinished()), this, SLOT(EnableTrackingControls()));
 
     //connect worker thread
     connect(m_Worker, SIGNAL(AutoDetectToolsFinished(bool,QString)), this, SLOT(OnAutoDetectToolsFinished(bool,QString)) );
     connect(m_Worker, SIGNAL(ConnectDeviceFinished(bool,QString)), this, SLOT(OnConnectFinished(bool,QString)) );
     connect(m_Worker, SIGNAL(StartTrackingFinished(bool,QString)), this, SLOT(OnStartTrackingFinished(bool,QString)) );
     connect(m_Worker, SIGNAL(StopTrackingFinished(bool,QString)), this, SLOT(OnStopTrackingFinished(bool,QString)) );
     connect(m_Worker, SIGNAL(DisconnectDeviceFinished(bool,QString)), this, SLOT(OnDisconnectFinished(bool,QString)) );
     connect(m_WorkerThread,SIGNAL(started()), m_Worker, SLOT(ThreadFunc()) );
 
     //move the worker to the thread
     m_Worker->moveToThread(m_WorkerThread);
 
 
     //initialize widgets
     m_Controls->m_configurationWidget->EnableAdvancedUserControl(false);
     m_Controls->m_TrackingToolsStatusWidget->SetShowPositions(true);
     m_Controls->m_TrackingToolsStatusWidget->SetTextAlignment(Qt::AlignLeft);
 
     //initialize tracking volume node
     m_TrackingVolumeNode = mitk::DataNode::New();
     m_TrackingVolumeNode->SetName("TrackingVolume");
     m_TrackingVolumeNode->SetOpacity(0.25);
     m_TrackingVolumeNode->SetBoolProperty("Backface Culling",true);
     mitk::Color red;
     red.SetRed(1);
     m_TrackingVolumeNode->SetColor(red);
-    GetDataStorage()->Add(m_TrackingVolumeNode);
 
     //initialize buttons
     m_Controls->m_Connect->setEnabled(true);
     m_Controls->m_Disconnect->setEnabled(false);
     m_Controls->m_StartTracking->setEnabled(false);
     m_Controls->m_StopTracking->setEnabled(false);
     m_Controls->m_AutoDetectTools->setVisible(false); //only visible if tracking device is Aurora
 
     //Update List of available models for selected tool.
     std::vector<mitk::TrackingDeviceData> Compatibles = mitk::GetDeviceDataForLine( m_Controls->m_configurationWidget->GetTrackingDevice()->GetType());
     m_Controls->m_VolumeSelectionBox->clear();
     for(int i = 0; i < Compatibles.size(); i++)
     {
       m_Controls->m_VolumeSelectionBox->addItem(Compatibles[i].Model.c_str());
     }
 
     //initialize tool storage
     m_toolStorage = mitk::NavigationToolStorage::New(GetDataStorage());
     m_toolStorage->SetName("TrackingToolbox Default Storage");
     m_toolStorage->RegisterAsMicroservice("no tracking device");
 
     //set home directory as default path for logfile
     m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(QDir::homePath()) + QDir::separator() + "logfile.csv");
 
+    //tracking device may be changed already by the persistence of the
+    //QmitkTrackingDeciveConfigurationWidget
+    this->OnTrackingDeviceChanged();
+
+    this->LoadUISettings();
 
+    //add tracking volume node only to data storage if the volume should be shown
+    if ( m_Controls->m_ShowTrackingVolume->isChecked() )
+    {
+      this->GetDataStorage()->Add(m_TrackingVolumeNode);
+    }
   }
 }
 
 
 void QmitkMITKIGTTrackingToolboxView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
   m_MultiWidget = &stdMultiWidget;
 }
 
 
 void QmitkMITKIGTTrackingToolboxView::StdMultiWidgetNotAvailable()
 {
   m_MultiWidget = NULL;
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnLoadTools()
 {
   //read in filename
   QString filename = QFileDialog::getOpenFileName(NULL,tr("Open Tool Storage"), "/", tr("Tool Storage Files (*.IGTToolStorage)"));
   if (filename.isNull()) return;
 
   //read tool storage from disk
   std::string errorMessage = "";
   mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(GetDataStorage());
   // try-catch block for exceptions
   try
   {
     this->ReplaceCurrentToolStorage(myDeserializer->Deserialize(filename.toStdString()),filename.toStdString());
   }
   catch(mitk::IGTException)
   {
    std::string errormessage = "Error during deserializing. Problems with file,please check the file?";
    QMessageBox::warning(NULL, "IGTPlayer: Error", errormessage.c_str());
    return;
   }
 
   if(m_toolStorage->isEmpty())
     {
     errorMessage = myDeserializer->GetErrorMessage();
     MessageBox(errorMessage);
     return;
     }
 
   //update label
   Poco::Path myPath = Poco::Path(filename.toStdString()); //use this to seperate filename from path
   QString toolLabel = QString("Loaded Tools: ") + QString::number(m_toolStorage->GetToolCount()) + " Tools from " + myPath.getFileName().c_str();
   m_Controls->m_toolLabel->setText(toolLabel);
 
   //update tool preview
   m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
   m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
+
+  //save filename for persistent storage
+  m_ToolStorageFilename = filename;
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnResetTools()
 {
   this->ReplaceCurrentToolStorage(mitk::NavigationToolStorage::New(GetDataStorage()),"TrackingToolbox Default Storage");
   m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
   QString toolLabel = QString("Loaded Tools: <none>");
   m_Controls->m_toolLabel->setText(toolLabel);
+
+  m_ToolStorageFilename = "";
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnConnect()
   {
   MITK_INFO << "Connect Clicked";
   //check if everything is ready to start tracking
   if (this->m_toolStorage.IsNull())
   {
     MessageBox("Error: No Tools Loaded Yet!");
     return;
   }
   else if (this->m_toolStorage->GetToolCount() == 0)
   {
     MessageBox("Error: No Way To Track Without Tools!");
     return;
   }
 
   //parse tracking device data
   mitk::TrackingDeviceData data = mitk::DeviceDataUnspecified;
   QString qstr =  m_Controls->m_VolumeSelectionBox->currentText();
   if ( (! qstr.isNull()) || (! qstr.isEmpty()) ) {
     std::string str = qstr.toStdString();
     data = mitk::GetDeviceDataByName(str); //Data will be set later, after device generation
   }
 
   //initialize worker thread
   m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eConnectDevice);
   m_Worker->SetTrackingDevice(this->m_Controls->m_configurationWidget->GetTrackingDevice());
   m_Worker->SetInverseMode(m_Controls->m_InverseMode->isChecked());
   m_Worker->SetNavigationToolStorage(this->m_toolStorage);
   m_Worker->SetTrackingDeviceData(data);
 
   //start worker thread
   m_WorkerThread->start();
 
   //disable buttons
   this->m_Controls->m_MainWidget->setEnabled(false);
   }
 
 void QmitkMITKIGTTrackingToolboxView::OnConnectFinished(bool success, QString errorMessage)
   {
   m_WorkerThread->quit();
 
   //enable buttons
   this->m_Controls->m_MainWidget->setEnabled(true);
 
   if (!success)
     {
     MITK_WARN << errorMessage.toStdString();
     MessageBox(errorMessage.toStdString());
     return;
     }
 
   //get data from worker thread
   m_TrackingDeviceSource = m_Worker->GetTrackingDeviceSource();
   m_TrackingDeviceData = m_Worker->GetTrackingDeviceData();
   m_ToolVisualizationFilter = m_Worker->GetToolVisualizationFilter();
 
   //enable/disable Buttons
   m_Controls->m_Disconnect->setEnabled(true);
   m_Controls->m_StartTracking->setEnabled(true);
   m_Controls->m_StopTracking->setEnabled(false);
   m_Controls->m_Connect->setEnabled(false);
   DisableOptionsButtons();
   DisableTrackingConfigurationButtons();
   m_Controls->m_configurationWidget->ConfigurationFinished();
 
   m_Controls->m_TrackingControlLabel->setText("Status: connected");
   }
 
 void QmitkMITKIGTTrackingToolboxView::OnDisconnect()
   {
   m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eDisconnectDevice);
   m_WorkerThread->start();
   m_Controls->m_MainWidget->setEnabled(false);
   }
 
 void QmitkMITKIGTTrackingToolboxView::OnDisconnectFinished(bool success, QString errorMessage)
   {
   m_WorkerThread->quit();
   m_Controls->m_MainWidget->setEnabled(true);
 
   if (!success)
     {
     MITK_WARN << errorMessage.toStdString();
     MessageBox(errorMessage.toStdString());
     return;
     }
 
   //enable/disable Buttons
   m_Controls->m_Disconnect->setEnabled(false);
   m_Controls->m_StartTracking->setEnabled(false);
   m_Controls->m_StopTracking->setEnabled(false);
   m_Controls->m_Connect->setEnabled(true);
   EnableOptionsButtons();
   EnableTrackingConfigurationButtons();
   m_Controls->m_configurationWidget->Reset();
   m_Controls->m_TrackingControlLabel->setText("Status: disconnected");
   }
 
 void QmitkMITKIGTTrackingToolboxView::OnStartTracking()
 {
   m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eStartTracking);
   m_WorkerThread->start();
   this->m_Controls->m_MainWidget->setEnabled(false);
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnStartTrackingFinished(bool success, QString errorMessage)
 {
   m_WorkerThread->quit();
   this->m_Controls->m_MainWidget->setEnabled(true);
 
   if(!success)
   {
     MessageBox(errorMessage.toStdString());
     MITK_WARN << errorMessage.toStdString();
     return;
   }
 
   m_TrackingTimer->start(1000/(m_Controls->m_UpdateRate->value()));
   m_Controls->m_TrackingControlLabel->setText("Status: tracking");
 
   //connect the tool visualization widget
   for(int i=0; i<m_TrackingDeviceSource->GetNumberOfOutputs(); i++)
   {
     m_Controls->m_TrackingToolsStatusWidget->AddNavigationData(m_TrackingDeviceSource->GetOutput(i));
   }
   m_Controls->m_TrackingToolsStatusWidget->ShowStatusLabels();
   if (m_Controls->m_ShowToolQuaternions->isChecked()) {m_Controls->m_TrackingToolsStatusWidget->SetShowQuaternions(true);}
   else {m_Controls->m_TrackingToolsStatusWidget->SetShowQuaternions(false);}
 
   //show tracking volume
   this->OnTrackingVolumeChanged(m_Controls->m_VolumeSelectionBox->currentText());
 
   //enable/disable Buttons
   m_Controls->m_Disconnect->setEnabled(true);
   m_Controls->m_StartTracking->setEnabled(false);
   m_Controls->m_StopTracking->setEnabled(true);
   m_Controls->m_Connect->setEnabled(false);
 
   m_tracking = true;
 
   this->GlobalReinit();
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnStopTracking()
 {
   if (!m_tracking) return;
   m_TrackingTimer->stop();
 
   m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eStopTracking);
   m_WorkerThread->start();
   m_Controls->m_MainWidget->setEnabled(false);
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnStopTrackingFinished(bool success, QString errorMessage)
   {
   m_WorkerThread->quit();
   m_Controls->m_MainWidget->setEnabled(true);
   if(!success)
     {
       MessageBox(errorMessage.toStdString());
       MITK_WARN << errorMessage.toStdString();
       return;
     }
 
   m_Controls->m_TrackingControlLabel->setText("Status: connected");
   if (m_logging) StopLogging();
   m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
   m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
   m_tracking = false;
 
   //enable/disable Buttons
   m_Controls->m_Disconnect->setEnabled(true);
   m_Controls->m_StartTracking->setEnabled(true);
   m_Controls->m_StopTracking->setEnabled(false);
   m_Controls->m_Connect->setEnabled(false);
 
   this->GlobalReinit();
 }
 
 
 void QmitkMITKIGTTrackingToolboxView::OnTrackingDeviceChanged()
 {
   mitk::TrackingDeviceType Type;
 
   if (m_Controls->m_configurationWidget->GetTrackingDevice().IsNotNull())
     {
       Type = m_Controls->m_configurationWidget->GetTrackingDevice()->GetType();
       //enable controls because device is valid
       m_Controls->m_TrackingToolsGoupBox->setEnabled(true);
       m_Controls->m_TrackingControlsGroupBox->setEnabled(true);
     }
   else
     {
       Type = mitk::TrackingSystemNotSpecified;
       MessageBox("Error: This tracking device is not included in this project. Please make sure that the device is installed and activated in your MITK build.");
       m_Controls->m_TrackingToolsGoupBox->setEnabled(false);
       m_Controls->m_TrackingControlsGroupBox->setEnabled(false);
       return;
     }
 
 
 
   // Code to enable/disable device specific buttons
   if (Type == mitk::NDIAurora) //Aurora
   {
     m_Controls->m_AutoDetectTools->setVisible(true);
     m_Controls->m_AddSingleTool->setEnabled(false);
   }
   else //Polaris or Microntracker
   {
     m_Controls->m_AutoDetectTools->setVisible(false);
     m_Controls->m_AddSingleTool->setEnabled(true);
   }
 
   // Code to select appropriate tracking volume for current type
   std::vector<mitk::TrackingDeviceData> Compatibles = mitk::GetDeviceDataForLine(Type);
   m_Controls->m_VolumeSelectionBox->clear();
   for(int i = 0; i < Compatibles.size(); i++)
   {
     m_Controls->m_VolumeSelectionBox->addItem(Compatibles[i].Model.c_str());
   }
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnTrackingVolumeChanged(QString qstr)
 {
   if (qstr.isNull()) return;
   if (qstr.isEmpty()) return;
   if (m_Controls->m_ShowTrackingVolume->isChecked())
   {
     mitk::TrackingVolumeGenerator::Pointer volumeGenerator = mitk::TrackingVolumeGenerator::New();
 
     std::string str = qstr.toStdString();
 
     mitk::TrackingDeviceData data = mitk::GetDeviceDataByName(str);
     m_TrackingDeviceData = data;
 
     volumeGenerator->SetTrackingDeviceData(data);
     volumeGenerator->Update();
 
     mitk::Surface::Pointer volumeSurface = volumeGenerator->GetOutput();
 
     m_TrackingVolumeNode->SetData(volumeSurface);
 
     GlobalReinit();
   }
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnShowTrackingVolumeChanged()
 {
   if (m_Controls->m_ShowTrackingVolume->isChecked())
     {
     OnTrackingVolumeChanged(m_Controls->m_VolumeSelectionBox->currentText());
     GetDataStorage()->Add(m_TrackingVolumeNode);
     }
   else
     {
     GetDataStorage()->Remove(m_TrackingVolumeNode);
     GlobalReinit();
     }
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnAutoDetectTools()
 {
 if (m_Controls->m_configurationWidget->GetTrackingDevice()->GetType() == mitk::NDIAurora)
     {
     DisableTrackingConfigurationButtons();
     m_Worker->SetWorkerMethod(QmitkMITKIGTTrackingToolboxViewWorker::eAutoDetectTools);
     m_Worker->SetTrackingDevice(m_Controls->m_configurationWidget->GetTrackingDevice().GetPointer());
     m_Worker->SetDataStorage(this->GetDataStorage());
     m_WorkerThread->start();
     //disable controls until worker thread is finished
     this->m_Controls->m_MainWidget->setEnabled(false);
     }
 }
 
 void QmitkMITKIGTTrackingToolboxView::OnAutoDetectToolsFinished(bool success, QString errorMessage)
 {
     m_WorkerThread->quit();
 
     //enable controls again
     this->m_Controls->m_MainWidget->setEnabled(true);
 
     if(!success)
     {
       MITK_WARN << errorMessage.toStdString();
       MessageBox(errorMessage.toStdString());
       EnableTrackingConfigurationButtons();
       return;
     }
 
     mitk::NavigationToolStorage::Pointer autoDetectedStorage = m_Worker->GetNavigationToolStorage();
 
     //save detected tools
     this->ReplaceCurrentToolStorage(autoDetectedStorage,"Autodetected NDI Aurora Storage");
     //update label
     QString toolLabel = QString("Loaded Tools: ") + QString::number(m_toolStorage->GetToolCount()) + " Tools (Auto Detected)";
     m_Controls->m_toolLabel->setText(toolLabel);
     //update tool preview
     m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
     m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
 
 
     EnableTrackingConfigurationButtons();
 
     if (m_toolStorage->GetToolCount()>0)
       {
       //ask the user if he wants to save the detected tools
       QMessageBox msgBox;
       switch(m_toolStorage->GetToolCount())
         {
         case 1:
           msgBox.setText("Found one tool!");
           break;
         default:
           msgBox.setText("Found " + QString::number(m_toolStorage->GetToolCount()) + " tools!");
         }
       msgBox.setInformativeText("Do you want to save this tools as tool storage, so you can load them again?");
       msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
       msgBox.setDefaultButton(QMessageBox::No);
       int ret = msgBox.exec();
 
       if (ret == 16384) //yes
         {
         //ask the user for a filename
         QString fileName = QFileDialog::getSaveFileName(NULL, tr("Save File"),"/",tr("*.IGTToolStorage"));
         //check for empty filename
         if(fileName == "") {return;}
         mitk::NavigationToolStorageSerializer::Pointer mySerializer = mitk::NavigationToolStorageSerializer::New();
 
         //when Serialize method is used exceptions are thrown, need to be adapted
         //try-catch block for exception handling in Serializer
         try
         {
         mySerializer->Serialize(fileName.toStdString(),m_toolStorage);
         }
         catch(mitk::IGTException)
         {
         std::string errormessage = "Error during serialization. Please check the Zip file.";
         QMessageBox::warning(NULL, "IGTPlayer: Error", errormessage.c_str());}
         return;
         }
         else if (ret == 65536) //no
         {
         return;
         }
       }
 
 }
 
 void QmitkMITKIGTTrackingToolboxView::MessageBox(std::string s)
   {
   QMessageBox msgBox;
   msgBox.setText(s.c_str());
   msgBox.exec();
   }
 
 void QmitkMITKIGTTrackingToolboxView::UpdateTrackingTimer()
   {
   m_ToolVisualizationFilter->Update();
   MITK_DEBUG << "Number of outputs ToolVisualizationFilter: " << m_ToolVisualizationFilter->GetNumberOfIndexedOutputs();
   MITK_DEBUG << "Number of inputs ToolVisualizationFilter: " << m_ToolVisualizationFilter->GetNumberOfIndexedInputs();
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   if (m_logging)
     {
     this->m_loggingFilter->Update();
     m_loggedFrames = this->m_loggingFilter->GetRecordCounter();
     this->m_Controls->m_LoggedFramesLabel->setText("Logged Frames: "+QString::number(m_loggedFrames));
     //check if logging stopped automatically
     if((m_loggedFrames>1)&&(!m_loggingFilter->GetRecording())){StopLogging();}
     }
   m_Controls->m_TrackingToolsStatusWidget->Refresh();
   }
 
 void QmitkMITKIGTTrackingToolboxView::OnChooseFileClicked()
   {
   QDir currentPath = QFileInfo(m_Controls->m_LoggingFileName->text()).dir();
 
   // if no path was selected (QDir would select current working dir then) or the
   // selected path does not exist -> use home directory
   if ( currentPath == QDir() || ! currentPath.exists() )
   {
     currentPath = QDir(QDir::homePath());
   }
 
   QString filename = QFileDialog::getSaveFileName(NULL,tr("Choose Logging File"), currentPath.absolutePath(), "*.*");
   if (filename == "") return;
   this->m_Controls->m_LoggingFileName->setText(filename);
   this->OnToggleFileExtension();
   }
 // bug-16470: toggle file extension after clicking on radio button
 void QmitkMITKIGTTrackingToolboxView::OnToggleFileExtension()
 {
 
   QString currentInputText = this->m_Controls->m_LoggingFileName->text();
   QString currentFile = QFileInfo(currentInputText).baseName();
   QDir currentPath = QFileInfo(currentInputText).dir();
   if(currentFile.isEmpty())
   {
     currentFile = "logfile";
   }
   // Setting currentPath to default home path when currentPath is empty or it does not exist
   if(currentPath == QDir() || !currentPath.exists())
   {
     currentPath = QDir::homePath();
   }
   // check if csv radio button is clicked
   if(this->m_Controls->m_csvFormat->isChecked())
   {
     // you needn't add a seperator to the input text when currentpath is the rootpath
     if(currentPath.isRoot())
     {
       this->m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(currentPath.absolutePath()) + currentFile + ".csv");
     }
 
     else
     {
       this->m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(currentPath.absolutePath()) + QDir::separator() + currentFile + ".csv");
     }
   }
   // check if xml radio button is clicked
   else if(this->m_Controls->m_xmlFormat->isChecked())
   {
     // you needn't add a seperator to the input text when currentpath is the rootpath
     if(currentPath.isRoot())
     {
       this->m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(currentPath.absolutePath()) + currentFile + ".xml");
     }
     else
     {
       this->m_Controls->m_LoggingFileName->setText(QDir::toNativeSeparators(currentPath.absolutePath()) + QDir::separator() + currentFile + ".xml");
     }
 
   }
 
 
 
 }
 
 void QmitkMITKIGTTrackingToolboxView::StartLogging()
   {
 
   if (m_ToolVisualizationFilter.IsNull())
   {
     MessageBox("Cannot activate logging without a connected device. Configure and connect a tracking device first.");
     return;
   }
 
   if (!m_logging)
     {
     //initialize logging filter
     m_loggingFilter = mitk::NavigationDataRecorder::New();
     m_loggingFilter->SetRecordingMode(mitk::NavigationDataRecorder::NormalFile);
     if (m_Controls->m_xmlFormat->isChecked()) m_loggingFilter->SetOutputFormat(mitk::NavigationDataRecorder::xml);
     else if (m_Controls->m_csvFormat->isChecked()) m_loggingFilter->SetOutputFormat(mitk::NavigationDataRecorder::csv);
     std::string filename = m_Controls->m_LoggingFileName->text().toStdString().c_str();
     // this part has been changed in order to prevent crash of the  program
     if(!filename.empty())
     m_loggingFilter->SetFileName(filename);
     else if(filename.empty()){
      std::string errormessage = "File name has not been set, please set the file name";
      mitkThrowException(mitk::IGTIOException)<<errormessage;
      QMessageBox::warning(NULL, "IGTPlayer: Error", errormessage.c_str());
      m_loggingFilter->SetFileName(filename);
     }
 
     if (m_Controls->m_LoggingLimit->isChecked()){m_loggingFilter->SetRecordCountLimit(m_Controls->m_LoggedFramesLimit->value());}
 
     //connect filter
     for(int i=0; i<m_ToolVisualizationFilter->GetNumberOfOutputs(); i++){m_loggingFilter->AddNavigationData(m_ToolVisualizationFilter->GetOutput(i));}
 
     //start filter with try-catch block for exceptions
     try
     {
     m_loggingFilter->StartRecording();
     }
     catch(mitk::IGTException)
     {
     std::string errormessage = "Error during start recording. Recorder already started recording?";
     QMessageBox::warning(NULL, "IGTPlayer: Error", errormessage.c_str());
     m_loggingFilter->StopRecording();
     return;
     }
 
     //update labels / logging variables
     this->m_Controls->m_LoggingLabel->setText("Logging ON");
     this->m_Controls->m_LoggedFramesLabel->setText("Logged Frames: 0");
     m_loggedFrames = 0;
     m_logging = true;
     DisableLoggingButtons();
   }
   }
 
 
 
 void QmitkMITKIGTTrackingToolboxView::StopLogging()
   {
   if (m_logging)
     {
     //update label
     this->m_Controls->m_LoggingLabel->setText("Logging OFF");
 
     m_loggingFilter->StopRecording();
     m_logging = false;
     EnableLoggingButtons();
     }
   }
 
 void QmitkMITKIGTTrackingToolboxView::OnAddSingleTool()
   {
   QString Identifier = "Tool#";
   if (m_toolStorage.IsNotNull()) Identifier += QString::number(m_toolStorage->GetToolCount());
   else Identifier += "0";
   m_Controls->m_NavigationToolCreationWidget->Initialize(GetDataStorage(),Identifier.toStdString());
   m_Controls->m_NavigationToolCreationWidget->SetTrackingDeviceType(m_Controls->m_configurationWidget->GetTrackingDevice()->GetType(),false);
   m_Controls->m_TrackingToolsWidget->setCurrentIndex(1);
 
   //disable tracking volume during tool editing
   lastTrackingVolumeState = m_Controls->m_ShowTrackingVolume->isChecked();
   if (lastTrackingVolumeState) m_Controls->m_ShowTrackingVolume->click();
   GlobalReinit();
 
   }
 
 void QmitkMITKIGTTrackingToolboxView::OnAddSingleToolFinished()
   {
   m_Controls->m_TrackingToolsWidget->setCurrentIndex(0);
   if (this->m_toolStorage.IsNull())
     {
     //this shouldn't happen!
     MITK_WARN << "No ToolStorage available, cannot add tool, aborting!";
     return;
     }
   m_toolStorage->AddTool(m_Controls->m_NavigationToolCreationWidget->GetCreatedTool());
   m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
   QString toolLabel = QString("Loaded Tools: <manually added>");
 
   //enable tracking volume again
   if (lastTrackingVolumeState) m_Controls->m_ShowTrackingVolume->click();
   GlobalReinit();
   }
 
 void QmitkMITKIGTTrackingToolboxView::OnAddSingleToolCanceled()
   {
   m_Controls->m_TrackingToolsWidget->setCurrentIndex(0);
 
   //enable tracking volume again
   if (lastTrackingVolumeState) m_Controls->m_ShowTrackingVolume->click();
   GlobalReinit();
   }
 
 
 void QmitkMITKIGTTrackingToolboxView::GlobalReinit()
 {
 // get all nodes that have not set "includeInBoundingBox" to false
   mitk::NodePredicateNot::Pointer pred = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox", mitk::BoolProperty::New(false)));
 
   mitk::DataStorage::SetOfObjects::ConstPointer rs = this->GetDataStorage()->GetSubset(pred);
   // calculate bounding geometry of these nodes
   mitk::TimeGeometry::Pointer bounds = this->GetDataStorage()->ComputeBoundingGeometry3D(rs, "visible");
 
   // initialize the views to the bounding geometry
   mitk::RenderingManager::GetInstance()->InitializeViews(bounds);
 }
 
 void QmitkMITKIGTTrackingToolboxView::DisableLoggingButtons()
 {
     m_Controls->m_StartLogging->setEnabled(false);
     m_Controls->m_LoggingFileName->setEnabled(false);
     m_Controls->m_ChooseFile->setEnabled(false);
     m_Controls->m_LoggingLimit->setEnabled(false);
     m_Controls->m_LoggedFramesLimit->setEnabled(false);
     m_Controls->m_csvFormat->setEnabled(false);
     m_Controls->m_xmlFormat->setEnabled(false);
     m_Controls->m_StopLogging->setEnabled(true);
 }
 
 void QmitkMITKIGTTrackingToolboxView::EnableLoggingButtons()
 {
     m_Controls->m_StartLogging->setEnabled(true);
     m_Controls->m_LoggingFileName->setEnabled(true);
     m_Controls->m_ChooseFile->setEnabled(true);
     m_Controls->m_LoggingLimit->setEnabled(true);
     m_Controls->m_LoggedFramesLimit->setEnabled(true);
     m_Controls->m_csvFormat->setEnabled(true);
     m_Controls->m_xmlFormat->setEnabled(true);
     m_Controls->m_StopLogging->setEnabled(false);
 }
 
 void QmitkMITKIGTTrackingToolboxView::DisableOptionsButtons()
 {
     m_Controls->m_ShowTrackingVolume->setEnabled(false);
     m_Controls->m_UpdateRate->setEnabled(false);
     m_Controls->m_ShowToolQuaternions->setEnabled(false);
     m_Controls->m_OptionsUpdateRateLabel->setEnabled(false);
 }
 
 void QmitkMITKIGTTrackingToolboxView::EnableOptionsButtons()
 {
     m_Controls->m_ShowTrackingVolume->setEnabled(true);
     m_Controls->m_UpdateRate->setEnabled(true);
     m_Controls->m_ShowToolQuaternions->setEnabled(true);
     m_Controls->m_OptionsUpdateRateLabel->setEnabled(true);
 }
 
 void QmitkMITKIGTTrackingToolboxView::EnableTrackingControls()
 {
     m_Controls->m_TrackingControlsGroupBox->setEnabled(true);
 }
 
 void QmitkMITKIGTTrackingToolboxView::DisableTrackingControls()
 {
     m_Controls->m_TrackingControlsGroupBox->setEnabled(false);
 }
 
 void QmitkMITKIGTTrackingToolboxView::EnableTrackingConfigurationButtons()
 {
     m_Controls->m_AutoDetectTools->setEnabled(true);
     if (m_Controls->m_configurationWidget->GetTrackingDevice()->GetType() != mitk::NDIAurora) m_Controls->m_AddSingleTool->setEnabled(true);
     m_Controls->m_LoadTools->setEnabled(true);
     m_Controls->m_ResetTools->setEnabled(true);
 }
 
 void QmitkMITKIGTTrackingToolboxView::DisableTrackingConfigurationButtons()
 {
     m_Controls->m_AutoDetectTools->setEnabled(false);
     if (m_Controls->m_configurationWidget->GetTrackingDevice()->GetType() != mitk::NDIAurora) m_Controls->m_AddSingleTool->setEnabled(false);
     m_Controls->m_LoadTools->setEnabled(false);
     m_Controls->m_ResetTools->setEnabled(false);
 }
 
 void QmitkMITKIGTTrackingToolboxView::ReplaceCurrentToolStorage(mitk::NavigationToolStorage::Pointer newStorage, std::string newStorageName)
 {
     //first: get rid of the old one
     m_toolStorage->UnLockStorage(); //only to be sure...
     m_toolStorage->UnRegisterMicroservice();
     m_toolStorage = NULL;
 
-    //now: replace by the new one
-    m_toolStorage = newStorage;
-    m_toolStorage->SetName(newStorageName);
-    m_toolStorage->RegisterAsMicroservice("no tracking device");
+  //now: replace by the new one
+  m_toolStorage = newStorage;
+  m_toolStorage->SetName(newStorageName);
+  m_toolStorage->RegisterAsMicroservice("no tracking device");
+}
+
+void QmitkMITKIGTTrackingToolboxView::StoreUISettings()
+{
+  // persistence service does not directly work in plugins for now
+  // -> using QSettings
+  QSettings settings;
+
+  settings.beginGroup(QString::fromStdString(VIEW_ID));
+
+  // set the values of some widgets and attrbutes to the QSettings
+  settings.setValue("ShowTrackingVolume", QVariant(m_Controls->m_ShowTrackingVolume->isChecked()));
+  settings.setValue("toolStorageFilename", QVariant(m_ToolStorageFilename));
+  settings.setValue("VolumeSelectionBox", QVariant(m_Controls->m_VolumeSelectionBox->currentIndex()));
+
+  settings.endGroup();
+}
+
+void QmitkMITKIGTTrackingToolboxView::LoadUISettings()
+{
+  // persistence service does not directly work in plugins for now
+  // -> using QSettings
+  QSettings settings;
+
+  settings.beginGroup(QString::fromStdString(VIEW_ID));
+
+  // set some widgets and attributes by the values from the QSettings
+  m_Controls->m_ShowTrackingVolume->setChecked(settings.value("ShowTrackingVolume", true).toBool());
+  m_Controls->m_VolumeSelectionBox->setCurrentIndex(settings.value("VolumeSelectionBox", 0).toInt());
+  m_ToolStorageFilename = settings.value("toolStorageFilename", QVariant("")).toString();
+
+  settings.endGroup();
+
+
+  // try to deserialize the tool storage from the given tool storage file name
+  if ( ! m_ToolStorageFilename.isEmpty() )
+  {
+    // try-catch block for exceptions
+    try
+    {
+      mitk::NavigationToolStorageDeserializer::Pointer myDeserializer = mitk::NavigationToolStorageDeserializer::New(GetDataStorage());
+      m_toolStorage->UnRegisterMicroservice();
+      m_toolStorage = myDeserializer->Deserialize(m_ToolStorageFilename.toStdString());
+      m_toolStorage->RegisterAsMicroservice("no tracking device");
+
+      //update label
+      Poco::Path myPath = Poco::Path(m_ToolStorageFilename.toStdString()); //use this to seperate filename from path
+      QString toolLabel = QString("Loaded Tools: ") + QString::number(m_toolStorage->GetToolCount()) + " Tools from " + myPath.getFileName().c_str();
+      m_Controls->m_toolLabel->setText(toolLabel);
+
+      //update tool preview
+      m_Controls->m_TrackingToolsStatusWidget->RemoveStatusLabels();
+      m_Controls->m_TrackingToolsStatusWidget->PreShowTools(m_toolStorage);
+    }
+    catch(mitk::IGTException)
+    {
+      MITK_WARN("QmitkMITKIGTTrackingToolBoxView") << "Error during deserializing. Problems with file,please check the file?";
+    }
+  }
 }
 
 void QmitkMITKIGTTrackingToolboxViewWorker::SetWorkerMethod(WorkerMethod w)
 {
   m_WorkerMethod = w;
 }
 
 void QmitkMITKIGTTrackingToolboxViewWorker::SetTrackingDevice(mitk::TrackingDevice::Pointer t)
 {
   m_TrackingDevice = t;
 }
 
 void QmitkMITKIGTTrackingToolboxViewWorker::SetDataStorage(mitk::DataStorage::Pointer d)
 {
   m_DataStorage = d;
 }
 
 void QmitkMITKIGTTrackingToolboxViewWorker::SetInverseMode(bool mode)
 {
   m_InverseMode = mode;
 }
 
 void QmitkMITKIGTTrackingToolboxViewWorker::SetTrackingDeviceData(mitk::TrackingDeviceData d)
 {
   m_TrackingDeviceData = d;
 }
 
 void QmitkMITKIGTTrackingToolboxViewWorker::SetNavigationToolStorage(mitk::NavigationToolStorage::Pointer n)
 {
   m_NavigationToolStorage = n;
 }
 
 void QmitkMITKIGTTrackingToolboxViewWorker::ThreadFunc()
 {
   switch(m_WorkerMethod)
   {
   case eAutoDetectTools:
     this->AutoDetectTools();
     break;
   case eConnectDevice:
     this->ConnectDevice();
     break;
   case eStartTracking:
     this->StartTracking();
     break;
   case eStopTracking:
     this->StopTracking();
     break;
   case eDisconnectDevice:
     this->DisconnectDevice();
     break;
   default:
     MITK_WARN << "Undefined worker method was set ... something went wrong!";
     break;
   }
 }
 
 void QmitkMITKIGTTrackingToolboxViewWorker::AutoDetectTools()
  {
 mitk::ProgressBar::GetInstance()->AddStepsToDo(4);
  mitk::NavigationToolStorage::Pointer autoDetectedStorage = mitk::NavigationToolStorage::New(m_DataStorage);
  mitk::NDITrackingDevice::Pointer currentDevice = dynamic_cast<mitk::NDITrackingDevice*>(m_TrackingDevice.GetPointer());
 try
       {
       currentDevice->OpenConnection();
       mitk::ProgressBar::GetInstance()->Progress();
       currentDevice->StartTracking();
       }
     catch(mitk::Exception& e)
       {
       QString message = QString("Warning, can not auto-detect tools! (") + QString(e.GetDescription()) + QString(")");
       //MessageBox(message.toStdString()); //TODO: give message to the user here!
 
       MITK_WARN << message.toStdString();
       mitk::ProgressBar::GetInstance()->Progress(4);
       emit AutoDetectToolsFinished(false,message.toStdString().c_str());
       return;
       }
 
   for (int i=0; i<currentDevice->GetToolCount(); i++)
     {
     //create a navigation tool with sphere as surface
     std::stringstream toolname;
     toolname << "AutoDetectedTool" << i;
     mitk::NavigationTool::Pointer newTool = mitk::NavigationTool::New();
     newTool->SetSerialNumber(dynamic_cast<mitk::NDIPassiveTool*>(currentDevice->GetTool(i))->GetSerialNumber());
     newTool->SetIdentifier(toolname.str());
     newTool->SetTrackingDeviceType(mitk::NDIAurora);
     mitk::DataNode::Pointer newNode = mitk::DataNode::New();
     mitk::Surface::Pointer mySphere = mitk::Surface::New();
     vtkSphereSource *vtkData = vtkSphereSource::New();
     vtkData->SetRadius(3.0f);
     vtkData->SetCenter(0.0, 0.0, 0.0);
     vtkData->Update();
     mySphere->SetVtkPolyData(vtkData->GetOutput());
     vtkData->Delete();
     newNode->SetData(mySphere);
     newNode->SetName(toolname.str());
     newTool->SetDataNode(newNode);
     autoDetectedStorage->AddTool(newTool);
     }
 
   m_NavigationToolStorage = autoDetectedStorage;
 
   currentDevice->StopTracking();
   mitk::ProgressBar::GetInstance()->Progress();
   currentDevice->CloseConnection();
 
   emit AutoDetectToolsFinished(true,"");
   mitk::ProgressBar::GetInstance()->Progress(4);
  }
 
 void QmitkMITKIGTTrackingToolboxViewWorker::ConnectDevice()
 {
   std::string message = "";
   mitk::ProgressBar::GetInstance()->AddStepsToDo(10);
 
   //build the IGT pipeline
   mitk::TrackingDevice::Pointer trackingDevice = m_TrackingDevice;
   trackingDevice->SetData(m_TrackingDeviceData);
 
   //set device to rotation mode transposed becaus we are working with VNL style quaternions
   if(m_InverseMode)
     {trackingDevice->SetRotationMode(mitk::TrackingDevice::RotationTransposed);}
 
   //Get Tracking Volume Data
   mitk::TrackingDeviceData data = m_TrackingDeviceData;
   mitk::ProgressBar::GetInstance()->Progress();
 
   //Create Navigation Data Source with the factory class
   mitk::TrackingDeviceSourceConfigurator::Pointer myTrackingDeviceSourceFactory = mitk::TrackingDeviceSourceConfigurator::New(m_NavigationToolStorage,trackingDevice);
   m_TrackingDeviceSource = myTrackingDeviceSourceFactory->CreateTrackingDeviceSource(m_ToolVisualizationFilter);
   mitk::ProgressBar::GetInstance()->Progress();
 
   if ( m_TrackingDeviceSource.IsNull() )
   {
     message = std::string("Cannot connect to device: ") + myTrackingDeviceSourceFactory->GetErrorMessage();
     emit ConnectDeviceFinished(false,QString(message.c_str()));
     return;
   }
 
   //set filter to rotation mode transposed becaus we are working with VNL style quaternions
   if(m_InverseMode)
     m_ToolVisualizationFilter->SetRotationMode(mitk::NavigationDataObjectVisualizationFilter::RotationTransposed);
 
   //First check if the created object is valid
   if (m_TrackingDeviceSource.IsNull())
   {
     message = myTrackingDeviceSourceFactory->GetErrorMessage();
     emit ConnectDeviceFinished(false,QString(message.c_str()));
     return;
   }
 
   MITK_INFO << "Number of tools: " << m_TrackingDeviceSource->GetNumberOfOutputs();
   mitk::ProgressBar::GetInstance()->Progress();
 
   //The tools are maybe reordered after initialization, e.g. in case of auto-detected tools of NDI Aurora
   mitk::NavigationToolStorage::Pointer toolsInNewOrder = myTrackingDeviceSourceFactory->GetUpdatedNavigationToolStorage();
   if ((toolsInNewOrder.IsNotNull()) && (toolsInNewOrder->GetToolCount() > 0))
     {
     //so delete the old tools in wrong order and add them in the right order
     //we cannot simply replace the tool storage because the new storage is
     //not correctly initialized with the right data storage
     m_NavigationToolStorage->DeleteAllTools();
     for (int i=0; i < toolsInNewOrder->GetToolCount(); i++) {m_NavigationToolStorage->AddTool(toolsInNewOrder->GetTool(i));}
     }
   mitk::ProgressBar::GetInstance()->Progress();
 
   //connect to device
   try
     {
     m_TrackingDeviceSource->Connect();
     mitk::ProgressBar::GetInstance()->Progress();
     //Microservice registration:
     m_TrackingDeviceSource->RegisterAsMicroservice();
     m_NavigationToolStorage->UnRegisterMicroservice();
     m_NavigationToolStorage->RegisterAsMicroservice(m_TrackingDeviceSource->GetMicroserviceID());
     m_NavigationToolStorage->LockStorage();
     }
   catch (...) //todo: change to mitk::IGTException
     {
     message = "Error on connecting the tracking device.";
     emit ConnectDeviceFinished(false,QString(message.c_str()));
     return;
     }
   emit ConnectDeviceFinished(true,QString(message.c_str()));
   mitk::ProgressBar::GetInstance()->Progress(10);
 }
 
 void QmitkMITKIGTTrackingToolboxViewWorker::StartTracking()
 {
   QString errorMessage = "";
   try
     {
     m_TrackingDeviceSource->StartTracking();
     }
   catch (...) //todo: change to mitk::IGTException
     {
     errorMessage += "Error while starting the tracking device!";
     emit StartTrackingFinished(false,errorMessage);
     return;
     }
   emit StartTrackingFinished(true,errorMessage);
 }
 
 void QmitkMITKIGTTrackingToolboxViewWorker::StopTracking()
 {
   try
   {
   m_TrackingDeviceSource->StopTracking();
   }
   catch(mitk::Exception& e)
   {
     emit StopTrackingFinished(false, e.GetDescription());
   }
   emit StopTrackingFinished(true, "");
 
 }
 
 void QmitkMITKIGTTrackingToolboxViewWorker::DisconnectDevice()
 {
   try
     {
     if (m_TrackingDeviceSource->IsTracking()) {m_TrackingDeviceSource->StopTracking();}
     m_TrackingDeviceSource->Disconnect();
     m_TrackingDeviceSource->UnRegisterMicroservice();
     m_NavigationToolStorage->UnLockStorage();
     }
   catch(mitk::Exception& e)
     {
     emit DisconnectDeviceFinished(false, e.GetDescription());
     }
   emit DisconnectDeviceFinished(true, "");
 }
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.h b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.h
index a1ae8f565a..f57e8d6738 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.h
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxView.h
@@ -1,247 +1,258 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef QmitkMITKIGTTrackingToolboxView_h
 #define QmitkMITKIGTTrackingToolboxView_h
 
 #include <berryISelectionListener.h>
 
 #include <QmitkFunctionality.h>
 
 #include "ui_QmitkMITKIGTTrackingToolboxViewControls.h"
 
 //mitk headers
 #include <mitkNavigationToolStorage.h>
 #include <mitkTrackingDeviceSource.h>
 #include <mitkNavigationDataObjectVisualizationFilter.h>
 #include <mitkNavigationDataRecorder.h>
 
 //QT headers
 #include <QTimer>
 
 class QmitkMITKIGTTrackingToolboxViewWorker;
 
 /*!
   \brief QmitkMITKIGTTrackingToolboxView
 
    This is the view of the bundle IGT Tracking Toolbox. The IGT Tracking Toolbox can be used to access tracking devices with MITK-IGT. The Tracking Toolbox can be used to log tracking data in     XML or CSV format for measurement purposes. The Tracking Toolbox further allows for visualization of tools with given surfaces in combination with the NaviagtionToolManager.
 
   \sa QmitkFunctionality
   \ingroup Functionalities
 */
 class QmitkMITKIGTTrackingToolboxView : public QmitkFunctionality
 {
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
   public:
 
     static const std::string VIEW_ID;
 
     QmitkMITKIGTTrackingToolboxView();
     virtual ~QmitkMITKIGTTrackingToolboxView();
 
     virtual void CreateQtPartControl(QWidget *parent);
 
     virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
 
     virtual void StdMultiWidgetNotAvailable();
 
   protected slots:
 
     /** @brief changes name of the filename when switching fileextension by radio button */
     void OnToggleFileExtension();
     /** @brief This slot is called if the user wants to load a new tool file. A new window opens where the user can choose a file. If the chosen file is
                corrupt or not valid the user gets an error message. If the file was loaded successfully the tools are show in the tool status widget. */
     void OnLoadTools();
 
     /** @brief This slot connects to the device. In status "connected" configuration of the device is disabled. */
     void OnConnect();
 
     /** @brief This slot disconnects from the device. */
     void OnDisconnect();
 
     /** @brief This slot tries to start tracking with the current device. If start tracking fails the user gets an error message and tracking stays off.*/
     void OnStartTracking();
 
     /** @brief This slot stops tracking. If tracking is not strated it does nothing.*/
     void OnStopTracking();
 
     /** @brief This slot is called if the user want's to choose a file name for logging. A new windows to navigate through the file system and choose
                a file opens.*/
     void OnChooseFileClicked();
 
     /** @brief This slot starts logging. Logging is only possible if a device is tracking. If not the logging mechanism start when the start tracking
                is called.*/
     void StartLogging();
 
     /** @brief This slot stops logging. If logging is not running it does nothing.*/
     void StopLogging();
 
     /** @brief This slot enables / disables UI elements depending on the tracking device after a device is changed.*/
     void OnTrackingDeviceChanged();
 
     /** @brief This slot selects the Tracking Volume appropriate for a given model */
     void OnTrackingVolumeChanged(QString qstr);
 
     /** @brief Shows or hides the tracking volume according to the checkboxe's state */
     void OnShowTrackingVolumeChanged();
 
     /** @brief This slot auto detects tools of a NDI Aurora tracking device. If tools where found they will be stored internally as a tool storage.
         The user is also asked if he wants to save this tool storage to load it later. Only call it if a Aurora device was configured because other
         devices don't support auto detection.*/
     void OnAutoDetectTools();
 
     /** @brief Slot for tracking timer. The timer updates the IGT pipline and also the logging filter if logging is activated.*/
     void UpdateTrackingTimer();
 
     /** @brief Resets the Tracking Tools: this means all tools are removed. */
     void OnResetTools();
 
     /** @brief Opens a dialog where a new navigation tool can be created. */
     void OnAddSingleTool();
 
     /** @brief This slot is called if the user finishes the creation of a new tool. */
     void OnAddSingleToolFinished();
 
     /** @brief This slot is called if the user cancels the creation of a new tool. */
     void OnAddSingleToolCanceled();
 
   protected slots:
 
    //help slots for enable/disable buttons
    void DisableLoggingButtons();
    void EnableLoggingButtons();
    void DisableOptionsButtons();
    void EnableOptionsButtons();
    void EnableTrackingConfigurationButtons();
    void DisableTrackingConfigurationButtons();
    void EnableTrackingControls();
    void DisableTrackingControls();
 
    //slots for worker thread
    void OnAutoDetectToolsFinished(bool success, QString errorMessage);
    void OnConnectFinished(bool success, QString errorMessage);
    void OnStartTrackingFinished(bool success, QString errorMessage);
    void OnStopTrackingFinished(bool success, QString errorMessage);
    void OnDisconnectFinished(bool success, QString errorMessage);
 
   protected:
 
     Ui::QmitkMITKIGTTrackingToolboxViewControls* m_Controls;
 
     QmitkStdMultiWidget* m_MultiWidget;
 
     bool m_tracking;    ///> bool which is true if tracking is running, false if not
     bool m_logging;     ///> bool which is true if logging is running, false if not
     int m_loggedFrames; ///> stores the current number of logged frames if logging is on
 
     mitk::NavigationToolStorage::Pointer m_toolStorage;  ///>stores the loaded tools
     mitk::DataNode::Pointer m_TrackingVolumeNode;        ///>holds the data node of the tracking volume if volume is visualized
     bool lastTrackingVolumeState;                        ///>temporary holds the state of the tracking volume (activated/not activated) during some methods
 
+    QString m_ToolStorageFilename; ///>stores the filename of the current tool storage
+
     /** @brief Shows a message box with the text given as parameter. */
     void MessageBox(std::string s);
 
     /** @brief reinits the view globally. */
     void GlobalReinit();
 
    //members for the filter pipeline
    mitk::TrackingDeviceSource::Pointer m_TrackingDeviceSource; ///> member for the source of the IGT pipeline
    mitk::TrackingDeviceData m_TrackingDeviceData; ///> stores the tracking device data as long as this is not handled by the tracking device configuration widget
    mitk::NavigationDataObjectVisualizationFilter::Pointer m_ToolVisualizationFilter; ///> holds the tool visualization filter (second filter of the IGT pipeline)
    mitk::NavigationDataRecorder::Pointer m_loggingFilter; ///> holds the logging filter if logging is on (third filter of the IGT pipeline)
 
    /** @brief This timer updates the IGT pipline and also the logging filter if logging is activated.*/
    QTimer* m_TrackingTimer;
 
    /** Replaces the current navigation tool storage which is stored in m_toolStorage.
     *  Basically handles the microservice stuff: unregisteres the old storage, then
     *  replaces the storage and registers the new one.
     */
    void ReplaceCurrentToolStorage(mitk::NavigationToolStorage::Pointer newStorage, std::string newStorageName);
 
+   /**
+    * \brief Stores the properties of some QWidgets (and the tool storage file name) to QSettings.
+    */
+   void StoreUISettings();
+
+   /**
+    * \brief Loads the properties of some QWidgets (and the tool storage file name) from QSettings.
+    */
+   void LoadUISettings();
    //members for worker thread
    QThread* m_WorkerThread;
    QmitkMITKIGTTrackingToolboxViewWorker* m_Worker;
 
 };
 
 
 /**
  * Worker thread class for this view.
  */
 class QmitkMITKIGTTrackingToolboxViewWorker : public QObject
 {
   Q_OBJECT
 
 public:
   enum WorkerMethod{
     eAutoDetectTools = 0,
     eConnectDevice = 1,
     eStartTracking = 2,
     eStopTracking = 3,
     eDisconnectDevice = 4
   };
 
   void SetWorkerMethod(WorkerMethod w);
   void SetTrackingDevice(mitk::TrackingDevice::Pointer t);
   void SetDataStorage(mitk::DataStorage::Pointer d);
   void SetInverseMode(bool mode);
   void SetTrackingDeviceData(mitk::TrackingDeviceData d);
   void SetNavigationToolStorage(mitk::NavigationToolStorage::Pointer n);
 
   itkGetMacro(NavigationToolStorage,mitk::NavigationToolStorage::Pointer);
 
   itkGetMacro(TrackingDeviceSource,mitk::TrackingDeviceSource::Pointer);
   itkGetMacro(TrackingDeviceData,mitk::TrackingDeviceData);
   itkGetMacro(ToolVisualizationFilter,mitk::NavigationDataObjectVisualizationFilter::Pointer);
 
   public slots:
     void ThreadFunc();
 
   signals:
     void AutoDetectToolsFinished(bool success, QString errorMessage);
     void ConnectDeviceFinished(bool success, QString errorMessage);
     void StartTrackingFinished(bool success, QString errorMessage);
     void StopTrackingFinished(bool success, QString errorMessage);
     void DisconnectDeviceFinished(bool success, QString errorMessage);
 
 
   protected:
 
     mitk::TrackingDevice::Pointer m_TrackingDevice;
     WorkerMethod m_WorkerMethod;
     mitk::DataStorage::Pointer m_DataStorage;
     mitk::NavigationToolStorage::Pointer m_NavigationToolStorage;
 
     //members for the filter pipeline which is created in the worker thread during ConnectDevice()
     mitk::TrackingDeviceSource::Pointer m_TrackingDeviceSource; ///> member for the source of the IGT pipeline
     mitk::TrackingDeviceData m_TrackingDeviceData; ///> stores the tracking device data as long as this is not handled by the tracking device configuration widget
     mitk::NavigationDataObjectVisualizationFilter::Pointer m_ToolVisualizationFilter; ///> holds the tool visualization filter (second filter of the IGT pipeline)
     bool m_InverseMode;
 
     void AutoDetectTools();
     void ConnectDevice();
     void StartTracking();
     void StopTracking();
     void DisconnectDevice();
 };
 
 
 
 #endif // _QMITKMITKIGTTRACKINGTOOLBOXVIEW_H_INCLUDED
diff --git a/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupport.cpp b/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupport.cpp
index bc9424cc54..28e25349d7 100644
--- a/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupport.cpp
+++ b/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupport.cpp
@@ -1,343 +1,355 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 //Mitk
 #include <mitkDataNode.h>
 #include <mitkNodePredicateNot.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkIRenderingManager.h>
 
 // Qmitk
 #include "UltrasoundSupport.h"
 #include <QTimer>
 
 // Qt
 #include <QMessageBox>
 
 // Ultrasound
 #include "mitkUSDevice.h"
 #include "QmitkUSAbstractCustomWidget.h"
 
 #include <usModuleContext.h>
 #include <usGetModuleContext.h>
 #include "usServiceReference.h"
 #include "internal/org_mitk_gui_qt_ultrasound_Activator.h"
 
 const std::string UltrasoundSupport::VIEW_ID = "org.mitk.views.ultrasoundsupport";
 
 void UltrasoundSupport::SetFocus()
 {
 }
 
 void UltrasoundSupport::CreateQtPartControl( QWidget *parent )
 {
   m_Timer = new QTimer(this);
 
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi( parent );
 
   connect( m_Controls.m_DeviceManagerWidget, SIGNAL(NewDeviceButtonClicked()), this, SLOT(OnClickedAddNewDevice()) ); // Change Widget Visibilities
   connect( m_Controls.m_DeviceManagerWidget, SIGNAL(NewDeviceButtonClicked()), this->m_Controls.m_NewVideoDeviceWidget, SLOT(CreateNewDevice()) ); // Init NewDeviceWidget
   connect( m_Controls.m_NewVideoDeviceWidget, SIGNAL(Finished()), this, SLOT(OnNewDeviceWidgetDone()) ); // After NewDeviceWidget finished editing
   connect( m_Controls.m_BtnView, SIGNAL(clicked()), this, SLOT(OnClickedViewDevice()) );
   connect( m_Controls.m_FrameRate, SIGNAL(valueChanged(int)), this, SLOT(OnChangedFramerateLimit(int)) );
   connect( m_Controls.m_FreezeButton, SIGNAL(clicked()), this, SLOT(OnClickedFreezeButton()) );
   connect( m_Timer, SIGNAL(timeout()), this, SLOT(DisplayImage()));
 
   // Initializations
   m_Controls.m_NewVideoDeviceWidget->setVisible(false);
   std::string filter = "(&(" + us::ServiceConstants::OBJECTCLASS() + "="
       + "org.mitk.services.UltrasoundDevice)("
       + mitk::USDevice::GetPropertyKeys().US_PROPKEY_ISACTIVE + "=true))";
   m_Controls.m_ActiveVideoDevices->Initialize<mitk::USDevice>(
         mitk::USDevice::GetPropertyKeys().US_PROPKEY_LABEL ,filter);
 
   m_Node = this->GetDataStorage()->GetNamedNode("US Image Stream");
   if (m_Node.IsNull())
   {
     // Create Node for US Stream
     m_Node = mitk::DataNode::New();
     m_Node->SetName("US Image Stream");
     this->GetDataStorage()->Add(m_Node);
   }
 
   m_Controls.tabWidget->setTabEnabled(1, false);
 }
 
 void UltrasoundSupport::OnClickedAddNewDevice()
 {
   m_Controls.m_NewVideoDeviceWidget->setVisible(true);
   m_Controls.m_DeviceManagerWidget->setVisible(false);
   m_Controls.m_Headline->setText("Add New Video Device:");
   m_Controls.m_WidgetActiveDevices->setVisible(false);
 }
 
 void UltrasoundSupport::DisplayImage()
 {
   m_Device->Modified();
   m_Device->Update();
 
   mitk::Image::Pointer curOutput = m_Device->GetOutput();
-  if (! m_ImageAlreadySetToNode && curOutput.IsNotNull() && curOutput->IsInitialized())
-  {
-    m_Node->SetData(curOutput);
-    m_ImageAlreadySetToNode = true;
-  }
 
-  if ( curOutput.GetPointer() != m_Node->GetData() )
+  if ( m_ImageAlreadySetToNode && ( curOutput.GetPointer() != m_Node->GetData() ) )
   {
     MITK_INFO << "Data Node of the ultrasound image stream was changed by another plugin. Stop viewing.";
     this->StopViewing();
     return;
   }
 
+  if (! m_ImageAlreadySetToNode && curOutput.IsNotNull() && curOutput->IsInitialized())
+  {
+    m_Node->SetData(curOutput);
+    m_ImageAlreadySetToNode = true;
+  }
+
   this->RequestRenderWindowUpdate();
 
   if ( curOutput->GetDimension() > 1
     && (curOutput->GetDimension(0) != m_CurrentImageWidth
     || curOutput->GetDimension(1) != m_CurrentImageHeight) )
   {
     // make a reinit on the ultrasound image
     mitk::IRenderWindowPart* renderWindow = this->GetRenderWindowPart();
     if ( renderWindow != NULL && curOutput->GetTimeGeometry()->IsValid() )
     {
       renderWindow->GetRenderingManager()->InitializeViews(
         curOutput->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
       renderWindow->GetRenderingManager()->RequestUpdateAll();
     }
 
     m_CurrentImageWidth = curOutput->GetDimension(0);
     m_CurrentImageHeight = curOutput->GetDimension(1);
   }
 
   m_FrameCounter ++;
   if (m_FrameCounter == 10)
   {
     int nMilliseconds = m_Clock.restart();
     int fps = 10000.0f / (nMilliseconds );
     m_Controls.m_FramerateLabel->setText("Current Framerate: "+ QString::number(fps) +" FPS");
     m_FrameCounter = 0;
   }
 }
 
 void UltrasoundSupport::OnClickedViewDevice()
 {
   m_FrameCounter = 0;
   // We use the activity state of the timer to determine whether we are currently viewing images
   if ( ! m_Timer->isActive() ) // Activate Imaging
   {
     this->StartViewing();
   }
   else //deactivate imaging
   {
     this->StopViewing();
   }
 }
 
 void UltrasoundSupport::OnChangedFramerateLimit(int value)
 {
   m_Timer->setInterval(1000 / value);
 }
 
 void UltrasoundSupport::OnClickedFreezeButton()
 {
   if ( m_Device->GetIsFreezed() )
   {
     m_Device->SetIsFreezed(false);
     m_Controls.m_FreezeButton->setText("Freeze");
   }
   else
   {
     m_Device->SetIsFreezed(true);
     m_Controls.m_FreezeButton->setText("Start Viewing Again");
   }
 }
 
 void UltrasoundSupport::OnNewDeviceWidgetDone()
 {
   m_Controls.m_NewVideoDeviceWidget->setVisible(false);
   m_Controls.m_DeviceManagerWidget->setVisible(true);
   m_Controls.m_Headline->setText("Ultrasound Devices:");
   m_Controls.m_WidgetActiveDevices->setVisible(true);
 }
 
 void UltrasoundSupport::StartViewing()
 {
   m_ImageAlreadySetToNode = false;
 
   m_Controls.tabWidget->setTabEnabled(1, true);
   m_Controls.tabWidget->setCurrentIndex(1);
 
   //get device & set data node
   m_Device = m_Controls.m_ActiveVideoDevices->GetSelectedService<mitk::USDevice>();
   if (m_Device.IsNull())
   {
     m_Timer->stop();
     return;
   }
 
   //start timer
   int interval = (1000 / m_Controls.m_FrameRate->value());
   m_Timer->setInterval(interval);
   m_Timer->start();
 
   //change UI elements
   m_Controls.m_BtnView->setText("Stop Viewing");
 
   this->CreateControlWidgets();
 }
 
 void UltrasoundSupport::StopViewing()
 {
   m_Controls.tabWidget->setTabEnabled(1, false);
 
   this->RemoveControlWidgets();
 
   //stop timer & release data
   m_Timer->stop();
   m_Node->ReleaseData();
   this->RequestRenderWindowUpdate();
 
   //change UI elements
   m_Controls.m_BtnView->setText("Start Viewing");
 }
 
 void UltrasoundSupport::CreateControlWidgets()
 {
   m_ControlProbesWidget = new QmitkUSControlsProbesWidget(m_Device->GetControlInterfaceProbes(), m_Controls.m_ToolBoxControlWidgets);
   m_Controls.probesWidgetContainer->addWidget(m_ControlProbesWidget);
 
   // create b mode widget for current device
   m_ControlBModeWidget = new QmitkUSControlsBModeWidget(m_Device->GetControlInterfaceBMode(), m_Controls.m_ToolBoxControlWidgets);
   m_Controls.m_ToolBoxControlWidgets->addItem(m_ControlBModeWidget, "B Mode Controls");
   if ( ! m_Device->GetControlInterfaceBMode() )
   {
     m_Controls.m_ToolBoxControlWidgets->setItemEnabled(m_Controls.m_ToolBoxControlWidgets->count()-1, false);
   }
 
   // create doppler widget for current device
   m_ControlDopplerWidget = new QmitkUSControlsDopplerWidget(m_Device->GetControlInterfaceDoppler(), m_Controls.m_ToolBoxControlWidgets);
   m_Controls.m_ToolBoxControlWidgets->addItem(m_ControlDopplerWidget, "Doppler Controls");
   if ( ! m_Device->GetControlInterfaceDoppler() )
   {
     m_Controls.m_ToolBoxControlWidgets->setItemEnabled(m_Controls.m_ToolBoxControlWidgets->count()-1, false);
   }
 
   ctkPluginContext* pluginContext = mitk::PluginActivator::GetContext();
   if ( pluginContext )
   {
     std::string filter = "(ork.mitk.services.UltrasoundCustomWidget.deviceClass=" + m_Device->GetDeviceClass() + ")";
 
     QString interfaceName ( us_service_interface_iid<QmitkUSAbstractCustomWidget>() );
     m_CustomWidgetServiceReference = pluginContext->getServiceReferences(interfaceName, QString::fromStdString(filter));
 
     if (m_CustomWidgetServiceReference.size() > 0)
     {
       m_ControlCustomWidget = pluginContext->getService<QmitkUSAbstractCustomWidget>
         (m_CustomWidgetServiceReference.at(0))->CloneForQt(m_Controls.tab2);
       m_ControlCustomWidget->SetDevice(m_Device);
       m_Controls.m_ToolBoxControlWidgets->addItem(m_ControlCustomWidget, "Custom Controls");
     }
     else
     {
       m_Controls.m_ToolBoxControlWidgets->addItem(new QWidget(m_Controls.m_ToolBoxControlWidgets), "Custom Controls");
       m_Controls.m_ToolBoxControlWidgets->setItemEnabled(m_Controls.m_ToolBoxControlWidgets->count()-1, false);
     }
   }
 
   // select first enabled control widget
   for ( int n = 0; n < m_Controls.m_ToolBoxControlWidgets->count(); ++n)
   {
     if ( m_Controls.m_ToolBoxControlWidgets->isItemEnabled(n) )
     {
       m_Controls.m_ToolBoxControlWidgets->setCurrentIndex(n);
       break;
     }
   }
 }
 
 void UltrasoundSupport::RemoveControlWidgets()
 {
   // remove all control widgets from the tool box widget
   while (m_Controls.m_ToolBoxControlWidgets->count() > 0)
   {
     m_Controls.m_ToolBoxControlWidgets->removeItem(0);
   }
 
   // remove probes widget (which is not part of the tool box widget)
   m_Controls.probesWidgetContainer->removeWidget(m_ControlProbesWidget);
   delete m_ControlProbesWidget;
   m_ControlProbesWidget = 0;
 
   delete m_ControlBModeWidget;
   m_ControlBModeWidget = 0;
 
   delete m_ControlDopplerWidget;
   m_ControlDopplerWidget = 0;
 
   // delete custom widget if it is present
   if ( m_ControlCustomWidget )
   {
     ctkPluginContext* pluginContext = mitk::PluginActivator::GetContext();
     delete m_ControlCustomWidget; m_ControlCustomWidget = 0;
 
     if ( m_CustomWidgetServiceReference.size() > 0 )
     {
       pluginContext->ungetService(m_CustomWidgetServiceReference.at(0));
     }
   }
 }
 
 void UltrasoundSupport::OnDeciveServiceEvent(const ctkServiceEvent event)
 {
   if ( m_Device.IsNull() || event.getType() != us::ServiceEvent::MODIFIED ) { return; }
 
   ctkServiceReference service = event.getServiceReference();
 
-  if ( m_Device->GetDeviceManufacturer() != service.getProperty(mitk::USImageMetadata::PROP_DEV_MANUFACTURER).toString().toStdString()
-    && m_Device->GetDeviceModel() != service.getProperty(mitk::USImageMetadata::PROP_DEV_MODEL).toString().toStdString() )
+  if ( m_Device->GetManufacturer() != service.getProperty(QString::fromStdString(mitk::USDevice::GetPropertyKeys().US_PROPKEY_MANUFACTURER)).toString().toStdString()
+    && m_Device->GetName() != service.getProperty(QString::fromStdString(mitk::USDevice::GetPropertyKeys().US_PROPKEY_NAME)).toString().toStdString() )
   {
     return;
   }
 
   if ( ! m_Device->GetIsActive() && m_Timer->isActive() )
   {
     this->StopViewing();
   }
+
+  if ( m_CurrentDynamicRange != service.getProperty(QString::fromStdString(mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_DYNAMIC_RANGE)).toDouble() )
+  {
+    m_CurrentDynamicRange = service.getProperty(QString::fromStdString(mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_DYNAMIC_RANGE)).toDouble();
+
+    // update level window for the current dynamic range
+    mitk::LevelWindow levelWindow;
+    m_Node->GetLevelWindow(levelWindow);
+    levelWindow.SetAuto(m_Image, true, true);
+    m_Node->SetLevelWindow(levelWindow);
+  }
 }
 
 UltrasoundSupport::UltrasoundSupport()
 : m_ControlCustomWidget(0), m_ControlBModeWidget(0),
   m_ControlProbesWidget(0), m_ImageAlreadySetToNode(false),
   m_CurrentImageWidth(0), m_CurrentImageHeight(0)
 {
   ctkPluginContext* pluginContext = mitk::PluginActivator::GetContext();
 
   if ( pluginContext )
   {
     // to be notified about service event of an USDevice
     pluginContext->connectServiceListener(this, "OnDeciveServiceEvent",
       QString::fromStdString("(" + us::ServiceConstants::OBJECTCLASS() + "=" + us_service_interface_iid<mitk::USDevice>() + ")"));
   }
 }
 
 UltrasoundSupport::~UltrasoundSupport()
 {
 }
diff --git a/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupport.h b/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupport.h
index fa3c909ebc..15439003ba 100644
--- a/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupport.h
+++ b/Plugins/org.mitk.gui.qt.ultrasound/src/internal/UltrasoundSupport.h
@@ -1,124 +1,125 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef UltrasoundSupport_h
 #define UltrasoundSupport_h
 
 #include <berryISelectionListener.h>
 
 #include <QmitkAbstractView.h>
 
 #include "ui_UltrasoundSupportControls.h"
 #include "QmitkUSAbstractCustomWidget.h"
 #include "QmitkUSControlsBModeWidget.h"
 #include "QmitkUSControlsDopplerWidget.h"
 #include "QmitkUSControlsProbesWidget.h"
 
 #include <QTime>
 
 #include <ctkServiceEvent.h>
 
 /*!
 \brief UltrasoundSupport
 This plugin provides functionality to manage Ultrasound devices, create video devices and to view device images.
 
 \sa QmitkFunctionality
 \ingroup ${plugin_target}_internal
 */
 class UltrasoundSupport : public QmitkAbstractView
 {
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
 
   virtual void SetFocus();
 
   static const std::string VIEW_ID;
 
   virtual void CreateQtPartControl(QWidget *parent);
 
   UltrasoundSupport();
   virtual ~UltrasoundSupport();
 
   public slots:
     /*
     * \brief This is called when the newDeviceWidget is closed
     */
     void OnNewDeviceWidgetDone();
 
     protected slots:
 
       void OnClickedAddNewDevice();
 
       void OnClickedViewDevice();
 
       void OnChangedFramerateLimit(int);
 
       void OnClickedFreezeButton();
 
       void OnDeciveServiceEvent(const ctkServiceEvent event);
 
       /*
       * \brief This is the main imaging loop that is called regularily during the imaging process
       */
       void DisplayImage();
 
 protected:
 
   void StartViewing();
   void StopViewing();
 
   void CreateControlWidgets();
   void RemoveControlWidgets();
 
   int m_FrameCounter;
 
   /*
   * \brief This timer triggers periodic updates to the pipeline
   */
   QTimer* m_Timer;
 
   QTime   m_Clock;
 
   /*
   * \brief The device that is currently used to aquire images
   */
   mitk::USDevice::Pointer m_Device;
 
   /*
   * \brief The node that we feed images into
   */
   mitk::DataNode::Pointer m_Node;
 
   mitk::Image::Pointer m_Image;
 
   Ui::UltrasoundSupportControls m_Controls;
 
   QmitkUSAbstractCustomWidget*  m_ControlCustomWidget;
   QmitkUSControlsBModeWidget*   m_ControlBModeWidget;
   QmitkUSControlsDopplerWidget* m_ControlDopplerWidget;
   QmitkUSControlsProbesWidget*  m_ControlProbesWidget;
 
   QList<ctkServiceReference>    m_CustomWidgetServiceReference;
 
   bool m_ImageAlreadySetToNode;
   unsigned int m_CurrentImageWidth;
   unsigned int m_CurrentImageHeight;
+  double m_CurrentDynamicRange;
 };
 
 #endif // UltrasoundSupport_h
\ No newline at end of file