diff --git a/Modules/IGTUI/Qmitk/QmitkAbstractTrackingDeviceWidget.cpp b/Modules/IGTUI/Qmitk/QmitkAbstractTrackingDeviceWidget.cpp
index df36176cd3..b1dad757a6 100644
--- a/Modules/IGTUI/Qmitk/QmitkAbstractTrackingDeviceWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkAbstractTrackingDeviceWidget.cpp
@@ -1,71 +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.
 
 ===================================================================*/
 
 #include "QmitkAbstractTrackingDeviceWidget.h"
 
-QmitkAbstractTrackingDeviceWidget::QmitkAbstractTrackingDeviceWidget(QWidget* parent, Qt::WindowFlags f) : QWidget(parent, f)
+#include <QThread>
+
+QmitkAbstractTrackingDeviceWidget::QmitkAbstractTrackingDeviceWidget(QWidget* parent, Qt::WindowFlags f)
+  : QWidget(parent, f)
+  , isInitialized(false)
 {
-  isInitialized = false;
 }
 
 void QmitkAbstractTrackingDeviceWidget::InitializeSuperclassWidget()
 {
   m_TestConnectionWorkerThread = new QThread();
   m_TestConnectionWorker = new QmitkTrackingDeviceConfigurationWidgetConnectionWorker();
   CreateConnections();
   m_ErrorMessage = "";
   isInitialized = true;
 }
 
 QmitkAbstractTrackingDeviceWidget::~QmitkAbstractTrackingDeviceWidget(){
   if (m_TestConnectionWorker) delete m_TestConnectionWorker;
   if (m_TestConnectionWorkerThread) delete m_TestConnectionWorkerThread;
 }
 
 void QmitkAbstractTrackingDeviceWidget::TestConnectionFinished(bool connected, QString output)
 {
   m_TestConnectionWorkerThread->quit();
   AddOutput(output.toStdString());
   MITK_INFO << "Test connection: " << connected;
   this->setEnabled(true);
 }
 
 void QmitkAbstractTrackingDeviceWidget::TestConnection()
 {
   this->setEnabled(false);
   //construct a tracking device:
   mitk::TrackingDevice::Pointer testTrackingDevice = ConstructTrackingDevice();
   m_TestConnectionWorker->SetTrackingDevice(testTrackingDevice);
   m_TestConnectionWorkerThread->start();
 }
 
 void QmitkAbstractTrackingDeviceWidget::CreateConnections() {
   connect(m_TestConnectionWorker, SIGNAL(ConnectionTested(bool, QString)), this, SLOT(TestConnectionFinished(bool, QString)));
   connect(m_TestConnectionWorkerThread, SIGNAL(started()), m_TestConnectionWorker, SLOT(TestConnectionThreadFunc()));
 
   //move the worker to the thread
   m_TestConnectionWorker->moveToThread(m_TestConnectionWorkerThread);
 }
 
 QmitkAbstractTrackingDeviceWidget* QmitkAbstractTrackingDeviceWidget::CloneForQt(QWidget* parent) const
 {
   QmitkAbstractTrackingDeviceWidget* clonedWidget = this->Clone(parent);
   if (!clonedWidget->IsInitialized())
     MITK_ERROR << "Your cloned widget is not initialized!";
   clonedWidget->create();
 
   return clonedWidget;
-}
\ No newline at end of file
+}
diff --git a/Modules/IGTUI/Qmitk/QmitkAbstractTrackingDeviceWidget.h b/Modules/IGTUI/Qmitk/QmitkAbstractTrackingDeviceWidget.h
index 31e5bbfdee..44754bd672 100644
--- a/Modules/IGTUI/Qmitk/QmitkAbstractTrackingDeviceWidget.h
+++ b/Modules/IGTUI/Qmitk/QmitkAbstractTrackingDeviceWidget.h
@@ -1,146 +1,143 @@
 /*===================================================================
 
 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 QmitkAbstractTrackingDeviceWidget_H
 #define QmitkAbstractTrackingDeviceWidget_H
 
 #include <QWidget>
 #include "MitkIGTUIExports.h"
 #include "mitkTrackingDevice.h"
 
-#include <qscrollbar.h>
-#include <qthread.h>
-
 #include <mitkIPersistenceService.h>
 
 #include "QmitkTrackingDeviceConfigurationWidgetConnectionWorker.h"
 
 //itk headers
 
 /** Documentation:
  *  \brief Abstract class to configure a tracking device.
  *         Inherited widgets should be registered in the Microservice (TrackingDeviceCollectionWidget),
  *         If done so, they will be included in the QmitkTrackingDeviceConfigurationWidget of the Tracking Toolbox.
  *
  *         - Each implementation of this class must have a method to construct a tracking Device (ConstructTrackingDevice).
  *         - Please create the UI elements in a function like CreateQtPartControl (e.g. see QmitkVitrualTrackerWidget).
  *         - You might want to use own buttons etc., please connect them in a private CreateConnections (e.g. see QmitkVitrualTrackerWidget).
  *         - Due to initialization of qt during autoloading of the IGT module, you constructor should be as slim as possible and only contain a call
  *           of the QmitkAbstractTrackingDeviceWidget constructor and simple variable initialization.
  *         - For the initialization, you must write an Iniltialize() function, which must include a call of InitializeSuperclassWidget() and should contain
  *           calls of your private CreateConnections / CreateQtPartControl (if you implemented these).
  *         - For integration into the TrackingToolbox, a clone function is needed. Here, a new widget should be created, Initialize() needs to be called,
  *           and all settings of your widget should be copied.
  *
  *         You can Load and Store previous settings of your GUI elements (e.g. see QmitkNDIPolarisWidget).
  *         Also, you can add an output textbox to your widget to display information about your device status. It's optional, see e.g. QmitkNDIAuroraWidget.
  *         Some Devices need the information if drivers are installed on your computer. If this is necessary for your device to avoid crashes,
  *         please override IsDeviceInstalled. The default return value is true otherwise.
  *
  *  \ingroup IGTUI
  */
 class MITKIGTUI_EXPORT QmitkAbstractTrackingDeviceWidget : public QWidget
 {
   Q_OBJECT
 
 public:
   static const std::string VIEW_ID;
 
   QmitkAbstractTrackingDeviceWidget(QWidget* parent = 0, Qt::WindowFlags f = 0);
 
   virtual ~QmitkAbstractTrackingDeviceWidget();
 
   /**
    * \brief Return pointer to copy of the object.
    * Internally use of QmitkUSAbstractCustomWidget::Clone() with additionaly
    * setting an internal flag that the object was really cloned.
    */
   QmitkAbstractTrackingDeviceWidget* CloneForQt(QWidget* parent = 0) const;
 
   /**
   * \brief Subclass must implement this method to return a pointer to a copy of the object.
   * Please don't forget to call InitializeSuperclassWidget(), CreateQtPartControl and optionally CreateConnections during this function.
   */
   virtual void Initialize() = 0;
 
   bool IsInitialized() const { return isInitialized; }
 
 signals:
   void ConnectionTested(bool connected, QString output);
 
   protected slots:
   void TestConnectionFinished(bool connected, QString output);
 
   /* @brief This method is called when the user presses the button "test connection". The method will then create a temporary tracking device,
    *        try to open a connection and start tracking. The user can see the result of the connection test on the small output window.
    */
   void TestConnection();
 
 private:
   /// \brief Creation of the connections. You might implement the same function again in your inherited widget.
   void CreateConnections();
 
 protected:
   PERSISTENCE_GET_SERVICE_METHOD_MACRO
     void InitializeSuperclassWidget();
 
   QmitkTrackingDeviceConfigurationWidgetConnectionWorker* m_TestConnectionWorker;
   QThread* m_TestConnectionWorkerThread;
 
   /**
    * \brief Subclass must implement this method to return a pointer to a copy of the object.
    * Please don't forget to call Initialize() during this function and copy all of your settings.
    */
   virtual QmitkAbstractTrackingDeviceWidget* Clone(QWidget* parent = 0) const = 0;
 
 public:
   /**
   * \brief Optional method to add output to a small screen in the trackingToolbox (see QmitkNDIPolarisWidget)
   */
   virtual void ResetOutput() {}
   /**
   * \brief Optional method to add output to a small screen in the trackingToolbox (see QmitkNDIPolarisWidget)
   */
   virtual void AddOutput(std::string) {}
   virtual mitk::TrackingDevice::Pointer ConstructTrackingDevice() = 0;
 
   /**
   * \brief Optional method to store and load settings of your widget (see QmitkNDIPolarisWidget)
   */
   virtual void StoreUISettings() {}
 
   /**
   * \brief Optional method to store and load settings of your widget (see QmitkNDIPolarisWidget)
   */
   virtual void LoadUISettings() {}
 
   /**
   * \brief Optional method to investigate if drivers etc for your device are installed.
   * The default value is "true" as most devices don't need this information.
   * Others however migth crash, and for these you might implement this function (see QmitkMicronTrackerWidget)
   */
   virtual bool IsDeviceInstalled() { return true; }
 
   std::string m_ErrorMessage; ///< current problem description
 
 private:
   /**
   * \warning Don't touch this variable if you don't know what you are doing!
   */
   bool isInitialized;
 };
 
 #endif
diff --git a/Modules/IGTUI/Qmitk/QmitkMicronTrackerWidget.cpp b/Modules/IGTUI/Qmitk/QmitkMicronTrackerWidget.cpp
index d73dbfec55..cc79711681 100644
--- a/Modules/IGTUI/Qmitk/QmitkMicronTrackerWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkMicronTrackerWidget.cpp
@@ -1,169 +1,168 @@
 /*===================================================================
 
 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 "QmitkMicronTrackerWidget.h"
-#include "QmitkTrackingDeviceConfigurationWidget.h"
 
 #include <QFileDialog>
-#include <QMessageBox>
+#include <QScrollBar>
 
 #include <mitkClaronTrackingDevice.h>
 
 #include <itksys/SystemTools.hxx>
 #include <Poco/Path.h>
 #include <QSettings>
 
 const std::string QmitkMicronTrackerWidget::VIEW_ID = "org.mitk.views.NDIMicronTrackerWidget";
 
 QmitkMicronTrackerWidget::QmitkMicronTrackerWidget(QWidget* parent, Qt::WindowFlags f)
   : QmitkAbstractTrackingDeviceWidget(parent, f)
+  , m_Controls(nullptr)
 {
-  m_Controls = NULL;
 }
 
 void QmitkMicronTrackerWidget::Initialize()
 {
   InitializeSuperclassWidget();
   CreateQtPartControl(this);
   CreateConnections();
   m_MTCalibrationFile = "";
 }
 
 QmitkMicronTrackerWidget::~QmitkMicronTrackerWidget()
 {
   delete m_Controls;
 }
 
 void QmitkMicronTrackerWidget::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkMicronTrackerWidget;
     m_Controls->setupUi(parent);
   }
 }
 
 void QmitkMicronTrackerWidget::CreateConnections()
 {
   if (m_Controls)
   {
     connect((QObject*)(m_Controls->m_testConnectionMicronTracker), SIGNAL(clicked()), this, SLOT(TestConnection()));
     connect((QObject*)(m_Controls->m_SetMTCalibrationFile), SIGNAL(clicked()), this, SLOT(SetMTCalibrationFileClicked()));
   }
 }
 
 void QmitkMicronTrackerWidget::ResetOutput()
 {
   m_Controls->m_outputTextMicronTracker->setHtml("<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>");
 }
 
 void QmitkMicronTrackerWidget::AddOutput(std::string s)
 {
   m_Controls->m_outputTextMicronTracker->setHtml(QString(s.c_str()));
   m_Controls->m_outputTextMicronTracker->verticalScrollBar()->setValue(m_Controls->m_outputTextMicronTracker->verticalScrollBar()->maximum());
 }
 
 mitk::TrackingDevice::Pointer QmitkMicronTrackerWidget::ConstructTrackingDevice()
 {
   mitk::ClaronTrackingDevice::Pointer newDevice = mitk::ClaronTrackingDevice::New();
   if (this->m_MTCalibrationFile.empty()) //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()));
   }
   if (!this->m_MTCalibrationFile.empty())
   {
     //extract path from calibration file and set the calibration dir of the device
     std::string path = itksys::SystemTools::GetFilenamePath(m_MTCalibrationFile);
     newDevice->SetCalibrationDir(path);
   }
   else
     AddOutput("<br>Warning: Calibration file is not set!");
   return static_cast<mitk::TrackingDevice::Pointer>(newDevice);
 }
 
 void QmitkMicronTrackerWidget::StoreUISettings()
 {
   std::string id = "org.mitk.modules.igt.ui.trackingdeviceconfigurationwidget";
   if (this->GetPeristenceService()) // now save the settings using the persistence service
   {
     mitk::PropertyList::Pointer propList = this->GetPeristenceService()->GetPropertyList(id);
     propList->Set("MTCalibrationFile", m_MTCalibrationFile);
   }
   else // QSettings as a fallback if the persistence service is not available
   {
     QSettings settings;
     settings.beginGroup(QString::fromStdString(id));
     settings.setValue("mTCalibrationFile", QVariant(QString::fromStdString(m_MTCalibrationFile)));
     settings.endGroup();
   }
 }
 
 void QmitkMicronTrackerWidget::LoadUISettings()
 {
   std::string id = "org.mitk.modules.igt.ui.trackingdeviceconfigurationwidget";
 
   if (this->GetPeristenceService())
   {
     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;
     }
 
     propList->Get("MTCalibrationFile", m_MTCalibrationFile);
   }
   else
   {
     // QSettings as a fallback if the persistence service is not available
     QSettings settings;
     settings.beginGroup(QString::fromStdString(id));
     m_MTCalibrationFile = settings.value("mTCalibrationFile", "").toString().toStdString();
 
     settings.endGroup();
   }
   m_Controls->m_MTCalibrationFile->setText("Calibration File: " + QString::fromStdString(m_MTCalibrationFile));
 }
 
 bool QmitkMicronTrackerWidget::IsDeviceInstalled()
 {
   return mitk::ClaronTrackingDevice::New()->IsDeviceInstalled();
 }
 
 void QmitkMicronTrackerWidget::SetMTCalibrationFileClicked()
 {
   std::string filename = QFileDialog::getOpenFileName(NULL, tr("Open Calibration File"), "/", "*.*").toLatin1().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()));
   }
 }
 
 QmitkMicronTrackerWidget* QmitkMicronTrackerWidget::Clone(QWidget* parent) const
 {
   QmitkMicronTrackerWidget* clonedWidget = new QmitkMicronTrackerWidget(parent);
   clonedWidget->Initialize();
   clonedWidget->m_MTCalibrationFile = m_MTCalibrationFile;
   m_Controls->m_MTCalibrationFile->setText("Calibration File: " + QString::fromStdString(m_MTCalibrationFile));
 
   return clonedWidget;
-}
\ No newline at end of file
+}
diff --git a/Modules/IGTUI/Qmitk/QmitkMicronTrackerWidget.h b/Modules/IGTUI/Qmitk/QmitkMicronTrackerWidget.h
index a33fb2805a..6f304182f1 100644
--- a/Modules/IGTUI/Qmitk/QmitkMicronTrackerWidget.h
+++ b/Modules/IGTUI/Qmitk/QmitkMicronTrackerWidget.h
@@ -1,73 +1,71 @@
 /*===================================================================
 
 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 QmitkMicronTrackerWidget_H
 #define QmitkMicronTrackerWidget_H
 
-#include <QWidget>
-#include "MitkIGTUIExports.h"
 #include "ui_QmitkMicronTrackerWidget.h"
 
 #include "QmitkAbstractTrackingDeviceWidget.h"
 
-//itk headers
 
 /** Documentation:
  *   \brief Implementation of a configuration widget for Micron Tracking Devices.
  *
  *   \ingroup IGTUI
  */
 class MITKIGTUI_EXPORT QmitkMicronTrackerWidget : public QmitkAbstractTrackingDeviceWidget
 {
   Q_OBJECT // this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
 
 public:
   static const std::string VIEW_ID;
 
   QmitkMicronTrackerWidget(QWidget* parent = 0, Qt::WindowFlags f = 0);
   ~QmitkMicronTrackerWidget();
 
   virtual void Initialize();
 
 signals:
 
   protected slots :
     /* @brief Opens a file dialog. The users sets the calibration file which location is then stored in the member m_MTCalibrationFile.*/
     void SetMTCalibrationFileClicked();
 
 private:
 
   /// \brief Creation of the connections
   void CreateConnections();
 
   void CreateQtPartControl(QWidget *parent);
+
 protected:
   virtual QmitkMicronTrackerWidget* Clone(QWidget* parent) const;
 
   std::string m_MTCalibrationFile;
 
   Ui::QmitkMicronTrackerWidget* m_Controls;
 
 public:
   virtual void ResetOutput();
   virtual void AddOutput(std::string s);
   virtual mitk::TrackingDevice::Pointer ConstructTrackingDevice();
 
   virtual void StoreUISettings();
   virtual void LoadUISettings();
   virtual bool IsDeviceInstalled();
 };
 #endif
diff --git a/Modules/IGTUI/Qmitk/QmitkNDIAbstractDeviceWidget.cpp b/Modules/IGTUI/Qmitk/QmitkNDIAbstractDeviceWidget.cpp
index 6c5474993c..ad8d4b758d 100644
--- a/Modules/IGTUI/Qmitk/QmitkNDIAbstractDeviceWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkNDIAbstractDeviceWidget.cpp
@@ -1,71 +1,67 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkNDIAbstractDeviceWidget.h"
-#include "QmitkTrackingDeviceConfigurationWidget.h"
-#include <mitkNDITrackingDevice.h>
 
-#include <QFileDialog>
-#include <QMessageBox>
+#include <QThread>
 
 const std::string QmitkNDIAbstractDeviceWidget::VIEW_ID = "org.mitk.views.NDIAbstractDeviceWidget";
 
 QmitkNDIAbstractDeviceWidget::QmitkNDIAbstractDeviceWidget(QWidget* parent, Qt::WindowFlags f)
   : QmitkAbstractTrackingDeviceWidget(parent, f)
+  , m_ScanPortsWorker(new QmitkTrackingDeviceConfigurationWidgetScanPortsWorker())
+  , m_ScanPortsWorkerThread(new QThread())
 {
-  //initialize worker thread
-  m_ScanPortsWorker = new QmitkTrackingDeviceConfigurationWidgetScanPortsWorker();
-  m_ScanPortsWorkerThread = new QThread();
 }
 
 void QmitkNDIAbstractDeviceWidget::InitializeNDIWidget()
 {
   InitializeSuperclassWidget();
   CreateConnections();
 }
 
 QmitkNDIAbstractDeviceWidget::~QmitkNDIAbstractDeviceWidget()
 {
   if (m_ScanPortsWorker) delete m_ScanPortsWorker;
   if (m_ScanPortsWorkerThread) delete m_ScanPortsWorkerThread;
 }
 
 void QmitkNDIAbstractDeviceWidget::CreateConnections()
 {
   //slots for the worker thread
   connect(m_ScanPortsWorker, SIGNAL(PortsScanned(int, QString, int)), this, SLOT(AutoScanPortsFinished(int, QString, int)));
   connect(m_ScanPortsWorkerThread, SIGNAL(started()), m_ScanPortsWorker, SLOT(ScanPortsThreadFunc()));
 }
 
 void QmitkNDIAbstractDeviceWidget::AutoScanPorts()
 {
   this->setEnabled(false);
   AddOutput("<br>Scanning...");
   m_ScanPortsWorkerThread->start();
 }
 
 void QmitkNDIAbstractDeviceWidget::AutoScanPortsFinished(int Port, QString result, int PortType)
 {
   m_ScanPortsWorkerThread->quit();
 #ifdef WIN32
   if (PortType != -1) { MITK_WARN << "Port type is specified although this should not be the case for Windows. Ignoring port type."; }
 #else //linux systems
   SetPortTypeToGUI(PortType);
 #endif
   SetPortValueToGUI(Port);
   AddOutput(result.toStdString());
   this->setEnabled(true);
-}
\ No newline at end of file
+}
diff --git a/Modules/IGTUI/Qmitk/QmitkNDIAbstractDeviceWidget.h b/Modules/IGTUI/Qmitk/QmitkNDIAbstractDeviceWidget.h
index 4062b31247..c26d46b9c2 100644
--- a/Modules/IGTUI/Qmitk/QmitkNDIAbstractDeviceWidget.h
+++ b/Modules/IGTUI/Qmitk/QmitkNDIAbstractDeviceWidget.h
@@ -1,74 +1,70 @@
 /*===================================================================
 
 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 QmitkNDIAbstractDeviceWidget_H
 #define QmitkNDIAbstractDeviceWidget_H
 
-#include <QWidget>
 #include "MitkIGTUIExports.h"
 #include "QmitkAbstractTrackingDeviceWidget.h"
-
 #include "QmitkTrackingDeviceConfigurationWidgetScanPortsWorker.h"
 
-//itk headers
-
 /** Documentation:
 *   \brief Abstract class of a configuration widget for NDI Devices.
 *          For implementations see NDIAuroraWidget or NDIPolarisWidget.
 *
 *   \ingroup IGTUI
 */
 class MITKIGTUI_EXPORT QmitkNDIAbstractDeviceWidget : public QmitkAbstractTrackingDeviceWidget
 {
   Q_OBJECT // this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
 
 public:
   static const std::string VIEW_ID;
 
   QmitkNDIAbstractDeviceWidget(QWidget* parent = 0, Qt::WindowFlags f = 0);
   ~QmitkNDIAbstractDeviceWidget();
 
   virtual void Initialize() = 0;
 
   virtual void AddOutput(std::string s) = 0;
 
 signals:
   void PortsScanned(int Port, QString result, int PortType);
 
   protected slots:
 
   /* @brief Scans the serial ports automatically for a connected tracking device. If the method finds a device
   *        it selects the right type and sets the corresponding port in the widget.
   */
   void AutoScanPorts();
 
   /** This slot is called when the port scanning is finished. */
   void AutoScanPortsFinished(int Port, QString result, int PortType);
 
 private:
   /// \brief Creation of the connections
   void CreateConnections();
 protected:
   void InitializeNDIWidget();
 
   QThread* m_ScanPortsWorkerThread;
   QmitkTrackingDeviceConfigurationWidgetScanPortsWorker* m_ScanPortsWorker;
 
   virtual void SetPortValueToGUI(int portValue) = 0;
   virtual void SetPortTypeToGUI(int portType) = 0;
 };
 
 #endif
diff --git a/Modules/IGTUI/Qmitk/QmitkNDIAuroraWidget.cpp b/Modules/IGTUI/Qmitk/QmitkNDIAuroraWidget.cpp
index 8fcb95eaa8..bc00cbfb50 100644
--- a/Modules/IGTUI/Qmitk/QmitkNDIAuroraWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkNDIAuroraWidget.cpp
@@ -1,175 +1,174 @@
 /*===================================================================
 
 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 "QmitkNDIAuroraWidget.h"
-#include "QmitkTrackingDeviceConfigurationWidget.h"
-#include <mitkNDITrackingDevice.h>
 
-#include <QFileDialog>
-#include <QMessageBox>
-#include <QSettings>
+#include "mitkNDITrackingDevice.h"
 #include "mitkNDIAuroraTypeInformation.h"
 
+#include <QScrollBar>
+#include <QSettings>
+
 const std::string QmitkNDIAuroraWidget::VIEW_ID = "org.mitk.views.NDIAuroraWidget";
 
 QmitkNDIAuroraWidget::QmitkNDIAuroraWidget(QWidget* parent, Qt::WindowFlags f)
   : QmitkNDIAbstractDeviceWidget(parent, f)
+  , m_Controls(nullptr)
 {
-  m_Controls = NULL;
 }
 
 void QmitkNDIAuroraWidget::Initialize()
 {
   InitializeNDIWidget();
   CreateQtPartControl(this);
   CreateConnections();
 }
 
 QmitkNDIAuroraWidget::~QmitkNDIAuroraWidget()
 {
   delete m_Controls;
 }
 
 void QmitkNDIAuroraWidget::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkNDIAuroraWidget;
     m_Controls->setupUi(parent);
   }
 }
 
 void QmitkNDIAuroraWidget::CreateConnections()
 {
   if (m_Controls)
   {
     connect((QObject*)(m_Controls->m_testConnectionAurora), SIGNAL(clicked()), this, SLOT(TestConnection()));
     connect((QObject*)(m_Controls->m_AutoScanAurora), SIGNAL(clicked()), this, SLOT(AutoScanPorts()));
     //set a few UI components depending on Windows / Linux
 #ifdef WIN32
     m_Controls->portTypeLabelAurora->setVisible(false);
     m_Controls->portTypeAurora->setVisible(false);
 #else
     m_Controls->comPortLabelAurora->setText("Port Nr:");
     m_Controls->m_portSpinBoxAurora->setPrefix("");
 #endif
   }
 }
 
 void QmitkNDIAuroraWidget::ResetOutput()
 {
   m_Controls->m_outputTextAurora->setHtml("<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>");
 }
 
 void QmitkNDIAuroraWidget::AddOutput(std::string s)
 {
   m_Controls->m_outputTextAurora->setHtml(QString(s.c_str()));
   m_Controls->m_outputTextAurora->verticalScrollBar()->setValue(m_Controls->m_outputTextAurora->verticalScrollBar()->maximum());
 }
 
 mitk::TrackingDevice::Pointer QmitkNDIAuroraWidget::ConstructTrackingDevice()
 {
   mitk::NDITrackingDevice::Pointer tempTrackingDevice = mitk::NDITrackingDevice::New();
 
   //get port
   int port = 0;
   port = m_Controls->m_portSpinBoxAurora->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
   prefix = m_Controls->portTypeAurora->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
   tempTrackingDevice->SetType(mitk::NDIAuroraTypeInformation::GetTrackingDeviceName());
   return static_cast<mitk::TrackingDevice::Pointer>(tempTrackingDevice);
 }
 
 void QmitkNDIAuroraWidget::StoreUISettings()
 {
   std::string id = "org.mitk.modules.igt.ui.trackingdeviceconfigurationwidget";
   if (this->GetPeristenceService()) // now save the settings using the persistence service
   {
     mitk::PropertyList::Pointer propList = this->GetPeristenceService()->GetPropertyList(id);
     propList->Set("AuroraPortWin", m_Controls->m_portSpinBoxAurora->value());
     propList->Set("PortTypeAurora", m_Controls->portTypeAurora->currentIndex());
   }
   else // QSettings as a fallback if the persistence service is not available
   {
     QSettings settings;
     settings.beginGroup(QString::fromStdString(id));
     settings.setValue("portSpinBoxAurora", QVariant(m_Controls->m_portSpinBoxAurora->value()));
     settings.setValue("portTypeAurora", QVariant(m_Controls->portTypeAurora->currentIndex()));
     settings.endGroup();
   }
 }
 
 void QmitkNDIAuroraWidget::LoadUISettings()
 {
   std::string id = "org.mitk.modules.igt.ui.trackingdeviceconfigurationwidget";
   if (this->GetPeristenceService())
   {
     int port = 0;
     int portType = 0;
     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;
     }
 
     propList->Get("AuroraPortWin", port);
     propList->Get("PortTypeAurora", portType);
     this->SetPortTypeToGUI(portType);
     this->SetPortValueToGUI(port);
   }
   else
   {
     // QSettings as a fallback if the persistence service is not available
     QSettings settings;
     settings.beginGroup(QString::fromStdString(id));
 
     m_Controls->m_portSpinBoxAurora->setValue(settings.value("portSpinBoxAurora", 0).toInt());
     m_Controls->portTypeAurora->setCurrentIndex(settings.value("portTypeAurora", 0).toInt());
 
     settings.endGroup();
   }
 }
 
 void QmitkNDIAuroraWidget::SetPortValueToGUI(int portValue){
   m_Controls->m_portSpinBoxAurora->setValue(portValue);
 }
 void QmitkNDIAuroraWidget::SetPortTypeToGUI(int portType){
   m_Controls->portTypeAurora->setCurrentIndex(portType);
 }
 
 QmitkNDIAuroraWidget* QmitkNDIAuroraWidget::Clone(QWidget* parent) const
 {
   QmitkNDIAuroraWidget* clonedWidget = new QmitkNDIAuroraWidget(parent);
   clonedWidget->Initialize();
 
   clonedWidget->SetPortTypeToGUI(m_Controls->portTypeAurora->currentIndex());
   clonedWidget->SetPortValueToGUI(m_Controls->m_portSpinBoxAurora->value());
   return clonedWidget;
-}
\ No newline at end of file
+}
diff --git a/Modules/IGTUI/Qmitk/QmitkNDIAuroraWidget.h b/Modules/IGTUI/Qmitk/QmitkNDIAuroraWidget.h
index 5ad322f912..f3fd1bea10 100644
--- a/Modules/IGTUI/Qmitk/QmitkNDIAuroraWidget.h
+++ b/Modules/IGTUI/Qmitk/QmitkNDIAuroraWidget.h
@@ -1,65 +1,62 @@
 /*===================================================================
 
 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 QmitkNDIAuroraWidget_H
 #define QmitkNDIAuroraWidget_H
 
-#include <QWidget>
-#include "MitkIGTUIExports.h"
 #include "ui_QmitkNDIAuroraWidget.h"
 #include "QmitkNDIAbstractDeviceWidget.h"
 
-//itk headers
 
 /** Documentation:
 *   \brief Implementation of a configuration widget for NDI Aurora Devices.
 *
 *   \ingroup IGTUI
 */
 class MITKIGTUI_EXPORT QmitkNDIAuroraWidget : public QmitkNDIAbstractDeviceWidget
 {
   Q_OBJECT // this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
 
 public:
   static const std::string VIEW_ID;
 
   QmitkNDIAuroraWidget(QWidget* parent = 0, Qt::WindowFlags f = 0);
   ~QmitkNDIAuroraWidget();
 
   virtual void Initialize();
 
 private:
   /// \brief Creation of the connections
   void CreateConnections();
 
   void CreateQtPartControl(QWidget *parent);
 protected:
   virtual void ResetOutput();
   virtual void AddOutput(std::string s);
   virtual mitk::TrackingDevice::Pointer ConstructTrackingDevice();
 
   virtual void StoreUISettings();
   virtual void LoadUISettings();
 
   virtual void SetPortValueToGUI(int portValue);
   virtual void SetPortTypeToGUI(int portType);
 
   virtual QmitkNDIAuroraWidget* Clone(QWidget* parent) const;
 
   Ui::QmitkNDIAuroraWidget* m_Controls;
 };
 
 #endif
diff --git a/Modules/IGTUI/Qmitk/QmitkNDIPolarisWidget.cpp b/Modules/IGTUI/Qmitk/QmitkNDIPolarisWidget.cpp
index e60d387625..1c4d1bd060 100644
--- a/Modules/IGTUI/Qmitk/QmitkNDIPolarisWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkNDIPolarisWidget.cpp
@@ -1,200 +1,197 @@
 /*===================================================================
 
 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 "QmitkNDIPolarisWidget.h"
-#include "QmitkTrackingDeviceConfigurationWidget.h"
-
-#include <QFileDialog>
-#include <QMessageBox>
-#include <mitkNDITrackingDevice.h>
 
+#include "mitkNDITrackingDevice.h"
 #include "mitkNDIPolarisTypeInformation.h"
 
+#include <QScrollBar>
 #include <QSettings>
 
 const std::string QmitkNDIPolarisWidget::VIEW_ID = "org.mitk.views.NDIPolarisWidget";
 
 QmitkNDIPolarisWidget::QmitkNDIPolarisWidget(QWidget* parent, Qt::WindowFlags f)
   : QmitkNDIAbstractDeviceWidget(parent, f)
+  , m_Controls(nullptr)
 {
-  m_Controls = NULL;
 }
 
 void QmitkNDIPolarisWidget::Initialize()
 {
   InitializeNDIWidget();
   CreateQtPartControl(this);
   CreateConnections();
 }
 
 QmitkNDIPolarisWidget::~QmitkNDIPolarisWidget()
 {
   delete m_Controls;
 }
 
 void QmitkNDIPolarisWidget::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkNDIPolarisWidget;
     m_Controls->setupUi(parent);
   }
 }
 
 void QmitkNDIPolarisWidget::CreateConnections()
 {
   if (m_Controls)
   {
     connect((QObject*)(m_Controls->m_testConnectionPolaris), SIGNAL(clicked()), this, SLOT(TestConnection()));
     connect((QObject*)(m_Controls->m_AutoScanPolaris), SIGNAL(clicked()), this, SLOT(AutoScanPorts()));
 
     //set a few UI components depending on Windows / Linux
 #ifdef WIN32
     m_Controls->portTypeLabelPolaris->setVisible(false);
     m_Controls->portTypePolaris->setVisible(false);
 
 #else
     m_Controls->m_comPortLabelPolaris->setText("Port Nr:");
     m_Controls->m_portSpinBoxPolaris->setPrefix("");
 #endif
   }
   }
 
 void QmitkNDIPolarisWidget::ResetOutput()
 {
   m_Controls->m_outputTextPolaris->setHtml("<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>");
 }
 
 void QmitkNDIPolarisWidget::AddOutput(std::string s)
 {
   m_Controls->m_outputTextPolaris->setHtml(QString(s.c_str()));
   m_Controls->m_outputTextPolaris->verticalScrollBar()->setValue(m_Controls->m_outputTextPolaris->verticalScrollBar()->maximum());
 }
 
 mitk::TrackingDevice::Pointer QmitkNDIPolarisWidget::ConstructTrackingDevice()
 {
   mitk::NDITrackingDevice::Pointer tempTrackingDevice = mitk::NDITrackingDevice::New();
 
   //get port
   int port = 0;
   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
   tempTrackingDevice->SetIlluminationActivationRate(GetPolarisFrameRate());
 #else
   prefix = m_Controls->portTypePolaris->currentText();
   tempTrackingDevice->SetIlluminationActivationRate(GetPolarisFrameRate());
 #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
   tempTrackingDevice->SetType(mitk::NDIPolarisTypeInformation::GetTrackingDeviceName());
   return static_cast<mitk::TrackingDevice::Pointer>(tempTrackingDevice);
 }
 
 void QmitkNDIPolarisWidget::StoreUISettings()
 {
   std::string id = "org.mitk.modules.igt.ui.trackingdeviceconfigurationwidget";
   if (this->GetPeristenceService()) // now save the settings using the persistence service
   {
     mitk::PropertyList::Pointer propList = this->GetPeristenceService()->GetPropertyList(id);
     propList->Set("PolarisPortWin", m_Controls->m_portSpinBoxPolaris->value());
     propList->Set("PortTypePolaris", m_Controls->portTypePolaris->currentIndex());
     propList->Set("PolarisFrameRate", GetPolarisFrameRate());
   }
   else // QSettings as a fallback if the persistence service is not available
   {
     QSettings settings;
     settings.beginGroup(QString::fromStdString(id));
     settings.setValue("portSpinBoxPolaris", QVariant(m_Controls->m_portSpinBoxPolaris->value()));
     settings.setValue("portTypePolaris", QVariant(m_Controls->portTypePolaris->currentIndex()));
     settings.setValue("PolarisFrameRate", QVariant(GetPolarisFrameRate()));
     settings.endGroup();
   }
 }
 
 void QmitkNDIPolarisWidget::LoadUISettings()
 {
   std::string id = "org.mitk.modules.igt.ui.trackingdeviceconfigurationwidget";
   if (this->GetPeristenceService())
   {
     int port = 0;
     int portType = 0;
     int polarisFrameRate = 0;
 
     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;
     }
 
     propList->Get("PolarisPortWin", port);
     propList->Get("PortTypePolaris", portType);
     propList->Get("PolarisFrameRate", polarisFrameRate);
     this->SetPortTypeToGUI(portType);
     this->SetPortValueToGUI(port);
     m_Controls->m_frameRateComboBoxPolaris->setCurrentIndex((int)(polarisFrameRate / 30));
   }
   else
   {
     // QSettings as a fallback if the persistence service is not available
     QSettings settings;
     settings.beginGroup(QString::fromStdString(id));
 
     m_Controls->m_portSpinBoxPolaris->setValue(settings.value("portSpinBoxPolaris", 0).toInt());
     m_Controls->portTypePolaris->setCurrentIndex(settings.value("portTypePolaris", 0).toInt());
     //framerates 20,30,60 --> divided by 30 = 0,1,2 --> index of combobox
     m_Controls->m_frameRateComboBoxPolaris->setCurrentIndex((int)(settings.value("PolarisFrameRate", 0).toInt() / 30));
 
     settings.endGroup();
   }
 }
 
 mitk::IlluminationActivationRate QmitkNDIPolarisWidget::GetPolarisFrameRate()
 {
   mitk::IlluminationActivationRate frameRate;
   QString comboBox = m_Controls->m_frameRateComboBoxPolaris->currentText();
   if (comboBox == "20 Hz") frameRate = mitk::Hz20;
   else if (comboBox == "30 Hz") frameRate = mitk::Hz30;
   else if (comboBox == "60 Hz") frameRate = mitk::Hz60;
   return frameRate;
 }
 
 void QmitkNDIPolarisWidget::SetPortValueToGUI(int portValue){
   m_Controls->m_portSpinBoxPolaris->setValue(portValue);
 }
 void QmitkNDIPolarisWidget::SetPortTypeToGUI(int portType){
   m_Controls->portTypePolaris->setCurrentIndex(portType);
 }
 
 QmitkNDIPolarisWidget* QmitkNDIPolarisWidget::Clone(QWidget* parent) const
 {
   QmitkNDIPolarisWidget* clonedWidget = new QmitkNDIPolarisWidget(parent);
   clonedWidget->Initialize();
 
   clonedWidget->SetPortTypeToGUI(m_Controls->portTypePolaris->currentIndex());
   clonedWidget->SetPortValueToGUI(m_Controls->m_portSpinBoxPolaris->value());
   clonedWidget->m_Controls->m_frameRateComboBoxPolaris->setCurrentIndex(m_Controls->m_frameRateComboBoxPolaris->currentIndex());
   return clonedWidget;
-}
\ No newline at end of file
+}
diff --git a/Modules/IGTUI/Qmitk/QmitkNDIPolarisWidget.h b/Modules/IGTUI/Qmitk/QmitkNDIPolarisWidget.h
index 7add00a1be..d201e84349 100644
--- a/Modules/IGTUI/Qmitk/QmitkNDIPolarisWidget.h
+++ b/Modules/IGTUI/Qmitk/QmitkNDIPolarisWidget.h
@@ -1,74 +1,71 @@
 /*===================================================================
 
 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 QmitkNDIPolarisWidget_H
 #define QmitkNDIPolarisWidget_H
 
-#include "MitkIGTUIExports.h"
 #include "ui_QmitkNDIPolarisWidget.h"
-
 #include "QmitkNDIAbstractDeviceWidget.h"
 
-//itk headers
 
 /** Documentation:
 *   \brief Implementation of a configuration widget for NDI Polaris Devices.
 *
 *   \ingroup IGTUI
 */
 class MITKIGTUI_EXPORT QmitkNDIPolarisWidget : public QmitkNDIAbstractDeviceWidget
 {
   Q_OBJECT // this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
 
 public:
   static const std::string VIEW_ID;
 
   QmitkNDIPolarisWidget(QWidget* parent = 0, Qt::WindowFlags f = 0);
   ~QmitkNDIPolarisWidget();
 
   virtual void Initialize();
 
 signals:
 
   protected slots :
 
 private:
   /// \brief Creation of the connections
   void CreateConnections();
 
   void CreateQtPartControl(QWidget *parent);
 protected:
 
   /** @return Returns the frame rate set in the m_frameRatePolaris ComboBox
   */
   mitk::IlluminationActivationRate GetPolarisFrameRate();
 
   Ui::QmitkNDIPolarisWidget* m_Controls;
 
   virtual void SetPortValueToGUI(int portValue);
   virtual void SetPortTypeToGUI(int portType);
 
   virtual QmitkNDIPolarisWidget* Clone(QWidget* parent) const;
 
 public:
   virtual void ResetOutput();
   virtual void AddOutput(std::string s);
   virtual mitk::TrackingDevice::Pointer ConstructTrackingDevice();
 
   virtual void StoreUISettings();
   virtual void LoadUISettings();
 };
 #endif
diff --git a/Modules/IGTUI/Qmitk/QmitkNPOptitrackWidget.cpp b/Modules/IGTUI/Qmitk/QmitkNPOptitrackWidget.cpp
index 2ad5c9c61c..156ea72622 100644
--- a/Modules/IGTUI/Qmitk/QmitkNPOptitrackWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkNPOptitrackWidget.cpp
@@ -1,121 +1,120 @@
 /*===================================================================
 
 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 "QmitkNPOptitrackWidget.h"
-#include "QmitkTrackingDeviceConfigurationWidget.h"
+
+#include "mitkOptitrackTrackingDevice.h"
+#include "mitkNPOptitrackTrackingTypeInformation.h"
 
 #include <QFileDialog>
-#include <QMessageBox>
+#include <QScrollBar>
 #include <Poco/Path.h>
 
-#include <mitkOptitrackTrackingDevice.h>
-#include "mitkNPOptitrackTrackingTypeInformation.h"
-
 const std::string QmitkNPOptitrackWidget::VIEW_ID = "org.mitk.views.NPOptitrackWidget";
 
 QmitkNPOptitrackWidget::QmitkNPOptitrackWidget(QWidget* parent, Qt::WindowFlags f)
   : QmitkAbstractTrackingDeviceWidget(parent, f)
+  , m_Controls(nullptr)
 {
-  m_Controls = NULL;
 }
 
 void QmitkNPOptitrackWidget::Initialize()
 {
   InitializeSuperclassWidget();
   CreateQtPartControl(this);
   CreateConnections();
 }
 
 QmitkNPOptitrackWidget::~QmitkNPOptitrackWidget()
 {
   delete m_Controls;
 }
 
 void QmitkNPOptitrackWidget::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkNPOptitrackWidget;
     m_Controls->setupUi(parent);
   }
 }
 
 void QmitkNPOptitrackWidget::CreateConnections()
 {
   if (m_Controls)
   {
     connect((QObject*)(m_Controls->m_testConnectionOptitrack), SIGNAL(clicked()), this, SLOT(TestConnection()));
     connect((QObject*)(m_Controls->m_SetOptitrackCalibrationFile), SIGNAL(clicked()), this, SLOT(SetOptitrackCalibrationFileClicked()));
   }
 }
 
 void QmitkNPOptitrackWidget::ResetOutput()
 {
   m_Controls->m_outputTextOptitrack->setHtml("<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>");
 }
 
 void QmitkNPOptitrackWidget::AddOutput(std::string s)
 {
   m_Controls->m_outputTextOptitrack->setHtml(QString(s.c_str()));
   m_Controls->m_outputTextOptitrack->verticalScrollBar()->setValue(m_Controls->m_outputTextOptitrack->verticalScrollBar()->maximum());
 }
 
 mitk::TrackingDevice::Pointer QmitkNPOptitrackWidget::ConstructTrackingDevice()
 {
   // Create the Tracking Device
   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());
 
   tempTrackingDevice->SetType(mitk::NPOptitrackTrackingTypeInformation::GetTrackingDeviceName());
   return static_cast<mitk::TrackingDevice::Pointer>(tempTrackingDevice);
 }
 
 bool QmitkNPOptitrackWidget::IsDeviceInstalled()
 {
   return mitk::OptitrackTrackingDevice::New()->IsDeviceInstalled();
 }
 
 void QmitkNPOptitrackWidget::SetOptitrackCalibrationFileClicked()
 {
   std::string filename = QFileDialog::getOpenFileName(NULL, tr("Open Calibration File"), "/", "*.*").toLatin1().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()));
   }
 }
 
 QmitkNPOptitrackWidget* QmitkNPOptitrackWidget::Clone(QWidget* parent) const
 {
   QmitkNPOptitrackWidget* clonedWidget = new QmitkNPOptitrackWidget(parent);
   clonedWidget->Initialize();
   clonedWidget->m_OptitrackCalibrationFile = this->m_OptitrackCalibrationFile;
   clonedWidget->m_Controls->m_OptitrackCalibrationFile->setText(m_Controls->m_OptitrackCalibrationFile->text());
 
   clonedWidget->m_Controls->m_OptitrackExp->setValue(m_Controls->m_OptitrackExp->value());
   clonedWidget->m_Controls->m_OptitrackLed->setValue(m_Controls->m_OptitrackLed->value());
   clonedWidget->m_Controls->m_OptitrackThr->setValue(m_Controls->m_OptitrackThr->value());
   return clonedWidget;
-}
\ No newline at end of file
+}
diff --git a/Modules/IGTUI/Qmitk/QmitkNPOptitrackWidget.h b/Modules/IGTUI/Qmitk/QmitkNPOptitrackWidget.h
index 2ff9c4e0df..54d8c17088 100644
--- a/Modules/IGTUI/Qmitk/QmitkNPOptitrackWidget.h
+++ b/Modules/IGTUI/Qmitk/QmitkNPOptitrackWidget.h
@@ -1,72 +1,68 @@
 /*===================================================================
 
 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 QmitkNPOptitrackWidget_H
 #define QmitkNPOptitrackWidget_H
 
-#include <QWidget>
-#include "MitkIGTUIExports.h"
 #include "ui_QmitkNPOptitrackWidget.h"
-
 #include "QmitkAbstractTrackingDeviceWidget.h"
 
-//itk headers
 
 /** Documentation:
 *   \brief Implementation of a configuration widget for NP Optitrack Tracking Devices.
 *
 *   \ingroup IGTUI
 */
 class MITKIGTUI_EXPORT QmitkNPOptitrackWidget : public QmitkAbstractTrackingDeviceWidget
 {
   Q_OBJECT // this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
 
 public:
   static const std::string VIEW_ID;
 
   QmitkNPOptitrackWidget(QWidget* parent = 0, Qt::WindowFlags f = 0);
   ~QmitkNPOptitrackWidget();
 
   virtual void Initialize();
 
 signals:
 
   protected slots :
 
     /* @brief Opens a file dialog. The users sets the calibration file which location is then stored in the member m_OptitrackCalibrationFile.*/
     void SetOptitrackCalibrationFileClicked();
 
 private:
 
   /// \brief Creation of the connections
   void CreateConnections();
 
   void CreateQtPartControl(QWidget *parent);
 protected:
   virtual QmitkNPOptitrackWidget* Clone(QWidget* parent) const;
 
   std::string m_OptitrackCalibrationFile;
 
   Ui::QmitkNPOptitrackWidget* m_Controls;
 
 public:
   virtual void ResetOutput();
   virtual void AddOutput(std::string s);
   virtual mitk::TrackingDevice::Pointer ConstructTrackingDevice();
 
   virtual bool IsDeviceInstalled();
 };
 #endif
diff --git a/Modules/IGTUI/Qmitk/QmitkOpenIGTLinkWidget.cpp b/Modules/IGTUI/Qmitk/QmitkOpenIGTLinkWidget.cpp
index 65508050ea..0591f0ba80 100644
--- a/Modules/IGTUI/Qmitk/QmitkOpenIGTLinkWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkOpenIGTLinkWidget.cpp
@@ -1,72 +1,68 @@
 /*===================================================================
 
 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 "QmitkOpenIGTLinkWidget.h"
-#include "QmitkTrackingDeviceConfigurationWidget.h"
 
-#include <QFileDialog>
-#include <QMessageBox>
-
-#include <mitkOpenIGTLinkTrackingDevice.h>
+#include "mitkOpenIGTLinkTrackingDevice.h"
 
 const std::string QmitkOpenIGTLinkWidget::VIEW_ID = "org.mitk.views.OpenIGTLinkWidget";
 
 QmitkOpenIGTLinkWidget::QmitkOpenIGTLinkWidget(QWidget* parent, Qt::WindowFlags f)
   : QmitkAbstractTrackingDeviceWidget(parent, f)
+  , m_Controls(nullptr)
 {
-  m_Controls = NULL;
 }
 
 void QmitkOpenIGTLinkWidget::Initialize()
 {
   InitializeSuperclassWidget();
   CreateQtPartControl(this);
 }
 
 QmitkOpenIGTLinkWidget::~QmitkOpenIGTLinkWidget()
 {
   delete m_Controls;
 }
 
 void QmitkOpenIGTLinkWidget::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkOpenIGTLinkWidget;
     m_Controls->setupUi(parent);
   }
 }
 
 mitk::TrackingDevice::Pointer QmitkOpenIGTLinkWidget::ConstructTrackingDevice()
 {
   // Create the Virtual Tracking Device
   mitk::OpenIGTLinkTrackingDevice::Pointer OIGTLDevice = mitk::OpenIGTLinkTrackingDevice::New();
   OIGTLDevice->SetPortNumber(m_Controls->m_OpenIGTLinkPort->text().toInt());
   OIGTLDevice->SetHostname(m_Controls->m_OpenIGTLinkHostname->text().toStdString());
   return static_cast<mitk::TrackingDevice::Pointer>(OIGTLDevice);
 }
 
 QmitkOpenIGTLinkWidget* QmitkOpenIGTLinkWidget::Clone(QWidget* parent) const
 {
   QmitkOpenIGTLinkWidget* clonedWidget = new QmitkOpenIGTLinkWidget(parent);
   clonedWidget->Initialize();
 
   clonedWidget->m_Controls->m_OpenIGTLinkPort->setText(m_Controls->m_OpenIGTLinkPort->text());
   clonedWidget->m_Controls->m_OpenIGTLinkHostname->setText(m_Controls->m_OpenIGTLinkHostname->text());
 
   return clonedWidget;
-}
\ No newline at end of file
+}
diff --git a/Modules/IGTUI/Qmitk/QmitkOpenIGTLinkWidget.h b/Modules/IGTUI/Qmitk/QmitkOpenIGTLinkWidget.h
index 05ae47c9cb..a0ebfbb3e5 100644
--- a/Modules/IGTUI/Qmitk/QmitkOpenIGTLinkWidget.h
+++ b/Modules/IGTUI/Qmitk/QmitkOpenIGTLinkWidget.h
@@ -1,58 +1,54 @@
 /*===================================================================
 
 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 QmitkOpenIGTLinkWidget_H
 #define QmitkOpenIGTLinkWidget_H
 
-#include <QWidget>
-#include "MitkIGTUIExports.h"
 #include "ui_QmitkOpenIGTLinkWidget.h"
-
 #include "QmitkAbstractTrackingDeviceWidget.h"
 
-//itk headers
 
 /** Documentation:
 *   \brief Implementation of a configuration widget to use an Open IGT Link connection to track any device.
 *
 *   \ingroup IGTUI
 */
 class MITKIGTUI_EXPORT QmitkOpenIGTLinkWidget : public QmitkAbstractTrackingDeviceWidget
 {
   Q_OBJECT // this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
 
 public:
   static const std::string VIEW_ID;
 
   QmitkOpenIGTLinkWidget(QWidget* parent = 0, Qt::WindowFlags f = 0);
   ~QmitkOpenIGTLinkWidget();
 
   virtual void Initialize();
 
 signals:
 
   protected slots :
 
 private:
   void CreateQtPartControl(QWidget *parent);
 protected:
   virtual QmitkOpenIGTLinkWidget* Clone(QWidget* parent) const;
 
   Ui::QmitkOpenIGTLinkWidget* m_Controls;
 public:
   virtual mitk::TrackingDevice::Pointer ConstructTrackingDevice();
 };
 #endif
diff --git a/Modules/IGTUI/Qmitk/QmitkTrackingDeviceConfigurationWidget.cpp b/Modules/IGTUI/Qmitk/QmitkTrackingDeviceConfigurationWidget.cpp
index 57e453beb8..bdf68cf9ee 100644
--- a/Modules/IGTUI/Qmitk/QmitkTrackingDeviceConfigurationWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkTrackingDeviceConfigurationWidget.cpp
@@ -1,366 +1,347 @@
 /*===================================================================
 
 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 <mitkSerialCommunication.h>
-#include <qscrollbar.h>
-#include <qmessagebox.h>
-#include <qfiledialog.h>
-#include <mitkIGTException.h>
-#include <QSettings>
-
-#include "QmitkAbstractTrackingDeviceWidget.h"
-
-//All Tracking devices, which should be available by default
-#include "mitkNDIAuroraTypeInformation.h"
 #include "mitkNDIPolarisTypeInformation.h"
-#include "mitkVirtualTrackerTypeInformation.h"
-#include "mitkMicronTrackerTypeInformation.h"
-#include "mitkNPOptitrackTrackingTypeInformation.h"
-#include "mitkOpenIGTLinkTypeInformation.h"
-//standard tracking devices, which always should be avaiable
-#include "QmitkNDIAuroraWidget.h"
-#include "QmitkNDIPolarisWidget.h"
-#include "QmitkMicronTrackerWidget.h"
-#include "QmitkNPOptitrackWidget.h"
-#include "QmitkVirtualTrackerWidget.h"
-#include "QmitkOpenIGTLinkWidget.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
-  m_Controls = nullptr;
   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()
 {
   QmitkAbstractTrackingDeviceWidget* currentWidget = this->GetWidget(this->GetCurrentDeviceName());
 
   if (currentWidget == nullptr)
   {
     return nullptr;
   }
 
   return currentWidget->ConstructTrackingDevice();
 }
 
 mitk::TrackingDevice::Pointer QmitkTrackingDeviceConfigurationWidget::GetTrackingDevice()
 {
   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->GetPeristenceService()) // now save the settings using the persistence service
   {
     mitk::PropertyList::Pointer propList = this->GetPeristenceService()->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->GetPeristenceService())
   {
     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;
     }
 
     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/Modules/IGTUI/Qmitk/QmitkTrackingDeviceConfigurationWidget.h b/Modules/IGTUI/Qmitk/QmitkTrackingDeviceConfigurationWidget.h
index 94afdd0bc0..f024a6d923 100644
--- a/Modules/IGTUI/Qmitk/QmitkTrackingDeviceConfigurationWidget.h
+++ b/Modules/IGTUI/Qmitk/QmitkTrackingDeviceConfigurationWidget.h
@@ -1,112 +1,108 @@
 /*===================================================================
 
 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 QMITKTRACKINGDEVICECONFIGURATIONWIDGET_H
 #define QMITKTRACKINGDEVICECONFIGURATIONWIDGET_H
 
 #include <QWidget>
 #include <QThread>
 #include "MitkIGTUIExports.h"
 #include "ui_QmitkTrackingDeviceConfigurationWidgetControls.h"
-#include "mitkTrackingDevice.h"
-#include <mitkIPersistenceService.h>
 #include "mitkTrackingDeviceTypeCollection.h"
 #include "mitkTrackingDeviceWidgetCollection.h"
 
-//itk headers
-
 /** Documentation:
  *   \brief An object of this class offers an UI to configurate
  *          a tracking device. If the user finished the configuration process and
  *          a fully configurated tracking device is availiabe the object emits a
  *          signal "TrackingDeviceConfigurationFinished()". You can then get the
  *          tracking device by calling the method GetTrackingDevice().
  *
  *          Once the tracking device is configurated there are two ways to reset
  *          the UI to allow the user for configuring a new device. The method Reset()
  *          can be called and there is also a button "reset" which can be pressed by
  *          the user. In both cases a signal "TrackingDeviceConfigurationReseted()"
  *          is emitted and you may wait for a new configurated tracking device.
  *
  *
  *   \ingroup IGTUI
  */
 class MITKIGTUI_EXPORT QmitkTrackingDeviceConfigurationWidget : public QWidget
 {
   Q_OBJECT
 
 public:
   static const std::string VIEW_ID;
 
   QmitkTrackingDeviceConfigurationWidget(QWidget* parent = 0, Qt::WindowFlags f = 0);
   ~QmitkTrackingDeviceConfigurationWidget();
 
   /* @return Returns the current configurated tracking device. If the user didn't finished the
    *         configuration process or if there is an error during configuration NULL is returned.
    */
   mitk::TrackingDevice::Pointer GetTrackingDevice();
 
 signals:
 
   /* @brief This signal is sent if the tracking device was changed. */
   void TrackingDeviceSelectionChanged();
 
 protected:
 
   /// \brief Creation of the connections
   virtual void CreateConnections();
 
   virtual void CreateQtPartControl(QWidget *parent);
 
   Ui::QmitkTrackingDeviceConfigurationWidgetControls* m_Controls;
 
   mitk::TrackingDevice::Pointer m_TrackingDevice;
 
   // key is port name (e.g. "COM1", "/dev/ttyS0"), value will be filled with the type of tracking device at this port
   typedef QMap<QString, mitk::TrackingDeviceType> PortDeviceMap;
 
   //######################### internal help methods #######################################
   void ResetOutput();
   void AddOutput(std::string s);
   mitk::TrackingDevice::Pointer ConstructTrackingDevice();
 
   void StoreUISettings();
   void LoadUISettings();
 
   /* @brief This method is called when the user clicks on "Refresh Selection" (m_RefreshTrackingDeviceCollection).
   It then sets the correct widget for the selected tracking device.*/
   void RefreshTrackingDeviceCollection();
 
   protected slots:
   /* @brief This method is called when the user changes the selection of the trackingdevice (m_trackingDeviceChooser).
             It then sets the correct widget for the selected tracking device.*/
   void TrackingDeviceChanged();
 
 private:
   PERSISTENCE_GET_SERVICE_METHOD_MACRO
 
   std::string GetCurrentDeviceName(void) const;
 
   QmitkAbstractTrackingDeviceWidget* GetWidget(const std::string& deviceName) const;
 
   /**
    * @brief Mapping of device type identifier and index of the configuration widget in QStackedWidget.
    */
   std::map<std::string, int> m_DeviceToWidgetIndexMap;
 
 };
 
 #endif
diff --git a/Modules/IGTUI/Qmitk/QmitkVirtualTrackerWidget.cpp b/Modules/IGTUI/Qmitk/QmitkVirtualTrackerWidget.cpp
index a42d615a7f..4b4a3db625 100644
--- a/Modules/IGTUI/Qmitk/QmitkVirtualTrackerWidget.cpp
+++ b/Modules/IGTUI/Qmitk/QmitkVirtualTrackerWidget.cpp
@@ -1,98 +1,94 @@
 /*===================================================================
 
 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 "QmitkVirtualTrackerWidget.h"
-#include "QmitkTrackingDeviceConfigurationWidget.h"
 
-#include <mitkVirtualTrackingDevice.h>
-
-#include <QFileDialog>
-#include <QMessageBox>
+#include "mitkVirtualTrackingDevice.h"
 
 const std::string QmitkVirtualTrackerWidget::VIEW_ID = "org.mitk.views.VirtualTrackerWidget";
 
 QmitkVirtualTrackerWidget::QmitkVirtualTrackerWidget(QWidget* parent, Qt::WindowFlags f)
   : QmitkAbstractTrackingDeviceWidget(parent, f)
+  , m_Controls(nullptr)
 {
-  m_Controls = NULL;
 }
 
 void QmitkVirtualTrackerWidget::Initialize()
 {
   InitializeSuperclassWidget();
   CreateQtPartControl(this);
   CreateConnections();
 }
 
 QmitkVirtualTrackerWidget::~QmitkVirtualTrackerWidget()
 {
   delete m_Controls;
 }
 
 void QmitkVirtualTrackerWidget::CreateQtPartControl(QWidget *parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkVirtualTrackerWidget;
     m_Controls->setupUi(parent);
   }
 }
 
 void QmitkVirtualTrackerWidget::CreateConnections()
 {
   if (m_Controls)
   {
     connect((QObject*)(m_Controls->m_EnableGaussianNoise), SIGNAL(clicked()), this, SLOT(EnableGaussianNoise()));
   }
 }
 
 mitk::TrackingDevice::Pointer QmitkVirtualTrackerWidget::ConstructTrackingDevice()
 {
   // Create the Virtual Tracking Device
   mitk::VirtualTrackingDevice::Pointer returnValue = mitk::VirtualTrackingDevice::New();
   if (m_Controls->m_EnableGaussianNoise->isChecked())
   {
     returnValue->EnableGaussianNoise();
     returnValue->SetParamsForGaussianNoise(m_Controls->m_MeanDistributionParam->value(), m_Controls->m_DeviationDistributionParam->value());
   }
   return static_cast<mitk::TrackingDevice::Pointer>(returnValue); //static_cast necessary for compiling with Linux
 }
 
 void QmitkVirtualTrackerWidget::EnableGaussianNoise()
 {
   if (m_Controls->m_EnableGaussianNoise->isChecked())
   {
     m_Controls->m_MeanDistributionParam->setEnabled(true);
     m_Controls->m_DeviationDistributionParam->setEnabled(true);
   }
   else
   {
     m_Controls->m_MeanDistributionParam->setEnabled(false);
     m_Controls->m_DeviationDistributionParam->setEnabled(false);
   }
 }
 
 QmitkVirtualTrackerWidget* QmitkVirtualTrackerWidget::Clone(QWidget* parent) const
 {
   QmitkVirtualTrackerWidget* clonedWidget = new QmitkVirtualTrackerWidget(parent);
   clonedWidget->Initialize();
 
   clonedWidget->m_Controls->m_EnableGaussianNoise->setEnabled(m_Controls->m_EnableGaussianNoise->isEnabled());
   clonedWidget->m_Controls->m_MeanDistributionParam->setValue(m_Controls->m_MeanDistributionParam->value());
   clonedWidget->m_Controls->m_DeviationDistributionParam->setValue(m_Controls->m_DeviationDistributionParam->value());
   return clonedWidget;
-}
\ No newline at end of file
+}
diff --git a/Modules/IGTUI/Qmitk/QmitkVirtualTrackerWidget.h b/Modules/IGTUI/Qmitk/QmitkVirtualTrackerWidget.h
index 38aa691cc5..a713d917dc 100644
--- a/Modules/IGTUI/Qmitk/QmitkVirtualTrackerWidget.h
+++ b/Modules/IGTUI/Qmitk/QmitkVirtualTrackerWidget.h
@@ -1,65 +1,61 @@
 /*===================================================================
 
 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 QmitkVirtualTrackerWidget_H
 #define QmitkVirtualTrackerWidget_H
 
-#include <QWidget>
-#include "MitkIGTUIExports.h"
 #include "ui_QmitkVirtualTrackerWidget.h"
-
 #include "QmitkAbstractTrackingDeviceWidget.h"
 
-//itk headers
 
 /** Documentation:
 *   \brief Implementation of a configuration widget for a Vitrual Tracking Device.
 *
 *   \ingroup IGTUI
 */
 class MITKIGTUI_EXPORT QmitkVirtualTrackerWidget : public QmitkAbstractTrackingDeviceWidget
 {
   Q_OBJECT // this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
 
 public:
   static const std::string VIEW_ID;
 
   QmitkVirtualTrackerWidget(QWidget* parent = 0, Qt::WindowFlags f = 0);
   ~QmitkVirtualTrackerWidget();
 
   virtual void Initialize();
 
 signals:
 
   protected slots :
     /* @brief Enables or disables the Gaussian Noise for the VirtualTrackingDevice dependent on the State of the according Checkbox */
     void EnableGaussianNoise();
 
 private:
 
   /// \brief Creation of the connections
   void CreateConnections();
 
   void CreateQtPartControl(QWidget *parent);
 protected:
   virtual QmitkVirtualTrackerWidget* Clone(QWidget* parent) const;
 
   Ui::QmitkVirtualTrackerWidget* m_Controls;
 
 public:
   virtual mitk::TrackingDevice::Pointer ConstructTrackingDevice();
 };
 #endif
diff --git a/Modules/IGTUI/Qmitk/mitkTrackingDeviceWidgetCollection.cpp b/Modules/IGTUI/Qmitk/mitkTrackingDeviceWidgetCollection.cpp
index a086879837..596d40caf2 100644
--- a/Modules/IGTUI/Qmitk/mitkTrackingDeviceWidgetCollection.cpp
+++ b/Modules/IGTUI/Qmitk/mitkTrackingDeviceWidgetCollection.cpp
@@ -1,79 +1,80 @@
 /*===================================================================
 
 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 "mitkTrackingDeviceWidgetCollection.h"
-#include "mitkUIDGenerator.h"
 
 //Microservices
 #include <usGetModuleContext.h>
-#include <usModule.h>
-#include <usServiceProperties.h>
 #include <usModuleContext.h>
 
 mitk::TrackingDeviceWidgetCollection::TrackingDeviceWidgetCollection()
-  : m_TrackingDeviceWidgets()
+  : m_ServiceRegistration()
+  , m_TrackingDeviceWidgets()
 {
 }
 
 mitk::TrackingDeviceWidgetCollection::~TrackingDeviceWidgetCollection()
 {
+  for (auto& item : m_TrackingDeviceWidgets)
+  {
+    delete item.second;
+  }
 }
 
 void mitk::TrackingDeviceWidgetCollection::RegisterAsMicroservice()
 {
-  // Get Context
   us::ModuleContext* context = us::GetModuleContext();
 
   m_ServiceRegistration = context->RegisterService(this);
 }
 
 void mitk::TrackingDeviceWidgetCollection::UnRegisterMicroservice()
 {
-  if (m_ServiceRegistration != NULL) m_ServiceRegistration.Unregister();
+  if (m_ServiceRegistration != nullptr) m_ServiceRegistration.Unregister();
   m_ServiceRegistration = 0;
 }
 
 void mitk::TrackingDeviceWidgetCollection::RegisterTrackingDeviceWidget(TrackingDeviceType type, QmitkAbstractTrackingDeviceWidget* widget)
 {
   if (widget != nullptr)
   {
     //Don't add widget, if it is already included
-    for (int i = 0; i < m_TrackingDeviceWidgets.size(); i++)
+    for (unsigned int i = 0; i < m_TrackingDeviceWidgets.size(); i++)
     {
       if (m_TrackingDeviceWidgets.at(i).first == type)
         return;
     }
     m_TrackingDeviceWidgets.push_back(std::make_pair(type, widget));
   }
 }
 
 QmitkAbstractTrackingDeviceWidget* mitk::TrackingDeviceWidgetCollection::GetTrackingDeviceWidgetClone(TrackingDeviceType type)
 {
-  for (int i = 0; i < m_TrackingDeviceWidgets.size(); i++)
+  for (unsigned int i = 0; i < m_TrackingDeviceWidgets.size(); i++)
   {
     if (m_TrackingDeviceWidgets.at(i).first == type)
     {
       if (!(m_TrackingDeviceWidgets.at(i).second->IsInitialized()))
       {
         m_TrackingDeviceWidgets.at(i).second->Initialize();
         if (!(m_TrackingDeviceWidgets.at(i).second->IsInitialized())) //still not initialized?
           MITK_ERROR << "Something went wrong with initialization of your tracking device widget!";
       }
       return (m_TrackingDeviceWidgets.at(i).second->CloneForQt());
     }
   }
   return nullptr;
-}
\ No newline at end of file
+}
diff --git a/Modules/IGTUI/Qmitk/mitkTrackingDeviceWidgetCollection.h b/Modules/IGTUI/Qmitk/mitkTrackingDeviceWidgetCollection.h
index 8159eb7114..2a30e7f1c3 100644
--- a/Modules/IGTUI/Qmitk/mitkTrackingDeviceWidgetCollection.h
+++ b/Modules/IGTUI/Qmitk/mitkTrackingDeviceWidgetCollection.h
@@ -1,71 +1,68 @@
 /*===================================================================
 
 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 TRACKINGDEVICEWidgetCollection_H_INCLUDED
-#define TRACKINGDEVICEWidgetCollection_H_INCLUDED
+#ifndef TrackingDeviceWidgetCollection_H_INCLUDED
+#define TrackingDeviceWidgetCollection_H_INCLUDED
 
 #include <MitkIGTUIExports.h>
 
-#include "mitkTrackingTypes.h"
 #include "mitkTrackingDeviceTypeInformation.h"
+#include "QmitkAbstractTrackingDeviceWidget.h"
 
 // Microservices
 #include <mitkServiceInterface.h>
 #include <usServiceRegistration.h>
 
-#include "QmitkAbstractTrackingDeviceWidget.h"
 
 namespace mitk {
   /** Documentation:
   *   \brief This class is a collection for all TrackingDeviceWidgets (derived from AbstractTrackingDeviceWidget)
   *   The Collection is avaiable via Microservice.
   *   If you want to add your own tracking device to the Tracking Toolbox, you should register your widget configuring your device
   *   to this collection using the RegisterTrackingDeviceWidget function.
   *   \ingroup IGTUI
   */
   class MITKIGTUI_EXPORT TrackingDeviceWidgetCollection
   {
   public:
 
     TrackingDeviceWidgetCollection();
     ~TrackingDeviceWidgetCollection();
 
     /**
     *\brief Registers this object as a Microservice, making it available to every module and/or plugin.
     * To unregister, call UnregisterMicroservice().
     */
     virtual void RegisterAsMicroservice();
 
     /**
     *\brief Registers this object as a Microservice, making it available to every module and/or plugin.
     */
     virtual void UnRegisterMicroservice();
 
     void RegisterTrackingDeviceWidget(TrackingDeviceType type, QmitkAbstractTrackingDeviceWidget* widget);
 
     QmitkAbstractTrackingDeviceWidget* GetTrackingDeviceWidgetClone(TrackingDeviceType type);
 
   private:
 
-    std::string m_Name;
-
     us::ServiceRegistration<TrackingDeviceWidgetCollection> m_ServiceRegistration;
 
-    std::vector<std::pair <TrackingDeviceType, QmitkAbstractTrackingDeviceWidget*>> m_TrackingDeviceWidgets;
+    std::vector<std::pair<TrackingDeviceType, QmitkAbstractTrackingDeviceWidget*> > m_TrackingDeviceWidgets;
   };
 } // namespace mitk
 MITK_DECLARE_SERVICE_INTERFACE(mitk::TrackingDeviceWidgetCollection, "org.mitk.services.TrackingDeviceWidgetCollection")
-#endif //TRACKINGDEVICEWidgetCollection_H_INCLUDED
+#endif //TrackingDeviceWidgetCollection_H_INCLUDED