diff --git a/Modules/IGTUI/Qmitk/QmitkTrackingDeviceConfigurationWidget.cpp b/Modules/IGTUI/Qmitk/QmitkTrackingDeviceConfigurationWidget.cpp
index 691c1bc944..7a83f10b82 100644
--- a/Modules/IGTUI/Qmitk/QmitkTrackingDeviceConfigurationWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkTrackingDeviceConfigurationWidget.cpp
@@ -1,351 +1,352 @@
 /*===================================================================
 
 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 "mitkNDIPolarisTypeInformation.h"
 
 #include <QSettings>
 
 const std::string QmitkTrackingDeviceConfigurationWidget::VIEW_ID = "org.mitk.views.trackingdeviceconfigurationwidget";
 
 QmitkTrackingDeviceConfigurationWidget::QmitkTrackingDeviceConfigurationWidget(QWidget* parent, Qt::WindowFlags f)
   : QWidget(parent, f)
   , m_Controls(nullptr)
   , m_TrackingDevice(nullptr)
   , m_DeviceToWidgetIndexMap()
 {
   //initializations
   CreateQtPartControl(this);
   CreateConnections();
 
   RefreshTrackingDeviceCollection();
 
   //initialize a few UI elements
   AddOutput("<br>First Element selected"); //Order from Collection List
 
   //reset a few things
   ResetOutput();
 
   //restore old UI settings
   LoadUISettings();
 }
 
 QmitkTrackingDeviceConfigurationWidget::~QmitkTrackingDeviceConfigurationWidget()
 {
   StoreUISettings();
   delete m_Controls;
   m_TrackingDevice = nullptr;
 }
 
 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()));
   }
 }
 
 void QmitkTrackingDeviceConfigurationWidget::TrackingDeviceChanged()
 {
   const std::string currentDevice = this->GetCurrentDeviceName();
 
   //show the correspondig widget
   m_Controls->m_TrackingSystemWidget->setCurrentIndex(m_DeviceToWidgetIndexMap[currentDevice]);
 
   //reset output
   ResetOutput();
 
   AddOutput("<br>");
   AddOutput(currentDevice);
   AddOutput(" selected");
 
   QmitkAbstractTrackingDeviceWidget* widget = GetWidget(currentDevice);
 
   if (widget == nullptr || !widget->IsDeviceInstalled())
   {
     AddOutput("<br>ERROR: not installed!");
   }
 
   emit TrackingDeviceSelectionChanged();
 }
 
 void QmitkTrackingDeviceConfigurationWidget::RefreshTrackingDeviceCollection()
 {
   // clean-up of stacked widget, drop-down box and map
   for (auto& item : m_DeviceToWidgetIndexMap)
   {
     m_Controls->m_TrackingSystemWidget->removeWidget(m_Controls->m_TrackingSystemWidget->widget(item.second));
     MITK_INFO << "removing widget for device '" << item.first << "'";
   }
 
   m_Controls->m_TrackingDeviceChooser->clear();
 
   m_DeviceToWidgetIndexMap.clear();
 
   // get tracking device type service references
   us::ModuleContext* context = us::GetModuleContext();
   std::vector<us::ServiceReference<mitk::TrackingDeviceTypeCollection> > deviceRefs =
     context->GetServiceReferences<mitk::TrackingDeviceTypeCollection>();
 
   if (deviceRefs.empty())
   {
     MITK_ERROR << "No tracking device type service found!";
     return;
   }
 
   // get tracking device configuration widget service references
   std::vector<us::ServiceReference<mitk::TrackingDeviceWidgetCollection> > widgetRefs =
     context->GetServiceReferences<mitk::TrackingDeviceWidgetCollection>();
 
   if (widgetRefs.empty())
   {
     MITK_ERROR << "No tracking device configuration widget service found!";
     return;
   }
 
   const us::ServiceReference<mitk::TrackingDeviceTypeCollection>& deviceServiceReference = deviceRefs.front();
   const us::ServiceReference<mitk::TrackingDeviceWidgetCollection>& widgetServiceReference = widgetRefs.front();
 
   mitk::TrackingDeviceTypeCollection* deviceTypeCollection =
     context->GetService<mitk::TrackingDeviceTypeCollection>(deviceServiceReference);
 
   mitk::TrackingDeviceWidgetCollection* deviceWidgetCollection =
     context->GetService<mitk::TrackingDeviceWidgetCollection>(widgetServiceReference);
 
   for (auto name : deviceTypeCollection->GetTrackingDeviceTypeNames())
   {
     // if the device is not included yet, add name to comboBox and widget to stackedWidget
     if (m_Controls->m_TrackingDeviceChooser->findText(QString::fromStdString(name)) == -1)
     {
       m_Controls->m_TrackingDeviceChooser->addItem(QString::fromStdString(name));
       QWidget* current = deviceWidgetCollection->GetTrackingDeviceWidgetClone(name);
       if (current == nullptr)
       {
         MITK_WARN << "No widget for tracking device type " << name << " available. Please implement and register it!";
         current = new QWidget();
       }
 
       m_DeviceToWidgetIndexMap[name] = m_Controls->m_TrackingSystemWidget->addWidget(current);
     }
   }
 
   if (!m_DeviceToWidgetIndexMap.empty())
   {
     m_Controls->m_TrackingDeviceChooser->setCurrentIndex(0);
     m_Controls->m_TrackingSystemWidget->setCurrentIndex(0);
   }
 
   context->UngetService(deviceServiceReference);
   context->UngetService(widgetServiceReference);
 }
 
 //######################### internal help methods #######################################
 void QmitkTrackingDeviceConfigurationWidget::ResetOutput()
 {
   QmitkAbstractTrackingDeviceWidget* currentWidget = this->GetWidget(this->GetCurrentDeviceName());
 
   if (currentWidget == nullptr)
   {
     return;
   }
 
   currentWidget->ResetOutput();
   currentWidget->repaint();
 }
 
 void QmitkTrackingDeviceConfigurationWidget::AddOutput(std::string s)
 {
   QmitkAbstractTrackingDeviceWidget* currentWidget = this->GetWidget(this->GetCurrentDeviceName());
 
   if (currentWidget == nullptr)
   {
     return;
   }
 
   currentWidget->AddOutput(s);
   currentWidget->repaint();
 }
 
 mitk::TrackingDevice::Pointer QmitkTrackingDeviceConfigurationWidget::ConstructTrackingDevice()
 {
+  MITK_DEBUG << "Construct Tracking Device";
   QmitkAbstractTrackingDeviceWidget* currentWidget = this->GetWidget(this->GetCurrentDeviceName());
 
   if (currentWidget == nullptr)
   {
     return nullptr;
   }
 
   return currentWidget->ConstructTrackingDevice();
 }
 
 mitk::TrackingDevice::Pointer QmitkTrackingDeviceConfigurationWidget::GetTrackingDevice()
 {
   //Only create a new device, if we don't have one yet or if the device selection in the widget has changed.
   //otherwise, hundered of devices will be created each time someone calls Get...
   if (m_TrackingDevice.IsNull() || m_TrackingDevice->GetTrackingDeviceName() != this->GetCurrentDeviceName())
     m_TrackingDevice = ConstructTrackingDevice();
 
   if (m_TrackingDevice.IsNull() || !m_TrackingDevice->IsDeviceInstalled()) return nullptr;
   else return this->m_TrackingDevice;
 }
 
 void QmitkTrackingDeviceConfigurationWidget::StoreUISettings()
 {
   std::string id = "org.mitk.modules.igt.ui.trackingdeviceconfigurationwidget";
 
   std::string selectedDevice = this->GetCurrentDeviceName();
 
   //Save settings for every widget
   //Don't use m_DeviceTypeCollection here, it's already unregistered, when deconstructor is called...
   for (int index = 0; index < m_Controls->m_TrackingSystemWidget->count(); index++)
   {
     QmitkAbstractTrackingDeviceWidget* widget = dynamic_cast<QmitkAbstractTrackingDeviceWidget*>(m_Controls->m_TrackingSystemWidget->widget(index));
 
     if (widget != nullptr)
     {
       widget->StoreUISettings();
     }
   }
 
   if (this->GetPersistenceService()) // now save the settings using the persistence service
   {
     mitk::PropertyList::Pointer propList = this->GetPersistenceService()->GetPropertyList(id);
     propList->Set("SelectedDevice", selectedDevice);
   }
   else // QSettings as a fallback if the persistence service is not available
   {
     QSettings settings;
     settings.beginGroup(QString::fromStdString(id));
     settings.setValue("trackingDeviceChooser", QVariant(QString::fromStdString(selectedDevice)));
     settings.endGroup();
   }
 }
 
 /**
  * @brief QmitkTrackingDeviceConfigurationWidget::LoadUISettings
  *
  * Precondition:
  * Make sure that QStackedWidget is already initialized,
  * e.g. by calling RefreshTrackingDeviceCollection() before.
  */
 void QmitkTrackingDeviceConfigurationWidget::LoadUISettings()
 {
   //Load settings for every widget
   for (int index = 0; index < m_Controls->m_TrackingSystemWidget->count(); index++)
   {
     QmitkAbstractTrackingDeviceWidget* widget = dynamic_cast<QmitkAbstractTrackingDeviceWidget*>(m_Controls->m_TrackingSystemWidget->widget(index));
 
     if (widget != nullptr)
     {
       widget->LoadUISettings();
     }
   }
 
   std::string id = "org.mitk.modules.igt.ui.trackingdeviceconfigurationwidget";
   std::string selectedDevice;
   if (this->GetPersistenceService())
   {
     mitk::PropertyList::Pointer propList = this->GetPersistenceService()->GetPropertyList(id);
     if (propList.IsNull())
     {
       MITK_ERROR << "Property list for this UI (" << id << ") is not available, could not load UI settings!"; return;
     }
 
     propList->Get("SelectedDevice", selectedDevice);
 
     if (selectedDevice.empty())
     {
       MITK_ERROR << "Loaded data from persistence service is invalid (SelectedDevice:" << selectedDevice << "): aborted to restore data!";
       return;
     }
 
     MITK_INFO << "Successfully restored UI settings";
   }
   else
   {
     // QSettings as a fallback if the persistence service is not available
     QSettings settings;
     settings.beginGroup(QString::fromStdString(id));
 
     selectedDevice = settings.value("trackingDeviceChooser", "").toString().toStdString();
 
     settings.endGroup();
   }
 
   // The selected device requires some checks because a device that is not installed should not be restored to avoid bugs.
   // Use NDI Polaris as default if there's no widget registered for selected device or there's a widget for it but no device installed.
 
   const auto& deviceIterator = m_DeviceToWidgetIndexMap.find(selectedDevice);
 
   if (deviceIterator != m_DeviceToWidgetIndexMap.end())
   {
     QmitkAbstractTrackingDeviceWidget* widget =
       dynamic_cast<QmitkAbstractTrackingDeviceWidget*>(m_Controls->m_TrackingSystemWidget->widget(deviceIterator->second));
 
     if (widget == nullptr || (widget != nullptr && !widget->IsDeviceInstalled()))
     {
       selectedDevice = mitk::NDIPolarisTypeInformation::GetTrackingDeviceName();
     }
   }
   else
   {
     selectedDevice = mitk::NDIPolarisTypeInformation::GetTrackingDeviceName();
   }
 
   const int index = m_Controls->m_TrackingDeviceChooser->findText(QString::fromStdString(selectedDevice));
 
   if (index >= 0)
   {
     m_Controls->m_TrackingDeviceChooser->setCurrentIndex(index);
   }
   else
   {
     MITK_ERROR << "Failed to load UI setting for tracking device configuration";
     return;
   }
 
   m_Controls->m_TrackingSystemWidget->setCurrentIndex(m_DeviceToWidgetIndexMap[selectedDevice]);
 }
 
 std::string QmitkTrackingDeviceConfigurationWidget::GetCurrentDeviceName(void) const
 {
   return m_Controls->m_TrackingDeviceChooser->currentText().toStdString();
 }
 
 QmitkAbstractTrackingDeviceWidget* QmitkTrackingDeviceConfigurationWidget::GetWidget(const std::string& deviceName) const
 {
   const auto& deviceIterator = m_DeviceToWidgetIndexMap.find(deviceName);
 
   if (deviceIterator != m_DeviceToWidgetIndexMap.end())
   {
     QWidget* widget = m_Controls->m_TrackingSystemWidget->widget(deviceIterator->second);
 
     return dynamic_cast<QmitkAbstractTrackingDeviceWidget*>(widget);
   }
 
   return nullptr;
 }
diff --git a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxViewWorker.cpp b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxViewWorker.cpp
index 2df2a46482..4f6272aeba 100644
--- a/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxViewWorker.cpp
+++ b/Plugins/org.mitk.gui.qt.igttracking/src/internal/QmitkMITKIGTTrackingToolboxViewWorker.cpp
@@ -1,265 +1,266 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // Qmitk
 #include "QmitkMITKIGTTrackingToolboxViewWorker.h"
 
 #include <mitkTrackingDeviceSourceConfigurator.h>
 
 QmitkMITKIGTTrackingToolboxViewWorker::QmitkMITKIGTTrackingToolboxViewWorker()
 {
 }
 
 QmitkMITKIGTTrackingToolboxViewWorker::~QmitkMITKIGTTrackingToolboxViewWorker()
 {
 }
 
 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;
 }
 
 //! [Thread 7]
 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;
   }
 }
 //! [Thread 7]
 
 void QmitkMITKIGTTrackingToolboxViewWorker::AutoDetectTools()
 {
   mitk::NavigationToolStorage::Pointer autoDetectedStorage = mitk::NavigationToolStorage::New(m_DataStorage);
   try
   {
     mitk::NavigationToolStorage::Pointer tempStorage = m_TrackingDevice->AutoDetectTools();
     for (int i = 0; i < tempStorage->GetToolCount(); i++) { autoDetectedStorage->AddTool(tempStorage->GetTool(i)); }
   }
   catch (mitk::Exception& e)
   {
     MITK_WARN << e.GetDescription();
     emit AutoDetectToolsFinished(false, e.GetDescription());
     return;
   }
+  m_NavigationToolStorage = nullptr;
   m_NavigationToolStorage = autoDetectedStorage;
   emit AutoDetectToolsFinished(true, "");
 }
 
 void QmitkMITKIGTTrackingToolboxViewWorker::ConnectDevice()
 {
   std::string message = "";
 
   //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;
 
   //Create Navigation Data Source with the factory class
   mitk::TrackingDeviceSourceConfigurator::Pointer myTrackingDeviceSourceFactory = mitk::TrackingDeviceSourceConfigurator::New(m_NavigationToolStorage, trackingDevice);
 
   m_TrackingDeviceSource = myTrackingDeviceSourceFactory->CreateTrackingDeviceSource(m_ToolVisualizationFilter);
 
   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 << "Connected device with " << m_TrackingDeviceSource->GetNumberOfOutputs() << " tools.";
 
   //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
 
     for (int i = 0; i < toolsInNewOrder->GetToolCount(); i++)
     {
       m_NavigationToolStorage->AssignToolNumber(toolsInNewOrder->GetTool(i)->GetIdentifier(), i);
     }
   }
 
   //connect to device
   try
   {
     m_TrackingDeviceSource->Connect();
     //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::TrackingDeviceSource::Pointer QmitkMITKIGTTrackingToolboxViewWorker::GetTrackingDeviceSource()
 {
   return this->m_TrackingDeviceSource;
 }
 
 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;
   }
   //remember the original colors of the tools
   m_OriginalColors = std::map<mitk::DataNode::Pointer, mitk::Color>();
   for (int i = 0; i < this->m_NavigationToolStorage->GetToolCount(); i++)
   {
     mitk::DataNode::Pointer currentToolNode = m_NavigationToolStorage->GetTool(i)->GetDataNode();
     float c[3];
     currentToolNode->GetColor(c);
     mitk::Color color;
     color.SetRed(c[0]);
     color.SetGreen(c[1]);
     color.SetBlue(c[2]);
     m_OriginalColors[currentToolNode] = color;
   }
 
   emit StartTrackingFinished(true, errorMessage);
 }
 
 void QmitkMITKIGTTrackingToolboxViewWorker::StopTracking()
 {
   //stop tracking
   try
   {
     m_TrackingDeviceSource->StopTracking();
   }
   catch (mitk::Exception& e)
   {
     emit StopTrackingFinished(false, e.GetDescription());
   }
 
   //restore the original colors of the tools
   for (int i = 0; i < this->m_NavigationToolStorage->GetToolCount(); i++)
   {
     mitk::DataNode::Pointer currentToolNode = m_NavigationToolStorage->GetTool(i)->GetDataNode();
     if (m_OriginalColors.find(currentToolNode) == m_OriginalColors.end())
     {
       MITK_WARN << "Cannot restore original color of tool " << m_NavigationToolStorage->GetTool(i)->GetToolName();
     }
     else
     {
       currentToolNode->SetColor(m_OriginalColors[currentToolNode]);
     }
   }
 
   //emit signal
   emit StopTrackingFinished(true, "");
 }
 
 void QmitkMITKIGTTrackingToolboxViewWorker::DisconnectDevice()
 {
   try
   {
     if (m_TrackingDeviceSource->IsTracking()) { m_TrackingDeviceSource->StopTracking(); }
     m_TrackingDeviceSource->Disconnect();
     m_TrackingDeviceSource->UnRegisterMicroservice();
 
     m_NavigationToolStorage->UnLockStorage();
 
     m_TrackingDeviceSource = nullptr;
   }
   catch (mitk::Exception& e)
   {
     emit DisconnectDeviceFinished(false, e.GetDescription());
   }
   emit DisconnectDeviceFinished(true, "");
 }
\ No newline at end of file